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 testNegativeTermEquality()
{
FOLDomain domain = new FOLDomain();
domain.addConstant("A");
domain.addConstant("B");
domain.addConstant("C");
domain.addPredicate("P");
domain.addFunction("F");
FOLParser parser = new FOLParser(domain);
ICollection <Literal> lits = CollectionFactory.CreateQueue <Literal>();
AtomicSentence a1 = (AtomicSentence)parser.parse("P(y, F(A,y))");
lits.Add(new Literal(a1));
Clause c1 = new Clause(lits);
lits.Clear();
a1 = (AtomicSentence)parser.parse("F(x,B) = x");
lits.Add(new Literal(a1, true));
Clause c2 = new Clause(lits);
ISet <Clause> paras = paramodulation.apply(c1, c2);
Assert.AreEqual(0, paras.Size());
}
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);
ICollection <TermEquality> rewrites = CollectionFactory.CreateQueue <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().Get(0));
Assert.AreEqual("[P(y,y), P(y,ONE), P(ONE,y)]", simplified.ToString());
}
public void testSimplepredicate()
{
ISet <Variable> variables = vc.collectAllVariables(parser.parse("King(x)"));
Assert.AreEqual(1, variables.Size());
Assert.IsTrue(variables.Contains(new Variable("x")));
}
static void fOL_Demodulation()
{
System.Console.WriteLine("-----------------");
System.Console.WriteLine("Demodulation Demo");
System.Console.WriteLine("-----------------");
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");
Demodulation demodulation = new Demodulation();
Predicate altExpression = (Predicate)demodulation.apply(assertion, expression);
System.Console.WriteLine("Demodulate '" + expression + "' with '" + assertion + "' to give");
System.Console.WriteLine(altExpression.ToString());
System.Console.WriteLine("and again to give");
System.Console.WriteLine(demodulation.apply(assertion, altExpression).ToString());
System.Console.WriteLine("");
}
public void testSimpleClauseNonExample()
{
FOLDomain domain = new FOLDomain();
domain.addConstant("A");
domain.addConstant("B");
domain.addConstant("C");
domain.addPredicate("P");
domain.addFunction("F");
FOLParser parser = new FOLParser(domain);
ICollection <Literal> lits = CollectionFactory.CreateQueue <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("F(x,B) = C");
Clause altClExpression = demodulation.apply(assertion, clExpression);
Assert.IsNull(altClExpression);
}
public Sentence tell(string sentence)
{
Sentence s = parser.parse(sentence);
tell(s);
return(s);
}
public Sentence tell(String aSentence)
{
Sentence s = parser.parse(aSentence);
tell(s);
return(s);
}
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>();
AtomicSentence a1 = (AtomicSentence)parser.parse("P(y, F(A,y))");
lits.Add(new Literal(a1));
Clause c1 = new Clause(lits);
lits.Clear();
a1 = (AtomicSentence)parser.parse("x = x");
lits.Add(new Literal(a1));
Clause c2 = new Clause(lits);
List <Clause> paras = paramodulation.apply(c1, c2);
Assert.AreEqual(0, paras.Count);
}
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 testImplicationsAndExtendedAndsOrs()
{
FOLDomain domain = new FOLDomain();
domain.addPredicate("Cheat");
domain.addPredicate("Extra");
domain.addPredicate("Knows");
domain.addPredicate("Diff");
domain.addPredicate("F");
domain.addPredicate("A");
domain.addPredicate("Probation");
domain.addPredicate("Award");
FOLParser parser = new FOLParser(domain);
CNFConverter cnfConv = new CNFConverter(parser);
// cheat(x,y) => f(x,y)
Sentence def1 = parser.parse("(Cheat(x,y) => F(x,y))");
CNF cnfDef1 = cnfConv.convertToCNF(def1);
Assert.AreEqual("[~Cheat(x,y), F(x,y)]", cnfDef1.ToString());
// extra(x,y) | knows(x) => a(x,y)
Sentence def2 = parser.parse("((Extra(x,y) OR Knows(x)) => A(x,y))");
CNF cnfDef2 = cnfConv.convertToCNF(def2);
Assert.AreEqual("[~Extra(x,y), A(x,y)],[~Knows(x), A(x,y)]",
cnfDef2.ToString());
// f(x,y) & f(x,z) & diff(y,z) <=> probation(x)
Sentence def3 = parser
.parse("(((NOT(((F(x,y) AND F(x,z)) AND Diff(y,z)))) OR Probation(x)) AND (((F(x,y) AND F(x,z)) AND Diff(y,z)) OR NOT(Probation(x))))");
CNF cnfDef3 = cnfConv.convertToCNF(def3);
Assert
.AreEqual(
"[~Diff(y,z), ~F(x,y), ~F(x,z), Probation(x)],[~Probation(x), F(x,y)],[~Probation(x), F(x,z)],[~Probation(x), Diff(y,z)]",
cnfDef3.ToString());
// a(x,y) & a(x,z) & diff(y,z) <=> award(x)
Sentence def4 = parser
.parse("(((NOT(((A(x,y) AND A(x,z)) AND Diff(y,z)))) OR Award(x)) AND (((A(x,y) AND A(x,z)) AND Diff(y,z)) OR NOT(Award(x))))");
CNF cnfDef4 = cnfConv.convertToCNF(def4);
Assert
.AreEqual(
"[~A(x,y), ~A(x,z), ~Diff(y,z), Award(x)],[~Award(x), A(x,y)],[~Award(x), A(x,z)],[~Award(x), Diff(y,z)]",
cnfDef4.ToString());
// f(x,y) <=> ~a(x,y)
Sentence def5 = parser
.parse("( ( NOT(F(x,y)) OR NOT(A(x,y))) AND ( F(x,y) OR NOT(NOT(A(x,y))) ) )");
CNF cnfDef5 = cnfConv.convertToCNF(def5);
Assert.AreEqual("[~A(x,y), ~F(x,y)],[A(x,y), F(x,y)]", cnfDef5
.ToString());
}
public void testNestedExistsAndOrs()
{
FOLDomain domain = new FOLDomain();
domain.addPredicate("P");
domain.addPredicate("R");
domain.addPredicate("Q");
FOLParser parser = new FOLParser(domain);
Sentence origSentence = parser
.parse("EXISTS w (FORALL x ( (EXISTS z (Q(w, z))) => (EXISTS y (NOT(P(x, y)) AND R(y))) ) )");
CNFConverter cnfConv = new CNFConverter(parser);
CNF cnf = cnfConv.convertToCNF(origSentence);
Assert.AreEqual("[~P(x,SF0(x)), ~Q(SC0,z)],[~Q(SC0,z), R(SF0(x))]",
cnf.ToString());
// Ax.Ay.(p(x,y) => Ez.(q(x,y,z)))
origSentence = parser
.parse("FORALL x1 (FORALL y1 (P(x1, y1) => EXISTS z1 (Q(x1, y1, z1))))");
cnf = cnfConv.convertToCNF(origSentence);
Assert.AreEqual("[~P(x1,y1), Q(x1,y1,SF1(x1,y1))]", cnf.ToString());
// Ex.Ay.Az.(r(y,z) <=> q(x,y,z))
origSentence = parser
.parse("EXISTS x2 (FORALL y2 (FORALL z2 (R(y2, z2) <=> Q(x2, y2, z2))))");
cnf = cnfConv.convertToCNF(origSentence);
Assert.AreEqual(
"[~R(y2,z2), Q(SC1,y2,z2)],[~Q(SC1,y2,z2), R(y2,z2)]", cnf
.ToString());
// Ax.Ey.(~p(x,y) => Az.(q(x,y,z)))
origSentence = parser
.parse("FORALL x3 (EXISTS y3 (NOT(P(x3, y3)) => FORALL z3 (Q(x3, y3, z3))))");
cnf = cnfConv.convertToCNF(origSentence);
Assert
.AreEqual("[P(x3,SF2(x3)), Q(x3,SF2(x3),z3)]", cnf
.ToString());
// Ew.Ex.Ey.Ez.(r(x,y) & q(x,w,z))
origSentence = parser
.parse("NOT(EXISTS w4 (EXISTS x4 (EXISTS y4 ( EXISTS z4 (R(x4, y4) AND Q(x4, w4, z4))))))");
cnf = cnfConv.convertToCNF(origSentence);
Assert.AreEqual("[~Q(x4,w4,z4), ~R(x4,y4)]", cnf.ToString());
}
public void testFailureIfThetaisNull()
{
Variable var = new Variable("x");
Sentence sentence = parser.parse("Knows(x)");
theta = null;
IMap <Variable, Term> result = unifier.unify(var, sentence, theta);
Assert.IsNull(result);
}
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 testInductionAxiomSchema()
{
FOLDomain domain = new FOLDomain();
domain.addPredicate("Equal");
domain.addFunction("Plus");
domain.addConstant("A");
domain.addConstant("B");
domain.addConstant("N");
domain.addConstant("ONE");
domain.addConstant("ZERO");
FOLParser parser = new FOLParser(domain);
CNFConverter cnfConv = new CNFConverter(parser);
// Base Case:
Sentence sent = parser
.parse("NOT(FORALL x (FORALL y (Equal(Plus(Plus(x,y),ZERO), Plus(x,Plus(y,ZERO))))))");
CNF cnf = cnfConv.convertToCNF(sent);
Assert.AreEqual(
"[~Equal(Plus(Plus(SC0,SC1),ZERO),Plus(SC0,Plus(SC1,ZERO)))]",
cnf.ToString());
// Instance of Induction Axion Scmema
sent = parser
.parse("(("
+ "Equal(Plus(Plus(A,B),ZERO), Plus(A,Plus(B,ZERO)))"
+ " AND "
+ "(FORALL x (FORALL y (FORALL z("
+ "Equal(Plus(Plus(x,y),z), Plus(x,Plus(y,z)))"
+ " => "
+ "Equal(Plus(Plus(x,y),Plus(z,ONE)), Plus(x,Plus(y,Plus(z,ONE))))"
+ "))))" + ")" + " => "
+ "FORALL x (FORALL y (FORALL z("
+ "Equal(Plus(Plus(x,y),z), Plus(x,Plus(y,z)))"
+ "))))");
cnf = cnfConv.convertToCNF(sent);
Assert
.AreEqual(
"[~Equal(Plus(Plus(A,B),ZERO),Plus(A,Plus(B,ZERO))), Equal(Plus(Plus(q0,q1),q2),Plus(q0,Plus(q1,q2))), Equal(Plus(Plus(SC2,SC3),SC4),Plus(SC2,Plus(SC3,SC4)))],[~Equal(Plus(Plus(A,B),ZERO),Plus(A,Plus(B,ZERO))), ~Equal(Plus(Plus(SC2,SC3),Plus(SC4,ONE)),Plus(SC2,Plus(SC3,Plus(SC4,ONE)))), Equal(Plus(Plus(q0,q1),q2),Plus(q0,Plus(q1,q2)))]",
cnf.ToString());
// Goal
sent = parser
.parse("NOT(FORALL x (FORALL y (FORALL z (Equal(Plus(Plus(x,y),z), Plus(x,Plus(y,z)))))))");
cnf = cnfConv.convertToCNF(sent);
Assert.AreEqual(
"[~Equal(Plus(Plus(SC5,SC6),SC7),Plus(SC5,Plus(SC6,SC7)))]",
cnf.ToString());
}
public void testSimpleSentence()
{
Sentence s = parser.parse("(Missile(x) => Weapon(x))");
List <Predicate> predicates = collector.getPredicates(s);
Assert.IsNotNull(predicates);
}
private static void unifierDemo()
{
FOLParser parser = new FOLParser(DomainFactory.knowsDomain());
Unifier unifier = new Unifier();
IMap <Variable, Term> theta = CollectionFactory.CreateInsertionOrderedMap <Variable, Term>();
Sentence query = parser.parse("Knows(John,x)");
Sentence johnKnowsJane = parser.parse("Knows(y,Mother(y))");
System.Console.WriteLine("------------");
System.Console.WriteLine("Unifier Demo");
System.Console.WriteLine("------------");
IMap <Variable, Term> subst = unifier.unify(query, johnKnowsJane, theta);
System.Console.WriteLine("Unify '" + query + "' with '" + johnKnowsJane + "' to get the substitution " + subst + ".");
System.Console.WriteLine("");
}
public void testBadCascadeSubstitution_LCL418_1()
{
FOLDomain domain = new FOLDomain();
domain.addPredicate("ISATHEOREM");
domain.addFunction("EQUIVALENT");
FOLParser parser = new FOLParser(domain);
Sentence s1 = parser
.parse("ISATHEOREM(EQUIVALENT(EQUIVALENT(c1744,c1743),EQUIVALENT(c1742,c1743)))");
Sentence s2 = parser
.parse("ISATHEOREM(EQUIVALENT(EQUIVALENT(c1752,c1751),c1752))");
IMap <Variable, Term> result = unifier.unify(s1, s2);
Assert.AreEqual(
"[[c1744, EQUIVALENT(c1742,c1751)], [c1743, c1751], [c1752, EQUIVALENT(c1742,c1751)]]",
result.ToString());
}
private static void unifierDemo()
{
FOLParser parser = new FOLParser(DomainFactory.knowsDomain());
Unifier unifier = new Unifier();
var theta = new Dictionary <Variable, Term>();
Sentence query = parser.parse("Knows(John,x)");
Sentence johnKnowsJane = parser.parse("Knows(y,Mother(y))");
System.Console.WriteLine("------------");
System.Console.WriteLine("Unifier Demo");
System.Console.WriteLine("------------");
var subst = unifier.unify(query, johnKnowsJane, theta);
System.Console.WriteLine("Unify '" + query + "' with '" + johnKnowsJane
+ "' to get the substitution " + DictToString(subst) + ".");
System.Console.WriteLine("");
}
public void testSimpleClauseExamples()
{
FOLDomain domain = new FOLDomain();
domain.addConstant("A");
domain.addConstant("B");
domain.addConstant("C");
domain.addConstant("D");
domain.addConstant("E");
domain.addPredicate("P");
domain.addPredicate("Q");
domain.addPredicate("W");
domain.addFunction("F");
domain.addFunction("G");
domain.addFunction("H");
domain.addFunction("J");
FOLParser parser = new FOLParser(domain);
List <Literal> lits = new List <Literal>();
Predicate p1 = (Predicate)parser.parse("Q(z, G(D,B))");
Predicate p2 = (Predicate)parser.parse("P(x, G(A,C))");
Predicate p3 = (Predicate)parser.parse("W(z,x,u,w,y)");
lits.Add(new Literal(p1));
lits.Add(new Literal(p2));
lits.Add(new Literal(p3));
Clause clExpression = new Clause(lits);
TermEquality assertion = (TermEquality)parser.parse("G(x,y) = x");
Clause altClExpression = demodulation.apply(assertion, clExpression);
Assert.AreEqual("[P(x,G(A,C)), Q(z,D), W(z,x,u,w,y)]",
altClExpression.ToString());
altClExpression = demodulation.apply(assertion, altClExpression);
Assert.AreEqual("[P(x,A), Q(z,D), W(z,x,u,w,y)]", altClExpression
.ToString());
}
public void 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());
}
static void fOL_Paramodulation()
{
System.Console.WriteLine("-------------------");
System.Console.WriteLine("Paramodulation Demo");
System.Console.WriteLine("-------------------");
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);
ICollection <Literal> lits = CollectionFactory.CreateQueue <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);
Paramodulation paramodulation = new Paramodulation();
ISet <Clause> paras = paramodulation.apply(c1, c2);
System.Console.WriteLine("Paramodulate '" + c1 + "' with '" + c2 + "' to give");
System.Console.WriteLine(paras.ToString());
System.Console.WriteLine("");
}
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 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))");
IMap <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 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);
ICollection <Literal> lits = CollectionFactory.CreateQueue <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);
ISet <Clause> paras = paramodulation.apply(c1, c2);
Assert.AreEqual(2, paras.Size());
Assert.AreEqual("[P(B,A), Q(A), R(B)]", Util.first(paras).ToString());
paras.Remove(Util.first(paras));
Assert.AreEqual("[P(F(A,F(x,B)),x), Q(x), R(F(x,B))]", Util.first(paras).ToString());
}
public void testEqualityBinaryResolvents()
{
FOLDomain domain = new FOLDomain();
domain.addConstant("A");
domain.addConstant("B");
FOLParser parser = new FOLParser(domain);
// B = A
Clause c1 = new Clause();
c1.addPositiveLiteral((AtomicSentence)parser.parse("B = A"));
Clause c2 = new Clause();
c2.addNegativeLiteral((AtomicSentence)parser.parse("B = A"));
c2.addPositiveLiteral((AtomicSentence)parser.parse("B = A"));
ISet <Clause> resolvents = c1.binaryResolvents(c2);
Assert.AreEqual(1, resolvents.Size());
Assert.AreEqual("[[B = A]]", resolvents.ToString());
}
public void testExamplePg296AIMA2e()
{
FOLDomain domain = DomainFactory.lovesAnimalDomain();
FOLParser parser = new FOLParser(domain);
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);
Assert.AreEqual(
"[Animal(SF0(x)), Loves(SF1(x),x)],[~Loves(x,SF0(x)), Loves(SF1(x),x)]",
cnf.ToString());
}
public void testExamplePg295AIMA2e()
{
FOLDomain domain = DomainFactory.weaponsDomain();
FOLParser parser = new FOLParser(domain);
Sentence origSentence = parser
.parse("FORALL x ((((American(x) AND Weapon(y)) AND Sells(x, y, z)) AND Hostile(z)) => Criminal(x))");
CNFConverter cnfConv = new CNFConverter(parser);
CNF cnf = cnfConv.convertToCNF(origSentence);
Assert.AreEqual(
"[~American(x), ~Hostile(z), ~Sells(x,y,z), ~Weapon(y), Criminal(x)]",
cnf.ToString());
}
static void fOL_CNFConversion()
{
System.Console.WriteLine("-------------------------------------------------");
System.Console.WriteLine("Conjuctive Normal Form for First Order Logic Demo");
System.Console.WriteLine("-------------------------------------------------");
FOLDomain domain = DomainFactory.lovesAnimalDomain();
FOLParser parser = new FOLParser(domain);
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);
System.Console.WriteLine("Convert '" + origSentence + "' to CNF.");
System.Console.WriteLine("CNF=" + cnf.ToString());
System.Console.WriteLine("");
}
public void testNegationsAndNestedImplications()
{
FOLDomain domain = new FOLDomain();
domain.addPredicate("P");
domain.addPredicate("Q");
domain.addPredicate("R");
domain.addConstant("A");
FOLParser parser = new FOLParser(domain);
CNFConverter cnfConv = new CNFConverter(parser);
// ~(((~p or ~q) => ~(p or q)) => r)
Sentence sent = parser
.parse("NOT(((((NOT(P(A)) OR NOT(Q(A)))) => NOT((P(A) OR Q(A)))) => R(A)))");
CNF cnf = cnfConv.convertToCNF(sent);
Assert.AreEqual(
"[~P(A), P(A)],[~P(A), Q(A)],[~Q(A), P(A)],[~Q(A), Q(A)],[~R(A)]",
cnf.ToString());
}