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));
                }
            }
Exemple #2
0
        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 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);
        }