def neg_con(br):
if len(br) == 1:
sbf = NegForm(br[0])
elif len(br) == 2:
sbf = NegForm(DisForm(br[0], br[1]))
else:
sbf = NegForm(DisForm(br[0], neg_con(br[1:]).value))
return sbf
def consistent_join(liters, newlitera):
# nr = newlitera.reduce()
nr = newlitera
if isinstance(nr, AtomForm):
nn = NegForm(newlitera)
# nr = newlitera.reduce()
for l in liters:
# print('cmp',l,nn)
if str(l) == str(nn):
return None
if str(l) == str(nr):
return liters
return liters + [nr]
elif isinstance(nr, NegForm):
nn = nr.value
# nr = newlitera.reduce()
for l in liters:
# print('cmp',l,nn)
if str(l) == str(nn):
return None
if str(l) == str(nr):
return liters
return liters + [nr]
elif type(nr) is ConForm:
res = liters.copy()
for a in newlitera.members:
res = consistent_join(res, a)
if res is None:
break
return res
else:
raise ValueError()
def CNFt2CNF(s):
ll = [[
AtomForm('p{}'.format(str(n))) if n > 0 else NegForm(
AtomForm('p{}'.format(str(-n)))) for n in t
] for t in s]
f = CNForm(ll)
if minimize:
pass
return f
def tfr(r):
if r[2] == 'I':
return ImpForm(tfr(r[0]), tfr(r[1]))
elif r[2] == 'C':
return ConForm(tfr(r[0]), tfr(r[1]))
elif r[2] == 'D':
return DisForm(tfr(r[0]), tfr(r[1]))
elif r[2] == 'N':
c = r[0] if r[0] is not None else r[1]
return NegForm(tfr(c))
else:
return AtomForm(self.branch_var_dict[r[2]])
def extend_liters(a, ls: set):
nl = ls.copy()
inv = None
if isinstance(a, NegForm):
inv = a.value
else:
inv = NegForm(a)
if inv in nl:
return None
nl.add(a)
return nl
def make_formula(node):
if isinstance(node, str):
return AtomForm(node)
elif node.op == 'D':
return DisForm(make_formula(node.childs[0]),
make_formula(node.childs[1]))
elif node.op == 'C':
return ConForm(make_formula(node.childs[0]),
make_formula(node.childs[1]))
elif node.op == 'I':
return ImpForm(make_formula(node.childs[0]),
make_formula(node.childs[1]))
elif node.op == 'N':
return NegForm(make_formula(node.childs[0]))
def a_tableux(formulas, liters=None):
if liters is None:
liters = []
def select_formula(formulas: list):
if len(formulas) == 0:
return None
for i, f in enumerate(formulas):
if type(f) is AtomForm or type(f) is NegForm and type(
f.value) is AtomForm:
return i
for i, f in enumerate(formulas):
if type(f) is ConForm:
return i
for i, f in enumerate(formulas):
if type(f) is DisForm:
return i
return 0
if len(formulas) == 0:
return [liters]
res = []
locfs = formulas.copy()
fi = select_formula(locfs)
f = locfs[fi]
locfs.pop(fi)
# print('f:', f, 'forms:', locfs, 'lits:', liters)
if isinstance(f, ConForm):
res = a_tableux([f.a, f.b] + locfs, liters)
elif isinstance(f, AtomForm):
j = consistent_join(liters, f)
if not j is None:
res.extend(a_tableux(locfs, j))
else:
return []
elif isinstance(f, DisForm):
for m in [f.a, f.b]:
res.extend(a_tableux([m] + locfs, liters))
elif isinstance(f, ImpForm):
for m in [NegForm(f.a), f.b]:
res.extend(a_tableux([m] + locfs, liters))
elif isinstance(f, NegForm):
# sf = f.reduce()
v = f.value
if isinstance(v, ConForm):
for m in [NegForm(v.a), NegForm(v.b)]:
res.extend(a_tableux([m] + locfs, liters))
elif isinstance(v, AtomForm):
j = consistent_join(liters, f)
if not j is None:
res.extend(a_tableux(locfs, j))
else:
return []
elif isinstance(v, DisForm):
res = a_tableux([NegForm(v.a), NegForm(v.b)] + locfs, liters)
elif isinstance(v, ImpForm):
res = a_tableux([v.a, NegForm(v.b)] + locfs, liters)
elif isinstance(v, NegForm):
res = a_tableux([v.value] + locfs, liters)
else:
return []
else:
return []
# print('res:', res)
return res