#C8.txt, Feb. 18, 2013, thinkless games (with at most one option)
#With two procedures (RollLoadedDie, and RandGame1) that we didn't
#have time to do in class (because I messed up)
#(note that NuGame1(n) has been shortened)

Help:=proc(): print(` Games1(n), P1(n,x), NuGames1(n), RandGame1(n) `): end:

#Games1(n): the set of games of size n where always
#always there is at most one option:
Games1:=proc(n) local Ga,m, S1,s1, S2, s2:
#every game is [L,R] let Size(L)=m
option remember:
if n=0 then
  RETURN({}):
fi:

if n=1 then
 RETURN({[{},{}]}):
fi:

S1:=Games1(n-1):

Ga:={seq([{}, {s1}], s1 in S1), seq([{s1},{}], s1 in S1)}:


for m from 1 to n-2 do
 S1:=Games1(m):
 S2:=Games1(n-1-m):

 Ga:=Ga union { seq(seq( [ {s1}, {s2}], s1 in S1), s2 in S2)}:
od:
Ga:
 

end:

#The number of positive, negative, zero and fuzzy
#thinkless games of size n
P1:=proc(n,x) local S,s:

S:=Games1(n):

add( x[WhatKind(s)], s in S):
end:

#NuGames1(n): the number of games of size n where always
#there is at most one option:
NuGames1:=proc(n) local m:
#every game is [L,R] let Size(L)=m
option remember:
if n=0 then
  RETURN(1):
fi:

add(NuGames1(m)*NuGames1(n-1-m),m=0..n-1):

end:

#RollLD(L): Given a Loaded die, L, rolls it, try:
#RollLD([1,3,2]);
RollLD:=proc(L) local i,r,N:
N:=convert(L,`+`):
r:=rand(1..N)():

for i from 1 to nops(L) while convert([op(1..i,L)],`+`)<r do od:
i:

end:

#RandGame1(n): a uniformaly-at-random thinkless game of size n
RandGame1:=proc(n) local L,m:

if n=1 then
 RETURN([{},{}]):
fi:

L:=[seq(NuGames1(m)*NuGames1(n-1-m),m=0..n-1)]:

m:=RollLD(L)-1:

if m=0 then
 RETURN([{},{RandGame1(n-1)}]):
elif m=n-1 then
 RETURN([{RandGame1(n-1)},{}]):
else
 RETURN([{RandGame1(m)},{RandGame1(n-1-m)}]):
fi:

end:

###Old Stuff from C6.txt
#GamesD1(k): all the games created in day<=k
GamesD1:=proc(k) local L,R,S:
option remember:

if k=0 then
 RETURN({[{},{}] }):
fi:

S:=powerset(GamesD1(k-1)):

{ seq(seq( [ L, R], L in S), R in S) }:

end:


GamesD:=proc(k): GamesD1(k) minus GamesD1(k-1): end:

#RandGame(k,m): a random game created in day <=k
#where L and R are always of size <=m
RandGame:=proc(k,m) local L,R,m1,m2,k1,i:

if k=0 then
 RETURN([{},{}]):
fi:

m1:=rand(0..m)():

m2:=rand(0..m)():

L:={}:

for i from 1 to m1 do
 k1:=rand(0..k-1)(): 
 L:=L union {RandGame(k1,m)}:
od:

R:={}:

for i from 1 to m2 do
 k1:=rand(0..k-1)(): 
 R:=R union {RandGame(k1,m)}:
od:
[L,R]:
end:

#Age(G):the age of G=[{L},{R}]
Age:=proc(G) local L,R:

if G=[{},{}] then
  RETURN(0):
fi:

max(seq(Age(L), L in G[1]), 
seq(Age(R), R in G[2]))+1:

end:

#CanLeftWin(G): Can Left win the game G?
CanLeftWin:=proc(G) local L:
option remember:

#if true in {seq(not CanRightWin(L), L in G[1])} then
 #RETURN(true):
#fi:
#false:
evalb(true in {seq(not CanRightWin(L), L in G[1])}):
end:

#CanRightWin(G): Can Left win the game G?
CanRightWin:=proc(G) local R:
option remember:

#if true in {seq(not CanLeftWin(R), R in G[2])} then
# RETURN(true):
#fi:
#false:

evalb(true in {seq(not CanLeftWin(R), R in G[2])}):
end:

#WhatKind(G): Is the game 
#
WhatKind:=proc(G) local a,b:

a:=CanLeftWin(G):
b:=CanRightWin(G):

if a and b then 
"Fuzzy":
elif a and not b  then
"Positive":
elif not a and b then
 "Negative":
else
 "Zero" :
fi:

end:
##end stuff from C6.txt