def test_not_closing_1(self):
# A
expr = Atom("A")
builder = PropositionalTableauxBuilder(false_exprs=[expr])
builder.auto_resolve()
self.assertFalse(builder.is_closed())
def test_closing_1(self):
# A | !A
expr = Or(Atom("A"), Not(Atom("A")))
builder = PropositionalTableauxBuilder(false_exprs=[expr])
builder.auto_resolve()
self.assertTrue(builder.is_closed())
def test_closing_3(self):
# !A -> (A -> B)
expr = Impl(Not(Atom("A")), Impl(Atom("A"), Atom("B")))
builder = PropositionalTableauxBuilder(false_exprs=[expr])
builder.auto_resolve()
self.assertTrue(builder.is_closed())
def test_closing_7(self):
# !!A <-> A
expr = Eq(Not(Not(Atom("A"))), Atom("A"))
builder = PropositionalTableauxBuilder(false_exprs=[expr])
builder.auto_resolve()
self.assertTrue(builder.is_closed())
def test_not_closing_4(self):
# A&B | !A&B
expr = Or(And(Atom("A"), Atom("B")), And(Not(Atom("A")), Atom("B")))
builder = PropositionalTableauxBuilder(false_exprs=[expr])
builder.auto_resolve()
self.assertFalse(builder.is_closed())
def test_closing_4(self):
# A -> (B -> C) <-> A&B -> C
expr = Eq(Impl(Atom("A"), Impl(Atom("B"), Atom("C"))),
Impl(And(Atom("A"), Atom("B")), Atom("C")))
builder = PropositionalTableauxBuilder(false_exprs=[expr])
builder.auto_resolve()
self.assertTrue(builder.is_closed())
def test_closing_11(self):
# !(!A&!B) <-> A|B
expr = Eq(Not(And(Not(Atom("A")), Not(Atom("B")))),
Or(Atom("A"), Atom("B")))
builder = PropositionalTableauxBuilder(false_exprs=[expr])
builder.auto_resolve()
self.assertTrue(builder.is_closed())
def get_drawing_calculator(self, true_exprs, false_exprs):
painter_mock = MagicMock()
tableaux_builder = PropositionalTableauxBuilder(
true_exprs=true_exprs,
false_exprs=false_exprs,
visit_idx=len(true_exprs) + len(false_exprs))
tableaux_builder.auto_resolve()
return DrawingCalculator(tableaux_builder, painter_mock, False, False,
10)
def test_incorrect_1(self):
expr = parse('(a->b)&(b->c)->(a->c)')
l_expr = [
parse('(a->b)&(b->c)'),
parse('(a->c)'),
]
tableau = PropositionalTableauxBuilder(false_exprs=[expr])
manual_tableau = BaseManualTableau(LogicType.PROPOSITIONAL, tableau)
success = manual_tableau.merge((None, expr, None), [l_expr], [[]],
[[]], [])
self.assertFalse(success)
def test_correct_3(self):
expr_t = parse('!!a')
expr_f = parse('(a->b)&(b->c)->(a->c)')
l_expr = [parse('(a->b)&(b->c)')]
r_expr = [parse('(a->c)')]
tableau = PropositionalTableauxBuilder(true_exprs=[expr_t],
false_exprs=[expr_f])
manual_tableau = BaseManualTableau(LogicType.PROPOSITIONAL, tableau)
success = manual_tableau.merge((None, expr_f, None), [l_expr],
[r_expr], [[]], [])
self.assertTrue(success)
def test_incorrect_5(self):
expr_t = parse('!!a')
expr_f = parse('a|b')
l_expr = []
r_expr = [
parse('a'),
]
tableau = PropositionalTableauxBuilder(true_exprs=[expr_t],
false_exprs=[expr_f])
manual_tableau = BaseManualTableau(LogicType.PROPOSITIONAL, tableau)
success = manual_tableau.merge((None, expr_f, None), [l_expr],
[r_expr], [[]], [])
self.assertFalse(success)
def test_correct_10(self):
expr_t = [
parse('a&b&c'),
parse('q->r'),
parse('r->s'),
]
expr_f = [parse('!s->!p')]
l_expr = [parse('a&b'), parse('c')]
r_expr = []
tableau = PropositionalTableauxBuilder(true_exprs=expr_t,
false_exprs=expr_f)
manual_tableau = BaseManualTableau(LogicType.PROPOSITIONAL, tableau)
success = manual_tableau.merge((expr_t[0], None, None), [l_expr],
[r_expr], [[]], [])
self.assertTrue(success)
def test_merge_3(self):
expr_t = [
parse('a&b&c'),
parse('q->r'),
parse('r->s'),
]
expr_f = [parse('!s->!p')]
l_expr = [parse('!s')]
r_expr = [parse('!p')]
tableau = PropositionalTableauxBuilder(true_exprs=expr_t,
false_exprs=expr_f)
manual_tableau = BaseManualTableau(LogicType.PROPOSITIONAL, tableau)
manual_tableau.merge((None, expr_f[0], None), [l_expr], [r_expr], [[]],
[])
sequent = tableau.sequent
self.assertEqual(4, len(sequent[BaseTableauxBuilder.true_exprs]))
self.assertIn(parse('q->r'), sequent[BaseTableauxBuilder.true_exprs])
self.assertIn(parse('r->s'), sequent[BaseTableauxBuilder.true_exprs])
self.assertIn(parse('!s'), sequent[BaseTableauxBuilder.true_exprs])
self.assertIn(parse('a&b&c'), sequent[BaseTableauxBuilder.true_exprs])
self.assertEqual(1, len(sequent[BaseTableauxBuilder.false_exprs]))
self.assertIn(parse('!p'), sequent[BaseTableauxBuilder.false_exprs])
self.assertEqual(0, len(sequent[BaseTableauxBuilder.false_atoms]))
self.assertEqual(0, len(sequent[BaseTableauxBuilder.true_atoms]))
self.assertEqual(0, len(sequent[BaseTableauxBuilder.true_processed]))
self.assertEqual(1, len(sequent[BaseTableauxBuilder.false_processed]))
self.assertIn(parse('!s->!p'),
sequent[BaseTableauxBuilder.false_processed])
self.assertEqual(0, len(tableau.children))
def create_tableau_builder(logic_type: int, left_exprs: list,
right_exprs: list, visit_idx:int=0,
cf: list=None, constants=[], functions=[]):
if logic_type == LogicType.PROPOSITIONAL:
tableau_builder = PropositionalTableauxBuilder(
true_exprs=left_exprs,
false_exprs=right_exprs,
visit_idx=visit_idx,
)
return tableau_builder
if logic_type == LogicType.FOPL:
tableau_builder = FoplTableauxBuilder(
true_exprs=left_exprs,
false_exprs=right_exprs,
constants=constants,
functions=functions,
visit_idx=visit_idx,
)
return tableau_builder
if logic_type == LogicType.IPROPOSITIONAL:
tableau_builder = IpcTableauxBuilder(
true_exprs=left_exprs,
false_exprs=right_exprs,
visit_idx=visit_idx,
cf_exprs=cf if cf is not None else [],
)
return tableau_builder
if logic_type == LogicType.IFOPL:
tableau_builder = IfoplTableauxBuilder(
true_exprs=left_exprs,
false_exprs=right_exprs,
constants = constants,
functions=functions,
visit_idx=visit_idx,
cf_exprs=cf if cf is not None else [],
)
return tableau_builder
def test_merge_4(self):
expr_t = [
parse('q->r'),
parse('a&b&c'),
parse('r->s'),
]
expr_f = [parse('!s->!p')]
l_expr = [
[],
[parse('r')],
]
r_expr = [
[parse('q')],
[],
]
tableau = PropositionalTableauxBuilder(true_exprs=expr_t,
false_exprs=expr_f)
manual_tableau = BaseManualTableau(LogicType.PROPOSITIONAL, tableau)
manual_tableau.merge((expr_t[0], None, None), l_expr, r_expr, [[], []],
[])
sequent = tableau.sequent
self.assertEqual(2, len(tableau.children))
self.assertEqual(2, len(sequent[BaseTableauxBuilder.true_exprs]))
self.assertIn(parse('r->s'), sequent[BaseTableauxBuilder.true_exprs])
self.assertIn(parse('a&b&c'), sequent[BaseTableauxBuilder.true_exprs])
self.assertEqual(0, len(sequent[BaseTableauxBuilder.false_atoms]))
self.assertEqual(0, len(sequent[BaseTableauxBuilder.true_atoms]))
self.assertEqual(0, len(sequent[BaseTableauxBuilder.false_processed]))
self.assertEqual(1, len(sequent[BaseTableauxBuilder.true_processed]))
self.assertIn(parse('q->r'),
sequent[BaseTableauxBuilder.true_processed])
c_s_1 = tableau.children[0].sequent
c_s_2 = tableau.children[1].sequent
self.assertEqual(2, len(c_s_1[BaseTableauxBuilder.true_exprs]))
self.assertIn(parse('r->s'), c_s_1[BaseTableauxBuilder.true_exprs])
self.assertIn(parse('a&b&c'), c_s_1[BaseTableauxBuilder.true_exprs])
self.assertEqual(1, len(c_s_1[BaseTableauxBuilder.false_atoms]))
self.assertIn(parse('q'), c_s_1[BaseTableauxBuilder.false_atoms])
self.assertEqual(0, len(c_s_1[BaseTableauxBuilder.true_atoms]))
self.assertEqual(0, len(c_s_1[BaseTableauxBuilder.false_processed]))
self.assertEqual(1, len(c_s_1[BaseTableauxBuilder.true_processed]))
self.assertIn(parse('q->r'), c_s_1[BaseTableauxBuilder.true_processed])
self.assertEqual(2, len(c_s_2[BaseTableauxBuilder.true_exprs]))
self.assertIn(parse('r->s'), c_s_2[BaseTableauxBuilder.true_exprs])
self.assertIn(parse('a&b&c'), c_s_2[BaseTableauxBuilder.true_exprs])
self.assertEqual(1, len(c_s_2[BaseTableauxBuilder.true_atoms]))
self.assertIn(parse('r'), c_s_2[BaseTableauxBuilder.true_atoms])
self.assertEqual(0, len(c_s_2[BaseTableauxBuilder.false_atoms]))
self.assertEqual(0, len(c_s_2[BaseTableauxBuilder.false_processed]))
self.assertEqual(1, len(c_s_2[BaseTableauxBuilder.true_processed]))
self.assertIn(parse('q->r'), c_s_2[BaseTableauxBuilder.true_processed])
