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