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)
