def test_closing_14(self):
# (!A|B)->(A->B)
expr = Impl(Or(Not(Atom("A")), Atom("B")), Impl(Atom("A"), Atom("B")))
builder = IpcTableauxBuilder(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 = IpcTableauxBuilder(false_exprs=[expr])
builder.auto_resolve()
self.assertFalse(builder.is_closed())
def test_not_closing_6(self):
# !!A->A
expr = Impl(Not(Not(Atom("A"))), Atom("A"))
builder = IpcTableauxBuilder(false_exprs=[expr])
builder.auto_resolve()
self.assertFalse(builder.is_closed())
def test_not_closing_1(self):
# A
expr = Atom("A")
builder = IpcTableauxBuilder(false_exprs=[expr])
builder.auto_resolve()
self.assertFalse(builder.is_closed())
def test_closing_3(self):
# T A&B F A
expr_1 = And(Atom("A"), Atom("B"))
expr_2 = Atom("A")
builder = IpcTableauxBuilder(true_exprs=[expr_1], false_exprs=[expr_2])
builder.auto_resolve()
self.assertTrue(builder.is_closed())
def test_closing_8(self):
# !(A|B) -> !A&!B
expr = Impl(Not(Or(Atom("A"), Atom("B"))),
And(Not(Atom("A")), Not(Atom("B"))))
builder = IpcTableauxBuilder(false_exprs=[expr])
builder.auto_resolve()
self.assertTrue(builder.is_closed())
def test_closing_11(self):
# (A->!B) -> !(A&B)
expr = Impl(Impl(Atom("A"), Not(Atom("B"))),
Not(And(Atom("A"), Atom("B"))))
builder = IpcTableauxBuilder(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 = IpcTableauxBuilder(
true_exprs=[parse(e) for e in true_exprs],
false_exprs=[parse(e) for e in false_exprs],
visit_idx=len(true_exprs) + len(false_exprs))
tableaux_builder.auto_resolve()
return DrawingCalculator(tableaux_builder, painter_mock, False, True,
10)
def test_not_closing_13(self):
# (A->B)->(!A|B)
expr = Impl(
Impl(Atom("A"), Atom("B")),
Or(Not(Atom("A")), Atom("B")),
)
builder = IpcTableauxBuilder(false_exprs=[expr])
builder.auto_resolve()
self.assertFalse(builder.is_closed())
def test_not_closing_10(self):
# !(A->!B)->A&B
expr = Impl(
Not(Impl(Atom("A"), Not(Atom("B")))),
And(Atom("A"), Atom("B")),
)
builder = IpcTableauxBuilder(false_exprs=[expr])
builder.auto_resolve()
self.assertFalse(builder.is_closed())
def test_closing_18(self):
# (A&B)<->((A->B)<->A)
expr = Eq(And(Atom("A"), Atom("B")),
Eq(
Impl(Atom("A"), Atom("B")),
Atom("A"),
))
builder = IpcTableauxBuilder(false_exprs=[expr])
builder.auto_resolve()
self.assertTrue(builder.is_closed())
def test_correct_15(self):
expr_t = [
parse('a&b&c'),
parse('q->r'),
parse('r->s'),
]
expr_f = [
parse('!s->!p')
]
expr_cf = [
parse('a<->b')
]
l_expr = [[]]
r_expr = [[]]
cf_expr = [[
parse('(a->b)&(b->a)')
]]
tableau = IpcTableauxBuilder(true_exprs=expr_t,
false_exprs=expr_f,
cf_exprs=expr_cf)
manual_tableau = BaseManualTableau(LogicType.IPROPOSITIONAL, tableau)
success = manual_tableau.merge((None, None, expr_cf[0]), l_expr, r_expr, cf_expr, [])
self.assertTrue(success)
def test_merge_true_impl(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 = IpcTableauxBuilder(true_exprs=expr_t, false_exprs=expr_f)
manual_tableau = BaseManualTableau(LogicType.IPROPOSITIONAL, 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])
def test_merge_true_not(self):
expr_t = [
parse('!s'),
parse('a&b&c'),
parse('q->r'),
parse('r->s'),
]
expr_f = [
parse('!s->!p'),
parse('t&f')
]
expr_cf = [
parse('!s')
]
l_expr = [[]]
r_expr = [[]]
cf_expr = [[
parse('s')
]]
tableau = IpcTableauxBuilder(true_exprs=expr_t,
false_exprs=expr_f,
cf_exprs = expr_cf)
manual_tableau = BaseManualTableau(LogicType.IPROPOSITIONAL, tableau)
manual_tableau.merge((expr_t[0], None, None), l_expr, r_expr, cf_expr, [])
self.assertEqual(0, len(tableau.children))
sequent = tableau.sequent
self.assertEqual(3, 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('a&b&c'), sequent[BaseTableauxBuilder.true_exprs])
self.assertEqual(0, len(sequent[BaseTableauxBuilder.true_atoms]))
self.assertEqual(2, len(sequent[BaseTableauxBuilder.false_exprs]))
self.assertIn(parse('!s->!p'), sequent[BaseTableauxBuilder.false_exprs])
self.assertIn(parse('t&f'), sequent[BaseTableauxBuilder.false_exprs])
self.assertEqual(0, len(sequent[BaseTableauxBuilder.false_atoms]))
self.assertEqual(1, len(sequent[BaseTableauxBuilder.certain_falsehood_exprs]))
self.assertIn(parse('!s'), sequent[BaseTableauxBuilder.certain_falsehood_exprs])
self.assertEqual(1, len(sequent[BaseTableauxBuilder.certain_falsehood_atoms]))
self.assertIn(parse('s'), sequent[BaseTableauxBuilder.certain_falsehood_atoms])
self.assertEqual(1, len(sequent[BaseTableauxBuilder.true_processed]))
self.assertIn(parse('!s'), sequent[BaseTableauxBuilder.true_processed])
self.assertEqual(0, len(sequent[BaseTableauxBuilder.false_processed]))
self.assertEqual(0, len(sequent[BaseTableauxBuilder.certain_falsehood_processed]))
def test_incorrect_1(self):
expr = parse('(a->b)&(b->c)->(a->c)')
l_expr = [
parse('(a->b)&(b->c)'),
parse('(a->c)'),
]
tableau = IpcTableauxBuilder(false_exprs=[expr])
manual_tableau = BaseManualTableau(LogicType.IPROPOSITIONAL, tableau)
success = manual_tableau.merge((None, expr, None), [l_expr], [[]], [[]], [])
self.assertFalse(success)
def test_incorrect_5(self):
expr_t = parse('!!a')
expr_f = parse('a|b')
l_expr = []
r_expr = [
parse('a'),
]
tableau = IpcTableauxBuilder(true_exprs=[expr_t], false_exprs=[expr_f])
manual_tableau = BaseManualTableau(LogicType.IPROPOSITIONAL, tableau)
success = manual_tableau.merge((None, expr_f, None), [l_expr], [r_expr], [[]], [])
self.assertFalse(success)
def test_incorrect_4(self):
expr_t = parse('(a->b)&(b->c)->(a->c)')
expr_f = parse('(a->b)&(b->c)->(a->c)')
l_expr = [
parse('(a->b)&(b->c)'),
]
r_expr = [
parse('(a->c)'),
]
tableau = IpcTableauxBuilder(true_exprs=[expr_t], false_exprs=[expr_f])
manual_tableau = BaseManualTableau(LogicType.IPROPOSITIONAL, tableau)
success = manual_tableau.merge((expr_t, None, None), [l_expr], [r_expr], [[]], [])
self.assertFalse(success)
def test_merge_false_impl(self):
expr_t = [
parse('a&b&c'),
parse('q->r'),
parse('r->s'),
]
expr_f = [
parse('!s->!p'),
parse('t&f')
]
l_expr = [
parse('!s')
]
r_expr = [
parse('!p')
]
tableau = IpcTableauxBuilder(true_exprs=expr_t, false_exprs=expr_f)
manual_tableau = BaseManualTableau(LogicType.IPROPOSITIONAL, tableau)
manual_tableau.merge((None, expr_f[0], None), [l_expr], [r_expr], [[]], [])
self.assertEqual(1, len(tableau.children))
sequent = tableau.children[0].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(0, len(sequent[BaseTableauxBuilder.false_processed]))
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 = IpcTableauxBuilder(true_exprs=expr_t, false_exprs=expr_f)
manual_tableau = BaseManualTableau(LogicType.IPROPOSITIONAL, tableau)
success = manual_tableau.merge((expr_t[0], None, None), [l_expr], [r_expr], [[]], [])
self.assertTrue(success)
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