def insert_stench_regle(gs: Gophersat, wumpus_voca: List, stench_voca: List):
for stench in stench_voca:
# Soit le symbole Wij
ij = stench[1:] # On enleve la lettre
i = int(ij[:2]) # On prend les deux premiers chiffres pour l'indice i
j = int(ij[2:]) # On prend les deux derniers chiffres pour l'indice j
i_moins_1 = int_to_two_digits_str(i, -1)
i_plus_1 = int_to_two_digits_str(i, 1)
j_moins_1 = int_to_two_digits_str(j, -1)
j_plus_1 = int_to_two_digits_str(j, 1)
i = int_to_two_digits_str(i)
j = int_to_two_digits_str(j)
wumpuses = []
if f"W{i_plus_1}{j}" in wumpus_voca:
wumpuses.append(f"W{i_plus_1}{j}")
if f"W{i_moins_1}{j}" in wumpus_voca:
wumpuses.append(f"W{i_moins_1}{j}")
if f"W{i}{j_plus_1}" in wumpus_voca:
wumpuses.append(f"W{i}{j_plus_1}")
if f"W{i}{j_moins_1}" in wumpus_voca:
wumpuses.append(f"W{i}{j_moins_1}")
clause = wumpuses + [f"-{stench}"]
gs.push_pretty_clause(clause)
def push_clause_from_wumpus(gs: Gophersat,
case_contents: str,
position: Tuple[str, str],
is_from_know_method: bool = False,
enable_log: bool = False):
if enable_log:
print(f"contents is : {case_contents}")
facts = []
for case_content in case_contents:
if enable_log:
print(f"inserting from wumpus : {case_content}\n")
tmp_facts = wumpus_to_clause(case_content, position)
if tmp_facts == -1:
print("Error : Invalid case contents : wumpus to clause")
return -1
else:
facts = facts + tmp_facts
if is_from_know_method == False: # Si on utilise pas la methode know, on est certains de ce qu'il n'y a pas dans la case
facts = facts + get_implicit_negative_facts(facts, position)
for fact in facts: # On doit inserer les clauses une a une
gs.push_pretty_clause([fact])
def insert_trou_regle(gs: Gophersat, trou_voca: List, brise_voca: List):
for trou in trou_voca:
# Soit le symbole Tij, une chaine de caractere avec i et j appartient a [0..99]
# On enleve la lettre et on recupere i et j
ij = trou[1:]
i = int(ij[:2]) # On prend les deux premiers chiffres pour l'indice i
j = int(ij[2:]) # On prend les deux derniers chiffres pour l'indice j
i_moins_1 = int_to_two_digits_str(i, -1)
i_plus_1 = int_to_two_digits_str(i, 1)
j_moins_1 = int_to_two_digits_str(j, -1)
j_plus_1 = int_to_two_digits_str(j, 1)
i = int_to_two_digits_str(i)
j = int_to_two_digits_str(j)
brises = []
if f"B{i_plus_1}{j}" in brise_voca:
brises.append(f"B{i_plus_1}{j}")
if f"B{i_moins_1}{j}" in brise_voca:
brises.append(f"B{i_moins_1}{j}")
if f"B{i}{j_plus_1}" in brise_voca:
brises.append(f"B{i}{j_plus_1}")
if f"B{i}{j_moins_1}" in brise_voca:
brises.append(f"B{i}{j_moins_1}")
for brise in brises:
gs.push_pretty_clause([f"-{trou}", brise])
def insert_wumpus_stench_regle(gs: Gophersat, wumpus_voca: List,
stench_voca: List):
for wumpus in wumpus_voca:
# Soit le symbole Tij
ij = wumpus[1:] # On enleve la lettre
i = int(ij[:2]) # On prend les deux premiers chiffres pour l'indice i
j = int(ij[2:]) # On prend les deux derniers chiffres pour l'indice j
i_moins_1 = int_to_two_digits_str(i, -1)
i_plus_1 = int_to_two_digits_str(i, 1)
j_moins_1 = int_to_two_digits_str(j, -1)
j_plus_1 = int_to_two_digits_str(j, 1)
i = int_to_two_digits_str(i)
j = int_to_two_digits_str(j)
stenches = []
if f"S{i_plus_1}{j}" in stench_voca:
stenches.append(f"S{i_plus_1}{j}")
if f"S{i_moins_1}{j}" in stench_voca:
stenches.append(f"S{i_moins_1}{j}")
if f"S{i}{j_plus_1}" in stench_voca:
stenches.append(f"S{i}{j_plus_1}")
if f"S{i}{j_moins_1}" in stench_voca:
stenches.append(f"S{i}{j_moins_1}")
for stench in stenches:
gs.push_pretty_clause([f"-{wumpus}", stench])
def is_number_possible(gs: Gophersat, number_to_insert: int, i: int, j: int):
gs.push_pretty_clause([f"{number_to_insert}_{i}_{j}"])
solvable = gs.solve()
if not solvable:
gs.pop_clause()
return solvable
def insert_only_one_wumpus_regle(gs: Gophersat, wumpus_voca: List):
wumpus_voca2 = wumpus_voca.copy()
for case in wumpus_voca:
wumpus_voca2.remove(case)
for c in wumpus_voca2:
gs.push_pretty_clause([f"-{case}", f"-{c}"])
gs.push_pretty_clause(wumpus_voca)
def insert_une_menace_par_case_regle(gs: Gophersat, wumpus_voca: List,
trou_voca: List):
trou_voca_pile = trou_voca.copy()
wumpus_voca_pile = wumpus_voca.copy()
for i in range(len(wumpus_voca)):
trou = trou_voca_pile.pop()
wumpus = wumpus_voca_pile.pop()
gs.push_pretty_clause([f"-{wumpus}", f"-{trou}"])
gs.push_pretty_clause([f"-{trou}", f"-{wumpus}"])
def insert_only_one_number_in_case(gs: Gophersat, voca: List):
for case in voca:
num_case = int(case.split('_')[0])
i = case.split('_')[1]
j = case.split('_')[2]
ou_clause = [case]
for number in range(
1, 10
): # non(1_i_j) OU non(2_i_j) ET non(1_i_j) OU non(3_i_j) ET ... ET non(1_i_j) OU non(9_i_j)
if num_case != number:
ou_clause.append(f"{number}_{i}_{j}")
gs.push_pretty_clause([f"-{case}", f"-{number}_{i}_{j}"])
gs.push_pretty_clause(ou_clause)
ou_clause = []
def insert_one_value_in_col(gs: Gophersat, voca: List):
for case in voca:
num_case = case.split('_')[0]
i = int(case.split('_')[1])
j = case.split('_')[2]
ou_clause = [case]
for i_prime in range(
0, 9
): # non(1_i_j) OU non(1_1_j) ET non(1_i_j) OU non(1_2_j) ET ... ET non(1_i_j) OU non(1_8_j)
if i != i_prime:
ou_clause.append(f"{num_case}_{i_prime}_{j}")
gs.push_pretty_clause(
[f"-{case}", f"-{num_case}_{i_prime}_{j}"])
gs.push_pretty_clause(ou_clause)
ou_clause = []
def insert_one_value_in_row(gs: Gophersat, voca: List):
for case in voca:
num_case = case.split('_')[0]
i = case.split('_')[1]
j = int(case.split('_')[2])
ou_clause = [case]
for j_prime in range(
0, 9
): # non(1_i_j) OU non(1_i_0) ET non(1_i_j) OU non(1_i_1) ET ... ET non(1_i_j) OU non(1_i_8)
if j != j_prime:
ou_clause.append(f"{num_case}_{i}_{j_prime}")
gs.push_pretty_clause(
[f"-{case}", f"-{num_case}_{i}_{j_prime}"])
gs.push_pretty_clause(ou_clause)
ou_clause = []
def insert_one_value_in_square(gs: Gophersat, voca: List):
for case in voca:
num_case = case.split('_')[0]
i = int(case.split('_')[1])
j = int(case.split('_')[2])
ib = 3 * (i // 3) # coordinates of the first case of the square
jb = 3 * (j // 3)
ou_clause = [case]
for i_prime in range(ib, ib + 3):
for j_prime in range(jb, jb + 3):
if i != i_prime or j != j_prime:
ou_clause.append(f"{num_case}_{i_prime}_{j_prime}")
gs.push_pretty_clause(
[f"-{case}", f"-{num_case}_{i_prime}_{j_prime}"])
gs.push_pretty_clause(ou_clause)
ou_clause = []
def initialisation(N, random = False):
ww = WumpusWorld(N, random)
voc = creationVoc(ww.get_n())
gs = Gophersat(gophersat_exec, voc)
#état des lieux 1: on ne sait rien
knowledge = [[]] * N
for i in range(N):
knowledge[i] = [''] * N
for j in range(N):
ajoutClauseEmpty(gs, i, j)
ajoutClausesBreeze(gs, i, j)
ajoutClausesStench(gs, i, j)
ajoutClausesWumpus(gs, i, j)
ajoutClausesPuit(gs, i, j)
#on probe l'unique case safe
probe1=ww.probe(0, 0)
knowledge[0][0] = probe1[1]
if ('.' in probe1[1]): #la case est empty
gs.push_pretty_clause(["E0_0"])
if ('B' in probe1[1]): #la case est breeze
gs.push_pretty_clause(["B0_0"])
if ('S' in probe1[1]): #la case est stenchy
gs.push_pretty_clause(["S0_0"])
return(ww, gs, knowledge)
def initialisation(size, wwr):
#ww = WumpusWorld(size, random)
voc = creationVoc(size)
gs = Gophersat(gophersat_exec, voc)
#état des lieux 1: on ne sait rien
knowledge = [[]] * size
for i in range(size):
knowledge[i] = [''] * size
for j in range(size):
ajoutClauseEmpty(gs, i, j)
ajoutClausesBreeze(size, gs, i, j)
ajoutClausesStench(size, gs, i, j)
ajoutClausesWumpus(size, gs, i, j)
ajoutClausesPuit(size, gs, i, j)
#on probe l'unique case safe
status, probe1, cost = wwr.probe(0, 0)
knowledge[0][0] = probe1
if ('.' in probe1): #la case est empty
gs.push_pretty_clause(["E0_0"])
if ('B' in probe1): #la case est breeze
gs.push_pretty_clause(["B0_0"])
if ('S' in probe1): #la case est stenchy
gs.push_pretty_clause(["S0_0"])
return (gs, knowledge)
def insert_brise_regle(gs: Gophersat, brise_voca: List, trou_voca: List):
#-Bij ou T(i-1)j ou T(i+1)j ou Ti(j-1) ou Ti(j+1)
for brise in brise_voca:
# Soit le symbole Bij
# On enleve la lettre et on recupere i et j
ij = brise[1:]
i = int(ij[:2]) # On prend les deux premiers chiffres pour l'indice i
j = int(ij[2:]) # On prend les deux derniers chiffres pour l'indice j
i_moins_1 = int_to_two_digits_str(i, -1)
i_plus_1 = int_to_two_digits_str(i, 1)
j_moins_1 = int_to_two_digits_str(j, -1)
j_plus_1 = int_to_two_digits_str(j, 1)
i = int_to_two_digits_str(i)
j = int_to_two_digits_str(j)
trous = []
if f"T{i_plus_1}{j}" in trou_voca:
trous.append(f"T{i_plus_1}{j}")
if f"T{i_moins_1}{j}" in trou_voca:
trous.append(f"T{i_moins_1}{j}")
if f"T{i}{j_plus_1}" in trou_voca:
trous.append(f"T{i}{j_plus_1}")
if f"T{i}{j_moins_1}" in trou_voca:
trous.append(f"T{i}{j_moins_1}")
clause = trous + [f"-{brise}"]
gs.push_pretty_clause(clause)
# -Tij ou B(i-1)j ou B(i+1)j ou Bi(j-1) ou Bi(j+1)
for trou in trou_voca:
# Soit le symbole Tij
ij = trou[1:] # On eneleve la lettre
i = int(ij[:2]) # On prend les deux premiers chiffres pour l'indice i
j = int(ij[2:]) # On prend les deux derniers chiffres pour l'indice j
i_moins_1 = int_to_two_digits_str(i, -1)
i_plus_1 = int_to_two_digits_str(i, 1)
j_moins_1 = int_to_two_digits_str(j, -1)
j_plus_1 = int_to_two_digits_str(j, 1)
i = int_to_two_digits_str(i)
j = int_to_two_digits_str(j)
brises = []
if f"B{i_plus_1}{j}" in brise_voca:
brises.append(f"B{i_plus_1}{j}")
if f"B{i_moins_1}{j}" in brise_voca:
brises.append(f"B{i_moins_1}{j}")
if f"B{i}{j_plus_1}" in brise_voca:
brises.append(f"B{i}{j_plus_1}")
if f"B{i}{j_moins_1}" in brise_voca:
brises.append(f"B{i}{j_moins_1}")
clause = brises + [f"-{trou}"]
gs.push_pretty_clause(clause)
def insert_safety_regle(gs: Gophersat):
gs.push_pretty_clause(["-W0000"])
gs.push_pretty_clause(["-T0000"])