void ana_AutoConfiguration(LIST Clauses, FLAGSTORE Flags,
PRECEDENCE Precedence)
/**************************************************************
INPUT: A list of clauses, a flag store and a precedence.
RETURNS: Nothing.
EFFECT: Based on the values of the ana analysis module, an appropriate
complete configuration of inference, reduction rules and other
settings is established.
***************************************************************/
{
LIST Scan, Functions, Predicates, Constants;
Functions = symbol_GetAllFunctions();
Predicates = fol_GetNonFOLPredicates();
/* Set precedence */
Predicates = ana_CalculatePredicatePrecedence(Predicates, Clauses);
Functions = ana_CalculateFunctionPrecedence(Functions, Clauses, Flags);
Constants = list_Nil();
for (Scan=Functions; !list_Empty(Scan); Scan=list_Cdr(Scan))
if (symbol_IsConstant((SYMBOL)list_Car(Scan)))
Constants = list_Cons(list_Car(Scan),Constants);
Functions = list_NPointerDifference(Functions,Constants);
Constants = list_NReverse(Constants);
for ( ; !list_Empty(Functions); Functions = list_Pop(Functions))
symbol_SetIncreasedOrdering(Precedence, (SYMBOL)list_Car(Functions));
/* Predicates < Functions */
for ( ; !list_Empty(Predicates); Predicates = list_Pop(Predicates))
symbol_SetIncreasedOrdering(Precedence, (SYMBOL)list_Car(Predicates));
/* Constants < Predicates */
/* Predicates < Functions */
for ( ; !list_Empty(Constants); Constants = list_Pop(Constants))
symbol_SetIncreasedOrdering(Precedence, (SYMBOL)list_Car(Constants));
flag_ClearInferenceRules(Flags);
flag_ClearReductionRules(Flags);
flag_SetFlagIntValue(Flags, flag_ROBV, flag_ROBVON);
flag_SetFlagIntValue(Flags, flag_RTAUT, flag_RTAUTSYNTACTIC);
flag_SetFlagIntValue(Flags, flag_RFSUB, flag_RFSUBON);
flag_SetFlagIntValue(Flags, flag_RBSUB, flag_RBSUBON);
flag_SetFlagIntValue(Flags, flag_RFMRR, flag_RFMRRON);
flag_SetFlagIntValue(Flags, flag_RBMRR, flag_RBMRRON);
flag_SetFlagIntValue(Flags, flag_RUNC, flag_RUNCON);
flag_SetFlagIntValue(Flags, flag_FULLRED, flag_FULLREDON);
/*flag_SetFlagIntValue(Flags, flag_FUNCWEIGHT,1);
flag_SetFlagIntValue(Flags, flag_VARWEIGHT,1);*/
flag_SetFlagIntValue(Flags, flag_WDRATIO,5);
if (ana_NEQUATIONS) {
flag_SetFlagIntValue(Flags, flag_IEQR, flag_EQUALITYRESOLUTIONON);
if (ana_NONUNIT) {
if (ana_NONTRIVDOMAIN)
flag_SetFlagIntValue(Flags, flag_RAED, flag_RAEDPOTUNSOUND);
else
flag_SetFlagIntValue(Flags, flag_RAED, flag_RAEDSOUND);
}
}
if (ana_PEQUATIONS) {
flag_SetFlagIntValue(Flags, flag_ISPR, flag_SUPERPOSITIONRIGHTON);
flag_SetFlagIntValue(Flags, flag_ISPL, flag_SUPERPOSITIONLEFTON);
if (ana_NONHORNCLAUSES > 0)
flag_SetFlagIntValue(Flags, flag_IEQF, flag_EQUALITYFACTORINGON);
if (ana_NONUNIT)
flag_SetFlagIntValue(Flags, flag_RCON, flag_RCONON);
flag_SetFlagIntValue(Flags, flag_RFREW, flag_RFREWON);
flag_SetFlagIntValue(Flags, flag_RBREW, flag_RBREWON);
}
if (ana_SORTRES) {
flag_SetFlagIntValue(Flags, flag_SORTS, flag_SORTSMONADICWITHVARIABLE);
flag_SetFlagIntValue(Flags, flag_IEMS, flag_EMPTYSORTON);
flag_SetFlagIntValue(Flags, flag_ISOR, flag_SORTRESOLUTIONON);
flag_SetFlagIntValue(Flags, flag_RSSI, flag_RSSION);
if (!ana_PEQUATIONS || ana_SORTMANYEQUATIONS)
flag_SetFlagIntValue(Flags, flag_RSST, flag_RSSTON);
}
else
flag_SetFlagIntValue(Flags, flag_SORTS, flag_SORTSOFF);
if (ana_MONADIC || ana_NONMONADIC) { /* Problem contains real predicates */
flag_SetFlagIntValue(Flags, flag_IORE, flag_ORDEREDRESOLUTIONNOEQUATIONS);
if (ana_NONHORNCLAUSES > 0)
flag_SetFlagIntValue(Flags, flag_IOFC, flag_FACTORINGONLYRIGHT);
if (ana_NONUNIT)
flag_SetFlagIntValue(Flags, flag_RCON, flag_RCONON);
}
if (!ana_FUNCTIONS)
flag_SetFlagIntValue(Flags, flag_SELECT, flag_SELECTALWAYS);
else
if (ana_NONUNIT)
flag_SetFlagIntValue(Flags, flag_SELECT, flag_SELECTIFSEVERALMAXIMAL);
else
flag_SetFlagIntValue(Flags, flag_SELECT, flag_SELECTOFF);
if (ana_CONCLAUSES < ana_AXIOMCLAUSES || (ana_CONGROUND && !ana_PUREPROPOSITIONAL))
flag_SetFlagIntValue(Flags, flag_SATINPUT, flag_SATINPUTON);
else
flag_SetFlagIntValue(Flags, flag_SATINPUT, flag_SATINPUTOFF);
if (ana_NONHORNCLAUSES > 0)
flag_SetFlagIntValue(Flags, flag_SPLITS, flag_SPLITSUNLIMITED);
else
flag_SetFlagIntValue(Flags, flag_SPLITS, flag_SPLITSOFF);
/* if (ana_PUREPROPOSITIONAL) */
/* flag_SetFlagIntValue(Flags, flag_SPLITHEURISTIC, flag_SPLITHEURISTICALWAYS); */
}
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));
}
