def test_is_formula_and(self): fol = self.fol john = ConstantTerm.fromString("john") paul = ConstantTerm.fromString("paul") not_a_term = ConstantTerm.fromString("NotATerm") right_equal = Equal(john, paul) wrong_equal = Equal(john, not_a_term) self.assertTrue(fol.is_formula(And(right_equal, right_equal))) self.assertFalse(fol.is_formula(And(right_equal, Not(wrong_equal)))) self.assertTrue( fol.is_formula( And(right_equal, PredicateFormula(PredicateSymbol("Person", 2), john, paul)))) self.assertFalse( fol.is_formula( And( right_equal, PredicateFormula(PredicateSymbol("Person", 3), john, paul, john)))) self.assertFalse( fol.is_formula( And( right_equal, PredicateFormula(PredicateSymbol("Person_fake", 2), john, paul))))
def test_is_formula_exists(self): fol = self.fol john = ConstantTerm.fromString("john") not_a_term = ConstantTerm.fromString("NotATerm") x = Variable.fromString("x") y = Variable.fromString("y") right_equal = Equal(x, john) wrong_equal = Equal(x, not_a_term) self.assertTrue(fol.is_formula(Exists(x, right_equal))) self.assertFalse(fol.is_formula(Exists(x, wrong_equal))) self.assertTrue( fol.is_formula( Exists(x, PredicateFormula(PredicateSymbol("Person", 2), john, x)))) self.assertFalse( fol.is_formula( Exists( x, PredicateFormula(PredicateSymbol("Person", 3), john, x, john)))) self.assertFalse( fol.is_formula( Exists( x, PredicateFormula(PredicateSymbol("Person_fake", 2), john, x))))
def test_is_formula_predicate(self): # TODO: Cover the FunctionTerm case (not only ConstantTerm) fol = self.fol Person_pred_sym = self.Person_pred_sym john = ConstantTerm.fromString("john") paul = ConstantTerm.fromString("paul") not_a_term = ConstantTerm.fromString("NotATerm") # Notice: only syntactic check. # test terms self.assertTrue( fol.is_formula(PredicateFormula(Person_pred_sym, john, paul))) self.assertFalse( fol.is_formula(PredicateFormula(Person_pred_sym, not_a_term, paul))) # test predicate symbol self.assertTrue( self.fol.is_formula( PredicateFormula(PredicateSymbol("Person", 2), john, paul))) self.assertFalse( self.fol.is_formula( PredicateFormula(PredicateSymbol("Person", 3), john, paul, john))) self.assertFalse( self.fol.is_formula( PredicateFormula(PredicateSymbol("Person_fake", 2), john, paul)))
def test_is_formula_equal(self): fol = self.fol john = ConstantTerm.fromString("john") paul = ConstantTerm.fromString("paul") not_a_term = ConstantTerm.fromString("NotATerm") right_equal = Equal(john, paul) wrong_equal = Equal(john, not_a_term) # test terms self.assertTrue(fol.is_formula(right_equal)) self.assertFalse(fol.is_formula(wrong_equal))
def test_to_nnf_derived_formulas(self): fol = self.fol john = ConstantTerm.fromString("john") x = Variable.fromString("x") right_equal = Equal(x, john) true_ = TrueFormula() false_ = FalseFormula() or_ = Or(true_, Not(right_equal)) implies_ = Implies(or_, false_) equivalence_ = Equivalence(implies_, false_) forall_true_ = ForAll(x, true_) forall_not_or_ = ForAll(x, Not(or_)) forall_equivalence_ = ForAll(x, equivalence_) to_nnf_true_ = Equal(DUMMY_TERM, DUMMY_TERM) to_nnf_false_ = Not(Equal(DUMMY_TERM, DUMMY_TERM)) to_nnf_or_ = Or(to_nnf_true_, Not(right_equal)) to_nnf_not_or_ = And(Not(to_nnf_true_), right_equal) to_nnf_implies_ = Or(to_nnf_not_or_, to_nnf_false_) not_to_nnf_implies_ = And(to_nnf_or_, to_nnf_true_) positive_equivalence = And(to_nnf_implies_, to_nnf_false_) negative_equivalence = And(not_to_nnf_implies_, to_nnf_true_) to_nnf_equivalence_ = Or(positive_equivalence, negative_equivalence) self.assertEqual(fol.to_nnf(true_), to_nnf_true_) self.assertEqual(fol.to_nnf(false_), to_nnf_false_) self.assertEqual(fol.to_nnf(or_), to_nnf_or_) self.assertEqual(fol.to_nnf(implies_), to_nnf_implies_) self.assertEqual(fol.to_nnf(equivalence_), to_nnf_equivalence_) self.assertEqual(fol.to_nnf(forall_true_), ForAll(x, to_nnf_true_)) self.assertEqual(fol.to_nnf(forall_not_or_), ForAll(x, to_nnf_not_or_)) self.assertEqual(fol.to_nnf(forall_equivalence_), ForAll(x, to_nnf_equivalence_))
def test_expand_formula_derived_formulas(self): fol = self.fol john = ConstantTerm.fromString("john") x = Variable.fromString("x") right_equal = Equal(x, john) true_ = TrueFormula() false_ = FalseFormula() or_ = Or(true_, Not(right_equal)) implies_ = Implies(or_, false_) equivalence_ = Equivalence(implies_, false_) forall_ = ForAll(x, equivalence_) expanded_true = Equal(DUMMY_TERM, DUMMY_TERM) expanded_false = Not(Equal(DUMMY_TERM, DUMMY_TERM)) expanded_or_ = Not(And(Not(expanded_true), Not(Not(right_equal)))) expanded_implies_ = Not(And(expanded_or_, Not(expanded_false))) positive_equivalence = And(expanded_implies_, expanded_false) negative_equivalence = And(Not(expanded_implies_), Not(expanded_false)) expanded_equivalence_ = Not( And(Not(positive_equivalence), Not(negative_equivalence))) self.assertEqual(fol.expand_formula(true_), expanded_true) self.assertEqual(fol.expand_formula(false_), expanded_false) self.assertEqual(fol.expand_formula(or_), expanded_or_) self.assertEqual(fol.expand_formula(implies_), expanded_implies_) self.assertEqual(fol.expand_formula(equivalence_), expanded_equivalence_) self.assertEqual(fol.expand_formula(forall_), Not(Exists(x, Not(expanded_equivalence_))))
def test_assignment(self): self.assertEqual(self.assignment(self.x), "john") self.assertEqual(self.assignment(self.y), 20) self.assertEqual(self.assignment(self.z), "ny") self.assertEqual( self.assignment(FunctionTerm(self.LivesIn_fun_sym, self.x)), "ny") self.assertTrue((self.assignment(self.x), self.assignment(ConstantTerm.fromString("20")) ) in self.Person.tuples)
def test_is_formula_derived(self): fol = self.fol john = ConstantTerm.fromString("john") not_a_term = ConstantTerm.fromString("NotATerm") x = Variable.fromString("x") y = Variable.fromString("y") right_equal = Equal(x, john) wrong_equal = Equal(x, not_a_term) self.assertTrue(fol.is_formula(TrueFormula())) self.assertTrue(fol.is_formula(FalseFormula())) self.assertTrue(fol.is_formula(Or(right_equal, right_equal))) self.assertFalse(fol.is_formula(Or(right_equal, wrong_equal))) self.assertTrue(fol.is_formula(Or(right_equal, right_equal))) self.assertFalse(fol.is_formula(Or(right_equal, wrong_equal))) self.assertTrue(fol.is_formula(Implies(right_equal, right_equal))) self.assertFalse(fol.is_formula(Implies(right_equal, wrong_equal))) self.assertTrue(fol.is_formula(Equivalence(right_equal, right_equal))) self.assertFalse(fol.is_formula(Equivalence(right_equal, wrong_equal))) self.assertTrue( fol.is_formula( ForAll(x, PredicateFormula(PredicateSymbol("Person", 2), john, x)))) self.assertFalse( fol.is_formula( ForAll( x, PredicateFormula(PredicateSymbol("Person", 3), john, x, john)))) self.assertFalse( fol.is_formula( ForAll( x, PredicateFormula(PredicateSymbol("Person_fake", 2), john, x))))
def test_to_nnf_allowed_formulas(self): fol = self.fol john = ConstantTerm.fromString("john") x = Variable.fromString("x") right_equal = Equal(x, john) not_ = Not(right_equal) and_ = And(right_equal, not_) exists_ = Exists(x, right_equal) self.assertEqual(fol.to_nnf(right_equal), right_equal) self.assertEqual(fol.to_nnf(not_), not_) self.assertEqual(fol.to_nnf(and_), and_) self.assertEqual(fol.to_nnf(exists_), exists_)
def test_truth(self): w = Variable.fromString("w") Person_x_20 = PredicateFormula(self.Person_pred_sym, self.x, ConstantTerm.fromString("20")) Person_x_y = PredicateFormula(self.Person_pred_sym, self.x, self.y) not_Person_x_21 = Not( PredicateFormula(self.Person_pred_sym, self.x, ConstantTerm.fromString("21"))) y_equal_20 = Equal(self.y, ConstantTerm.fromString("20")) x_equal_john = Equal(self.x, ConstantTerm.fromString("john")) x_equal_x = Equal(self.x, self.x) x_equal_y = Equal(self.x, self.y) x_equal_z = Equal(self.x, self.z) x_lives_w = PredicateFormula(self.Lives_pred_sym, self.x, w) x_lives_y = PredicateFormula(self.Lives_pred_sym, self.x, self.y) x_lives_ny = PredicateFormula(self.Lives_pred_sym, self.x, ConstantTerm.fromString("ny")) x_lives_paris = PredicateFormula(self.Lives_pred_sym, self.x, ConstantTerm.fromString("paris")) w_lives_z = PredicateFormula(self.Lives_pred_sym, w, self.z) exists_w__x_lives_w = Exists(w, x_lives_w) exists_y__x_lives_y = Exists(self.y, x_lives_y) exists_z_exists_w__w_lives_z = Exists(self.z, Exists(w, w_lives_z)) exists_x__x_equal_x = Exists(self.x, x_equal_x) exists_x__x_equal_y = Exists(self.x, x_equal_y) exists_x__x_equal_john_and_Lives_x_paris = Exists( self.x, And(x_equal_john, x_lives_paris)) exists_x__x_equal_john_and_exists_x__Lives_x_ny = And( Exists(self.x, x_equal_john), Exists(self.x, x_lives_ny)) exists_x__x_equal_x_and_exists_x__Lives_x_ny = And( exists_x__x_equal_x, Exists(self.x, x_lives_ny)) forall_x__x_equal_x = ForAll(self.x, x_equal_x) forall_x__x_equal_y = ForAll(self.x, x_equal_y) not_forall_x__x_equal_x = Not(forall_x__x_equal_x) # Person(x, 20) # x = "john" self.assertTrue(self.FOL.truth(Person_x_20, self.assignment)) # ~Person(x, 21) # x = "john" self.assertTrue(self.FOL.truth(not_Person_x_21, self.assignment)) # Equals self.assertTrue(self.FOL.truth(y_equal_20, self.assignment)) self.assertTrue(self.FOL.truth(x_equal_x, self.assignment)) self.assertFalse(self.FOL.truth(x_equal_y, self.assignment)) self.assertFalse(self.FOL.truth(x_equal_z, self.assignment)) # y == 20 and x == "john" and Person(x, y) self.assertTrue( self.FOL.truth(And(y_equal_20, And(x_equal_john, Person_x_y)), self.assignment)) self.assertTrue( self.FOL.truth(Or(Person_x_20, x_equal_john), self.assignment)) # De Morgan on previous formula # Not (Not y == 20 or Not x == "john" ot Not Person(x, y) self.assertTrue( self.FOL.truth( Not(Or(Not(y_equal_20), Or(Not(x_equal_john), Not(Person_x_y)))), self.assignment)) # Or with the last formula true self.assertTrue( self.FOL.truth( Or(Equal(self.x, self.y), Or(Equal(self.x, self.y), Equal(self.z, self.z))), self.assignment)) # (y==20 and x=="john") => Person(x,y) self.assertTrue( self.FOL.truth(Implies(And(y_equal_20, x_equal_john), Person_x_y), self.assignment)) self.assertTrue( self.FOL.truth(Implies(Not(x_equal_x), Person_x_y), self.assignment)) # Exists self.assertTrue(self.FOL.truth(exists_w__x_lives_w, self.assignment)) self.assertTrue(self.FOL.truth(exists_x__x_equal_x, self.assignment)) self.assertTrue(self.FOL.truth(exists_x__x_equal_y, self.assignment)) # quantified variable not present in the formula self.assertTrue(self.FOL.truth(exists_y__x_lives_y, self.assignment)) # 2 quantified variables self.assertTrue( self.FOL.truth(exists_z_exists_w__w_lives_z, self.assignment)) # annidate exists self.assertTrue( self.FOL.truth(exists_x__x_equal_john_and_exists_x__Lives_x_ny, self.assignment)) self.assertTrue( self.FOL.truth(exists_x__x_equal_x_and_exists_x__Lives_x_ny, self.assignment)) self.assertFalse( self.FOL.truth(exists_x__x_equal_john_and_Lives_x_paris, self.assignment)) # ForAll self.assertTrue(self.FOL.truth(forall_x__x_equal_x, self.assignment)) self.assertFalse(self.FOL.truth(forall_x__x_equal_y, self.assignment)) self.assertFalse( self.FOL.truth(not_forall_x__x_equal_x, self.assignment))
def _members(self): return (self.symbol) def __str__(self): return str(self.symbol) def __lt__(self, other): return self.symbol.name.__lt__(other.symbol.name) @classmethod def fromName(cls, name: str): return cls(Symbol(name)) DUMMY_ATOMIC = AtomicFormula(DUMMY_SYMBOL) DUMMY_TERM = ConstantTerm.fromString(DUMMY_SYMBOL.name) class PredicateFormula(SimpleFormula): def __init__(self, predicate_symbol: PredicateSymbol, *args: Term): assert len(args) == predicate_symbol.arity self.predicate_symbol = predicate_symbol self.args = args def __str__(self): return str(self.predicate_symbol) + "(" + ", ".join( [t.__str__() for t in self.args]) + ")" def _members(self): sorted_args = sorted(self.args) return (self.predicate_symbol, *sorted_args)