/**
* 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);
}
}
}
}
/**
* {<(&&, 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>} |- {<S ==> P>,
*
* <P ==>S>, <S <=> P>}
*
* @param task1 The first premise
* @param task2 The second premise
* @param order Temporal order of the terms in conclusion
*/
public static void temporalIndCom(Task task1, Task task2, TemporalValue order) {
Judgment judg1 = (Judgment) task1.getSentence();
Judgment judg2 = (Judgment) task2.getSentence();
Stamp stamp = Stamp.make(judg1.getStamp(), judg2.getStamp());
if (stamp == null) {
return;
}
Memory.currentStamp = stamp;
Term term1 = judg1.getContent();
Term term2 = judg2.getContent();
if ((term1 instanceof Inheritance) && (term2 instanceof Inheritance)) {
RDFStatement s1 = (RDFStatement) term1;
RDFStatement s2 = (RDFStatement) term2;
Variable var1 = new Variable(Symbols.VARIABLE_TAG + "0");
Variable var2 = new Variable(Symbols.VARIABLE_TAG + "0");
if (s1.getSubject().equals(s2.getSubject())) {
term1 = RDFStatement.make(s1, var1, s1.getPredicate());
term2 = RDFStatement.make(s2, var2, s2.getPredicate());
} else if (s1.getPredicate().equals(s2.getPredicate())) {
term1 = RDFStatement.make(s1, s1.getSubject(), var1);
term2 = RDFStatement.make(s2, s2.getSubject(), var2);
}
} else { // to generalize
Term condition;
if ((term1 instanceof Implication) && (term2 instanceof Inheritance)) {
condition = ((Implication) term1).getSubject();
if (condition.equals(term2)) {
return;
}
if ((condition instanceof Conjunction)
&& ((Conjunction) condition).containComponent(term2)) {
return;
}
} else if ((term1 instanceof Inheritance) && (term2 instanceof Implication)) {
condition = ((Implication) term2).getSubject();
if (condition.equals(term1)) {
return;
}
if ((condition instanceof Conjunction)
&& ((Conjunction) condition).containComponent(term1)) {
return;
}
}
}
RDFStatement statement1 = Implication.make(term1, term2, order);
RDFStatement statement2 = Implication.make(term2, term1, TemporalValue.getReverse(order));
RDFStatement statement3 = Equivalence.make(term1, term2, order);
TruthValue value1 = judg1.getTruth();
TruthValue value2 = judg2.getTruth();
TruthValue truth1 = TruthFunctions.induction(value1, value2);
TruthValue truth2 = TruthFunctions.induction(value2, value1);
TruthValue truth3 = TruthFunctions.comparison(value1, value2);
BudgetValue budget1 =
BudgetFunctions.temporalIndCom(task1.getBudget(), task2.getBudget(), truth1);
BudgetValue budget2 =
BudgetFunctions.temporalIndCom(task1.getBudget(), task2.getBudget(), truth2);
BudgetValue budget3 =
BudgetFunctions.temporalIndCom(task1.getBudget(), task2.getBudget(), truth3);
Memory.currentTense = new TemporalValue(0);
Memory.doublePremiseTask(budget1, statement1, truth1);
Memory.doublePremiseTask(budget2, statement2, truth2);
Memory.doublePremiseTask(budget3, statement3, truth3);
}
/**
* {<<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);
}