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)