public Clause GetStandardizeApartResult(Clause clause, IStandardizeApartIndexical standardizeApartIndexical)
{
var toRename = variableCollector.CollectAllVariables(clause);
IDictionary <Variable, ITerm> renameSubstitution = new Dictionary <Variable, ITerm>();
foreach (var 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[var] = v;
}
if (renameSubstitution.Count > 0)
{
var literals = clause.GetLiterals().Select(l => this.substVisitor.Subst(renameSubstitution, l)).ToList();
var renamed = new Clause(literals);
renamed.SetProofStep(new ProofStepRenaming(renamed, clause.GetProofStep()));
return(renamed);
}
return(clause);
}
public Clause Apply(TermEquality assertion, Clause clExpression)
{
Clause altClExpression = null;
foreach (Literal l1 in clExpression.GetLiterals())
{
IAtomicSentence altExpression = Apply(assertion, l1.AtomicSentence);
if (null != altExpression)
{
// I have an alternative, create a new clause
// with the alternative and return
IList <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.Immutable)
{
altClExpression.Immutable = true;
}
if (!clExpression.IsStandardizedApartCheckRequired())
{
altClExpression.SetStandardizedApartCheckNotRequired();
}
break;
}
}
return(altClExpression);
}
public ISet <Variable> CollectAllVariables(Clause aClause)
{
ISet <Variable> variables = new HashedSet <Variable>();
foreach (Literal l in aClause.GetLiterals())
{
l.AtomicSentence.Accept(this, variables);
}
return(variables);
}
public static int StandardizeApart(Clause c, int saIdx)
{
IList <Variable> variables = new List <Variable>();
foreach (Literal l in c.GetLiterals())
{
CollectAllVariables(l.AtomicSentence, variables);
}
return(StandardizeApart(variables, c, saIdx));
}
public bool IsCheckForUnitRefutation(Clause clause)
{
if (this.IsLookingForAnswerLiteral())
{
if (2 == clause.GetNumberLiterals())
{
return clause.GetLiterals().Any(t => t.AtomicSentence.GetSymbolicName().Equals(this.answerLiteral.AtomicSentence.GetSymbolicName()));
}
} else {
return clause.IsUnitClause();
}
return false;
}