protected void testFullFOLKBLovesAnimalQueryNotKillsJackTunaSucceeds(InferenceProcedure infp, bool expectedToTimeOut) { FOLKnowledgeBase akb = FOLKnowledgeBaseFactory.createLovesAnimalKnowledgeBase(infp); ICollection <Term> terms = CollectionFactory.CreateQueue <Term>(); terms.Add(new Constant("Jack")); terms.Add(new Constant("Tuna")); NotSentence query = new NotSentence(new Predicate("Kills", terms)); InferenceResult answer = akb.ask(query); Assert.IsTrue(null != answer); if (expectedToTimeOut) { Assert.IsFalse(answer.isPossiblyFalse()); Assert.IsFalse(answer.isTrue()); Assert.IsTrue(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 AnswerHandler(FOLKnowledgeBase kb, Sentence query, long maxQueryTime, FOLModelElimination fOLModelElimination) { finishTime = CommonFactory.Now().AddMilliseconds(maxQueryTime); Sentence refutationQuery = new NotSentence(query); // Want to use an answer literal to pull // query variables where necessary Literal answerLiteral = kb.createAnswerLiteral(refutationQuery); answerLiteralVariables = kb.collectAllVariables(answerLiteral.getAtomicSentence()); // Create the Set of Support based on the Query. if (answerLiteralVariables.Size() > 0) { Sentence refutationQueryWithAnswer = new ConnectedSentence( Connectors.OR, refutationQuery, answerLiteral .getAtomicSentence().copy()); sos = fOLModelElimination.createChainsFromClauses(kb.convertToClauses(refutationQueryWithAnswer)); answerChain.addLiteral(answerLiteral); } else { sos = fOLModelElimination.createChainsFromClauses(kb.convertToClauses(refutationQuery)); } foreach (Chain s in sos) { s.setProofStep(new ProofStepGoal(s)); } }
private void constructFOLEg() { ithExampleConstant = new Constant(folDSDomain.getExampleConstant(egNo)); ICollection <Term> terms = CollectionFactory.CreateQueue <Term>(); terms.Add(ithExampleConstant); // Create the classification sentence classification = new Predicate(folDSDomain.getGoalPredicateName(), terms); if (!example.getAttributeValueAsString( folDSDomain.getDataSetTargetName()).Equals(folDSDomain.getTrueGoalValue())) { // if not true then needs to be a Not sentence classification = new NotSentence(classification); } // Create the description sentence ICollection <Sentence> descParts = CollectionFactory.CreateQueue <Sentence>(); foreach (string dname in folDSDomain.getDescriptionDataSetNames()) { string foldDName = folDSDomain.getFOLName(dname); terms = CollectionFactory.CreateQueue <Term>(); terms.Add(ithExampleConstant); // If multivalued becomes a two place predicate // e.g: Patrons(X1, Some) // otherwise: Hungry(X1) or ~ Hungry(X1) // see pg 769 of AIMA Sentence part = null; if (folDSDomain.isMultivalued(dname)) { terms.Add(new Constant(folDSDomain.getFOLName(example.getAttributeValueAsString(dname)))); part = new Predicate(foldDName, terms); } else { part = new Predicate(foldDName, terms); // Need to determine if false if (!folDSDomain.getTrueGoalValue().Equals( example.getAttributeValueAsString(dname))) { part = new NotSentence(part); } } descParts.Add(part); } if (descParts.Size() == 1) { description = descParts.Get(0); } else if (descParts.Size() > 1) { description = new ConnectedSentence(Connectors.AND, descParts.Get(0), descParts.Get(1)); for (int i = 2; i < descParts.Size(); ++i) { description = new ConnectedSentence(Connectors.AND, description, descParts.Get(i)); } } }
public object visitNotSentence(NotSentence notSentence, object arg) { // CNF requires NOT (~) to appear only in literals, so we 'move ~ // inwards' by repeated application of the following equivalences: Sentence negated = notSentence.getNegated(); // ~(~alpha) equivalent to alpha (double negation elimination) if (negated is NotSentence) { return(((NotSentence)negated).getNegated().accept(this, arg)); } if (negated is ConnectedSentence) { ConnectedSentence negConnected = (ConnectedSentence)negated; Sentence alpha = negConnected.getFirst(); Sentence beta = negConnected.getSecond(); // ~(alpha ^ beta) equivalent to (~alpha V ~beta) (De Morgan) if (Connectors.isAND(negConnected.getConnector())) { // I need to ensure the ~s are moved in deeper Sentence notAlpha = (Sentence)(new NotSentence(alpha)).accept(this, arg); Sentence notBeta = (Sentence)(new NotSentence(beta)).accept(this, arg); return(new ConnectedSentence(Connectors.OR, notAlpha, notBeta)); } // ~(alpha V beta) equivalent to (~alpha ^ ~beta) (De Morgan) if (Connectors.isOR(negConnected.getConnector())) { // I need to ensure the ~s are moved in deeper Sentence notAlpha = (Sentence)(new NotSentence(alpha)).accept(this, arg); Sentence notBeta = (Sentence)(new NotSentence(beta)).accept(this, arg); return(new ConnectedSentence(Connectors.AND, notAlpha, notBeta)); } } // in addition, rules for negated quantifiers: if (negated is QuantifiedSentence) { QuantifiedSentence negQuantified = (QuantifiedSentence)negated; // I need to ensure the ~ is moved in deeper Sentence notP = (Sentence)(new NotSentence(negQuantified.getQuantified())).accept(this, arg); // ~FORALL x p becomes EXISTS x ~p if (Quantifiers.isFORALL(negQuantified.getQuantifier())) { return(new QuantifiedSentence(Quantifiers.EXISTS, negQuantified.getVariables(), notP)); } // ~EXISTS x p becomes FORALL x ~p if (Quantifiers.isEXISTS(negQuantified.getQuantifier())) { return(new QuantifiedSentence(Quantifiers.FORALL, negQuantified.getVariables(), notP)); } } return(new NotSentence((Sentence)negated.accept(this, arg))); }
private void ConstructFOLEg() { ithExampleConstant = new Constant(folDSDomain.GetExampleConstant(egNo)); var terms = new List <ITerm>(); terms.Add(ithExampleConstant); // Create the classification sentence classification = new Predicate(folDSDomain.GetGoalPredicateName(), terms); if (!example.GetAttributeValueAsString(folDSDomain.GetDataSetTargetName()).Equals(folDSDomain.TrueGoalValue)) { // if not true then needs to be a Not sentence classification = new NotSentence(classification); } // Create the description sentence var descParts = new List <ISentence>(); foreach (String dname in folDSDomain.DescriptionDataSetNames) { String foldDName = folDSDomain.GetFOLName(dname); terms = new List <ITerm>(); terms.Add(ithExampleConstant); // If multivalued becomes a two place predicate // e.g: Patrons(X1, Some) // otherwise: Hungry(X1) or ~ Hungry(X1) // see pg 769 of AIMA ISentence part = null; if (this.folDSDomain.IsMultivalued(dname)) { terms.Add(new Constant(this.folDSDomain.GetFOLName(this.example.GetAttributeValueAsString(dname)))); part = new Predicate(foldDName, terms); } else { part = new Predicate(foldDName, terms); // Need to determine if false if (!this.folDSDomain.TrueGoalValue.Equals(this.example.GetAttributeValueAsString(dname))) { part = new NotSentence(part); } } descParts.Add(part); } if (descParts.Count == 1) { this.description = descParts[0]; } else if (descParts.Count > 1) { this.description = new ConnectedSentence(Connectors.And, descParts[0], descParts[1]); for (int i = 2; i < descParts.Count; i++) { description = new ConnectedSentence(Connectors.And, description, descParts[i]); } } }
public void testNotSentence() { NotSentence ns = (NotSentence)parser .parse("NOT BrotherOf(John) = EnemyOf(Saladin)"); Assert.AreEqual(ns.getNegated().ToString(), (new TermEquality( getBrotherOfFunction(new Constant("John")), getEnemyOfFunction())).ToString()); }
public Object visitNotSentence(NotSentence sentence, Object arg) { ArgData ad = (ArgData)arg; // Indicate that the enclosed predicate is negated ad.negated = true; sentence.getNegated().accept(this, arg); ad.negated = false; return(sentence); }
public object VisitNotSentence(NotSentence sentence, object arg) { ArgData ad = (ArgData)arg; // Indicate that the enclosed predicate is negated ad.Negated = true; sentence.Negated.Accept(this, arg); ad.Negated = false; return(sentence); }
public AnswerHandler(FOLKnowledgeBase kb, ISentence aQuery, long maxQueryTime) { var ts = DateTime.Now - DateTime.MinValue; this.finishTime = (long)ts.TotalMilliseconds + maxQueryTime; ISentence refutationQuery = new NotSentence(aQuery); // Want to use an answer literal to pull // query variables where necessary Literal answerLiteral = kb.CreateAnswerLiteral(refutationQuery); answerLiteralVariables = kb.CollectAllVariables(answerLiteral .AtomicSentence); // Create the Set of Support based on the Query. if (answerLiteralVariables.Count > 0) { ISentence refutationQueryWithAnswer = new ConnectedSentence( Connectors.Or, refutationQuery, (ISentence)answerLiteral.AtomicSentence.Copy()); sos = CreateChainsFromClauses(kb .ConvertToClauses(refutationQueryWithAnswer)); answerChain.AddLiteral(answerLiteral); } else { sos = CreateChainsFromClauses(kb .ConvertToClauses(refutationQuery)); } foreach (Chain s in sos) { s.SetProofStep(new ProofStepGoal(s)); } }
public AnswerHandler(FOLKnowledgeBase kb, Sentence aQuery, long maxQueryTime, FOLModelElimination folModelElimination) { finishTime = System.DateTime.UtcNow.Ticks + maxQueryTime; Sentence refutationQuery = new NotSentence(aQuery); // Want to use an answer literal to pull // query variables where necessary Literal answerLiteral = kb.createAnswerLiteral(refutationQuery); answerLiteralVariables = kb.collectAllVariables(answerLiteral .getAtomicSentence()); // Create the Set of Support based on the Query. if (answerLiteralVariables.Count > 0) { Sentence refutationQueryWithAnswer = new ConnectedSentence( Connectors.OR, refutationQuery, (Sentence)answerLiteral .getAtomicSentence().copy()); sos = folModelElimination.createChainsFromClauses(kb .convertToClauses(refutationQueryWithAnswer)); answerChain.addLiteral(answerLiteral); } else { sos = folModelElimination.createChainsFromClauses(kb .convertToClauses(refutationQuery)); } foreach (Chain s in sos) { s.setProofStep(new ProofStepGoal(s)); } }
public object VisitNotSentence(NotSentence notSentence, object arg) { // CNF requires NOT (~) to appear only in literals, so we 'move ~ // inwards' by repeated application of the following equivalences: ISentence negated = notSentence.Negated; // ~(~alpha) equivalent to alpha (double negation elimination) if (negated is NotSentence) { return(((NotSentence)negated).Negated.Accept(this, arg)); } if (negated is ConnectedSentence) { ConnectedSentence negConnected = (ConnectedSentence)negated; ISentence alpha = negConnected.First; ISentence beta = negConnected.Second; // ~(alpha ^ beta) equivalent to (~alpha V ~beta) (De Morgan) if (Connectors.IsAnd(negConnected.Connector)) { // I need to ensure the ~s are moved in deeper ISentence notAlpha = (ISentence)(new NotSentence(alpha)).Accept( this, arg); ISentence notBeta = (ISentence)(new NotSentence(beta)).Accept( this, arg); return(new ConnectedSentence(Connectors.Or, notAlpha, notBeta)); } // ~(alpha V beta) equivalent to (~alpha ^ ~beta) (De Morgan) if (Connectors.IsOr(negConnected.Connector)) { // I need to ensure the ~s are moved in deeper ISentence notAlpha = (ISentence)(new NotSentence(alpha)).Accept( this, arg); ISentence notBeta = (ISentence)(new NotSentence(beta)).Accept( this, arg); return(new ConnectedSentence(Connectors.And, notAlpha, notBeta)); } } // in addition, rules for negated quantifiers: if (negated is QuantifiedSentence) { QuantifiedSentence negQuantified = (QuantifiedSentence)negated; // I need to ensure the ~ is moved in deeper ISentence notP = (ISentence)(new NotSentence(negQuantified .Quantified)).Accept(this, arg); // ~ForAll x p becomes Exists x ~p if (Quantifiers.IsForall(negQuantified.Quantifier)) { return(new QuantifiedSentence(Quantifiers.Exists, negQuantified .Variables, notP)); } // ~Exists x p becomes ForAll x ~p if (Quantifiers.IsExists(negQuantified.Quantifier)) { return(new QuantifiedSentence(Quantifiers.ForAll, negQuantified .Variables, notP)); } } return(new NotSentence((ISentence)negated.Accept(this, arg))); }
// // START-InferenceProcedure public InferenceResult ask(FOLKnowledgeBase KB, Sentence alpha) { // clauses <- the set of clauses in CNF representation of KB ^ ~alpha ISet <Clause> clauses = CollectionFactory.CreateSet <Clause>(); foreach (Clause cIter in KB.getAllClauses()) { Clause c = cIter; c = KB.standardizeApart(c); c.setStandardizedApartCheckNotRequired(); clauses.AddAll(c.getFactors()); } Sentence notAlpha = new NotSentence(alpha); // Want to use an answer literal to pull // query variables where necessary Literal answerLiteral = KB.createAnswerLiteral(notAlpha); ISet <Variable> answerLiteralVariables = KB.collectAllVariables(answerLiteral.getAtomicSentence()); Clause answerClause = new Clause(); if (answerLiteralVariables.Size() > 0) { Sentence notAlphaWithAnswer = new ConnectedSentence(Connectors.OR, notAlpha, answerLiteral.getAtomicSentence()); foreach (Clause cIter in KB.convertToClauses(notAlphaWithAnswer)) { Clause c = cIter; c = KB.standardizeApart(c); c.setProofStep(new ProofStepGoal(c)); c.setStandardizedApartCheckNotRequired(); clauses.AddAll(c.getFactors()); } answerClause.addLiteral(answerLiteral); } else { foreach (Clause cIter in KB.convertToClauses(notAlpha)) { Clause c = cIter; c = KB.standardizeApart(c); c.setProofStep(new ProofStepGoal(c)); c.setStandardizedApartCheckNotRequired(); clauses.AddAll(c.getFactors()); } } TFMAnswerHandler ansHandler = new TFMAnswerHandler(answerLiteral, answerLiteralVariables, answerClause, maxQueryTime); // new <- {} ISet <Clause> newClauses = CollectionFactory.CreateSet <Clause>(); ISet <Clause> toAdd = CollectionFactory.CreateSet <Clause>(); // loop do int noOfPrevClauses = clauses.Size(); do { if (null != tracer) { tracer.stepStartWhile(clauses, clauses.Size(), newClauses.Size()); } newClauses.Clear(); // for each Ci, Cj in clauses do Clause[] clausesA = clauses.ToArray(); // Basically, using the simple T)wo F)inger M)ethod here. for (int i = 0; i < clausesA.Length; i++) { Clause cI = clausesA[i]; if (null != tracer) { tracer.stepOuterFor(cI); } for (int j = i; j < clausesA.Length; j++) { Clause cJ = clausesA[j]; if (null != tracer) { tracer.stepInnerFor(cI, cJ); } // resolvent <- FOL-RESOLVE(Ci, Cj) ISet <Clause> resolvents = cI.binaryResolvents(cJ); if (resolvents.Size() > 0) { toAdd.Clear(); // new <- new <UNION> resolvent foreach (Clause rc in resolvents) { toAdd.AddAll(rc.getFactors()); } if (null != tracer) { tracer.stepResolved(cI, cJ, toAdd); } ansHandler.checkForPossibleAnswers(toAdd); if (ansHandler.isComplete()) { break; } newClauses.AddAll(toAdd); } if (ansHandler.isComplete()) { break; } } if (ansHandler.isComplete()) { break; } } noOfPrevClauses = clauses.Size(); // clauses <- clauses <UNION> new clauses.AddAll(newClauses); if (ansHandler.isComplete()) { break; } // if new is a <SUBSET> of clauses then finished // searching for an answer // (i.e. when they were added the # clauses // did not increase). } while (noOfPrevClauses < clauses.Size()); if (null != tracer) { tracer.stepFinished(clauses, ansHandler); } return(ansHandler); }
public object visitNotSentence(NotSentence sentence, object arg) { throw new IllegalStateException("visitNotSentence() should not be called."); }
public Object visitNotSentence(NotSentence sentence, Object arg) { throw new InvalidOperationException("Should not be called"); }
public object VisitNotSentence(NotSentence sentence, object arg) { sentence.Negated.Accept(this, arg); return(sentence); }
public Object visitNotSentence(NotSentence sentence, Object arg) { return(new NotSentence((Sentence)sentence.getNegated().accept(this, arg))); }
// START-InferenceProcedure /** * <code> * function FOL-FC-ASK(KB, alpha) returns a substitution or false * inputs: KB, the knowledge base, a set of first order definite clauses * alpha, the query, an atomic sentence * </code> */ public InferenceResult ask(FOLKnowledgeBase KB, Sentence query) { // Assertions on the type of queries this Inference procedure // supports if (!(query is AtomicSentence)) { throw new ArgumentException( "Only Atomic Queries are supported."); } FCAskAnswerHandler ansHandler = new FCAskAnswerHandler(); Literal alpha = new Literal((AtomicSentence)query); // local variables: new, the new sentences inferred on each iteration List <Literal> newSentences = new List <Literal>(); // Ensure query is not already a know fact before // attempting forward chaining. List <Dictionary <Variable, Term> > answers = KB.fetch(alpha); if (answers.Count > 0) { ansHandler.addProofStep(new ProofStepFoChAlreadyAFact(alpha)); ansHandler.setAnswers(answers); return(ansHandler); } // repeat until new is empty do { // new <- {} newSentences.Clear(); // for each rule in KB do // (p1 ^ ... ^ pn => q) <-STANDARDIZE-VARIABLES(rule) foreach (Clause impl in KB.getAllDefiniteClauseImplications()) { Clause impl2 = KB.standardizeApart(impl); // for each theta such that SUBST(theta, p1 ^ ... ^ pn) = // SUBST(theta, p'1 ^ ... ^ p'n) // --- for some p'1,...,p'n in KB foreach (Dictionary <Variable, Term> theta in KB.fetch(invert(new List <Literal>(impl2 .getNegativeLiterals())))) { // q' <- SUBST(theta, q) Literal qPrime = KB.subst(theta, impl.getPositiveLiterals() [0]); // if q' does not unify with some sentence already in KB or // new then do if (!KB.isRenaming(qPrime) && !KB.isRenaming(qPrime, newSentences)) { // add q' to new newSentences.Add(qPrime); ansHandler.addProofStep(impl, qPrime, theta); // theta <- UNIFY(q', alpha) Dictionary <Variable, Term> theta2 = KB.unify(qPrime.getAtomicSentence(), alpha .getAtomicSentence()); // if theta is not fail then return theta if (null != theta2) { foreach (Literal l in newSentences) { Sentence s = null; if (l.isPositiveLiteral()) { s = l.getAtomicSentence(); } else { s = new NotSentence(l.getAtomicSentence()); } KB.tell(s); } ansHandler.setAnswers(KB.fetch(alpha)); return(ansHandler); } } } } // add new to KB foreach (Literal l in newSentences) { Sentence s = null; if (l.isPositiveLiteral()) { s = l.getAtomicSentence(); } else { s = new NotSentence(l.getAtomicSentence()); } KB.tell(s); } } while (newSentences.Count > 0); // return false return(ansHandler); }
public IInferenceResult Ask(FOLKnowledgeBase kb, ISentence alpha) { // clauses <- the set of clauses in CNF representation of KB ^ ~alpha ISet <Clause> clauses = new HashedSet <Clause>(); foreach (Clause c in kb.GetAllClauses()) { var standardizedC = kb.StandardizeApart(c); standardizedC.SetStandardizedApartCheckNotRequired(); clauses.UnionWith(standardizedC.GetFactors()); } ISentence notAlpha = new NotSentence(alpha); // Want to use an answer literal to pull // query variables where necessary Literal answerLiteral = kb.CreateAnswerLiteral(notAlpha); ISet <Variable> answerLiteralVariables = kb .CollectAllVariables(answerLiteral.AtomicSentence); Clause answerClause = new Clause(); if (answerLiteralVariables.Count > 0) { ISentence notAlphaWithAnswer = new ConnectedSentence(Connectors.Or, notAlpha, answerLiteral.AtomicSentence); foreach (Clause c in kb.ConvertToClauses(notAlphaWithAnswer)) { var standardizedC = kb.StandardizeApart(c); standardizedC.SetProofStep(new ProofStepGoal(standardizedC)); standardizedC.SetStandardizedApartCheckNotRequired(); clauses.UnionWith(standardizedC.GetFactors()); } answerClause.AddLiteral(answerLiteral); } else { foreach (Clause c in kb.ConvertToClauses(notAlpha)) { var standardizedC = kb.StandardizeApart(c); standardizedC.SetProofStep(new ProofStepGoal(standardizedC)); standardizedC.SetStandardizedApartCheckNotRequired(); clauses.UnionWith(standardizedC.GetFactors()); } } var ansHandler = new TFMAnswerHandler(answerLiteral, answerLiteralVariables, answerClause, this.MaxQueryTime); // new <- {} ISet <Clause> newClauses = new HashedSet <Clause>(); ISet <Clause> toAdd = new HashedSet <Clause>(); // loop do int noOfPrevClauses = clauses.Count; do { if (Tracer != null) { Tracer.StepStartWhile(clauses, clauses.Count, newClauses .Count); } newClauses.Clear(); // for each Ci, Cj in clauses do Clause[] clausesA = new Clause[clauses.Count]; clausesA = clauses.ToArray(); // Basically, using the simple T)wo F)inger M)ethod here. for (int i = 0; i < clausesA.Length; i++) { Clause cI = clausesA[i]; if (null != Tracer) { Tracer.StepOuterFor(cI); } for (int j = i; j < clausesA.Length; j++) { Clause cJ = clausesA[j]; if (null != Tracer) { Tracer.StepInnerFor(cI, cJ); } // resolvent <- FOL-RESOLVE(Ci, Cj) ISet <Clause> resolvents = cI.BinaryResolvents(cJ); if (resolvents.Count > 0) { toAdd.Clear(); // new <- new <UNION> resolvent foreach (Clause rc in resolvents) { toAdd.UnionWith(rc.GetFactors()); } if (null != Tracer) { Tracer.StepResolved(cI, cJ, toAdd); } ansHandler.CheckForPossibleAnswers(toAdd); if (ansHandler.IsComplete()) { break; } newClauses.UnionWith(toAdd); } if (ansHandler.IsComplete()) { break; } } if (ansHandler.IsComplete()) { break; } } noOfPrevClauses = clauses.Count; // clauses <- clauses <UNION> new clauses.UnionWith(newClauses); if (ansHandler.IsComplete()) { break; } // if new is a <SUBSET> of clauses then finished // searching for an answer // (i.e. when they were added the # clauses // did not increase). } while (noOfPrevClauses < clauses.Count); if (null != Tracer) { Tracer.StepFinished(clauses, ansHandler); } return(ansHandler); }
public object VisitNotSentence(NotSentence notSentence, object arg) { ISentence negated = notSentence.Negated; return(new NotSentence((ISentence)negated.Accept(this, arg))); }
public object VisitNotSentence(NotSentence sentence, object arg) { throw new InvalidOperationException( "visitNotSentence() should not be called."); }
public object visitNotSentence(NotSentence sentence, object arg) { sentence.getNegated().accept(this, arg); return(sentence); }
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 visitNotSentence(NotSentence sentence, Object arg) { throw new NotImplementedException( "visitNotSentence() should not be called."); }
public Object visitNotSentence(NotSentence notSentence, Object arg) { Sentence negated = notSentence.getNegated(); return(new NotSentence((Sentence)negated.accept(this, arg))); }
// 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 VisitNotSentence(NotSentence sentence, object arg) { return(new NotSentence((ISentence)sentence.Negated.Accept(this, arg))); }