TABLEAU tab_PruneClosedBranches(TABLEAU T, LIST* Clauses)
/**************************************************************
INPUT: A tableau, a list of clauses by reference.
RETURNS: The (destructively) reduced tableau: Descendants of
nodes that have an empty clause are deleted.
EFFECTS: The tableau is modified.
***************************************************************/
{
if (tab_IsEmpty(T))
return T;
/* if there is an empty clause on this level, delete subtrees */
if (tab_HasEmptyClause(T)) {
tab_DeleteCollectClauses(tab_RightBranch(T), Clauses);
tab_DeleteCollectClauses(tab_LeftBranch(T), Clauses);
tab_SetRightBranch(T, tab_EmptyTableau());
tab_SetLeftBranch(T, tab_EmptyTableau());
list_Delete(tab_RightSplitClauses(T));
tab_SetRightSplitClauses(T, list_Nil());
tab_SetSplitClause(T,clause_Null());
tab_SetLeftSplitClause(T, clause_Null());
}
/* else recursively prune subtrees */
else {
tab_SetRightBranch(T, tab_PruneClosedBranches(tab_RightBranch(T), Clauses));
tab_SetLeftBranch(T, tab_PruneClosedBranches(tab_LeftBranch(T), Clauses));
}
return T;
}
void tab_GetEarliestEmptyClauses(TABLEAU T, LIST* L)
/**************************************************************
INPUT : A tableau, a list of clauses by reference
RETURNS: Nothing.
EFFECTS: For each leaf node, adds empty clauses in
leaf nodes to <L>. If the leaf node contains only one
empty clause, it is added to <L> anyway.
If the leaf node contains more than one empty clause,
the earliest derived empty clause is added to <L>.
***************************************************************/
{
CLAUSE FirstEmpty;
LIST Scan;
if (tab_IsEmpty(T))
return;
if (tab_IsLeaf(T)) {
FirstEmpty = clause_Null();
for (Scan = tab_Clauses(T); !list_Empty(Scan); Scan = list_Cdr(Scan)) {
if (clause_IsEmptyClause(list_Car(Scan))) {
if (FirstEmpty == clause_Null())
FirstEmpty = list_Car(Scan);
else if (clause_Number(FirstEmpty) > clause_Number(list_Car(Scan)))
FirstEmpty = list_Car(Scan);
}
}
if (FirstEmpty != clause_Null())
(*L) = list_Cons(FirstEmpty, *L);
}
tab_GetEarliestEmptyClauses(tab_LeftBranch(T), L);
tab_GetEarliestEmptyClauses(tab_RightBranch(T), L);
}
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;
}
}
