/**
* {<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;
}
/**
* {<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);
}
/**
* Extract consequents from a implications at a single program point. It only searches for top
* level Program points because Implications are produced only at those points.
*/
public static void extract_consequent_maybe(PptTopLevel ppt, PptMap all_ppts) {
ppt.simplify_variable_names();
List<Invariant> invs = new ArrayList<Invariant>();
if (invs.size() > 0) {
String pptname = cleanup_pptname(ppt.name());
for (Invariant maybe_as_inv : invs) {
Implication maybe = (Implication) maybe_as_inv;
// don't print redundant invariants.
if (Daikon.suppress_redundant_invariants_with_simplify
&& maybe.ppt.parent.redundant_invs.contains(maybe)) {
continue;
}
// don't print out invariants with min(), max(), or sum() variables
boolean mms = false;
VarInfo[] varbls = maybe.ppt.var_infos;
for (int v = 0; !mms && v < varbls.length; v++) {
mms |= varbls[v].isDerivedSequenceMinMaxSum();
}
if (mms) {
continue;
}
if (maybe.ppt.parent.ppt_name.isExitPoint()) {
for (int i = 0; i < maybe.ppt.var_infos.length; i++) {
VarInfo vi = maybe.ppt.var_infos[i];
if (vi.isDerivedParam()) {
continue;
}
}
}
Invariant consequent = maybe.consequent();
Invariant predicate = maybe.predicate();
Invariant inv, cluster_inv;
boolean cons_uses_cluster = false, pred_uses_cluster = false;
// extract the consequent (predicate) if the predicate
// (consequent) uses the variable "cluster". Ignore if they
// both depend on "cluster"
if (consequent.usesVarDerived("cluster")) cons_uses_cluster = true;
if (predicate.usesVarDerived("cluster")) pred_uses_cluster = true;
if (!(pred_uses_cluster ^ cons_uses_cluster)) {
continue;
} else if (pred_uses_cluster) {
inv = consequent;
cluster_inv = predicate;
} else {
inv = predicate;
cluster_inv = consequent;
}
if (!inv.isInteresting()) {
continue;
}
if (!inv.isWorthPrinting()) {
continue;
}
if (contains_constant_non_012(inv)) {
continue;
}
// filter out unwanted invariants
// 1) Invariants involving sequences
if (inv instanceof daikon.inv.binary.twoSequence.TwoSequence
|| inv instanceof daikon.inv.binary.sequenceScalar.SequenceScalar
|| inv instanceof daikon.inv.binary.sequenceString.SequenceString
|| inv instanceof daikon.inv.unary.sequence.SingleSequence
|| inv instanceof daikon.inv.unary.stringsequence.SingleStringSequence) {
continue;
}
if (inv instanceof daikon.inv.ternary.threeScalar.LinearTernary
|| inv instanceof daikon.inv.binary.twoScalar.LinearBinary) {
continue;
}
String inv_string = inv.format_using(OutputFormat.JAVA);
if (orig_pattern.matcher(inv_string).find()
|| dot_class_pattern.matcher(inv_string).find()) {
continue;
}
String fake_inv_string = simplify_inequalities(inv_string);
HashedConsequent real = new HashedConsequent(inv, null);
if (!fake_inv_string.equals(inv_string)) {
// For instance, inv_string is "x != y", fake_inv_string is "x == y"
HashedConsequent fake = new HashedConsequent(inv, inv_string);
boolean added =
store_invariant(
cluster_inv.format_using(OutputFormat.JAVA), fake_inv_string, fake, pptname);
if (!added) {
// We couldn't add "x == y", (when we're "x != y") because
// it already exists; so don't add "x == y" either.
continue;
}
}
store_invariant(cluster_inv.format_using(OutputFormat.JAVA), inv_string, real, pptname);
}
}
}
/**
* {<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);
}
/**
* {<(&&, 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);
}