def get_drawing_calculator(self, true_exprs, false_exprs):
painter_mock = MagicMock()
tableaux_builder = FoplTableauxBuilder(
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, False,
10)
def test_merge_9(self):
expr_t = parse('(A)x (P(x)|T(x))')
expr_f = parse('P(A)&F(B)')
l_expr = [
parse('P(A)|T(A)'),
]
r_expr = []
tableau = FoplTableauxBuilder(true_exprs=[expr_t],
false_exprs=[expr_f],
constants=['A', 'B'])
manual_tableau = BaseManualTableau(LogicType.FOPL, tableau)
manual_tableau.merge((expr_t, None, None), [l_expr], [r_expr], [[]],
['A'])
sequent = tableau.sequent
self.assertEqual(1, len(sequent[BaseTableauxBuilder.true_exprs]))
self.assertIn(parse('P(A)|T(A)'),
sequent[BaseTableauxBuilder.true_exprs])
self.assertEqual(1, len(sequent[BaseTableauxBuilder.false_exprs]))
self.assertIn(parse('P(A)&F(B)'),
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]))
self.assertEqual(
0,
len(sequent[
BaseTableauxBuilder.processed_false_quantor_expressions]))
self.assertEqual(
1,
len(sequent[
BaseTableauxBuilder.processed_true_quantor_expressions]))
self.assertIn(
parse('(A)x (P(x)|T(x))'),
sequent[BaseTableauxBuilder.processed_true_quantor_expressions])
self.assertEqual(
1,
len(sequent[BaseTableauxBuilder.processed_true_quantor_expressions]
[parse('(A)x (P(x)|T(x))')]))
self.assertIn(
'A',
sequent[BaseTableauxBuilder.processed_true_quantor_expressions][
parse('(A)x (P(x)|T(x))')])
self.assertEqual(
2, len(sequent[BaseTableauxBuilder.established_constants]))
self.assertIn('A', sequent[BaseTableauxBuilder.established_constants])
self.assertIn('B', sequent[BaseTableauxBuilder.established_constants])
self.assertEqual(0, len(tableau.children))
def test_incorrect_1(self):
expr = parse('(P()->T())&(T()->Q())->(P()->Q())')
l_expr = [
parse('(P()->T())&(T()->Q())'),
parse('(P()->Q())'),
]
tableau = FoplTableauxBuilder(false_exprs=[expr])
manual_tableau = BaseManualTableau(LogicType.FOPL, tableau)
success = manual_tableau.merge((None, expr, None), [l_expr], [[]],
[[]], [])
self.assertFalse(success)
def test_correct_3(self):
expr_t = parse('!!P()')
expr_f = parse('(P()->T())&(T()->Q())->(P()->Q())')
l_expr = [parse('(P()->T())&(T()->Q())')]
r_expr = [parse('(P()->Q())')]
tableau = FoplTableauxBuilder(true_exprs=[expr_t],
false_exprs=[expr_f])
manual_tableau = BaseManualTableau(LogicType.FOPL, tableau)
success = manual_tableau.merge((None, expr_f, None), [l_expr],
[r_expr], [[]], [])
self.assertTrue(success)
def test_correct_18(self):
expr_t = parse('(E)x (P(x)|T(x))')
expr_f = parse('P(A)&F(B)')
l_expr = [parse('P(C)|T(C)')]
r_expr = []
tableau = FoplTableauxBuilder(true_exprs=[expr_t],
false_exprs=[expr_f],
constants=['A', 'B'])
manual_tableau = BaseManualTableau(LogicType.FOPL, tableau)
success = manual_tableau.merge((expr_t, None, None), [l_expr],
[r_expr], [[]], ['C'])
self.assertTrue(success)
def test_incorrect_5(self):
expr_t = parse('!!P()')
expr_f = parse('P()|T()')
l_expr = []
r_expr = [
parse('P()'),
]
tableau = FoplTableauxBuilder(true_exprs=[expr_t],
false_exprs=[expr_f])
manual_tableau = BaseManualTableau(LogicType.FOPL, tableau)
success = manual_tableau.merge((None, expr_f, None), [l_expr],
[r_expr], [[]], [])
self.assertFalse(success)
def test_correct_19(self):
expr_t = parse('(A)x,y M(x,l(x,y))')
expr_f = parse('M(A,l(A,l(B,NIL)))')
l_expr = [parse('(A)y M(A,l(A, y))')]
r_expr = []
tableau = FoplTableauxBuilder(true_exprs=[expr_t],
false_exprs=[expr_f],
constants=['A', 'B', 'NIL'],
functions=[('l', 2)])
manual_tableau = BaseManualTableau(LogicType.FOPL, tableau)
success = manual_tableau.merge((expr_t, None, None), [l_expr],
[r_expr], [[]], ['A'])
self.assertTrue(success)
def test_correct_10(self):
expr_t = [
parse('P()&T()&Q()'),
parse('K()->R()'),
parse('R()->S()'),
]
expr_f = [parse('!S()->!F()')]
l_expr = [parse('P()&T()'), parse('Q()')]
r_expr = []
tableau = FoplTableauxBuilder(true_exprs=expr_t, false_exprs=expr_f)
manual_tableau = BaseManualTableau(LogicType.FOPL, tableau)
success = manual_tableau.merge((expr_t[0], None, None), [l_expr],
[r_expr], [[]], [])
self.assertTrue(success)
def test_incorrect_13(self):
expr_t = parse('(A)x P(x)')
expr_f = parse('P(A)|T(B)')
l_expr = [
parse('P(A)&T(B)'),
]
r_expr = []
tableau = FoplTableauxBuilder(true_exprs=[expr_t],
false_exprs=[expr_f],
constants=['A', 'B'])
manual_tableau = BaseManualTableau(LogicType.FOPL, tableau)
success = manual_tableau.merge((expr_t, None, None), [l_expr],
[r_expr], [[]], ['A', 'B'])
self.assertFalse(success)
def test_merge_3(self):
expr_t = [
parse('P()&T()&Q()'),
parse('K()->R()'),
parse('R()->S()'),
]
expr_f = [parse('!S()->!F()')]
l_expr = [parse('!S()')]
r_expr = [parse('!F()')]
tableau = FoplTableauxBuilder(true_exprs=expr_t, false_exprs=expr_f)
manual_tableau = BaseManualTableau(LogicType.FOPL, 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('K()->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('P()&T()&Q()'),
sequent[BaseTableauxBuilder.true_exprs])
self.assertEqual(1, len(sequent[BaseTableauxBuilder.false_exprs]))
self.assertIn(parse('!F()'), 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()->!F()'),
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('K()->R()'),
parse('P()&T()&Q()'),
parse('R()->S()'),
]
expr_f = [parse('!S()->!F()')]
l_expr = [
[],
[parse('R()')],
]
r_expr = [
[parse('K()')],
[],
]
tableau = FoplTableauxBuilder(true_exprs=expr_t, false_exprs=expr_f)
manual_tableau = BaseManualTableau(LogicType.FOPL, 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('P()&T()&Q()'),
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('K()->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('P()&T()&Q()'),
c_s_1[BaseTableauxBuilder.true_exprs])
self.assertEqual(1, len(c_s_1[BaseTableauxBuilder.false_atoms]))
self.assertIn(parse('K()'), 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('K()->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('P()&T()&Q()'),
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('K()->R()'),
c_s_2[BaseTableauxBuilder.true_processed])
def is_done(self):
return self.is_closed() or (super().is_done()
and FoplTableauxBuilder.is_done(self))
def get_partially_processed_exprs(self, partially_in_trees=False):
t_1, f_1, cf_1 = IpcTableauxBuilder.get_partially_processed_exprs(self)
t_2, f_2, cf_2 = FoplTableauxBuilder.get_partially_processed_exprs(
self)
return (t_1 + t_2, f_1 + f_2, cf_1 + cf_2)
