|
public subst ( Term>.Dictionary |
||
| theta | Term>.Dictionary | |
| aFunction | Function | |
| return | Function | |
// 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));
}
// 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 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 Object visitQuantifiedSentence(QuantifiedSentence sentence,
Object arg)
{
Sentence quantified = sentence.getQuantified();
List <Variable> universalScope = (List <Variable>)arg;
// Skolemize: Skolemization is the process of removing existential
// quantifiers by elimination. This is done by introducing Skolem
// functions. The general rule is that the arguments of the Skolem
// function are all the universally quantified variables in whose
// scope the existential quantifier appears.
if (Quantifiers.isEXISTS(sentence.getQuantifier()))
{
Dictionary <Variable, Term> skolemSubst = new Dictionary <Variable, Term>();
foreach (Variable eVar in sentence.getVariables())
{
if (universalScope.Count > 0)
{
// Replace with a Skolem Function
String skolemFunctionName = parser.getFOLDomain()
.addSkolemFunction();
skolemSubst.Add(eVar, new Function(skolemFunctionName,
new List <Term>(universalScope)));
}
else
{
// Replace with a Skolem Constant
String skolemConstantName = parser.getFOLDomain()
.addSkolemConstant();
skolemSubst.Add(eVar, new Constant(skolemConstantName));
}
}
Sentence skolemized = substVisitor.subst(skolemSubst, quantified);
return(skolemized.accept(this, arg));
}
// Drop universal quantifiers.
if (Quantifiers.isFORALL(sentence.getQuantifier()))
{
// Add to the universal scope so that
// existential skolemization may be done correctly
universalScope.AddRange(sentence.getVariables());
Sentence droppedUniversal = (Sentence)quantified.accept(this, arg);
// Enusre my scope is removed before moving back up
// the call stack when returning
foreach (Variable s in sentence.getVariables())
{
universalScope.Remove(s);
}
return(droppedUniversal);
}
// Should not reach here as have already
// handled the two quantifiers.
throw new ApplicationException("Unhandled Quantifier:"
+ sentence.getQuantifier());
}
