Ubuntu Manpage: E - manual page for E 3.2.5 Puttabong Moondrop (69a471a3f67fbd0e9686e497131291f452c2176c)

NAME

       E - manual page for E 3.2.5 Puttabong Moondrop (69a471a3f67fbd0e9686e497131291f452c2176c)

SYNOPSIS

       eprover [options] [files]

DESCRIPTION

       E 3.2.5 "Puttabong Moondrop"

       Read  a set of first-order (or, in the -ho-version, higher-order) clauses and formulae and
       try to prove the conjecture (if given) or show the set unsatisfiable.

OPTIONS

-h

--help

Print a short description of program usage and options.

-V

--version

Print the version number of the prover. Please include this with all bug reports
(if any).

-v

--verbose[=<arg>]

Verbose comments on the progress of the program. This differs from the output level
(below) in that technical information is printed to stderr, while the output level
determines which logical manipulations of the clauses are printed to stdout. The
short form or the long form without the optional argument is equivalent to
--verbose=1.

-o <arg>

--output-file=<arg>

Redirect output into the named file.

-s

--silent

Equivalent to --output-level=0.

-l <arg>

--output-level=<arg>

Select an output level, greater values imply more verbose output. Level 0 produces
nearly no output, level 1 will output each clause as it is processed, level 2 will
output generating inferences, level 3 will give a full protocol including rewrite
steps and level 4 will include some internal clause renamings. Levels >= 2 also
imply PCL2 or TSTP formats (which can be post-processed with suitable tools).

-p

--proof-object[=<arg>]

Generate (and print, in case of success) an internal proof object. Level 0 will not
print a proof object, level 1 will build asimple, compact proof object that only
contains inference rules and dependencies, level 2 will build a proof object where
inferences are unambiguously described by giving inference positions, and level 3
will expand this to a proof object where all intermediate results are explicit.
This feature is under development, so far only level 0 and 1 are operational. The
proof object will be provided in TPTP-3 or PCL syntax, depending on input format
and explicit settings. The --proof-graph option will suppress normal output of the
proof object in favour of a graphial representation. The short form or the long
form without the optional argument is equivalent to --proof-object=1.

--proof-graph[=<arg>]

Generate (and print, in case of success) an internal proof object in the form of a
GraphViz dot graph. The optional argument can be 1 (nodes are labelled with just
the name of the clause/formula), 2 (nodes are labelled with the TPTP
clause/formula) or 3 (nodes also labelled with source/inference record. The option
without the optional argument is equivalent to --proof-graph=3.

--proof-statistics

Print various statistics of the proof object.

-d

--full-deriv

Include all derived formuas/clauses in the proof graph/proof object, not just the
ones contributing to the actual proof.

--force-deriv[=<arg>]

Force output of the derivation even in cases where the prover terminates in an
indeterminate state. By default, the deriviation of all processed clauses is
included in the derivation object. With argument 2, the derivation of all clauses
will be printed. The option without the optional argument is equivalent to
--force-deriv=1.

--record-gcs

Record given-clause selection as separate (pseudo-)inferences and preserve the form
of given clauses evaluated and selected via archiving for analysis and possibly
machine learning.

--training-examples[=<arg>]

Generate and process training examples from the proof search object. Implies
--record-gcs. The argument is a binary or of the desired processing. Bit zero
prints positive exampels. Bit 1 prints negative examples. Additional selectors will
be added later. The option without the optional argument is equivalent to
--training-examples=1.

--pcl-terms-compressed

Print terms in the PCL output in shared representation.

--pcl-compact

Print PCL steps without additional spaces for formatting (safes disk space for
large protocols).

--pcl-shell-level[=<arg>]

Determines level to which clauses and formulas are suppressed in the output. Level
0 will print all, level 1 will only print initial clauses/formulas, level 2 will
print no clauses or axioms. All levels will still print the dependency graph. The
option without the optional argument is equivalent to --pcl-shell-level=1.

--print-statistics

Print the inference statistics (only relevant for output level <=1, otherwise they
are printed automatically.

-0

--print-detailed-statistics

Print data about the proof state that is potentially expensive to collect. Includes
number of term cells and number of rewrite steps. This implies the previous option.

-S

--print-saturated[=<arg>]

Print the (semi-) saturated clause sets after terminating the saturation process.
The argument given describes which parts should be printed in which order. Legal
characters are 'teigEIGaA', standing for type declarations, processed positive
units, processed negative units, processed non-units, unprocessed positive units,
unprocessed negative units, unprocessed non-units, and two types of additional
equality axioms, respectively. Equality axioms will only be printed if the original
specification contained real equality. In this case, 'a' requests axioms in which a
separate substitutivity axiom is given for each argument position of a function or
predicate symbol, while 'A' requests a single substitutivity axiom (covering all
positions) for each symbol. The short form or the long form without the optional
argument is equivalent to --print-saturated=eigEIG.

--print-sat-info

Print additional information (clause number, weight, etc) as a comment for clauses
from the semi-saturated end system.

--filter-saturated[=<arg>]

Filter the
(semi-) saturated clause sets after terminating the

saturation process. The argument is a string describing which operations to take
(and in which order). Options are 'u' (remove all clauses with more than one
literal), 'c' (delete all but one copy of identical clauses, 'n', 'r', 'f' (forward
contraction, unit-subsumption only, no rewriting, rewriting with rules only, full
rewriting, respectively), and 'N', 'R' and 'F' (as their lower case counterparts,
but with non-unit-subsumption enabled as well). The option without the optional
argument is equivalent to --filter-saturated=Fc.

--syntax-only

Stop after parsing, i.e. only check if the input can be parsed correcly.

--prune

Stop after relevancy pruning, SInE pruning, and output of the initial clause- and
formula set. This will automatically set output level to 4 so that the pruned
problem specification is printed. Note that the desired pruning methods must still
be specified (e.g. '--sine=Auto').

--cnf

Convert the input problem into clause normal form and print it. This is (nearly)
equivalent to '--print-saturated=eigEIG --processed-clauses-limit=0' and will by
default perform some usually useful simplifications. You can additionally specify
e.g. '--no-preprocessing' if you want just the result of CNF translation.

--print-pid

Print the process id of the prover as a comment after option processing.

--print-version

Print the version number of the prover as a comment after option processing. Note
that unlike -version, the prover will not terminate, but proceed normally.

--error-on-empty

Return with an error code if the input file contains no clauses. Formally, the
empty clause set (as an empty conjunction of clauses) is trivially satisfiable, and
E will treat any empty input set as satisfiable. However, in composite systems this
is more often a sign that something went wrong. Use this option to catch such bugs.

-m <arg>

--memory-limit=<arg>

Limit the memory the prover may use. The argument is the allowed amount of memory
in MB. If you use the argument 'Auto', the system will try to figure out the amount
of physical memory of your machine and claim most of it. This option may not work
everywhere, due to broken and/or strange behaviour of setrlimit() in some UNIX
implementations, and due to the fact that I know of no portable way to figure out
the physical memory in a machine. Both the option and the 'Auto' version do work
under all tested versions of Solaris and GNU/Linux. Due to problems with limit data
types, it is currently impossible to set a limit of more than 2 GB (2048 MB).

--cpu-limit[=<arg>]

Limit the (per core) cpu time the prover should run. The optional argument is the
CPU time in seconds. The prover will terminate immediately after reaching the time
limit, regardless of internal state. As a side effect, this option will inhibit
core file writing. Please note that if you use both --cpu-limit and
--soft-cpu-limit, the soft limit has to be smaller than the hard limit to have any
effect. The option without the optional argument is equivalent to --cpu-limit=300.

--soft-cpu-limit[=<arg>]

Limit the cpu time the prover should spend in the main saturation phase. The
prover will then terminate gracefully, i.e. it will perform post-processing,
filtering and printing of unprocessed clauses, if these options are selected. Note
that for some filtering options (in particular those which perform full
subsumption), the post-processing time may well be larger than the saturation time.
This option is particularly useful if you want to use E as a preprocessor or lemma
generator in a larger system. The option without the optional argument is
equivalent to --soft-cpu-limit=290.

-R

--resources-info

Give some information about the resources used by the prover. You will usually get
CPU time information. On systems returning more information with the rusage()
system call, you will also get information about memory consumption.

--select-strategy=<arg>

Select one of the built-in strategies and set all proof search parameters
accordingly.

--print-strategy[=<arg>]

Print a representation of all search parameters and their setting of a given
strategy, then terminate. If no argument is given, the current strategy is printed.
Use the reserved name '>all-strats<'to get a description of all built-in
strategies, '>all-names<' to get a list of all names of strategies. The option
without the optional argument is equivalent to --print-strategy=>current-strategy<.

--parse-strategy=<arg>

Parse the previously printed representation of strategy and set all proof search
parameters accordingly.

-C <arg>

--processed-clauses-limit=<arg>

Set the maximal number of clauses to process (i.e. the number of traversals of the
main-loop).

-P <arg>

--processed-set-limit=<arg>

Set the maximal size of the set of processed clauses. This differs from the
previous option in that redundant and back-simplified processed clauses are not
counted.

-U <arg>

--unprocessed-limit=<arg>

Set the maximal size of the set of unprocessed clauses. This is a termination
condition, not something to use to control the deletion of bad clauses. Compare
--delete-bad-limit.

-T <arg>

--total-clause-set-limit=<arg>

Set the maximal size of the set of all clauses. See previous option.

--generated-limit=<arg>

Set the maximal number of generated clauses before the proof search stops. This is
a reasonable (though not great) estimate of the work done.

--tb-insert-limit=<arg>

Set the maximal number of of term bank term top insertions. This is a reasonable
(though not great) estimate of the work done.

--answers[=<arg>]

Set the maximal number of answers to print for existentially quantified questions.
Without this option, the prover terminates after the first answer found. If the
value is different from 1, the prover is no longer guaranteed to terminate, even if
there is a finite number of answers. The option without the optional argument is
equivalent to --answers=2147483647.

--conjectures-are-questions

Treat all conjectures as questions to be answered. This is a wart necessary because
CASC-J6 has categories requiring answers, but does not yet support the 'question'
type for formulas.

-n

--eqn-no-infix

In LOP, print equations in prefix notation equal(x,y).

-e

--full-equational-rep

In LOP. print all literals as equations, even non-equational ones.

--lop-in

Set E-LOP as the input format. If no input format is selected by this or one of the
following options, E will guess the input format based on the first token. It will
almost always correctly recognize TPTP-3, but it may misidentify E-LOP files that
use TPTP meta-identifiers as logical symbols.

--pcl-out

Set PCL as the proof object output format.

--tptp-in

Set TPTP-2 as the input format (but note that includes are still handled according
to TPTP-3 semantics).

--tptp-out

Print TPTP format instead of E-LOP. Implies --eqn-no-infix and will ignore
--full-equational-rep.

--tptp-format

Equivalent to --tptp-in and --tptp-out.

--tptp2-in

Synonymous with --tptp-in.

--tptp2-out

Synonymous with --tptp-out.

--tptp2-format

Synonymous with --tptp-format.

--tstp-in

Set TPTP-3 as the input format TPTP-3 syntax is still under development, and any
given version in E may not be fully conforming at all times. E works on all TPTP
8.2.0 FOF and CNF files (including includes).

--tstp-out

Print output clauses in TPTP-3 syntax. In particular, for output levels >=2, write
derivations as TPTP-3 derivations.

--tstp-format

Equivalent to --tstp-in and --tstp-out.

--tptp3-in

Synonymous with --tstp-in.

--tptp3-out

Synonymous with --tstp-out.

--tptp3-format

Synonymous with --tstp-format.

--auto

Automatically determine settings for proof search.

--auto-schedule[=<arg>]

Use the (experimental) strategy scheduling. This will try several different fully
specified search strategies (aka "Auto-Modes"), one after the other, until a proof
or saturation is found, or the time limit is exceeded. The optional argument is the
number of CPUs on which the schedule is going to be executed on. By default, the
schedule is executed on a single core. To execute on all cores of a system, set the
argument to 'Auto', but note that this will use all reported cores (even
low-performance efficiency cores, if available on the hardware platform and
reported by the OS). The option without the optional argument is equivalent to
--auto-schedule=1.

--force-preproc-sched=<arg>

When autoscheduling is used, make sure that preprocessing schedule is inserted in
the search categories

--serialize-schedule=<arg>

Convert parallel auto-schedule into serialized one.

--satauto-schedule[=<arg>]

Use strategy scheduling without SInE, thus maintaining completeness. The option
without the optional argument is equivalent to --satauto-schedule=1.

--no-preprocessing

Do not perform preprocessing on the initial clause set. Preprocessing currently
removes tautologies and orders terms, literals and clauses in a certain
("canonical") way before anything else happens. Unless limited by one of the
following options, it will also unfold equational definitions.

--eq-unfold-limit=<arg>

During preprocessing, limit unfolding (and removing) of equational definitions to
those where the expanded definition is at most the given limit bigger (in terms of
standard weight) than the defined term.

--eq-unfold-maxclauses=<arg>

During preprocessing, don't try unfolding of equational definitions if the problem
has more than this limit of clauses.

--no-eq-unfolding

During preprocessing, abstain from unfolding (and removing) equational definitions.

--goal-defs[=<arg>]

Introduce Twee-style equational definitions for ground terms in conjecture clauses.
The argument can be All or Neg, which will only consider ground terms from negative
literals (to be implemented). The option without the optional argument is
equivalent to --goal-defs=All.

--goal-subterm-defs

Introduce goal definitions for all conjecture ground subterms. The default is to
only introduce them for the maximal (with respect to the subterm relation) ground
terms in conjecture clauses (to be implemented).

--sine[=<arg>]

Apply SInE to prune the unprocessed axioms with the specified filter. 'Auto' will
automatically pick a filter. The option without the optional argument is equivalent
to --sine=Auto.

--rel-pruning-level[=<arg>]

Perform relevancy pruning up to the given level on the unprocessed axioms. The
option without the optional argument is equivalent to --rel-pruning-level=3.

--presat-simplify[=<arg>]

Before proper saturation do a complete interreduction of the proof state. The
option without the optional argument is equivalent to --presat-simplify=true.

--ac-handling[=<arg>]

Select AC handling mode, i.e. determine what to do with redundant AC tautologies.
The default is equivalent to 'DiscardAll', the other possible values are 'None' (to
disable AC handling), 'KeepUnits', and 'KeepOrientable'. The option without the
optional argument is equivalent to --ac-handling=KeepUnits.

--ac-non-aggressive

Do AC resolution on negative literals only on processing (by default, AC resolution
is done after clause creation). Only effective if AC handling is not disabled.

-W <arg>

--literal-selection-strategy=<arg>

Choose a strategy for selection of negative literals. There are two special values
for this option: NoSelection will select no literal (i.e. perform normal
superposition) and NoGeneration will inhibit all generating inferences. For a list
of the other (hopefully self-documenting) values run 'eprover -W none'. There are
two variants of each strategy. The one prefixed with 'P' will allow paramodulation
into maximal positive literals in addition to paramodulation into maximal selected
negative literals.

--no-generation

Don't perform any generating inferences (equivalent to
--literal-selection-strategy=NoGeneration).

--select-on-processing-only

Perform literal selection at processing time only (i.e. select only in the _given
clause_), not before clause evaluation. This is relevant because many clause
selection heuristics give special consideration to maximal or selected literals.

-i

--inherit-paramod-literals

Always select the negative literals a previous inference paramodulated into (if
possible). If no such literal exists, select as dictated by the selection strategy.

-j

--inherit-goal-pm-literals

In a goal (all negative clause), always select the negative literals a previous
inference paramodulated into (if possible). If no such literal exists, select as
dictated by the selection strategy.

--inherit-conjecture-pm-literals

In a conjecture-derived clause, always select the negative literals a previous
inference paramodulated into (if possible). If no such literal exists, select as
dictated by the selection strategy.

--selection-pos-min=<arg>

Set a lower limit for the number of positive literals a clause must have to be
eligible for literal selection.

--selection-pos-max=<arg>

Set a upper limit for the number of positive literals a clause can have to be
eligible for literal selection.

--selection-neg-min=<arg>

Set a lower limit for the number of negative literals a clause must have to be
eligible for literal selection.

--selection-neg-max=<arg>

Set a upper limit for the number of negative literals a clause can have to be
eligible for literal selection.

--selection-all-min=<arg>

Set a lower limit for the number of literals a clause must have to be eligible for
literal selection.

--selection-all-max=<arg>

Set an upper limit for the number of literals a clause must have to be eligible for
literal selection.

--selection-weight-min=<arg>

Set the minimum weight a clause must have to be eligible for literal selection.

--prefer-initial-clauses

Always process all initial clauses first.

-x <arg>

--expert-heuristic=<arg>

Select one of the clause selection heuristics. Currently at least available: Auto,
Weight, StandardWeight, RWeight, FIFO, LIFO, Uniq, UseWatchlist. For a full list
check HEURISTICS/che_proofcontrol.c. Auto is recommended if you only want to find a
proof. It is special in that it will also set some additional options. To have
optimal performance, you also should specify -tAuto to select a good term ordering.
LIFO is unfair and will make the prover incomplete. Uniq is used internally and is
not very useful in most cases. You can define more heuristics using the option -H
(see below).

--filter-orphans-limit[=<arg>]

Orphans are unprocessed clauses where one of the parents has been removed by
back-simolification. They are redundant and usually removed lazily (i.e. only when
they are selected for processing). With this option you can select a limit on
back-simplified clauses after which orphans will be eagerly deleted. The option
without the optional argument is equivalent to --filter-orphans-limit=100.

--forward-contract-limit[=<arg>]

Set a limit on the number of processed clauses after which the unprocessed clause
set will be re-simplified and reweighted. The option without the optional argument
is equivalent to --forward-contract-limit=80000.

--delete-bad-limit[=<arg>]

Set the number of storage units after which bad clauses are deleted without further
consideration. This causes the prover to be potentially incomplete, but will allow
you to limit the maximum amount of memory used fairly well. The prover will tell
you if a proof attempt failed due to the incompleteness introduced by this option.
It is recommended to set this limit significantly higher than --filter-limit or
--filter-copies-limit. If you select -xAuto and set a memory limit, the prover will
determine a good value automatically. The option without the optional argument is
equivalent to --delete-bad-limit=1500000.

--assume-completeness

There are various way (e.g. the next few options) to configure the prover to be
strongly incomplete in the general case. E will detect when such an option is
selected and return corresponding exit states (i.e. it will not claim
satisfiability just because it ran out of unprocessed clauses). If you _know_ that
for your class of problems the selected strategy is still complete, use this option
to tell the system that this is the case.

--assume-incompleteness

This option instructs the prover to assume incompleteness (typically because the
axiomatization already is incomplete because axioms have been filtered before they
are handed to the system.

--disable-eq-factoring

Disable equality factoring. This makes the prover incomplete for general non-Horn
problems, but helps for some specialized classes. It is not necessary to disable
equality factoring for Horn problems, as Horn clauses are not factored anyways.

--disable-paramod-into-neg-units

Disable paramodulation into negative unit clause. This makes the prover incomplete
in the general case, but helps for some specialized classes.

--condense

Enable condensing for the given clause. Condensing replaces a clause by a more
general factor (if such a factor exists).

--condense-aggressive

Enable condensing for the given and newly generated clauses.

--disable-given-clause-fw-contraction

Disable simplification and subsumption of the newly selected given clause (clauses
are still simplified when they are generated). In general, this breaks some basic
assumptions of the DISCOUNT loop proof search procedure. However, there are some
problem classes in which this simplifications empirically never occurs. In such
cases, we can save significant overhead. The option _should_ work in all cases, but
is not expected to improve things in most cases.

--simul-paramod

Use simultaneous paramodulation to implement superposition. Default is to use plain
paramodulation.

--oriented-simul-paramod

Use simultaneous paramodulation for oriented from-literals. This is an experimental
feature.

--supersimul-paramod

Use supersimultaneous paramodulation to implement superposition. Default is to use
plain paramodulation.

--oriented-supersimul-paramod

Use supersimultaneous paramodulation for oriented from-literals. This is an
experimental feature.

--split-clauses[=<arg>]

Determine which clauses should be subject to splitting. The argument is the binary
'OR' of values for the desired classes:

1: Horn clauses

2: Non-Horn clauses

4: Negative clauses

8: Positive clauses

16: Clauses with both positive and negative literals

Each set bit adds that class to the set of clauses which will be split. The option
without the optional argument is equivalent to --split-clauses=7.

--split-method=<arg>

Determine how to treat ground literals in splitting. The argument is either '0' to
denote no splitting of ground literals (they are all assigned to the first split
clause produced), '1' to denote that all ground literals should form a single new
clause, or '2', in which case ground literals are treated as usual and are all
split off into individual clauses.

--split-aggressive

Apply splitting to new clauses (after simplification) and before evaluation. By
default, splitting (if activated) is only performed on selected clauses.

--split-reuse-defs

If possible, reuse previous definitions for splitting.

--disequality-decomposition[=<arg>]

Enable the disequality decomposition inference. The optional argument is the
maximal literal number of clauses considered for the inference. The option without
the optional argument is equivalent to --disequality-decomposition=1024.

--disequality-decomp-maxarity[=<arg>]

Limit disequality decomposition to function symbols of at most the given arity. The
option without the optional argument is equivalent to
--disequality-decomp-maxarity=1.

-t <arg>

--term-ordering=<arg>

Select an ordering type (currently Auto, LPO, LPO4, KBO or KBO6). -tAuto is
suggested, in particular with -xAuto. KBO and KBO6 are different implementations of
the same ordering, KBO6 is usually faster and has had more testing. Similarly, LPO4
is a new, equivalent but superior implementation of LPO.

-w <arg>

--order-weight-generation=<arg>

Select a method for the generation of weights for use with the term ordering. Run
'eprover -w none' for a list of options.

--order-weights=<arg>

Describe a (partial) assignments of weights to function symbols for term orderings
(in particular, KBO). You can specify a list of weights of the form 'f1:w1,f2:w2,
...'. Since a total weight assignment is needed, E will _first_ apply any weight
generation scheme specified (or the default one), and then modify the weights as
specified. Note that E performs only very basic sanity checks, so you probably can
specify weights that break KBO constraints.

-G <arg>

--order-precedence-generation=<arg>

Select a method for the generation of a precedence for use with the term ordering.
Run 'eprover -G none' for a list of options.

--prec-pure-conj[=<arg>]

Set a weight for symbols that occur in conjectures only to determinewhere to place
it in the precedence. This value is used for a roughpre-order, the normal schemes
only sort within symbols with the sameoccurrence modifier. The option without the
optional argument is equivalent to --prec-pure-conj=10.

--prec-conj-axiom[=<arg>]

Set a weight for symbols that occur in both conjectures and axiomsto determine
where to place it in the precedence. This value is used for a rough pre-order, the
normal schemes only sort within symbols with the same occurrence modifier. The
option without the optional argument is equivalent to --prec-conj-axiom=5.

--prec-pure-axiom[=<arg>]

Set a weight for symbols that occur in axioms only to determine where to place it
in the precedence. This value is used for a rough pre-order, the normal schemes
only sort within symbols with the same occurrence modifier. The option without the
optional argument is equivalent to --prec-pure-axiom=2.

--prec-skolem[=<arg>]

Set a weight for Skolem symbols to determine where to place it in the precedence.
This value is used for a rough pre-order, the normal schemes only sort within
symbols with the same occurrence modifier. The option without the optional argument
is equivalent to --prec-skolem=2.

--prec-defpred[=<arg>]

Set a weight for introduced predicate symbols (usually via definitional CNF or
clause splitting) to determine where to place it in the precedence. This value is
used for a rough pre-order, the normal schemes only sort within symbols with the
same occurrence modifier. The option without the optional argument is equivalent to
--prec-defpred=2.

-c <arg>

--order-constant-weight=<arg>

Set a special weight > 0 for constants in the term ordering. By default, constants
are treated like other function symbols.

--precedence[=<arg>]

Describe a (partial) precedence for the term ordering used for the proof attempt.
You can specify a comma-separated list of precedence chains, where a precedence
chain is a list of function symbols (which all have to appear in the proof
problem), connected by >, <, or =. If this option is used in connection with
--order-precedence-generation, the partial ordering will be completed using the
selected method, otherwise the prover runs with a non-ground-total ordering. The
option without the optional argument is equivalent to --precedence=.

--lpo-recursion-limit[=<arg>]

Set a depth limit for LPO comparisons. Most comparisons do not need more than 10 or
20 levels of recursion. By default, recursion depth is limited to 1000 to avoid
stack overflow problems. If the limit is reached, the prover assumes that the terms
are uncomparable. Smaller values make the comparison attempts faster, but less
exact. Larger values have the opposite effect. Values up to 20000 should be save on
most operating systems. If you run into segmentation faults while using LPO or
LPO4, first try to set this limit to a reasonable value. If the problem persists,
send a bug report ;-) The option without the optional argument is equivalent to
--lpo-recursion-limit=100.

--restrict-literal-comparisons

Make all literals uncomparable in the term ordering (i.e. do not use the term
ordering to restrict paramodulation, equality resolution and factoring to certain
literals. This is necessary to make Set-of-Support-strategies complete for the
non-equational case (It still is incomplete for the equational case, but pretty
useless anyways).

--literal-comparison=<arg>

Modify how literal comparisons are done. 'None' is equivalent to the previous
option, 'Normal' uses the normal lifting of the term ordering, 'TFOEqMax' uses the
equivalent of a transfinite ordering deciding on the predicate symbol and making
equational literals maximal (note that this setting makes the prover incomplere),
and 'TFOEqMin' modifies this by making equational symbols minimal.

--sos-uses-input-types

If input is TPTP format, use TPTP conjectures for initializing the Set of Support.
If not in TPTP format, use E-LOP queries (clauses of the form ?-l(X),...,m(Y)).
Normally, all negative clauses are used. Please note that most E heuristics do not
use this information at all, it is currently only useful for certain parameter
settings (including the SimulateSOS priority function).

--destructive-er

Allow destructive equality resolution inferences on pure-variable literals of the
form X!=Y, i.e. replace the original clause with the result of an equality
resolution inference on this literal.

--strong-destructive-er

Allow destructive equality resolution inferences on literals of the form X!=t
(where X does not occur in t), i.e. replace the original clause with the result of
an equality resolution inference on this literal. Unless I am brain-dead, this
maintains completeness, although the proof is rather tricky.

--destructive-er-aggressive

Apply destructive equality resolution to all newly generated clauses, not just to
selected clauses. Implies --destructive-er.

--forward-context-sr

Apply contextual simplify-reflect with processed clauses to the given clause.

--forward-context-sr-aggressive

Apply contextual simplify-reflect with processed clauses to new clauses. Implies
--forward-context-sr.

--backward-context-sr

Apply contextual simplify-reflect with the given clause to processed clauses.

-g

--prefer-general-demodulators

Prefer general demodulators. By default, E prefers specialized demodulators. This
affects in which order the rewrite index is traversed.

-F <arg>

--forward-demod-level=<arg>

Set the desired level for rewriting of unprocessed clauses. A value of 0 means no
rewriting, 1 indicates to use rules (orientable equations) only, 2 indicates full
rewriting with rules and instances of unorientable equations. Default behavior is
2.

--demod-under-lambda=<arg>

Demodulate *closed* subterms under lambdas.

--strong-rw-inst

Instantiate unbound variables in matching potential demodulators with a small
constant terms.

-u

--strong-forward-subsumption

Try multiple positions and unit-equations to try to equationally subsume a single
new clause. Default is to search for a single position.

--satcheck-proc-interval[=<arg>]

Enable periodic SAT checking at the given interval of main loop non-trivial
processed clauses. The option without the optional argument is equivalent to
--satcheck-proc-interval=5000.

--satcheck-gen-interval[=<arg>]

Enable periodic SAT checking whenever the total proof state size increases by the
given limit. The option without the optional argument is equivalent to
--satcheck-gen-interval=10000.

--satcheck-ttinsert-interval[=<arg>]

Enable periodic SAT checking whenever the number of term tops insertions matches
the given limit (which grows exponentially). The option without the optional
argument is equivalent to --satcheck-ttinsert-interval=5000000.

--satcheck[=<arg>]

Set the grounding strategy for periodic SAT checking. Note that to enable SAT
checking, it is also necessary to set the interval with one of the previous two
options. The option without the optional argument is equivalent to
--satcheck=FirstConst.

--satcheck-decision-limit[=<arg>]

Set the number of decisions allowed for each run of the SAT solver. If the option
is not given, the built-in value is 10000. Use -1 to allow unlimited decision. The
option without the optional argument is equivalent to
--satcheck-decision-limit=100.

--satcheck-normalize-const

Use the current normal form (as recorded in the termbank rewrite cache) of the
selected constant as the term for the grounding substitution.

--satcheck-normalize-unproc

Enable re-simplification (heuristic re-revaluation) of unprocessed clauses before
grounding for SAT checking.

--watchlist[=<arg>]

Give the name for a file containing clauses to be watched for during the saturation
process. If a clause is generated that subsumes a watchlist clause, the subsumed
clause is removed from the watchlist. The prover will terminate when the watchlist
is empty. If you want to use the watchlist for guiding the proof, put the empty
clause onto the list and use the built-in clause selection heuristic 'UseWatchlist'
(or build a heuristic yourself using the priority functions 'PreferWatchlist' and
'DeferWatchlist'). Use the argument 'Use inline watchlist type' (or no argument)
and the special clause type 'watchlist' if you want to put watchlist clauses into
the normal input stream. This is only supported for TPTP input formats. The option
without the optional argument is equivalent to --watchlist='Use inline watchlist
type'.

--static-watchlist[=<arg>]

This is identical to the previous option, but subsumed clauses willnot be removed
from the watchlist (and hence the prover will not terminate if all watchlist
clauses have been subsumed. This may be more useful for heuristic guidance. The
option without the optional argument is equivalent to --static-watchlist='Use
inline watchlist type'.

--no-watchlist-simplification

By default, the watchlist is brought into normal form with respect to the current
processed clause set and certain simplifications. This option disables
simplification for the watchlist.

--fw-subsumption-aggressive

Perform forward subsumption on newly generated clauses before they are evaluated.
This is particularly useful if heuristic evaluation is very expensive, e.g. via
externally connected neural networks.

--conventional-subsumption

Equivalent to --subsumption-indexing=None.

--subsumption-indexing=<arg>

Determine choice of indexing for (most) subsumption operations. Choices are 'None'
for naive subsumption, 'Direct' for direct mapped FV-Indexing, 'Perm' for permuted
FV-Indexing and 'PermOpt' for permuted FV-Indexing with deletion of (suspected)
non-informative features. Default behaviour is 'Perm'.

--fvindex-featuretypes=<arg>

Select the feature types used for indexing. Choices are "None" to disable
FV-indexing, "AC" for AC compatible features (the default) (literal number and
symbol counts), "SS" for set subsumption compatible features (symbol depth), and
"All" for all features.Unless you want to measure the effects of the different
features, I suggest you stick with the default.

--fvindex-maxfeatures[=<arg>]

Set the maximum initial number of symbols for feature computation. Depending on
the feature selection, a value of X here will convert into 2X+2 features (for set
subsumption features), 2X+4 features (for AC-compatible features) or 4X+6 features
(if all features are used, the default). Note that the actually used set of
features may be smaller than this if the signature does not contain enough
symbols.For the Perm and PermOpt version, this is _also_ used to set the maximum
depth of the feature vector index. Yes, I should probably make this into two
separate options. If you select a small value here, you should probably not use
"Direct" for the --subsumption-indexing option. The option without the optional
argument is equivalent to --fvindex-maxfeatures=200.

--fvindex-slack[=<arg>]

Set the number of slots reserved in the index for function symbols that may be
introduced into the signature later, e.g. by splitting. If no new symbols are
introduced, this just wastes time and memory. If PermOpt is chosen, the slackness
slots will be deleted from the index anyways, but will still waste (a little) time
in computing feature vectors. The option without the optional argument is
equivalent to --fvindex-slack=0.

--rw-bw-index[=<arg>]

Select fingerprint function for backwards rewrite index. "NoIndex" will disable
paramodulation indexing. For a list of the other values run 'eprover
--pm-index=none'. FPX functions will use a fingerprint of X positions, the letters
disambiguate between different fingerprints with the same sample size. The option
without the optional argument is equivalent to --rw-bw-index=FP7.

--pm-from-index[=<arg>]

Select fingerprint function for the index for paramodulation from indexed clauses.
"NoIndex" will disable paramodulation indexing. For a list of the other values run
'eprover --pm-index=none'. FPX functionswill use a fingerprint of X positions, the
letters disambiguate between different fingerprints with the same sample size. The
option without the optional argument is equivalent to --pm-from-index=FP7.

--pm-into-index[=<arg>]

Select fingerprint function for the index for paramodulation into the indexed
clauses. "NoIndex" will disable paramodulation indexing. For a list of the other
values run 'eprover --pm-index=none'. FPX functionswill use a fingerprint of X
positions, the letters disambiguate between different fingerprints with the same
sample size. The option without the optional argument is equivalent to
--pm-into-index=FP7.

--fp-index[=<arg>]

Select fingerprint function for all fingerprint indices. See above. The option
without the optional argument is equivalent to --fp-index=FP7.

--fp-no-size-constr

Disable usage of size constraints for matching with fingerprint indexing.

--pdt-no-size-constr

Disable usage of size constraints for matching with perfect discrimination trees
indexing.

--pdt-no-age-constr

Disable usage of age constraints for matching with perfect discrimination trees
indexing.

--detsort-rw

Sort set of clauses eliminated by backward rewriting using a total syntactic
ordering.

--detsort-new

Sort set of newly generated and backward simplified clauses using a total syntactic
ordering.

-D <arg>

--define-weight-function=<arg>

Define
a weight function (see manual for details). Later definitions

override previous definitions.

-H <arg>

--define-heuristic=<arg>

Define a clause selection heuristic (see manual for details). Later definitions
override previous definitions.

--free-numbers

Treat numbers (strings of decimal digits) as normal free function symbols in the
input. By default, number now are supposed to denote domain constants and to be
implicitly different from each other.

--free-objects

Treat object identifiers (strings in double quotes) as normal free function symbols
in the input. By default, object identifiers now represent domain objects and are
implicitly different from each other (and from numbers, unless those are declared
to be free).

--definitional-cnf[=<arg>]

Tune the clausification algorithm to introduces definitions for subformulae to
avoid exponential blow-up. The optional argument is a fudge factor that determines
when definitions are introduced. 0 disables definitions completely. The default
works well. The option without the optional argument is equivalent to
--definitional-cnf=24.

--fool-unroll=<arg>

Enable or disable FOOL unrolling. Useful for some SH problems.

--miniscope-limit[=<arg>]

Set the limit of sub-formula-size to miniscope. The build-indefault is 256. Only
applies to the new (default) clausification algorithm The option without the
optional argument is equivalent to --miniscope-limit=2147483648.

--print-types

Print the type of every term. Useful for debugging purposes.

--app-encode

Encodes terms in the proof state using applicative encoding, prints encoded input
problem and exits.

--arg-cong=<arg>

Turns on ArgCong inference rule. Excepts an argument "all" or "max" that applies
the rule to all or only literals that are eligible for resolution.

--neg-ext=<arg>

Turns on NegExt inference rule. Excepts an argument "all" or "max" that applies the
rule to all or only literals that are eligible for resolution.

--pos-ext=<arg>

Turns on PosExt inference rule. Excepts an argument "all" or "max" that applies the
rule to all or only literals that are eligible for resolution.

--ext-sup-max-depth=<arg>

Sets the maximal proof depth of the clause which will be considered for Ext-family
of inferences. Negative value disables the rule.

--inverse-recognition

Enables the recognition of injective function symbols. If such a symbol is
recognized, existence of the inverse function is asserted by adding a corresponding
axiom.

--replace-inj-defs

After CNF and before saturation, replaces all clauses that are definitions of
injectivity by axiomatization of inverse function.

--lift-lambdas=<arg>

Should the lambdas be replaced by named fuctions?

--eta-normalize=<arg>

Which form of eta normalization to perform?

--ho-order-kind=<arg>

Do we use simple LFHO order or a more advanced Boolean free lambda-KBO?

--cnf-lambda-to-forall=<arg>

Do we turn equations of the form ^X.s (!)= ^X.t into (?)!X. s (!)= t ?

--kbo-lam-weight=<arg>

Weight of lambda symbol in KBO.

--kbo-db-weight=<arg>

Weight of DB var in KBO.

--eliminate-leibniz-eq=<arg>

Maximal proof depth of the clause on which Leibniz equality elimination should be
applied; -1 disaables Leibniz equality elimination altogether

--unroll-formulas-only=<arg>

Set to true if you want only formulas to be recognized as definitions during CNF.
Default is true.

--prim-enum-mode=<arg>

Choose the mode of primitive enumeration

--prim-enum-max-depth=<arg>

Maximal proof depth of a clause on which primitive enumeration is applied. -1
disables primitive enumeration

--inst-choice-max-depth=<arg>

Maximal proof depth of a clause which is going to be scanned for occurrences of
defined choice symbol -1 disables scanning for choice symbols

--local-rw=<arg>

Enable/disable local rewriting: if the clause is of the form s != t |
C,

where s > t, rewrite all occurrences of s with t in C.

--prune-args=<arg>

Enable/disable pruning arguments of applied variables.

--func-proj-limit=<arg>

Maximal number of functional projections

--imit-limit=<arg>

Maximal number of imitations

--ident-limit=<arg>

Maximal number of identifications

--elim-limit=<arg>

Maximal number of eliminations

--unif-mode=<arg>

Set the mode of unification: either single or multi.

--pattern-oracle=<arg>

Turn the pattern oracle on or off.

--fixpoint-oracle=<arg>

Turn the pattern oracle on or off.

--max-unifiers=<arg>

Maximal number of imitations

--max-unif-steps=<arg>

Maximal number of variable bindings that can be done in one single call to
copmuting the next unifier.

--classification-timeout-portion=<arg>

Which percentage (from 1 to 99) of the total CPU time will be devoted to problem
classification?

--preinstantiate-induction=<arg>

Abstract unit clauses coming from conjecture and use the abstractions to
instantiate clauses that look like the ones coming from induction axioms.

--bce=<arg>

Turn blocked clause elimination on or off

--bce-max-occs=<arg>

Stop tracking symbol after it occurs in <arg> clauses Set <arg> to -1 disable this
limit

--pred-elim=<arg>

Turn predicate elimination on or off

--pred-elim-max-occs=<arg>

Stop tracking symbol after it occurs in <arg> clauses Set <arg> to -1 disable this
limit

--pred-elim-tolerance=<arg>

Tolerance for predicate elimination measures.

--pred-elim-recognize-gates=<arg>

Turn gate recognition for predicate elimination on or off

--pred-elim-force-mu-decrease=<arg>

Require that the square number of distinct free variables decreases when doing
predicate elimination. Helps avoid creating huge clauses.

--pred-elim-ignore-conj-syms=<arg>

Disable eliminating symbols that occur in the conjecture.

REPORTING BUGS

       Report bugs to <schulz@eprover.org>. Please include the following, if possible:

       * The version of the package as reported by eprover --version.

       * The operating system and version.

       * The exact command line that leads to the unexpected behaviour.

       * A description of what you expected and what actually happened.

       * If possible all input files necessary to reproduce the bug.

COPYRIGHT

This program is a part of the distribution of the equational theorem prover E. You can
find the latest version of the E distribution as well as additional information at
http://www.eprover.org

This program is free software; you can redistribute it and/or modify it under the terms of
the GNU General Public License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program
(it should be contained in the top level directory of the distribution in the file
COPYING); if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
Boston, MA 02111-1307 USA

We welcome bug reports and even reasonable questions. If the prover behaves in an
unexpected way, please include the following information:

- What did you observe? - What did you expect? - The output of `eprover --version` - The
full commandline that lead to the unexpected behaviour - The input file(s) that lead to
the unexpected behaviour

Most bug reports should be send to <schulz@eprover.org>. Bug reports with respect to the
HO-version should be send to or at least copied to <jasmin.blanchette@gmail.com>. Please
remember that this is an unpaid volunteer service.

The original copyright holder can be contacted via email or as

Stephan Schulz DHBW Stuttgart Fakultaet Technik Informatik Lerchenstrasse 1 70174
Stuttgart Germany

E 3.2.5 Puttabong Moondrop (69a471a3f67fbd0October92024291f452c2176c) E(1)