def test_quantifier_namespace_saturation(self): a = Universal("x", Atom("Saturated", ("x", "NAME", "NAME"))) b = Universal("x", Atom("Saturated", ("x", "x", "NAME"))) self.assertNotEqual(a, b) c = Existential("a", Universal("b", Atom("Saturated", ("a", "b", "b")))) d = Existential("a", Universal("b", Atom("Saturated", ("a", "a", "b")))) self.assertNotEqual(c, d)
def test_complex_quantified_sequent(self): sequent = Sequent( [Existential( "alpha", Conjunction( Universal( "beta", Atom("Predicate", ("alpha", "beta")) ), Atom("AnotherPredicate", ("alpha",)) ))], []) with patch("json.load", lambda *args: self.names): decomp = sequent.decompose() self.assertEqual( Sequent( [ Conjunction( Universal("beta", Atom("Predicate", ("Adrian", "beta"))), Atom("AnotherPredicate", ("Adrian",)) ) ], [] ), decomp[0][0] )
def test_sequent_left_universal_principal(self): universal = Universal("x", Atom("Proposition", ("x",))) sequent = Sequent([universal], []) principal = sequent.principal self.assertEqual("ant", principal.side) self.assertEqual(0, principal.index) self.assertEqual(LeftUniversal("x", Atom("Proposition", ("x",))), principal.proposition)
def test_left_universal(self): """forall(x)(Predicate(x)) |~""" with patch("json.load", lambda *args: self.names): sequent = Sequent([Universal("alpha", self.alpha)], []) decomp = sequent.decompose() self.assertEqual(Sequent([Atom("Predicate", ("Adrian",))], []), decomp[0][0]) self.assertEqual(Sequent([Atom("Predicate", ("Eve",))], []), decomp[1][0])
def test_nested_quantified_sequents(self): """forall(x)(exists(y)(Predicate(x; y)) |~""" sequent = Sequent([ Universal( "alpha", Existential("beta", Atom("Predicate", ("alpha", "beta")))) ], []) with patch("json.load", lambda *args: self.names): decomp = sequent.decompose() self.assertEqual( Sequent( [Existential("beta", Atom("Predicate", ("Adrian", "beta")))], []), decomp[0][0]) self.assertEqual( Sequent([Existential("beta", Atom("Predicate", ("Eve", "beta")))], []), decomp[1][0])
def test_nested_two_name_complex_quantifier(self): nest = Universal("w", Existential("x", Disjunction( Atom("Nested", ("x", "w")), Atom("Nested", ("w", "x")))) ) self.assertEqual( Existential("x", Disjunction( Atom("Nested", ("x", "w")), Atom("Nested", ("w", "x")))), nest.prop ) self.assertEqual( Disjunction( Atom("Nested", ("x", "w")), Atom("Nested", ("w", "x"))), nest.prop.prop)
def test_nested_complex_quantifier_init(self): nest = Universal("x", Existential("y", Conjunction( Atom("Nested", ("x",)), Atom("Nested", ("y",)))) ) self.assertEqual( Existential("y", Conjunction( Atom("Nested", ("x",)), Atom("Nested", ("y",)))), nest.prop ) self.assertEqual("x", nest.var) self.assertEqual([], nest.names) self.assertEqual( Conjunction( Atom("Nested", ("x",)), Atom("Nested", ("y",))), nest.prop.prop ) self.assertEqual("y", nest.prop.var)
def test_universal_init(self): universal = Universal("x", self.test_atom) self.assertEqual("x", universal.var) self.assertEqual(self.test_atom, universal.prop)
def test_instantiate_atom(self): universal = Universal("x", self.test_atom) test = universal.instantiate(universal.var, "nothing") self.assertEqual(self.result_atom, test)
def test_nested_quantifier_string(self): expected = "forall(x)(exists(y)(Nested(x; y)))" actual = str(Universal("x", Existential("y", Atom("Nested", ("x", "y"))))) self.assertEqual(expected, actual)
def test_nested_quantifier_from_string(self): string = "(forall(x)(exists(y)(Nested(x; y))))" actual = String(string).to_proposition() expected = Universal("x", Existential("y", Atom("Nested", ("x", "y")))) self.assertEqual(expected, actual)
def test_nested_instantiated(self): uni = Universal("x", Existential("y", Atom("Nested", ("x", "y")))) inst = uni.instantiate("x", "alpha") self.assertEqual(Existential("y", Atom("Nested", ("alpha", "y"))), inst)
def test_instantiate_binary(self): for c in self.binary: universal = Universal("x", c(self.test_atom, self.test_atom)) test = universal.instantiate(universal.var, "nothing") self.assertEqual(c(self.result_atom, self.result_atom), test)
def test_universal_predicate_from_string(self): u = "(forall(y)(EatsDoughnuts(y)))" convert = String(u).to_proposition() self.assertEqual(Universal("y", Atom("EatsDoughnuts", ("y",))), convert)
def test_nested_two_name_atomic_quantifier(self): nest = Universal("w", Existential("x", Atom("Nested", ("x", "w")))) self.assertEqual(Existential("x", Atom("Nested", ("x", "w"))), nest.prop) self.assertEqual(Atom("Nested", ("x", "w")), nest.prop.prop)
def test_complex_quantifier_eq_same_object_predicate_different_names(self): a = Universal("x", Conjunction(Atom("Tough", ("x",)), Atom("Hard", ("x",)))) b = Universal("y", Conjunction(Atom("Tough", ("y",)), Atom("Hard", ("y",)))) self.assertEqual(a, b)
def test_nested_atomic_quantifier_init(self): nest = Universal("x", Existential("y", Atom("Nested", ("x", "y")))) self.assertEqual(Existential("y", Atom("Nested", ("x", "y"))), nest.prop) self.assertEqual("x", nest.var) self.assertEqual([], nest.names) self.assertEqual(Atom("Nested", ("x", "y")), nest.prop.prop)
def test_complex_quantifier_eq_same_object_multi_predicate(self): a = Universal("x", Conjunction(Atom("Tough", ("x", "x")), Atom("Hard", ("x", "x")))) b = Universal("y", Conjunction(Atom("Tough", ("y", "y")), Atom("Hard", ("y", "y")))) self.assertEqual(a, b)