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); }
// // 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); }
// // START-InferenceProcedure public InferenceResult ask(FOLKnowledgeBase KB, Sentence alpha) { // clauses <- the set of clauses in CNF representation of KB ^ ~alpha List<Clause> clauses = new List<Clause>(); foreach (Clause c in KB.getAllClauses()) { Clause c2 = KB.standardizeApart(c); c2.setStandardizedApartCheckNotRequired(); clauses.AddRange(c2.getFactors()); } 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(); clauses.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(); clauses.AddRange(c2.getFactors()); } } TFMAnswerHandler ansHandler = new TFMAnswerHandler(answerLiteral, answerLiteralVariables, answerClause, maxQueryTime); // new <- {} List<Clause> newClauses = new List<Clause>(); List<Clause> toAdd = new List<Clause>(); // loop do int noOfPrevClauses = clauses.Count; do { if (null != tracer) { 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) List<Clause> resolvents = cI.binaryResolvents(cJ); if (resolvents.Count > 0) { toAdd.Clear(); // new <- new <UNION> resolvent foreach (Clause rc in resolvents) { toAdd.AddRange(rc.getFactors()); } if (null != tracer) { tracer.stepResolved(cI, cJ, toAdd); } ansHandler.checkForPossibleAnswers(toAdd); if (ansHandler.isComplete()) { break; } newClauses.AddRange(toAdd); } if (ansHandler.isComplete()) { break; } } if (ansHandler.isComplete()) { break; } } noOfPrevClauses = clauses.Count; // clauses <- clauses <UNION> new clauses.AddRange(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; }