BOOL res_BackSubWithLength(CLAUSE clause, st_INDEX stindex)
/**********************************************************
INPUT: A clauses and an index.
RETURNS: TRUE if a clause of the index subsumes the clause clause
and length(clause) >= length(clause of index).
CAUTION: None.
***********************************************************/
{
int n,i;
LIST scan,generals;
TERM term;
LITERAL litres;
n = clause_Length(clause);
for (i = 0; i < n; i++) {
term = clause_GetLiteralTerm(clause,i);
generals = st_GetGen(cont_LeftContext(), stindex, term);
for (scan = generals; !list_Empty(scan); scan = list_Cdr(scan)) {
litres = (LITERAL) list_Car(scan);
if (litres == clause_GetLiteral(clause_LiteralOwningClause(litres),0) &&
clause_Length(clause) >= clause_Length(clause_LiteralOwningClause(litres)) &&
clause_Weight(clause) >= clause_Weight(clause_LiteralOwningClause(litres)) &&
subs_Idc(clause_LiteralOwningClause(litres),clause)) {
list_Delete(generals);
return TRUE;
}
}
list_Delete(generals);
}
return FALSE;
}
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;
}
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 LIST red_GetTerminatorPartnerLits(TERM Atom, LITERAL Lit,
BOOL UnitsOnly, LIST IndexList)
/**************************************************************
INPUT: An atom, a literal, a boolean flag and a list of SHARED_INDEXes.
RETURNS: A list of literals with sign complementary to <Lit>
that are unifiable with <Atom>. The literals are searched
in all SHARED_INDEXes from <IndexList>. Additionally,
if <Unitsonly> is true, only literals from unit clauses
are returned.
EFFECT: <Atom> is a copy of <Lit> where some substitution
was applied and equality literals might have been swapped.
<Lit> is just needed to check whether the unifiable
literals are complementary.
***************************************************************/
{
LIST Result, Unifiers, LitScan;
LITERAL NextLit;
Result = list_Nil();
for ( ; !list_Empty(IndexList); IndexList = list_Cdr(IndexList)) {
Unifiers = st_GetUnifier(cont_LeftContext(),
sharing_Index(list_Car(IndexList)),
cont_RightContext(), Atom);
for ( ; !list_Empty(Unifiers); Unifiers = list_Pop(Unifiers)) {
if (!term_IsVariable(list_Car(Unifiers))) {
for (LitScan = sharing_NAtomDataList(list_Car(Unifiers));
!list_Empty(LitScan); LitScan = list_Cdr(LitScan)) {
NextLit = list_Car(LitScan);
if (clause_LiteralsAreComplementary(Lit, NextLit) &&
(!UnitsOnly || clause_Length(clause_LiteralOwningClause(NextLit))==1))
/* The partner literals must have complementary sign and
if <UnitsOnly> == TRUE they must be from unit clauses. */
Result = list_Cons(NextLit, Result);
}
}
}
}
return Result;
}
static LIST inf_GetURPartnerLits(TERM Atom, LITERAL Lit,
BOOL Unit, SHARED_INDEX Index)
/**************************************************************
INPUT: An atom, a literal, a boolean flag and a SHARED_INDEX.
RETURNS: A list of literals with sign complementary to <Lit>
that are unifiable with <Atom>. If <Unit> is true,
only literals from unit clauses are returned, if <Unit>
is false, only literals from non-unit clauses are
returned.
EFFECT: <Atom> is a copy of <Lit>'s atom where some substitution
was applied and equality literals might have been swapped.
<Lit> is just needed to check whether the unifiable
literals are complementary.
***************************************************************/
{
LIST Result, Unifiers, LitScan;
LITERAL PLit;
int length;
Result = list_Nil();
Unifiers = st_GetUnifier(cont_LeftContext(), sharing_Index(Index),
cont_RightContext(), Atom);
for ( ; !list_Empty(Unifiers); Unifiers = list_Pop(Unifiers)) {
if (!term_IsVariable(list_Car(Unifiers))) {
for (LitScan = sharing_NAtomDataList(list_Car(Unifiers));
!list_Empty(LitScan); LitScan = list_Cdr(LitScan)) {
PLit = list_Car(LitScan);
length = clause_Length(clause_LiteralOwningClause(PLit));
if (clause_LiteralsAreComplementary(Lit, PLit) &&
((Unit && length==1) || (!Unit && length!=1)))
/* The partner literals must have complementary sign and
if <Unit> == TRUE they must be from unit clauses,
if <Unit> == FALSE they must be from non-unit clauses. */
Result = list_Cons(PLit, Result);
}
}
}
return Result;
}
static CLAUSE red_SearchTerminator(NAT n, LIST RestLits, LIST FoundMap,
SUBST Subst, SYMBOL GlobalMaxVar,
LIST IndexList, FLAGSTORE Flags,
PRECEDENCE Precedence)
/**************************************************************
INPUT: A natural number, a list of literals, a list of pairs,
a substitution, the maximum variable occurring in all
involved clauses, a list of SHARED_INDEXes, a flag store
and a precedence.
RETURNS: An empty clause, if a terminator situation was found,
NULL otherwise.
EFFECT: This recursive function implements the search for
a terminator situation with at most <n> non-unit clauses.
<RestLits> is the lists of literals actually missing
a complementary partner literal.
<FoundMap> is a list of pairs (l1,l2), where l1 and l2
are complementary, unifiable literals.
<Subst> is the common substitution of all those pairs.
<GlobalMaxVar> is the maximum variable from all
involved clauses.
To enable the search all involved clauses are made
variable-disjoint.
At the moment the function stops, if ANY terminator
situation occurred. This might not be desirable
if splitting is enabled, since there might be other
terminator situations resulting in an empty clause
of lower split level.
The flag store and the precedence are needed to create
the new clause.
***************************************************************/
{
if (list_Empty(RestLits)) {
/* We found a terminator situation, so stop the recursion */
return red_CreateTerminatorEmptyClause(FoundMap, Flags, Precedence);
} else {
CLAUSE Result, PClauseCopy;
LITERAL Lit, PLit;
SYMBOL NewMaxVar;
SUBST NewSubst, RightSubst;
TERM AtomCopy;
LIST ClashList, ToDoList;
BOOL Swapped;
NAT Limit;
int PLitInd;
Swapped = FALSE;
Result = clause_Null();
clause_MoveBestLiteralToFront(RestLits, Subst, GlobalMaxVar,
red_TerminatorLitIsBetter);
Lit = list_Car(RestLits);
RestLits = list_Cdr(RestLits);
AtomCopy = subst_Apply(Subst, term_Copy(clause_LiteralAtom(Lit)));
/* The following 'endless' loop runs twice for equality literals */
/* and only once for other literals. */
while (TRUE) {
ClashList = red_GetTerminatorPartnerLits(AtomCopy, Lit, n==0, IndexList);
for (; !list_Empty(ClashList) && Result==NULL;
ClashList = list_Pop(ClashList)) {
PLit = list_Car(ClashList);
PLitInd = clause_LiteralGetIndex(PLit);
PClauseCopy = clause_Copy(clause_LiteralOwningClause(PLit));
Limit = clause_Length(PClauseCopy) == 1 ? n : n-1;
clause_RenameVarsBiggerThan(PClauseCopy, GlobalMaxVar);
PLit = clause_GetLiteral(PClauseCopy, PLitInd);
FoundMap = list_Cons(list_PairCreate(Lit, PLit), FoundMap);
ToDoList = clause_GetLiteralListExcept(PClauseCopy, PLitInd);
ToDoList = list_Nconc(ToDoList, list_Copy(RestLits));
NewMaxVar = clause_SearchMaxVar(PClauseCopy);
if (symbol_GreaterVariable(GlobalMaxVar, NewMaxVar))
NewMaxVar = GlobalMaxVar;
cont_Check();
if (!unify_UnifyNoOC(cont_LeftContext(), AtomCopy,
cont_RightContext(), clause_LiteralAtom(PLit))) {
misc_StartErrorReport();
misc_ErrorReport("\n In red_SearchTerminator: Unification failed.");
misc_FinishErrorReport();
}
subst_ExtractUnifier(cont_LeftContext(), &NewSubst,
cont_RightContext(), &RightSubst);
cont_Reset();
/* The domains of both substitutions are disjoint */
/* so we do just a simple union operation. */
NewSubst = subst_NUnion(NewSubst, RightSubst);
RightSubst = NewSubst;
NewSubst = subst_Compose(NewSubst, subst_Copy(Subst));
subst_Delete(RightSubst);
Result = red_SearchTerminator(Limit, ToDoList, FoundMap, NewSubst,
NewMaxVar, IndexList, Flags, Precedence);
clause_Delete(PClauseCopy);
subst_Delete(NewSubst);
list_Delete(ToDoList);
list_PairFree(list_Car(FoundMap));
FoundMap = list_Pop(FoundMap);
}
/* loop control */
if (!fol_IsEquality(AtomCopy) || Swapped || Result!=NULL)
break;
else {
list_Delete(ClashList);
term_EqualitySwap(AtomCopy);
Swapped = TRUE;
}
}
/* cleanup */
term_Delete(AtomCopy);
/* <ClashList> may be non-empty since the loop stops */
/* if a terminator was found. */
list_Delete(ClashList);
return Result;
}
}
LIST inf_URResolution(CLAUSE Clause, SHARED_INDEX Index, FLAGSTORE Flags,
PRECEDENCE Precedence)
/**************************************************************
INPUT: A clause, a shared index, a flag store and a precedence.
RETURNS: The list of UR resolution resolvents.
EFFECT: The flag store and the precedence are needed to create
the resolvents.
***************************************************************/
{
LIST Result;
if (clause_Length(Clause) != 1) {
/* Clause isn't unit clause */
Result = inf_NonUnitURResolution(Clause, -1, list_Nil(), subst_Nil(),
clause_MaxVar(Clause), Index, Flags,
Precedence);
}
else {
/* Clause is unit clause, so search partner literals in non-unit clauses */
LITERAL Lit, PLit;
TERM Atom;
LIST Partners, FoundMap;
SYMBOL MaxVar, PMaxVar;
SUBST LeftSubst, RightSubst;
CLAUSE PClause;
int PLitInd;
BOOL Swapped;
Result = list_Nil();
Lit = clause_GetLiteral(Clause, clause_FirstLitIndex());
Atom = term_Copy(clause_LiteralAtom(Lit));
Swapped = FALSE;
/* The following 'endless' loop runs twice for equality literals */
/* and only once for other literals. */
while (TRUE) {
/* Get complementary literals from non-unit clauses */
Partners = inf_GetURPartnerLits(Atom, Lit, FALSE, Index);
for ( ; !list_Empty(Partners); Partners = list_Pop(Partners)) {
PLit = list_Car(Partners);
PLitInd = clause_LiteralGetIndex(PLit);
PClause = clause_LiteralOwningClause(PLit); /* non-unit clause */
PMaxVar = clause_MaxVar(PClause);
term_StartMaxRenaming(PMaxVar);
term_Rename(Atom); /* Rename atom from unit clause */
MaxVar = term_MaxVar(Atom);
if (symbol_GreaterVariable(PMaxVar, MaxVar))
MaxVar = PMaxVar;
/* Get the substitution */
cont_Check();
unify_UnifyNoOC(cont_LeftContext(), clause_LiteralAtom(PLit),
cont_RightContext(), Atom);
subst_ExtractUnifier(cont_LeftContext(), &LeftSubst,
cont_RightContext(), &RightSubst);
cont_Reset();
/* We don't need the substitution for the unit clause */
subst_Delete(RightSubst);
FoundMap = list_List(list_PairCreate(PLit, Lit));
Result = list_Nconc(inf_NonUnitURResolution(PClause, PLitInd, FoundMap,
LeftSubst, MaxVar, Index,
Flags, Precedence),
Result);
list_DeletePairList(FoundMap);
subst_Delete(LeftSubst);
}
/* loop control */
if (!fol_IsEquality(Atom) || Swapped)
break;
else {
term_EqualitySwap(Atom);
Swapped = TRUE;
}
} /* end of endless loop */
term_Delete(Atom);
}
return Result;
}
