def add_goal(self, statement):
"""
:param statement:
:return:
"""
statement = parser.parse(statement)
self._add_statement(deepcopy(statement), self.goals)
self._add_statement(Not(deepcopy(statement)), self._goals)
def add_formula(self, statement):
"""
:param statement:
:return:
"""
if isinstance(statement, str):
statement = parser.parse(statement)
self._add_statement(deepcopy(statement), self.formulas)
def test_parse_fol_1(self):
Predicate.reset()
Herbrand.reset()
Skolem.reset()
statement = parser.parse("forall(x,if(A(x),and(B(x),C(x))))")
expected = Universal(Symbol("x"), If(Predicate("A", [Symbol("x")]),
And(Predicate("B", [Symbol("x")]),
Predicate("C", [Symbol("x")]))))
self.assertEqual(expected, statement)
def _add_statement(statement, add_to_list):
"""
:param statement:
:param add_to_list:
:param additional: additional operator to apply onto statement
:return:
"""
statement = parser.parse(statement)
statement = converter.convert_formula(statement)
add_to_list.append(statement)
def test_bad_paranthesis(self):
with self.assertRaises(SyntaxError):
parser.parse("and((a)),b)")
def test_convert_to_cnf_2(self):
statement = parser.parse("forall(x,if(A(x),and(B(x),C(x))))")
statement = converter.convert_formula(statement)
expected = "((B(Herbrand1) | ~A(Herbrand1)) & (C(Herbrand1) | ~A(Herbrand1)))"
self.assertEqual(expected, str(statement))
def _herbrandization(statement, forall=None):
"""
Remove universal quantifiers through herbrandization
:param statement:
:param forall:
:return:
"""
if forall is None:
forall = dict()
if isinstance(statement, Universal):
forall[statement.symbol] = Herbrand()
statement = _herbrandization(statement.args[0], forall)
elif isinstance(statement, Existential):
statement.args[0] = _herbrandization(statement.args[0], forall)
elif isinstance(statement, Formula):
for i in range(len(statement.args)):
if isinstance(statement.args[i], Symbol):
if statement.args[i].arg in forall:
statement.args[i] = forall[str(statement.args[i])]
else:
statement.args[i] = _herbrandization(statement.args[i], forall)
else:
if statement in forall:
statement = forall[str(statement)]
return statement
if __name__ == "__main__":
print(convert_formula(parser.parse("not(forall(x,if(A(x),C(x))))")))
def test_extra_comma(self):
with self.assertRaises(SyntaxError):
parser.parse("and(a!,b)")
def test_parse_symbol(self):
statement = parser.parse("a")
self.assertEqual(statement, Symbol("a"))
def test_wrong_number_arguments(self):
with self.assertRaises(SyntaxError):
parser.parse("and(a)")
def test_invalid_formula(self):
with self.assertRaises(SyntaxError):
parser.parse("not(a),")
def test_parse_or(self):
statement = parser.parse("or(a, b)")
self.assertEqual(statement, Or(Symbol("a"), Symbol("b")))
def test_parse_and(self):
statement = parser.parse("and(a, b)")
self.assertEqual(statement, And(Symbol("a"), Symbol("b")))
def test_bad_symbol(self):
with self.assertRaises(SyntaxError):
parser.parse("&a")
def test_empty_parse(self):
with self.assertRaises(SyntaxError):
parser.parse("")
def test_parse_iff(self):
statement = parser.parse("iff(a, b)")
self.assertEqual(statement, Iff(Symbol("a"), Symbol("b")))
def test_extra_paranthesis(self):
statement = parser.parse("and((a),((b)))")
self.assertEqual(And(Symbol("a"), Symbol("b")), statement)
def test_parse_iff_2(self):
statement = parser.parse("iff(not(A), not(B))")
self.assertEqual(statement, Iff(Not(Symbol("A")), Not(Symbol("B"))))
def test_bad_paranthesis_left(self):
with self.assertRaises(SyntaxError):
parser.parse("and(a,b")
def test_parse_not(self):
statement = parser.parse("not(a)")
self.assertEqual(statement, Not(Symbol("a")))
