def _game(self):
nbAttempts = 0
maxNbAttempts = 10
hasWon = False
self._nbGames += 1
print("Game n°" + str(self._nbGames))
while not DarkLogic.isOver():
print("Attempt n°" + str(nbAttempts + 1) + "/" +
str(maxNbAttempts))
action = self._player.play()
LogicGame._actionSwitcher[action.fun()](self, action)
print(
"____________________________________________________________________________"
)
if action.fun() == EnumFun.PUSH_ACTION:
nbAttempts += 1
if nbAttempts == maxNbAttempts:
break
if DarkLogic.hasAlreadyPlayed():
if DarkLogic.isDemonstrated():
print(self._player.name() + " won! " + self._player.name() +
" finished the demonstration!")
hasWon = True
elif DarkLogic.isAlreadyPlayed():
print(self._player.name() + " lost! Repetition of theorem!")
elif DarkLogic.isEvaluated():
print(
self._player.name() +
"lost! Cannot (\"back-\")demonstrate that a theorem is false with "
"implications")
elif not DarkLogic.canBeDemonstrated():
print(
self._player.name() +
" lost! This theorem cannot be demonstrated! " +
"It can be true or false according to the values of its variables"
)
elif nbAttempts == maxNbAttempts:
print(self._player.name() + " lost! Too much attempts!")
# update player's elo
W = 1 if hasWon else 0
exElo = self._player.elo()
newElo = round(exElo + 30 *
(W - 1 / (1 + 10**((self._eloThm - exElo) / 400))))
self._player.setElo(newElo)
else:
if DarkLogic.isDemonstrated():
print("The demonstration is already finished!")
elif not DarkLogic.canBeDemonstrated():
print(
"This theorem cannot be demonstrated! " +
"It can be true or false according to the values of its variables"
)
# clear Logic State
DarkLogic.clearAll()
# let player meditates the last game
self._player.meditate()
def preExplore(self, nodeList, states):
# play crt move
DarkLogic.apply(self._threadId, self._actionId)
# check if it is a node which leads to loss
if DarkLogic.isAlreadyPlayed(self._threadId):
self._value = Node.VAL_MAX
elif not DarkLogic.canBeDemonstrated(self._threadId):
self._value = Node.VAL_MAX
if not DarkLogic.isEvaluated(self._threadId):
self._isLoss = True
# check if it is a node which leads to win
elif DarkLogic.isDemonstrated(self._threadId):
self._value = 0
# stop reflexion because AI found a demonstration
Node._ai.stopThread(self._threadId)
else:
actions = DarkLogic.getActions(self._threadId)
for action in actions:
self._sons[action] = None
nodeList.append(self)
if self._ai.canEvaluate(DarkLogic.getState(self._threadId)):
states.append(Node._ai.getTrueState(self._threadId))
else:
self._aiValue = Node.VAL_INIT
self._isEvaluated = True
# unplay crt move
DarkLogic.unapply(self._threadId)
def demonstration(self, name, content, nbThreads):
print("Test AI on " + name + " theorem with " + str(nbThreads) +
" cores")
DarkLogic.init(nbThreads)
ai = AI(nbThreads, 60)
assert DarkLogic.makeTheorem(
name, content), "cannot make " + name + " theorem"
DarkLogic.printTheorem()
start = time.perf_counter()
while not DarkLogic.isOver():
action = ai.play()
DarkLogic.getActions()
print(ai.name() + " plays action with id " + str(action.id()))
DarkLogic.apply(action.id())
DarkLogic.printTheorem()
print(
"____________________________________________________________________________"
)
end = time.perf_counter()
if DarkLogic.hasAlreadyPlayed():
if DarkLogic.isDemonstrated():
print(ai.name() + " won! " + ai.name() +
" finished the demonstration!")
elif DarkLogic.isAlreadyPlayed():
print(ai.name() + " lost! Repetition of theorem!")
elif DarkLogic.isEvaluated():
print(
ai.name() +
" lost! Cannot (\"back-\")demonstrate that a theorem is false with implications"
)
elif not DarkLogic.canBeDemonstrated():
print(
ai.name() +
" lost! This theorem cannot be demonstrated! " +
"It can be true or false according to the values of its variables"
)
else:
if DarkLogic.isDemonstrated():
print("Game Over! the demonstration is already finished!")
self._elapsed_seconds = end - start
elif not DarkLogic.canBeDemonstrated():
print(
"Game Over! This theorem cannot be demonstrated! " +
"It can be true or false according to the values of its variables"
)
self.pushEvent(Event.EventEnum.STOP)
def humanIdentity():
DarkLogic.init(0)
print("Identity Demonstration")
DarkLogic.makeTheorem("identity", "a<=>a")
DarkLogic.printTheorem()
print("__________________________________________________")
apply("arr,[0]")
apply("arr,[0]")
apply("arr,[1]")
apply("arr_True,[]")
assert DarkLogic.isDemonstrated(), "identity theorem was not demonstrated"
def humanDoubleNot():
DarkLogic.init(0)
print("DoubleNot Demonstration")
DarkLogic.makeTheorem("doubleNot", "a<=>!!a")
DarkLogic.printTheorem()
print("__________________________________________________")
apply("FE,[1]")
apply("arr,[0]")
apply("arr,[0]")
apply("arr_True")
assert DarkLogic.isDemonstrated(), "DoubleNot theorem was not demonstrated"
def humanExcludedMiddle():
DarkLogic.init(0)
print("ExcludedMiddle Demonstration")
DarkLogic.makeTheorem("ExcludedMiddle", "p||!p")
DarkLogic.printTheorem()
print("__________________________________________________")
apply("arr")
apply("FI!")
apply("||Ig_Annexe_0")
apply("FE")
apply("FI!_Annexe_7")
apply("||Ig")
apply("ax_Annexe_1")
assert DarkLogic.isDemonstrated(
), "ExcludedMiddle theorem was not demonstrated"
def performance(self, thName, thContent, maxTime):
print("CheckPerformance Test on " + thName + " theorem : " + thContent)
nbThreads = multiprocessing.cpu_count()
realMaxTime = (maxTime * 1.15) * (4.0 / nbThreads)
# start AI
self._thread = TestThread(self, thName, thContent, nbThreads)
with self._condition_var:
while not self._hasEvents:
hasTimedOut = not self._condition_var.wait(20)
if hasTimedOut:
break
if len(self._eventQueue):
self._eventQueue.pop()
self._hasEvents = False
assert DarkLogic.isDemonstrated(), thName + " cannot be demonstrated"
assert self._elapsed_seconds < realMaxTime, "Demonstration of " + thName + " theorem must be "
"done in less than " + str(realMaxTime) + " seconds"
DarkLogic.clearAll()
def eval(self, threadIdx):
# play crt move
DarkLogic.apply(threadIdx, self._actionId)
# check if it is a node which leads to loss
if DarkLogic.isAlreadyPlayed(threadIdx):
self._value = Node.VAL_MAX
elif not DarkLogic.canBeDemonstrated(threadIdx):
self._value = Node.VAL_MAX
if not DarkLogic.isEvaluated(threadIdx):
self._isLoss = True
# check if it is a node which leads to win
elif DarkLogic.isDemonstrated(threadIdx):
self._value = 0
# stop reflexion because AI found a demonstration
Node._ai.stopThread(threadIdx)
else:
self._subValue = Node._ai.eval([DarkLogic.getState(threadIdx)],
threadIdx)
self._isEvaluated = True
# unplay crt move
DarkLogic.unapply(threadIdx)
def exploreDepthStatic(self, maxDepth):
# play crt move
DarkLogic.apply(self._threadId, self._actionId)
"""print("crt action id: " + str(self._actionId) + ", at depth="
+ str(self._depth) + ", crt theorem is: " + DarkLogic.toStrTheorem(self._threadId))"""
# no need to go deeper
if self._depth == maxDepth:
# check if it is a node which leads to loss
if DarkLogic.isAlreadyPlayed(
self._threadId) or not DarkLogic.canBeDemonstrated(
self._threadId):
self._value = Node.VAL_MAX
# check if it is a node which leads to win
elif DarkLogic.isDemonstrated(self._threadId):
self._value = 0
# stop reflexion because AI found a demonstration
Node._ai.stopThread(self._threadId)
"""else:
self._subValue = self._ai.eval([DarkLogic.getState(self._threadId)], self._threadId)"""
elif not Node._ai.mustStop(self._threadId):
# get actions
actions = DarkLogic.getActions(self._threadId)
# add all subnodes if they have not been created yet
if self._depth == maxDepth - 1:
for action in actions:
self._sons[action] = Node(actionId=action,
threadId=self._threadId,
depth=self._depth + 1)
# explore subNodes
hasOnlyLosses = True
self._subValue = Node.INIT_SUBVALUE
for action in actions:
# explore node associated with action
node = self._sons[action]
retValue = Node.VAL_MAX
if node.value() < Node.VAL_MAX:
retValue = node.exploreDepthStatic(maxDepth)
# update m_value
if retValue == Node.VAL_MAX:
if hasOnlyLosses:
self._value = Node.VAL_MAX
else:
hasOnlyLosses = False
if retValue == Node.VAL_INIT and self._value == Node.VAL_MAX:
self._value = Node.VAL_INIT
elif self._value > retValue + 1:
self._value = retValue + 1
# update subValue
if self._subValue > node.subValue():
self._subValue = node.subValue()
# if must stop exploration, stop it
if Node._ai.mustStop(self._threadId):
break
# unplay crt move
DarkLogic.unapply(self._threadId)
return self._value