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);
}
// v 0.55
// Post L0-release. It appears that two clauses can happen to have more than 1 resolvent.
// What a retard I am because of not thinking of this before :O
// v 0.57
// Actually there occurred a lucky shizzle. Back then I wondered whether I should just remove
// useless calculations of resolvent for equal clauses. Well, actually if you take into account
// previous comment, you'll see that same two clauses can have an existing resolvent (!), e.g.
// clause [p(x), ~p(c)] has two unifiable atoms and after an xform of [x => c], there exists
// a self+self resolvent (so-called "glued clause").
public static IEnumerable<NaiveResolvent> NaiveResolvents(Clause clause1, Clause clause2)
{
// TODO. Snapshots here are absolutely unnecessary
// TODO. Remove this shitfix asap
foreach (var sourceTerm1 in clause1.Terms.Snapshot())
{
foreach (var sourceTerm2 in clause2.Terms.Snapshot())
{
var gcu = Unifier.NaiveUnifier(sourceTerm1, sourceTerm2).ToXformClause();
if (gcu != null)
{
var uclause1 = gcu(clause1);
var uclause2 = gcu(clause2);
foreach (var uterm1 in uclause1.Terms)
{
foreach (var uterm2 in uclause2.Terms)
{
if (uterm2.Counters(uterm1))
{
yield return new NaiveResolvent(
uclause1, uterm1, uclause2, uterm2);
}
}
}
}
}
}
}
public object Clone()
{
var clone = new Clause();
Terms.ForEach(term => clone.Terms.Add((Term)term.Clone()));
return clone;
}