def setUp(self):
"""
Setup function for resolution testing
"""
print()
self.spec = """
cnf(c1,axiom,p(a, X)|p(X,a)).
cnf(c2,axiom,~p(a,b)|p(f(Y),a)).
cnf(c3,axiom,q(Z,X)|~q(f(Z),X0)).
cnf(c4,axiom,p(X,X)|p(a,f(Y))).
cnf(c5,axiom,p(X,Y)|~q(b,a)|p(a,b)|~q(a,b)|p(Y,a)).
cnf(c6,axiom,~p(a,X)).
cnf(c7,axiom, q(f(a),a)).
cnf(c8,axiom, r(f(a))).
cnf(c9,axiom, p(X,Y)).
"""
lex = Lexer(self.spec)
self.c1 = clauses.parseClause(lex)
self.c2 = clauses.parseClause(lex)
self.c3 = clauses.parseClause(lex)
self.c4 = clauses.parseClause(lex)
self.c5 = clauses.parseClause(lex)
self.c6 = clauses.parseClause(lex)
self.c7 = clauses.parseClause(lex)
self.c8 = clauses.parseClause(lex)
self.c9 = clauses.parseClause(lex)
def setUp(self):
"""
Setup function for tests. Create some clauses to test
evaluations on.
"""
print()
self.spec = """
cnf(c1,axiom,(f(X1,X2)=f(X2,X1))).
cnf(c2,axiom,(f(X1,f(X2,X3))=f(f(X1,X2),X3))).
cnf(c3,axiom,(g(X1,X2)=g(X2,X1))).
cnf(c4,axiom,(f(f(X1,X2),f(X3,g(X4,X5)))!=f(f(g(X4,X5),X3),f(X2,X1))|k(X1,X1)!=k(a,b))).
cnf(c5,axiom,(b=c|X1!=X2|X3!=X4|c!=d)).
cnf(c6,axiom,(a=b|a=c)).
cnf(c7,axiom,(i(X1)=i(X2))).
cnf(c8,axiom,(c=d|h(i(a))!=h(i(e)))).
"""
lexer = Lexer(self.spec)
self.c1 = clauses.parseClause(lexer)
self.c2 = clauses.parseClause(lexer)
self.c3 = clauses.parseClause(lexer)
self.c4 = clauses.parseClause(lexer)
self.c5 = clauses.parseClause(lexer)
self.c6 = clauses.parseClause(lexer)
self.c7 = clauses.parseClause(lexer)
self.c8 = clauses.parseClause(lexer)
def parse(self, source, refdir=None):
"""
Parse a mixed FOF/CNF specification with includes. "source" is
either a filename or a lexer initialized with the input
text. "refdir" is the reference directory for TPTP includes.
"""
if not isinstance(source, Lexer):
source, refdir = tptpLexer(source, refdir)
while not source.TestTok(Token.EOFToken):
source.CheckLit(["cnf", "fof", "include"])
if source.TestLit("cnf"):
clause = parseClause(source)
self.addClause(clause)
elif source.TestLit("fof"):
formula = parseWFormula(source)
self.addFormula(formula)
else:
source.AcceptLit("include")
source.AcceptTok(Token.OpenPar)
name = source.LookLit()[1:-1]
source.AcceptTok(Token.SQString)
source.AcceptTok(Token.ClosePar)
source.AcceptTok(Token.FullStop)
self.parse(name, refdir)
def setUp(self):
"""
Setup function for resolution testing
"""
print()
self.spec = """
cnf(axiom, c1, $false).
cnf(axiom, c2, p(a)).
cnf(axiom, c3, p(X)).
cnf(axiom, c4, p(a)|q(f(X))).
cnf(axiom, c5, p(a)|q(f(b))|p(X)).
cnf(axiom, c6, X=X).
cnf(axiom, c7, Y=Y).
"""
lex = Lexer(self.spec)
self.c1 = parseClause(lex)
self.c2 = parseClause(lex)
self.c3 = parseClause(lex)
self.c4 = parseClause(lex)
self.c5 = parseClause(lex)
self.c6 = parseClause(lex)
self.c7 = parseClause(lex)
self.cset = ClauseSet()
self.cset.addClause(self.c2)
self.cset.addClause(self.c3)
self.cset.addClause(self.c4)
self.cset.addClause(self.c5)
self.cset.addClause(self.c6)
self.cset.addClause(self.c7)
def setUp(self):
"""
Setup function for paramodulation testing
"""
self.spec = """
cnf(commutativity_of_addition,axiom,
( add(A,B) = add(B,A) )).
cnf(associativity_of_addition,axiom,
( add(A,add(B,C)) = add(add(A,B),C) )).
cnf(commutativity2,axiom,
( subtract(add(A,B),C) = add(subtract(A,C),B) )).
cnf(add_substitution1,axiom,
( A != B
| C != add(A,D)
| C = add(B,D) )).
cnf(prove_equation,negated_conjecture,
( add(add(a,b),c) != add(a,add(b,c)) )).
cnf(n_right_equals_right_child_of_n,plain,n_right=right_child_of(n)).
cnf(halfthere,plain,siblings(n_left,right_child_of(n))).
"""
lex = Lexer(self.spec)
self.c1 = clauses.parseClause(lex)
self.c2 = clauses.parseClause(lex)
self.c3 = clauses.parseClause(lex)
self.c4 = clauses.parseClause(lex)
self.c5 = clauses.parseClause(lex)
self.c6 = clauses.parseClause(lex)
self.c7 = clauses.parseClause(lex)
def setUp(self):
"""
Setup function for clause/literal unit tests. Initialize
variables needed throughout the tests.
"""
print()
spec = """
cnf(g1, negated_conjecture, ~c).
cnf(c1, axiom, a|b|c).
cnf(c2, axiom, b|c).
cnf(c3, axiom, c).
"""
lex = Lexer(spec)
self.conj = parseClause(lex)
self.cset = ClauseSet()
self.cset.parse(lex)
cstr = "cnf(ftest, axiom, p(X)|~q|p(a)|~q|p(Y))."
lex = Lexer(cstr)
self.fclause = parseClause(lex)
def parse(self, lexer):
"""
Parse a sequence of clauses from lex and add them to the
set. Return number of clauses parsed.
"""
count = 0
while lexer.LookLit() == "cnf":
clause = parseClause(lexer)
self.addClause(clause)
count = count + 1
return count
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 setUp(self):
"""
Setup function for resolution testing
"""
print()
self.spec = """
cnf(c1,axiom,p(a, X)|p(X,a)).
cnf(c2,axiom,~p(a,b)|p(f(Y),a)).
cnf(c3,axiom,p(Z,X)|~p(f(Z),X0)).
cnf(c4,axiom,p(X,X)|p(a,f(Y))).
cnf(c5,axiom,p(X)|~q|p(a)|~q|p(Y)).
cnf(not_p,axiom,~p(a)).
cnf(taut,axiom,p(X4)|~p(X4)).
"""
lex = Lexer(self.spec)
self.c1 = clauses.parseClause(lex)
self.c2 = clauses.parseClause(lex)
self.c3 = clauses.parseClause(lex)
self.c4 = clauses.parseClause(lex)
self.c5 = clauses.parseClause(lex)
self.c6 = clauses.parseClause(lex)
self.c7 = clauses.parseClause(lex)