public AtomicSentence apply(TermEquality assertion,
AtomicSentence expression)
{
AtomicSentence altExpression = null;
IdentifyCandidateMatchingTerm icm = getMatchingSubstitution(assertion
.getTerm1(), expression);
if (null != icm)
{
Term replaceWith = substVisitor.subst(
icm.getMatchingSubstitution(), assertion.getTerm2());
// Want to ignore reflexivity axiom situation, i.e. x = x
if (!icm.getMatchingTerm().Equals(replaceWith))
{
ReplaceMatchingTerm rmt = new ReplaceMatchingTerm();
// Only apply demodulation at most once on each call.
altExpression = rmt.replace(expression, icm.getMatchingTerm(),
replaceWith);
}
}
return altExpression;
}
public ProofStepClauseDemodulation(Clause demodulated, Clause origClause,
TermEquality assertion)
{
this.demodulated = demodulated;
this.origClause = origClause;
this.assertion = assertion;
this.predecessors.Add(origClause.getProofStep());
}
public ProofStepClauseParamodulation(Clause paramodulated,
Clause topClause, Clause equalityClause, TermEquality assertion)
{
this.paramodulated = paramodulated;
this.topClause = topClause;
this.equalityClause = equalityClause;
this.assertion = assertion;
this.predecessors.Add(topClause.getProofStep());
this.predecessors.Add(equalityClause.getProofStep());
}
// END-AtomicSentence
//
public override bool Equals(Object o)
{
if (this == o)
{
return(true);
}
if ((o == null) || !(o is TermEquality))
{
return(false);
}
TermEquality te = (TermEquality)o;
return(te.getTerm1().Equals(term1) && te.getTerm2().Equals(term2));
}
public Clause apply(TermEquality assertion, Clause clExpression)
{
Clause altClExpression = null;
foreach (Literal l1 in clExpression.getLiterals())
{
AtomicSentence altExpression = apply(assertion, l1
.getAtomicSentence());
if (null != altExpression)
{
// I have an alternative, create a new clause
// with the alternative and return
List<Literal> newLits = new List<Literal>();
foreach (Literal l2 in clExpression.getLiterals())
{
if (l1.Equals(l2))
{
newLits.Add(l1.newInstance(altExpression));
}
else
{
newLits.Add(l2);
}
}
// Only apply demodulation at most once on
// each call.
altClExpression = new Clause(newLits);
altClExpression.setProofStep(new ProofStepClauseDemodulation(
altClExpression, clExpression, assertion));
if (clExpression.isImmutable())
{
altClExpression.setImmutable();
}
if (!clExpression.isStandardizedApartCheckRequired())
{
altClExpression.setStandardizedApartCheckNotRequired();
}
break;
}
}
return altClExpression;
}
protected void testEqualityAndSubstitutionNoAxiomsKBabcdFFASucceeds(
InferenceProcedure infp, bool expectedToFail)
{
FOLKnowledgeBase akb = FOLKnowledgeBaseFactory
.createABCDEqualityAndSubstitutionKnowledgeBase(infp, false);
List<Term> terms = new List<Term>();
terms.Add(new Constant("A"));
Function fa = new Function("F", terms);
terms = new List<Term>();
terms.Add(fa);
TermEquality query = new TermEquality(new Function("F", terms),
new Constant("A"));
InferenceResult answer = akb.ask(query);
Assert.IsTrue(null != answer);
if (expectedToFail)
{
Assert.IsTrue(answer.isPossiblyFalse());
Assert.IsFalse(answer.isTrue());
Assert.IsFalse(answer.isUnknownDueToTimeout());
Assert.IsFalse(answer.isPartialResultDueToTimeout());
Assert.IsTrue(0 == answer.getProofs().Count);
}
else
{
Assert.IsFalse(answer.isPossiblyFalse());
Assert.IsTrue(answer.isTrue());
Assert.IsFalse(answer.isUnknownDueToTimeout());
Assert.IsFalse(answer.isPartialResultDueToTimeout());
Assert.IsTrue(1 == answer.getProofs().Count);
Assert.IsTrue(0 == answer.getProofs()[0]
.getAnswerBindings().Count);
}
}
protected void testEqualityNoAxiomsKBabcAEqualsCSucceeds(
InferenceProcedure infp, bool expectedToFail)
{
FOLKnowledgeBase akb = FOLKnowledgeBaseFactory
.createABCEqualityKnowledgeBase(infp, false);
TermEquality query = new TermEquality(new Constant("A"), new Constant(
"C"));
InferenceResult answer = akb.ask(query);
Assert.IsTrue(null != answer);
if (expectedToFail)
{
Assert.IsTrue(answer.isPossiblyFalse());
Assert.IsFalse(answer.isTrue());
Assert.IsFalse(answer.isUnknownDueToTimeout());
Assert.IsFalse(answer.isPartialResultDueToTimeout());
Assert.IsTrue(0 == answer.getProofs().Count);
}
else
{
Assert.IsFalse(answer.isPossiblyFalse());
Assert.IsTrue(answer.isTrue());
Assert.IsFalse(answer.isUnknownDueToTimeout());
Assert.IsFalse(answer.isPartialResultDueToTimeout());
Assert.IsTrue(1 == answer.getProofs().Count);
Assert.IsTrue(0 == answer.getProofs()[0]
.getAnswerBindings().Count);
}
}
public Object visitTermEquality(TermEquality equality, Object arg)
{
return arg;
}
public Object visitTermEquality(TermEquality equality, Object arg)
{
ArgData ad = (ArgData)arg;
if (ad.negated)
{
ad.clauses[ad.clauses.Count - 1].addNegativeLiteral(equality);
}
else
{
ad.clauses[ad.clauses.Count - 1].addPositiveLiteral(equality);
}
return equality;
}
public Object visitTermEquality(TermEquality equality, Object arg)
{
equality.getTerm1().accept(this, arg);
equality.getTerm2().accept(this, arg);
return equality;
}
//
// START-InferenceProcedure
public InferenceResult ask(FOLKnowledgeBase KB, Sentence alpha) {
List<Clause> sos = new List<Clause>();
List<Clause> usable = new List<Clause>();
// Usable set will be the set of clauses in the KB,
// are assuming this is satisfiable as using the
// Set of Support strategy.
foreach (Clause c in KB.getAllClauses()) {
Clause c2 = KB.standardizeApart(c);
c2.setStandardizedApartCheckNotRequired();
usable.AddRange(c2.getFactors());
}
// Ensure reflexivity axiom is added to usable if using paramodulation.
if (isUseParamodulation()) {
// Reflexivity Axiom: x = x
TermEquality reflexivityAxiom = new TermEquality(new Variable("x"),
new Variable("x"));
Clause reflexivityClause = new Clause();
reflexivityClause.addLiteral(new Literal(reflexivityAxiom));
reflexivityClause = KB.standardizeApart(reflexivityClause);
reflexivityClause.setStandardizedApartCheckNotRequired();
usable.Add(reflexivityClause);
}
Sentence notAlpha = new NotSentence(alpha);
// Want to use an answer literal to pull
// query variables where necessary
Literal answerLiteral = KB.createAnswerLiteral(notAlpha);
List<Variable> answerLiteralVariables = KB
.collectAllVariables(answerLiteral.getAtomicSentence());
Clause answerClause = new Clause();
if (answerLiteralVariables.Count > 0) {
Sentence notAlphaWithAnswer = new ConnectedSentence(Connectors.OR,
notAlpha, answerLiteral.getAtomicSentence());
foreach (Clause c in KB.convertToClauses(notAlphaWithAnswer)) {
Clause c2 = KB.standardizeApart(c);
c2.setProofStep(new ProofStepGoal(c2));
c2.setStandardizedApartCheckNotRequired();
sos.AddRange(c2.getFactors());
}
answerClause.addLiteral(answerLiteral);
} else {
foreach (Clause c in KB.convertToClauses(notAlpha)) {
Clause c2 = KB.standardizeApart(c);
c2.setProofStep(new ProofStepGoal(c2));
c2.setStandardizedApartCheckNotRequired();
sos.AddRange(c2.getFactors());
}
}
// Ensure all subsumed clauses are removed
foreach (Clause c in SubsumptionElimination.findSubsumedClauses(usable))
{
usable.Remove(c);
}
foreach (Clause c in SubsumptionElimination.findSubsumedClauses(sos))
{
sos.Remove(c);
}
OTTERAnswerHandler ansHandler = new OTTERAnswerHandler(answerLiteral,
answerLiteralVariables, answerClause, maxQueryTime);
IndexedClauses idxdClauses = new IndexedClauses(
getLightestClauseHeuristic(), sos, usable);
return otter(ansHandler, idxdClauses, sos, usable);
}
public Object visitTermEquality(TermEquality equality, Object arg)
{
Term newTerm1 = (Term)equality.getTerm1().accept(this, arg);
Term newTerm2 = (Term)equality.getTerm2().accept(this, arg);
return new TermEquality(newTerm1, newTerm2);
}
public Object visitTermEquality(TermEquality equality, Object arg)
{
foreach (Term t in equality.getArgs())
{
// Finish processing if have found a match
if (null != matchingTerm)
{
break;
}
t.accept(this, null);
}
return equality;
}
