#C24.txt: April 18, 2022
Help24:=proc(): print(`GenSn(G), WikiCent(n), LaC(G,R), WikiCent1(n)  `):
print(`LabelP(L), Sparta(), Sandy() `):
end:

#Added April 21, 2022 (before class)
Sandy:=proc():[{2,3},{3},{}],[Sandy,Dicky,Lucy]:end:


#Added April 21, 2022 (before class)
#Sparta(): The family "tree" of Anaxendridas, King of Sparta
Sparta:=proc():
[{2,3},{5},{4},{5},{}],[Anaxandridas,Leonidas,Cleomenes,Gorgo,Pleistarchus]:
end:


#LabelP(L): inputs a list of pairs [[a_i,b_i]], outputs [b_j,a_j] where b_j is
#is the largest b_i
LabelP:=proc(L) local i:
i:=max[index]([seq(L[i][2],i=1..nops(L))]):
[L[i][2],L[i][1]]:
end:

#LaC(G,R): Inputs a directed graph G, and R, a set of pairs [sink, [a,b]]
#outputs the list of labels of all the vertices
LaC:=proc(G,R) local n,L,T,i,j,s,r,k:
n:=nops(G):

L:=GenS(G):
 if {seq(r[1],r in R)}<>L[1] then
  RETURN(FAIL):
 fi:
for r in R do
  T[r[1]]:=r[2]:
od:

for j from 2 to nops(L) do
  for i in L[j] do
    T[i]:=LabelP([seq(T[k], k in G[i])]):
  od:
od:
[seq(T[i],i=1..n)]:
end:



#WikiCent(n): The centipede game 2*n non-leaf vertices and 2*n+1 leaves wich that 1 goes 2 and 2*n+2,
#2 goes to 3 and 2*n+3, ..., 2*n goes to 2*n+1 and 4*n+1, and the reward pairs for
#vertex 2*n+1 is [2*n-1+0.1,2*n-1+0.1], the reward pair of vertex 2*n+2 is [0,1], and the reward
#pair for vertex [2*n+3+i] (i=0..2*n-2) is [i,i+2]
WikiCent:=proc(n) local i,G,P:
G:=[seq({i+1,i+2*n+1},i=1..2*n),seq({},i=1..2*n+1)]:
P:={[2*n+1,[2*n-1+ 0.1,2*n-1+0.1]],[2*n+2,[0,1]],seq([2*n+3+i,[i,i+2]],i=0..2*n-2)}:
G,P:
end:


#WikiCent1(n): Same as WikiCent(n) but with ONE edge removed
WikiCent1:=proc(n) local i,G,P:
G:=[seq({i+1,i+2*n+1},i=1..2*n-1),{2*n+1},seq({},i=1..2*n+1)]:
P:={[2*n+1,[2*n-1+ 0.1,2*n-1+0.1]],[2*n+2,[0,1]],seq([2*n+3+i,[i,i+2]],i=0..2*n-2)}:
G,P:
end:




#GenSn(G): Inputs a directed graph (w/o cycles) and outputs a list of "generations"
#L[1] : the set of vertices that are sinks (no childre), and L[i] the set of vertices
#all whose children are in L[1] union L[i-1]
GenSn:=proc(G) local n,T,i,j,NYD,AD,j1,ma,AP:
#New version checking for bad input

AP:={seq(op(G[i]),i=1..nops(G))}:

ma:=max(AP):
if ma>nops(G) then
 RETURN(FAIL):
fi:


n:=nops(G):
NYD:={seq(i,i=1..n)}:
T[1]:={}:
 for i from 1 to n do
  if G[i]={} then
    T[1]:=T[1] union {i}:
  fi:
 od:
NYD:=NYD minus T[1]:
AD:=T[1]:
for j from 2 while NYD<>{} do
 T[j]:={}:
  for i in NYD do
   if G[i] minus AD={} then
     T[j]:=T[j] union {i}:
   fi:
  od:
AD:=AD union T[j]:
NYD:=NYD minus T[j]:
od:
[seq(T[j1],j1=1..j-1)]:
end:




####
Help23:=proc(): print(` GenS(G), Els() `): end:

#GenS(G): Inputs a directed graph (w/o cycles) and outputs a list of "generations"
#L[1] : the set of vertices that are sinks (no childre), and L[i] the set of vertices
#all whose children are in L[1] union L[i-1]
GenS:=proc(G) local n,T,i,j,NYD,AD,j1:
n:=nops(G):
NYD:={seq(i,i=1..n)}:
T[1]:={}:
 for i from 1 to n do
  if G[i]={} then
    T[1]:=T[1] union {i}:
  fi:
 od:
NYD:=NYD minus T[1]:
AD:=T[1]:
for j from 2 while NYD<>{} do
 T[j]:={}:
  for i in NYD do
   if G[i] minus AD={} then
     T[j]:=T[j] union {i}:
   fi:
  od:
AD:=AD union T[j]:
NYD:=NYD minus T[j]:
od:
[seq(T[j1],j1=1..j-1)]:
end:




#DZ:=[{3,4,5},{3,4,5},{6},{},{},{}];

#GenS(DZ);
#                    [{4, 5, 6}, {3}, {1, 2}]

#LaGn(G): Same as LaG(G) from C22.txt, but hopefully better (at least more adaptable for the Centipede games)
LaGn:=proc(G) local n,L,T,i,j,s:
n:=nops(G):
L:=GenS(G):
for i in L[1] do
 T[i]:=0:
od:

for j from 2 to nops(L) do
  for i in L[j] do
     if member(0,{seq(T[s], s in G[i])}) then
      T[i]:=1:
      else
       T[i]:=0:
      fi:
 od:
od:
[seq(T[i],i=1..n)]:
end:




#The Elster graph
Els:=proc():
[{2, 6}, {3, 7}, {4, 8}, {5, 9}, {}, {}, {}, {}, {}], {[5, [3, 4]], [6, [-1, 2]
], [7, [1, 2]], [8, [1, 4]], [9, [6, 3]]}:
end:


Els1:=proc():
[{2, 6}, {3, 7}, {4, 8}, {9}, {}, {}, {}, {}, {}], {[5, [3, 4]], [6, [-1, 2]
], [7, [1, 2]], [8, [1, 4]], [9, [6, 3]]}:
end:


###STUFF FROM C22.txt

#C22.txt: April 11, 2022
Help22:=proc(): print(`mex(S), ai(i), aiC(i), RDG(n,p), Parents(G), OneStep0(G,AL,T)  , OneStep1(G,AL,T), OneStep(G,AL,T), LaG(G)    `):
end:

#mex(S): inputs a set of NON-NEGATIVE integers and outputs the smallest
#non-neg. intger NOT in the set S, i.e. min({0,1,2,3,...} minus S)
mex:=proc(S) local i:
for i from 0 while member(i,S) do od:
i:
end:

#ai(i): the a-component in the losing position for Wythoff's game [a_i,i+a_i]
ai:=proc(i) local j:
option remember:
 if i=0 then
   RETURN(0):
else
mex({seq(ai(j),j=0..i-1),seq(ai(j)+j,j=0..i-1)}):
fi:
end:

#aiC(i) : Faster way to compute ai(i) using Wythof's formula trunc(phi*i):
aiC:=proc(i)
trunc((1+sqrt(5))/2*i):
end:

#RDG(n,p): inputs a pos. integer n and a RATIONAL number p=a/b between 0 and 1
#and outputs a random directed graph w/o cycles such tha the prob. of
#an edge is p
RDG:=proc(n,p) local a,b,L,i,j,S,ra:
a:=numer(p):
b:=denom(p):

ra:=rand(1..b):

L:=[]:

for i from 1 to n do
 S:={}:
  for j from i+1 to n do
    if ra()<=a then
     S:=S union {j}:
    fi:
  od:
L:=[op(L),S]:
od:

L:
end:

#Parents(G): inputs a directed graph on {1,...,n} where n:=nops(G) such that G[i] is  the set of children of i (the set of outgoing neihbors)
#outputs the list whose i-th component is the set of "parents" of i, i.e. those j such that i belongs to G[j]. For example
#Parents([{2,3},{3},{}]); should be [{},{1},{1,2}]
Parents:=proc(G) local n,i,j,P:
option remember:
n:=nops(G):

#We initialize all the parents-sets to be empty
for j from 1 to n do
P[j]:={}:
od:

for i from 1 to n do
 for j in G[i] do
  P[j]:=P[j] union {i}:
 od:
od:

#For each vertex i (we look for its children) and append i to the set of parents of each such child

[seq(P[j],j=1..n)]:

end:



#OneStep0(G,AL,T): Given a graph G, with a set of already labelled vertices AL and a table T of lables
#performs one step in the labelling algorithm, the implication that if a vertex is labeled 0 then all its parents are labeled 1
#(since there exists is a legal move that will make the opponent lose)
OneStep0:=proc(G,AL,T) local AL1,n,T1,i,j,P:
AL1:=AL:
n:=nops(G):
P:=Parents(G):
T1:=T:
for i in AL do
 if T1[i]=0 then
  for j in P[i] do
  T1:=[op(1..j-1,T1),1,op(j+1..n,T1)]:
    AL1:=AL1 union {j}:
  od:
 fi:
od:

RETURN(G,AL1,T1):
end:


#OneStep1(G,AL,T): Given a graph G, with a set of already labelled vertices AL and a table T of lables
#performs one step in the labelling algorithm, that if all the children of a vertex are already labeld 1 then
#it is labeled 0 (since whatever the player can do it would be winning for the opponent)
OneStep1:=proc(G,AL,T) local n,T1,i,j:

n:=nops(G):
T1:=T:

 for i from 1 to n do
 if not member(i,AL) then
   if G[i] minus AL={} and {seq(T1[j],j in G[i])}={1} then
  T1:=[op(1..i-1,T1),0,op(i+1..n,T1)]:
     RETURN(G,AL union {i},T1):
   fi:
  fi:
 od:
G,AL,T1:
end:

#OneStep(G,AL,T): Given a graph G, with a set of already labelled vertices AL and a table T of lables
#performs one step in the labelling algorithm, that if all the children of a vertex are already labeld 1 then
#it is labeled 0 (since whatever the player can do it would be winning for the opponent)

OneStep:=proc(G,AL,T) local n,Hope:
n:=nops(G):
if nops(AL)=n then
 RETURN(G,AL,op(T)):
fi:

Hope:=OneStep0(G,AL,T):
if nops(Hope[2])>nops(AL) then
  RETURN(Hope):
fi:


Hope:=OneStep1(G,AL,T):
if nops(Hope[2])>nops(AL) then
  RETURN(Hope):
fi:

FAIL:

end:


#LaG(G)
LaG:=proc(G) local n,i,AL,T,Hope:
n:=nops(G):

T:=[(-1)$n]:

AL:={}:

for i from 1 to n do
 if G[i]={}  then
 T:=[op(1..i-1,T),0,op(i+1..n,T)]:
  AL:=AL union {i}:
 fi:
od:

Hope:=G,AL,T:
while nops(Hope[2])<n do
Hope:=OneStep(Hope):
od:

[seq(Hope[3][i],i=1..n)]:
end: