def arrange_problem(self):
for i in self.queries:
# If there's only one observation then any '?' tile state is unknown
if self.num_observations == 1:
self.results[i] = '?'
continue
self.kb = []
self.query_kb = []
self.build_kb(i)
input_clause = self.query_to_cnf(i)
g = Glucose4()
f = Glucose4()
f_clauses, extra_f = [], []
for kb_clause in self.query_kb:
g.add_clause(kb_clause)
f_clauses.append(kb_clause)
if (abs(input_clause) // 10) % 10 == self.tile_state('S'):
for index, k in enumerate(kb_clause):
if abs(k) % 10 == 0:
g.add_clause([-1 * abs(k)])
break
if (abs(input_clause) // 10) % 10 == self.tile_state('H'):
for index, k in enumerate(kb_clause):
if abs(k) % 10 == 0:
extra_f.append([-1 * abs(k)])
break
for kb_clause in self.kb:
g.add_clause(kb_clause)
f_clauses.append(kb_clause)
for clause in f_clauses:
for index, l in enumerate(clause):
if abs(l) % 10000 == input_clause:
clause[index] = -1 * l
f.add_clause(clause)
break
for kb_clause in extra_f:
f.add_clause(kb_clause)
asked_query = g.solve()
if asked_query:
self.results[i] = 'T'
elif not asked_query:
self.results[i] = 'F'
"""opposite_query = f.solve()
if asked_query != opposite_query:
if asked_query:
self.results[i] = 'T'
elif not asked_query:
self.results[i] = 'F'
else:
self.results[i] = '?'"""
return self.results
def resolver(passo: int,
conjuntoVertices: bool = False,
ordemVertices: bool = True):
"""Resolve o caminho eureliano do grafo.
:param passo: Recebe um array contendo os primeiros passos de cada possível começo do problema
:param conjuntoVertices: Exibir o uma lista fora de ordem com o conjunto dos vértices que resolvem o problema. (Default value = False)
:param ordemVertices: Exibir o caminho pelos vértices a ser percorrido para resolver o problema. (Default value = True)
"""
formula = CNF()
g = Glucose4()
getClausulas(matriz, formula)
formula.append([passo])
g.append_formula(formula)
print(
f'O passo inicial para prova é: \33[32m{passo}\33[m, o caminho com ele é \33[34m{g.solve()}\33[m'
)
model = g.get_model()
if model:
valoracaoValida = valoresValidos(model)
print(f'Passos válidos: \33[35m{valoracaoValida}\33[m')
if conjuntoVertices:
print(
f'Esse são os conjuntos de vértices usados (fora de ordem): \33[36m{caminhosUsados(model)}\33[m'
)
if ordemVertices:
print(f"Ordem de passagem pelos vértices: ")
printEmOrdem(valoracaoValida)
print()
def reinit_oracle(self):
self.oracle.delete()
self.oracle = Glucose4(bootstrap_with=self.hard)
self.oracle.append_formula(self.soft)
rlist = self.r_to_list()
self.oracle.append_formula(
CardEnc.atmost(lits=rlist, bound=self.k, top_id=self.topv).clauses)
def construct_solver(c, assumptions=None, engine="cadical"):
"""
Constructs a SAT solver instance with the given circuit and assumptions
Parameters
----------
c : Circuit
circuit to encode
assumptions : dict of str:int
Assumptions to add to solver
Returns
-------
solver : pysat.Cadical
SAT solver instance
variables : pysat.IDPool
solver variable mapping
"""
formula, variables = cnf(c)
if assumptions:
for n in assumptions.keys():
if n not in c:
raise ValueError(f"incorrect assumption key: {n}")
add_assumptions(formula, variables, assumptions)
if engine == "cadical":
solver = Cadical(bootstrap_with=formula)
elif engine == "glucose":
solver = Glucose4(bootstrap_with=formula, incr=True)
elif engine == "lingeling":
solver = Lingeling(bootstrap_with=formula)
else:
raise ValueError(f"unsupported solver: {engine}")
return solver, variables
def get_smaller_models(model):
newClauses = list()
found_models = list()
# keep negative assignments
for lit in model:
if lit < 0:
newClauses.append([lit])
disable_model(newClauses, model, True)
solver = Glucose4(bootstrap_with=clauses + newClauses)
while True:
sat = solver.solve()
smaller_model = solver.get_model()
if not sat:
break
# append new model and disable it for future calls
found_models.append(smaller_model)
#disable_model(newClauses, smaller_model)
newClause = list()
for lit in smaller_model:
if lit > 0:
newClause.append(-lit)
solver.add_clause(newClause)
disable_model_in_solver(model_clauses, smaller_model)
solver.delete()
return found_models
def solver(knowledgeBase, ask):
g = Glucose4()
g.add_clause([ask])
for i in knowledgeBase:
g.add_clause(i)
ans = g.solve()
g.delete()
return ans
def solve_problem(input):
g_solver = Glucose4()
police = input['police']
medics = input['medics']
observations = input['observations']
queries = input['queries']
queries_answers = dict()
turns = 0
for turn in observations:
rows = 0
for line in turn:
cols = 0
for var in line:
cols += 1
rows += 1
turns += 1
basics = [rows, cols, turns]
known_base = list()
actions, pos_states, days = action_treatment(police, medics, basics)
clauses = negative_options(actions)
known_base += clauses
clauses = S_treatment(actions, basics, days, police)
known_base += clauses
if medics > 0:
clauses = I_treatment(actions, basics, days, medics)
known_base += clauses
if police > 0:
clauses = Q_treatment(actions, basics, days, police)
known_base += clauses
clauses = U_treatment(actions, basics, days)
known_base += clauses
clauses = H_treatment(actions, basics, days, police, medics)
known_base += clauses
clauses = infect(actions, basics, days, police)
known_base += clauses
clauses = initial(observations, actions, days)
known_base += clauses
for q in queries:
query_answer = query_treatment(q, actions, days, known_base, g_solver,
medics, police)
queries_answers = merge_ans(queries_answers, query_answer)
return queries_answers
def solver(known_base, ask):
"""
the SAT solver
"""
g_solver = Glucose4()
g_solver.add_clause([ask])
for kb in known_base:
g_solver.add_clause(kb)
ans = g_solver.solve()
g_solver.delete()
return ans
def solver(kb, ask):
g = Glucose4()
g.add_clause([ask])
for i in kb:
g.add_clause(i)
# print("kb",kb,"ask",ask)
ans = g.solve()
# print("ans",ans)
# print("model",g.get_model())
g.delete()
return ans
def TT_check_all_pysat(KB: 'ClauseTheory', a: 'AtomSet', symbols: 'AtomSet',
model: 'AtomSet'):
formula = CNF()
for clause in KB:
arr = []
arr.extend(clause.get_positive().get_atoms())
arr.extend(map(lambda x: -x, clause.get_negative().get_atoms()))
formula.append(arr)
assumptions = []
assumptions.extend(model)
formula.append(list(map(lambda x: -x, a)))
with Glucose4(bootstrap_with=formula.clauses) as g:
return not g.solve(assumptions=assumptions)
def solve(self, constraints_flag=False):
solver = Glucose4()
# solver = Maplesat()
# solver = Lingeling()
# solver = Cadical()
self.add_clauses_to_solver(solver, constraints_flag)
success = solver.solve()
if success:
self.result = solver.get_model()
self.success = success
def single_problem(problem, letter, query):
round = problem.prop_index + problem.action_index
actions_at_time = lambda time: time * round + problem.prop_index
prop_at_time = lambda time: time * round
#interfering = return_interfeering(problem.actions)
g = Glucose4()
# Initial state clauses
for key in problem.initial_state.keys():
sign = 1 if problem.initial_state[key] else -1
g.add_clause([sign * problem.proposition_to_number[key]])
for t in range(30):
#Linear
# Goal State
know_assumption = prop_at_time(t) + problem.proposition_to_number['known', query[1], query[0], '_']
letter_assumption = prop_at_time(t) + problem.proposition_to_number['letter', query[1], query[0], letter]
for act in problem.actions:
# Action precondition clauses
for p in act.pre:
g.add_clause([-(act.index + actions_at_time(t)), fix_sign(p, prop_at_time(t))])
# Action effect clauses
for p in act.add:
g.add_clause([-(act.index + actions_at_time(t)), (p + prop_at_time(t+1))])
for p in act.dele:
g.add_clause([-(act.index + actions_at_time(t)), -(p + prop_at_time(t+1))])
for p in range(1, problem.prop_index + 1):
# Positive Frame axiom clauses
if p not in act.dele:
g.add_clause([-(act.index + actions_at_time(t)), -(p + prop_at_time(t)), p + prop_at_time(t + 1)])
# Negative Frame axiom clauses
if p not in act.add:
g.add_clause([-(act.index + actions_at_time(t)), p + prop_at_time(t), -(p + prop_at_time(t + 1))])
# Linearity constraints clauses
for act_tag in problem.actions:
if act_tag.index != act.index:
g.add_clause([-(act.index + actions_at_time(t)), -(act_tag.index + actions_at_time(t))])
g.add_clause([act.index + actions_at_time(t) for act in problem.actions])
if g.solve(assumptions=[know_assumption, letter_assumption]):
return True
return False
def juan_coin(problem, query, letter):
g = Glucose4()
b = 20
# Initial state clauses
for key in problem.obs_dict.keys():
sign = 1 if problem.obs_dict[key] else -1
g.add_clause([sign * problem.props_dict[key]])
for t in range(b):
# Goal State Clauses
know_assumption = problem.props_current_index(t) + problem.props_dict[query[1], query[0], '?']
letter_assumption = problem.props_current_index(t) + problem.props_dict[query[1], query[0], letter]
for act in problem.actions:
# Action prec
for pre_prop in act.pre:
pre_prefix = problem.is_negative(pre_prop)
g.add_clause([-(act.index + problem.actions_current_index(t)), pre_prop + pre_prefix * problem.props_current_index(t)])
# Action effect
for p in act.add:
g.add_clause([-(act.index + problem.actions_current_index(t)), (p + problem.props_current_index(t + 1))])
for p in act.delt:
g.add_clause([-(act.index + problem.actions_current_index(t)), -(p + problem.props_current_index(t + 1))])
# Positive and Negative Frame axiom clauses
for p in range(1, problem.prop_ind + 1):
if p not in act.delt:
g.add_clause([-(act.index + problem.actions_current_index(t)), -(p + problem.props_current_index(t)),
p + problem.props_current_index(t + 1)])
if p not in act.add:
g.add_clause([-(act.index + problem.actions_current_index(t)), p + problem.props_current_index(t),
-(p + problem.props_current_index(t + 1))])
# Linearity
for act_tag in problem.actions:
if act_tag.index != act.index:
g.add_clause([-(act.index + problem.actions_current_index(t)), -(act_tag.index + problem.actions_current_index(t))])
g.add_clause([act.index + problem.actions_current_index(t) for act in problem.actions])
if g.solve(assumptions=[know_assumption, letter_assumption]):
return True
return False
def solve_problem(input):
policeNum = input['police']
medicsNum = input['medics']
observed_map = input['observations']
queries = input['queries']
turnsNum = len(observed_map)
rowsNum = len(observed_map[0])
columnsNum = len(observed_map[0][0])
g = Glucose4()
queries_dict = {}
rows_cols_turns = [rowsNum, columnsNum, turnsNum]
knowledgeBase = []
actions, pos_states, days = action_treatment(policeNum, medicsNum,
rows_cols_turns)
clauses = only_one_per_position(actions)
knowledgeBase += clauses
clauses = S_treatment(actions, rows_cols_turns, days, policeNum)
knowledgeBase += clauses
if policeNum > 0:
clauses = Q_treatment(actions, rows_cols_turns, days, policeNum)
knowledgeBase += clauses
if medicsNum > 0:
clauses = I_treatment(actions, rows_cols_turns, days, medicsNum)
knowledgeBase += clauses
clauses = H_treatment(actions, rows_cols_turns, days, policeNum, medicsNum)
knowledgeBase += clauses
clauses = U_treatment(actions, rows_cols_turns, days)
knowledgeBase += clauses
clauses = infect(actions, rows_cols_turns, days, policeNum)
knowledgeBase += clauses
clauses = Initial(observed_map, actions, days)
knowledgeBase += clauses
for q in queries:
query_dict = query_treatment(q, actions, days, knowledgeBase, g,
medicsNum, policeNum)
queries_dict.update(query_dict)
return queries_dict
def RemoveKB(self, _list_pos):
# Tell KB that wumpus disappear
tmp = _list_pos.pop(0)
self.agentFormulaWumpus.append([self.ConvertPosToNum(tmp, -1)])
self.agentBrainPit.add_clause([self.ConvertPosToNum(tmp, -1)])
# Remove Stench
for i in _list_pos:
tmp = self.ConvertPosToNum(i, 1, 1)
try:
self.agentFormulaWumpus.remove([tmp])
except:
print("Stench is not exists in formula")
self.agentFormulaWumpus.append([tmp * -1])
self.agentBrainWumpus.delete()
self.agentBrainWumpus = Glucose4()
self.agentBrainWumpus.append_formula(self.agentFormulaWumpus)
def find_clique(k):
max_clique = 2
n = 2
while True:
formula = build_formula(n, k)
with Glucose4(bootstrap_with=formula) as solver:
if solver.solve():
max_clique = n
else:
break
print("Clique of size {} for {} color(s) exists".format(n, k))
n += 1
print("--------")
print("Clique of size {} is maximum for {} color(s)".format(max_clique, k))
def check_queries(queries, kb, states_encoding):
g = Glucose4()
for clause in kb:
g.add_clause(map(int, clause))
answers = dict()
for query in queries:
x, y = query[0]
t = query[1]
state = query[2]
if not g.solve(assumptions=map(int, [states_encoding[state][x, y, t]])):
answers[query] = 'F'
elif g.solve(assumptions=map(int, [-states_encoding[state][x, y, t]])):
answers[query] = '?'
else:
answers[query] = 'T'
g.delete()
return answers
def is_minimal_model(model):
newClauses = list()
found_models = list()
# keep negative assignments
disableClause = list()
for lit in model:
disableClause.append(-lit)
if lit < 0:
newClauses.append([lit])
newClauses.append(disableClause)
solver = Glucose4(bootstrap_with=clauses + newClauses)
res = solver.solve()
if res:
print(
f"Found smaller model: {get_model_size(model)} -> {get_model_size(solver.get_model())}"
)
solver.delete()
return not res
def solve_given_query(query,
all_given_clauses,
times,
number_of_rows,
number_of_cols,
index_by_variable,
original_query=False,
print_flag=False):
g = Glucose4()
for c in all_given_clauses:
g.add_clause(c)
query_formula = get_query_formula(query, index_by_variable)
for c in query_formula.clauses:
g.add_clause(c)
query_sol = g.solve()
if print_flag:
if query_sol:
if original_query:
print(f"Original query: {query}")
else:
print(f"Not original query: {query}")
printable_solution(g.get_model(), times, number_of_rows,
number_of_cols, query, index_by_variable)
else:
if original_query:
print(f"Original query: {query}: No solution\n")
else:
print(f"Not original query: {query}: No solution\n")
return query_sol
import sys
from pysat.card import *
from pysat.formula import CNF
from pysat.solvers import Glucose4
k = 0
instance = sys.argv[1]
cnf = CNF(from_file=instance)
clauses = cnf.clauses
oracle = Glucose4()
topv = cnf.nv
variables = list()
for i in range(1, topv + 1):
variables.append(i)
cnf = None
def get_model_size(model):
size = 0
for lit in model:
if lit > 0:
#print(lit)
size += 1
return size
def is_minimal_model(model):
newClauses = list()
found_models = list()
def setup(self, m, **kwargs):
from pysat.solvers import Glucose4
solver = Glucose4()
solver.append_formula(self._clauses.as_list())
return solver
def __init__(self, sizeMap):
self.agentBrainWumpus = Glucose4()
self.agentBrainPit = Glucose4()
self.agentFormulaWumpus = []
self.sizeMap = sizeMap
def __init__(self):
self._solver = Glucose4()
self._name_to_nums = None
self._num_to_name = None
def solve_problem(input):
num_of_turns = len(input["observations"])
num_of_rows = len(input["observations"][0])
num_of_cols = len(input["observations"][0][0])
num_of_police = input["police"]
num_of_medics = input["medics"]
clauses = list()
clauses += KB(input)
clauses += create_atoms(num_of_turns, num_of_rows, num_of_cols)
clauses += actions(num_of_turns, num_of_rows, num_of_cols)
clauses += infection_action_precondition(num_of_turns, num_of_rows, num_of_cols)
if num_of_turns > 3:
clauses += healing_action_precondition(num_of_turns, num_of_rows, num_of_cols)
clauses += noop_H_action_precondition(num_of_turns, num_of_rows, num_of_cols)
clauses += noop_S_action_precondition(num_of_turns, num_of_rows, num_of_cols)
clauses += noop_U_action_precondition(num_of_turns, num_of_rows, num_of_cols)
clauses += infection_action_fact_achievement(num_of_turns, num_of_rows, num_of_cols)
clauses += healing_action_fact_achievement(num_of_turns, num_of_rows, num_of_cols)
clauses += unpopulated_action_fact_achievement(num_of_turns, num_of_rows, num_of_cols)
clauses += additional_rules(num_of_turns, num_of_rows, num_of_cols, num_of_police, num_of_medics)
if num_of_police == 0 and num_of_medics == 0:
queries_dict = dict()
for query in input["queries"]:
if query[2] == "H":
assumption = int(str(1) + str(query[0][0]) + str(query[0][1]) + str(query[1]))
elif query[2] == "S":
assumption = int(str(2) + str(query[0][0]) + str(query[0][1]) + str(query[1]))
else: # query[2] == "U"
assumption = int(str(3) + str(query[0][0]) + str(query[0][1]) + str(query[1]))
g1 = Glucose4(bootstrap_with=clauses + [[-assumption]])
g2 = Glucose4(bootstrap_with=clauses + [[assumption]])
solver1 = g1.solve()
solver2 = g2.solve()
if solver1 and solver2:
queries_dict[query] = '?'
elif not solver1 and solver2:
queries_dict[query] = 'T'
else:
queries_dict[query] = 'F'
return queries_dict
elif num_of_police == 1 and num_of_medics == 0:
clauses += quarantine_action(num_of_turns, num_of_rows, num_of_cols)
clauses += quarantine_action_precondition(num_of_turns, num_of_rows, num_of_cols)
clauses += noop_Q_action_precondition(num_of_turns, num_of_rows, num_of_cols)
clauses += qur_action_fact_achievement(num_of_turns, num_of_rows, num_of_cols)
queries_dict = dict()
for query in input["queries"]:
if query[2] == "H":
assumption = int(str(1) + str(query[0][0]) + str(query[0][1]) + str(query[1]))
elif query[2] == "S":
assumption = int(str(2) + str(query[0][0]) + str(query[0][1]) + str(query[1]))
elif query[2] == "U":
assumption = int(str(3) + str(query[0][0]) + str(query[0][1]) + str(query[1]))
else: # query[2] == "Q"
assumption = int(str(4) + str(query[0][0]) + str(query[0][1]) + str(query[1]))
g1 = Glucose4(bootstrap_with=clauses + [[-assumption]])
g2 = Glucose4(bootstrap_with=clauses + [[assumption]])
solver1 = g1.solve()
solver2 = g2.solve()
if solver1 and solver2:
queries_dict[query] = '?'
elif not solver1 and solver2:
queries_dict[query] = 'T'
else:
queries_dict[query] = 'F'
return queries_dict
elif num_of_police == 0 and num_of_medics == 1:
clauses += vaccinate_action(num_of_turns, num_of_rows, num_of_cols)
clauses += vaccinate_action_precondition(num_of_turns, num_of_rows, num_of_cols)
clauses += noop_I_action_precondition(num_of_turns, num_of_rows, num_of_cols)
clauses += vac_action_fact_achievement(num_of_turns, num_of_rows, num_of_cols)
queries_dict = dict()
for query in input["queries"]:
if query[2] == "H":
assumption = int(str(1) + str(query[0][0]) + str(query[0][1]) + str(query[1]))
elif query[2] == "S":
assumption = int(str(2) + str(query[0][0]) + str(query[0][1]) + str(query[1]))
elif query[2] == "U":
assumption = int(str(3) + str(query[0][0]) + str(query[0][1]) + str(query[1]))
else: # query[2] == "I"
assumption = int(str(5) + str(query[0][0]) + str(query[0][1]) + str(query[1]))
g1 = Glucose4(bootstrap_with=clauses + [[-assumption]])
g2 = Glucose4(bootstrap_with=clauses + [[assumption]])
solver1 = g1.solve()
solver2 = g2.solve()
if solver1 and solver2:
queries_dict[query] = '?'
elif not solver1 and solver2:
queries_dict[query] = 'T'
else:
queries_dict[query] = 'F'
return queries_dict
else:
clauses += quarantine_action(num_of_turns, num_of_rows, num_of_cols)
clauses += quarantine_action_precondition(num_of_turns, num_of_rows, num_of_cols)
clauses += noop_Q_action_precondition(num_of_turns, num_of_rows, num_of_cols)
clauses += qur_action_fact_achievement(num_of_turns, num_of_rows, num_of_cols)
clauses += vaccinate_action(num_of_turns, num_of_rows, num_of_cols)
clauses += vaccinate_action_precondition(num_of_turns, num_of_rows, num_of_cols)
clauses += noop_I_action_precondition(num_of_turns, num_of_rows, num_of_cols)
clauses += vac_action_fact_achievement(num_of_turns, num_of_rows, num_of_cols)
queries_dict = dict()
for query in input["queries"]:
if query[2] == "H":
assumption = int(str(1) + str(query[0][0]) + str(query[0][1]) + str(query[1]))
elif query[2] == "S":
assumption = int(str(2) + str(query[0][0]) + str(query[0][1]) + str(query[1]))
elif query[2] == "U":
assumption = int(str(3) + str(query[0][0]) + str(query[0][1]) + str(query[1]))
elif query[2] == "Q":
assumption = int(str(4) + str(query[0][0]) + str(query[0][1]) + str(query[1]))
else: # query[2] == "I"
assumption = int(str(5) + str(query[0][0]) + str(query[0][1]) + str(query[1]))
g1 = Glucose4(bootstrap_with=clauses + [[-assumption]])
g2 = Glucose4(bootstrap_with=clauses + [[assumption]])
solver1 = g1.solve()
solver2 = g2.solve()
if solver1 and solver2:
queries_dict[query] = '?'
elif not solver1 and solver2:
queries_dict[query] = 'T'
else:
queries_dict[query] = 'F'
return queries_dict
def solve_problem(input):
g = Glucose4(with_proof=True)
police_num = input["police"]
medic_num = input["medics"]
queries = input["queries"]
g_array = []
observations = input['observations']
num_of_cells = len(observations) * len(observations[0])
meaningful_cell_numbers = [
10000, 20000, 21000, 22000, 30000, 40000, 50000, 51000
]
meaningful_world_numbers = [
60000, 61000, 62000, 63000, 64000, 65000, 66000, 70000, 71000, 72000
]
states_dic = {
'H': 10000,
'S0': 20000,
'S1': 21000,
'S2': 22000,
'I': 30000,
'U': 40000,
'Q0': 50000,
'Q1': 51000
}
actions_map = [('H', 'S0', 60000), ('S0', 'S1', 61000),
('S1', 'S2', 62000),
('S2', 'H', 63000), ('noop', 'H', 64000),
('noop', 'I', 65000), ('noop', 'U', 66000),
('Q0', 'Q1', 70000), ('Q1', 'H', 71000), ('H', 'I', 72000)]
## todo: add S -> Q0, Q0->Q1, Q1->H, H->I
## todo: פעולות אפשריות כמספר הצוותים
## todo: in H->S0 need to check if S wasn't turned to Q
add_restrictions(g_array, observations)
create_cell_options(meaningful_cell_numbers, observations, g_array)
create_world_actions(
num_of_cells, meaningful_world_numbers, observations, actions_map,
states_dic, meaningful_cell_numbers,
g_array) #todo if bug, check disjunction from presentation
insert_observation(input, g_array, meaningful_cell_numbers)
limit_teams_actions(observations, g_array)
if (input['medics'] > 0):
g_array.append([12])
else:
g_array.append([-12])
#print('Adding')
for i in range(len(g_array)):
#print(g_array[i])
r = g.add_clause(g_array[i], no_return=True)
answer_dict = {}
for q in range(len(queries)):
assumption_answer = hadle_query(queries, q, states_dic, g)
if (assumption_answer == True):
unknown_answer = check_if_unknown(meaningful_cell_numbers, queries,
q, g, states_dic)
if (unknown_answer == '?'):
answer_dict[queries[q]] = '?'
else:
answer_dict[queries[q]] = 'T'
else:
answer_dict[queries[q]] = 'F'
return answer_dict
def solve_sat(dimension=5, filename="test.txt"):
cells = dimension * dimension # Represents the number of cells in the grid
# gen_random_game(dimension, filename)
game = get_matrix(filename)
# ensures that all coordinates in matrix are valid
for ii in range(cells):
x, y = get_coordinates(dimension, ii)
if get_int_index(dimension, x, y) != ii:
raise Exception("Get int index function failed")
if not game.valid_coord(x, y):
raise Exception("Error with matrix creation")
matrix = game.get_matrix()
# create constraints for source pipe
if matrix[0][0].type == Type.STRAIGHT:
start_index = get_index(dimension, 0)
clauses.append([int(start_index + "2")])
elif matrix[0][0].type == Type.TURN:
start_index = get_index(dimension, 0)
clauses.append([int(start_index + "6")])
# create constraints for destination pipe
if matrix[dimension - 1][dimension - 1].type == Type.STRAIGHT:
start_index = get_index(dimension, cells - 1)
clauses.append([int(start_index + "1")])
elif matrix[dimension - 1][dimension - 1].type == Type.TURN:
start_index = get_index(dimension, cells - 1)
clauses.append([int(start_index + "6")])
# create constraints to ensure that each cell has one pipe type either ═:1 ║:2 ╔:3 ╗:4 ╝:5 ╚:6
for ii in range(cells):
x, y = get_coordinates(dimension, ii)
ii_index = get_index(dimension, ii)
if matrix[y][x].type == Type.STRAIGHT:
# has to be one orientation either 1 or 2
clauses.append([int(ii_index + "1"), int(ii_index + "2")])
# can't be both orientations at same time, negation of 1 ^ 2 is -1 ∨ -2
clauses.append([int("-" + ii_index + "1"), int("-" + ii_index + "2")])
elif matrix[y][x].type == Type.TURN:
# has to be either 3, 4, 5, 6
clauses.append([int(ii_index + "3"), int(ii_index + "4"), int(ii_index + "5"), int(ii_index + "6")])
# can only be one
else:
raise Exception("Invalid Pipe when creating constraints")
for jj in range(0, 7):
for kk in range(jj + 1, 7):
clauses.append([int("-" + ii_index + str(jj)), int("-" + ii_index + str(kk))])
# define interactions between pipes in adjacent cells
sat_helper(game, 0, 0)
g = Glucose4()
[g.add_clause(elem) for elem in clauses]
g.solve()
try:
solution = g.get_model()
pos_sol = []
for elem in solution:
if elem >= 0:
pos_sol.append(elem)
parse_solution(game, pos_sol)
except TypeError as e:
print("No solution found via sat")
return game
def reset_oracle():
global oracle
oracle.delete()
oracle = Glucose4(bootstrap_with=clauses)
import sys
from pysat.formula import CNF
from pysat.solvers import Glucose4
import copy
iteration = 0
instance = sys.argv[1]
all = bool(int(sys.argv[2]))
clauses = CNF(from_file=instance).clauses
model_clauses = list()
disabled_models = set()
oracle = Glucose4()
minimal_models = list()
def disable_model(clauselist, model, global_disable=False):
#print("disabling found model")
l = list()
for lit in model:
if lit > 0:
l.append(-lit)
clauselist.append(l)
if global_disable:
disabled_models.add(tuple(i for i in model))
def disable_model_in_solver(clauselist, model, global_disable=False):
def solve_problem(input):
state_set = {('H', -1), ('S', 0), ('S', 1), ('S', 2), ('Q', 0), ('Q', 1),
('I', -1), ('U', -1)}
agent_actions = {
'P': {'P' + str(j)
for j in range(input["police"])},
'M': {'M' + str(i)
for i in range(input["medics"])}
}
literal_set = set()
clause_list = []
prev_agent_literals = {'P': [], 'M': []}
for time, obs in enumerate(input["observations"]):
curr_agent_literals = {'P': [], 'M': []}
for row_idx in range(len(obs)):
for col_idx in range(len(obs[row_idx])):
state = obs[row_idx][col_idx]
if time == 0:
literal_set, clause_list = add_initial_obs_literals(
state, row_idx, col_idx, state_set, literal_set,
clause_list)
if time == len(input["observations"]) - 1:
continue
literal_set, clause_list, agent_literals = add_agent_actions(
time, row_idx, col_idx, agent_actions, literal_set,
clause_list)
for key_act in agent_literals.keys():
curr_agent_literals[key_act] = curr_agent_literals[
key_act] + agent_literals[key_act]
literal_set, clause_list, infect_literal = add_infect_action(
row_idx, col_idx, time, len(obs), len(obs[row_idx]),
literal_set, clause_list)
clause_list = add_action_conflicts(agent_literals,
infect_literal,
clause_list)
clause_list = add_frame_effects(row_idx, col_idx, time,
infect_literal,
agent_literals, state_set,
clause_list)
elif time < len(input["observations"]) - 1:
literal_set, clause_list = add_advanced_obs_literals(
state, row_idx, col_idx, time, state_set, literal_set,
clause_list)
clause_list = add_agent_dependencies(
row_idx, col_idx, time, prev_agent_literals,
agent_actions, clause_list)
literal_set, clause_list, agent_literals = add_agent_actions(
time, row_idx, col_idx, agent_actions, literal_set,
clause_list)
for key_act in agent_literals.keys():
curr_agent_literals[key_act] = curr_agent_literals[
key_act] + agent_literals[key_act]
literal_set, clause_list, infect_literal = add_infect_action(
row_idx, col_idx, time, len(obs), len(obs[row_idx]),
literal_set, clause_list)
clause_list = add_action_conflicts(agent_literals,
infect_literal,
clause_list)
clause_list = add_frame_effects(row_idx, col_idx, time,
infect_literal,
agent_literals, state_set,
clause_list)
else:
literal_set, clause_list = add_advanced_obs_literals(
state, row_idx, col_idx, time, state_set, literal_set,
clause_list)
clause_list = add_agent_dependencies(
row_idx, col_idx, time, prev_agent_literals,
agent_actions, clause_list)
literal_set, clause_list = add_general_sick(
row_idx, col_idx, time, literal_set, clause_list)
clause_list = add_agent_conflicts(agent_actions, curr_agent_literals,
clause_list)
prev_agent_literals = curr_agent_literals
literal_dict = {}
for num, literal in enumerate(literal_set):
literal_dict[literal] = num + 1
coded_clause_list = []
for clause in clause_list:
coded_clause = []
for literal, sign in clause:
if sign:
coded_clause.append(literal_dict[literal])
else:
coded_clause.append(-literal_dict[literal])
coded_clause_list.append(coded_clause)
results = {}
for query in input["queries"]:
new_clause_false = coded_clause_list.copy()
true_clause = []
if query[2] == 'S':
for i in range(3):
time_literal = (query[0], query[1], ('S', i))
true_clause.append(literal_dict[time_literal])
new_clause_false.append([-literal_dict[time_literal]])
new_clause_true = coded_clause_list + [true_clause]
elif query[2] == 'Q':
for i in range(2):
time_literal = (query[0], query[1], ('Q', i))
true_clause.append(literal_dict[time_literal])
new_clause_false.append([-literal_dict[time_literal]])
new_clause_true = coded_clause_list + [true_clause]
else:
literal = (query[0], query[1], (query[2], -1))
new_clause_true = coded_clause_list + [[literal_dict[literal]]]
new_clause_false = coded_clause_list + [[-literal_dict[literal]]]
glucose4_true = Glucose4(bootstrap_with=new_clause_true)
glucose4_false = Glucose4(bootstrap_with=new_clause_false)
result_true = glucose4_true.solve()
result_false = glucose4_false.solve()
if result_true and result_false:
results[query] = '?'
elif not result_true and result_false:
results[query] = 'F'
elif result_true and not result_false:
results[query] = 'T'
else:
print(query, 'Knowledge base is wrong - return empty results')
return results
return results
def solve_formula(formula):
g = Glucose4(with_proof=True)
g.append_formula(formula)
return g.solve()
