private void lookForUnitRefutation(OTTERAnswerHandler ansHandler,
IndexedClauses idxdClauses, Clause clause, List <Clause> sos,
List <Clause> usable)
{
List <Clause> toCheck = new List <Clause>();
if (ansHandler.isCheckForUnitRefutation(clause))
{
foreach (Clause s in sos)
{
if (s.isUnitClause())
{
toCheck.Add(s);
}
}
foreach (Clause u in usable)
{
if (u.isUnitClause())
{
toCheck.Add(u);
}
}
}
if (toCheck.Count > 0)
{
toCheck = infer(clause, toCheck);
foreach (Clause t in toCheck)
{
// * clause <- SIMPLIFY(clause)
Clause t2 = getClauseSimplifier().simplify(t);
// * discard clause if it is a tautology
if (t2.isTautology())
{
continue;
}
// * if clause has no literals then a refutation has been found
// or if it just contains the answer literal.
if (!ansHandler.isAnswer(t2))
{
// * sos <- [clause | sos]
// This check ensure duplicate clauses are not
// introduced which will cause the
// LightestClauseHeuristic to loop continuously
// on the same pair of objects.
if (!sos.Contains(t2) && !usable.Contains(t2))
{
idxdClauses.addClause(t2, sos, usable);
}
}
if (ansHandler.isComplete())
{
break;
}
}
}
}
// procedure PROCESS(clauses, sos)
private void process(OTTERAnswerHandler ansHandler,
IndexedClauses idxdClauses, List <Clause> clauses, List <Clause> sos,
List <Clause> usable)
{
// * for each clause in clauses do
foreach (Clause clause in clauses)
{
// * clause <- SIMPLIFY(clause)
Clause clause2 = getClauseSimplifier().simplify(clause);
// * merge identical literals
// Note: Not required as handled by Clause Implementation
// which keeps literals within a Set, so no duplicates
// will exist.
// * discard clause if it is a tautology
if (clause2.isTautology())
{
continue;
}
// * if clause has no literals then a refutation has been found
// or if it just contains the answer literal.
if (!ansHandler.isAnswer(clause2))
{
// * sos <- [clause | sos]
// This check ensure duplicate clauses are not
// introduced which will cause the
// LightestClauseHeuristic to loop continuously
// on the same pair of objects.
if (!sos.Contains(clause2) && !usable.Contains(clause2))
{
foreach (Clause ac in clause2.getFactors())
{
if (!sos.Contains(ac) && !usable.Contains(ac))
{
idxdClauses.addClause(ac, sos, usable);
// * if clause has one literal then look for unit
// refutation
lookForUnitRefutation(ansHandler, idxdClauses, ac,
sos, usable);
}
}
}
}
if (ansHandler.isComplete())
{
break;
}
}
}
private void lookForUnitRefutation(OTTERAnswerHandler ansHandler,
IndexedClauses idxdClauses, Clause clause, List<Clause> sos,
List<Clause> usable)
{
List<Clause> toCheck = new List<Clause>();
if (ansHandler.isCheckForUnitRefutation(clause))
{
foreach (Clause s in sos)
{
if (s.isUnitClause())
{
toCheck.Add(s);
}
}
foreach (Clause u in usable)
{
if (u.isUnitClause())
{
toCheck.Add(u);
}
}
}
if (toCheck.Count > 0)
{
toCheck = infer(clause, toCheck);
foreach (Clause t in toCheck)
{
// * clause <- SIMPLIFY(clause)
Clause t2 = getClauseSimplifier().simplify(t);
// * discard clause if it is a tautology
if (t2.isTautology())
{
continue;
}
// * if clause has no literals then a refutation has been found
// or if it just contains the answer literal.
if (!ansHandler.isAnswer(t2))
{
// * sos <- [clause | sos]
// This check ensure duplicate clauses are not
// introduced which will cause the
// LightestClauseHeuristic to loop continuously
// on the same pair of objects.
if (!sos.Contains(t2) && !usable.Contains(t2))
{
idxdClauses.addClause(t2, sos, usable);
}
}
if (ansHandler.isComplete())
{
break;
}
}
}
}
// procedure PROCESS(clauses, sos)
private void process(OTTERAnswerHandler ansHandler,
IndexedClauses idxdClauses, List<Clause> clauses, List<Clause> sos,
List<Clause> usable)
{
// * for each clause in clauses do
foreach (Clause clause in clauses)
{
// * clause <- SIMPLIFY(clause)
Clause clause2 = getClauseSimplifier().simplify(clause);
// * merge identical literals
// Note: Not required as handled by Clause Implementation
// which keeps literals within a Set, so no duplicates
// will exist.
// * discard clause if it is a tautology
if (clause2.isTautology())
{
continue;
}
// * if clause has no literals then a refutation has been found
// or if it just contains the answer literal.
if (!ansHandler.isAnswer(clause2))
{
// * sos <- [clause | sos]
// This check ensure duplicate clauses are not
// introduced which will cause the
// LightestClauseHeuristic to loop continuously
// on the same pair of objects.
if (!sos.Contains(clause2) && !usable.Contains(clause2))
{
foreach (Clause ac in clause2.getFactors())
{
if (!sos.Contains(ac) && !usable.Contains(ac))
{
idxdClauses.addClause(ac, sos, usable);
// * if clause has one literal then look for unit
// refutation
lookForUnitRefutation(ansHandler, idxdClauses, ac,
sos, usable);
}
}
}
}
if (ansHandler.isComplete())
{
break;
}
}
}