Analogs between QM and games

The notion of winning [“game over”]

Putting in foliations

Final winning

Measurements in QM

Moves in the game

Roughly to time steps in cosmological rest frame
[Turn-based vs real-time games]
Diplomacy Game : simultaneous moves (resolve branch pairs)
“Players write down moves” (e.g. in chess variants [e.g blind chess])
< Rules for resolving conflict or skip turn if there is a conflict >

“Miss a turn” is the analog of a foliation that isn’t flat [though this is state dependent]

How to determine a win: scoring / instant winning

Evaluating an intermediate position

E.g. territory in Go
Assign a number to a position
E.g. Tic tac toe / 5-in-a-row: [ a number for each player for each configuration ]

What positions are nearby?

Scoring by lookahead

[ Branch cones / entanglement cones ]

Forward entanglement cone: game states you can reach from your state

[ Event horizon ]

Breaks state space up into states you can never reach

[ Superposition ]

E.g. blind chess
Poker, bridge
Stratego [know where pieces are, but not values]
Mau / Mao : rulial multiway system [rulial superposition ]

Odds in game are the path weights in multiway graph

Build up conditional probabilities by knowing what region of the multiway graph you’re in

[ Completions ]

Equivalence relation between states
(You don’t care about the difference between one configuration and another)
​
In Tic Tac Toe / Checkers : symmetry of board

[ Analog of uncertainty principle ]

Tic Tac Toe

Nik’s version: (with alternation built in)
In[]:=
TicTacFunction[k_Integer]:=Function[list,With[{a=First[Mod[Commonest[DeleteCases[Flatten@list,0]],k]+1,1]},ReplacePart[list,#a]&/@Position[list,0]]]
In[]:=
CheckWin[list_]:=Catch[Module[{n=First[Dimensions[list]],u},Do[u=Part[list,i,All];If[!AllTrue[u,#0&]&&SameQ@@u,Throw[First[u]]],{i,n}];Do[u=Part[list,All,i];If[!AllTrue[u,#0&]&&SameQ@@u,Throw[First[u]]],{i,n}];​​u=Table[list[[i,i]],{i,n}];If[!AllTrue[u,#0&]&&SameQ@@u,Throw[First[u]]];u=Table[list[[-i,i]],{i,n}];If[!AllTrue[u,#0&]&&SameQ@@u,Throw[First[u]]];False]]
In[]:=
Clear[CheckWin]
Nik’s version:
In[]:=
CheckWin[board_]:=With[{dims=Dimensions@board},First[Keys@Select[KeySelect[Merge[Map[Counts,Join[board,Transpose@board,{Diagonal@board,ResourceFunction["Antidiagonal"]@board}]],AnyTrue[EqualTo[First@dims]]],GreaterThan[0]],Identity],False]/;Length[dims]===2&&SameQ@@dims]
In[]:=
PlotBoard[list_String,sz_:40]:=PlotBoard[ToExpression[list],sz]
In[]:=
PlotBoard[list:{{_Integer..}..},sz_:40]:=ArrayPlot[list,ImageSizesz,ColorRules{0White,1Orange,2Purple},MeshTrue]
In[]:=
PlotBoard[i_Integer,sz_:40]:=Framed[Framed[PlotBoard[{{i}},sz]]]
In[]:=
TicTacWinAssociation[k_:2]:=<|"StateEvolutionFunction"(If[IntegerQ[#],{#},With[{w=CheckWin[#]},If[w=!=False,{w},TicTacFunction[k][#]]]]&),"StateEquivalenceFunction"SameQ,"StateEventFunction"Identity,"EventDecompositionFunction"Identity,"EventApplicationFunction"Identity,"SystemType""None","EventSelectionFunction"Identity|>;
In[]:=
TicTacWinBeforeAssociation[k_:2]:=<|"StateEvolutionFunction"(If[IntegerQ[#],{#},With[{w=CheckWin[#]},If[w=!=False,{w},With[{c=CheckWin[#]},If[c=!=False,c,#]]&/@TicTacFunction[k][#]]]]&),"StateEquivalenceFunction"SameQ,"StateEventFunction"Identity,"EventDecompositionFunction"Identity,"EventApplicationFunction"Identity,"SystemType""None","EventSelectionFunction"Identity|>;
In[]:=
TicTacAssociation[k_:2]:=<|"StateEvolutionFunction"TicTacFunction[k],"StateEquivalenceFunction"SameQ,"StateEventFunction"Identity,"EventDecompositionFunction"Identity,"EventApplicationFunction"Identity,"SystemType""None","EventSelectionFunction"Identity|>;
In[]:=
ResourceFunction["MultiwaySystem"][TicTacAssociation[2],{Table[0,2,2]},1,"StatesGraph","StateRenderingFunction"(Inset[PlotBoard[#2,30],#1]&),GraphLayout"SpringElectricalEmbedding"]
Out[]=
In[]:=
ResourceFunction["MultiwaySystem"][TicTacAssociation[2],{Table[0,2,2]},2,"StatesGraph","StateRenderingFunction"(Inset[PlotBoard[#2,30],#1]&),GraphLayout"SpringElectricalEmbedding"]
Out[]=
In[]:=
ResourceFunction["MultiwaySystem"][TicTacAssociation[2],{Table[0,2,2]},3,"StatesGraph","StateRenderingFunction"(Inset[PlotBoard[#2,20],#1]&),GraphLayout"SpringElectricalEmbedding"]
Out[]=
In[]:=
ResourceFunction["MultiwaySystem"][TicTacAssociation[2],{Table[0,2,2]},4,"StatesGraph","StateRenderingFunction"(Inset[PlotBoard[#2,20],#1]&),GraphLayout"SpringElectricalEmbedding"]
Out[]=
[[[ The following is wrong : includes post-win configurations ]]]

1 player

Games are won after between 3 and 7 steps
​
In Japanese rules, only the empty spaces count (plus prisoners and the spaces they occupy). In Chinese rules, all your live stones on the board ALSO count as a point for you.
Slight rule change in minigo causes different outcomes.

Dimensions

1D case

[[ Probably similar to Turing machine structure ]]
E.g. define a win for 3 in a row.....

Completion

Original rules:
To freeze time to define a win, we want a completion that maps all states to that frozen time state. Win = spacelike singularity.
What are the threat coordinates here?

String Analog

There are no causal connections, because no writing in any cell can ever affect writing in the same cell, except by excluding it....

[[ Cf. deadlock: causal impossibility graph ]]

All separations are spacelike; i.e. there are only a finite number of places to have something happen

Threat score