Пример #1
0
 /**
  * {<S ==> P>, <M <=> P>} |- <S ==> P>
  *
  * @param term1 Subject of the new task
  * @param term2 Predicate of the new task
  * @param asym The asymmetric premise
  * @param sym The symmetric premise
  * @param figure Locations of the shared term in premises
  */
 static void analogy(Term term1, Term term2, Sentence asym, Sentence sym, int figure) {
   if (RDFStatement.invalidStatement(term1, term2)) {
     return;
   }
   RDFStatement asymSt = (RDFStatement) asym.getContent();
   RDFStatement symSt = (RDFStatement) sym.getContent();
   TruthValue truth = null;
   BudgetValue budget;
   Sentence sentence = Memory.currentTask.getSentence();
   CompoundTerm taskTerm = (CompoundTerm) sentence.getContent();
   if (sentence instanceof Question) {
     if (taskTerm.isCommutative()) {
       budget = BudgetFunctions.backwardWeak(asym.getTruth());
     } else {
       budget = BudgetFunctions.backward(sym.getTruth());
     }
   } else {
     if (sentence instanceof Goal) {
       if (taskTerm.isCommutative()) {
         truth = TruthFunctions.desireWeak(asym.getTruth(), sym.getTruth());
       } else {
         truth = TruthFunctions.desireStrong(asym.getTruth(), sym.getTruth());
       }
     } else {
       truth = TruthFunctions.analogy(asym.getTruth(), sym.getTruth());
     }
     budget = BudgetFunctions.forward(truth);
   }
   TemporalValue order1 = asymSt.getOrder();
   TemporalValue order2 = symSt.getOrder();
   TemporalValue order;
   switch (figure) {
     case 11:
     case 12:
       order = TemporalRules.syllogistic(order2, order1, figure);
       break;
     case 21:
     case 22:
       order = TemporalRules.syllogistic(order1, order2, figure);
       break;
     default:
       return;
   }
   Term content = RDFStatement.make(asymSt, term1, term2, order);
   Memory.doublePremiseTask(budget, content, truth);
 }
Пример #2
0
 /**
  * {<<M --> S> ==> <M --> P>>, <M --> S>} |- <M --> P> {<<M --> S> ==> <M --> P>>, <M --> P>} |-
  * <M --> S>
  *
  * @param mainSentence The implication/equivalence premise
  * @param subSentence The premise on part of s1
  * @param s The location of s2 in s1
  */
 static void detachment(Sentence mainSentence, Sentence subSentence, int s) {
   RDFStatement statement = (RDFStatement) mainSentence.getContent();
   Term subject = statement.getSubject();
   Term predicate = statement.getPredicate();
   Term term = subSentence.getContent();
   Term content;
   int side;
   if (term.equals(subject)) {
     side = 0;
     content = predicate;
   } else if (term.equals(predicate)) {
     side = 1;
     content = subject;
   } else {
     return;
   }
   if ((content instanceof RDFStatement) && ((RDFStatement) content).invalid()) {
     return;
   }
   Sentence taskSentence = Memory.currentTask.getSentence();
   Sentence beliefSentence = Memory.currentBelief;
   TruthValue beliefTruth = beliefSentence.getTruth();
   TruthValue truth1 = mainSentence.getTruth();
   TruthValue truth2 = subSentence.getTruth();
   TruthValue truth = null;
   BudgetValue budget;
   if (taskSentence instanceof Question) {
     if (statement instanceof Equivalence) {
       budget = BudgetFunctions.backward(beliefTruth);
     } else if (side == 0) {
       budget = BudgetFunctions.backwardWeak(beliefTruth);
     } else {
       budget = BudgetFunctions.backward(beliefTruth);
     }
   } else {
     if (taskSentence instanceof Goal) {
       if (statement instanceof Equivalence) {
         truth = TruthFunctions.desireStrong(truth1, truth2);
       } else if (side == 0) {
         truth = TruthFunctions.desireInd(truth1, truth2);
       } else {
         truth = TruthFunctions.desireDed(truth1, truth2);
       }
     } else {
       if (statement instanceof Equivalence) {
         truth = TruthFunctions.analogy(truth1, truth2);
       } else if (side == 0) {
         truth = TruthFunctions.deduction(truth1, truth2);
       } else {
         truth = TruthFunctions.abduction(truth2, truth1);
       }
     }
     budget = BudgetFunctions.forward(truth);
   }
   TemporalValue tense0 = subSentence.getTense();
   TemporalValue order0 = statement.getOrder();
   TemporalValue tense;
   if (order0 == null) {
     tense = tense0;
   } else if (side == 0) {
     tense = TemporalRules.tenseSyllogistic(tense0, subSentence.getCreationTime(), order0);
   } else {
     tense =
         TemporalRules.tenseSyllogistic(
             tense0, subSentence.getCreationTime(), TemporalValue.getReverse(order0));
   }
   Memory.currentTense = tense;
   Memory.doublePremiseTask(budget, content, truth);
 }