// Note: see page 327.
public StandardizeApartResult standardizeApart(Sentence aSentence,
StandardizeApartIndexical standardizeApartIndexical)
{
List<Variable> toRename = variableCollector
.collectAllVariables(aSentence);
Dictionary<Variable, Term> renameSubstitution = new Dictionary<Variable, Term>();
Dictionary<Variable, Term> reverseSubstitution = new Dictionary<Variable, Term>();
foreach (Variable var in toRename)
{
Variable v = null;
do
{
v = new Variable(standardizeApartIndexical.getPrefix()
+ standardizeApartIndexical.getNextIndex());
// Ensure the new variable name is not already
// accidentally used in the sentence
} while (toRename.Contains(v));
renameSubstitution.Add(var, v);
reverseSubstitution.Add(v, var);
}
Sentence standardized = substVisitor.subst(renameSubstitution,
aSentence);
return new StandardizeApartResult(aSentence, standardized,
renameSubstitution, reverseSubstitution);
}
public void testUnificationFailure()
{
Variable var = new Variable("x");
Sentence sentence = parser.parse("Knows(y)");
theta = null;
Dictionary<Variable, Term> result = unifier.unify(var, sentence, theta);
Assert.IsNull(result);
}
public override Object visitVariable(Variable variable, Object arg)
{
Dictionary<Variable, Term> substitution = (Dictionary<Variable, Term>)arg;
if (substitution.ContainsKey(variable))
{
return substitution[variable].copy();
}
return variable.copy();
}
public void testVariableEqualsConstant()
{
Variable var1 = new Variable("x");
Constant constant = new Constant("John");
Dictionary<Variable, Term> result = unifier.unify(var1, constant, theta);
Assert.AreEqual(theta, result);
Assert.AreEqual(1, theta.Keys.Count);
Assert.IsTrue(theta.ContainsKey(var1));
Assert.AreEqual(constant, theta[var1]);
}
public void testThetaPassedBackIfXEqualsYBothVariables()
{
Variable var1 = new Variable("x");
Variable var2 = new Variable("x");
theta.Add(new Variable("dummy"), new Variable("dummy"));
Dictionary<Variable, Term> result = unifier.unify(var1, var2, theta);
Assert.AreEqual(theta, result);
Assert.AreEqual(1, theta.Keys.Count);
Assert.IsTrue(theta.ContainsKey(new Variable("dummy")));
}
public void testSimpleVariableUnification()
{
Variable var1 = new Variable("x");
List<Term> terms1 = new List<Term>();
terms1.Add(var1);
Predicate p1 = new Predicate("King", terms1); // King(x)
List<Term> terms2 = new List<Term>();
terms2.Add(new Constant("John"));
Predicate p2 = new Predicate("King", terms2); // King(John)
Dictionary<Variable, Term> result = unifier.unify(p1, p2, theta);
Assert.AreEqual(theta, result);
Assert.AreEqual(1, theta.Keys.Count);
Assert.IsTrue(theta.ContainsKey(new Variable("x"))); // x =
Assert.AreEqual(new Constant("John"), theta[var1]); // John
}
public Clause standardizeApart(Clause clause,
StandardizeApartIndexical standardizeApartIndexical)
{
List<Variable> toRename = variableCollector.collectAllVariables(clause);
Dictionary<Variable, Term> renameSubstitution = new Dictionary<Variable, Term>();
foreach (Variable var in toRename)
{
Variable v = null;
do
{
v = new Variable(standardizeApartIndexical.getPrefix()
+ standardizeApartIndexical.getNextIndex());
// Ensure the new variable name is not already
// accidentally used in the sentence
} while (toRename.Contains(v));
if (renameSubstitution.ContainsKey(var))
{
renameSubstitution[var] = v;
}
else
{
renameSubstitution.Add(var, v);
}
}
if (renameSubstitution.Count > 0)
{
List<Literal> literals = new List<Literal>();
foreach (Literal l in clause.getLiterals())
{
literals.Add(substVisitor.subst(renameSubstitution, l));
}
Clause renamed = new Clause(literals);
renamed.setProofStep(new ProofStepRenaming(renamed, clause
.getProofStep()));
return renamed;
}
return clause;
}
//
// PROTECTED METHODS
//
// Note: You can subclass and override this method in order
// to re-implement the OCCUR-CHECK?() to always
// return false if you want that to be the default
// behavior, as is the case with Prolog.
protected bool occurCheck(Dictionary<Variable, Term> theta, Variable var,
FOLNode x)
{
if (x is Function)
{
List<Variable> varsToCheck = _variableCollector
.collectAllVariables((Function)x);
if (varsToCheck.Contains(var))
{
return true;
}
// Now need to check if cascading will cause occurs to happen
// e.g.
// Loves(SF1(v2),v2)
// Loves(v3,SF0(v3))
// or
// P(v1,SF0(v1),SF0(v1))
// P(v2,SF0(v2),v2 )
// or
// P(v1, F(v2),F(v2),F(v2),v1, F(F(v1)),F(F(F(v1))),v2)
// P(F(v3),v4, v5, v6, F(F(v5)),v4, F(v3), F(F(v5)))
return cascadeOccurCheck(theta, var, varsToCheck,
new List<Variable>(varsToCheck));
}
return false;
}
public Object visitVariable(Variable var, Object arg)
{
List<Variable> variables = (List<Variable>)arg;
variables.Add(var);
return var;
}
public Object visitVariable(Variable variable, Object arg)
{
if (!replaced)
{
if (toReplace.Equals(variable))
{
replaced = true;
return replaceWith;
}
}
return variable;
}
public Object visitVariable(Variable variable, Object arg)
{
// This should not be called
throw new NotImplementedException("visitVariable() should not be called.");
}
// See:
// http://logic.stanford.edu/classes/cs157/2008/miscellaneous/faq.html#jump165
// for need for this.
private void cascadeSubstitution(Dictionary<Variable, Term> theta, Variable var,
Term x)
{
theta.Add(var, x);
List<Variable> thetaKeys = theta.Keys.ToList<Variable>();
foreach (Variable v in thetaKeys)
{
Term t = theta[v];
if (theta.ContainsKey(v))
{
theta[v] = _substVisitor.subst(theta, t);
}
else
{
theta.Add(v, _substVisitor.subst(theta, t));
}
}
}
public virtual Object visitVariable(Variable variable, Object arg)
{
return variable.copy();
}
public void testSimpleEquals()
{
Term cons1 = new Constant("C1");
Term cons2 = new Constant("C2");
Term var1 = new Variable("v1");
List<Term> pts1 = new List<Term>();
List<Term> pts2 = new List<Term>();
pts1.Add(cons1);
pts1.Add(cons2);
pts1.Add(var1);
pts2.Add(cons2);
pts2.Add(cons1);
pts2.Add(var1);
Clause c1 = new Clause();
Clause c2 = new Clause();
Assert.IsTrue(c1.Equals(c1));
Assert.IsTrue(c2.Equals(c2));
Assert.IsTrue(c1.Equals(c2));
Assert.IsTrue(c2.Equals(c1));
// Check negatives
c1.addNegativeLiteral(new Predicate("Pred1", pts1));
Assert.IsFalse(c1.Equals(c2));
Assert.IsFalse(c2.Equals(c1));
c2.addNegativeLiteral(new Predicate("Pred1", pts1));
Assert.IsTrue(c1.Equals(c2));
Assert.IsTrue(c2.Equals(c1));
c1.addNegativeLiteral(new Predicate("Pred2", pts2));
Assert.IsFalse(c1.Equals(c2));
Assert.IsFalse(c2.Equals(c1));
c2.addNegativeLiteral(new Predicate("Pred2", pts2));
Assert.IsTrue(c1.Equals(c2));
Assert.IsTrue(c2.Equals(c1));
// Check same but added in different order
c1.addNegativeLiteral(new Predicate("Pred3", pts1));
Assert.IsFalse(c1.Equals(c2));
Assert.IsFalse(c2.Equals(c1));
c1.addNegativeLiteral(new Predicate("Pred4", pts1));
Assert.IsFalse(c1.Equals(c2));
Assert.IsFalse(c2.Equals(c1));
c2.addNegativeLiteral(new Predicate("Pred4", pts1));
Assert.IsFalse(c1.Equals(c2));
Assert.IsFalse(c2.Equals(c1));
c2.addNegativeLiteral(new Predicate("Pred3", pts1));
Assert.IsTrue(c1.Equals(c2));
Assert.IsTrue(c2.Equals(c1));
// Check positives
c1.addPositiveLiteral(new Predicate("Pred1", pts1));
Assert.IsFalse(c1.Equals(c2));
Assert.IsFalse(c2.Equals(c1));
c2.addPositiveLiteral(new Predicate("Pred1", pts1));
Assert.IsTrue(c1.Equals(c2));
Assert.IsTrue(c2.Equals(c1));
c1.addPositiveLiteral(new Predicate("Pred2", pts2));
Assert.IsFalse(c1.Equals(c2));
Assert.IsFalse(c2.Equals(c1));
c2.addPositiveLiteral(new Predicate("Pred2", pts2));
Assert.IsTrue(c1.Equals(c2));
Assert.IsTrue(c2.Equals(c1));
// Check same but added in different order
c1.addPositiveLiteral(new Predicate("Pred3", pts1));
Assert.IsFalse(c1.Equals(c2));
Assert.IsFalse(c2.Equals(c1));
c1.addPositiveLiteral(new Predicate("Pred4", pts1));
Assert.IsFalse(c1.Equals(c2));
Assert.IsFalse(c2.Equals(c1));
c2.addPositiveLiteral(new Predicate("Pred4", pts1));
Assert.IsFalse(c1.Equals(c2));
Assert.IsFalse(c2.Equals(c1));
c2.addPositiveLiteral(new Predicate("Pred3", pts1));
Assert.IsTrue(c1.Equals(c2));
Assert.IsTrue(c2.Equals(c1));
}
public void testHashCode()
{
Term cons1 = new Constant("C1");
Term cons2 = new Constant("C2");
Term var1 = new Variable("v1");
List<Term> pts1 = new List<Term>();
List<Term> pts2 = new List<Term>();
pts1.Add(cons1);
pts1.Add(cons2);
pts1.Add(var1);
pts2.Add(cons2);
pts2.Add(cons1);
pts2.Add(var1);
Clause c1 = new Clause();
Clause c2 = new Clause();
Assert.AreEqual(c1.GetHashCode(), c2.GetHashCode());
c1.addNegativeLiteral(new Predicate("Pred1", pts1));
Assert.AreNotSame(c1.GetHashCode(), c2.GetHashCode());
c2.addNegativeLiteral(new Predicate("Pred1", pts1));
Assert.AreEqual(c1.GetHashCode(), c2.GetHashCode());
c1.addPositiveLiteral(new Predicate("Pred1", pts1));
Assert.AreNotSame(c1.GetHashCode(), c2.GetHashCode());
c2.addPositiveLiteral(new Predicate("Pred1", pts1));
Assert.AreEqual(c1.GetHashCode(), c2.GetHashCode());
}
//
// PRIVATE METHODS
//
/**
* <code>
* function UNIFY-VAR(var, x, theta) returns a substitution
* inputs: var, a variable
* x, any expression
* theta, the substitution built up so far
* </code>
*/
private Dictionary<Variable, Term> unifyVar(Variable var, FOLNode x,
Dictionary<Variable, Term> theta)
{
if (!(x is Term))
{
return null;
}
else if (theta.ContainsKey(var))
{
// if {var/val} E theta then return UNIFY(val, x, theta)
return unify(theta[var], x, theta);
}
else if (theta.Keys.Contains(x))
{
// else if {x/val} E theta then return UNIFY(var, val, theta)
return unify(var, (FOLNode)theta[(Variable)x], theta);
}
else if (occurCheck(theta, var, x))
{
// else if OCCUR-CHECK?(var, x) then return failure
return null;
}
else
{
// else return add {var/x} to theta
cascadeSubstitution(theta, var, (Term)x);
return theta;
}
}
private bool cascadeOccurCheck(Dictionary<Variable, Term> theta, Variable var,
List<Variable> varsToCheck, List<Variable> varsCheckedAlready)
{
// Want to check if any of the variable to check end up
// looping back around on the new variable.
List<Variable> nextLevelToCheck = new List<Variable>();
foreach (Variable v in varsToCheck)
{
Term t = null;
if (theta.ContainsKey(v))
{
t = theta[v];
}
if (null == t)
{
// Variable may not be a key so skip
continue;
}
if (t.Equals(var))
{
// e.g.
// v1=v2
// v2=SFO(v1)
return true;
}
else if (t is Function)
{
// Need to ensure the function this variable
// is to be replaced by does not contain var.
List<Variable> indirectvars = _variableCollector
.collectAllVariables(t);
if (indirectvars.Contains(var))
{
return true;
}
else
{
// Determine the next cascade/level
// of variables to check for looping
foreach (Variable iv in indirectvars)
{
if (!varsCheckedAlready.Contains(iv))
{
nextLevelToCheck.Add(iv);
}
}
}
}
}
if (nextLevelToCheck.Count > 0)
{
varsCheckedAlready.AddRange(nextLevelToCheck);
return cascadeOccurCheck(theta, var, nextLevelToCheck,
varsCheckedAlready);
}
return false;
}
public Chain standardizeApart(Chain chain,
StandardizeApartIndexical standardizeApartIndexical)
{
List<Variable> toRename = variableCollector.collectAllVariables(chain);
Dictionary<Variable, Term> renameSubstitution = new Dictionary<Variable, Term>();
foreach (Variable var in toRename)
{
Variable v = null;
do
{
v = new Variable(standardizeApartIndexical.getPrefix()
+ standardizeApartIndexical.getNextIndex());
// Ensure the new variable name is not already
// accidentally used in the sentence
} while (toRename.Contains(v));
renameSubstitution.Add(var, v);
}
if (renameSubstitution.Count > 0)
{
List<Literal> lits = new List<Literal>();
foreach (Literal l in chain.getLiterals())
{
AtomicSentence atom = (AtomicSentence)substVisitor.subst(
renameSubstitution, l.getAtomicSentence());
lits.Add(l.newInstance(atom));
}
Chain renamed = new Chain(lits);
renamed.setProofStep(new ProofStepRenaming(renamed, chain
.getProofStep()));
return renamed;
}
return chain;
}
public Object visitQuantifiedSentence(QuantifiedSentence sentence,
Object arg)
{
List<Variable> seenSoFar = (List<Variable>)arg;
// Keep track of what I have to subst locally and
// what my renamed variables will be.
Dictionary<Variable, Term> localSubst = new Dictionary<Variable, Term>();
List<Variable> replVariables = new List<Variable>();
foreach (Variable v in sentence.getVariables())
{
// If local variable has be renamed already
// then I need to come up with own name
if (seenSoFar.Contains(v))
{
Variable sV = new Variable(quantifiedIndexical.getPrefix()
+ quantifiedIndexical.getNextIndex());
localSubst.Add(v, sV);
// Replacement variables should contain new name for variable
replVariables.Add(sV);
}
else
{
// Not already replaced, this name is good
replVariables.Add(v);
}
}
// Apply the local subst
Sentence subst = substVisitor.subst(localSubst, sentence
.getQuantified());
// Ensure all my existing and replaced variable
// names are tracked
seenSoFar.AddRange(replVariables);
Sentence sQuantified = (Sentence)subst.accept(this, arg);
return new QuantifiedSentence(sentence.getQuantifier(), replVariables,
sQuantified);
}
public Dictionary<Variable, Term> standardizeApart(List<Literal> l1Literals,
List<Literal> l2Literals,
StandardizeApartIndexical standardizeApartIndexical)
{
List<Variable> toRename = new List<Variable>();
foreach (Literal pl in l1Literals)
{
toRename.AddRange(variableCollector.collectAllVariables(pl
.getAtomicSentence()));
}
foreach (Literal nl in l2Literals)
{
toRename.AddRange(variableCollector.collectAllVariables(nl
.getAtomicSentence()));
}
Dictionary<Variable, Term> renameSubstitution = new Dictionary<Variable, Term>();
foreach (Variable var in toRename)
{
Variable v = null;
do
{
v = new Variable(standardizeApartIndexical.getPrefix()
+ standardizeApartIndexical.getNextIndex());
// Ensure the new variable name is not already
// accidentally used in the sentence
} while (toRename.Contains(v));
if (renameSubstitution.ContainsKey(var))
{
renameSubstitution[var] = v;
}
else
{
renameSubstitution.Add(var, v);
}
}
List<Literal> posLits = new List<Literal>();
List<Literal> negLits = new List<Literal>();
foreach (Literal pl in l1Literals)
{
posLits.Add(substVisitor.subst(renameSubstitution, pl));
}
foreach (Literal nl in l2Literals)
{
negLits.Add(substVisitor.subst(renameSubstitution, nl));
}
l1Literals.Clear();
l1Literals.AddRange(posLits);
l2Literals.Clear();
l2Literals.AddRange(negLits);
return renameSubstitution;
}
public Object visitVariable(Variable variable, Object arg)
{
return arg;
}
public Object visitVariable(Variable variable, Object arg)
{
if (null != (substitution = abstractModulation.unifier.unify(toMatch, variable)))
{
if (abstractModulation.isValidMatch(toMatch, toMatchVariables, variable,
substitution))
{
matchingTerm = variable;
}
}
return variable;
}