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_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_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_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_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 test_merge_2(self):
expr_t = [
parse('a&b&c'),
parse('q->r'),
parse('r->s'),
]
expr_f = [parse('!s->!p')]
l_expr = [parse('b&c'), parse('a')]
r_expr = []
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(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('b&c'), sequent[BaseTableauxBuilder.true_exprs])
self.assertIn(parse('a'), sequent[BaseTableauxBuilder.true_atoms])
self.assertEqual(1, len(sequent[BaseTableauxBuilder.false_exprs]))
self.assertIn(parse('!s->!p'),
sequent[BaseTableauxBuilder.false_exprs])
self.assertEqual(0, len(sequent[BaseTableauxBuilder.false_atoms]))
self.assertEqual(0, len(sequent[BaseTableauxBuilder.false_processed]))
self.assertEqual(1, len(sequent[BaseTableauxBuilder.true_processed]))
self.assertIn(parse('a&b&c'),
sequent[BaseTableauxBuilder.true_processed])
self.assertEqual(0, len(tableau.children))
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_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_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_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_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_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_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_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_correct_4(self):
expr_t = [
parse('p->q'),
parse('q->r'),
parse('r->s'),
]
expr_f = [
parse('!s->!p')
]
l_expr = [
parse('!s')
]
r_expr = [
parse('!p')
]
tableau = IpcTableauxBuilder(true_exprs=expr_t, false_exprs=expr_f)
manual_tableau = BaseManualTableau(LogicType.IPROPOSITIONAL, tableau)
success = manual_tableau.merge((None, expr_f[0], None), [l_expr], [r_expr], [[]], [])
self.assertTrue(success)
def test_correct_8(self):
expr_t = [
parse('a|b'),
parse('q->r'),
parse('r->s'),
]
expr_f = [
parse('!s->!p')
]
l_expr = [
[parse('a')], [parse('b')]
]
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 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])
class InputWindow(BaseWindow):
margin = 10
def __init__(self, callback, logic_type, expr, tableau_builder):
super().__init__()
self.ui = Ui_InputWindow()
self.ui.setupUi(self)
self.ui.ok_btn.clicked.connect(self.ok_pressed)
self.ui.cancel_btn.clicked.connect(self.cancel_pressed)
self.ui.help_btn.clicked.connect(self.show_help)
self.installEventFilter(self)
self.ui.scrollAreaContentsSingle.installEventFilter(self)
self.ui.scrollAreaContentsBranch.installEventFilter(self)
self.callback = callback
self.logic_type = logic_type
self.expr = expr
l, r, cf = expr
if l:
self.expr_name = l.name
elif r:
self.expr_name = r.name
elif cf:
self.expr_name = cf.name
self.manual_tableau = BaseManualTableau(logic_type, tableau_builder)
def eventFilter(self, watched: PySide2.QtCore.QObject,
event: PySide2.QtCore.QEvent):
if watched is self.ui.scrollAreaContentsSingle and type(
event) is QPaintEvent:
self.draw_single()
elif watched is self.ui.scrollAreaContentsBranch and type(
event) is QPaintEvent:
self.draw_branch()
elif event.type() == QEvent.Close:
self.callback(False)
return False
def ok_pressed(self):
self.reset()
intuitionistic_logic = self.logic_type in [
LogicType.IPROPOSITIONAL, LogicType.IFOPL
]
if self.ui.tab_bar.currentIndex() == 0:
# single tab
left_exprs = self.parse_exprs(self.ui.deduction_single_left,
self.ui.scrollAreaContentsSingle)
right_exprs = self.parse_exprs(self.ui.deduction_single_right,
self.ui.scrollAreaContentsSingle,
include_cf=intuitionistic_logic)
cf_exprs = []
# check if parsing successfull
if left_exprs is None or right_exprs is None:
return
if intuitionistic_logic:
right_exprs, cf_exprs = right_exprs
constants = self.constants_from_trees(left_exprs + right_exprs)
left_exprs = self.exprs_from_trees(left_exprs)
right_exprs = self.exprs_from_trees(right_exprs)
cf_exprs = self.exprs_from_trees(cf_exprs)
if self.manual_tableau.merge(self.expr, [left_exprs],
[right_exprs], [cf_exprs], constants):
self.callback(True)
self.close()
return
self.show_error(
self.ui.scrollAreaContentsSingle,
f'<b>Wrong Derivation</b><p>Wrong application of the resolution rule for {self.expr_name}</<p>'
)
else:
# branch tab
ll_exprs = self.parse_exprs(self.ui.deduction_branch_ll,
self.ui.scrollAreaContentsBranch)
lr_exprs = self.parse_exprs(self.ui.deduction_branch_lr,
self.ui.scrollAreaContentsBranch,
include_cf=intuitionistic_logic)
rl_exprs = self.parse_exprs(self.ui.deduction_branch_rl,
self.ui.scrollAreaContentsBranch)
rr_exprs = self.parse_exprs(self.ui.deduction_branch_rr,
self.ui.scrollAreaContentsBranch,
include_cf=intuitionistic_logic)
cf_exprs = ([], [])
# check if parsing successfull
if ll_exprs is None or lr_exprs is None or rl_exprs is None or rr_exprs is None:
return
if intuitionistic_logic:
lr_exprs, l_cf_exprs = lr_exprs
rr_exprs, r_cf_exprs = rr_exprs
cf_exprs = (self.exprs_from_trees(l_cf_exprs),
self.exprs_from_trees(r_cf_exprs))
constants_l = self.constants_from_trees(ll_exprs + lr_exprs)
constants_r = self.constants_from_trees(rl_exprs + rr_exprs)
ll_exprs = self.exprs_from_trees(ll_exprs)
lr_exprs = self.exprs_from_trees(lr_exprs)
rl_exprs = self.exprs_from_trees(rl_exprs)
rr_exprs = self.exprs_from_trees(rr_exprs)
if self.manual_tableau.merge(self.expr, (ll_exprs, rl_exprs),
(lr_exprs, rr_exprs), cf_exprs,
(constants_l, constants_r)):
self.callback(True)
self.close()
return
self.show_error(
self.ui.scrollAreaContentsBranch,
f'<b>Wrong Derivation</b><p>Wrong application of the resolution rule for {self.expr_name}</<p>'
)
def reset(self):
for txt_input in [
self.ui.deduction_single_left,
self.ui.deduction_single_right,
self.ui.deduction_branch_ll,
self.ui.deduction_branch_lr,
self.ui.deduction_branch_rl,
self.ui.deduction_branch_rr,
]:
txt_input.setStyleSheet('')
def cancel_pressed(self):
self.callback(False)
self.close()
def draw_expr(self, painter, x=400):
t, f, cf = self.expr
expr_str = ""
if t is not None:
expr_str = str(t)
x -= self.margin + painter.get_text_width(expr_str)
elif f is not None:
expr_str = str(f)
x += self.margin
elif cf is not None:
expr_str = "[" + str(cf) + "]"
x += self.margin
painter.draw_normal(expr_str, x, 125)
def draw_single(self):
p = CustomPainter(self.ui.scrollAreaContentsSingle)
p.begin()
center_x = self.get_tableau_center(p)
p.draw_tableau_header(self.logic_type, center_x=center_x, height=275)
self.draw_expr(p, center_x)
self.ui.deduction_single_left.setGeometry(center_x - 175, 135, 165,
200)
self.ui.deduction_single_right.setGeometry(center_x + 10, 135, 165,
200)
width = max(400, self.get_expr_width(p) + 2 * self.margin) + 400
p.end()
self.ui.scrollAreaContentsSingle.setMinimumSize(width, 407)
def draw_branch(self):
p = CustomPainter(self.ui.scrollAreaContentsBranch)
p.begin()
center_x = self.get_tableau_center(p)
p.draw_tableau_header(self.logic_type, center_x=center_x, height=100)
# draw branch lines
l = center_x - 190
r = center_x + 190
p.drawLine(l, 175, r, 175)
p.drawLine(l, 175, l, 400)
p.drawLine(r, 175, r, 400)
# position text areas
self.ui.deduction_branch_ll.setGeometry(l - 175, 185, 165, 200)
self.ui.deduction_branch_lr.setGeometry(l + 10, 185, 165, 200)
self.ui.deduction_branch_rl.setGeometry(r - 175, 185, 165, 200)
self.ui.deduction_branch_rr.setGeometry(r + 10, 185, 165, 200)
self.draw_expr(p, center_x)
width = max(400, self.get_expr_width(p) + 2 * self.margin) + 400
p.end()
self.ui.scrollAreaContentsBranch.setMinimumSize(width, 407)
def get_tableau_center(self, painter):
t, f, cf = self.expr
x = 400
if t is not None:
width = painter.get_text_width(str(t))
width += 2 * self.margin
x = max(width, x)
return x
def get_expr_width(self, painter):
t, f, cf = self.expr
if t is not None:
return painter.get_text_width(str(t))
if f is not None:
return painter.get_text_width(str(f))
if cf is not None:
return painter.get_text_width('[' + str(cf) + ']')
