static CLAUSE inf_CreateURUnitResolvent(CLAUSE Clause, int i, SUBST Subst,
LIST FoundMap, FLAGSTORE Flags,
PRECEDENCE Precedence)
/**************************************************************
INPUT: A non-unit clause, a literal index from the clause,
a substitution, a list of pairs (l1, l2) of literals,
where l1 is from the non-unit clause and l2 is from a
unit clause, a flag store and a precedence.
RETURNS: The resolvent of this UR resolution inference. The
clause consists of the literal at index <i> in <Clause>
after application of <Subst>.
EFFECT: The flag store and the precedence are needed to create
the new clause.
***************************************************************/
{
CLAUSE Result, PClause;
LITERAL Lit;
TERM Atom;
LIST Parents;
NAT depth;
/* Create atom for resolvent */
Atom = subst_Apply(Subst, term_Copy(clause_GetLiteralAtom(Clause, i)));
/* Create clause */
Parents = list_List(Atom);
if (i <= clause_LastConstraintLitIndex(Clause))
Result = clause_Create(Parents, list_Nil(), list_Nil(), Flags, Precedence);
else if (i <= clause_LastAntecedentLitIndex(Clause))
Result = clause_Create(list_Nil(), Parents, list_Nil(), Flags, Precedence);
else
Result = clause_Create(list_Nil(), list_Nil(), Parents, Flags, Precedence);
list_Delete(Parents);
/* Get parent clauses and literals, calculate depth of resolvent */
Parents = list_List(Clause);
depth = clause_Depth(Clause);
for ( ; !list_Empty(FoundMap); FoundMap = list_Cdr(FoundMap)) {
Lit = list_PairSecond(list_Car(FoundMap)); /* Literal from unit */
PClause = clause_LiteralOwningClause(Lit);
Parents = list_Cons(PClause, Parents);
depth = misc_Max(depth, clause_Depth(PClause));
clause_AddParentClause(Result, clause_Number(PClause));
clause_AddParentLiteral(Result, clause_LiteralGetIndex(Lit));
Lit = list_PairFirst(list_Car(FoundMap)); /* Is from <Clause> */
clause_AddParentClause(Result, clause_Number(Clause));
clause_AddParentLiteral(Result, clause_LiteralGetIndex(Lit));
}
clause_SetFromURResolution(Result);
clause_SetDepth(Result, depth+1);
clause_SetSplitDataFromList(Result, Parents);
list_Delete(Parents);
return Result;
}
static CLAUSE red_CreateTerminatorEmptyClause(LIST FoundMap, FLAGSTORE Flags,
PRECEDENCE Precedence)
/**************************************************************
INPUT: A list of pairs (l1, l2), where l1 and l2 are unifiable
literals with complementary sign and a flag store.
More accurately, a substitution s exists,
such that l1 s = l2 s for all pairs (l1,l2) in
<FoundMap>.
For all literals l from the involved clauses
there exists one pair (l1,l2) in <FoundMap>
with l1=l or l2=l.
The flags store and the precedence are needed to create
the new clause.
RETURNS: A newly created empty clause, where the data
(parents,...) is set according to <FoundMap>.
***************************************************************/
{
CLAUSE Result, PClause;
LITERAL Lit;
LIST Parents;
NAT depth;
Result = clause_Create(list_Nil(), list_Nil(), list_Nil(), Flags, Precedence);
Parents = list_Nil();
depth = 0;
for (; !list_Empty(FoundMap); FoundMap = list_Cdr(FoundMap)) {
Lit = list_PairSecond(list_Car(FoundMap));
PClause = clause_LiteralOwningClause(Lit);
Parents = list_Cons(PClause, Parents);
depth = misc_Max(depth, clause_Depth(PClause));
clause_AddParentClause(Result, clause_Number(PClause));
clause_AddParentLiteral(Result, clause_LiteralGetIndex(Lit));
Lit = list_PairFirst(list_Car(FoundMap));
PClause = clause_LiteralOwningClause(Lit);
Parents = list_Cons(PClause, Parents);
depth = misc_Max(depth, clause_Depth(PClause));
clause_AddParentClause(Result, clause_Number(PClause));
clause_AddParentLiteral(Result, clause_LiteralGetIndex(Lit));
}
clause_SetFromTerminator(Result);
clause_SetDepth(Result, depth+1);
clause_SetSplitDataFromList(Result, Parents);
list_Delete(Parents);
return Result;
}
