public object VisitTermEquality(TermEquality equality, object arg) { var newTerm1 = (ITerm)equality.Term1.Accept(this, arg); var newTerm2 = (ITerm)equality.Term2.Accept(this, arg); return(new TermEquality(newTerm1, newTerm2)); }
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(""); }
protected void testEqualityAndSubstitutionAxiomsKBabcdFFASucceeds( InferenceProcedure infp) { FOLKnowledgeBase akb = FOLKnowledgeBaseFactory .createABCDEqualityAndSubstitutionKnowledgeBase(infp, true); List <Term> terms = new List <Term>(); terms.Add(new Constant("A")); Function fa = new Function("F", terms); terms = new List <Term>(); terms.Add(fa); TermEquality query = new TermEquality(new Function("F", terms), new Constant("A")); InferenceResult answer = akb.ask(query); Assert.IsTrue(null != answer); Assert.IsFalse(answer.isPossiblyFalse()); Assert.IsTrue(answer.isTrue()); Assert.IsFalse(answer.isUnknownDueToTimeout()); Assert.IsFalse(answer.isPartialResultDueToTimeout()); Assert.IsTrue(1 == answer.getProofs().Count); Assert.IsTrue(0 == answer.getProofs()[0].getAnswerBindings() .Count); }
public object visitTermEquality(TermEquality equality, object arg) { Term newTerm1 = (Term)equality.getTerm1().accept(this, arg); Term newTerm2 = (Term)equality.getTerm2().accept(this, arg); return(new TermEquality(newTerm1, newTerm2)); }
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 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); }
protected void testEqualityNoAxiomsKBabcAEqualsCSucceeds(InferenceProcedure infp, bool expectedToFail) { FOLKnowledgeBase akb = FOLKnowledgeBaseFactory.createABCEqualityKnowledgeBase(infp, false); TermEquality query = new TermEquality(new Constant("A"), new Constant("C")); InferenceResult answer = akb.ask(query); Assert.IsTrue(null != answer); if (expectedToFail) { Assert.IsTrue(answer.isPossiblyFalse()); Assert.IsFalse(answer.isTrue()); Assert.IsFalse(answer.isUnknownDueToTimeout()); Assert.IsFalse(answer.isPartialResultDueToTimeout()); Assert.IsTrue(0 == answer.getProofs().Size()); } else { Assert.IsFalse(answer.isPossiblyFalse()); Assert.IsTrue(answer.isTrue()); Assert.IsFalse(answer.isUnknownDueToTimeout()); Assert.IsFalse(answer.isPartialResultDueToTimeout()); Assert.IsTrue(1 == answer.getProofs().Size()); Assert.IsTrue(0 == answer.getProofs().Get(0) .getAnswerBindings().Size()); } }
public ProofStepClauseDemodulation(Clause demodulated, Clause origClause, TermEquality assertion) { this.demodulated = demodulated; this.origClause = origClause; this.assertion = assertion; this.predecessors.Add(origClause.getProofStep()); }
protected void testEqualityAndSubstitutionNoAxiomsKBabcdFFASucceeds(InferenceProcedure infp, bool expectedToFail) { FOLKnowledgeBase akb = FOLKnowledgeBaseFactory.createABCDEqualityAndSubstitutionKnowledgeBase(infp, false); ICollection <Term> terms = CollectionFactory.CreateQueue <Term>(); terms.Add(new Constant("A")); Function fa = new Function("F", terms); terms = CollectionFactory.CreateQueue <Term>(); terms.Add(fa); TermEquality query = new TermEquality(new Function("F", terms), new Constant("A")); InferenceResult answer = akb.ask(query); Assert.IsTrue(null != answer); if (expectedToFail) { Assert.IsTrue(answer.isPossiblyFalse()); Assert.IsFalse(answer.isTrue()); Assert.IsFalse(answer.isUnknownDueToTimeout()); Assert.IsFalse(answer.isPartialResultDueToTimeout()); Assert.IsTrue(0 == answer.getProofs().Size()); } else { Assert.IsFalse(answer.isPossiblyFalse()); Assert.IsTrue(answer.isTrue()); Assert.IsFalse(answer.isUnknownDueToTimeout()); Assert.IsFalse(answer.isPartialResultDueToTimeout()); Assert.IsTrue(1 == answer.getProofs().Size()); Assert.IsTrue(0 == answer.getProofs().Get(0) .getAnswerBindings().Size()); } }
public AtomicSentence apply(TermEquality assertion, AtomicSentence expression) { AtomicSentence altExpression = null; IdentifyCandidateMatchingTerm icm = getMatchingSubstitution(assertion .getTerm1(), expression); if (null != icm) { Term replaceWith = substVisitor.subst( icm.getMatchingSubstitution(), assertion.getTerm2()); // Want to ignore reflexivity axiom situation, i.e. x = x if (!icm.getMatchingTerm().Equals(replaceWith)) { ReplaceMatchingTerm rmt = new ReplaceMatchingTerm(); // Only apply demodulation at most once on each call. altExpression = rmt.replace(expression, icm.getMatchingTerm(), replaceWith); } } return(altExpression); }
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 ProofStepClauseParamodulation(Clause paramodulated, Clause topClause, Clause equalityClause, TermEquality assertion) { this.paramodulated = paramodulated; this.topClause = topClause; this.equalityClause = equalityClause; this.assertion = assertion; this.predecessors.Add(topClause.GetProofStep()); this.predecessors.Add(equalityClause.GetProofStep()); }
public object visitTermEquality(TermEquality equality, object arg) { foreach (Term t in equality.getArgs()) { // Finish processing if have found a match if (null != matchingTerm) { break; } t.accept(this, null); } return(equality); }
public object visitTermEquality(TermEquality equality, object arg) { ArgData ad = (ArgData)arg; if (ad.negated) { ad.clauses.Get(ad.clauses.Size() - 1).addNegativeLiteral(equality); } else { ad.clauses.Get(ad.clauses.Size() - 1).addPositiveLiteral(equality); } return(equality); }
public Object visitTermEquality(TermEquality equality, Object arg) { ArgData ad = (ArgData)arg; if (ad.negated) { ad.clauses[ad.clauses.Count - 1].addNegativeLiteral(equality); } else { ad.clauses[ad.clauses.Count - 1].addPositiveLiteral(equality); } return(equality); }
public object VisitTermEquality(TermEquality equality, object arg) { ArgData ad = (ArgData)arg; if (ad.Negated) { ad.Clauses[ad.Clauses.Count - 1].AddNegativeLiteral(equality); } else { ad.Clauses[ad.Clauses.Count - 1].AddPositiveLiteral(equality); } return(equality); }
public void testTermEquality2() { try { TermEquality te = (TermEquality)parser .parse("BrotherOf(John) = x)"); Assert.AreEqual(te, new TermEquality( getBrotherOfFunction(new Constant("John")), new Variable( "x"))); } catch (RuntimeException) { Assert.Fail("RuntimeException thrown"); } }
public void testTermEquality() { try { TermEquality te = (TermEquality)parser .parse("BrotherOf(John) = EnemyOf(Saladin)"); Assert.AreEqual(te.ToString(), (new TermEquality( getBrotherOfFunction(new Constant("John")), getEnemyOfFunction())).ToString()); } catch (ApplicationException) { Assert.Fail("RuntimeException thrown"); } }
public Clause apply(TermEquality assertion, Clause clExpression) { Clause altClExpression = null; foreach (Literal l1 in clExpression.getLiterals()) { AtomicSentence altExpression = apply(assertion, l1 .getAtomicSentence()); if (null != altExpression) { // I have an alternative, create a new clause // with the alternative and return List <Literal> newLits = new List <Literal>(); foreach (Literal l2 in clExpression.getLiterals()) { if (l1.Equals(l2)) { newLits.Add(l1.newInstance(altExpression)); } else { newLits.Add(l2); } } // Only apply demodulation at most once on // each call. altClExpression = new Clause(newLits); altClExpression.setProofStep(new ProofStepClauseDemodulation( altClExpression, clExpression, assertion)); if (clExpression.isImmutable()) { altClExpression.setImmutable(); } if (!clExpression.isStandardizedApartCheckRequired()) { altClExpression.setStandardizedApartCheckNotRequired(); } break; } } return(altClExpression); }
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 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()); }
protected static void abcEqualityNoAxiomDemo(InferenceProcedure ip) { StandardizeApartIndexicalFactory.flush(); FOLKnowledgeBase kb = FOLKnowledgeBaseFactory.createABCEqualityKnowledgeBase(ip, false); string kbStr = kb.ToString(); TermEquality query = new TermEquality(new Constant("A"), new Constant("C")); InferenceResult answer = kb.ask(query); System.Console.WriteLine("ABC Equality No Axiom Knowledge Base:"); System.Console.WriteLine(kbStr); System.Console.WriteLine("Query: " + query); foreach (Proof p in answer.getProofs()) { System.Console.Write(ProofPrinter.printProof(p)); System.Console.WriteLine(""); } }
public List <Clause> apply(Clause c1, Clause c2, bool standardizeApart) { List <Clause> paraExpressions = new List <Clause>(); for (int i = 0; i < 2; i++) { Clause topClause, equalityClause; if (i == 0) { topClause = c1; equalityClause = c2; } else { topClause = c2; equalityClause = c1; } foreach (Literal possEqLit in equalityClause.getLiterals()) { // Must be a positive term equality to be used // for paramodulation. if (possEqLit.isPositiveLiteral() && possEqLit.getAtomicSentence() is TermEquality) { TermEquality assertion = (TermEquality)possEqLit .getAtomicSentence(); // Test matching for both sides of the equality for (int x = 0; x < 2; x++) { Term toMatch, toReplaceWith; if (x == 0) { toMatch = assertion.getTerm1(); toReplaceWith = assertion.getTerm2(); } else { toMatch = assertion.getTerm2(); toReplaceWith = assertion.getTerm1(); } foreach (Literal l1 in topClause.getLiterals()) { IdentifyCandidateMatchingTerm icm = getMatchingSubstitution( toMatch, l1.getAtomicSentence()); if (null != icm) { Term replaceWith = substVisitor.subst(icm .getMatchingSubstitution(), toReplaceWith); // Want to ignore reflexivity axiom situation, // i.e. x = x if (icm.getMatchingTerm().Equals(replaceWith)) { continue; } ReplaceMatchingTerm rmt = new ReplaceMatchingTerm(); AtomicSentence altExpression = rmt.replace(l1 .getAtomicSentence(), icm .getMatchingTerm(), replaceWith); // I have an alternative, create a new clause // with the alternative and the substitution // applied to all the literals before returning List <Literal> newLits = new List <Literal>(); foreach (Literal l2 in topClause.getLiterals()) { if (l1.Equals(l2)) { newLits .Add(l1 .newInstance((AtomicSentence)substVisitor .subst( icm .getMatchingSubstitution(), altExpression))); } else { newLits .Add(substVisitor .subst( icm .getMatchingSubstitution(), l2)); } } // Assign the equality clause literals, // excluding // the term equality used. foreach (Literal l2 in equalityClause.getLiterals()) { if (possEqLit.Equals(l2)) { continue; } newLits.Add(substVisitor.subst(icm .getMatchingSubstitution(), l2)); } // Only apply paramodulation at most once // for each term equality. Clause nc = null; if (standardizeApart) { sApart.standardizeApart(newLits, _emptyLiteralList, _saIndexical); nc = new Clause(newLits); } else { nc = new Clause(newLits); } nc .setProofStep(new ProofStepClauseParamodulation( nc, topClause, equalityClause, assertion)); if (c1.isImmutable()) { nc.setImmutable(); } if (!c1.isStandardizedApartCheckRequired()) { c1.setStandardizedApartCheckNotRequired(); } paraExpressions.Add(nc); break; } } } } } } return(paraExpressions); }
public IInferenceResult Ask(FOLKnowledgeBase KB, ISentence alpha) { ISet<Clause> sos = new HashedSet<Clause>(); ISet<Clause> usable = new HashedSet<Clause>(); // Usable set will be the set of clauses in the KB, // are assuming this is satisfiable as using the // ISet of Support strategy. //foreach (var standardizedC in KB.GetAllClauses().Select(c => KB.StandardizeApart(c))) foreach (var standardizedC in KB.GetAllClauses()) { standardizedC.SetStandardizedApartCheckNotRequired(); usable.UnionWith(standardizedC.GetFactors()); } // Ensure reflexivity axiom is added to usable if using paramodulation. if (this.UseParamodulation) { // Reflexivity Axiom: x = x var reflexivityAxiom = new TermEquality(new Variable("x"), new Variable("x")); var reflexivityClause = new Clause(); reflexivityClause.AddLiteral(new Literal(reflexivityAxiom)); reflexivityClause = KB.StandardizeApart(reflexivityClause); reflexivityClause.SetStandardizedApartCheckNotRequired(); usable.Add(reflexivityClause); } ISentence notAlpha = new NotSentence(alpha); // Want to use an answer literal to pull // query variables where necessary var answerLiteral = KB.CreateAnswerLiteral(notAlpha); var answerLiteralVariables = KB .CollectAllVariables(answerLiteral.AtomicSentence); var answerClause = new Clause(); if (answerLiteralVariables.Count > 0) { ISentence notAlphaWithAnswer = new ConnectedSentence(Connectors.Or, notAlpha, answerLiteral.AtomicSentence); // foreach (var standardizedC in // KB.ConvertToClauses(notAlphaWithAnswer).Select(KB.StandardizeApart)) foreach (var standardizedC in KB.ConvertToClauses(notAlphaWithAnswer)) { Clause c = KB.StandardizeApart(standardizedC); c.SetProofStep(new ProofStepGoal(c)); c.SetStandardizedApartCheckNotRequired(); sos.UnionWith(c.GetFactors()); } answerClause.AddLiteral(answerLiteral); } else { //foreach (var standardizedC in // KB.ConvertToClauses(notAlpha).Select(KB.StandardizeApart)) foreach (var standardizedC in KB.ConvertToClauses(notAlpha)) { Clause c = KB.StandardizeApart(standardizedC); c.SetProofStep(new ProofStepGoal(c)); c.SetStandardizedApartCheckNotRequired(); sos.UnionWith(standardizedC.GetFactors()); } } // Ensure all subsumed clauses are removed usable.ExceptWith(SubsumptionElimination.FindSubsumedClauses(usable)); sos.ExceptWith(SubsumptionElimination.FindSubsumedClauses(sos)); var ansHandler = new OTTERAnswerHandler(answerLiteral, answerLiteralVariables, answerClause, this.MaxQueryTime); var idxdClauses = new IndexedClauses(LightestClauseHeuristic, sos, usable); return this.Otter(ansHandler, idxdClauses, sos, usable); }
public Object visitTermEquality(TermEquality equality, Object arg) { return(arg); }
public object VisitTermEquality(TermEquality equality, object arg) { return(equality); }
public object visitTermEquality(TermEquality equality, object arg) { equality.getTerm1().accept(this, arg); equality.getTerm2().accept(this, arg); return(equality); }
public Object visitTermEquality(TermEquality equality, Object arg) { throw new InvalidOperationException("Should not be called"); }
// START-InferenceProcedure public InferenceResult ask(FOLKnowledgeBase KB, Sentence alpha) { List <Clause> sos = new List <Clause>(); List <Clause> usable = new List <Clause>(); // Usable set will be the set of clauses in the KB, // are assuming this is satisfiable as using the // Set of Support strategy. foreach (Clause c in KB.getAllClauses()) { Clause c2 = KB.standardizeApart(c); c2.setStandardizedApartCheckNotRequired(); usable.AddRange(c2.getFactors()); } // Ensure reflexivity axiom is added to usable if using paramodulation. if (isUseParamodulation()) { // Reflexivity Axiom: x = x TermEquality reflexivityAxiom = new TermEquality(new Variable("x"), new Variable("x")); Clause reflexivityClause = new Clause(); reflexivityClause.addLiteral(new Literal(reflexivityAxiom)); reflexivityClause = KB.standardizeApart(reflexivityClause); reflexivityClause.setStandardizedApartCheckNotRequired(); usable.Add(reflexivityClause); } Sentence notAlpha = new NotSentence(alpha); // Want to use an answer literal to pull // query variables where necessary Literal answerLiteral = KB.createAnswerLiteral(notAlpha); List <Variable> answerLiteralVariables = KB .collectAllVariables(answerLiteral.getAtomicSentence()); Clause answerClause = new Clause(); if (answerLiteralVariables.Count > 0) { Sentence notAlphaWithAnswer = new ConnectedSentence(Connectors.OR, notAlpha, answerLiteral.getAtomicSentence()); foreach (Clause c in KB.convertToClauses(notAlphaWithAnswer)) { Clause c2 = KB.standardizeApart(c); c2.setProofStep(new ProofStepGoal(c2)); c2.setStandardizedApartCheckNotRequired(); sos.AddRange(c2.getFactors()); } answerClause.addLiteral(answerLiteral); } else { foreach (Clause c in KB.convertToClauses(notAlpha)) { Clause c2 = KB.standardizeApart(c); c2.setProofStep(new ProofStepGoal(c2)); c2.setStandardizedApartCheckNotRequired(); sos.AddRange(c2.getFactors()); } } // Ensure all subsumed clauses are removed foreach (Clause c in SubsumptionElimination.findSubsumedClauses(usable)) { usable.Remove(c); } foreach (Clause c in SubsumptionElimination.findSubsumedClauses(sos)) { sos.Remove(c); } OTTERAnswerHandler ansHandler = new OTTERAnswerHandler(answerLiteral, answerLiteralVariables, answerClause, maxQueryTime); IndexedClauses idxdClauses = new IndexedClauses( getLightestClauseHeuristic(), sos, usable); return(otter(ansHandler, idxdClauses, sos, usable)); }
public object VisitTermEquality(TermEquality equality, object arg) { equality.Term1.Accept(this, arg); equality.Term2.Accept(this, arg); return(equality); }