Esempio n. 1
0
 /**
  * Syllogistic rules whose both premises are on the same symmetric relation
  *
  * @param belief The premise that comes from a belief
  * @param taskSentence The premise that comes from a task
  * @param figure The location of the shared term
  * @param memory Reference to the memory
  */
 private static void symmetricSymmetric(
     Sentence belief, Sentence taskSentence, int figure, Memory memory) {
   Statement s1 = (Statement) belief.cloneContent();
   Statement s2 = (Statement) taskSentence.cloneContent();
   switch (figure) {
     case 11:
       if (Variable.unify(Symbols.VAR_INDEPENDENT, s1.getSubject(), s2.getSubject(), s1, s2)) {
         SyllogisticRules.resemblance(
             s1.getPredicate(), s2.getPredicate(), belief, taskSentence, figure, memory);
       }
       break;
     case 12:
       if (Variable.unify(Symbols.VAR_INDEPENDENT, s1.getSubject(), s2.getPredicate(), s1, s2)) {
         SyllogisticRules.resemblance(
             s1.getPredicate(), s2.getSubject(), belief, taskSentence, figure, memory);
       }
       break;
     case 21:
       if (Variable.unify(Symbols.VAR_INDEPENDENT, s1.getPredicate(), s2.getSubject(), s1, s2)) {
         SyllogisticRules.resemblance(
             s1.getSubject(), s2.getPredicate(), belief, taskSentence, figure, memory);
       }
       break;
     case 22:
       if (Variable.unify(Symbols.VAR_INDEPENDENT, s1.getPredicate(), s2.getPredicate(), s1, s2)) {
         SyllogisticRules.resemblance(
             s1.getSubject(), s2.getSubject(), belief, taskSentence, figure, memory);
       }
       break;
   }
 }
Esempio n. 2
0
 /**
  * Syllogistic rules whose first premise is on an asymmetric relation, and the second on a
  * symmetric relation
  *
  * @param asym The asymmetric premise
  * @param sym The symmetric premise
  * @param figure The location of the shared term
  * @param memory Reference to the memory
  */
 private static void asymmetricSymmetric(Sentence asym, Sentence sym, int figure, Memory memory) {
   Statement asymSt = (Statement) asym.cloneContent();
   Statement symSt = (Statement) sym.cloneContent();
   Term t1, t2;
   switch (figure) {
     case 11:
       if (Variable.unify(
           Symbols.VAR_INDEPENDENT, asymSt.getSubject(), symSt.getSubject(), asymSt, symSt)) {
         t1 = asymSt.getPredicate();
         t2 = symSt.getPredicate();
         if (Variable.unify(Symbols.VAR_QUERY, t1, t2, asymSt, symSt)) {
           LocalRules.matchAsymSym(asym, sym, figure, memory);
         } else {
           SyllogisticRules.analogy(t2, t1, asym, sym, figure, memory);
         }
       }
       break;
     case 12:
       if (Variable.unify(
           Symbols.VAR_INDEPENDENT, asymSt.getSubject(), symSt.getPredicate(), asymSt, symSt)) {
         t1 = asymSt.getPredicate();
         t2 = symSt.getSubject();
         if (Variable.unify(Symbols.VAR_QUERY, t1, t2, asymSt, symSt)) {
           LocalRules.matchAsymSym(asym, sym, figure, memory);
         } else {
           SyllogisticRules.analogy(t2, t1, asym, sym, figure, memory);
         }
       }
       break;
     case 21:
       if (Variable.unify(
           Symbols.VAR_INDEPENDENT, asymSt.getPredicate(), symSt.getSubject(), asymSt, symSt)) {
         t1 = asymSt.getSubject();
         t2 = symSt.getPredicate();
         if (Variable.unify(Symbols.VAR_QUERY, t1, t2, asymSt, symSt)) {
           LocalRules.matchAsymSym(asym, sym, figure, memory);
         } else {
           SyllogisticRules.analogy(t1, t2, asym, sym, figure, memory);
         }
       }
       break;
     case 22:
       if (Variable.unify(
           Symbols.VAR_INDEPENDENT, asymSt.getPredicate(), symSt.getPredicate(), asymSt, symSt)) {
         t1 = asymSt.getSubject();
         t2 = symSt.getSubject();
         if (Variable.unify(Symbols.VAR_QUERY, t1, t2, asymSt, symSt)) {
           LocalRules.matchAsymSym(asym, sym, figure, memory);
         } else {
           SyllogisticRules.analogy(t1, t2, asym, sym, figure, memory);
         }
       }
       break;
   }
 }
Esempio n. 3
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)
     }
   }
 }
Esempio n. 4
0
 /**
  * The detachment rule, with variable unification
  *
  * @param originalMainSentence The premise that is an Implication or Equivalence
  * @param subSentence The premise that is the subject or predicate of the first one
  * @param index The location of the second premise in the first
  * @param memory Reference to the memory
  */
 private static void detachmentWithVar(
     Sentence originalMainSentence, Sentence subSentence, int index, Memory memory) {
   Sentence mainSentence = (Sentence) originalMainSentence.clone(); // for substitution
   Statement statement = (Statement) mainSentence.getContent();
   Term component = statement.componentAt(index);
   Term content = subSentence.getContent();
   if ((component instanceof Inheritance) && (memory.currentBelief != null)) {
     if (component.isConstant()) {
       SyllogisticRules.detachment(mainSentence, subSentence, index, memory);
     } else if (Variable.unify(Symbols.VAR_INDEPENDENT, component, content, statement, content)) {
       SyllogisticRules.detachment(mainSentence, subSentence, index, memory);
     } else if ((statement instanceof Implication)
         && (statement.getPredicate() instanceof Statement)
         && (memory.currentTask.getSentence().isJudgment())) {
       Statement s2 = (Statement) statement.getPredicate();
       if (s2.getSubject().equals(((Statement) content).getSubject())) {
         CompositionalRules.introVarInner((Statement) content, s2, statement, memory);
       }
     }
   }
 }
Esempio n. 5
0
 /**
  * Conditional deduction or induction, with variable unification
  *
  * @param conditional The premise that is an Implication with a Conjunction as condition
  * @param index The location of the shared term in the condition
  * @param statement The second premise that is a statement
  * @param side The location of the shared term in the statement
  * @param memory Reference to the memory
  */
 private static void conditionalDedIndWithVar(
     Implication conditional, short index, Statement statement, short side, Memory memory) {
   CompoundTerm condition = (CompoundTerm) conditional.getSubject();
   Term component = condition.componentAt(index);
   Term component2 = null;
   if (statement instanceof Inheritance) {
     component2 = statement;
     side = -1;
   } else if (statement instanceof Implication) {
     component2 = statement.componentAt(side);
   }
   if ((component2 != null)
       && Variable.unify(Symbols.VAR_INDEPENDENT, component, component2, conditional, statement)) {
     SyllogisticRules.conditionalDedInd(conditional, index, statement, side, memory);
   }
 }
Esempio n. 6
0
 /**
  * Entry point of the inference engine
  *
  * @param tLink The selected TaskLink, which will provide a task
  * @param bLink The selected TermLink, which may provide a belief
  * @param memory Reference to the memory
  */
 public static void reason(TaskLink tLink, TermLink bLink, Memory memory) {
   Task task = memory.currentTask;
   Sentence taskSentence = task.getSentence();
   Term taskTerm = (Term) taskSentence.getContent().clone(); // cloning for substitution
   Term beliefTerm = (Term) bLink.getTarget().clone(); // cloning for substitution
   Concept beliefConcept = memory.termToConcept(beliefTerm);
   Sentence belief = null;
   if (beliefConcept != null) {
     belief = beliefConcept.getBelief(task);
   }
   memory.currentBelief = belief; // may be null
   if (belief != null) {
     LocalRules.match(task, belief, memory);
   }
   if (!memory.noResult()) {
     return;
   }
   short tIndex = tLink.getIndex(0);
   short bIndex = bLink.getIndex(0);
   switch (tLink.getType()) { // dispatch first by TaskLink type
     case TermLink.SELF:
       switch (bLink.getType()) {
         case TermLink.COMPONENT:
           compoundAndSelf((CompoundTerm) taskTerm, beliefTerm, true, memory);
           break;
         case TermLink.COMPOUND:
           compoundAndSelf((CompoundTerm) beliefTerm, taskTerm, false, memory);
           break;
         case TermLink.COMPONENT_STATEMENT:
           if (belief != null) {
             SyllogisticRules.detachment(task.getSentence(), belief, bIndex, memory);
           }
           break;
         case TermLink.COMPOUND_STATEMENT:
           if (belief != null) {
             SyllogisticRules.detachment(belief, task.getSentence(), bIndex, memory);
           }
           break;
         case TermLink.COMPONENT_CONDITION:
           if (belief != null) {
             bIndex = bLink.getIndex(1);
             SyllogisticRules.conditionalDedInd(
                 (Implication) taskTerm, bIndex, beliefTerm, tIndex, memory);
           }
           break;
         case TermLink.COMPOUND_CONDITION:
           if (belief != null) {
             bIndex = bLink.getIndex(1);
             SyllogisticRules.conditionalDedInd(
                 (Implication) beliefTerm, bIndex, taskTerm, tIndex, memory);
           }
           break;
       }
       break;
     case TermLink.COMPOUND:
       switch (bLink.getType()) {
         case TermLink.COMPOUND:
           compoundAndCompound((CompoundTerm) taskTerm, (CompoundTerm) beliefTerm, memory);
           break;
         case TermLink.COMPOUND_STATEMENT:
           compoundAndStatement(
               (CompoundTerm) taskTerm,
               tIndex,
               (Statement) beliefTerm,
               bIndex,
               beliefTerm,
               memory);
           break;
         case TermLink.COMPOUND_CONDITION:
           if (belief != null) {
             if (beliefTerm instanceof Implication) {
               SyllogisticRules.conditionalDedInd(
                   (Implication) beliefTerm, bIndex, taskTerm, -1, memory);
             } else if (beliefTerm instanceof Equivalence) {
               SyllogisticRules.conditionalAna(
                   (Equivalence) beliefTerm, bIndex, taskTerm, -1, memory);
             }
           }
           break;
       }
       break;
     case TermLink.COMPOUND_STATEMENT:
       switch (bLink.getType()) {
         case TermLink.COMPONENT:
           componentAndStatement(
               (CompoundTerm) memory.currentTerm, bIndex, (Statement) taskTerm, tIndex, memory);
           break;
         case TermLink.COMPOUND:
           compoundAndStatement(
               (CompoundTerm) beliefTerm,
               bIndex,
               (Statement) taskTerm,
               tIndex,
               beliefTerm,
               memory);
           break;
         case TermLink.COMPOUND_STATEMENT:
           if (belief != null) {
             //                            bIndex = bLink.getIndex(1);
             syllogisms(tLink, bLink, taskTerm, beliefTerm, memory);
           }
           break;
         case TermLink.COMPOUND_CONDITION:
           if (belief != null) {
             bIndex = bLink.getIndex(1);
             if (beliefTerm instanceof Implication) {
               conditionalDedIndWithVar(
                   (Implication) beliefTerm, bIndex, (Statement) taskTerm, tIndex, memory);
             }
           }
           break;
       }
       break;
     case TermLink.COMPOUND_CONDITION:
       switch (bLink.getType()) {
         case TermLink.COMPOUND_STATEMENT:
           if (belief != null) {
             //                            if (beliefTerm instanceof Implication)
             // TODO adding instanceof test changes results of Example-NAL6-in.txt
             // TODO maybe put instanceof test within conditionalDedIndWithVar()
             conditionalDedIndWithVar(
                 (Implication) taskTerm, tIndex, (Statement) beliefTerm, bIndex, memory);
           }
           break;
       }
       break;
   }
 }
Esempio n. 7
0
  /**
   * Syllogistic rules whose both premises are on the same asymmetric relation
   *
   * @param sentence The taskSentence in the task
   * @param belief The judgment in the belief
   * @param figure The location of the shared term
   * @param memory Reference to the memory
   */
  private static void asymmetricAsymmetric(
      Sentence sentence, Sentence belief, int figure, Memory memory) {
    Statement s1 = (Statement) sentence.cloneContent();
    Statement s2 = (Statement) belief.cloneContent();
    Term t1, t2;
    switch (figure) {
      case 11: // induction
        if (Variable.unify(Symbols.VAR_INDEPENDENT, s1.getSubject(), s2.getSubject(), s1, s2)) {
          if (s1.equals(s2)) {
            return;
          }
          t1 = s2.getPredicate();
          t2 = s1.getPredicate();
          SyllogisticRules.abdIndCom(t1, t2, sentence, belief, figure, memory);
          CompositionalRules.composeCompound(s1, s2, 0, memory);
        }

        break;
      case 12: // deduction
        if (Variable.unify(Symbols.VAR_INDEPENDENT, s1.getSubject(), s2.getPredicate(), s1, s2)) {
          if (s1.equals(s2)) {
            return;
          }
          t1 = s2.getSubject();
          t2 = s1.getPredicate();
          if (Variable.unify(Symbols.VAR_QUERY, t1, t2, s1, s2)) {
            LocalRules.matchReverse(memory);
          } else {
            SyllogisticRules.dedExe(t1, t2, sentence, belief, memory);
          }
        }
        break;
      case 21: // exemplification
        if (Variable.unify(Symbols.VAR_INDEPENDENT, s1.getPredicate(), s2.getSubject(), s1, s2)) {
          if (s1.equals(s2)) {
            return;
          }
          t1 = s1.getSubject();
          t2 = s2.getPredicate();
          if (Variable.unify(Symbols.VAR_QUERY, t1, t2, s1, s2)) {
            LocalRules.matchReverse(memory);
          } else {
            SyllogisticRules.dedExe(t1, t2, sentence, belief, memory);
          }
        }
        break;
      case 22: // abduction
        if (Variable.unify(Symbols.VAR_INDEPENDENT, s1.getPredicate(), s2.getPredicate(), s1, s2)) {
          if (s1.equals(s2)) {
            return;
          }
          t1 = s1.getSubject();
          t2 = s2.getSubject();
          if (!SyllogisticRules.conditionalAbd(
              t1, t2, s1, s2, memory)) { // if conditional abduction, skip the following
            SyllogisticRules.abdIndCom(t1, t2, sentence, belief, figure, memory);
            CompositionalRules.composeCompound(s1, s2, 1, memory);
          }
        }
        break;
      default:
    }
  }