void ana_AnalyzeProblem(PROOFSEARCH Search, LIST Clauses) /************************************************************** INPUT: A proofsearch object and a list of clauses. RETURNS: Void. EFFECT: Analyzes the clauses and sets the analyze variables. Recomputes the weight for the clauses. <Search> is modified according to clauses: non trivial domain number is set ***************************************************************/ { CLAUSE Clause; ana_EQUATIONS = FALSE; ana_PEQUATIONS = FALSE; /* Defaults for properties */ ana_NEQUATIONS = FALSE; ana_FUNCTIONS = FALSE; ana_FINDOMAIN = FALSE; ana_NONTRIVDOMAIN = FALSE; ana_MONADIC = FALSE; ana_NONMONADIC = FALSE; ana_PROP = FALSE; ana_GROUND = FALSE; ana_SORTRES = FALSE; ana_USORTRES = FALSE; ana_NONUNIT = FALSE; ana_CONGROUND = TRUE; ana_AXIOMCLAUSES = 0; ana_CONCLAUSES = 0; ana_NONHORNCLAUSES = 0; list_Delete(ana_FINITEMONADICPREDICATES); ana_FINITEMONADICPREDICATES = list_Nil(); if (list_Empty(Clauses)) return; ana_FINITEMONADICPREDICATES = clause_FiniteMonadicPredicates(Clauses); while (!list_Empty(Clauses)) { Clause = (CLAUSE)list_Car(Clauses); clause_UpdateWeight(Clause, prfs_Store(Search)); if (clause_GetFlag(Clause,CONCLAUSE)) ana_CONCLAUSES++; else ana_AXIOMCLAUSES++; if (clause_NumOfSuccLits(Clause) > 1) ana_NONHORNCLAUSES++; if (ana_CONGROUND && clause_GetFlag(Clause,CONCLAUSE) && clause_MaxVar(Clause) != symbol_GetInitialStandardVarCounter()) ana_CONGROUND = FALSE; if (!ana_PEQUATIONS && clause_ContainsPositiveEquations(Clause)) { ana_PEQUATIONS = TRUE; } if (!ana_NEQUATIONS && clause_ContainsNegativeEquations(Clause)) { ana_NEQUATIONS = TRUE; } if (!ana_MONADIC || !ana_NONMONADIC || !ana_PROP || !ana_GROUND) clause_ContainsFolAtom(Clause,&ana_PROP,&ana_GROUND,&ana_MONADIC,&ana_NONMONADIC); if (!ana_FUNCTIONS && clause_ContainsFunctions(Clause)) { ana_FUNCTIONS = TRUE; } if (!ana_FINDOMAIN && clause_ImpliesFiniteDomain(Clause)) { ana_FINDOMAIN = TRUE; } if (!ana_NONTRIVDOMAIN && clause_ImpliesNonTrivialDomain(Clause)) { prfs_SetNonTrivClauseNumber(Search, clause_Number(Clause)); ana_NONTRIVDOMAIN = TRUE; } if (!ana_NONUNIT && clause_Length(Clause) > 1) { ana_NONUNIT = TRUE; } if (!ana_SORTRES || !ana_USORTRES) clause_ContainsSortRestriction(Clause,&ana_SORTRES,&ana_USORTRES); Clauses = list_Cdr(Clauses); } ana_PUREEQUATIONAL = ((ana_PEQUATIONS || ana_NEQUATIONS) && !ana_MONADIC && !ana_NONMONADIC && !ana_PROP && !ana_GROUND); ana_EQUATIONS = (ana_PEQUATIONS || ana_NEQUATIONS); ana_PUREPROPOSITIONAL = (!ana_PEQUATIONS && !ana_NEQUATIONS &&!ana_MONADIC && !ana_NONMONADIC && ana_PROP); }
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; }