def satisfiable(self, casename):
students, sessions = self.opencase(casename)
formula = lab.boolify_scheduling_problem(copy.deepcopy(students),
copy.deepcopy(sessions))
sched = lab.satisfying_assignment(formula)
self.assertIsNotNone(sched)
unplaced_students = set(students)
for var, val in sched.items():
if val:
student, session = var.split('_')
self.assertIn(
student, unplaced_students,
"Students should be assigned at most one session.")
unplaced_students.remove(student)
self.assertIn(student, students,
"This is not a valid student.")
self.assertIn(session, students[student],
"Student should be assigned a desired session.")
self.assertIn(session, sessions,
"This is not a valid session.")
self.assertTrue(sessions[session] >= 1,
"This session is over-capacity.")
sessions[session] -= 1
self.assertEqual(len(unplaced_students), 0)
def _scheduling_satisfiable(casename):
students, sessions = _open_scheduling_case(casename)
formula = lab.boolify_scheduling_problem(copy.deepcopy(students),
copy.deepcopy(sessions))
sched = lab.satisfying_assignment(formula)
assert sched is not None
unplaced_students = set(students)
for var, val in sched.items():
if val:
student, session = var.split('_')
assert student in unplaced_students, "Students should be assigned at most one session."
unplaced_students.remove(student)
assert student in students, "This is not a valid student."
assert session in sessions, "This is not a valid session."
assert session in students[
student], "Student should be assigned a desired session."
assert sessions[session] >= 1, "This session is over-capacity."
sessions[session] -= 1
assert not unplaced_students, "Some students were not placed into a section!"
def _satisfiable(cnf):
assignment = lab.satisfying_assignment(copy.deepcopy(cnf))
#print ('cnf', cnf)
#print ('assignment', assignment)
assert all(
any(variable in assignment and assignment[variable] == polarity
for variable, polarity in clause) for clause in cnf)
def satisfiable(self, casename):
for cnf in self.opencase(casename):
asgn = lab.satisfying_assignment(copy.deepcopy(cnf))
self.assertIsNotNone(asgn)
# Check that every clause has some literal appearing in the assignment.
self.assertTrue(all(any(variable in asgn and asgn[variable] == polarity
for variable, polarity in clause)
for clause in cnf))
def test_class_example(self):
rules = self.get_rules()
asgn = lab.satisfying_assignment(rules)
print(asgn)
self.assertTrue('tim' in asgn and asgn['tim'] == True)
self.assertTrue(
all(
any(variable in asgn and asgn[variable] == polarity
for variable, polarity in clause) for clause in rules))
def test_schedule(self):
students, sessions = ({'Alice': {'basement', 'penthouse'},
'Bob': {'kitchen'},
'Charles': {'basement', 'kitchen'},
'Dana': {'kitchen', 'penthouse', 'basement'}},
{'basement': 1,
'kitchen': 2,
'penthouse': 4})
cnf = lab.boolify_scheduling_problem(students, sessions)
print(lab.satisfying_assignment(cnf))
def ui_assign(case):
def trim(val, lim=400):
val_str = str(val)
return val_str if len(val_str) < lim else val_str[0:lim] + ' ...'
try:
sat = lab.boolify_scheduling_problem(case[0], case[1])
print("lab.boolify_scheduling_problem returned: " + trim(sat),
flush=True)
assign = lab.satisfying_assignment(sat)
print("lab.satisfying_assignment returned: " + trim(assign),
flush=True)
return assign
except:
print(traceback.format_exc(), flush=True)
return {}
def satisfiable(self, casename):
students, sessions = self.opencase(casename)
formula = lab.boolify_scheduling_problem(copy.deepcopy(students),
copy.deepcopy(sessions))
sched = lab.satisfying_assignment(formula)
self.assertIsNotNone(sched)
unplaced_students = set(students)
for var, val in sched.items():
if val:
student, session = var.split('_')
self.assertIn(student, unplaced_students)
unplaced_students.remove(student)
self.assertIn(student, students)
self.assertIn(session, students[student])
self.assertIn(session, sessions)
self.assertTrue(sessions[session] >= 1)
sessions[session] -= 1
self.assertEqual(len(unplaced_students), 0)
def unsatisfiable(self, casename):
students, sessions = self.opencase(casename)
sched = lab.satisfying_assignment(
lab.boolify_scheduling_problem(copy.deepcopy(students),
copy.deepcopy(sessions)))
self.assertIsNone(sched)
def _unsatisfiable(cnf):
assignment = lab.satisfying_assignment(copy.deepcopy(cnf))
assert assignment is None
def _scheduling_unsatisfiable(casename):
students, sessions = _open_scheduling_case(casename)
sched = lab.satisfying_assignment(
lab.boolify_scheduling_problem(copy.deepcopy(students),
copy.deepcopy(sessions)))
assert sched is None
def test_example5(self):
formula = [[('a', True)], [('a', False)]]
print(lab.satisfying_assignment(formula))
def run_sudoku_test(self, n, original):
result = lab.satisfying_assignment(self.get_sudoku(n))
self.check_sudoku(original, self.assignment_to_grid(result))
def unsatisfiable(self, casename, use_tuple=True):
cnf = self.opencase(casename)
if use_tuple:
cnf = self.convert_to_tuple(cnf)
asgn = lab.satisfying_assignment(copy.deepcopy(cnf))
self.assertIsNone(asgn)
def run_sudoku_test(self, n, original):
result = lab.satisfying_assignment(self.get_sudoku(n))
self.assertNotEqual(None, result, "There is a valid sudoku solution, but you returned None.")
self.check_sudoku(original, self.assignment_to_grid(result))
def unsatisfiable(self, casename):
cnf = self.opencase(casename)
asgn = lab.satisfying_assignment(copy.deepcopy(cnf))
self.assertIsNone(asgn)
def _run_sudoku_test(n, original):
result = lab.satisfying_assignment(_get_sudoku(n))
assert result is not None, "There is a valid sudoku solution, but you returned None."
_check_sudoku(original, _assignment_to_grid(result))
def test_class_example_unsat(self):
rules = self.get_rules()
asgn = lab.satisfying_assignment(rules + [[('tim', False)]])
expected = None
self.assertEqual(asgn, expected)
def test_example3(self):
formula = [[('c', True)], [('c', False), ('d', False)], [('f', False), ('d', True)]]
print(lab.satisfying_assignment(formula))
