Ejemplo n.º 1
0
 /**
  * Inference between a compound term and a statement
  *
  * @param compound The compound term
  * @param index The location of the current term in the compound
  * @param statement The statement
  * @param side The location of the current term in the statement
  * @param beliefTerm The content of the belief
  * @param memory Reference to the memory
  */
 private static void compoundAndStatement(
     CompoundTerm compound,
     short index,
     Statement statement,
     short side,
     Term beliefTerm,
     Memory memory) {
   Term component = compound.componentAt(index);
   Task task = memory.currentTask;
   if (component.getClass() == statement.getClass()) {
     if ((compound instanceof Conjunction) && (memory.currentBelief != null)) {
       if (Variable.unify(Symbols.VAR_DEPENDENT, component, statement, compound, statement)) {
         SyllogisticRules.elimiVarDep(compound, component, statement.equals(beliefTerm), memory);
       } else if (task.getSentence().isJudgment()) {
         CompositionalRules.introVarInner(statement, (Statement) component, compound, memory);
       }
     }
   } else {
     if (!task.isStructural() && task.getSentence().isJudgment()) {
       if (statement instanceof Inheritance) {
         StructuralRules.structuralCompose1(compound, index, statement, memory);
         //                    if (!(compound instanceof SetExt) && !(compound instanceof SetInt))
         // {
         if (!(compound instanceof SetExt
             || compound instanceof SetInt
             || compound instanceof Negation)) {
           StructuralRules.structuralCompose2(compound, index, statement, side, memory);
         } // {A --> B, A @ (A&C)} |- (A&C) --> (B&C)
       } else if ((statement instanceof Similarity) && !(compound instanceof Conjunction)) {
         StructuralRules.structuralCompose2(compound, index, statement, side, memory);
       } // {A <-> B, A @ (A&C)} |- (A&C) <-> (B&C)
     }
   }
 }
Ejemplo n.º 2
0
 void check(Term t) {
   if (mCheckedTerms.contains(t) || !mIsClosed) {
     return;
   }
   mCheckedTerms.add(t);
   if (t instanceof ApplicationTerm) {
     for (final Term arg : ((ApplicationTerm) t).getParameters()) {
       enqueueWalker(new TermWalker(arg));
     }
   } else if (t instanceof AnnotatedTerm) {
     enqueueWalker(new TermWalker(((AnnotatedTerm) t).getSubterm()));
   } else if (t instanceof LetTerm) {
     final LetTerm let = (LetTerm) t;
     for (final Term value : let.getValues()) {
       enqueueWalker(new TermWalker(value));
     }
     mCheckedTerms.beginScope();
     enqueueWalker(new EndScopeWalker());
     for (final TermVariable var : let.getVariables()) {
       mCheckedTerms.add(var);
     }
     enqueueWalker(new TermWalker(let.getSubTerm()));
   } else if (t instanceof TermVariable) {
     /* all bound term variables were added to mCheckedTerms */
     mIsClosed = false;
   } else if (t instanceof QuantifiedFormula) {
     final QuantifiedFormula quant = (QuantifiedFormula) t;
     mCheckedTerms.beginScope();
     enqueueWalker(new EndScopeWalker());
     for (final TermVariable var : quant.getVariables()) {
       mCheckedTerms.add(var);
     }
     enqueueWalker(new TermWalker(quant.getSubformula()));
   } else if (!(t instanceof ConstantTerm)) {
     throw new AssertionError("Unknown term: " + t.getClass());
   }
 }
Ejemplo n.º 3
0
 /**
  * set Term to current program position
  *
  * @param term Term object
  */
 public void setCurTerm(Term term) {
   assert term != null;
   log.fine("Set program[" + I_P + "] = " + term.getClass().getName());
   program.set(I_P, term);
 }
Ejemplo n.º 4
0
 /**
  * {<(&&, S1, S2, S3) ==> P>, S1} |- <(&&, S2, S3) ==> P> {<(&&, S2, S3) ==> P>, <S1 ==> S2>} |-
  * <(&&, S1, S3) ==> P> {<(&&, S1, S3) ==> P>, <S1 ==> S2>} |- <(&&, S2, S3) ==> P>
  *
  * @param premise1 The conditional premise
  * @param index The location of the shared term in the condition of premise1
  * @param premise2 The premise which, or part of which, appears in the condition of premise1
  * @param side The location of the shared term in premise2: 0 for subject, 1 for predicate, -1 for
  *     the whole term
  */
 static void conditionalDedInd(Implication premise1, short index, Term premise2, int side) {
   Task task = Memory.currentTask;
   Sentence taskSentence = task.getSentence();
   Judgment belief = Memory.currentBelief;
   boolean deduction = (side != 0);
   HashMap substitute =
       Variable.findSubstitute(Variable.VarType.ALL, premise2, belief.getContent());
   boolean conditionalTask = (substitute != null);
   TemporalValue tense1 = (conditionalTask ? taskSentence.getTense() : belief.getTense());
   TemporalValue tense2 = (conditionalTask ? belief.getTense() : taskSentence.getTense());
   TemporalValue order1 = premise1.getOrder();
   TemporalValue order2 = premise2.getOrder();
   if ((side == -1) && (tense2 != null) && (tense2.getDelta() > 0)) {
     return;
   }
   if ((side == 0) && (order2 != null) && (order2.getDelta() > 0)) {
     return;
   }
   if ((side == 1) && (order2 != null) && (order2.getDelta() < 0)) {
     return;
   }
   TemporalValue tense = TemporalRules.syllogistic(tense1, tense2);
   if (tense != null) {
     tense = new TemporalValue(0);
   }
   Term commonComponent;
   Term newComponent = null;
   if (side == 0) {
     commonComponent = ((RDFStatement) premise2).getSubject();
     newComponent = ((RDFStatement) premise2).getPredicate();
   } else if (side == 1) {
     commonComponent = ((RDFStatement) premise2).getPredicate();
     newComponent = ((RDFStatement) premise2).getSubject();
   } else {
     commonComponent = premise2;
   }
   Conjunction oldCondition = (Conjunction) premise1.getSubject();
   boolean match =
       Variable.unify(
           Variable.VarType.INDEPENDENT,
           oldCondition.componentAt(index),
           commonComponent,
           premise1,
           premise2);
   if (!match && (commonComponent.getClass() == oldCondition.getClass())) {
     match =
         Variable.unify(
             Variable.VarType.INDEPENDENT,
             oldCondition.componentAt(index),
             ((CompoundTerm) commonComponent).componentAt(index),
             premise1,
             premise2);
   }
   if (!match) {
     return;
   }
   Term newCondition;
   if (oldCondition.equals(commonComponent)) {
     newCondition = null;
   } else {
     newCondition = CompoundTerm.replaceComponent(oldCondition, index, newComponent);
     if ((newCondition instanceof Conjunction) && ((CompoundTerm) newCondition).size() == 1) {
       newCondition = ((CompoundTerm) newCondition).componentAt(0);
     }
   }
   Term content;
   if (newCondition != null) {
     content = RDFStatement.make(premise1, newCondition, premise1.getPredicate(), order1);
   } else {
     content = premise1.getPredicate();
   }
   if (content == null) {
     return;
   }
   TruthValue truth1 = taskSentence.getTruth();
   TruthValue truth2 = belief.getTruth();
   TruthValue truth = null;
   BudgetValue budget;
   if (taskSentence instanceof Question) {
     budget = BudgetFunctions.backwardWeak(truth2);
   } else {
     if (taskSentence instanceof Goal) {
       if (conditionalTask) {
         truth = TruthFunctions.desireWeak(truth1, truth2);
       } else if (deduction) {
         truth = TruthFunctions.desireInd(truth1, truth2);
       } else {
         truth = TruthFunctions.desireDed(truth1, truth2);
       }
       budget = BudgetFunctions.forward(truth);
     } else {
       if (deduction) {
         truth = TruthFunctions.deduction(truth1, truth2);
       } else if (conditionalTask) {
         truth = TruthFunctions.induction(truth2, truth1);
       } else {
         truth = TruthFunctions.induction(truth1, truth2);
       }
     }
     budget = BudgetFunctions.forward(truth);
   }
   Memory.currentTense = tense;
   Memory.doublePremiseTask(budget, content, truth);
 }