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 = Util.first(c.getNonTrivialFactors()); Literal p = c.getPositiveLiterals().Get(0); Assert.AreEqual("P", p.getAtomicSentence().getSymbolicName()); Function f = (Function)p.getAtomicSentence().getArgs().Get(0); Assert.AreEqual("F", f.getFunctionName()); Variable v = (Variable)f.getTerms().Get(0); f = (Function)p.getAtomicSentence().getArgs().Get(1); Assert.AreEqual("F", f.getFunctionName()); Assert.AreEqual(v, f.getTerms().Get(0)); // p = c.getPositiveLiterals().Get(1); f = (Function)p.getAtomicSentence().getArgs().Get(0); Assert.AreEqual("G", f.getFunctionName()); f = (Function)f.getTerms().Get(0); Assert.AreEqual("F", f.getFunctionName()); Assert.AreEqual(v, f.getTerms().Get(0)); f = (Function)p.getAtomicSentence().getArgs().Get(1); Assert.AreEqual("F", f.getFunctionName()); Assert.AreEqual(v, f.getTerms().Get(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()); }
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 setUp() { parser = new FOLParser(DomainFactory.crusadesDomain()); sv = new SubstVisitor(); }
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().Get(0); Clause c2 = cnf2.getConjunctionOfClauses().Get(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().Get(0); c2 = cnf2.getConjunctionOfClauses().Get(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().Get(0); c2 = cnf2.getConjunctionOfClauses().Get(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().Get(0); c2 = cnf2.getConjunctionOfClauses().Get(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().Get(0); c2 = cnf2.getConjunctionOfClauses().Get(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().Get(0); c2 = cnf2.getConjunctionOfClauses().Get(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().Get(0); c2 = cnf2.getConjunctionOfClauses().Get(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().Get(0); c2 = cnf2.getConjunctionOfClauses().Get(0); Assert.IsTrue(c1.Equals(c2)); }
public void testConnectedSentence() { 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("(P(A) AND P(B))"); Sentence s2 = parser.parse("(P(A) AND P(B))"); Dictionary <Variable, Term> result = unifier.unify(s1, s2); Assert.IsNotNull(result); Assert.AreEqual(0, result.Count); s1 = parser.parse("(P(A) AND P(B))"); s2 = parser.parse("(P(A) AND P(C))"); result = unifier.unify(s1, s2); Assert.IsNull(result); s1 = parser.parse("(P(A) AND P(B))"); s2 = parser.parse("(P(A) AND P(x))"); result = unifier.unify(s1, s2); Assert.IsNotNull(result); Assert.AreEqual(1, result.Count); Assert.AreEqual(new Constant("B"), result[new Variable("x")]); s1 = parser.parse("(P(A) OR P(B))"); s2 = parser.parse("(P(A) OR P(B))"); result = unifier.unify(s1, s2); Assert.IsNotNull(result); Assert.AreEqual(0, result.Count); s1 = parser.parse("(P(A) OR P(B))"); s2 = parser.parse("(P(A) OR P(C))"); result = unifier.unify(s1, s2); Assert.IsNull(result); s1 = parser.parse("(P(A) OR P(B))"); s2 = parser.parse("(P(A) OR P(x))"); result = unifier.unify(s1, s2); Assert.IsNotNull(result); Assert.AreEqual(1, result.Count); Assert.AreEqual(new Constant("B"), result[new Variable("x")]); s1 = parser.parse("(P(A) => P(B))"); s2 = parser.parse("(P(A) => P(B))"); result = unifier.unify(s1, s2); Assert.IsNotNull(result); Assert.AreEqual(0, result.Count); s1 = parser.parse("(P(A) => P(B))"); s2 = parser.parse("(P(A) => P(C))"); result = unifier.unify(s1, s2); Assert.IsNull(result); s1 = parser.parse("(P(A) => P(B))"); s2 = parser.parse("(P(A) => P(x))"); result = unifier.unify(s1, s2); Assert.IsNotNull(result); Assert.AreEqual(1, result.Count); Assert.AreEqual(new Constant("B"), result[new Variable("x")]); s1 = parser.parse("(P(A) <=> P(B))"); s2 = parser.parse("(P(A) <=> P(B))"); result = unifier.unify(s1, s2); Assert.IsNotNull(result); Assert.AreEqual(0, result.Count); s1 = parser.parse("(P(A) <=> P(B))"); s2 = parser.parse("(P(A) <=> P(C))"); result = unifier.unify(s1, s2); Assert.IsNull(result); s1 = parser.parse("(P(A) <=> P(B))"); s2 = parser.parse("(P(A) <=> P(x))"); result = unifier.unify(s1, s2); Assert.IsNotNull(result); Assert.AreEqual(1, result.Count); Assert.AreEqual(new Constant("B"), result[new Variable("x")]); s1 = parser.parse("((P(A) AND P(B)) OR (P(C) => (P(A) <=> P(C))))"); s2 = parser.parse("((P(A) AND P(B)) OR (P(C) => (P(A) <=> P(C))))"); result = unifier.unify(s1, s2); Assert.IsNotNull(result); Assert.AreEqual(0, result.Count); s1 = parser.parse("((P(A) AND P(B)) OR (P(C) => (P(A) <=> P(C))))"); s2 = parser.parse("((P(A) AND P(B)) OR (P(C) => (P(A) <=> P(A))))"); result = unifier.unify(s1, s2); Assert.IsNull(result); s1 = parser.parse("((P(A) AND P(B)) OR (P(C) => (P(A) <=> P(C))))"); s2 = parser.parse("((P(A) AND P(B)) OR (P(C) => (P(A) <=> P(x))))"); result = unifier.unify(s1, s2); Assert.IsNotNull(result); Assert.AreEqual(1, result.Count); Assert.AreEqual(new Constant("C"), result[new Variable("x")]); }
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)))"); IMap <Variable, Term> result = unifier.unify(s1, s2); Assert.IsNotNull(result); Assert.AreEqual(0, result.Size()); 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.Size()); Assert.AreEqual(new Constant("A"), result.Get(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.Size()); 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.Size()); Assert.AreEqual(new Constant("A"), result.Get(new Variable("x"))); }
public void setUp() { collector = new PredicateCollector(); parser = new FOLParser(DomainFactory.weaponsDomain()); }
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); ICollection <Literal> lits = CollectionFactory.CreateQueue <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); ISet <Clause> paras = paramodulation.apply(c1, c2); Assert.AreEqual(5, paras.Size()); Assert.AreEqual( "[F(B,B) = C, F(C,A) = D, A = D, P(B,A), Q(A), R(A), R(B), R(C)]", Util.first(paras).ToString()); paras.Remove(Util.first(paras)); 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)]", Util.first(paras).ToString()); paras.Remove(Util.first(paras)); Assert.AreEqual( "[F(A,B) = B, F(C,B) = D, A = D, P(C,B), Q(B), R(A), R(B), R(C)]", Util.first(paras).ToString()); paras.Remove(Util.first(paras)); 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)]", Util.first(paras).ToString()); paras.Remove(Util.first(paras)); 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)]", Util.first(paras).ToString()); }
public void testConnectedImplication() { parser = new FOLParser(DomainFactory.weaponsDomain()); parser.parse("((Missile(m) AND Owns(Nono,m)) => Sells(West , m ,Nono))"); }
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 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)); }
public void testExamplesPg299AIMA2e() { FOLDomain domain = DomainFactory.lovesAnimalDomain(); FOLParser parser = new FOLParser(domain); // FOL A. Sentence origSentence = parser .parse("FORALL x (FORALL y (Animal(y) => Loves(x, y)) => EXISTS y Loves(y, x))"); CNFConverter cnfConv = new CNFConverter(parser); CNF cnf = cnfConv.convertToCNF(origSentence); // CNF A1. and A2. Assert.AreEqual( "[Animal(SF0(x)), Loves(SF1(x),x)],[~Loves(x,SF0(x)), Loves(SF1(x),x)]", cnf.ToString()); // FOL B. origSentence = parser .parse("FORALL x (EXISTS y (Animal(y) AND Kills(x, y)) => FORALL z NOT(Loves(z, x)))"); cnf = cnfConv.convertToCNF(origSentence); // CNF B. Assert.AreEqual("[~Animal(y), ~Kills(x,y), ~Loves(z,x)]", cnf.ToString()); // FOL C. origSentence = parser.parse("FORALL x (Animal(x) => Loves(Jack, x))"); cnf = cnfConv.convertToCNF(origSentence); // CNF C. Assert.AreEqual("[~Animal(x), Loves(Jack,x)]", cnf.ToString()); // FOL D. origSentence = parser .parse("(Kills(Jack, Tuna) OR Kills(Curiosity, Tuna))"); cnf = cnfConv.convertToCNF(origSentence); // CNF D. Assert.AreEqual("[Kills(Curiosity,Tuna), Kills(Jack,Tuna)]", cnf.ToString()); // FOL E. origSentence = parser.parse("Cat(Tuna)"); cnf = cnfConv.convertToCNF(origSentence); // CNF E. Assert.AreEqual("[Cat(Tuna)]", cnf.ToString()); // FOL F. origSentence = parser.parse("FORALL x (Cat(x) => Animal(x))"); cnf = cnfConv.convertToCNF(origSentence); // CNF F. Assert.AreEqual("[~Cat(x), Animal(x)]", cnf.ToString()); // FOL G. origSentence = parser.parse("NOT(Kills(Curiosity, Tuna))"); cnf = cnfConv.convertToCNF(origSentence); // CNF G. Assert.AreEqual("[~Kills(Curiosity,Tuna)]", 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 CNFConverter(FOLParser parser) { this.parser = parser; this.substVisitor = new SubstVisitor(); }
public void setUp() { parser = new FOLParser(DomainFactory.knowsDomain()); unifier = new Unifier(); theta = CollectionFactory.CreateInsertionOrderedMap <Variable, Term>(); }
public RemoveQuantifiers(FOLParser parser) { this.parser = parser; substVisitor = new SubstVisitor(); }
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. IMap <Variable, Term> result = unifier.unify(te1, te2); Assert.IsNotNull(result); Assert.AreEqual(0, result.Size()); // 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.Size()); 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.Size()); 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.Size()); 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.Size()); 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.Size()); // 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 setUp() { parser = new FOLParser(DomainFactory.crusadesDomain()); vc = new VariableCollector(); }
public void setUp() { parser = new FOLParser(DomainFactory.knowsDomain()); unifier = new Unifier(); theta = new Dictionary <Variable, Term>(); }