void ProofControlInit(ProofState_p state,ProofControl_p control,
HeuristicParms_p params, FVIndexParms_p fvi_params,
PStack_p wfcb_defs, PStack_p hcb_defs)
{
PStackPointer sp;
Scanner_p in;
assert(control && control->wfcbs);
assert(state && state->axioms && state->signature);
assert(params);
assert(!control->ocb);
assert(!control->hcb);
SpecFeaturesCompute(&(control->problem_specs),
state->axioms,state->signature);
control->ocb = TOSelectOrdering(state, params,
&(control->problem_specs));
in = CreateScanner(StreamTypeInternalString,
DefaultWeightFunctions,
true, NULL);
WeightFunDefListParse(control->wfcbs, in, control->ocb, state);
DestroyScanner(in);
for(sp = 0; sp < PStackGetSP(wfcb_defs); sp++)
{
in = CreateScanner(StreamTypeOptionString,
PStackElementP(wfcb_defs, sp) ,
true, NULL);
WeightFunDefListParse(control->wfcbs, in, control->ocb, state);
DestroyScanner(in);
}
in = CreateScanner(StreamTypeInternalString,
DefaultHeuristics,
true, NULL);
HeuristicDefListParse(control->hcbs, in, control->wfcbs,
control->ocb, state);
DestroyScanner(in);
for(sp = 0; sp < PStackGetSP(hcb_defs); sp++)
{
in = CreateScanner(StreamTypeOptionString,
PStackElementP(hcb_defs, sp) ,
true, NULL);
HeuristicDefListParse(control->hcbs, in, control->wfcbs,
control->ocb, state);
DestroyScanner(in);
}
control->heuristic_parms = *params;
control->fvi_parms = *fvi_params;
control->hcb = GetHeuristic(params->heuristic_name,
state,
control,
params);
if(!control->heuristic_parms.split_clauses)
{
control->fvi_parms.symbol_slack = 0;
}
}
static String ParseEncoding(InStm *stm)
{
Ptr<LexScanner> scanner = CreateScanner(stm);
// skip version
if (scanner->GetToken() != LexScanner::Token(LexScanner::XMLDECL) ||
scanner->GetToken().type_ != LexScanner::VERSION)
{
scanner->Error("XML version error");
}
// check if next is encoding
LexScanner::Token t = scanner->GetToken();
if(t != LexScanner::Token(LexScanner::ENCODING))
return "UTF-8";
// skip '='
if (scanner->GetToken().type_ != LexScanner::EQ)
scanner->Error("XML header: '=' expected");
// next should be string value
t = scanner->GetToken();
if(t.type_ != LexScanner::VALUE)
scanner->Error("XML header: 'value' expected");
return t.s_;
}
void process_formulas(char* infile, TB_p terms, OCB_p ocb, ClauseSet_p *demodulators)
{
WFormula_p form;
Scanner_p in;
if(infile)
{
in = CreateScanner(StreamTypeFile, infile, true, NULL);
ScannerSetFormat(in, parse_format);
while(!TestInpTok(in, NoToken))
{
form = WFormulaParse(in, terms);
WFormulaPrint(GlobalOut, form, true);
form->tformula = TermComputeLINormalform(ocb, terms, form->tformula,
demodulators,
1, false, false);
fprintf(GlobalOut, " ==> ");
WFormulaPrint(GlobalOut, form, true);
fprintf(GlobalOut, "\n");
WFormulaFree(form);
}
DestroyScanner(in);
}
}
bool FileVarsGetIdentifier(FileVars_p vars, char* name, char **value)
{
StrTree_p cell = StrTreeFind(&(vars->vars), name);
Scanner_p in;
if(!cell)
{
return false;
}
in = CreateScanner(StreamTypeInternalString, cell->val1.p_val,
true, NULL);
if(!TestInpTok(in, Identifier))
{
DStr_p errpos = DStrAlloc();
DStrAppendStr(errpos,
"Identifier value requested for file variable ");
DStrAppendStr(errpos, name);
DStrAppendStr(errpos, "read from \"");
DStrAppendStr(errpos, cell->val2.p_val);
DStrAppendStr(errpos,
"\", but no such value present.");
Error(DStrView(errpos), SYNTAX_ERROR);
DStrFree(errpos);
}
DestroyScanner(in);
*value = cell->val1.p_val;
return true;
}
long FileVarsReadFromFile(char* file, FileVars_p vars)
{
long res;
Scanner_p in;
in = CreateScanner(StreamTypeFile, file, true, NULL);
res = FileVarsParse(in, vars);
DestroyScanner(in);
return res;
}
ProofState_p parse_spec(CLState_p state,
IOFormat parse_format,
bool error_on_empty,
FunctionProperties free_symb_prop,
long* ax_no)
{
ProofState_p proofstate;
Scanner_p in;
int i;
StrTree_p skip_includes = NULL;
long parsed_ax_no;
proofstate = ProofStateAlloc(free_symb_prop);
for(i=0; state->argv[i]; i++)
{
in = CreateScanner(StreamTypeFile, state->argv[i], true, NULL);
ScannerSetFormat(in, parse_format);
FormulaAndClauseSetParse(in, proofstate->axioms,
proofstate->f_axioms,
proofstate->original_terms,
NULL,
&skip_includes);
CheckInpTok(in, NoToken);
DestroyScanner(in);
}
VERBOUT2("Specification read\n");
parsed_ax_no = ProofStateAxNo(proofstate);
if(error_on_empty && (parsed_ax_no == 0))
{
#ifdef PRINT_SOMEERRORS_STDOUT
fprintf(GlobalOut, "# Error: Input file contains no clauses or formulas\n");
TSTPOUT(GlobalOut, "InputError");
#endif
Error("Input file contains no clauses or formulas", OTHER_ERROR);
}
*ax_no = parsed_ax_no;
return proofstate;
}
void process_raw_feature_files(char *argv[], SpecLimits_p limits)
{
char *name;
int i;
Scanner_p in;
RawSpecFeatureCell features;
for(i=0; argv[i]; i++)
{
in = CreateScanner(StreamTypeFile, argv[i], true, NULL);
while(!TestInpTok(in, NoToken))
{
name = parse_raw_feature_line(in, &features);
RawSpecFeaturesClassify(&features, limits, raw_mask);
fprintf(GlobalOut, "%s : ", name);
RawSpecFeaturesPrint(GlobalOut, &features);
fprintf(GlobalOut, "\n");
FREE(name);
}
DestroyScanner(in);
}
}
void process_terms(char* infile, TB_p terms, OCB_p ocb, ClauseSet_p *demodulators)
{
Term_p t, tp;
Scanner_p in;
if(infile)
{
in = CreateScanner(StreamTypeFile, infile, true, NULL);
ScannerSetFormat(in, parse_format);
while(!TestInpTok(in, NoToken))
{
t = TBTermParse(in, terms);
tp = TermComputeLINormalform(ocb, terms, t,
demodulators,
1, false, false);
TBPrintTermFull(GlobalOut, terms, t);
fprintf(GlobalOut, " ==> ");
TBPrintTermFull(GlobalOut, terms, tp);
fprintf(GlobalOut, "\n");
}
DestroyScanner(in);
}
}
void process_clauses(char* infile, TB_p terms, OCB_p ocb, ClauseSet_p *demodulators)
{
Clause_p clause;
Scanner_p in;
if(infile)
{
in = CreateScanner(StreamTypeFile, infile, true, NULL);
ScannerSetFormat(in, parse_format);
while(!TestInpTok(in, NoToken))
{
clause = ClauseParse(in, terms);
ClausePrint(GlobalOut, clause, true);
ClauseComputeLINormalform(ocb, terms, clause,
demodulators,
1, false);
fprintf(GlobalOut, " ==> ");
ClausePrint(GlobalOut, clause, true);
fprintf(GlobalOut, "\n");
ClauseFree(clause);
}
DestroyScanner(in);
}
}
int main(int argc, char* argv[])
{
/* Scanner_p in; */
CLState_p state;
Scanner_p in;
PCLProt_p prot;
long steps, proof_steps, neg_steps;
int i;
assert(argv[0]);
InitIO(NAME);
ESignalSetup(SIGTERM);
ESignalSetup(SIGINT);
/* We need consistent name->var mappings here because we
potentially read the compressed input format. */
ClausesHaveLocalVariables = false;
state = process_options(argc, argv);
GlobalOut = OutOpen(outname);
OpenGlobalOut(outname);
prot = PCLProtAlloc();
if(state->argc == 0)
{
CLStateInsertArg(state, "-");
}
steps = 0;
for(i=0; state->argv[i]; i++)
{
in = CreateScanner(StreamTypeFile, state->argv[i], true, NULL);
ScannerSetFormat(in, TPTPFormat);
steps+=PCLProtParse(in, prot);
CheckInpTok(in, NoToken);
DestroyScanner(in);
}
VERBOUT2("PCL input read\n");
PCLProtStripFOF(prot);
PCLProtResetTreeData(prot, false);
PCLProtMarkProofClauses(prot);
PCLProtProofDistance(prot);
PCLProtUpdateGRefs(prot);
proof_steps = PCLProtCountProp(prot, PCLIsProofStep);
neg_steps = proof_steps?neg_proportion*proof_steps:neg_examples;
PCLProtSelectExamples(prot, neg_steps);
fprintf(GlobalOut, "# Axioms:\n");
PCLProtPrintPropClauses(GlobalOut, prot, PCLIsInitial, lop_format);
fprintf(GlobalOut, ".\n\n# Examples:\n");
PCLProtPrintExamples(GlobalOut, prot);
PCLProtFree(prot);
CLStateFree(state);
fflush(GlobalOut);
OutClose(GlobalOut);
ExitIO();
#ifdef CLB_MEMORY_DEBUG
MemFlushFreeList();
MemDebugPrintStats(stdout);
#endif
return EXIT_SUCCESS;
}
int main(int argc, char* argv[])
{
ProofState_p fstate;
Scanner_p in;
int i;
CLState_p state;
SpecFeatureCell features;
SpecLimits_p limits;
StrTree_p skip_includes = NULL;
assert(argv[0]);
InitIO(NAME);
limits = SpecLimitsAlloc();
state = process_options(argc, argv, limits);
OpenGlobalOut(outname);
if(state->argc == 0)
{
CLStateInsertArg(state, "-");
}
if(parse_features)
{
if(raw_classify)
{
process_raw_feature_files(state->argv, limits);
}
else
{
process_feature_files(state->argv, limits);
}
}
else
{
for(i=0; state->argv[i]; i++)
{
fstate = ProofStateAlloc(FPIgnoreProps);
in = CreateScanner(StreamTypeFile, state->argv[i], true, NULL);
ScannerSetFormat(in, parse_format);
FormulaAndClauseSetParse(in, fstate->axioms,
fstate->f_axioms,
fstate->original_terms, NULL, &
skip_includes);
if(raw_classify)
{
do_raw_classification(state->argv[i], fstate, limits);
}
else
{
FormulaSetPreprocConjectures(fstate->f_axioms, fstate->f_ax_archive,
false, false);
FormulaSetCNF(fstate->f_axioms,
fstate->f_ax_archive,
fstate->axioms,
fstate->original_terms,
fstate->freshvars,
fstate->gc_original_terms);
if(!no_preproc)
{
ClauseSetPreprocess(fstate->axioms,
fstate->watchlist,
fstate->archive,
fstate->tmp_terms,
eqdef_incrlimit,
eqdef_maxclauses);
}
SpecFeaturesCompute(&features, fstate->axioms, fstate->signature);
SpecFeaturesAddEval(&features, limits);
if(!tptp_header)
{
fprintf(GlobalOut, "%s : ", state->argv[i]);
SpecFeaturesPrint(GlobalOut, &features);
fprintf(GlobalOut, " : ");
SpecTypePrint(GlobalOut, &features, mask);
fprintf(GlobalOut, "\n");
}
else
{
print_tptp_header(fstate, features);
}
DestroyScanner(in);
ProofStateFree(fstate);
}
}
}
CLStateFree(state);
SpecLimitsCellFree(limits);
fflush(GlobalOut);
OutClose(GlobalOut);
ExitIO();
#ifdef CLB_MEMORY_DEBUG
MemFlushFreeList();
MemDebugPrintStats(stdout);
#endif
return 0;
}
int main(int argc, char* argv[])
{
TB_p terms;
GCAdmin_p collector;
VarBank_p freshvars;
Sig_p sig;
ClauseSet_p clauses;
FormulaSet_p formulas, f_ax_archive;
Scanner_p in;
int i;
CLState_p state;
StrTree_p skip_includes = NULL;
ClauseSet_p demodulators[1];
OCB_p ocb;
assert(argv[0]);
InitIO(NAME);
#ifdef STACK_SIZE
IncreaseMaxStackSize(argv, STACK_SIZE);
#endif
ESignalSetup(SIGXCPU);
state = process_options(argc, argv);
OpenGlobalOut(outname);
if(state->argc == 0)
{
CLStateInsertArg(state, "-");
}
sig = SigAlloc();
SigInsertInternalCodes(sig);
terms = TBAlloc(sig);
collector = GCAdminAlloc(terms);
clauses = ClauseSetAlloc();
formulas = FormulaSetAlloc();
f_ax_archive = FormulaSetAlloc();
GCRegisterClauseSet(collector, clauses);
GCRegisterFormulaSet(collector, formulas);
GCRegisterFormulaSet(collector, f_ax_archive);
for(i=0; state->argv[i]; i++)
{
in = CreateScanner(StreamTypeFile, state->argv[i], true, NULL);
ScannerSetFormat(in, parse_format);
/* ClauseSetParseList(in, clauses, terms); */
FormulaAndClauseSetParse(in,clauses, formulas, terms,
NULL, &skip_includes);
CheckInpTok(in, NoToken);
DestroyScanner(in);
}
CLStateFree(state);
if(FormulaSetPreprocConjectures(formulas, f_ax_archive, false, false))
{
VERBOUT("Negated conjectures.\n");
}
freshvars = VarBankAlloc();
if(FormulaSetCNF(formulas, f_ax_archive,
clauses, terms, freshvars, collector))
{
VERBOUT("CNFization done\n");
}
VarBankFree(freshvars);
GCDeregisterFormulaSet(collector, formulas);
FormulaSetFree(formulas);
GCDeregisterFormulaSet(collector, f_ax_archive);
FormulaSetFree(f_ax_archive);
demodulators[0] = ClauseSetAlloc();
demodulators[0]->demod_index = PDTreeAlloc();
GCRegisterClauseSet(collector, demodulators[0]);
build_rw_system(demodulators[0], clauses);
GCDeregisterClauseSet(collector, clauses);
ClauseSetFree(clauses);
VERBOUT("# Demodulators\n");
VERBOSE(ClauseSetPrint(stderr, demodulators[0], true););
int main(int argc, char* argv[])
{
CLState_p state;
Scanner_p in;
BatchSpec_p spec;
StructFOFSpec_p ctrl;
char *prover = "eprover";
char *category = NULL;
char *train_dir = NULL;
long now, start, res;
assert(argv[0]);
InitIO(NAME);
DocOutputFormat = tstp_format;
OutputFormat = TSTPFormat;
state = process_options(argc, argv);
OpenGlobalOut(outname);
if((state->argc < 1) || (state->argc > 2))
{
Error("Usage: e_ltb_runner <spec> [<path-to-eprover>] \n",
USAGE_ERROR);
}
if(state->argc >= 2)
{
prover = state->argv[1];
}
in = CreateScanner(StreamTypeFile, state->argv[0], true, NULL);
ScannerSetFormat(in, TSTPFormat);
AcceptDottedId(in, "division.category");
category = ParseDottedId(in);
if(TestInpId(in, "division"))
{
AcceptDottedId(in, "division.category.training_directory");
train_dir = ParseContinous(in);
}
while(!TestInpTok(in, NoToken))
{
start = GetSecTime();
spec = BatchSpecParse(in, prover, category, train_dir, TSTPFormat);
/* BatchSpecPrint(GlobalOut, spec); */
if(total_wtc_limit && !spec->total_wtc_limit)
{
spec->total_wtc_limit = total_wtc_limit;
}
if(spec->per_prob_limit<=0 && total_wtc_limit<=0)
{
Error("Either the per-problem time limit or the global "
"time limit must be set to a value > 0", USAGE_ERROR);
}
/* BatchSpecPrint(stdout, spec); */
ctrl = StructFOFSpecAlloc();
BatchStructFOFSpecInit(spec, ctrl);
now = GetSecTime();
res = BatchProcessProblems(spec, ctrl, MAX(0,total_wtc_limit-(now-start)));
now = GetSecTime();
fprintf(GlobalOut, "\n\n# == WCT: %4lds, Solved: %4ld/%4d ==\n",
now-start, res, BatchSpecProblemNo(spec));
if(interactive)
{
BatchProcessInteractive(spec, ctrl, stdout);
}
StructFOFSpecFree(ctrl);
BatchSpecFree(spec);
fprintf(GlobalOut, "# =============== Batch done ===========\n\n");
}
DestroyScanner(in);
if(category)
{
FREE(category);
}
if(train_dir)
{
FREE(train_dir);
}
CLStateFree(state);
OutClose(GlobalOut);
ExitIO();
#ifdef CLB_MEMORY_DEBUG
MemFlushFreeList();
MemDebugPrintStats(stdout);
#endif
return 0;
}
int main(int argc, char* argv[])
{
CLState_p state;
StructFOFSpec_p ctrl;
PStack_p prob_names = PStackAlloc();
int i;
AxFilterSet_p filters;
Scanner_p in;
DStr_p corename;
char *tname;
assert(argv[0]);
InitIO(NAME);
DocOutputFormat = tstp_format;
OutputFormat = TSTPFormat;
state = process_options(argc, argv);
OpenGlobalOut(outname);
if(filtername)
{
filters = AxFilterSetAlloc();
in = CreateScanner(StreamTypeFile, filtername, true, NULL);
AxFilterSetParse(in, filters);
DestroyScanner(in);
}
else
{
filters = AxFilterSetCreateInternal(AxFilterDefaultSet);
}
if(dumpfilter)
{
AxFilterSetPrint(GlobalOut, filters);
}
if(state->argc < 1)
{
Error("Usage: e_axfilter <problem> [<options>]\n", USAGE_ERROR);
}
for(i=0; state->argv[i]; i++)
{
PStackPushP(prob_names, state->argv[i]);
}
/* Base name is the stripped base of the first argument */
tname = FileNameStrip(state->argv[0]);
corename = DStrAlloc();
DStrAppendStr(corename, tname);
FREE(tname);
ctrl = StructFOFSpecAlloc();
StructFOFSpecParseAxioms(ctrl, prob_names, parse_format);
StructFOFSpecInitDistrib(ctrl);
StructFOFSpecResetShared(ctrl);
for(i=0; i<AxFilterSetElements(filters); i++)
{
/* SigPrint(stdout,ctrl->sig); */
filter_problem(ctrl,
AxFilterSetGetFilter(filters,i),
DStrView(corename));
}
StructFOFSpecFree(ctrl);
DStrFree(corename);
AxFilterSetFree(filters);
CLStateFree(state);
PStackFree(prob_names);
OutClose(GlobalOut);
ExitIO();
#ifdef CLB_MEMORY_DEBUG
MemFlushFreeList();
MemDebugPrintStats(stdout);
#endif
return 0;
}
