def Compute_Sat(KB, facts, print_info):
"""Prints symbols, propositions, and additional information from a knowledge base,
then runs a DPLL satisfiability search and prints the result"""
# Create new KB initialized from current KB and extra facts
new_KB = KB[:]
for fact in facts:
if fact not in KB:
new_KB.append(fact)
symbols = find_symbols(new_KB) # Collect list of symbols
model = {} # Initialize model to 'None' for each symbol
for symbol in symbols:
model[symbol] = None
print("Props:") # Print propositional symbols
for symbol in symbols:
print(symbol, end=' ')
print("\nInitial clauses:") # Print original KB
i = 0
for clause in KB:
print(str(i) + ": " + format_clause(clause))
i += 1
if facts:
print("Additional facts:") # Print additional facts
for fact in facts:
print(str(i) + ": " + format_clause(fact))
i += 1
print("-----------")
model = DPLL(new_KB, symbols, model,
print_info) # Satisfiability computation
if model: # If the model was populated
print("KB and additional facts can be satisfied with the given model")
print(model)
print("-----------")
print("True props:")
for assignment in model:
if model[assignment]:
print(assignment)
else: # If no solution was returned
print("There is no solution given the current KB and additional facts")
notdisp = [
letra(i) for i in range(1, 21) if i not in disponibilidad_professor2
]
addrule = '(' + letra(42) + '>' + friendly_multiNEGAND(notdisp) + ')'
Rules = '(' + Rules + 'Y' + addrule + ')'
#same for A2
notdisp = [
letra(i + 20) for i in range(1, 21)
if i not in disponibilidad_professor2
]
addrule = '(' + letra(44) + '>' + friendly_multiNEGAND(notdisp) + ')'
Rules = '(' + Rules + 'Y' + addrule + ')'
clausal = formaClausal(Tseitin(Rules, letras))
satisfacible, solucion = DPLL(clausal, {})
solucion_filter = {}
for i in solucion.keys():
if i in letras:
solucion_filter[i] = solucion[i]
decoded = {}
for i in solucion_filter.keys():
decoded[inverse_letra(i)] = solucion_filter[i]
print(satisfacible, decoded)
export_horario(decoded, professor1, professor2, signature1, signature2,
filename)
###############################################################################
#Verificamos que las reglas estén bien escritas
print(
"------------------------Regla_1-----------------------------------------")
print(regla1)
#print(tuplas(regla1,letras))
print(
"------------------------Regla_2-----------------------------------------")
print(regla2)
#print(tuplas(regla2,letras))
print(
"------------------------Regla_3-----------------------------------------")
print(regla3)
#print(tuplas(regla3,letras))
print(
"------------------------Regla_4-----------------------------------------")
print(regla4)
#print(tuplas(regla4,letras))
lista_solucion = [letras[0], regla1, regla2, regla3, regla4]
solucion = conjuncion(lista_solucion)
tseitin = Tseitin(solucion, letras)
fc = formaClausal(tseitin)
dpll = DPLL(fc, {})
interp = {}
for i in dpll[1]:
if i in letras:
interp[i] = dpll[1][i]
print(interp)
if __name__ == '__main__':
R1 = subregla1NC(Nf, Nc, No)
R2 = sub_regla2NC(Nf, Nc, No)
RF = regla_final(R1, R2)
TRF = str(RF)
#se pasa por Tseitin para que genere una formula equisatisfacible mas sencilla que TRF (regla oficial)
teis = fn.Tseitin(TRF, letrasProposicionales)
#pasando a forma clausal
hk = fn.formaClausal(teis)
#se ingresa al DPLL (este genera una interpretacion para la formula de Tseitin, pero se sabe que dicha interpretacion tambien
#es modelo de TRF)
S, I = dp.DPLL(hk, {})
#ii es una lista con las letras proposicionales de la interpretacion I
ii = list(I.keys())
I2 = {}
#este ciclo selecciona todas las letrasproposicionales que estan en letras(lista original con codificacion) y crea un nuevo diccionario
#I2 donde se guardan solo esas letras que son las de interes.
for j in ii:
if j in letrasProposicionales:
if I[j] == 1:
I2[j] = 1
else:
I2[j] = 0
#print(len(I2))
# aqui se imprime la interpretacion que encuentra el programa, es decir una solucion al problema
print(I2)
from DPLL import DPLL
import time
from plot_tools import n_queens_plotter
from nqueens import n_queens
import os
solver = DPLL()
# # test capacity of solver
# for n in range(1,100):
# print("n is: ", n)
# if not os.path.isfile("/Users/Chelsea/scratch/n_queens_"+str(n)+".txt"):
# n_queens(n).encode("/Users/Chelsea/scratch")
# t = time.time()
# solver.run_solver("/Users/Chelsea/scratch/n_queens_"+str(n)+".txt", testing=False)
# dt = time.time() - t
# print("dt: ", dt, " seconds, aka ", dt/60, " minutes.")
# print("counter: ", solver.counter)
# print("decisions: ", solver.dec_counter)
# if dt/60 > 5:
# break
n = 5
n_queens(n).encode("/Users/Chelsea/scratch")
solver.run_solver("/Users/Chelsea/scratch/n_queens_" + str(n) + ".txt",
testing=False)
n_queens_plotter(solver.nvars, solver.model).plot()
import sys
from SAT import SAT
if __name__ == "__main__":
# for testing, always initialize the pseudorandom number generator to output the same sequence
# of values:
random.seed(1)
sudoku_problem = Sudoku(int(sys.argv[3]) == 1)
sudoku_problem.load(sys.argv[1])
puzzle_name = str(sys.argv[1][:-4])
cnf_filename = "cnfs/{}.cnf".format(puzzle_name)
sol_filename = puzzle_name + ".sol"
sudoku_problem.generate_cnf(cnf_filename)
if int(sys.argv[2]) == 1:
solver = SAT(cnf_filename)
result = solver.gsat()
elif int(sys.argv[2]) == 2:
solver = SAT(cnf_filename)
result = solver.walksat()
else:
solver = DPLL(cnf_filename)
result = solver.dpll_satisfiable()
if result:
solver.write_solution(sol_filename)
display_sudoku_solution(sol_filename)
# print(REGLAFINAL) # Polaca Inversa
arbol = string2Tree(REGLAFINAL, letras, nums)
formula = InOrder(arbol)
# print(formula) # Forma Comun
# print("".join(formula))
###############################################################################
# Solucion al problema
FNC, cont = Tseitin(formula, letrasTs)
# print(FNC)
print()
print("Letras de Tseitin: ", cont)
# FNCSN = withoutDN(FNC)
# print(FNCSN)
FC = formaClausal(FNC)
# print(FC)
inter = {}
respuesta, interpretacion = DPLL(FC, inter)
print()
print("Tablero 3x3: ")
print()
print("La formula es: ", respuesta)
print("Su interpretación es: ", interpretacion)
print("Por lo tanto este problema no tiene solución. ")
###############################################################################
B = cnf.deMorgan(A)
B = cnf.quitarDobleNegacion(B)
aux2 = cnf.Inorder(B)
if aux1 != aux2:
OK = True
A = B
else:
OK = False
OK = True
while OK:
OK, A = cnf.aplicaDistributiva(A)
conjuntoClausulas = cnf.formaClausal(A)
clausulas.append(conjuntoClausulas)
k = clausulas[0]
o = DPLL(k, {})
U, L = o.DO_DPLL()
print "Satisfacible?"
print U
print "Interpretacion:"
print L
lista = []
for i in L:
if L[i] == False:
h = '-' + i
lista.append(h)
else:
lista.append(i)
if U == 'satisfacible':
from display import display_sudoku_solution
import random, sys
from DPLL import DPLL
if __name__ == "__main__":
# for testing, always initialize the pseudorandom number generator to output the same sequence
# of values:
#random.seed(2)
seed = 2
random.seed(seed)
thresh = .7
#seed 8 thresh .6? puzz 1 - a mil iterations w no luck
puzzle_name = str(sys.argv[1][:-4])
sol_filename = puzzle_name + ".sol"
dpll = DPLL(sys.argv[1], 729, var_start=110)
print("Seed: " + str(seed))
result = dpll.init_dpll()
print("Seed: " + str(seed))
if result:
dpll.write_solution(sol_filename)
display_sudoku_solution(sol_filename)
else:
print("Oh no bb what is u doin'")
