/**
* {<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);
}
/**
* {<<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);
}
