/// <summary>
/// Gets all pure literals from Cnf
/// </summary>
/// <param name="cnf"></param>
/// <returns>Returns a list containing all pure literals of Cnf</returns>
private IEnumerable <Formula> PureLiterals(Cnf cnf)
{
var result = new List <Formula>();
foreach (var clause in cnf.Clauses)
{
foreach (var literal in clause.Literals)
{
if (PureLiteral(cnf, literal))
{
result.Add(literal);
}
}
}
return(result);
}
/// <summary>
/// Determines whether a given literal is pure
/// </summary>
/// <param name="cnf"></param>
/// <param name="literal"></param>
/// <returns>True is literal is pure; false otherwise</returns>
private bool PureLiteral(Cnf cnf, Formula literal)
{
var negation = NegateLiteral(literal);
foreach (var clause in cnf.Clauses)
{
foreach (var l in clause.Literals)
{
if (clause.LiteralEquals(l, negation))
{
return(false);
}
}
}
return(true);
}
/// <summary>
/// Splits the Cnf on a given literal
/// </summary>
/// <param name="cnf"></param>
/// <param name="literal"></param>
/// <returns>A tuple of Cnfs one for the left branch another for the right branch</returns>
private Tuple <Cnf, Cnf> SplittingOnLiteral(Cnf cnf, Formula literal)
{
// List of clauses containing literal
var @in = new List <Clause>();
// List of clauses containing Not(literal)
var @inNegated = new List <Clause>();
// List of clauses not containing literal nor Not(literal)
var @out = new List <Clause>();
var negated = NegateLiteral(literal);
foreach (var clause in cnf.Clauses)
{
if (clause.Contains(literal))
{
@in.Add(clause);
}
else if (clause.Contains(negated))
{
@inNegated.Add(clause);
}
else
{
@out.Add(clause);
}
}
var inCnf = new Cnf {
Clauses = @in
};
var outCnf = new Cnf {
Clauses = @inNegated
};
inCnf.Join(@out);
outCnf.Join(@out);
return(new Tuple <Cnf, Cnf>(inCnf, outCnf));
}
/// <summary>
/// Applies the one literal rule i.e. finds all literals that are the single member of their clause.
/// </summary>
/// <param name="cnf"></param>
/// <returns>Returns a tuple with the resulting Cnf after having removed clauses containing one literals or their negations and an integer which can be 0 (no clauses), 1 (continue dpll), -1 (empty clause)</returns>
private Tuple <Cnf, int> OneLiteral(Cnf cnf)
{
var unitLiteral = UnitClause(cnf);
if (unitLiteral == null)
{
return(new Tuple <Cnf, int>(cnf, 1));
}
var newCnf = new Cnf();
while (unitLiteral != null)
{
var clausesToRemove = new List <int>();
var i = 0;
// Finding clauses where the unit literal is, these clauses will be deleted
foreach (var clause in cnf.Clauses)
{
if (clause.Literals.Any(literal => clause.LiteralEquals(literal, unitLiteral)))
{
clausesToRemove.Add(i);
}
i++;
}
// New Cnf after removing every clause where unit literal is
newCnf = new Cnf();
// Leave clausules that do not include the unit literal
for (var j = 0; j < cnf.Clauses.Count; j++)
{
if (!clausesToRemove.Contains(j))
{
newCnf.Clauses.Add(cnf.Clauses[j]);
}
}
// No clauses which implies SAT
if (newCnf.Clauses.Count == 0)
{
return(new Tuple <Cnf, int>(newCnf, 0));
}
// Remove negation of unit literal from remaining clauses
var unitNegated = NegateLiteral(unitLiteral);
var clausesNoLitNeg = new List <Clause>();
foreach (var clause in newCnf.Clauses)
{
var newClause = new Clause();
// Leaving every literal except the unit literal negated
foreach (var literal in clause.Literals)
{
if (!clause.LiteralEquals(literal, unitNegated))
{
newClause.Literals.Add(literal);
}
}
clausesNoLitNeg.Add(newClause);
}
newCnf.Clauses = new List <Clause>(clausesNoLitNeg);
// Resetting variables for next stage
cnf = newCnf;
unitLiteral = UnitClause(cnf);
// Empty clause found
if (cnf.Clauses.Any(c => c.Literals.Count == 0))
{
return(new Tuple <Cnf, int>(newCnf, -1));
}
}
return(new Tuple <Cnf, int>(newCnf, 1));
}
