def _evaluate(self):
left_cnf = self.left.evaluate() if isinstance(self.left,
Node) else self.left
if self.left_negated:
left_cnf = Clause.cnf_negated(left_cnf)
if self.right is None:
return left_cnf
right_cnf = self.right.evaluate() if isinstance(self.right,
Node) else self.right
if self.right_negated:
right_cnf = Clause.cnf_negated(right_cnf)
if self.operator == "v":
return Clause.disjunctionOperator(left_cnf, right_cnf)
elif self.operator == "&":
return Clause.conjunctionOperator(left_cnf, right_cnf)
elif self.operator == "=":
return Clause.equalityOperator(left_cnf, right_cnf)
elif self.operator == ">":
return Clause.implicationOperator(left_cnf, right_cnf)
else:
raise ValueError("Invalid operator! '{}'".format(self.operator))
def check_deduction(facts, goal_clause, debug: bool = False) -> (str, str):
output = ""
(prove_true, steps_true) = Resolution.refute_by_resolution_proof(
facts, {goal_clause})
if debug:
output += steps_true + "\n\n"
if prove_true:
check_result = "true"
return tuple([
check_result, output + Clause.clause_to_string(goal_clause) +
" is " + check_result
])
(prove_false, steps_false) = Resolution.refute_by_resolution_proof(
facts, Clause.cnf_negated({goal_clause}))
if debug:
output += steps_false + "\n\n"
check_result = "false" if prove_false else "unknown"
return tuple([
check_result, output + Clause.clause_to_string(goal_clause) +
" is " + check_result
])
def _refute_by_resolution(facts, goal) -> (bool, str):
steps = ""
Resolution.clause_counter = 1
clause_to_number = {}
goal_negated = Clause.cnf_negated(goal)
clauses = set()
clauses.update([x for x in facts if not Clause.cnf_tautology(x)])
for clause in itertools.chain(facts, ["yolo"], goal_negated):
if clause == "yolo":
steps += Resolution.horizontal_line
continue
if clause not in clause_to_number:
steps += "{}. {}\n".format(Resolution.clause_counter,
Clause.clause_to_string(clause))
clause_to_number[clause] = Resolution.clause_counter
Resolution.clause_counter += 1
steps += Resolution.horizontal_line
sos = set()
sos_stage = set()
sos_stage.update(goal_negated)
sos_new = set()
Clause.simplify_within_set_for_subsets(clauses)
Clause.simplify_within_set_for_subsets(sos_stage)
Clause.simplify_among_two_sets_for_subsets(sos_stage, clauses)
while True:
# # I'm sorry for this for loop. TODO refactor later
# for (c1, c2) in itertools.product(sos_stage, sos_stage):
# x, steps = Resolution.__help_fun(c1, c2, sos_new, sos_stage, clauses, clause_to_number, steps)
# if x:
# return [x, steps]
# if sos_new:
# sos_stage.update(sos_new)
# sos_new = set()
# continue
#
# for (c1, c2) in itertools.product(sos_stage, sos):
# x, steps = Resolution.__help_fun(c1, c2, sos_new, sos_stage, clauses, clause_to_number, steps)
# if x:
# return [x, steps]
# if sos_new:
# sos_stage.update(sos_new)
# sos_new = set()
# continue
#
# for (c1, c2) in itertools.product(sos_stage, clauses):
# x, steps = Resolution.__help_fun(c1, c2, sos_new, sos_stage, clauses, clause_to_number, steps)
# if x:
# return [x, steps]
# if not sos_new:
# if not clauses:
# return tuple([False, steps])
# else:
# clauses, sos_new = set(), clauses
# sos.update(sos_stage)
# sos_stage, sos_new = sos_new, set()
for (c1, c2) in itertools.chain(
itertools.product(sos_stage, sos_stage),
itertools.product(sos_stage, sos),
itertools.product(sos_stage, clauses)):
x, steps = Resolution.__help_fun(c1, c2, sos_new, sos_stage,
clauses, clause_to_number,
steps)
if x:
return [x, steps]
if not sos_new:
# if not clauses:
return tuple([False, steps])
# else:
# clauses, sos_new = set(), clauses
sos.update(sos_stage)
sos_stage, sos_new = sos_new, set()
