static ord_RESULT rpos_MulGreaterEqual(TERM T1, TERM T2, BOOL VarIsConst)
/**************************************************************
INPUT: Two terms with equal top symbols and multiset status.
RETURNS: ord_GREATER_THAN if <T1> is greater than <T2>,
ord_EQUAL if both terms are equal and
ord_UNCOMPARABLE otherwise.
CAUTION: If <VarIsConst> is set then variables are interpreted as constants
with lowest precedence. They are ranked to each other using
their variable index.
***************************************************************/
{
LIST l1, l2;
l1 = rpos_MultisetDifference(T1, T2);
if (list_Empty(l1))
/* If |M| = |N| and M-N = {} then N-M = {} */
return ord_Equal(); /* Terms are equal */
else {
LIST scan;
BOOL greater;
l2 = rpos_MultisetDifference(T2, T1);
for (greater = TRUE; !list_Empty(l2) && greater; l2 = list_Pop(l2)) {
for (scan = l1, greater = FALSE; !list_Empty(scan) && !greater; scan = list_Cdr(scan))
greater = rpos_Greater(list_Car(scan), list_Car(l2), VarIsConst);
}
list_Delete(l1); /* l2 was freed in the outer for loop */
if (greater)
return ord_GreaterThan();
else
return ord_Uncomparable();
}
}
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;
}
LIST list_NReverse(LIST List)
/**************************************************************
INPUT: A list
RETURNS: The same list with reversed order of items.
CAUTION: Destructive.
The function needs time O(n), where <n> is the length
of the list.
***************************************************************/
{
LIST ReverseList;
LIST Scan1;
LIST Scan2;
ReverseList = list_Nil();
for (Scan1=List; !list_Empty(Scan1); Scan1=list_Cdr(Scan1))
ReverseList = list_Cons(list_Car(Scan1),ReverseList);
for (Scan1=List, Scan2=ReverseList;
!list_Empty(Scan1);
Scan1=list_Cdr(Scan1), Scan2=list_Cdr(Scan2))
list_Rplaca(Scan1, list_Car(Scan2));
list_Delete(ReverseList);
return List;
}
BOOL rpos_Equal(TERM T1, TERM T2)
/**************************************************************
INPUT: Two terms.
RETURNS: TRUE, if <T1> is equal to <T2> and
FALSE otherwise.
***************************************************************/
{
LIST l1, l2;
if (!term_EqualTopSymbols(T1, T2))
return FALSE;
else if (!term_IsComplex(T1)) /* Equal variable or constant */
return TRUE;
else {
if (symbol_HasProperty(term_TopSymbol(T1), ORDMUL)) { /* MUL case */
l1 = rpos_MultisetDifference(T1, T2);
if (list_Empty(l1))
return TRUE;
else {
list_Delete(l1);
return FALSE;
}
} else { /* LEX case */
for (l1 = term_ArgumentList(T1), l2 = term_ArgumentList(T2);
!list_Empty(l1) && rpos_Equal(list_Car(l1), list_Car(l2));
l1 = list_Cdr(l1), l2 = list_Cdr(l2))
/* empty */;
return list_Empty(l1); /* All arguments were equal */
}
}
}
void literal_Delete(CLITERAL literal)
/**********************************************************
INPUT: A literal.
RETURNS: None.
MEMORY: Deletes the LITERAL and frees the storage.
***********************************************************/
{
list_Delete(literal_GetLitVarList(literal));
literal_Free(literal);
}
void hsh_Reset(HASH H)
/**************************************************************
INPUT: A hasharray
EFFECT: Deletes all information stored in the array but keeps
the array itself.
Keys and data items are not deleted !
***************************************************************/
{
int i;
LIST Scan, Pair;
for (i = 0; i < hsh__SIZE; i++) {
for (Scan = H[i]; !list_Empty(Scan); Scan = list_Cdr(Scan)) {
Pair = list_Car(Scan);
list_Delete(list_PairSecond(Pair));
list_PairFree(Pair);
}
list_Delete(H[i]);
H[i] = list_Nil();
}
}
void graph_Delete(GRAPH Graph)
/**************************************************************
INPUT: A graph.
RETURNS: Nothing.
EFFECT: All memory required by the graph and its nodes
is freed.
***************************************************************/
{
for ( ; !list_Empty(Graph->nodes); Graph->nodes = list_Pop(Graph->nodes)) {
list_Delete(graph_NodeNeighbors(list_Car(Graph->nodes)));
memory_Free(list_Car(Graph->nodes), sizeof(GRAPHNODE_STRUCT));
}
memory_Free(Graph, sizeof(GRAPH_STRUCT));
}
void list_DeleteAssocListWithValues(LIST List, void (*ValueDelete)(POINTER))
/**************************************************************
INPUT: An association list and a delete function for the values.
RETURNS: void.
EFFECT: The assoc list and its values are deleted.
***************************************************************/
{
LIST Scan;
for (Scan=List;!list_Empty(Scan);Scan = list_Cdr(Scan)) {
ValueDelete(list_PairSecond(list_Car(Scan)));
list_PairFree(list_Car(Scan));
}
list_Delete(List);
}
void st_IndexDelete(st_INDEX StIndex)
/**************************************************************
INPUT: A pointer to an existing St-Index.
SUMMARY: Deletes the whole index structure.
***************************************************************/
{
if (StIndex == NULL)
return;
else if (st_IsLeaf(StIndex))
list_Delete(StIndex->entries);
else
/* Recursion */
list_DeleteWithElement(StIndex->subnodes, (void (*)(POINTER))st_IndexDelete);
subst_Delete(StIndex->subst);
st_Free(StIndex);
}
static CLAUSE red_CreateTerminatorEmptyClause(LIST FoundMap, FLAGSTORE Flags,
PRECEDENCE Precedence)
/**************************************************************
INPUT: A list of pairs (l1, l2), where l1 and l2 are unifiable
literals with complementary sign and a flag store.
More accurately, a substitution s exists,
such that l1 s = l2 s for all pairs (l1,l2) in
<FoundMap>.
For all literals l from the involved clauses
there exists one pair (l1,l2) in <FoundMap>
with l1=l or l2=l.
The flags store and the precedence are needed to create
the new clause.
RETURNS: A newly created empty clause, where the data
(parents,...) is set according to <FoundMap>.
***************************************************************/
{
CLAUSE Result, PClause;
LITERAL Lit;
LIST Parents;
NAT depth;
Result = clause_Create(list_Nil(), list_Nil(), list_Nil(), Flags, Precedence);
Parents = list_Nil();
depth = 0;
for (; !list_Empty(FoundMap); FoundMap = list_Cdr(FoundMap)) {
Lit = list_PairSecond(list_Car(FoundMap));
PClause = clause_LiteralOwningClause(Lit);
Parents = list_Cons(PClause, Parents);
depth = misc_Max(depth, clause_Depth(PClause));
clause_AddParentClause(Result, clause_Number(PClause));
clause_AddParentLiteral(Result, clause_LiteralGetIndex(Lit));
Lit = list_PairFirst(list_Car(FoundMap));
PClause = clause_LiteralOwningClause(Lit);
Parents = list_Cons(PClause, Parents);
depth = misc_Max(depth, clause_Depth(PClause));
clause_AddParentClause(Result, clause_Number(PClause));
clause_AddParentLiteral(Result, clause_LiteralGetIndex(Lit));
}
clause_SetFromTerminator(Result);
clause_SetDepth(Result, depth+1);
clause_SetSplitDataFromList(Result, Parents);
list_Delete(Parents);
return Result;
}
static LIST inf_NonUnitURResolution(CLAUSE Clause, int SpecialLitIndex,
LIST FoundMap, SUBST Subst,
SYMBOL GlobalMaxVar, SHARED_INDEX Index,
FLAGSTORE Flags, PRECEDENCE Precedence)
/**************************************************************
INPUT: A non-unit clause, a literal index from <Clause>.
<FoundMap> is a list of pairs (l1,l2) of unifiable literals,
where l1 is from <Clause> and l2 is from a unit clause.
At this point the list has at most one element.
<Subst> is the substitution for <Clause>.
<GlobalMaxVar> is the maximal variable encountered so far.
<Index> is used to search unifiable literals.
The flag store and the precedence are needed to create
the new clauses.
RETURNS: The list of UR resolution resolvents.
EFFECT: If inf_URResolution was called with a unit clause,
<SpecialLitIndex> is the index of a literal from a non-unit
clause, that is unifiable with the unit clause's literal,
otherwise it is set to -1.
***************************************************************/
{
LIST Result, RestLits;
int i, last;
Result = list_Nil();
RestLits = clause_GetLiteralListExcept(Clause, SpecialLitIndex);
last = clause_LastLitIndex(Clause);
for (i = clause_FirstLitIndex(); i <= last; i++) {
/* <i> is the index of the literal that remains in the resolvent */
if (i != SpecialLitIndex) {
RestLits = list_PointerDeleteOneElement(RestLits,
clause_GetLiteral(Clause,i));
Result = list_Nconc(inf_SearchURResolvents(Clause, i, FoundMap, RestLits,
Subst, GlobalMaxVar, Index,
Flags, Precedence),
Result);
RestLits = list_Cons(clause_GetLiteral(Clause, i), RestLits);
}
}
list_Delete(RestLits);
return Result;
}
static ord_RESULT rpos_ContMulGreaterEqual(CONTEXT GlobalC1, CONTEXT TermC1, TERM T1,
CONTEXT GlobalC2, CONTEXT TermC2, TERM T2,
BOOL VarIsConst)
/**************************************************************
INPUT: Two contexts and two terms with equal top symbols
and multiset status.
RETURNS: ord_GREATER_THAN if <T1> is greater than <T2>,
ord_EQUAL if both terms are equal and
ord_UNCOMPARABLE otherwise.
EFFECT: Variable bindings are considered.
ASSUMPTION: All index variables of <T1> and <T2> are bound in
<GlobalC1> and <GlobalCt2>, respectively
***************************************************************/
{
LIST l1, l2;
/* Don't apply bindings at top level, since that happened */
/* in rpos_ContGreaterEqual. */
l1 = rpos_ContMultisetDifference(GlobalC1, TermC1, T1, GlobalC2, TermC2, T2);
if (list_Empty(l1))
/* If |M| = |N| and M-N = {} then N-M = {} */
return ord_Equal(); /* Terms are equal */
else {
LIST scan;
BOOL greater;
l2 = rpos_ContMultisetDifference(GlobalC2, TermC2, T2, GlobalC1, TermC1, T1);
for (greater = TRUE; !list_Empty(l2) && greater; l2 = list_Pop(l2)) {
for (scan = l1, greater = FALSE; !list_Empty(scan) && !greater;
scan = list_Cdr(scan))
greater = rpos_ContGreaterAux(GlobalC1, TermC1, list_Car(scan),
GlobalC2, TermC2, list_Car(l2),
VarIsConst);
}
list_Delete(l1); /* l2 was freed in the outer for loop */
if (greater)
return ord_GreaterThan();
else
return ord_Uncomparable();
}
}
void tab_CheckEmpties(TABLEAU T)
/**************************************************************
INPUT: A tableau
RETURNS: Nothing.
EFFECTS: Prints warnings if non-leaf nodes contain
empty clauses (which should not be the case
after pruning any more), of if leaf nodes
contain more than one empty clause
***************************************************************/
{
LIST Scan, Empties;
BOOL Printem;
if (tab_IsEmpty(T))
return;
/* get all empty clauses in this node */
Empties = list_Nil();
for (Scan = tab_Clauses(T); !list_Empty(Scan); Scan = list_Cdr(Scan)) {
if (clause_IsEmptyClause(list_Car(Scan)))
Empties = list_Cons(list_Car(Scan), Empties);
}
Printem = FALSE;
if (!list_Empty(Empties) && !tab_IsLeaf(T)) {
puts("\nNOTE: non-leaf node contains empty clauses.");
Printem = TRUE;
}
if (tab_IsLeaf(T) && list_Length(Empties) > 1) {
puts("\nNOTE: Leaf contains more than one empty clauses.");
Printem = TRUE;
}
if (Printem) {
puts("Clauses:");
clause_PParentsListPrint(tab_Clauses(T));
}
list_Delete(Empties);
tab_CheckEmpties(tab_LeftBranch(T));
tab_CheckEmpties(tab_RightBranch(T));
}
BOOL rpos_ContEqual(CONTEXT GlobalC1, CONTEXT TermC1, TERM T1,
CONTEXT GlobalC2, CONTEXT TermC2, TERM T2)
/**************************************************************
INPUT: Two contexts and two terms.
RETURNS: TRUE, if <T1> is equal to <T2> and
FALSE otherwise.
EFFECT: Variable bindings are considered.
ASSUMPTION: All index variables of <T1> and <T2> are bound in
<GlobalC1> and <GlobalCt2>, respectively
***************************************************************/
{
LIST l1, l2;
T1 = cont_Deref(GlobalC1, &TermC1, T1);
T2 = cont_Deref(GlobalC2, &TermC2, T2);
if (!term_EqualTopSymbols(T1, T2))
return FALSE;
else if (!term_IsComplex(T1))
return TRUE;
else {
if (symbol_HasProperty(term_TopSymbol(T1), ORDMUL)) {
l1 = rpos_ContMultisetDifference(GlobalC1, TermC1, T1,
GlobalC2, TermC2, T2);
if (list_Empty(l1))
return TRUE;
else {
list_Delete(l1);
return FALSE;
}
} else { /* LEX case */
for (l1 = term_ArgumentList(T1), l2 = term_ArgumentList(T2);
!list_Empty(l1) && rpos_ContEqual(GlobalC1, TermC1,list_Car(l1),
GlobalC2, TermC2,list_Car(l2));
l1 = list_Cdr(l1), l2 = list_Cdr(l2)); /* empty body */
return list_Empty(l1); /* All arguments were equal */
}
}
}
void symbol_FreeAllSymbols(void)
/**************************************************************
INPUT: None.
RETURNS: Nothing.
EFFECTS: Frees all generated symbols
***************************************************************/
{
if (symbol_SignatureExists()) {
int Index;
SIGNATURE S;
for (Index = 1; Index < symbol_ACTINDEX; Index++) {
S = symbol_Signature(Index);
if (S != NULL)
symbol_FreeSignature(S);
}
memory_Free(symbol_SIGNATURE, sizeof(SIGNATURE[symbol__MAXSIGNATURE]));
}
memory_Free(symbol_VARSTRING, symbol__SYMBOLMAXLEN);
list_Delete(symbol_FREEDSYMBOLS);
}
void symbol_FPrintPrecedence(FILE *File, PRECEDENCE Precedence)
/**************************************************************
INPUT: A file pointer and a precedence.
RETURNS: void
EFFECT: Prints the current precedence as a setting command
in DFG syntax to <File>.
***************************************************************/
{
if (symbol_SignatureExists()) {
LIST Symbols,Scan;
int Index;
SIGNATURE S;
Symbols = list_Nil();
for (Index = 1; Index < symbol_ACTINDEX; Index++) {
S = symbol_Signature(Index);
if (S != NULL &&
(symbol_IsPredicate(S->info) || symbol_IsFunction(S->info)))
Symbols = list_Cons((POINTER)S->info, Symbols);
}
Symbols = symbol_SortByPrecedence(Symbols, Precedence);
Index = 0;
fputs("set_precedence(", File);
for (Scan = Symbols; !list_Empty(Scan); Scan = list_Cdr(Scan)) {
S = symbol_Signature(symbol_Index((SYMBOL)list_Car(Scan)));
fputs(S->name, File);
if (!list_Empty(list_Cdr(Scan)))
putc(',', File);
if (Index > 15) {
Index = 0;
fputs("\n\t", File);
}
else
Index++;
}
fputs(").", File);
list_Delete(Symbols);
}
}
static void st_NodeMergeWithSon(st_INDEX StIndex)
/**************************************************************
INPUT:
RETURNS:
EFFECTS:
***************************************************************/
{
st_INDEX SubNode;
SubNode = (st_INDEX)list_Car(StIndex->subnodes);
list_Delete(StIndex->subnodes);
StIndex->subst = subst_Merge(SubNode->subst, StIndex->subst);
StIndex->entries = SubNode->entries;
StIndex->subnodes = SubNode->subnodes;
st_SetMax(StIndex, st_Max(SubNode));
st_SetMin(StIndex, st_Min(SubNode));
subst_Delete(SubNode->subst);
st_Free(SubNode);
}
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;
}
static ord_RESULT rpos_ContLexGreaterEqual(CONTEXT GlobalC1, CONTEXT TermC1, TERM T1,
CONTEXT GlobalC2, CONTEXT TermC2, TERM T2,
BOOL VarIsConst)
/**************************************************************
INPUT: Two contexts and two terms with equal top symbols
and lexicographic status and a flag.
RETURNS: ord_GREATER_THAN if <T1> is greater than <T2>,
ord_EQUAL if both terms are equal and
ord_UNCOMPARABLE otherwise.
EFFECT: Variable bindings are considered.
ASSUMPTION: All index variables of <T1> and <T2> are bound in
<GlobalC1> and <GlobalCt2>, respectively
CAUTION: If <VarIsConst> is set then variables are interpreted as constants
with lowest precedence. They are ranked to each other using
their variable index.
***************************************************************/
{
ord_RESULT result;
LIST l1, l2, scan1, scan2;
/* Don't apply bindings at top level, since that happened */
/* in rpos_ContGreaterEqual */
if (symbol_HasProperty(term_TopSymbol(T1), ORDRIGHT)) {
l1 = list_Reverse(term_ArgumentList(T1)); /* Create new lists */
l2 = list_Reverse(term_ArgumentList(T2));
} else {
l1 = term_ArgumentList(T1);
l2 = term_ArgumentList(T2);
}
/* First ignore equal arguments */
result = ord_Equal();
for (scan1 = l1, scan2 = l2; !list_Empty(scan1);
scan1 = list_Cdr(scan1), scan2 = list_Cdr(scan2)) {
result = rpos_ContGreaterEqual(GlobalC1, TermC1, list_Car(scan1),
GlobalC2, TermC2, list_Car(scan2),
VarIsConst);
if (!ord_IsEqual(result))
break;
}
if (ord_IsEqual(result)) /* All arguments are equal, so the terms */
/* empty */; /* are equal with respect to RPOS */
else if (ord_IsGreaterThan(result)) {
/* Check if T1 > each remaining argument of T2 */
for (scan2 = list_Cdr(scan2);
!list_Empty(scan2) && rpos_ContGreaterAux(GlobalC1, TermC1, T1,
GlobalC2, TermC2, list_Car(scan2),
VarIsConst);
scan2 = list_Cdr(scan2)); /* Empty body */
if (list_Empty(scan2))
result = ord_GreaterThan();
else
result = ord_Uncomparable();
}
else {
/* Argument of T1 was not >= argument of T2. */
/* Try to find an argument of T1 that is >= T2 */
for (scan1 = list_Cdr(scan1), result = ord_Uncomparable();
!list_Empty(scan1) && !ord_IsGreaterThan(result);
scan1 = list_Cdr(scan1)) {
if (!ord_IsUncomparable(rpos_ContGreaterEqual(GlobalC1, TermC1,list_Car(scan1),
GlobalC2, TermC2,T2,
VarIsConst)))
result = ord_GreaterThan();
}
}
if (symbol_HasProperty(term_TopSymbol(T1), ORDRIGHT)) {
list_Delete(l1); /* Delete the lists create above */
list_Delete(l2);
}
return result;
}
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;
}
}
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 subs_CompList(LITPTR litptr)
/**********************************************************
INPUT: A pointer litptr.
RETURNS: A list with indexes which represents the first component of
with respect to the actual bindings and to litptr.
CAUTION: The structure to which litptr points to
is changed destructively in the used slot.
***********************************************************/
{
BOOL found,hasinter;
LIST scan,complist,compindexlist;
int n,i,j,lit;
compindexlist = list_Nil(); /* the result will be placed into this list */
complist = list_Nil(); /* added afterwards */
n = litptr_Length(litptr);
if (n > 0) {
for (j = 0; j < n; j++) {
printf("\nj = %d\n",j);
if (!literal_GetUsed(litptr_Literal(litptr,j))) {
complist = list_Nil();
complist = list_Cons((POINTER)j,complist);
compindexlist = list_Cons((POINTER)(litptr->litptr[j]->litindex),
compindexlist);
literal_PutUsed(litptr_Literal(litptr,j), TRUE);
j = n+1;
printf("\nj == %d\n",j);
}
}
if (j == n) {
list_Delete(complist); /* There is no more component */
return compindexlist; /* should be empty here */
}
found = TRUE;
while (found) {
found = FALSE;
for (scan = complist; !list_Empty(scan); scan = list_Cdr(scan)) {
lit = (int)list_Car(scan);
for (i = 0; i < n; i++) {
if (!literal_GetUsed(litptr_Literal(litptr,i))) {
printf("lit = %d\n",lit);
printf("i = %d\n",i);
hasinter = list_HasIntersection(litptr->litptr[lit]->litvarlist,
litptr->litptr[i]->litvarlist);
if (hasinter) {
puts("hasinter = TRUE");
complist = list_Cons((POINTER)i,complist);
compindexlist = list_Cons((POINTER)(litptr->litptr[i]->litindex),compindexlist);
literal_PutUsed(litptr_Literal(litptr,i), TRUE);
found = TRUE;
}
}
}
}
if (!found) { /* one component is finished */
list_Delete(complist);
found = FALSE;
}
}
}
return compindexlist;
}
static void dp_FPrintDFGProof(LIST Clauses, const char *FilePrefix,
FLAGSTORE Flags, PRECEDENCE Precedence)
/*********************************************************
INPUT: A list of clauses representing a proof, a
string indicating a file name prefix, a flag
store and a precedence.
RETURNS: void.
EFFECT: Outputs the proof in DFG proof format to
<FilePrefix>.prf
**********************************************************/
{
FILE *Output;
CLAUSE Clause;
LIST AxClauses,ConClauses,ProofClauses,Scan;
char *name;
AxClauses = ConClauses = ProofClauses = list_Nil();
name = memory_Malloc(sizeof(char)*(strlen(FilePrefix)+5));
sprintf(name,"%s.prf", FilePrefix);
Output = misc_OpenFile(name,"w");
fputs("begin_problem(Unknown).\n\n", Output);
fputs("list_of_descriptions.\n", Output);
fputs("name({*", Output);
fputs(FilePrefix, Output);
fputs("*}).\n", Output);
fputs("author({*SPASS ", Output);
fputs(misc_VERSION, Output);
fputs("*}).\n", Output);
fputs("status(unsatisfiable).\n", Output);
fputs("description({*File generated by SPASS containing a proof.*}).\n", Output);
fputs("end_of_list.\n\n", Output);
fputs("list_of_symbols.\n", Output);
fol_FPrintDFGSignature(Output);
fputs("end_of_list.\n\n", Output);
for (Scan=Clauses;!list_Empty(Scan);Scan=list_Cdr(Scan)) {
Clause = (CLAUSE)list_Car(Scan);
if (clause_IsFromInput(Clause)) {
if (clause_GetFlag(Clause, CONCLAUSE))
ConClauses = list_Cons(Clause, ConClauses);
else
AxClauses = list_Cons(Clause, AxClauses);
}
else
ProofClauses = list_Cons(Clause, ProofClauses);
}
ConClauses = list_NReverse(ConClauses);
AxClauses = list_NReverse(AxClauses);
ProofClauses = list_NReverse(ProofClauses);
clause_FPrintCnfDFG(Output, FALSE, AxClauses, ConClauses, Flags, Precedence);
fputs("\nlist_of_proof(SPASS).\n", Output);
for (Scan=ProofClauses; !list_Empty(Scan); Scan=list_Cdr(Scan)) {
clause_FPrintDFGStep(Output,list_Car(Scan),TRUE);
}
fputs("end_of_list.\n\n", Output);
fputs("end_problem.\n\n", Output);
misc_CloseFile(Output, name);
fputs("\nDFG Proof printed to: ", stdout);
puts(name);
list_Delete(ConClauses);
list_Delete(AxClauses);
list_Delete(ProofClauses);
memory_Free(name, sizeof(char)*(strlen(FilePrefix)+5));
}
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;
}
int main(int argc, const char* argv[])
{
LIST Clauses,Axioms,Conjectures,Sorts,Scan,
UserPrecedence,UserSelection,ClAxRelation;
FILE *Input;
CLAUSE Clause;
const char *Filename;
FLAGSTORE Flags;
PRECEDENCE Precedence;
BOOL HasPlainClauses;
DFGDESCRIPTION Description;
memory_Init(memory__UNLIMITED);
atexit(memory_FreeAllMem);
symbol_Init(TRUE);
stack_Init();
term_Init();
flag_Init(flag_SPASS);
cmdlne_Init();
Flags = flag_CreateStore();
flag_InitStoreByDefaults(Flags);
Precedence = symbol_CreatePrecedence();
Description = desc_Create();
fol_Init(TRUE, Precedence);
eml_Init(Precedence);
clause_Init();
if (argc < 2 || !cmdlne_Read(argc, argv)) {
fputs("\n\t dfg2ascii Version ", stdout);
fputs(DFG2ASCII__VERSION, stdout);
puts("\n\t Usage: dfg2ascii <input-file>\n");
return EXIT_FAILURE;
}
if (!cmdlne_SetFlags(Flags))
return EXIT_FAILURE;
Axioms = list_Nil();
Conjectures = list_Nil();
Sorts = list_Nil();
UserPrecedence = list_Nil();
UserSelection = list_Nil();
ClAxRelation = list_Nil();
Filename = cmdlne_GetInputFile();
Input = misc_OpenFile(Filename,"r");
Clauses = dfg_DFGParser(Input, Flags, Precedence, Description, &Axioms, &Conjectures,
&Sorts, &UserPrecedence, &UserSelection, &ClAxRelation,
&HasPlainClauses);
misc_CloseFile(Input,Filename);
Axioms = list_Nconc(Axioms, Sorts);
if (!list_Empty(Axioms) || !list_Empty(Conjectures)) {
puts("\n\n\t\t Axioms:\n");
if (list_Empty(Axioms))
puts("None.\n");
else
for (Scan=Axioms; !list_Empty(Scan);Scan=list_Cdr(Scan)) {
if (list_PairFirst(list_Car(Scan)) != NULL)
printf("%s:\n",(char *)list_PairFirst(list_Car(Scan)));
fol_PrettyPrintDFG(list_PairSecond(list_Car(Scan)));
puts("\n");
}
puts("\n\n\t\t Conjectures:\n");
if (list_Empty(Conjectures))
puts("None.\n");
else
for (Scan=Conjectures; !list_Empty(Scan);Scan=list_Cdr(Scan)) {
if (list_PairFirst(list_Car(Scan)) != NULL)
printf("%s:\n",(char *)list_PairFirst(list_Car(Scan)));
fol_PrettyPrintDFG(list_PairSecond(list_Car(Scan)));
puts("\n");
}
}
else {
BOOL SetExist;
LIST ClauseScan;
/* Before we sort the clauses, we need to make sure that they have been
assigned a weight.
*/
for (ClauseScan = Clauses; !list_Empty(ClauseScan); ClauseScan = list_Cdr(ClauseScan)) {
clause_UpdateWeight((CLAUSE) list_Car(ClauseScan), Flags);
}
Clauses = clause_ListSortWeighed(Clauses);
clause_SetCounter(1);
for (Scan = Clauses;!list_Empty(Scan);Scan=list_Cdr(Scan)) {
Clause = (CLAUSE)list_Car(Scan);
clause_SetSortConstraint(Clause, FALSE, Flags, Precedence);
clause_NewNumber(Clause);
clause_OrientAndReInit(Clause, Flags, Precedence);
}
puts("\n\n\t\t Axiom Clauses:\n");
SetExist = FALSE;
for (Scan = Clauses;!list_Empty(Scan);Scan=list_Cdr(Scan)) {
Clause = (CLAUSE)list_Car(Scan);
if (!clause_GetFlag(Clause,CONCLAUSE)) {
SetExist = TRUE;
clause_Print(Clause);
putchar('\n');
}
}
if (SetExist)
SetExist = FALSE;
else
puts("None.\n");
puts("\n\n\t\t Conjecture Clauses:\n");
for (Scan = Clauses;!list_Empty(Scan);Scan=list_Cdr(Scan)) {
Clause = (CLAUSE)list_Car(Scan);
if (clause_GetFlag(Clause,CONCLAUSE)) {
SetExist = TRUE;
clause_Print(Clause);
putchar('\n');
}
}
if (SetExist)
SetExist = FALSE;
else
puts("None.\n");
}
clause_DeleteClauseList(Clauses);
dfg_StripLabelsFromList(Axioms);
dfg_StripLabelsFromList(Conjectures);
term_DeleteTermList(Axioms);
term_DeleteTermList(Conjectures);
eml_Free();
flag_DeleteStore(Flags);
symbol_DeletePrecedence(Precedence);
list_Delete(UserPrecedence);
list_Delete(UserSelection);
dfg_DeleteClAxRelation(ClAxRelation);
desc_Delete(Description);
/*symbol_Dump();*/
cmdlne_Free();
fol_Free();
symbol_FreeAllSymbols();
#ifdef CHECK
memory_Print();
#endif
return 0;
}
static ord_RESULT rpos_ContLexGreaterEqual(CONTEXT C1, TERM T1,
CONTEXT C2, TERM T2)
/**************************************************************
INPUT: Two contexts and two terms with equal top symbols
and lexicographic status.
RETURNS: ord_GREATER_THAN if <T1> is greater than <T2>,
ord_EQUAL if both terms are equal and
ord_UNCOMPARABLE otherwise.
EFFECT: Variable bindings are considered.
***************************************************************/
{
ord_RESULT result;
LIST l1, l2, scan1, scan2;
/* Don't apply bindings at top level, since that happened */
/* in rpos_ContGreaterEqual */
if (symbol_HasProperty(term_TopSymbol(T1), ORDRIGHT)) {
l1 = list_Reverse(term_ArgumentList(T1)); /* Create new lists */
l2 = list_Reverse(term_ArgumentList(T2));
} else {
l1 = term_ArgumentList(T1);
l2 = term_ArgumentList(T2);
}
/* First ignore equal arguments */
result = ord_Equal();
for (scan1 = l1, scan2 = l2; !list_Empty(scan1);
scan1 = list_Cdr(scan1), scan2 = list_Cdr(scan2)) {
result = rpos_ContGreaterEqual(C1, list_Car(scan1), C2, list_Car(scan2));
if (!ord_IsEqual(result))
break;
}
if (ord_IsEqual(result)) /* All arguments are equal, so the terms */
/* empty */; /* are equal with respect to RPOS */
else if (ord_IsGreaterThan(result)) {
/* Check if T1 > each remaining argument of T2 */
for (scan2 = list_Cdr(scan2);
!list_Empty(scan2) && rpos_ContGreater(C1, T1, C2, list_Car(scan2));
scan2 = list_Cdr(scan2)); /* Empty body */
if (list_Empty(scan2))
result = ord_GreaterThan();
else
result = ord_Uncomparable();
}
else {
/* Argument of T1 was not >= argument of T2. */
/* Try to find an argument of T1 that is >= T2 */
for (scan1 = list_Cdr(scan1), result = ord_Uncomparable();
!list_Empty(scan1) && !ord_IsGreaterThan(result);
scan1 = list_Cdr(scan1)) {
if (!ord_IsUncomparable(rpos_ContGreaterEqual(C1,list_Car(scan1),C2,T2)))
result = ord_GreaterThan();
}
}
if (symbol_HasProperty(term_TopSymbol(T1), ORDRIGHT)) {
list_Delete(l1); /* Delete the lists create above */
list_Delete(l2);
}
return result;
}
static LIST inf_SearchURResolvents(CLAUSE Clause, int i, LIST FoundMap,
LIST RestLits, SUBST Subst,
SYMBOL GlobalMaxVar, SHARED_INDEX Index,
FLAGSTORE Flags, PRECEDENCE Precedence)
/**************************************************************
INPUT: A non-unit clause, a literal index from <Clause>.
<FoundMap> is a list of pairs (l1,l2) of unifiable literals,
where l1 is from <Clause> and l2 is from a unit clause.
<RestLits> is a list of literals from <Clause> where
we haven't found unifiable literals from unit clauses
so far.
<Subst> is the overall substitution for <Clause>
(not for the unit-clauses!).
<GlobalMaxVar> is the maximal variable encountered so far.
<Index> is used to search unifiable literals.
The flag store and the precedence are needed to create
the new clauses.
RETURNS: A list of UR resolution resolvents.
***************************************************************/
{
if (list_Empty(RestLits)) {
/* Stop the recursion */
return list_List(inf_CreateURUnitResolvent(Clause, i, Subst, FoundMap,
Flags, Precedence));
} else {
LITERAL Lit, PLit;
SYMBOL NewMaxVar;
SUBST NewSubst, RightSubst;
TERM AtomCopy, PAtom;
LIST Result, Partners;
BOOL Swapped;
Result = list_Nil();
Swapped = FALSE;
/* Choose the unmatched literal with the most symbols */
RestLits = clause_MoveBestLiteralToFront(list_Copy(RestLits), Subst,
GlobalMaxVar,
clause_HyperLiteralIsBetter);
Lit = list_Car(RestLits);
RestLits = list_Pop(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) {
Partners = inf_GetURPartnerLits(AtomCopy, Lit, TRUE, Index);
for ( ; !list_Empty(Partners); Partners = list_Pop(Partners)) {
PLit = list_Car(Partners);
/* Rename the atom */
PAtom = term_Copy(clause_LiteralAtom(PLit));
term_StartMaxRenaming(GlobalMaxVar);
term_Rename(PAtom);
/* Get the new global maximal variable */
NewMaxVar = term_MaxVar(PAtom);
if (symbol_GreaterVariable(GlobalMaxVar, NewMaxVar))
NewMaxVar = GlobalMaxVar;
/* Get the substitution */
cont_Check();
if (!unify_UnifyNoOC(cont_LeftContext(), AtomCopy,
cont_RightContext(), PAtom)) {
misc_StartErrorReport();
misc_ErrorReport("\n In inf_SearchURResolvents: Unification failed.");
misc_FinishErrorReport();
}
subst_ExtractUnifier(cont_LeftContext(), &NewSubst,
cont_RightContext(), &RightSubst);
cont_Reset();
subst_Delete(RightSubst); /* Forget substitution for unit clause */
term_Delete(PAtom); /* Was just needed to get the substitution */
/* Build the composition of the substitutions */
RightSubst = NewSubst;
NewSubst = subst_Compose(NewSubst, subst_Copy(Subst));
subst_Delete(RightSubst);
FoundMap = list_Cons(list_PairCreate(Lit, PLit), FoundMap);
Result = list_Nconc(inf_SearchURResolvents(Clause,i,FoundMap,RestLits,
NewSubst,NewMaxVar,Index,
Flags, Precedence),
Result);
list_PairFree(list_Car(FoundMap));
FoundMap = list_Pop(FoundMap);
subst_Delete(NewSubst);
}
/* loop control */
if (!fol_IsEquality(AtomCopy) || Swapped)
break;
else {
term_EqualitySwap(AtomCopy);
Swapped = TRUE;
}
}
/* cleanup */
term_Delete(AtomCopy);
list_Delete(RestLits);
return Result;
}
}
