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