public void testDefaultClauseSimplifier() { FOLDomain domain = new FOLDomain(); domain.addConstant("ZERO"); domain.addConstant("ONE"); domain.addPredicate("P"); domain.addFunction("Plus"); domain.addFunction("Power"); FOLParser parser = new FOLParser(domain); List<TermEquality> rewrites = new List<TermEquality>(); rewrites.Add((TermEquality)parser.parse("Plus(x, ZERO) = x")); rewrites.Add((TermEquality)parser.parse("Plus(ZERO, x) = x")); rewrites.Add((TermEquality)parser.parse("Power(x, ONE) = x")); rewrites.Add((TermEquality)parser.parse("Power(x, ZERO) = ONE")); DefaultClauseSimplifier simplifier = new DefaultClauseSimplifier( rewrites); Sentence s1 = parser .parse("((P(Plus(y,ZERO),Plus(ZERO,y)) OR P(Power(y, ONE),Power(y,ZERO))) OR P(Power(y,ZERO),Plus(y,ZERO)))"); CNFConverter cnfConverter = new CNFConverter(parser); CNF cnf = cnfConverter.convertToCNF(s1); Assert.AreEqual(1, cnf.getNumberOfClauses()); Clause simplified = simplifier.simplify(cnf.getConjunctionOfClauses() [0]); Assert.AreEqual("[P(y,y), P(y,ONE), P(ONE,y)]", simplified .ToString()); }
public static FOLDomain kingsDomain() { FOLDomain domain = new FOLDomain(); domain.addConstant("John"); domain.addConstant("Richard"); domain.addPredicate("King"); domain.addPredicate("Greedy"); domain.addPredicate("Evil"); return domain; }
public static FOLDomain knowsDomain() { FOLDomain domain = new FOLDomain(); domain.addConstant("John"); domain.addConstant("Jane"); domain.addConstant("Bill"); domain.addConstant("Elizabeth"); domain.addFunction("Mother"); domain.addPredicate("Knows"); return domain; }
public static FOLDomain kingsDomain() { FOLDomain domain = new FOLDomain(); domain.addConstant("John"); domain.addConstant("Richard"); domain.addPredicate("King"); domain.addPredicate("Greedy"); domain.addPredicate("Evil"); return(domain); }
public static FOLDomain lovesAnimalDomain() { FOLDomain domain = new FOLDomain(); domain.addPredicate("Animal"); domain.addPredicate("Loves"); domain.addPredicate("Kills"); domain.addPredicate("Cat"); domain.addConstant("Jack"); domain.addConstant("Tuna"); domain.addConstant("Curiosity"); return domain; }
public static FOLDomain knowsDomain() { FOLDomain domain = new FOLDomain(); domain.addConstant("John"); domain.addConstant("Jane"); domain.addConstant("Bill"); domain.addConstant("Elizabeth"); domain.addFunction("Mother"); domain.addPredicate("Knows"); return(domain); }
public void testExhaustsSearchSpace() { // Taken from AIMA pg 679 FOLDomain domain = new FOLDomain(); domain.addPredicate("alternate"); domain.addPredicate("bar"); domain.addPredicate("fri_sat"); domain.addPredicate("hungry"); domain.addPredicate("patrons"); domain.addPredicate("price"); domain.addPredicate("raining"); domain.addPredicate("reservation"); domain.addPredicate("type"); domain.addPredicate("wait_estimate"); domain.addPredicate("will_wait"); domain.addConstant("Some"); domain.addConstant("Full"); domain.addConstant("French"); domain.addConstant("Thai"); domain.addConstant("Burger"); domain.addConstant("$"); domain.addConstant("_30_60"); domain.addConstant("X0"); FOLParser parser = new FOLParser(domain); // The hypothesis String c1 = "patrons(v,Some)"; String c2 = "patrons(v,Full) AND (hungry(v) AND type(v,French))"; String c3 = "patrons(v,Full) AND (hungry(v) AND (type(v,Thai) AND fri_sat(v)))"; String c4 = "patrons(v,Full) AND (hungry(v) AND type(v,Burger))"; String sh = "FORALL v (will_wait(v) <=> (" + c1 + " OR (" + c2 + " OR (" + c3 + " OR (" + c4 + ")))))"; Sentence hypothesis = parser.parse(sh); Sentence desc = parser .parse("(((((((((alternate(X0) AND NOT(bar(X0))) AND NOT(fri_sat(X0))) AND hungry(X0)) AND patrons(X0,Full)) AND price(X0,$)) AND NOT(raining(X0))) AND NOT(reservation(X0))) AND type(X0,Thai)) AND wait_estimate(X0,_30_60))"); Sentence classification = parser.parse("will_wait(X0)"); FOLKnowledgeBase kb = new FOLKnowledgeBase(domain, new FOLOTTERLikeTheoremProver(false)); kb.tell(hypothesis); kb.tell(desc); InferenceResult ir = kb.ask(classification); Assert.IsFalse(ir.isTrue()); Assert.IsTrue(ir.isPossiblyFalse()); Assert.IsFalse(ir.isUnknownDueToTimeout()); Assert.IsFalse(ir.isPartialResultDueToTimeout()); Assert.AreEqual(0, ir.getProofs().Count); }
public void setUp() { FOLDomain domain = new FOLDomain(); domain.addConstant("P"); domain.addConstant("John"); domain.addConstant("Saladin"); domain.addFunction("LeftLeg"); domain.addFunction("BrotherOf"); domain.addFunction("EnemyOf"); domain.addPredicate("HasColor"); domain.addPredicate("King"); lexer = new FOLLexer(domain); }
public static FOLDomain lovesAnimalDomain() { FOLDomain domain = new FOLDomain(); domain.addPredicate("Animal"); domain.addPredicate("Loves"); domain.addPredicate("Kills"); domain.addPredicate("Cat"); domain.addConstant("Jack"); domain.addConstant("Tuna"); domain.addConstant("Curiosity"); return(domain); }
public static FOLDomain crusadesDomain() { FOLDomain domain = new FOLDomain(); domain.addConstant("John"); domain.addConstant("Richard"); domain.addConstant("England"); domain.addConstant("Saladin"); domain.addConstant("Crown"); domain.addFunction("LeftLegOf"); domain.addFunction("BrotherOf"); domain.addFunction("EnemyOf"); domain.addFunction("LegsOf"); domain.addPredicate("King"); return domain; }
public static FOLDomain crusadesDomain() { FOLDomain domain = new FOLDomain(); domain.addConstant("John"); domain.addConstant("Richard"); domain.addConstant("England"); domain.addConstant("Saladin"); domain.addConstant("Crown"); domain.addFunction("LeftLegOf"); domain.addFunction("BrotherOf"); domain.addFunction("EnemyOf"); domain.addFunction("LegsOf"); domain.addPredicate("King"); return(domain); }
public static FOLDomain weaponsDomain() { FOLDomain domain = new FOLDomain(); domain.addConstant("West"); domain.addConstant("America"); domain.addConstant("M1"); domain.addConstant("Nono"); domain.addPredicate("American"); domain.addPredicate("Weapon"); domain.addPredicate("Sells"); domain.addPredicate("Hostile"); domain.addPredicate("Criminal"); domain.addPredicate("Missile"); domain.addPredicate("Owns"); domain.addPredicate("Enemy"); return(domain); }
public static FOLDomain weaponsDomain() { FOLDomain domain = new FOLDomain(); domain.addConstant("West"); domain.addConstant("America"); domain.addConstant("M1"); domain.addConstant("Nono"); domain.addPredicate("American"); domain.addPredicate("Weapon"); domain.addPredicate("Sells"); domain.addPredicate("Hostile"); domain.addPredicate("Criminal"); domain.addPredicate("Missile"); domain.addPredicate("Owns"); domain.addPredicate("Enemy"); return domain; }
public void testSimpleAtomicExamples() { FOLDomain domain = new FOLDomain(); domain.addConstant("A"); domain.addConstant("B"); domain.addConstant("C"); domain.addConstant("D"); domain.addConstant("E"); domain.addPredicate("P"); domain.addFunction("F"); domain.addFunction("G"); domain.addFunction("H"); domain.addFunction("J"); FOLParser parser = new FOLParser(domain); Predicate expression = (Predicate)parser .parse("P(A,F(B,G(A,H(B)),C),D)"); TermEquality assertion = (TermEquality)parser.parse("B = E"); Predicate altExpression = (Predicate)demodulation.apply(assertion, expression); Assert.IsFalse(expression.Equals(altExpression)); Assert .AreEqual("P(A,F(E,G(A,H(B)),C),D)", altExpression .ToString()); altExpression = (Predicate)demodulation .apply(assertion, altExpression); Assert .AreEqual("P(A,F(E,G(A,H(E)),C),D)", altExpression .ToString()); assertion = (TermEquality)parser.parse("G(x,y) = J(x)"); altExpression = (Predicate)demodulation.apply(assertion, expression); Assert.AreEqual("P(A,F(B,J(A),C),D)", altExpression.ToString()); }
public void testSimpleExample() { FOLDomain domain = new FOLDomain(); domain.addConstant("A"); domain.addConstant("B"); domain.addPredicate("P"); domain.addPredicate("Q"); domain.addPredicate("R"); domain.addFunction("F"); FOLParser parser = new FOLParser(domain); List<Literal> lits = new List<Literal>(); AtomicSentence a1 = (AtomicSentence)parser.parse("P(F(x,B),x)"); AtomicSentence a2 = (AtomicSentence)parser.parse("Q(x)"); lits.Add(new Literal(a1)); lits.Add(new Literal(a2)); Clause c1 = new Clause(lits); lits.Clear(); a1 = (AtomicSentence)parser.parse("F(A,y) = y"); a2 = (AtomicSentence)parser.parse("R(y)"); lits.Add(new Literal(a1)); lits.Add(new Literal(a2)); Clause c2 = new Clause(lits); List<Clause> paras = paramodulation.apply(c1, c2); Assert.AreEqual(2, paras.Count); foreach (Clause c in paras) { Assert.AreEqual("[P(B,A), Q(A), R(B)]", c.ToString()); Assert.AreEqual("[P(F(A,F(x,B)),x), Q(x), R(F(x,B))]", c .ToString()); } }
public void testSimpleAtomicNonExample() { FOLDomain domain = new FOLDomain(); domain.addConstant("A"); domain.addConstant("B"); domain.addConstant("C"); domain.addConstant("D"); domain.addConstant("E"); domain.addPredicate("P"); domain.addFunction("F"); domain.addFunction("G"); domain.addFunction("H"); domain.addFunction("J"); FOLParser parser = new FOLParser(domain); Predicate expression = (Predicate)parser.parse("P(A,G(x,B),C)"); TermEquality assertion = (TermEquality)parser.parse("G(A,y) = J(y)"); Predicate altExpression = (Predicate)demodulation.apply(assertion, expression); Assert.IsNull(altExpression); }
public static FOLDomain ringOfThievesDomain() { FOLDomain domain = new FOLDomain(); domain.addPredicate("Parent"); domain.addPredicate("Caught"); domain.addPredicate("Friend"); domain.addPredicate("Skis"); domain.addConstant("Mike"); domain.addConstant("Joe"); domain.addConstant("Janet"); domain.addConstant("Nancy"); domain.addConstant("Ernie"); domain.addConstant("Bert"); domain.addConstant("Red"); domain.addConstant("Drew"); return(domain); }
public static FOLDomain ringOfThievesDomain() { FOLDomain domain = new FOLDomain(); domain.addPredicate("Parent"); domain.addPredicate("Caught"); domain.addPredicate("Friend"); domain.addPredicate("Skis"); domain.addConstant("Mike"); domain.addConstant("Joe"); domain.addConstant("Janet"); domain.addConstant("Nancy"); domain.addConstant("Ernie"); domain.addConstant("Bert"); domain.addConstant("Red"); domain.addConstant("Drew"); return domain; }
public void testSubsumes() { FOLDomain domain = new FOLDomain(); domain.addConstant("A"); domain.addConstant("B"); domain.addConstant("C"); domain.addConstant("D"); domain.addConstant("E"); domain.addConstant("F"); domain.addConstant("G"); domain.addConstant("H"); domain.addConstant("I"); domain.addConstant("J"); domain.addPredicate("P"); domain.addPredicate("Q"); FOLParser parser = new FOLParser(domain); // Example // {~p(a,b),q(c)} Clause psi = new Clause(); psi.addNegativeLiteral((Predicate)parser.parse("P(A,B)")); psi.addPositiveLiteral((Predicate)parser.parse("Q(C)")); // {~p(x,y)} Clause phi = new Clause(); phi.addNegativeLiteral((Predicate)parser.parse("P(x,y)")); Assert.IsTrue(phi.subsumes(psi)); // Non-Example // {~p(x,b),q(x)} psi = new Clause(); psi.addNegativeLiteral((Predicate)parser.parse("P(x,B)")); psi.addPositiveLiteral((Predicate)parser.parse("Q(x)")); // {~p(a,y)} phi = new Clause(); phi.addNegativeLiteral((Predicate)parser.parse("P(A,y)")); // Reason for Non-Example: // {p(b,b)} // {~q(b)} Assert.IsFalse(phi.subsumes(psi)); // // Additional Examples // Non-Example // {~p(x,b),q(z)} psi = new Clause(); psi.addNegativeLiteral((Predicate)parser.parse("P(x,B)")); psi.addPositiveLiteral((Predicate)parser.parse("Q(z)")); // {~p(a,y)} phi = new Clause(); phi.addNegativeLiteral((Predicate)parser.parse("P(A,y)")); Assert.IsFalse(phi.subsumes(psi)); // Example // {~p(a,b),~p(w,z),q(c)} psi = new Clause(); psi.addNegativeLiteral((Predicate)parser.parse("P(A,B)")); psi.addNegativeLiteral((Predicate)parser.parse("P(w,z)")); psi.addPositiveLiteral((Predicate)parser.parse("Q(C)")); // {~p(x,y),~p(a,b)} phi = new Clause(); phi.addNegativeLiteral((Predicate)parser.parse("P(x,y)")); phi.addNegativeLiteral((Predicate)parser.parse("P(A,B)")); Assert.IsTrue(phi.subsumes(psi)); // Non-Example // {~p(v,b),~p(w,z),q(c)} psi = new Clause(); psi.addNegativeLiteral((Predicate)parser.parse("P(v,B)")); psi.addNegativeLiteral((Predicate)parser.parse("P(w,z)")); psi.addPositiveLiteral((Predicate)parser.parse("Q(C)")); // {~p(x,y),~p(a,b)} phi = new Clause(); phi.addNegativeLiteral((Predicate)parser.parse("P(x,y)")); phi.addNegativeLiteral((Predicate)parser.parse("P(A,B)")); Assert.IsFalse(phi.subsumes(psi)); // Example // {~p(a,b),~p(c,d),~p(e,f),~p(g,h),~p(i,j),q(c)} psi = new Clause(); psi.addNegativeLiteral((Predicate)parser.parse("P(A,B)")); psi.addNegativeLiteral((Predicate)parser.parse("P(C,D)")); psi.addNegativeLiteral((Predicate)parser.parse("P(E,F)")); psi.addNegativeLiteral((Predicate)parser.parse("P(G,H)")); psi.addNegativeLiteral((Predicate)parser.parse("P(I,J)")); psi.addPositiveLiteral((Predicate)parser.parse("Q(C)")); // {~p(i,j)} phi = new Clause(); phi.addNegativeLiteral((Predicate)parser.parse("P(I,J)")); Assert.IsTrue(phi.subsumes(psi)); // Example // {~p(a,b),~p(c,d),~p(e,f),q(c)} psi = new Clause(); psi.addNegativeLiteral((Predicate)parser.parse("P(A,B)")); psi.addNegativeLiteral((Predicate)parser.parse("P(C,D)")); psi.addNegativeLiteral((Predicate)parser.parse("P(E,F)")); psi.addPositiveLiteral((Predicate)parser.parse("Q(C)")); // {~p(e,f),~p(a,b),~p(c,d)} phi = new Clause(); phi.addNegativeLiteral((Predicate)parser.parse("P(E,F)")); phi.addNegativeLiteral((Predicate)parser.parse("P(A,B)")); phi.addNegativeLiteral((Predicate)parser.parse("P(C,D)")); Assert.IsTrue(phi.subsumes(psi)); // Example // {~p(a,b),~p(c,d),~p(e,f),~p(g,h),~p(i,j),q(c)} psi = new Clause(); psi.addNegativeLiteral((Predicate)parser.parse("P(A,B)")); psi.addNegativeLiteral((Predicate)parser.parse("P(C,D)")); psi.addNegativeLiteral((Predicate)parser.parse("P(E,F)")); psi.addNegativeLiteral((Predicate)parser.parse("P(G,H)")); psi.addNegativeLiteral((Predicate)parser.parse("P(I,J)")); psi.addPositiveLiteral((Predicate)parser.parse("Q(C)")); // {~p(i,j),~p(c,d)} phi = new Clause(); phi.addNegativeLiteral((Predicate)parser.parse("P(I,J)")); phi.addNegativeLiteral((Predicate)parser.parse("P(C,D)")); Assert.IsTrue(phi.subsumes(psi)); // Non-Example // {~p(a,b),~p(x,d),~p(e,f),~p(g,h),~p(i,j),q(c)} psi = new Clause(); psi.addNegativeLiteral((Predicate)parser.parse("P(A,B)")); psi.addNegativeLiteral((Predicate)parser.parse("P(x,D)")); psi.addNegativeLiteral((Predicate)parser.parse("P(E,F)")); psi.addNegativeLiteral((Predicate)parser.parse("P(G,H)")); psi.addNegativeLiteral((Predicate)parser.parse("P(I,J)")); psi.addPositiveLiteral((Predicate)parser.parse("Q(C)")); // {~p(i,j),~p(c,d)} phi = new Clause(); phi.addNegativeLiteral((Predicate)parser.parse("P(I,J)")); phi.addNegativeLiteral((Predicate)parser.parse("P(C,D)")); Assert.IsFalse(phi.subsumes(psi)); // Example // {~p(a,b),~p(c,d),~p(e,f),~p(g,h),~p(i,j),q(c)} psi = new Clause(); psi.addNegativeLiteral((Predicate)parser.parse("P(A,B)")); psi.addNegativeLiteral((Predicate)parser.parse("P(C,D)")); psi.addNegativeLiteral((Predicate)parser.parse("P(E,F)")); psi.addNegativeLiteral((Predicate)parser.parse("P(G,H)")); psi.addNegativeLiteral((Predicate)parser.parse("P(I,J)")); psi.addPositiveLiteral((Predicate)parser.parse("Q(C)")); // {~p(i,j),~p(a,x)} phi = new Clause(); phi.addNegativeLiteral((Predicate)parser.parse("P(I,J)")); phi.addNegativeLiteral((Predicate)parser.parse("P(A,x)")); Assert.IsTrue(phi.subsumes(psi)); // Example // {~p(a,b),~p(c,d),~p(e,f),~p(g,h),~p(i,j),q(a,b),q(c,d),q(e,f)} psi = new Clause(); psi.addNegativeLiteral((Predicate)parser.parse("P(A,B)")); psi.addNegativeLiteral((Predicate)parser.parse("P(C,D)")); psi.addNegativeLiteral((Predicate)parser.parse("P(E,F)")); psi.addNegativeLiteral((Predicate)parser.parse("P(G,H)")); psi.addNegativeLiteral((Predicate)parser.parse("P(I,J)")); psi.addPositiveLiteral((Predicate)parser.parse("Q(A,B)")); psi.addPositiveLiteral((Predicate)parser.parse("Q(C,D)")); psi.addPositiveLiteral((Predicate)parser.parse("Q(E,F)")); // {~p(i,j),~p(a,b),q(e,f),q(a,b)} phi = new Clause(); phi.addNegativeLiteral((Predicate)parser.parse("P(I,J)")); phi.addNegativeLiteral((Predicate)parser.parse("P(A,B)")); phi.addPositiveLiteral((Predicate)parser.parse("Q(E,F)")); phi.addPositiveLiteral((Predicate)parser.parse("Q(A,B)")); Assert.IsTrue(phi.subsumes(psi)); // Non-Example // {~p(a,b),~p(c,d),~p(e,f),~p(g,h),~p(i,j),q(a,b),q(c,d),q(e,f)} psi = new Clause(); psi.addNegativeLiteral((Predicate)parser.parse("P(A,B)")); psi.addNegativeLiteral((Predicate)parser.parse("P(C,D)")); psi.addNegativeLiteral((Predicate)parser.parse("P(E,F)")); psi.addNegativeLiteral((Predicate)parser.parse("P(G,H)")); psi.addNegativeLiteral((Predicate)parser.parse("P(I,J)")); psi.addPositiveLiteral((Predicate)parser.parse("Q(A,B)")); psi.addPositiveLiteral((Predicate)parser.parse("Q(C,D)")); psi.addPositiveLiteral((Predicate)parser.parse("Q(E,F)")); // {~p(i,j),~p(a,b),q(e,f),q(a,b)} phi = new Clause(); phi.addNegativeLiteral((Predicate)parser.parse("P(I,J)")); phi.addNegativeLiteral((Predicate)parser.parse("P(A,B)")); phi.addPositiveLiteral((Predicate)parser.parse("Q(E,A)")); phi.addPositiveLiteral((Predicate)parser.parse("Q(A,B)")); Assert.IsFalse(phi.subsumes(psi)); }
public void testBypassReflexivityAxiom() { FOLDomain domain = new FOLDomain(); domain.addConstant("A"); domain.addConstant("B"); domain.addConstant("C"); domain.addPredicate("P"); domain.addFunction("F"); FOLParser parser = new FOLParser(domain); List<Literal> lits = new List<Literal>(); Predicate p1 = (Predicate)parser.parse("P(y, F(A,y))"); lits.Add(new Literal(p1)); Clause clExpression = new Clause(lits); TermEquality assertion = (TermEquality)parser.parse("x = x"); Clause altClExpression = demodulation.apply(assertion, clExpression); Assert.IsNull(altClExpression); }
public void testSimpleClauseExamples() { FOLDomain domain = new FOLDomain(); domain.addConstant("A"); domain.addConstant("B"); domain.addConstant("C"); domain.addConstant("D"); domain.addConstant("E"); domain.addPredicate("P"); domain.addPredicate("Q"); domain.addPredicate("W"); domain.addFunction("F"); domain.addFunction("G"); domain.addFunction("H"); domain.addFunction("J"); FOLParser parser = new FOLParser(domain); List<Literal> lits = new List<Literal>(); Predicate p1 = (Predicate)parser.parse("Q(z, G(D,B))"); Predicate p2 = (Predicate)parser.parse("P(x, G(A,C))"); Predicate p3 = (Predicate)parser.parse("W(z,x,u,w,y)"); lits.Add(new Literal(p1)); lits.Add(new Literal(p2)); lits.Add(new Literal(p3)); Clause clExpression = new Clause(lits); TermEquality assertion = (TermEquality)parser.parse("G(x,y) = x"); Clause altClExpression = demodulation.apply(assertion, clExpression); Assert.AreEqual("[P(x,G(A,C)), Q(z,D), W(z,x,u,w,y)]", altClExpression.ToString()); altClExpression = demodulation.apply(assertion, altClExpression); Assert.AreEqual("[P(x,A), Q(z,D), W(z,x,u,w,y)]", altClExpression .ToString()); }
public void testQuantifiedSentence() { FOLDomain domain = new FOLDomain(); domain.addConstant("A"); domain.addConstant("B"); domain.addConstant("C"); domain.addFunction("Plus"); domain.addPredicate("P"); FOLParser parser = new FOLParser(domain); Sentence s1 = parser .parse("FORALL x,y ((P(x) AND P(A)) OR (P(A) => P(y)))"); Sentence s2 = parser .parse("FORALL x,y ((P(x) AND P(A)) OR (P(A) => P(y)))"); Dictionary<Variable, Term> result = unifier.unify(s1, s2); Assert.IsNotNull(result); Assert.AreEqual(0, result.Count); s1 = parser.parse("FORALL x,y ((P(x) AND P(A)) OR (P(A) => P(y)))"); s2 = parser.parse("FORALL x ((P(x) AND P(A)) OR (P(A) => P(y)))"); result = unifier.unify(s1, s2); Assert.IsNull(result); s1 = parser.parse("FORALL x,y ((P(x) AND P(A)) OR (P(A) => P(y)))"); s2 = parser.parse("FORALL x,y ((P(x) AND P(A)) OR (P(B) => P(y)))"); result = unifier.unify(s1, s2); Assert.IsNull(result); s1 = parser.parse("FORALL x,y ((P(x) AND P(A)) OR (P(A) => P(y)))"); s2 = parser.parse("FORALL x,y ((P(A) AND P(A)) OR (P(A) => P(y)))"); result = unifier.unify(s1, s2); Assert.IsNotNull(result); Assert.AreEqual(1, result.Count); Assert.AreEqual(new Constant("A"), result[new Variable("x")]); // s1 = parser.parse("EXISTS x,y ((P(x) AND P(A)) OR (P(A) => P(y)))"); s2 = parser.parse("EXISTS x,y ((P(x) AND P(A)) OR (P(A) => P(y)))"); result = unifier.unify(s1, s2); Assert.IsNotNull(result); Assert.AreEqual(0, result.Count); s1 = parser.parse("EXISTS x,y ((P(x) AND P(A)) OR (P(A) => P(y)))"); s2 = parser.parse("EXISTS x ((P(x) AND P(A)) OR (P(A) => P(y)))"); result = unifier.unify(s1, s2); Assert.IsNull(result); s1 = parser.parse("EXISTS x,y ((P(x) AND P(A)) OR (P(A) => P(y)))"); s2 = parser.parse("EXISTS x,y ((P(x) AND P(A)) OR (P(B) => P(y)))"); result = unifier.unify(s1, s2); Assert.IsNull(result); s1 = parser.parse("EXISTS x,y ((P(x) AND P(A)) OR (P(A) => P(y)))"); s2 = parser.parse("EXISTS x,y ((P(A) AND P(A)) OR (P(A) => P(y)))"); result = unifier.unify(s1, s2); Assert.IsNotNull(result); Assert.AreEqual(1, result.Count); Assert.AreEqual(new Constant("A"), result[new Variable("x")]); }
public void testIsTautology() { FOLDomain domain = new FOLDomain(); domain.addConstant("A"); domain.addPredicate("P"); domain.addPredicate("Q"); domain.addPredicate("R"); domain.addFunction("F"); FOLParser parser = new FOLParser(domain); // {p(f(a)),~p(f(a))} Clause c = new Clause(); c.addPositiveLiteral((Predicate)parser.parse("P(F(A))")); Assert.IsFalse(c.isTautology()); c.addNegativeLiteral((Predicate)parser.parse("P(F(A))")); Assert.IsTrue(c.isTautology()); // {p(x),q(y),~q(y),r(z)} c = new Clause(); c.addPositiveLiteral((Predicate)parser.parse("P(x)")); Assert.IsFalse(c.isTautology()); c.addPositiveLiteral((Predicate)parser.parse("Q(y)")); Assert.IsFalse(c.isTautology()); c.addNegativeLiteral((Predicate)parser.parse("Q(y)")); Assert.IsTrue(c.isTautology()); c.addPositiveLiteral((Predicate)parser.parse("R(z)")); Assert.IsTrue(c.isTautology()); // {~p(a),p(x)} c = new Clause(); c.addNegativeLiteral((Predicate)parser.parse("P(A)")); Assert.IsFalse(c.isTautology()); c.addPositiveLiteral((Predicate)parser.parse("P(x)")); Assert.IsFalse(c.isTautology()); }
public void testFindSubsumedClauses() { // Taken from AIMA2e pg 679 FOLDomain domain = new FOLDomain(); domain.addPredicate("patrons"); domain.addPredicate("hungry"); domain.addPredicate("type"); domain.addPredicate("fri_sat"); domain.addPredicate("will_wait"); domain.addConstant("Some"); domain.addConstant("Full"); domain.addConstant("French"); domain.addConstant("Thai"); domain.addConstant("Burger"); FOLParser parser = new FOLParser(domain); String c1 = "patrons(v,Some)"; String c2 = "patrons(v,Full) AND (hungry(v) AND type(v,French))"; String c3 = "patrons(v,Full) AND (hungry(v) AND (type(v,Thai) AND fri_sat(v)))"; String c4 = "patrons(v,Full) AND (hungry(v) AND type(v,Burger))"; String sh = "FORALL v (will_wait(v) <=> (" + c1 + " OR (" + c2 + " OR (" + c3 + " OR (" + c4 + ")))))"; Sentence s = parser.parse(sh); CNFConverter cnfConv = new CNFConverter(parser); CNF cnf = cnfConv.convertToCNF(s); // Contains 9 duplicates Assert.AreEqual(40, cnf.getNumberOfClauses()); List<Clause> clauses = new List<Clause>(cnf.getConjunctionOfClauses()); // duplicates removed Assert.AreEqual(31, clauses.Count); foreach (Clause remove in SubsumptionElimination.findSubsumedClauses(clauses)) { clauses.Remove(remove); } // subsumed clauses removed Assert.AreEqual(8, clauses.Count); // Ensure only the 8 correct/expected clauses remain Clause cl1 = cnfConv .convertToCNF( parser .parse("(NOT(will_wait(v)) OR (patrons(v,Full) OR patrons(v,Some)))")) .getConjunctionOfClauses()[0]; Clause cl2 = cnfConv .convertToCNF( parser .parse("(NOT(will_wait(v)) OR (hungry(v) OR patrons(v,Some)))")) .getConjunctionOfClauses()[0]; Clause cl3 = cnfConv .convertToCNF( parser .parse("(NOT(will_wait(v)) OR (patrons(v,Some) OR (type(v,Burger) OR (type(v,French) OR type(v,Thai)))))")) .getConjunctionOfClauses()[0]; Clause cl4 = cnfConv .convertToCNF( parser .parse("(NOT(will_wait(v)) OR (fri_sat(v) OR (patrons(v,Some) OR (type(v,Burger) OR type(v,French)))))")) .getConjunctionOfClauses()[0]; Clause cl5 = cnfConv.convertToCNF( parser.parse("(NOT(patrons(v,Some)) OR will_wait(v))")) .getConjunctionOfClauses()[0]; Clause cl6 = cnfConv .convertToCNF( parser .parse("(NOT(hungry(v)) OR (NOT(patrons(v,Full)) OR (NOT(type(v,French)) OR will_wait(v))))")) .getConjunctionOfClauses()[0]; Clause cl7 = cnfConv .convertToCNF( parser .parse("(NOT(fri_sat(v)) OR (NOT(hungry(v)) OR (NOT(patrons(v,Full)) OR (NOT(type(v,Thai)) OR will_wait(v)))))")) .getConjunctionOfClauses()[0]; Clause cl8 = cnfConv .convertToCNF( parser .parse("(NOT(hungry(v)) OR (NOT(patrons(v,Full)) OR (NOT(type(v,Burger)) OR will_wait(v))))")) .getConjunctionOfClauses()[0]; Assert.IsTrue(clauses.Contains(cl1)); Assert.IsTrue(clauses.Contains(cl2)); Assert.IsTrue(clauses.Contains(cl3)); Assert.IsTrue(clauses.Contains(cl4)); Assert.IsTrue(clauses.Contains(cl5)); Assert.IsTrue(clauses.Contains(cl6)); Assert.IsTrue(clauses.Contains(cl7)); Assert.IsTrue(clauses.Contains(cl8)); }
// Note: see - // http://logic.stanford.edu/classes/cs157/2008/lectures/lecture15.pdf // slide 12 for where this test example was taken from. public static FOLKnowledgeBase createABCEqualityKnowledgeBase( InferenceProcedure infp, bool includeEqualityAxioms) { FOLDomain domain = new FOLDomain(); domain.addConstant("A"); domain.addConstant("B"); domain.addConstant("C"); FOLKnowledgeBase kb = new FOLKnowledgeBase(domain, infp); kb.tell("B = A"); kb.tell("B = C"); if (includeEqualityAxioms) { // Reflexivity Axiom kb.tell("x = x"); // Symmetry Axiom kb.tell("(x = y => y = x)"); // Transitivity Axiom kb.tell("((x = y AND y = z) => x = z)"); } return kb; }
public void testInductionAxiomSchema() { FOLDomain domain = new FOLDomain(); domain.addPredicate("Equal"); domain.addFunction("Plus"); domain.addConstant("A"); domain.addConstant("B"); domain.addConstant("N"); domain.addConstant("ONE"); domain.addConstant("ZERO"); FOLParser parser = new FOLParser(domain); CNFConverter cnfConv = new CNFConverter(parser); // Base Case: Sentence sent = parser .parse("NOT(FORALL x (FORALL y (Equal(Plus(Plus(x,y),ZERO), Plus(x,Plus(y,ZERO))))))"); CNF cnf = cnfConv.convertToCNF(sent); Assert.AreEqual( "[~Equal(Plus(Plus(SC0,SC1),ZERO),Plus(SC0,Plus(SC1,ZERO)))]", cnf.ToString()); // Instance of Induction Axion Scmema sent = parser .parse("((" + "Equal(Plus(Plus(A,B),ZERO), Plus(A,Plus(B,ZERO)))" + " AND " + "(FORALL x (FORALL y (FORALL z(" + "Equal(Plus(Plus(x,y),z), Plus(x,Plus(y,z)))" + " => " + "Equal(Plus(Plus(x,y),Plus(z,ONE)), Plus(x,Plus(y,Plus(z,ONE))))" + "))))" + ")" + " => " + "FORALL x (FORALL y (FORALL z(" + "Equal(Plus(Plus(x,y),z), Plus(x,Plus(y,z)))" + "))))"); cnf = cnfConv.convertToCNF(sent); Assert .AreEqual( "[~Equal(Plus(Plus(A,B),ZERO),Plus(A,Plus(B,ZERO))), Equal(Plus(Plus(q0,q1),q2),Plus(q0,Plus(q1,q2))), Equal(Plus(Plus(SC2,SC3),SC4),Plus(SC2,Plus(SC3,SC4)))],[~Equal(Plus(Plus(A,B),ZERO),Plus(A,Plus(B,ZERO))), ~Equal(Plus(Plus(SC2,SC3),Plus(SC4,ONE)),Plus(SC2,Plus(SC3,Plus(SC4,ONE)))), Equal(Plus(Plus(q0,q1),q2),Plus(q0,Plus(q1,q2)))]", cnf.ToString()); // Goal sent = parser .parse("NOT(FORALL x (FORALL y (FORALL z (Equal(Plus(Plus(x,y),z), Plus(x,Plus(y,z)))))))"); cnf = cnfConv.convertToCNF(sent); Assert.AreEqual( "[~Equal(Plus(Plus(SC5,SC6),SC7),Plus(SC5,Plus(SC6,SC7)))]", cnf.ToString()); }
public void testTermEquality() { FOLDomain domain = new FOLDomain(); domain.addPredicate("P"); domain.addPredicate("Q"); domain.addPredicate("R"); domain.addConstant("A"); domain.addConstant("B"); domain.addConstant("C"); domain.addConstant("D"); domain.addFunction("Plus"); domain.addConstant("ONE"); domain.addConstant("ZERO"); FOLParser parser = new FOLParser(domain); CNFConverter cnfConv = new CNFConverter(parser); // x=y Sentence sent = parser.parse("x = y"); CNF cnf = cnfConv.convertToCNF(sent); Assert.AreEqual("[x = y]", cnf.ToString()); // x!=y sent = parser.parse("NOT(x = y)"); cnf = cnfConv.convertToCNF(sent); Assert.AreEqual("[~x = y]", cnf.ToString()); // A=B sent = parser.parse("A = B"); cnf = cnfConv.convertToCNF(sent); Assert.AreEqual("[A = B]", cnf.ToString()); // A!=B sent = parser.parse("NOT(A = B)"); cnf = cnfConv.convertToCNF(sent); Assert.AreEqual("[~A = B]", cnf.ToString()); // ~(((~A=B or ~D=C) => ~(A=B or D=C)) => A=D) sent = parser .parse("NOT(((((NOT(A = B) OR NOT(D = C))) => NOT((A = B OR D = C))) => A = D))"); cnf = cnfConv.convertToCNF(sent); Assert .AreEqual( "[~A = B, A = B],[~A = B, D = C],[~D = C, A = B],[~D = C, D = C],[~A = D]", cnf.ToString()); // // Induction Axiom Schema using Term Equality // Base Case: sent = parser .parse("NOT(FORALL x (FORALL y (Plus(Plus(x,y),ZERO) = Plus(x,Plus(y,ZERO)))))"); cnf = cnfConv.convertToCNF(sent); Assert.AreEqual( "[~Plus(Plus(SC0,SC1),ZERO) = Plus(SC0,Plus(SC1,ZERO))]", cnf .ToString()); // Instance of Induction Axion Scmema sent = parser.parse("((" + "Plus(Plus(A,B),ZERO) = Plus(A,Plus(B,ZERO))" + " AND " + "(FORALL x (FORALL y (FORALL z(" + "Plus(Plus(x,y),z) = Plus(x,Plus(y,z))" + " => " + "Plus(Plus(x,y),Plus(z,ONE)) = Plus(x,Plus(y,Plus(z,ONE)))" + "))))" + ")" + " => " + "FORALL x (FORALL y (FORALL z(" + "Plus(Plus(x,y),z) = Plus(x,Plus(y,z))" + "))))"); cnf = cnfConv.convertToCNF(sent); Assert .AreEqual( "[~Plus(Plus(A,B),ZERO) = Plus(A,Plus(B,ZERO)), Plus(Plus(q0,q1),q2) = Plus(q0,Plus(q1,q2)), Plus(Plus(SC2,SC3),SC4) = Plus(SC2,Plus(SC3,SC4))],[~Plus(Plus(A,B),ZERO) = Plus(A,Plus(B,ZERO)), ~Plus(Plus(SC2,SC3),Plus(SC4,ONE)) = Plus(SC2,Plus(SC3,Plus(SC4,ONE))), Plus(Plus(q0,q1),q2) = Plus(q0,Plus(q1,q2))]", cnf.ToString()); // Goal sent = parser .parse("NOT(FORALL x (FORALL y (FORALL z (Plus(Plus(x,y),z) = Plus(x,Plus(y,z))))))"); cnf = cnfConv.convertToCNF(sent); Assert.AreEqual( "[~Plus(Plus(SC5,SC6),SC7) = Plus(SC5,Plus(SC6,SC7))]", cnf .ToString()); }
public void testMultipleTermEqualitiesInBothClausesExample() { FOLDomain domain = new FOLDomain(); domain.addConstant("A"); domain.addConstant("B"); domain.addConstant("C"); domain.addConstant("D"); domain.addPredicate("P"); domain.addPredicate("Q"); domain.addPredicate("R"); domain.addFunction("F"); FOLParser parser = new FOLParser(domain); List<Literal> lits = new List<Literal>(); AtomicSentence a1 = (AtomicSentence)parser.parse("F(C,x) = D"); AtomicSentence a2 = (AtomicSentence)parser.parse("A = D"); AtomicSentence a3 = (AtomicSentence)parser.parse("P(F(x,B),x)"); AtomicSentence a4 = (AtomicSentence)parser.parse("Q(x)"); AtomicSentence a5 = (AtomicSentence)parser.parse("R(C)"); lits.Add(new Literal(a1)); lits.Add(new Literal(a2)); lits.Add(new Literal(a3)); lits.Add(new Literal(a4)); lits.Add(new Literal(a5)); Clause c1 = new Clause(lits); lits.Clear(); a1 = (AtomicSentence)parser.parse("F(A,y) = y"); a2 = (AtomicSentence)parser.parse("F(B,y) = C"); a3 = (AtomicSentence)parser.parse("R(y)"); a4 = (AtomicSentence)parser.parse("R(A)"); lits.Add(new Literal(a1)); lits.Add(new Literal(a2)); lits.Add(new Literal(a3)); lits.Add(new Literal(a4)); Clause c2 = new Clause(lits); List<Clause> paras = paramodulation.apply(c1, c2); Assert.AreEqual(5, paras.Count); List<Clause>.Enumerator it = paras.GetEnumerator(); it.MoveNext(); Assert .AreEqual( "[F(B,B) = C, F(C,A) = D, A = D, P(B,A), Q(A), R(A), R(B), R(C)]", it.Current.ToString()); it.MoveNext(); Assert .AreEqual( "[F(A,F(C,x)) = D, F(B,F(C,x)) = C, A = D, P(F(x,B),x), Q(x), R(F(C,x)), R(A), R(C)]", it.Current.ToString()); it.MoveNext(); Assert .AreEqual( "[F(A,B) = B, F(C,B) = D, A = D, P(C,B), Q(B), R(A), R(B), R(C)]", it.Current.ToString()); it.MoveNext(); Assert .AreEqual( "[F(F(B,y),x) = D, F(A,y) = y, A = D, P(F(x,B),x), Q(x), R(y), R(A), R(C)]", it.Current.ToString()); it.MoveNext(); Assert .AreEqual( "[F(B,y) = C, F(C,x) = D, F(D,y) = y, P(F(x,B),x), Q(x), R(y), R(A), R(C)]", it.Current.ToString()); }
public void testEqualityBinaryResolvents() { FOLDomain domain = new FOLDomain(); domain.addConstant("A"); domain.addConstant("B"); FOLParser parser = new FOLParser(domain); // B = A Clause c1 = new Clause(); c1.addPositiveLiteral((AtomicSentence)parser.parse("B = A")); Clause c2 = new Clause(); c2.addNegativeLiteral((AtomicSentence)parser.parse("B = A")); c2.addPositiveLiteral((AtomicSentence)parser.parse("B = A")); List<Clause> resolvents = c1.binaryResolvents(c2); Assert.AreEqual(1, resolvents.Count); Assert.AreEqual("[[B = A]]", resolvents.ToString()); }
public void testComplexEquals() { FOLDomain domain = new FOLDomain(); domain.addConstant("A"); domain.addConstant("B"); domain.addConstant("C"); domain.addConstant("D"); domain.addPredicate("P"); domain.addPredicate("Animal"); domain.addPredicate("Kills"); domain.addFunction("F"); domain.addFunction("SF0"); FOLParser parser = new FOLParser(domain); CNFConverter cnfConverter = new CNFConverter(parser); Sentence s1 = parser.parse("((x1 = y1 AND y1 = z1) => x1 = z1)"); Sentence s2 = parser.parse("((x2 = y2 AND F(y2) = z2) => F(x2) = z2)"); CNF cnf1 = cnfConverter.convertToCNF(s1); CNF cnf2 = cnfConverter.convertToCNF(s2); Clause c1 = cnf1.getConjunctionOfClauses()[0]; Clause c2 = cnf2.getConjunctionOfClauses()[0]; Assert.IsFalse(c1.Equals(c2)); s1 = parser.parse("((x1 = y1 AND y1 = z1) => x1 = z1)"); s2 = parser.parse("((x2 = y2 AND y2 = z2) => x2 = z2)"); cnf1 = cnfConverter.convertToCNF(s1); cnf2 = cnfConverter.convertToCNF(s2); c1 = cnf1.getConjunctionOfClauses()[0]; c2 = cnf2.getConjunctionOfClauses()[0]; Assert.IsTrue(c1.Equals(c2)); s1 = parser.parse("((x1 = y1 AND y1 = z1) => x1 = z1)"); s2 = parser.parse("((y2 = z2 AND x2 = y2) => x2 = z2)"); cnf1 = cnfConverter.convertToCNF(s1); cnf2 = cnfConverter.convertToCNF(s2); c1 = cnf1.getConjunctionOfClauses()[0]; c2 = cnf2.getConjunctionOfClauses()[0]; Assert.IsTrue(c1.Equals(c2)); s1 = parser.parse("(((x1 = y1 AND y1 = z1) AND z1 = r1) => x1 = r1)"); s2 = parser.parse("(((x2 = y2 AND y2 = z2) AND z2 = r2) => x2 = r2)"); cnf1 = cnfConverter.convertToCNF(s1); cnf2 = cnfConverter.convertToCNF(s2); c1 = cnf1.getConjunctionOfClauses()[0]; c2 = cnf2.getConjunctionOfClauses()[0]; Assert.IsTrue(c1.Equals(c2)); s1 = parser.parse("(((x1 = y1 AND y1 = z1) AND z1 = r1) => x1 = r1)"); s2 = parser.parse("(((z2 = r2 AND y2 = z2) AND x2 = y2) => x2 = r2)"); cnf1 = cnfConverter.convertToCNF(s1); cnf2 = cnfConverter.convertToCNF(s2); c1 = cnf1.getConjunctionOfClauses()[0]; c2 = cnf2.getConjunctionOfClauses()[0]; Assert.IsTrue(c1.Equals(c2)); s1 = parser.parse("(((x1 = y1 AND y1 = z1) AND z1 = r1) => x1 = r1)"); s2 = parser.parse("(((x2 = y2 AND y2 = z2) AND z2 = y2) => x2 = r2)"); cnf1 = cnfConverter.convertToCNF(s1); cnf2 = cnfConverter.convertToCNF(s2); c1 = cnf1.getConjunctionOfClauses()[0]; c2 = cnf2.getConjunctionOfClauses()[0]; Assert.IsFalse(c1.Equals(c2)); s1 = parser .parse("(((((x1 = y1 AND y1 = z1) AND z1 = r1) AND r1 = q1) AND q1 = s1) => x1 = r1)"); s2 = parser .parse("(((((x2 = y2 AND y2 = z2) AND z2 = r2) AND r2 = q2) AND q2 = s2) => x2 = r2)"); cnf1 = cnfConverter.convertToCNF(s1); cnf2 = cnfConverter.convertToCNF(s2); c1 = cnf1.getConjunctionOfClauses()[0]; c2 = cnf2.getConjunctionOfClauses()[0]; Assert.IsTrue(c1.Equals(c2)); s1 = parser .parse("((((NOT(Animal(c1920)) OR NOT(Animal(c1921))) OR NOT(Kills(c1922,c1920))) OR NOT(Kills(c1919,c1921))) OR NOT(Kills(SF0(c1922),SF0(c1919))))"); s2 = parser .parse("((((NOT(Animal(c1929)) OR NOT(Animal(c1928))) OR NOT(Kills(c1927,c1929))) OR NOT(Kills(c1930,c1928))) OR NOT(Kills(SF0(c1930),SF0(c1927))))"); cnf1 = cnfConverter.convertToCNF(s1); cnf2 = cnfConverter.convertToCNF(s2); c1 = cnf1.getConjunctionOfClauses()[0]; c2 = cnf2.getConjunctionOfClauses()[0]; Assert.IsTrue(c1.Equals(c2)); }
public void testNegationsAndNestedImplications() { FOLDomain domain = new FOLDomain(); domain.addPredicate("P"); domain.addPredicate("Q"); domain.addPredicate("R"); domain.addConstant("A"); FOLParser parser = new FOLParser(domain); CNFConverter cnfConv = new CNFConverter(parser); // ~(((~p or ~q) => ~(p or q)) => r) Sentence sent = parser .parse("NOT(((((NOT(P(A)) OR NOT(Q(A)))) => NOT((P(A) OR Q(A)))) => R(A)))"); CNF cnf = cnfConv.convertToCNF(sent); Assert .AreEqual( "[~P(A), P(A)],[~P(A), Q(A)],[~Q(A), P(A)],[~Q(A), Q(A)],[~R(A)]", cnf.ToString()); }
public void testAdditionalVariableMixtures() { FOLDomain domain = new FOLDomain(); domain.addConstant("A"); domain.addConstant("B"); domain.addFunction("F"); domain.addFunction("G"); domain.addFunction("H"); domain.addPredicate("P"); FOLParser parser = new FOLParser(domain); // Test Cascade Substitutions handled correctly Sentence s1 = parser.parse("P(z, x)"); Sentence s2 = parser.parse("P(x, a)"); Dictionary<Variable, Term> result = unifier.unify(s1, s2); Assert.AreEqual("{z=a, x=a}", result.ToString()); s1 = parser.parse("P(x, z)"); s2 = parser.parse("P(a, x)"); result = unifier.unify(s1, s2); Assert.AreEqual("{x=a, z=a}", result.ToString()); s1 = parser.parse("P(w, w, w)"); s2 = parser.parse("P(x, y, z)"); result = unifier.unify(s1, s2); Assert.AreEqual("{w=z, x=z, y=z}", result.ToString()); s1 = parser.parse("P(x, y, z)"); s2 = parser.parse("P(w, w, w)"); result = unifier.unify(s1, s2); Assert.AreEqual("{x=w, y=w, z=w}", result.ToString()); s1 = parser.parse("P(x, B, F(y))"); s2 = parser.parse("P(A, y, F(z))"); result = unifier.unify(s1, s2); Assert.AreEqual("{x=A, y=B, z=B}", result.ToString()); s1 = parser.parse("P(F(x,B), G(y), F(z,A))"); s2 = parser.parse("P(y, G(F(G(w),w)), F(w,z))"); result = unifier.unify(s1, s2); Assert.IsNull(result); s1 = parser.parse("P(F(G(A)), x, F(H(z,z)), H(y, G(w)))"); s2 = parser.parse("P(y, G(z), F(v ), H(F(w), x ))"); result = unifier.unify(s1, s2); Assert.AreEqual( "{y=F(G(A)), x=G(G(A)), v=H(G(A),G(A)), w=G(A), z=G(A)}", result.ToString()); }
// Note: see - // http://logic.stanford.edu/classes/cs157/2008/lectures/lecture15.pdf // slide 16,17, and 18 for where this test example was taken from. public static FOLKnowledgeBase createABCDEqualityAndSubstitutionKnowledgeBase( InferenceProcedure infp, bool includeEqualityAxioms) { FOLDomain domain = new FOLDomain(); domain.addConstant("A"); domain.addConstant("B"); domain.addConstant("C"); domain.addConstant("D"); domain.addPredicate("P"); domain.addFunction("F"); FOLKnowledgeBase kb = new FOLKnowledgeBase(domain, infp); kb.tell("F(A) = B"); kb.tell("F(B) = A"); kb.tell("C = D"); kb.tell("P(A)"); kb.tell("P(C)"); if (includeEqualityAxioms) { // Reflexivity Axiom kb.tell("x = x"); // Symmetry Axiom kb.tell("(x = y => y = x)"); // Transitivity Axiom kb.tell("((x = y AND y = z) => x = z)"); // Function F Substitution Axiom kb.tell("((x = y AND F(y) = z) => F(x) = z)"); // Predicate P Substitution Axiom kb.tell("((x = y AND P(y)) => P(x))"); } return kb; }
public void testTermEquality() { FOLDomain domain = new FOLDomain(); domain.addConstant("A"); domain.addConstant("B"); domain.addFunction("Plus"); FOLParser parser = new FOLParser(domain); TermEquality te1 = (TermEquality)parser.parse("x = x"); TermEquality te2 = (TermEquality)parser.parse("x = x"); // Both term equalities the same, // should unify but no substitutions. Dictionary<Variable, Term> result = unifier.unify(te1, te2); Assert.IsNotNull(result); Assert.AreEqual(0, result.Count); // Different variable names but should unify. te1 = (TermEquality)parser.parse("x1 = x1"); te2 = (TermEquality)parser.parse("x2 = x2"); result = unifier.unify(te1, te2); Assert.IsNotNull(result); Assert.AreEqual(1, result.Count); Assert.AreEqual("{x1=x2}", result.ToString()); // Test simple unification with reflexivity axiom te1 = (TermEquality)parser.parse("x1 = x1"); te2 = (TermEquality)parser.parse("Plus(A,B) = Plus(A,B)"); result = unifier.unify(te1, te2); Assert.IsNotNull(result); Assert.AreEqual(1, result.Count); Assert.AreEqual("{x1=Plus(A,B)}", result.ToString()); // Test more complex unification with reflexivity axiom te1 = (TermEquality)parser.parse("x1 = x1"); te2 = (TermEquality)parser.parse("Plus(A,B) = Plus(A,z1)"); result = unifier.unify(te1, te2); Assert.IsNotNull(result); Assert.AreEqual(2, result.Count); Assert.AreEqual("{x1=Plus(A,B), z1=B}", result.ToString()); // Test reverse of previous unification with reflexivity axiom // Should still be the same. te1 = (TermEquality)parser.parse("x1 = x1"); te2 = (TermEquality)parser.parse("Plus(A,z1) = Plus(A,B)"); result = unifier.unify(te1, te2); Assert.IsNotNull(result); Assert.AreEqual(2, result.Count); Assert.AreEqual("{x1=Plus(A,B), z1=B}", result.ToString()); // Test with nested terms te1 = (TermEquality)parser .parse("Plus(Plus(Plus(A,B),B, A)) = Plus(Plus(Plus(A,B),B, A))"); te2 = (TermEquality)parser .parse("Plus(Plus(Plus(A,B),B, A)) = Plus(Plus(Plus(A,B),B, A))"); result = unifier.unify(te1, te2); Assert.IsNotNull(result); Assert.AreEqual(0, result.Count); // Simple term equality unification fails te1 = (TermEquality)parser.parse("Plus(A,B) = Plus(B,A)"); te2 = (TermEquality)parser.parse("Plus(A,B) = Plus(A,B)"); result = unifier.unify(te1, te2); Assert.IsNull(result); }
public void testNOTSentence() { FOLDomain domain = new FOLDomain(); domain.addConstant("A"); domain.addConstant("B"); domain.addConstant("C"); domain.addFunction("Plus"); domain.addPredicate("P"); FOLParser parser = new FOLParser(domain); Sentence s1 = parser.parse("NOT(P(A))"); Sentence s2 = parser.parse("NOT(P(A))"); Dictionary<Variable, Term> result = unifier.unify(s1, s2); Assert.IsNotNull(result); Assert.AreEqual(0, result.Count); s1 = parser.parse("NOT(P(A))"); s2 = parser.parse("NOT(P(B))"); result = unifier.unify(s1, s2); Assert.IsNull(result); s1 = parser.parse("NOT(P(A))"); s2 = parser.parse("NOT(P(x))"); result = unifier.unify(s1, s2); Assert.IsNotNull(result); Assert.AreEqual(1, result.Count); Assert.AreEqual(new Constant("A"), result[new Variable("x")]); }
public void testNonTrivialFactors() { FOLDomain domain = new FOLDomain(); domain.addConstant("A"); domain.addConstant("B"); domain.addFunction("F"); domain.addFunction("G"); domain.addFunction("H"); domain.addPredicate("P"); domain.addPredicate("Q"); FOLParser parser = new FOLParser(domain); // p(x,y), q(a,b), p(b,a), q(y,x) Clause c = new Clause(); c.addPositiveLiteral((Predicate)parser.parse("P(x,y)")); c.addPositiveLiteral((Predicate)parser.parse("Q(A,B)")); c.addNegativeLiteral((Predicate)parser.parse("P(B,A)")); c.addPositiveLiteral((Predicate)parser.parse("Q(y,x)")); Assert.AreEqual("[[~P(B,A), P(B,A), Q(A,B)]]", c .getNonTrivialFactors().ToString()); // p(x,y), q(a,b), p(b,a), q(y,x) c = new Clause(); c.addPositiveLiteral((Predicate)parser.parse("P(x,y)")); c.addPositiveLiteral((Predicate)parser.parse("Q(A,B)")); c.addNegativeLiteral((Predicate)parser.parse("P(B,A)")); c.addNegativeLiteral((Predicate)parser.parse("Q(y,x)")); Assert.AreEqual("[]", c.getNonTrivialFactors().ToString()); // p(x,f(y)), p(g(u),x), p(f(y),u) c = new Clause(); c.addPositiveLiteral((Predicate)parser.parse("P(x,F(y))")); c.addPositiveLiteral((Predicate)parser.parse("P(G(u),x)")); c.addPositiveLiteral((Predicate)parser.parse("P(F(y),u)")); // Should be: [{P(F(c#),F(c#)),P(G(F(c#)),F(c#))}] c = c.getNonTrivialFactors().First(); Literal p = c.getPositiveLiterals()[0]; Assert.AreEqual("P", p.getAtomicSentence().getSymbolicName()); Function f = (Function)p.getAtomicSentence().getArgs()[0]; Assert.AreEqual("F", f.getFunctionName()); Variable v = (Variable)f.getTerms()[0]; f = (Function)p.getAtomicSentence().getArgs()[1]; Assert.AreEqual("F", f.getFunctionName()); Assert.AreEqual(v, f.getTerms()[0]); // p = c.getPositiveLiterals()[1]; f = (Function)p.getAtomicSentence().getArgs()[0]; Assert.AreEqual("G", f.getFunctionName()); f = (Function)f.getTerms()[0]; Assert.AreEqual("F", f.getFunctionName()); Assert.AreEqual(v, f.getTerms()[0]); f = (Function)p.getAtomicSentence().getArgs()[1]; Assert.AreEqual("F", f.getFunctionName()); Assert.AreEqual(v, f.getTerms()[0]); // p(g(x)), q(x), p(f(a)), p(x), p(g(f(x))), q(f(a)) c = new Clause(); c.addPositiveLiteral((Predicate)parser.parse("P(G(x))")); c.addPositiveLiteral((Predicate)parser.parse("Q(x)")); c.addPositiveLiteral((Predicate)parser.parse("P(F(A))")); c.addPositiveLiteral((Predicate)parser.parse("P(x)")); c.addPositiveLiteral((Predicate)parser.parse("P(G(F(x)))")); c.addPositiveLiteral((Predicate)parser.parse("Q(F(A))")); Assert.AreEqual("[[P(F(A)), P(G(F(F(A)))), P(G(F(A))), Q(F(A))]]", c.getNonTrivialFactors().ToString()); }