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
