CLAUSE red_Terminator(CLAUSE RedClause, NAT n, SHARED_INDEX WoIndex, SHARED_INDEX UsIndex, FLAGSTORE Flags, PRECEDENCE Precedence) /************************************************************** INPUT: A clause, two shared indexes, a number <n> restricting the number of non-unit clauses in a possible terminator situation, a flag store and a precedence. RETURNS: An empty clause if a terminator with at most <n> non-unit clauses is found, NULL otherwise. EFFECT: See also description of red_SearchTerminator. ***************************************************************/ { LIST Rest, IndexList; CLAUSE Result; if (clause_Length(RedClause) > 1) /* non-unit clause */ n--; /* Pass the indexes as a list to sub-functions */ IndexList = list_Cons(WoIndex, list_List(UsIndex)); Rest = clause_GetLiteralList(RedClause); Result = red_SearchTerminator(n, Rest, list_Nil(), subst_Nil(), clause_MaxVar(RedClause), IndexList, Flags, Precedence); /* cleanup */ list_Delete(IndexList); list_Delete(Rest); return Result; }
static void cc_InitData(CLAUSE clause) /*************************************************************** INPUT: the clause to investigate EFFECT: pushes clause's atoms and their subterms on the pending stack, initializes each predecessor list with the list containing only a term's father, and unions the equivalence classes of the terms of the same antecedent equation ***************************************************************/ { int last, actno, i, ld; TERM atom; RAS cdr, size; cc_SetCars(ras_InitWithSize(cc_GetCars(), cc_RASSTDSIZE)); cc_SetPending(ras_InitWithSize(cc_GetPending(), cc_RASSTDSIZE)); ras_FastPush(cc_GetCars(), term_Null()); /* "true" has no predecessors */ actno = 1; last = clause_LastLitIndex(clause); for (i = clause_FirstLitIndex(); i <= last; i++) { atom = clause_GetLiteralAtom(clause, i); if (fol_IsEquality(atom)) { actno = cc_Number(actno, term_FirstArgument(atom), term_Null()); actno = cc_Number(actno, term_SecondArgument(atom), term_Null()); } else actno = cc_Number(actno, atom, term_Null()); } cc_SetPartition(part_Init(cc_GetPartition(), actno)); cc_SetTable(table_Init(cc_GetTable(), symbol_ActIndex() - 1, clause_MaxVar(clause), actno - 1)); cdr = ras_InitWithSize(cc_GetCdrs(), actno); size = ras_InitWithSize(cc_GetSizes(), actno); for (i = 0; i < actno; i++) { ras_FastPush(cdr, (POINTER) i); /* form a cycle */ ras_FastPush(size, (POINTER) (cc_GetCar(i) == term_Null()? 0 : 1)); } cc_SetCdrs(cdr); cc_SetSizes(size); /* compute ceil(ld(actno)) avoiding mathbib-logarithm's rounding errors: */ for (ld = 0, i = actno - 1; i > 0; i >>= 1) ld++; cc_SetCombine(ras_InitWithSize(cc_GetCombine(), actno * ld + 1)); /* for every antecedent equation union equivalence classes of its terms */ /* (a non-equational atom is represented as the equation atom = "true"): */ last = clause_LastAntecedentLitIndex(clause); for (i = clause_FirstLitIndex(); i <= last; i++) { atom = clause_GetLiteralAtom(clause, i); if (fol_IsEquality(atom)) cc_Union(term_Size(term_FirstArgument(atom)), /* clause not shared, therefore */ term_Size(term_SecondArgument(atom))); /* here no cc_Find needed */ else cc_Union(term_Size(atom), part_Find(cc_GetPartition(), cc_NOOFTRUE)); } }
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 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; }