def test_CustomGraphOneTwoCollors(self):
solver = SAT_solver()
graph = [[0, 1, 1, 1, 1], [1, 0, 1, 1, 0], [1, 1, 0, 1, 0], [1, 1, 1, 0, 1], [1, 0, 0, 1, 0]]
colors = 2
formula = graph_coloring(graph, colors)
solution = solver.solve(formula)
self.assertFalse(solution[0])
def test_completeGraphTwoCollors(self):
solver = SAT_solver()
graph = [[1, 1, 1], [1, 1, 1], [1, 1, 1]]
colors = 2
formula = graph_coloring(graph, colors)
solution = solver.solve(formula)
self.assertFalse(solution[0])
def test_CustomGraphOneFourCollors(self):
solver = SAT_solver()
graph = [[0, 1, 1, 1, 1], [1, 0, 1, 1, 0], [1, 1, 0, 1, 0], [1, 1, 1, 0, 1], [1, 0, 0, 1, 0]]
colors = 4
formula = graph_coloring(graph, colors)
solution = solver.solve(formula)
self.assertTrue(solution[0])
self.assertEqual("true", formula.nnf().cnf().evaluate(solution[1]).__class__.__name__)
def test_completeGraphThreeCollors(self):
solver = SAT_solver()
graph = [[1, 1, 1], [1, 1, 1], [1, 1, 1]]
colors = 3
formula = graph_coloring(graph, colors)
solution = solver.solve(formula)
self.assertTrue(solution[0])
self.assertEqual("true", formula.nnf().cnf().evaluate(solution[1]).__class__.__name__)
def test_OddCicleGraphTwoCollors(self):
solver = SAT_solver()
graph = [
[0, 1, 1],
[1, 0, 1],
[1, 1, 0],
]
colors = 2
formula = graph_coloring(graph, colors)
solution = solver.solve(FlatCNF(formula))
self.assertFalse(solution[0])
def test_EvenCicleGraphTwoCollors(self):
solver = SAT_solver()
graph = [
[0, 1, 0, 1],
[1, 0, 1, 0],
[0, 1, 0, 1],
[1, 0, 1, 0],
]
colors = 2
formula = graph_coloring(graph, colors)
solution = solver.solve(FlatCNF(formula))
self.assertTrue(solution[0])
self.assertEqual("true", formula.nnf().cnf().evaluate(solution[1]).__class__.__name__)
def test_SudokuCustom(self):
solver = SAT_solver()
board=[[4, 8, None, 1, 6, None, None, None, 7],
[1, None, 7, 4, None, 3, 6, None, None],
[3, None, None, 5, None, None, 4, 2, None],
[None, 9, None, None, 3, 2, 7, None, 4],
[None, None, None, None, None, None, None, None, None],
[2, None, 4, 8, 1, None, None, 6, None],
[None, 4, 1, None, None, 8, None, None, 6],
[None, None, 6, 7, None, 1, 9, None, 3],
[7, None, None, None, 9, 6, None, 4, None]]
formula = sudoku(board)
solution = solver.solve(formula,True)
self.assertTrue(solution[0])
self.assertEqual("true", formula.nnf().cnf().evaluate(solution[1]).__class__.__name__)
def test_SudokuMedium(self):
solver = SAT_solver()
board=[[None, None, 9, None, 6, 4, None, None, 1],
[None, None, None, None, 5, None, None, None, None],
[4, 6, None, 1, None, 7, None, None, 8],
[None, None, None, None, None, None, None, 9, None],
[None, None, None, None, 3, None, None, 1, None],
[3, None, None, None, None, None, None, 4, None],
[None, 4, 8, None, None, None, 2, None, None],
[2, None, 7, None, 4, 5, None, 8, 6],
[5, None, None, None, None, None, None, None, None]]
formula = sudoku(board)
solution = solver.solve(FlatCNF(formula))
self.assertTrue(solution[0])
self.assertEqual("true", formula.nnf().cnf().evaluate(solution[1]).__class__.__name__)
def test_SudokuEasy(self):
solver = SAT_solver()
board=[[None, None, None, 4, None, None, None, 5, None],
[None, None, None, None, 1, None, 3, 6, None],
[None, None, 8, None, None, 6, 9, 4, 7],
[1, None, 2, None, None, None, None, 9, 5],
[None, 9, None, 2, None, 1, None, None, None],
[None, None, None, 5, 9, 3, None, None, None],
[4, None, None, None, None, None, 1, 7, 9],
[7, 2, None, 1, None, None, None, None, None],
[None, 8, None, None, None, 9, None, 2, None]]
formula = sudoku(board)
solution = solver.solve(FlatCNF(formula))
self.assertTrue(solution[0])
self.assertEqual("true", formula.nnf().cnf().evaluate(solution[1]).__class__.__name__)
[None, None, None, None, None, None, None, None, None],
[2, None, 4, 8, 1, None, None, 6, None],
[None, 4, 1, None, None, 8, None, None, 6],
[None, None, 6, 7, None, 1, 9, None, 3],
[7, None, None, None, 9, 6, None, 4, None],
]
# print sudoku from board definition.
print "Lab exercise:"
print printSudoku(board)
# construct logical formula from board definition.
formula = sudoku(board)
# solve formula using SAT solver(singlethreaded)
result = solver.solve(formula)
print "Solution:"
# process and print result of sat solver.
print printSudoku(processResult(result[1]))
medium_board = [
[None, None, 5, None, 6, 3, 1, 2, None],
[None, None, 9, None, None, 1, None, 5, None],
[1, None, None, None, None, 8, 9, None, 6],
[None, None, None, None, 5, None, 8, None, 2],
[None, 5, None, None, None, None, None, 1, None],
[6, None, 1, None, 9, None, None, None, None],
[9, None, 6, 2, None, None, None, None, 1],
[None, 1, None, 6, None, None, 4, None, None],
[None, 4, 7, 3, 1, None, 2, None, None],
def test_contradiction(self):
solver = SAT_solver()
formula = And([Var("A"), Not(Var("A"))])
result = solver.solve(formula)
self.assertFalse(result[0])
def test_Or(self):
solver = SAT_solver()
formula = Or([Var("A"), Var("B")])
result = solver.solve(formula)
self.assertTrue(result[0])
self.assertEqual("true", formula.nnf().cnf().evaluate(result[1]).__class__.__name__)
def test_variableNegation(self):
solver = SAT_solver()
formula = Not(Var("A"))
result = solver.solve(formula)
self.assertTrue(result[0])
self.assertEqual("true", formula.nnf().cnf().evaluate(result[1]).__class__.__name__)
def test_false(self):
solver = SAT_solver()
self.assertFalse(solver.solve(false())[0])
def test_true(self):
solver = SAT_solver()
self.assertTrue(solver.solve(true())[0])
#graph represented with adjacency matrix
graph = [
[1, 1, 1],
[1, 1, 1],
[1, 1, 1],
]
#number of colors for graph coloring
colors = 3
#construct formula for certain graph and number of colors
formula = graph_coloring(graph, colors)
#solve formula
solution = solver.solve(formula)
#solve2 formula
solution2 = solver.solve(formula,True)
#flatcnf solution
solution3 = solver.solve(FlatCNF(formula))
print "Graph (" + str(colors) + " colors):"
print printGraph(graph)
print "SAT"
if solution[0]:
print processResult(solution[1])
else:
print "================================================="
print "Testing deduplicate method."
print "================================================="
dedupexpr = And([ Or([Var("x1"), Var("x2")]) ])
print "Expession: " + unicode(dedupexpr) + " -> " + unicode(dedupexpr.deduplicate())
dedupexpr = And([ Or([Var("x1"), Var("x1")]) ])
print "Expession: " + unicode(dedupexpr) + " -> " + unicode(dedupexpr.deduplicate())
print "================================================="
print "================================================="
print "SAT Solver Testing"
print "================================================="
solver = SAT_solver()
for i in globals().keys():
if i[:4] == "expr":
print i, ":", unicode(globals()[i]), "->", solver.solve(globals()[i])
print unicode(true()), "->", solver.solve(true())
print "================================================="
print "sudoku"
board=[[4, 8, None, 1, 6, None, None, None, 7],
[1, None, 7, 4, None, 3, 6, None, None],
[3, None, None, 5, None, None, 4, 2, None],
[None, 9, None, None, 3, 2, 7, None, 4],
[None, None, None, None, None, None, None, None, None],
[2, None, 4, 8, 1, None, None, 6, None],
[None, 4, 1, None, None, 8, None, None, 6],
[None, None, 6, 7, None, 1, 9, None, 3],
[7, None, None, None, 9, 6, None, 4, None]]
def test_variable(self):
solver = SAT_solver()
formula = Var("A")
result = solver.solve(FlatCNF(formula))
self.assertTrue(result[0])
self.assertEqual("true", formula.nnf().cnf().evaluate(result[1]).__class__.__name__)
def test_false(self):
solver = SAT_solver()
self.assertFalse(solver.solve(FlatCNF(false()))[0],True)
def test_true(self):
solver = SAT_solver()
self.assertTrue(solver.solve(FlatCNF(true()))[0],True)
#
#==========================================
# SAT solver
#==========================================
# argument - formula
# returns - (boolean value, dictionary)
# - value indicates if formula is satisfiable.
# - dictionary represents mapping of variables.
#==========================================
print "================================================="
print "SAT Solver"
print "================================================="
solver = SAT_solver()
for i in globals().keys():
if i[:4] == "expr":
print i, ":", unicode(globals()[i]), "->", solver.solve(globals()[i])
print "================================================="
print "SAT Solver - mt"
print "================================================="
solver = SAT_solver()
for i in globals().keys():
if i[:4] == "expr":
print i, ":", unicode(globals()[i]), "->", solver.solve(globals()[i],True)
print "================================================="
print "SAT Solver - multiprocess"
print "================================================="
solver = SAT_solver()
for i in globals().keys():
[None, 9, None, None, 3, 2, 7, None, 4],
[None, None, None, None, None, None, None, None, None],
[2, None, 4, 8, 1, None, None, 6, None],
[None, 4, 1, None, None, 8, None, None, 6],
[None, None, 6, 7, None, 1, 9, None, 3],
[7, None, None, None, 9, 6, None, 4, None]]
# print sudoku from board definition.
print "Lab exercise:"
print printSudoku(board)
# construct logical formula from board definition.
formula = sudoku(board)
# solve formula using SAT solver(singlethreaded)
result = solver.solve(FlatCNF(formula))
print "Solution:"
# process and print result of sat solver.
print printSudoku(processResult(result[1]))
medium_board = [[None, None, 5, None, 6, 3, 1, 2, None],
[None, None, 9, None, None, 1, None, 5, None],
[1, None, None, None, None, 8, 9, None, 6],
[None, None, None, None, 5, None, 8, None, 2],
[None, 5, None, None, None, None, None, 1, None],
[6, None, 1, None, 9, None, None, None, None],
[9, None, 6, 2, None, None, None, None, 1],
[None, 1, None, 6, None, None, 4, None, None],
[None, 4, 7, 3, 1, None, 2, None, None]]
