public NaiveResolvent(Clause clause1, Term term1, Clause clause2, Term term2)
{
Clause1 = (Clause)clause1.Clone();
Term1 = (Term)term1.Clone();
Clause2 = (Clause)clause2.Clone();
Term2 = (Term)term2.Clone();
var atoms = new List<Term>();
atoms.AddRange(clause1.Terms);
atoms.AddRange(clause2.Terms);
foreach (var term in atoms.Snapshot())
{
if (term.Equals(term1) || term.Counters(term1))
{
atoms.Remove(term);
}
}
Terms = atoms;
EliminateDuplicateAtoms();
// This is bullshit, since resolvents should be able to participate
// in solving process later on.
// Terms = new List<Term>(Terms).AsReadOnly();
}
public override void Visit(TermNode node)
{
Term term;
IAstTreeNode clauseRoot;
if (node.Parent is NegationNode)
{
term = new Term(node, false);
clauseRoot = node.Parent.Parent;
}
else if (node.Parent is OrNode || node.Parent is L1Expression)
{
term = new Term(node, true);
clauseRoot = node.Parent;
}
else if (node.Parent is AndNode)
{
term = new Term(node, true);
clauseRoot = node;
}
else
{
throw new NotSupportedException(String.Format(
"Not a CNF or fatal error: '{0}", node.Parent));
}
if (!_clauses.ContainsKey(clauseRoot)) _clauses[clauseRoot] = new Clause();
_clauses[clauseRoot].Terms.Add(term);
}
public bool Counters(Term term)
{
return
// Keklol, I should've implemented civilized term comparison :)
term.TermNode.ToString() == this.TermNode.ToString() &&
term.Polarity ^ this.Polarity;
}
public bool Equals(Term obj)
{
if(ReferenceEquals(null, obj))
{
return false;
}
if(ReferenceEquals(this, obj))
{
return true;
}
return obj.Polarity.Equals(Polarity) && Equals(obj.TermNode.ToString(), TermNode.ToString());
}
public static XformTerm NaiveUnifier(Term term1, Term term2)
{
if (term1.Token != term2.Token ||
term1.TermNode.Children.Count != term2.TermNode.Children.Count)
{
return null;
}
else
{
for (var i = 0; i < term1.TermNode.Children.Count; ++i)
{
var arg1C = term1.TermNode.Children[i] as ConstantNode;
var arg1V = term1.TermNode.Children[i] as VariableNode;
var arg2C = term2.TermNode.Children[i] as ConstantNode;
var arg2V = term2.TermNode.Children[i] as VariableNode;
if (arg1C != null && arg2C != null)
{
if (arg1C.Token != arg2C.Token)
{
return null;
}
}
else if (arg1V != null && arg2V != null)
{
if (arg1V.Token != arg2V.Token)
{
XformTerm xform = term => SubstituteWithVariable(term, arg1V.Token, arg2V.Token);
return xform.Composition(NaiveUnifier(xform(term1), xform(term2)));
}
}
else
{
var argC = arg1C ?? arg2C;
var argV = arg1V ?? arg2V;
XformTerm xform = term => SubstituteWithConstant(term, argV.Token, argC.Token);
return xform.Composition(NaiveUnifier(xform(term1), xform(term2)));
}
}
return term => term;
}
}
