def answer_query(query, base_clause, var_to_int_dict): cell, t, state = query i, j = cell clause_for_curr_q = [] # add to base_clause: # x_{i,j,t,state} and x'_{i,j,t,C} for every other C (other than state). clause_for_curr_q.append(var_to_int_dict[(i, j, t, state)]) for state2 in {"S", "H", "I", "Q", "U"}: if state2 != state: clause_for_curr_q.append(-var_to_int_dict[(i, j, t, state2)]) # Solving the SAT folrmula and check if satisfiyable. g1 = Glucose3() if not g1.solve(base_clause + clause_for_curr_q): return "F" # here if the assumption of the query is optional, we want to check if more than one is possible for other_state in {"S", "I", "Q", "U", "H"}: clause_for_curr_state = [] if other_state != state: clause_for_curr_state.append(var_to_int_dict[(i, j, t, other_state)]) for state2 in {"S", "H", "I", "Q", "U"}: if state2 != other_state: clause_for_curr_state.append(-var_to_int_dict[(i, j, t, state2)]) g2 = Glucose3() if g2.solve(base_clause + clause_for_curr_state): return "?" return "T"
def no_police_and_medics(input): # answer the query if there are not medics and there are not police police_num, med_num, observations = input['police'], input[ 'medics'], input['observations'] queries = input['queries'] total_observations = len(observations) solver = [] counter = 1 for i in range(total_observations): counter = add_observation(observations[i], solver, counter) find_firstSicks(observations[0], solver, total_observations) for i in range(total_observations): spread_disease(observations[i], solver, i + 1, total_observations) answers = {} for query in queries: indexes = ['U', 'H', 'S'] values = [] gs = [] g1 = Glucose3() g2 = Glucose3() g3 = Glucose3() update_solver(g1, solver) update_solver(g2, solver) update_solver(g3, solver) gs.append(g1) gs.append(g2) gs.append(g3) for i in range(3): updates = [] check_unknown(observations[query[1]], updates, query[0][0], query[0][1], query[1], total_observations, indexes[i]) update_solver(gs[i], updates) values.append(gs[i].solve()) if query[2] == 'U': if not values[0]: answers[query] = 'F' elif values[1] or values[2]: answers[query] = '?' else: answers[query] = 'T' if query[2] == 'H': if not values[1]: answers[query] = 'F' elif values[0] or values[2]: answers[query] = '?' else: answers[query] = 'T' if query[2] == 'S': if not values[2]: answers[query] = 'F' elif values[0] or values[1]: answers[query] = '?' else: answers[query] = 'T' return answers
def get_pos_SR(min_variable_number, max_variable_number, clause_number): variable_number = random.randint(min_variable_number, max_variable_number) clauses = [] solver = Glucose3() while solver.solve(): clause = get_SR(variable_number) solver.add_clause(clause) clauses.append(clause) if len(clauses) > clause_number: clauses = [] solver.delete() solver = Glucose3() clauses = clauses[:-1] return CNF(clauses)
def solve_problem(input_problem): """ init of variables """ g = Glucose3() num_police = input_problem["police"] num_medics = input_problem["medics"] num_observations = len(input_problem["observations"]) num_rows = len(input_problem["observations"][0]) num_columns = len(input_problem["observations"][0][0]) queries = input_problem["queries"] observations = input_problem["observations"] """ create 5 matrix of each status """ h_matrix = np.zeros((num_observations, num_rows, num_columns), dtype=int) s_matrix = np.zeros((num_observations, num_rows, num_columns), dtype=int) q_matrix = np.zeros((num_observations, num_rows, num_columns), dtype=int) i_matrix = np.zeros((num_observations, num_rows, num_columns), dtype=int) u_matrix = np.zeros((num_observations, num_rows, num_columns), dtype=int) """ actions for solving """ atom_num = create_atoms(g, observations, num_rows, num_columns, h_matrix, s_matrix, q_matrix, i_matrix, u_matrix) actions_clauses(g, atom_num, observations, num_rows, num_columns, h_matrix, s_matrix, q_matrix, i_matrix, u_matrix, num_police, num_medics) return_dict = query_solve(g, queries, h_matrix, s_matrix, q_matrix, i_matrix, u_matrix) return return_dict
def is_compatible_pb(comb, base): cnf = "" total = 0 all_clauses = [] con_ind = 0 for con in base + [comb]: con_ind += 1 rhs = -1 all_eq = [] for elem_ind in range(len(con)): elem = con[elem_ind] if elem != 0: for bit in range(1, 8): all_eq.append( pblib.WeightedLit(int("{}{}".format(elem_ind, bit)), 2**(bit - 1) * -elem)) constr = pblib.PBConstraint(all_eq, pblib.LEQ, rhs) aux_var = pblib.AuxVarManager(10000 * con_ind) config = pblib.PBConfig() formula = pblib.VectorClauseDatabase(config) pb2cnf = pblib.Pb2cnf(config) pb2cnf.encode(constr, formula, aux_var) clauses = formula.get_clauses() all_clauses += clauses g = Glucose3() for c in all_clauses: g.add_clause(c) sol = g.solve() return sol
def execute(self, model: PySATModel) -> 'Glucose3Valid': glucose = Glucose3() for clause in model.cnf: # AC es conjunto de conjuntos glucose.add_clause(clause) # aƱadimos la constraint self.result = glucose.solve() glucose.delete() return self
def solver_glucose(sat): g = Glucose3() for clause in sat: g.add_clause(clause) return g.solve()
def csptosat(A, B, initialL=None): newSignature = {} L, newSignature = ac3(A, B, initialL, newSignature, True) if L == None: return None print('Starting glucose') g = Glucose3() cntPrimaryVariables, table = buildSATInstance(g, A, B, L, newSignature) print('instance built', cntPrimaryVariables, 'variables') if g.solve(): print('solved') sol = g.get_model() h = {} for i in range(cntPrimaryVariables): if sol[i] > 0: (a, b) = table[i] h[a] = b g.delete() else: h = None g.delete() return h
def satisfiable(self): solver = Glucose3() for clause in self.clauses: solver.add_clause(clause) result = solver.solve() solver.delete() return result
def solve_CNF(clauses): global calls calls += 1 solver = Glucose3(bootstrap_with=clauses) res = solver.solve() solver.delete() return res
def performance(output, my_method): test_predict = [] run_time = [] for i in range(1, 156): A = read_DIMACS_CNF(f'tests/test_{i}.txt') if my_method: start = time.time() answer = DPPL(A) end = time.time() write_solution(answer, f'tests/test_{i}_my_solution.txt', my_method) else: glucose = Glucose3() for clause in A: glucose.add_clause(list(clause)) start = time.time() answer = glucose.solve() end = time.time() answer = answer if answer is False else glucose.get_model() write_solution(answer, f'tests/test_{i}_glucose3_solution.txt', my_method) test_predict += [0] if answer is False else [1] run_time.append((end - start) * 1000.0) hit_rate = [x == y for x, y in zip(output, test_predict) ].count(True) / len(output) mean_run_time = sum(run_time) / len(run_time) return hit_rate, mean_run_time
def get_product(self, model, transform): g = Glucose3() for clause in transform.destination_model.r_cnf: g.add_clause(clause) for clause in transform.destination_model.ctc_cnf: g.add_clause(clause) product = dict() for solution in g.enum_models(): model_features = model.get_features() for variable in solution: if variable > 0: name = transform.destination_model.features.get(variable) for feature in model_features: if feature.name == name: product[feature] = True else: name = transform.destination_model.features.get(variable) for feature in model_features: if feature.name == name: product[feature] = False break configuration = Configuration(product) return configuration
def execute(self, model: PySATModel) -> 'Glucose3ValidProduct': glucose = Glucose3() for clause in model.get_all_clauses(): # AC es conjunto de conjuntos glucose.add_clause(clause) # aƱadimos la constraint assumptions = [] config: list[str] = [] if self.configuration is not None: config = [feat.name for feat in self.configuration.elements] for feat in config: if feat not in model.variables.keys(): self.result = False return self for feat in model.features.values(): if feat in config: assumptions.append(model.variables[feat]) else: assumptions.append(-model.variables[feat]) self.result = glucose.solve(assumptions=assumptions) glucose.delete() return self
def __init__(self) -> None: """ Initializes a ClassScheduler object. """ self.var_count = 0 self.class_ref = {} self.section_ref = {} self.solver = Glucose3() self.going = False with open('classes.csv', encoding='utf-8-sig') as classes_file: classes_list = [line.split(',') for line in classes_file] for class_desc in classes_list: class_temp = ClassData(class_desc[0], class_desc[1], class_desc[2][:-1]) self.class_ref[class_temp.subject + " " + class_temp.class_id] = class_temp with open('sections.csv', encoding='utf-8-sig') as sections_file: sections_list = [line.split(',') for line in sections_file] for sections_desc in sections_list: section_temp = Section( int(sections_desc[0]), sections_desc[2] + " " + sections_desc[1], int(sections_desc[3][:-1])) self.section_ref[section_temp.section_id] = section_temp self.var_count += 1 print("Use help() for help operating the scheduler")
def lat_square_sat(mat): g = Glucose3() assumption = [] size = len(mat) for x in range(size): for y in range(size): val = mat[x][y] for z in range(size): var1 = construct_var(x, y, z) if val == 0: continue if val == z + 1: assumption.append(var1) else: assumption.append(-var1) for a in range(size - 1): var1 = construct_var(a, x, y) var3 = construct_var(x, a, y) for b in range(a + 1, size): clause1 = [] clause2 = [] var2 = construct_var(b, x, y) var4 = construct_var(x, b, y) clause1.append(-var1) clause1.append(-var2) clause2.append(-var3) clause2.append(-var4) g.add_clause(clause1) g.add_clause(clause2) return g.solve(assumptions=assumption)
def isConsistent(AC): global count count=count+1 g = Glucose3() for clause in AC: g.add_clause(clause) return g.solve()
def addClausestoSATSolver(inputFilename): solver = Glucose3() try: reader = open(inputFilename, "r") clauses = reader.readlines() i = 0 clausesSAT = [] for clause in clauses: if i == 0: pass else: cleanClause = clause.strip("\n") cleanClause = clause.strip() arClause = cleanClause.split(" ") finalClause = [] for var in arClause: finalClause.append(int(var)) clausesSAT.append(finalClause) i += 1 for clause in clausesSAT: solver.add_clause(clause) return (solver.solve(), solver.get_model()) # print(solver.solve()) # print(solver.get_model()) finally: reader.close()
def check_assignment(self): # check whether there is a satisfying assignment to the classifier. g = Glucose3() for clause in self.classifier: g.add_clause(clause) print("is SAT? ", g.solve()) print("assignment: ", g.get_model())
def solveCNF(clauses): g = Glucose3() for it in clauses: g.add_clause(it) sol = g.solve() if sol: return True, g.get_model() return False, None
def execute(self, model: PySATModel) -> 'Glucose3ProductsNumber': glucose = Glucose3() for clause in model.get_all_clauses(): # AC es conjunto de conjuntos glucose.add_clause(clause) # aƱadimos la constraint for _ in glucose.enum_models(): self.products_number += 1 glucose.delete() return self
def solve(self, size): self.size = size solver = Glucose3() self.build_cnf(solver) if solver.solve(): self.build_matrix(solver.get_model()) else: print("Not Satisfiable")
def mainTest(formulas): clauseForSolver = [] for i in formulas: clauseForSolver.append(get_clause_for_solver(i[0],i[1])) toSolve = list(itertools.chain.from_iterable(clauseForSolver)) print(toSolve) with Glucose3(bootstrap_with=toSolve) as g: for m in g.enum_models(): print(m)
def main(): ag = Agent() g = Glucose3() ##################################### # Add Knowledge Base to clauses for elem in KB: g.add_clause(elem) ##################################### finalpath = [] safe = [] unvisited=copy.deepcopy(grid) while(1): unvisited.remove(ag.FindCurrentLocation()) ##################################### x,y = ag.FindCurrentLocation() if(ag.FindCurrentLocation()==[4,4]): finalpath.append(ag.FindCurrentLocation()) print(finalpath) break # If percept return =0, then the cells adjacent have to be clear. So current cell is safe: add 6xy to KB if(ag.PerceiveCurrentLocation()=='=0'): temp = 600 + (10*x) + y # If percept return >=1, then mines are present: add -6xy to KB else: temp = -1*(600 + (10*x) + y) # If percept returns =1, then only one of the adjacent cells has a mine: add 1xy to KB alongside -6xy if(ag.PerceiveCurrentLocation()=='=1'): extra = 100 + (10*x) + y else: extra = 500 + (10*x) + y g.add_clause([extra]) g.add_clause([temp]) ##################################### findallsafe(grid, safe, g) # Try to reach goal cell path = astar(ag.FindCurrentLocation(),[[4,4]],safe, g) # If no path to the goal exists, find a path to the closest unvisited node that is safe. if path == None: goals = [i for i in unvisited if i in safe] path = astar(ag.FindCurrentLocation(),goals,safe, g) while(len(path)>0): x,y = ag.FindCurrentLocation() finalpath.append([x,y]) elem = path.pop(0) v=[elem.pos[0]-x, elem.pos[1]-y] index = validmoves.index(v) if index==0: ag.TakeAction('Up') elif index==1: ag.TakeAction('Down') elif index==2: ag.TakeAction('Left') elif index==3: ag.TakeAction('Right')
def solve_problem(input): no_police = input["police"] no_medics = input["medics"] observations = input["observations"] no_rounds = len(observations) n = len(observations[0]) m = len(observations[0][0]) indices_list = [(i, j) for i in range(n) for j in range(m)] queries = input["queries"] state_codes = ['U', 'H', 'S'] actions_codes = [ 'infected_left', 'infected_right', 'infected_down', 'infected_up', 'healed' ] if no_medics > 0: state_codes.append('I') actions_codes.append('vaccinate') if no_police > 0: state_codes.append('Q') actions_codes.extend(['quarantine', 'free']) actions_codes.extend(state_codes) decision_variables_p = get_decision_variables_p(state_codes, indices_list, no_rounds) p_to_atom = get_translation_dictionary(decision_variables_p, 2) decision_variables_a = get_decision_variables_a(observations, state_codes, no_police, no_medics, n, m) a_to_atom = get_translation_dictionary(decision_variables_a, len(decision_variables_p) + 2) formula = get_formula(observations, decision_variables_p, p_to_atom, decision_variables_a, a_to_atom, no_police, no_medics, indices_list, state_codes, no_rounds) g = Glucose3(bootstrap_with=formula.clauses) answers = {} for query in queries: if query[2] == 'Q' and (no_police == 0 or query[1] == 0): answer = False elif query[2] == 'I' and (no_medics == 0 or query[1] == 0): answer = False else: answer = g.solve(assumptions=[p_to_atom[query]]) if answer: answer = g.solve(assumptions=[-p_to_atom[query]]) if answer: answers[query] = '?' else: answers[query] = 'T' else: answers[query] = 'F' return answers
def parse_glucose(M, ncolors, path, filename): g = Glucose3() f = open( path+"/"+filename, "w") Vars = np.arange( 1, M.shape[0]*ncolors+1).reshape(M.shape[0], ncolors) #print("nv = {nv}".format(nv=M.shape[0])) for i in range(M.shape[0]): c = list() for j in range(ncolors): c.append( int(Vars[i,j]) ) s = ' '.join(map(str,c)) f.write(s+" 0\n") g.add_clause(c) edges = [ (i1,i2) for i1 in range(M.shape[0]) for i2 in range(i1+1,M.shape[0]) if M[i1,i2] == 1] #print("ne = {ne}".format(ne = len(edges))) #Ensure each edge has its endpoints colored with different colors for _,(i1,i2) in enumerate(edges): for j in range(ncolors): c = [ - int(Vars[i1,j]), - int(Vars[i2,j]) ] s = ' '.join(map(str,c)) f.write(s+" 0\n") g.add_clause( c ) #A given vertex is colored with one color at most for i in range(M.shape[0]): for j in range(ncolors-1): c = [ - int(Vars[i,j]), - int(Vars[i,j+1]) ] s = ' '.join(map(str,c)) f.write(s+" 0\n") g.add_clause( c ) #Symmetry breaking i1,i2 = edges[0] c = [ int(Vars[i1,0]) ] g.add_clause( c ) s = ' '.join(map(str,c)) f.write(s+" 0\n") c = [ int(Vars[i2,1]) ] g.add_clause( c ) s = ' '.join(map(str,c)) f.write(s+" 0\n") f.close() n_clauses = g.nof_clauses() n_vars = g.nof_vars() if "unsat" in path: firstline = "p cnf {n_vars} {n_clauses} 0".format(n_vars=n_vars, n_clauses=n_clauses) else: firstline = "p cnf {n_vars} {n_clauses} 1".format(n_vars=n_vars, n_clauses=n_clauses) line_prepender(path+"/"+filename, firstline)
def solveCNFs(clauses): g = Glucose3() print(type(clauses[0][0])) for it in clauses: g.add_clause(it) ret, result = g.solve(), None if ret: result = g.get_model() return ret, result
def runPySAT_fromFile(self, file): with open(file, 'r') as file: cnf = CNF(from_fp = file) glucose = Glucose3() glucose.append_formula(cnf) if glucose.solve(): return glucose.get_model() else: return False
def runPySAT_fromFormula(self, formula): list_clauses = [] relationAndClauses = self.cnf.formulaToCNFClauses(formula) clauses = list(relationAndClauses.get("clauses")) glucose = Glucose3() for clause in clauses: list_clauses.append(list(clause)) glucose.append_formula(list_clauses) return glucose.solve()
def __init__(self): self.temp_map = Map() self.map = self.temp_map.getMap() self.move = 1 self.shoot = 2 self.pick = 3 self.sur = 4 self.visited = [] self.doing = [] self.list_stench = [] self.wumpus_pos = [] self.climb_out = False self.point = 0 self.agent_pos = self.temp_map.getAgentPos() self.spawn = self.temp_map.getAgentPos() self.DangerFormula = [] #This is the KB of the AI Agent self.wumpus = Glucose3() self.pit = Glucose3() self.size = self.temp_map.getSize() self.makeFormula() #Make the formula before add clause to solve CNF
def infer(self, not_alpha): g = Glucose3() clause_list = copy.deepcopy(self.KB) negative_alpha = not_alpha for it in clause_list: g.add_clause(it) for it in negative_alpha: g.add_clause(it) sol = g.solve() if sol: return False return True