def testSimplification(self):
"""
Test that simplification works.
"""
f, m = formulaOpSimplify(self.f1)
f, m = formulaSimplify(f)
self.checkSimplificationResult(f)
f, m = formulaOpSimplify(self.f2)
f, m = formulaSimplify(f)
self.checkSimplificationResult(f)
f, m = formulaOpSimplify(self.f3)
f, m = formulaSimplify(f)
self.checkSimplificationResult(f)
f, m = formulaOpSimplify(self.f4)
f, m = formulaSimplify(f)
self.checkSimplificationResult(f)
f, m = formulaOpSimplify(self.f5)
f, m = formulaSimplify(f)
self.checkSimplificationResult(f)
lex = Lexer(self.covformulas)
while not lex.TestTok(Token.EOFToken):
f = parseFormula(lex)
f, m = formulaOpSimplify(f)
f, m = formulaSimplify(f)
self.checkSimplificationResult(f)
def testSplitter(self):
"""
Test splitting of conjunctions/disjunktions.
"""
lex = Lexer("""
a=>b
a & (a|(b=>c))
![X]:((a|b)&c)
![X]:![Y]:((a|b)&(?[X]:c(X)))
![X]:(a & (a|b|c) & (a|b|c|d))
a|(b&c)|(b<=>d)|![X]:p(X)
""")
cexpected = [1, 2, 2, 2, 3, 1]
dexpected = [1, 1, 1, 1, 1, 4]
while not lex.TestTok(Token.EOFToken):
f = parseFormula(lex)
f = f.getMatrix()
cs = f.conj2List()
res = cexpected.pop(0)
self.assertEqual(len(cs), res)
ds = f.disj2List()
res = dexpected.pop(0)
self.assertEqual(len(ds), res)
def testClausification(self):
"""
Test conversion of wrapped formulas into lists of clauses.
"""
lex = Lexer(self.testformulas)
while not lex.TestTok(Token.EOFToken):
wf = parseWFormula(lex)
clauses = wFormulaClausify(wf)
enableDerivationOutput()
print("==================")
for c in clauses:
print(c)
toggleDerivationOutput()
def generateEquivAxioms():
"""
Return a list with the three axioms describing an equivalence
relation. We are lazy here...
"""
lex = Lexer("""
cnf(reflexivity, axiom, X=X).
cnf(symmetry, axiom, X!=Y|Y=X).
cnf(transitivity, axiom, X!=Y|Y!=Z|X=Z).
""")
res = []
while not lex.TestTok(Token.EOFToken):
c = parseClause(lex)
c.setDerivation(Derivation("eq_axiom"))
res.append(c)
return res
def testCNFTest(self):
"""
Check the CNF test.
"""
lex = Lexer("""
a=>b
a & (a|(b=>c))
![X]:((a|b)&c)
![X]:![Y]:((a|b)&(?[X]:c(X)))
![X]:(a & (a|b|c) & (a|b|c|d))
""")
expected = [False, False, True, False, True]
while not lex.TestTok(Token.EOFToken):
f = parseFormula(lex)
res = expected.pop(0)
self.assertEqual(f.isCNF(), res)
def testCNFization(self):
"""
Test conversion of wrapped formulas into conjunctive normal
form.
"""
lex = Lexer(self.testformulas)
while not lex.TestTok(Token.EOFToken):
wf = parseWFormula(lex)
wf = wFormulaCNF(wf)
enableDerivationOutput()
self.assertTrue(wf.formula.isCNF())
deriv = wf.orderedDerivation()
print("==================")
for s in deriv:
print(s)
toggleDerivationOutput()
def testMiniScope(self):
"""
Test Miniscoping.
"""
lex = Lexer("""
![X]:(p(X)|q(a))
?[X]:(p(a)&q(X))
![X]:(p(X)&q(X))
?[X]:(p(X)|q(X))
![X]:(p(X)|q(X))
![X,Y]:?[Z]:(p(Z)|q(X))
""")
res = [True, True, True, True, False, True]
while not lex.TestTok(Token.EOFToken):
expected = res.pop(0)
f = parseFormula(lex)
f1, m = formulaMiniScope(f)
print(f, f1, m, expected)
self.assertEqual(expected, m)
if m:
self.assertTrue(not f1.isQuantified())
def testNNF(self):
"""
Test NNF transformation
"""
f, m = formulaOpSimplify(self.f1)
f, m = formulaSimplify(f)
f, m = formulaNNF(f, 1)
self.checkNNFResult(f)
f, m = formulaOpSimplify(self.f2)
f, m = formulaSimplify(f)
f, m = formulaNNF(f, 1)
self.checkNNFResult(f)
f, m = formulaOpSimplify(self.f3)
f, m = formulaSimplify(f)
f, m = formulaNNF(f, 1)
self.checkNNFResult(f)
f, m = formulaOpSimplify(self.f4)
f, m = formulaSimplify(f)
f, m = formulaNNF(f, 1)
self.checkNNFResult(f)
f, m = formulaOpSimplify(self.f5)
f, m = formulaSimplify(f)
f, m = formulaNNF(f, 1)
self.checkNNFResult(f)
lex = Lexer(self.covformulas)
while not lex.TestTok(Token.EOFToken):
f = parseFormula(lex)
f, m = formulaOpSimplify(f)
f, m = formulaSimplify(f)
f, m = formulaNNF(f, 1)
self.checkNNFResult(f)
