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>();
}
