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()