/**
* 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;
}
}
/**
* {<S ==> M>, <M ==> P>} |- {<S ==> P>,
*
* <P ==>S>}
*
* @param term1 Subject of the first new task
* @param term2 Predicate of the first new task
* @param sentence The first premise
* @param belief The second premise
*/
static void dedExe(Term term1, Term term2, Sentence sentence, Judgment belief) {
if (RDFStatement.invalidStatement(term1, term2)) {
return;
}
TruthValue value1 = sentence.getTruth();
TruthValue value2 = belief.getTruth();
TruthValue truth1 = null;
TruthValue truth2 = null;
BudgetValue budget1, budget2;
if (sentence instanceof Question) {
budget1 = BudgetFunctions.backwardWeak(value2);
budget2 = BudgetFunctions.backwardWeak(value2);
} else {
if (sentence instanceof Goal) {
truth1 = TruthFunctions.desireWeak(value1, value2);
truth2 = TruthFunctions.desireWeak(value1, value2);
} else {
truth1 = TruthFunctions.deduction(value1, value2);
truth2 = TruthFunctions.exemplification(value1, value2);
}
budget1 = BudgetFunctions.forward(truth1);
budget2 = BudgetFunctions.forward(truth2);
}
TemporalValue order1 = sentence.getContent().getOrder();
TemporalValue order2 = belief.getContent().getOrder();
TemporalValue order = TemporalRules.syllogistic(order1, order2);
RDFStatement content1 =
RDFStatement.make((RDFStatement) sentence.getContent(), term1, term2, order);
RDFStatement content2 =
RDFStatement.make(
(RDFStatement) sentence.getContent(), term2, term1, TemporalValue.getReverse(order));
Memory.doublePremiseTask(budget1, content1, truth1);
Memory.doublePremiseTask(budget2, content2, truth2);
}
/**
* {<M --> S>, <M --> P>} |- <<#x --> S> ==> <#x --> P>> {<M --> S>, <M --> P>} |- <<#x --> S> <=>
* <#x --> P>>
*
* @param sentence1 The first premise <M --> S>
* @param sentence2 The second premise <M --> P>
* @param figure The figure indicating the location of the shared term
* @param isImplication The conclusion is Implication, not Equivalence
*/
private static RDFStatement introVarInd(
Sentence sentence1, Sentence sentence2, int figure, boolean isImplication) {
RDFStatement premise1 = (RDFStatement) sentence1.getContent();
RDFStatement premise2 = (RDFStatement) sentence2.getContent();
RDFStatement state1, state2;
Variable v1 = new Variable(Symbols.VARIABLE_TAG + "0");
Variable v2 = new Variable(Symbols.VARIABLE_TAG + "0");
if (figure == 11) {
state1 = RDFStatement.make(premise1, v1, premise1.getPredicate());
state2 = RDFStatement.make(premise2, v2, premise2.getPredicate());
} else {
state1 = RDFStatement.make(premise1, premise1.getSubject(), v1);
state2 = RDFStatement.make(premise2, premise2.getSubject(), v2);
}
TemporalValue tense1 = sentence1.getTense();
TemporalValue tense2 = sentence2.getTense();
TemporalValue tense = TemporalRules.tenseInduction(tense1, tense2);
if (tense == null) {
return null;
}
RDFStatement content;
if (isImplication) {
content = Implication.make(state1, state2, tense);
} else {
content = Equivalence.make(state1, state2, tense);
}
return content;
}
/**
* {<S <=> M>, <M <=> P>} |- <S <=> P>
*
* @param term1 Subject of the new task
* @param term2 Predicate of the new task
* @param belief The first premise
* @param sentence The second premise
* @param figure Locations of the shared term in premises
*/
static void resemblance(Term term1, Term term2, Judgment belief, Sentence sentence, int figure) {
if (RDFStatement.invalidStatement(term1, term2)) {
return;
}
RDFStatement st1 = (RDFStatement) belief.getContent();
RDFStatement st2 = (RDFStatement) sentence.getContent();
TruthValue truth = null;
BudgetValue budget;
Task task = Memory.currentTask;
if (sentence instanceof Question) {
budget = BudgetFunctions.backward(belief.getTruth());
} else {
if (sentence instanceof Goal) {
truth = TruthFunctions.desireStrong(sentence.getTruth(), belief.getTruth());
} else {
truth = TruthFunctions.resemblance(belief.getTruth(), sentence.getTruth());
}
budget = BudgetFunctions.forward(truth);
}
TemporalValue order1 = st1.getOrder();
TemporalValue order2 = st2.getOrder();
TemporalValue order = TemporalRules.syllogistic(order1, order2, figure);
Term statement = RDFStatement.make(st1, term1, term2, order);
Memory.doublePremiseTask(budget, statement, truth);
}
/**
* 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;
}
}
/**
* {<M ==> S>, <M ==> P>} |- {<S ==> P>,
*
* <P ==>S>, <S <=> P>}
*
* @param term1 Subject of the first new task
* @param term2 Predicate of the first new task
* @param taskSentence The first premise
* @param belief The second premise
* @param figure Locations of the shared term in premises
*/
static void abdIndCom(
Term term1, Term term2, Sentence taskSentence, Judgment belief, int figure) {
if (RDFStatement.invalidStatement(term1, term2)) {
return;
}
RDFStatement st1 = (RDFStatement) taskSentence.getContent();
RDFStatement st2 = (RDFStatement) belief.getContent();
TruthValue truth1 = null;
TruthValue truth2 = null;
TruthValue truth3 = null;
BudgetValue budget1, budget2, budget3;
TruthValue value1 = taskSentence.getTruth();
TruthValue value2 = belief.getTruth();
if (taskSentence instanceof Question) {
budget1 = BudgetFunctions.backward(value2);
budget2 = BudgetFunctions.backwardWeak(value2);
budget3 = BudgetFunctions.backward(value2);
} else {
if (taskSentence instanceof Goal) {
truth1 = TruthFunctions.desireStrong(value1, value2);
truth2 = TruthFunctions.desireWeak(value2, value1);
truth3 = TruthFunctions.desireStrong(value1, value2);
} else {
truth1 = TruthFunctions.abduction(value1, value2);
truth2 = TruthFunctions.abduction(value2, value1);
truth3 = TruthFunctions.comparison(value1, value2);
}
budget1 = BudgetFunctions.forward(truth1);
budget2 = BudgetFunctions.forward(truth2);
budget3 = BudgetFunctions.forward(truth3);
}
TemporalValue order1 = st1.getOrder();
TemporalValue order2 = st2.getOrder();
TemporalValue order = TemporalRules.syllogistic(order1, order2, figure);
// if (tense == null) {
// tense = TemporalValue.WHEN;
// truth1 = TruthFunctions.temporalInduction(truth1);
// truth2 = TruthFunctions.temporalInduction(truth2);
// truth3 = TruthFunctions.temporalInduction(truth3);
// }
RDFStatement statement1, statement2, statement3;
statement1 = RDFStatement.make(st1, term1, term2, order);
statement2 = RDFStatement.make(st1, term2, term1, TemporalValue.getReverse(order));
statement3 = RDFStatement.makeSym(st1, term1, term2, order);
Memory.doublePremiseTask(budget1, statement1, truth1);
Memory.doublePremiseTask(budget2, statement2, truth2);
Memory.doublePremiseTask(budget3, statement3, truth3);
if (statement1.isConstant()) {
Memory.doublePremiseTask(budget1, introVarInd(belief, taskSentence, figure, true), truth1);
Memory.doublePremiseTask(budget2, introVarInd(taskSentence, belief, figure, true), truth2);
Memory.doublePremiseTask(budget3, introVarInd(taskSentence, belief, figure, false), truth3);
}
}
/**
* 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);
}
}
}
}
/**
* 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;
}
}
/**
* 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:
}
}
/**
* {<M --> S>, <C ==> <M --> P>>} |- <(&&, <#x --> S>, C) ==> <#x --> P>> {<M --> S>, (&&, C, <M
* --> P>)} |- (&&, C, <<#x --> S> ==> <#x --> P>>)
*
* @param premise1 The first premise directly used in internal induction, <M --> S>
* @param premise2 The component to be used as a premise in internal induction, <M --> P>
* @param oldCompound The whole content of the first premise, Implication or Conjunction
*/
static void introVarIndInner(
RDFStatement premise1, RDFStatement premise2, CompoundTerm oldCompound) {
Task task = Memory.currentTask;
Sentence taskSentence = task.getSentence();
if (!taskSentence.isJudgment()) {
return;
}
if (premise1.getClass() != premise2.getClass()) {
return;
}
Variable var1 = new Variable(Symbols.VARIABLE_TAG + "0");
Variable var2 = new Variable(Symbols.VARIABLE_TAG + "0");
RDFStatement state1, state2;
if (premise1.getSubject().equals(premise2.getSubject())) {
state1 = RDFStatement.make(premise1, var1, premise1.getPredicate());
state2 = RDFStatement.make(premise2, var2, premise2.getPredicate());
} else if (premise1.getPredicate().equals(premise2.getPredicate())) {
state1 = RDFStatement.make(premise1, premise1.getSubject(), var1);
state2 = RDFStatement.make(premise2, premise2.getSubject(), var2);
} else {
return;
}
Sentence belief = Memory.currentBelief;
Term compound, content;
TemporalValue tense;
TruthValue truth;
if (premise1.equals(taskSentence.getContent())) {
truth = TruthFunctions.abduction(taskSentence.getTruth(), belief.getTruth());
tense = TemporalRules.tenseInduction(taskSentence.getTense(), belief.getTense());
} else {
truth = TruthFunctions.abduction(belief.getTruth(), taskSentence.getTruth());
tense = TemporalRules.tenseInduction(belief.getTense(), taskSentence.getTense());
}
if (tense == null) {
return;
}
if ((oldCompound instanceof Implication) && (tense == oldCompound.getOrder())) {
compound = RDFStatement.make((RDFStatement) oldCompound, oldCompound.componentAt(0), state2);
content = RDFStatement.make((RDFStatement) oldCompound, state1, compound);
} else if (oldCompound instanceof Conjunction) {
compound = Implication.make(state1, state2, tense);
content = CompoundTerm.replaceComponent(oldCompound, premise2, compound);
} else {
return;
}
BudgetValue budget = BudgetFunctions.forward(truth);
Memory.doublePremiseTask(budget, content, truth);
}
/**
* {<(&&, S2, S3) ==> P>, <(&&, S1, S3) ==> P>} |- <S1 ==> S2>
*
* @param cond1 The condition of the first premise
* @param cond2 The condition of the second premise
* @param st1 The first premise
* @param st2 The second premise
* @return Whether there are derived tasks
*/
static boolean conditionalAbd(Term cond1, Term cond2, RDFStatement st1, RDFStatement st2) {
if (!(st1 instanceof Implication) || !(st2 instanceof Implication)) {
return false;
}
if (!(cond1 instanceof Conjunction) && !(cond2 instanceof Conjunction)) {
return false;
}
TemporalValue order1 = st1.getOrder();
TemporalValue order2 = st2.getOrder();
if (order1 != order2) {
return false;
}
Term term1 = null;
Term term2 = null;
if (cond1 instanceof Conjunction) {
term1 = CompoundTerm.reduceComponents((Conjunction) cond1, cond2);
}
if (cond2 instanceof Conjunction) {
term2 = CompoundTerm.reduceComponents((Conjunction) cond2, cond1);
}
if ((term1 == null) && (term2 == null)) {
return false;
}
Task task = Memory.currentTask;
Sentence sentence = task.getSentence();
Judgment belief = Memory.currentBelief;
TruthValue value1 = sentence.getTruth();
TruthValue value2 = belief.getTruth();
boolean keepOrder =
(Variable.findSubstitute(Variable.VarType.INDEPENDENT, st1, task.getContent()) != null);
Term content;
TruthValue truth = null;
BudgetValue budget;
if (term1 != null) {
if (term2 != null) {
content = RDFStatement.make(st2, term2, term1, order2);
} else {
content = term1;
}
if (sentence instanceof Question) {
budget = BudgetFunctions.backwardWeak(value2);
} else {
if (sentence instanceof Goal) {
if (keepOrder) {
truth = TruthFunctions.desireDed(value1, value2);
} else {
truth = TruthFunctions.desireInd(value1, value2);
}
} else {
truth = TruthFunctions.abduction(value2, value1);
}
budget = BudgetFunctions.forward(truth);
}
Memory.doublePremiseTask(budget, content, truth);
}
if (term2 != null) {
if (term1 != null) {
content = RDFStatement.make(st1, term1, term2, order1);
} else {
content = term2;
}
if (sentence instanceof Question) {
budget = BudgetFunctions.backwardWeak(value2);
} else {
if (sentence instanceof Goal) {
if (keepOrder) {
truth = TruthFunctions.desireDed(value1, value2);
} else {
truth = TruthFunctions.desireInd(value1, value2);
}
} else {
truth = TruthFunctions.abduction(value1, value2);
}
budget = BudgetFunctions.forward(truth);
}
Memory.currentTense = null;
Memory.doublePremiseTask(budget, content, truth);
}
return true;
}
/**
* {<(&&, 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);
}
/**
* {<<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);
}
/**
* {<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);
}