static LIST split_RemoveUnnecessarySplits(PROOFSEARCH PS, CLAUSE EmptyClause)
/**************************************************************
INPUT: An empty clause and a proof search object
EFFECT: Removes all splits up to the last backtrack level
that were not necessary to derive the empty clause.
RETURNS: A list of recovered clauses.
***************************************************************/
{
LIST Scan;
LIST Recover, New;
LIST Deleted;
LIST ScanStack;
int SplitLevel;
int LastBacktrackLevel;
SPLIT Split,ScanSplit;
Scan = prfs_SplitStack(PS);
SplitLevel = prfs_ValidLevel(PS);
LastBacktrackLevel = prfs_LastBacktrackLevel(PS);
Recover = list_Nil();
while (SplitLevel > LastBacktrackLevel) {
if (prfs_SplitIsUnused(list_Car(Scan)) &&
!clause_DependsOnSplitLevel(EmptyClause, SplitLevel)) {
New = list_Nil();
Split = list_Car(Scan);
/*printf("\n\t Removed: %d",prfs_SplitSplitLevel(Split));*/
clause_DeleteClauseList(prfs_SplitBlockedClauses(Split));
prfs_SplitSetBlockedClauses(Split, list_Nil());
Recover = list_Nconc(prfs_SplitDeletedClauses(Split), Recover);
prfs_SplitSetDeletedClauses(Split, list_Nil());
if (prfs_SplitFatherClause(Split) != (CLAUSE)NULL) {
Recover = list_Cons(prfs_SplitFatherClause(Split),Recover);
prfs_SplitSetFatherClause(Split,NULL);
}
Recover = split_DeleteClausesDependingOnLevelFromList(PS, Recover, SplitLevel, &New);
ScanStack = prfs_SplitStack(PS);
while (!list_StackEmpty(ScanStack) &&
prfs_SplitSplitLevel((ScanSplit = (SPLIT)list_Car(ScanStack))) > LastBacktrackLevel) {
Deleted = prfs_SplitDeletedClauses(ScanSplit);
prfs_SplitSetDeletedClauses(ScanSplit, list_Nil()); /* IMPORTANT!, see next line */
Deleted = split_DeleteClausesDependingOnLevelFromList(PS, Deleted, SplitLevel, &New);
prfs_SplitSetDeletedClauses(ScanSplit, Deleted);
ScanStack = list_Cdr(ScanStack);
}
while (!list_Empty(New)) {
Deleted = list_Nil();
Recover = list_Nconc(split_DeleteClausesDependingOnLevelFromList(PS, New, SplitLevel, &Deleted),
Recover);
New = Deleted;
}
Recover = list_Nconc(Recover,
split_DeleteClausesDependingOnLevelFromSet(PS, prfs_UsableClauses(PS), SplitLevel));
Recover = list_Nconc(Recover,
split_DeleteClausesDependingOnLevelFromSet(PS, prfs_WorkedOffClauses(PS), SplitLevel));
prfs_SplitSetUsed(Split);
}
SplitLevel--;
Scan = list_Cdr(Scan);
}
return Recover;
}
LIST dp_PrintProof(PROOFSEARCH Search, LIST Clauses, const char *FilePrefix)
/*********************************************************
INPUT: A proofsearch object, a list of empty clauses and
the prefix of the output file name.
RETURNS: The list of clauses required for the proof.
MEMORY: The returned list must be freed.
EFFECT: The proof is printed both to standard output and
to the file <FilePrefix>.prf.
**********************************************************/
{
LIST ProofClauses,Scan,EmptyClauses,AllClauses, ReducedProof;
LIST Missing, Incomplete, SplitClauses;
FLAGSTORE Flags;
Flags = prfs_Store(Search);
Missing = pcheck_ConvertParentsInSPASSProof(Search, Clauses);
if (!list_Empty(Missing)) {
puts("\nNOTE: clauses with following numbers have not been found:");
for (; !list_Empty(Missing); Missing = list_Pop(Missing))
printf("%d ", (int)list_Car(Missing));
putchar('\n');
}
EmptyClauses = list_Copy(Clauses);
ProofClauses = list_Nil();
AllClauses = list_Nconc(list_Copy(prfs_DocProofClauses(Search)),
list_Nconc(list_Copy(prfs_UsableClauses(Search)),
list_Copy(prfs_WorkedOffClauses(Search))));
/*
* collect proof clauses by noodling upward in the
* proof tree, starting from <EmptyClauses>.
* Before, add all splitting clauses to avoid gaps in split tree
*/
SplitClauses = list_Nil();
for (Scan = AllClauses; !list_Empty(Scan); Scan = list_Cdr(Scan))
if (clause_IsFromSplitting(list_Car(Scan)))
SplitClauses = list_Cons(list_Car(Scan), SplitClauses);
/* mark all needed clauses */
pcheck_ClauseListRemoveFlag(EmptyClauses, MARKED);
pcheck_ClauseListRemoveFlag(AllClauses, MARKED);
pcheck_MarkRecursive(EmptyClauses);
pcheck_MarkRecursive(SplitClauses);
/* collect all marked clauses */
ProofClauses = list_Nil();
for (Scan = AllClauses; !list_Empty(Scan); Scan = list_Cdr(Scan)) {
if (clause_GetFlag(list_Car(Scan), MARKED))
ProofClauses = list_Cons(list_Car(Scan), ProofClauses);
}
/* build reduced proof */
ProofClauses = list_Nconc(ProofClauses, list_Copy(EmptyClauses));
ProofClauses = pcheck_ClauseNumberMergeSort(ProofClauses);
ReducedProof = pcheck_ReduceSPASSProof(ProofClauses);
dp_SetProofDepth(pcheck_SeqProofDepth(ReducedProof));
pcheck_ParentPointersToParentNumbers(AllClauses);
pcheck_ParentPointersToParentNumbers(Clauses);
/* check reduced proof for clauses whose parents have been marked as
incomplete (HIDDEN flag) by ConvertParentsInSPASSProof */
Incomplete = list_Nil();
for (Scan = ReducedProof; !list_Empty(Scan); Scan = list_Cdr(Scan)) {
if (clause_GetFlag(list_Car(Scan), HIDDEN))
Incomplete = list_Cons(list_Car(Scan), Incomplete);
}
if (!list_Empty(Incomplete)) {
puts("NOTE: Following clauses in reduced proof have incomplete parent sets:");
for (Scan = Incomplete; !list_Empty(Scan); Scan = list_Cdr(Scan))
printf("%d ", clause_Number(list_Car(Scan)));
putchar('\n');
}
printf("\n\nHere is a proof with depth %d, length %d :\n",
dp_ProofDepth(), list_Length(ReducedProof));
clause_ListPrint(ReducedProof);
if (flag_GetFlagValue(Flags, flag_FPDFGPROOF))
dp_FPrintDFGProof(ReducedProof, FilePrefix, Flags, prfs_Precedence(Search));
fflush(stdout);
list_Delete(EmptyClauses);
list_Delete(AllClauses);
list_Delete(ProofClauses);
list_Delete(SplitClauses);
list_Delete(Incomplete);
return ReducedProof;
}
