static LIST split_DeleteClausesDependingOnLevelFromList(PROOFSEARCH Search,
LIST ClauseList,
int Level, LIST* New)
/**************************************************************
INPUT: A proof search object, a list of unshared clauses
and a split level.
EFFECT: Deletes all clauses depending on split level from
<ClauseList>.
All split stored deleted clauses from the level of
the deleted clauses from <ClauseList> are stored in
<*New>.
RETURNS: The updated list and the recover clauses in <*New>.
***************************************************************/
{
LIST Scan;
CLAUSE Clause;
SPLIT Reinsert;
for (Scan = ClauseList; !list_Empty(Scan); Scan = list_Cdr(Scan)) {
Clause = list_Car(Scan);
if (clause_DependsOnSplitLevel(Clause, Level)) {
Reinsert = prfs_GetSplitOfLevel(clause_SplitLevel(Clause), Search);
if (prfs_SplitDeletedClauses(Reinsert) != list_Nil()) {
*New = list_Nconc(prfs_SplitDeletedClauses(Reinsert), *New);
prfs_SplitSetDeletedClauses(Reinsert, list_Nil());
}
prfs_InsertDocProofClause(Search,Clause);
list_Rplaca(Scan, NULL);
}
}
return list_PointerDeleteElement(ClauseList, NULL);
}
CLAUSE split_SmallestSplitLevelClause(LIST Clauses)
/**************************************************************
INPUT: A non-empty list of clauses.
RETURNS: The clause with the smallest split level.
***************************************************************/
{
CLAUSE Result;
Result = (CLAUSE)list_Car(Clauses);
Clauses = list_Cdr(Clauses);
while (!list_Empty(Clauses)) {
if (clause_SplitLevel(Result) > clause_SplitLevel(list_Car(Clauses)))
Result = list_Car(Clauses);
Clauses = list_Cdr(Clauses);
}
return Result;
}
BOOL tab_PathContainsClause(TABPATH Path, CLAUSE Clause)
/**************************************************************
INPUT: A tableau path, a clause
RETURNS: TRUE iff the clause exists on its level (wrt. the
path) in the tableau
***************************************************************/
{
LIST Scan;
if (clause_SplitLevel(Clause) > tab_PathLength(Path))
return FALSE;
for (Scan = tab_Clauses(tab_PathNthNode(Path, clause_SplitLevel(Clause)));
!list_Empty(Scan); Scan = list_Cdr(Scan)) {
if (list_Car(Scan) == Clause)
return TRUE;
}
return FALSE;
}
void tab_AddClauseOnItsLevel(CLAUSE C, TABPATH Path)
/**************************************************************
INPUT: A clause, a tableau path
RETURNS: Nothing
EFFECTS: Adds the clause on its split level which
must belong to <Path>
***************************************************************/
{
int Level;
Level = clause_SplitLevel(C);
if (Level > tab_PathLength(Path)) {
misc_StartUserErrorReport();
misc_UserErrorReport("\nError: Split level of some clause ");
misc_UserErrorReport("\nis higher than existing level.");
misc_UserErrorReport("\nThis may be a bug in the proof file.");
misc_FinishUserErrorReport();
}
tab_AddClause(C, tab_PathNthNode(Path, clause_SplitLevel(C)));
}
static LIST split_DeleteClausesDependingOnLevelFromSet(PROOFSEARCH PS,
LIST ClauseList,
int SplitLevel)
/**************************************************************
INPUT: A PROOFSEARCH object, a list of shared clauses
and a split level.
RETURNS: A list of clauses that have to be recovered possibly.
EFFECT: Clauses from the clause list depending on <SplitLevel>
are moved to the doc proof index of <PS>.
All formerly redundant clauses that were reduced by a clause
of the same split level as a clause from the list depending
on <SplitLevel> are returned.
***************************************************************/
{
LIST scan, delList, recover;
CLAUSE clause;
SPLIT reinsert;
delList = recover = list_Nil();
for (scan = ClauseList; !list_Empty(scan); scan = list_Cdr(scan)){
clause = list_Car(scan);
if (clause_DependsOnSplitLevel(clause, SplitLevel)) {
reinsert = prfs_GetSplitOfLevel(clause_SplitLevel(clause), PS);
recover = list_Nconc(prfs_SplitDeletedClauses(reinsert), recover);
prfs_SplitSetDeletedClauses(reinsert, list_Nil());
delList = list_Cons(clause, delList);
}
}
/* WARNING: The following move operations change the worked off */
/* and usable sets of the proof search object destructively. */
/* So it's impossible to move those function calls into the */
/* loop above. */
for ( ; !list_Empty(delList); delList = list_Pop(delList)) {
clause = list_Car(delList);
if (clause_GetFlag(clause, WORKEDOFF))
prfs_MoveWorkedOffDocProof(PS, clause);
else
prfs_MoveUsableDocProof(PS, clause);
}
return recover;
}
static BOOL tab_PathContainsClauseSoft(TABPATH Path, CLAUSE Clause)
/**************************************************************
INPUT: A tableau path, a clause
RETURNS: TRUE iff the clause is on one of the levels
in the tableau traversed by the path. Different
from tab_PathContainsClauseSoft, since it does
not expect the clause on its split level.
***************************************************************/
{
LIST Scan;
int Level;
if (clause_SplitLevel(Clause) > tab_PathLength(Path))
return FALSE;
for (Level = 0; Level <= tab_PathLength(Path); Level++) {
for (Scan = tab_Clauses(tab_PathNthNode(Path, Level));
!list_Empty(Scan); Scan = list_Cdr(Scan)) {
if (list_Car(Scan) == Clause)
return TRUE;
}
}
return FALSE;
}
LIST split_Backtrack(PROOFSEARCH PS, CLAUSE EmptyClause, CLAUSE* SplitClause)
/**************************************************************
INPUT: A proofsearch object, an empty clause and a pointer to a clause
used as return value.
RETURNS: A list of clauses deleted in the backtracked split levels.
<*SplitClause> is set to the split clause for the right branch
of the splitting step, or NULL, if the tableau is finished.
EFFECT: Backtracks the top of the split stack wrt the empty clause's level
***************************************************************/
{
SPLIT ActBacktrackSplit;
LIST RecoverList, Scan;
int Backtracklevel;
ActBacktrackSplit = (SPLIT)NULL;
RecoverList = split_RemoveUnnecessarySplits(PS, EmptyClause);
Backtracklevel = clause_SplitLevel(EmptyClause);
*SplitClause = NULL;
/* Backtrack all split levels bigger than the level of the empty clause */
while (!prfs_SplitStackEmpty(PS) && (prfs_ValidLevel(PS) > Backtracklevel)) {
ActBacktrackSplit = prfs_SplitStackTop(PS);
prfs_SplitStackPop(PS);
if (prfs_SplitFatherClause(ActBacktrackSplit) != (CLAUSE)NULL) {
RecoverList = list_Cons(prfs_SplitFatherClause(ActBacktrackSplit),
RecoverList);
prfs_SplitSetFatherClause(ActBacktrackSplit, NULL);
}
RecoverList = list_Nconc(prfs_SplitDeletedClauses(ActBacktrackSplit),
RecoverList);
clause_DeleteClauseList(prfs_SplitBlockedClauses(ActBacktrackSplit));
prfs_SplitFree(ActBacktrackSplit);
prfs_DecValidLevel(PS);
}
/* Backtrack further for all right branches on top of the stack */
while (!prfs_SplitStackEmpty(PS) &&
list_Empty(prfs_SplitBlockedClauses(prfs_SplitStackTop(PS)))) {
ActBacktrackSplit = prfs_SplitStackTop(PS);
prfs_SplitStackPop(PS);
if (prfs_SplitFatherClause(ActBacktrackSplit) != (CLAUSE)NULL)
RecoverList = list_Cons(prfs_SplitFatherClause(ActBacktrackSplit),
RecoverList);
RecoverList = list_Nconc(prfs_SplitDeletedClauses(ActBacktrackSplit),
RecoverList);
prfs_SplitFree(ActBacktrackSplit);
prfs_DecValidLevel(PS);
}
if (!prfs_SplitStackEmpty(PS)) {
/* Enter the right branch of the splitting step */
int SplitMinus1;
LIST RightClauses;
SplitMinus1 = prfs_ValidLevel(PS) - 1;
ActBacktrackSplit = prfs_SplitStackTop(PS);
RecoverList = list_Nconc(prfs_SplitDeletedClauses(ActBacktrackSplit),
RecoverList);
prfs_SplitSetDeletedClauses(ActBacktrackSplit, list_Nil());
RecoverList = split_DeleteInvalidClausesFromList(PS, SplitMinus1,
RecoverList);
RightClauses = prfs_SplitBlockedClauses(ActBacktrackSplit);
prfs_SplitSetBlockedClauses(ActBacktrackSplit, list_Nil());
for (Scan = RightClauses; !list_Empty(Scan); Scan = list_Cdr(Scan)) {
if (clause_Number(list_Car(Scan)) == 0) {
/* Found the right clause, the negation clauses have number -1. */
#ifdef CHECK
if (*SplitClause != NULL) {
misc_StartErrorReport();
misc_ErrorReport("\n In split_Backtrack:");
misc_ErrorReport(" Found two blocked clauses ");
misc_ErrorReport("\n with clause number 0 (this marks the clause ");
misc_ErrorReport("\n for the right branch of the tableau).");
misc_FinishErrorReport();
}
#endif
*SplitClause = list_Car(Scan);
}
clause_NewNumber((CLAUSE) list_Car(Scan));
clause_AddParentClause((CLAUSE) list_Car(Scan), clause_Number(EmptyClause));
clause_AddParentLiteral((CLAUSE) list_Car(Scan), 0); /* dummy literal */
}
#ifdef CHECK
if (*SplitClause == NULL) {
misc_StartErrorReport();
misc_ErrorReport("\n In split_Backtrack: Didn´t find a blocked clause");
misc_ErrorReport("\n with clause number 0. (this marks the clause ");
misc_ErrorReport("\n for the right branch of the tableau).");
misc_FinishErrorReport();
}
#endif
RecoverList = list_Nconc(RightClauses, RecoverList);
/* Then, delete clauses from current level (Hack) */
prfs_DecValidLevel(PS);
prfs_MoveInvalidClausesDocProof(PS);
split_DeleteInvalidClausesFromStack(PS);
prfs_IncValidLevel(PS);
} else {
/* Don't delete clauses from current level (split is top level) */
prfs_MoveInvalidClausesDocProof(PS);
for (Scan = RecoverList; !list_Empty(Scan); Scan = list_Cdr(Scan))
prfs_InsertDocProofClause(PS, list_Car(Scan));
list_Delete(RecoverList);
RecoverList = list_Nil();
}
prfs_SetLastBacktrackLevel(PS, prfs_ValidLevel(PS));
return RecoverList;
}