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 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 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 FOLKnowledgeBase(FOLDomain domain,
InferenceProcedure inferenceProcedure, Unifier unifier)
{
this.parser = new FOLParser(new FOLDomain(domain));
this.inferenceProcedure = inferenceProcedure;
this.unifier = unifier;
//
this.substVisitor = new SubstVisitor();
this.variableCollector = new VariableCollector();
this._standardizeApart = new StandardizeApart(variableCollector,
substVisitor);
this.cnfConverter = new CNFConverter(parser);
}
public FOLLexer(FOLDomain domain)
{
this.domain = domain;
connectors = new List<String>();
connectors.Add(Connectors.NOT);
connectors.Add(Connectors.AND);
connectors.Add(Connectors.OR);
connectors.Add(Connectors.IMPLIES);
connectors.Add(Connectors.BICOND);
quantifiers = new List<String>();
quantifiers.Add(Quantifiers.FORALL);
quantifiers.Add(Quantifiers.EXISTS);
}
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 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 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 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));
}
// 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;
}
// 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 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 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 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 FOLKnowledgeBase(FOLDomain domain,
InferenceProcedure inferenceProcedure) : this(domain, inferenceProcedure, new Unifier())
{
}
//
// PUBLIC METHODS
//
public FOLKnowledgeBase(FOLDomain domain) : this(domain, new FOLOTTERLikeTheoremProver())
{
// Default to Full Resolution if not set.
}
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());
}
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 FOLDomain(FOLDomain toCopy) : this(toCopy.getConstants(), toCopy.getFunctions(), toCopy
.getPredicates())
{
}
public void testCascadedOccursCheck()
{
FOLDomain domain = new FOLDomain();
domain.addPredicate("P");
domain.addFunction("F");
domain.addFunction("SF0");
domain.addFunction("SF1");
FOLParser parser = new FOLParser(domain);
Sentence s1 = parser.parse("P(SF1(v2),v2)");
Sentence s2 = parser.parse("P(v3,SF0(v3))");
Dictionary<Variable, Term> result = unifier.unify(s1, s2);
Assert.IsNull(result);
s1 = parser.parse("P(v1,SF0(v1),SF0(v1),SF0(v1),SF0(v1))");
s2 = parser.parse("P(v2,SF0(v2),v2, v3, v2)");
result = unifier.unify(s1, s2);
Assert.IsNull(result);
s1 = parser
.parse("P(v1, F(v2),F(v2),F(v2),v1, F(F(v1)),F(F(F(v1))),v2)");
s2 = parser
.parse("P(F(v3),v4, v5, v6, F(F(v5)),v4, F(v3), F(F(v5)))");
result = unifier.unify(s1, s2);
Assert.IsNull(result);
}
public FOLDomain(FOLDomain toCopy) : this(toCopy.getConstants(), toCopy.getFunctions(), toCopy
.getPredicates())
{
}
public FOLParser(FOLDomain domain) : this(new FOLLexer(domain))
{
}
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 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);
}
