Sindbad~EG File Manager

binary_res
Use set() or clear() to set or clear this flag.
clear
If this flag is set, the inference rule binary resolution (along with any other inference rules that are set) is used to generate new clauses. Setting this flag causes the flags factor and unit_deletion to be automatically set.

hyper_res
Use set() or clear() to set or clear this flag.
clear
If this flag is set, the inference rule (positive) hyperresolution (along with any other inference rules that are set) is used to generate new clauses.

neg_hyper_res
Use set() or clear() to set or clear this flag.
clear
If this flag is set, the inference rule negative hyperresolution (along with any other inference rules that are set) is used to generate new clauses.

ur_res
Use set() or clear() to set or clear this flag.
clear
If this flag is set, the inference rule UR-resolution (unit-resulting resolution) (along with any other inference rules that are set) is used to generate new clauses.

para_into
Use set() or clear() to set or clear this flag.
clear
If this flag is set, the inference rule "paramodulation into the given clause" (along with any other inference rules that are set) is used to generatenew clauses. When using paramodulation, one should include the appropriate clause for reflexivity of equality, for example, x=x.

para_from
Use set() or clear() to set or clear this flag.
clear
If this flag is set, the inference rule "paramodulation from the given clause" (along with any other inference rules that are set) is used to generate new clauses. When using paramodulation, one should include the appropriate clause for reflexivity of equality, for example, x=x.

demod_inf
Use set() or clear() to set or clear this flag.
clear
If this flag is set, demodulation is applied, as if it were an inference rule, to the given clause. This is useful when term rewriting is the main objective. When this flag is set, the given clause is copied, then processed just like any newly generated clause.

geometric_rule
Use set() or clear() to set or clear this flag.
clear
When this flag is set, gL is applied as an inference rule (along with any other inference rules that are set) to each given clause. The rule gL applies to single positive unit equalities.

para_from_left
Use set() or clear() to set or clear this flag.
set
If this flag is set, paramodulation is allowed from the left sides of equality literals. (Applies to both para_into and para_from inference rules.)

para_from_right
Use set() or clear() to set or clear this flag.
set
If this flag is set, paramodulation is allowed from the right sides of equality literals. (Applies to both para_into and para_from inference rules.)

para_into_left
Use set() or clear() to set or clear this flag.
set
If this flag is set, paramodulation is allowed into left sides of positive and negative equalities. (Applies to both para_into and para_from inference rules.)

para_into_right
Use set() or clear() to set or clear this flag.
set
If this flag is set, paramodulation is allowed into right sides of positive and negative equalities. (Applies to both para_into and para_from inference rules.)

para_from_vars
Use set() or clear() to set or clear this flag.
clear
If this flag is set, paramodulation from variables is allowed. Warning: Setting this option may produce too many paramodulants. (Applies to both para_into and para_from inference rules.)

para_into_vars
Use set() or clear() to set or clear this flag.
clear
If this flag is set, paramodulation into variables is allowed. Warning: Setting this option may produce too many paramodulants. (Applies to both para_into and para_from inference rules.)

para_from_units_only
Use set() or clear() to set or clear this flag.
clear
If this flag is set, paramodulation is allowed only if the from clause is a unit (equality). (Applies to both para_into and para_from inference rules.)

para_into_units_only
Use set() or clear() to set or clear this flag.
clear
If this flag is set, paramodulation is allowed only if the into clause is a unit. (Applies to both para_into and para_from inference rules.)

para_skip_skolem
Use set() or clear() to set or clear this flag.
clear
If this flag is set, paramodulation is never allowed into subterms of Skolem expressions [16]. (Applies to both para_into and para_from inference rules.)

para_ones_rule
Use set() or clear() to set or clear this flag.
clear
If this flag is set, paramodulation obeys the 1's rule. (The 1's rule is a special-purpose strategy for problems in combinatory logic; its usefulness has not been demonstrated elsewhere.) (Applies to both para_into and para_from inference rules.)

para_all
Use set() or clear() to set or clear this flag.
clear
If this flag is set, all occurrences of the into term are replaced with the replacement term. (Applies to both para_into and para_from inference rules.)

very_verbose
Use set() or clear() to set or clear this flag.
clear
If this flag is set, a tremendous amount of information about the processing of generated clauses is output.

print_kept
Use set() or clear() to set or clear this flag.
set
If this flag is set, new clauses are output if they are retained (if they pass all retention tests).

print_given
Use set() or clear() to set or clear this flag.
set
If this flag is set, clauses are output when they become given clauses.

print_kept
Use set() or clear() to set or clear this flag.
set
If this flag is set, new clauses are output if they are retained (if they pass all retention tests).

print_back_sub
Use set() or clear() to set or clear this flag.
set
If this flag is set, clauses are printed if they are back subsumed. Back-subsumed clauses are always printed during input processing.

print_new_demod
Use set() or clear() to set or clear this flag.
set
If this flag is set, demodulators that are adjoined during the search (dynamic_demod) are printed. New demodulators are always printed during input processing.

print_back_demod
Use set() or clear() to set or clear this flag.
set
If this flag is set, clauses are printed as they are back demodulated. Back-demodulated clauses are always printed during input processing.

print_proofs
Use set() or clear() to set or clear this flag.
set
If this flag is set, all proofs that are found are printed to the output file. If this flag is clear, no proofs are printed.

print_lists_at_end
Use set() or clear() to set or clear this flag.
clear
If this flag is set, then usable, sos, and demodulators are printed at the end of the search.

echo_included_files
Use set() or clear() to set or clear this flag.
set
If this flag is set, input files included with the include(filename) command are echoed in the same way as ordinary input.

build_proof_object
Use set() or clear() to set or clear this flag.
clear
If this flag is set, then whenever a proof is found, a proof object is printed to the output file. Proof objects are very detailed proof and were introduced for two purposes: so that proofs can be checked by an independent program, and so that proofs can be translated into other forms by other programs. Proof objects are written in a Lisp-like notation. Warning: Construction of proof objects is fragile and sometimes it simply fails.

build_proof_object_1
Use set() or clear() to set or clear this flag.
clear
If this flag is set, then whenever a proof is found, a type 1 proof object is printed to the output file. Proof objects are very detailed proof and were introduced for two purposes: so that proofs can be checked by an independent program, and so that proofs can be translated into other forms by other programs. Proof objects are written in a Lisp-like notation. (Type 2 proof objects are usually preferred.) Warning: Construction of proof objects is fragile and sometimes it simply fails.

build_proof_object_2
Use set() or clear() to set or clear this flag.
clear
If this flag is set, then whenever a proof is found, a type 2 proof object is printed to the output file. Type 2 proof objects are used in the IVY verification project [19], and a detailed description (definition in ACL2) can be found there. Warning: construction of proof objects is fragileand sometimes it simply fails.

unit_deletion
Use set() or clear() to set or clear this flag.
clear
If this flag is set, unit deletion is applied to newly generated clauses. Unit deletion removes a literal from a newly generated clause if the literal is the negation of an instance of a unit clause that occurs in usable or sos. For example, the second literal of p(a,x) | q(a,x) is removed by the unit -q(u,v); but it is not removed by the unit -q(u,b), because that unification causes the instantiation of x. All such literals are removed from the newly generated clause, even if the result is the empty clause. One can view unit deletion with unit clause P as demodulation applied to literals with the demodulator P = $T. (Unit deletion is not useful if all generated clauses are units.)

delete_identical_nested_skolem
Use set() or clear() to set or clear this flag.
clear
If this flag is set, clauses with the nested Skolem property are deleted. A clause has the nested Skolem property if it contains a a Skolem expression that (properly) contains an occurrence of its leading Skolem symbol. For example, if f is a Skolem function, a clause containing a term f(f(x)) or a term f(g(f(x))) is deleted.

sort_literals
Use set() or clear() to set or clear this flag.
clear
If this flag is set, literals of newly generated clauses are sortednegative literals, then positive literals, then answer literals. The main purpose of this flag is to make clauses more readable. In some cases, this flag can speed up subsumption on non-unit clauses.

for_sub
Use set() or clear() to set or clear this flag.
set
If this flag is set, forward subsumption is applied during the processing of newly generated clauses. (New clauses are deleted if subsumed by any clause in usable or sos.)

back_sub
Use set() or clear() to set or clear this flag.
set
If this flag is set, back subsumption is applied during the processing of newly kept clauses. (Clauses in usable or sos are deleted if subsumed by the newly kept clause.)

ancestor_subsume
Use set() or clear() to set or clear this flag.
clear
If this flag is set, the notion of subsumption (forward and back) is replaced with ancestor-subsumption. Clause C ancestorsubsumes clause D iff C properly subsumes D or if C and D are variants and size(ancestorset(C)) <= size(ancestorset(D)). When setting ancestor_subsume, we strongly recommend not clearing the flag back_subsume, because doing so can cause many occurrences of the same clause to be retained and used as given clauses.

factor
Use set() or clear() to set or clear this flag.
clear
If this flag is set, factoring is applied in two ways. First, factoring is applied as a simplification rule to newly generated clauses. If a generated clause C has factors that subsume C, it is replaced with its smallest subsuming factor. Second, it is applied as an inference rule to newly kept clauses. Note that unlike other inference rules, factoring is not applied to the given clause; it is applied to a new clause as soon as it is kept. All factors are generated in an iterative manner. Factoring is attempted on answer literals. If factor is set, a clause with <I>n</I> literals will not cause a clause with fewer than <I>n</I> literals to be deleted by subsumption.

geometric_rewrite_before
Use set() or clear() to set or clear this flag.
clear
When this flag is set, gL is applied as a rewrite rule, before ordinary demodulation, to each generated clause.

geometric_rewrite_after
Use set() or clear() to set or clear this flag.
clear
When this flag is set, gL is applied as a rewrite rule, after ordinary demodulation, to each generated clause.

max_literals
assign(max_literals,<I>n</I>)
-1, range [-1..infinity]
If <I>n</I> <> -1, new clauses are discarded if they contain more than <I>n</I> literals.

max_weight
assign(max_weight,<I>n</I>)
infinity, range [-infinity..infinity]
New clauses are discarded if their weight is more than <I>n</I>. The weight list purge_gen or the weight list pick_and_purge is used to weigh clauses

max_distinct_vars
assign(max_distinct_vars,<I>n</I>)
-1, range [-1..infinity]
If <I>n</I> <> -1, new clauses are discarded if they contain more than <I>n</I> distinct variables.

change_limit_after
assign(change_limit_after,<I>n</I>)
0, range [0..infinity]
If <I>n</I> (the value) is not 0, this parameter has effect. After <I>n</I> given clauses have been used, the parameter max_weight is automatically reset to the value of the parameter new_max_weight.

new_max_weight
assign(new_max_weight,<I>n</I>)
infinity, range [-infinity..infinity]
See the description of change_limit_after.

detailed_history
Use set() or clear() to set or clear this flag.
set
This flag affects the parent lists in clauses that are derived by binary_res, para_from, or para_into. If the flag is set, the positions of the unified literals or terms are given along with the IDs of the parents.

order_history
Use set() or clear() to set or clear this flag.
clear
This flag affects the order of parent lists in clauses that are derived by hyperresolution, negative hyperresolution, or UR-resolution. If the flag is set, then the nucleus is listed first, and the satellites are listed in the order in which the corresponding literals appear in the nucleus. If the flag is clear (or if the clause was derived by some other inference rule), the given clause is listed first.

demod_history
Use set() or clear() to set or clear this flag.
set
If this flag is set, then when a clause is demodulated, the ID numbers of the demodulators are included in the derivation history of the clause.

max_seconds
assign(max_seconds,<I>n</I>)
-1, range [-1..infinity]
If <I>n</I> <> -1, the search is terminated after about <I>n</I> CPU seconds. The time is not exact because OTTER will wait until the current given clause is finished before stopping.

max_gen
assign(max_gen,<I>n</I>)
-1, range [-1..infinity]
If <I>n</I> <> -1, the search is terminated after about <I>n</I> clauses have been generated. The number is not exact because OTTER will wait until it is finished with the current given clause before stopping.

max_kept
assign(max_kept,<I>n</I>)
-1, range [-1..infinity]
If <I>n</I> <> -1, the search is terminated after about <I>n</I> clauses have been kept. The number is not exact because OTTER will wait until it is finished with the current given clause before stopping.

max_given
assign(max_given,<I>n</I>)
-1, range [-1..infinity]
If <I>n</I> <> -1, the search is terminated after <I>n</I> given clauses have been used.

max_mem
assign(max_mem,<I>n</I>)
-1, range [-1..infinity]
If <I>n</I> <> -1, OTTER will terminate the search before more than <I>n</I> kilobytes have been dynamically allocated (malloc).

max_proofs
assign(max_proofs,<I>n</I>)
1, range [-1..infinity]
If <I>n</I> = 1, OTTER will stop if it finds a proof. If <I>n</I> > 1, then OTTER will not stop when it has found the first proof; instead, it will try to keep searching until it has found <I>n</I> proofs. (Some of the proofs may in fact be identical.) (Because forward subsumption occurs before unit conflict, a clause representing a truly different proof may be discarded by forward subsumption before unit conflict detects the proof.) If <I>n</I> = -1, OTTER will find as many proofs as it can (within other constraints).

demod_linear
Use set() or clear() to set or clear this flag.
clear
If this flag is set, demodulation indexing is disabled, and a linear search of demodulators are used when rewriting terms. With indexing disabled, if more than one demodulator can be applied to rewrite a term, then the one whose clause number is lowest is applied; this flag is useful when demodulation is used to do "procedural" things. With indexing enabled (the default), demodulation is much faster, but the order in which demodulators is applied is not under the control of the user.

demod_out_in
Use set() or clear() to set or clear this flag.
clear
If this flag is set, terms are demodulated outside-in, left to right. In other words, the program attempts to rewrite a term before rewriting (left to right) its subterms. The algorithm is "repeat {rewrite the leftmost outermost rewritable term} until no more rewriting can be done or the limit is reached". (The effect is like a standard reduction in lambda calculus or in combinatory logic.) If this flag is clear, terms are demodulated inside-out (all subterms are fully demodulated before attempting to rewrite a term).

dynamic_demod
Use set() or clear() to set or clear this flag.
clear
If this flag is set, some newly kept equalities are made into demodulators. Setting this flag automatically sets the flag order_eq.

dynamic_demod_all
Use set() or clear() to set or clear this flag.
clear
If this flag is set, OTTER attempts to make all newly kept equalities into demodulators. Setting this flag automatically sets the flags dynamic_demod and order_eq.

back_demod
Use set() or clear() to set or clear this flag.
clear
If this flag is set, back demodulation is applied to demodulators, usable, and sos whenever a new demodulator is added. Back demodulation is delayed until the inference rules are finished generating clauses from the current given clause (delayed until post_process). Setting the back_demod flag automatically sets the flags order_eq and dynamic_demod.

demod_limit
assign(demod_limit,<I>n</I>)
1000, range [-1..infinity]
If <I>n</I> <> -1, <I>n</I> is the maximum number of rewrites that will be applied when demodulating a clause. The count includes $ symbol evaluation. If <I>n</I> is -1, there is no limit. A warning message is printed if OTTER attempts to exceed the limit.

knuth_bendix
Use set() or clear() to set or clear this flag.
clear
Setting this flag simply causes the preceding flag, anl_eq, to be set.

order_eq
Use set() or clear() to set or clear this flag.
clear
If this flag is set, equalities are flipped if the right side is heavier than the left.

eq_units_both_ways
Use set() or clear() to set or clear this flag.
clear
If this flag is set, unit equality clauses (both positive and negative) are sometimes stored in both orientations; the action taken depends on the flag order_eq. If order_eq is clear, then whenever a unit, say a = b, is processed, b = a is automatically generated and processed. If order_eq is set, then the reversed equality is generated only if the equality cannot be oriented.

dynamic_demod_lex_dep
Use set() or clear() to set or clear this flag.
clear
If this flag is set, dynamic demodulators may be lex-dependent or LRPO-dependent.

lrpo
Use set() or clear() to set or clear this flag.
clear
If this flag is set, then the lexicographic recursive path ordering (also called RPO with status) is used to compare terms. If this flag is clear, weight templates and lexicographic order are used.

lex_order_vars
Use set() or clear() to set or clear this flag.
clear
This flag affects lex-dependent demodulation and the evaluable functions and predicates that perform lexical comparisons. If this flag is set, then lexical ordering is a total order on terms; variables are lowest in the term order, with x < y < z < u < v < w < v6 < v7 < v8 < � � � . If this flag is clear, then a variable is comparable only to another occurrence of the same variable; it is not comparable to other variables or to nonvariables. For example, $LLT(f(x),f(y)) evaluates to $T if and only if lex_order_vars is set. If lrpo is set, lex_order_vars has no effect on demodulation.

symbol_elim
Use set() or clear() to set or clear this flag.
clear
If this flag is set, then new demodulators are oriented, if possible, so that function symbols (excluding constants) are eliminated. A demodulator can eliminate all occurrences of a function symbol if the arguments on the left side are all different variables and if the function symbol of the left side does not occur in the right side. For example, the demodulators g(x) = f(x,x) and h(x,y) = f(x,f(y,f(g(x),g(y)))) eliminate all occurrences of g and h, respectively.

order_hyper
Use set() or clear() to set or clear this flag.
set
If this flag is set, then the inference rules hyper_res and neg_hyper_res are constrained by an ordering strategy. A literal in a satellite is allowed to resolve only if it is maximal in the satellite. (A literal is maximal in a clause if and only if there is no larger literal.) The ordering uses only the lexical value (as in the lex command or the default) of the predicate symbol. (This flag is irrelevant for positive hyperresolution with a Horn set.)

auto
Use set() or clear() to set or clear this flag.
clear
If the flag auto is set, OTTER will scan the input clauses for some simple syntactic properties and decide on inference rules and a search strategy. We think of the autonomous mode as providing a built-in metastrategy for selecting search strategies. The search strategy that OTTER selects for a particular set of clauses is usually refutation complete (except for the flag control_memory), but the user should not expect it to be especially effective. It will find proofs for many easy theorems, and even for cases in which it fails to find a proof, it provides a reasonable starting point.<br> In the input file, the command set(auto) must occur before any input clauses, and all input clauses must be in list usable; it is an error to place input clauses on any of the other lists when in autonomous mode. OTTER will move some of the input clauses to sos before starting the search. When OTTER processes the set(auto) command, it alters some options, even before examining the input clauses. If the user wishes to augment the autonomous mode by including some ordinary OTTER commands (including overriding OTTER's choices), the commands should be placed after set(auto) and before list(usable).<br> After list(usable) has been read, OTTER examines the input clauses for several syntactic properties and decides which inference rules and strategies should be used, and which clauses should be moved to sos. The user cannot override the decisions that OTTER makes at this stage.<br> OTTER looks for the following syntactic properties of the set of input clauses: (1) whether it is propositional, (2) whether it is Horn, (3) whether equality is present, (4) whether equality axioms are present, and (5) the maximum number of literals in a clause. The program then considers six basic combinations of the properties: (1) propositional, (2) equality in which all clauses are units, and (3-6) the four combinations of {equality, Horn}. To see precisely what OTTER does for these cases, the reader can set up and run some simple experiments.<br> Please be aware that the autonomous mode reflects individual experience with OTTER; other users would certainly formulate different metastrategies. For example, one might prefer UR-resolution to hyperresolution or in addition to hyperresolution in rich Horn or nearly-Horn theories, and one might prefer to add few or no dynamic demodulators for equality theories.

simplify_fol
Use set() or clear() to set or clear this flag.
set
If this flag is set, then some propositional simplification is attempted when converting input first-order formulas into clauses. The simplification occurs after Skolemization, during the CNF translation. If simplification detects a refutation, it will always produce the empty clause $F, but OTTER will not recognize the proof (i.e., give the proof message and stop) unless the flag process_input is set.

process_input
Use set() or clear() to set or clear this flag.
clear
If this flag is set, input usable and sos clauses (including clauses from formula input) are processed as if they had been generated by an inference rule. (See the procedure for processing newly inferred clauses in Sec. 2.) The exceptions are (1) the following clause-processing options are not applied to input clauses: max_literals, max_weight, delete_identical_nested_skolem, and max_distinct_vars, (2) clauses input on list usable remain there if retained, and (3) some output appears even if the output flags are clear.

propositional
Use set() or clear() to set or clear this flag.
clear
If this flag is set, OTTER assumes that all clauses are propositional, and it makes some optimizations. The user should set this flag only when all clauses are propositional; otherwise OTTER may make unsound inferences and/or crash.

report
assign(report,<I>n</I>)
-1, range [-1..infinity]
If <I>n</I> > 0, then statistics are output approximately every <I>n</I> CPU seconds. The time is not exact because statistics will be output only after the current given clause is finished. This feature can be used in conjunction with UNIX programs such as grep and awk to conveniently monitor OTTER jobs.

stats_level
assign(stats_level,<I>n</I>)
2, range [0..4]
This indicates the level of detail of statistics printed in reports and at the end of the search. If <I>n</I> = 0, no statistics are output; if <I>n</I> = 1, a few important search and time statistics are output; if <I>n</I> = 2, all search and time statistics are output; if <I>n</I> = 3, search, time, and memory statistics are output; and if <I>n</I> = 4, search, time, and memory statistics and option values are output. This parameter does not affect the speed of OTTER, because all statistics are always kept.

min_bit_width
assign(min_bit_width,<I>n</I>)
bits-per-long, range [0..bits-per-long]
When the evaluable bit operations produce a new bit string, leading zeros are suppressed under the constraint that n is the minimum string length. (The value bits-per-long is the number of bits in the C data type long integer.)

sos_queue
Use set() or clear() to set or clear this flag.
clear
If this flag is set, the first clause in sos is selected as the given clause (the set of support list operates as a queue). This causes a breadth-first search, also called level saturation. Some information about search levels is printed if this flag is set.

sos_stack
Use set() or clear() to set or clear this flag.
clear
If this flag is set, the last clause in sos becomes the given clause (the set of support list operates as a stack). This causes a depth-first search (which rarely is useful with OTTER).

input_sos_first
Use set() or clear() to set or clear this flag.
clear
If this flag is set, the input clauses in sos are given a very low pick_given weight so that they are the first clauses selected as given clauses.

interactive_given
Use set() or clear() to set or clear this flag.
clear
If this flag is set, then when its time to select a new given clause, the user is prompted for a choice. This flag has priority over all other flags that govern selection of the given clause.

pick_given_ratio
assign(pick_given_ratio,<I>n</I>)
-1, range [-1..infinity]
This parameter causes some given clauses to be selected by weight and others in a breadth-first manner (by age). If <I>n</I> <> -1, <I>n</I> given clauses are are selected by (smallest pick_given) weight, then the first clause in sos is selected as given clause, then <I>n</I> given clauses are selected by weight, and so forth. This method allows heavy clauses to enter into the search while focusing mainly on light clauses. It combines breadth-first search and best-first search (default selection by weight). If <I>n</I> is -1, then the clause with smallest pick_given weight is always selected.

geo_given_ratio
assign(geo_given_ratio,<I>n</I>)
1, range [-1..infinity]
When this parameter is not -1, it affects selection of the given clause in a way similar to pick_given_ratio. If the ratio is <I>n</I>, then for each <I>n</I> given clauses selected in the normal way by weight, one given clause is selected because it is the lightest gL result available in sos. If pick_given_ratio and geo_given_ratio are both in effect, then clashes are resolved in favor of geo_given_ratio.

interrupt_given
assign(interrupt_given,<I>n</I>)
-1, range [-1..infinity]
If <I>n</I> > 0, then after <I>n</I> given clauses have been used, OTTER goes into its interactive mode

prolog_style_variables
Use set() or clear() to set or clear this flag.
clear
If this flag is set, a name with no arguments in a clause is a variable if and only if it starts with A through Z (upper case) or with _.

display_terms
Use set() or clear() to set or clear this flag.
clear
If this flag is set, all clauses and terms are printed in pure prefix form. This feature can be useful for debugging the input.

check_arity
Use set() or clear() to set or clear this flag.
set
If this flag is set, a warning is given if symbols have variable arities (different numbers of arguments in different places in the input). For example, the term f(a,a(b)) would be flagged. (Constants have arity 0.) If this flag is clear, then variable arities are permitted; in the preceding term, the two occurrences of a would be treated as different symbols.

input_sequent
Use set() or clear() to set or clear this flag.
clear
If this flag is set, clauses in the input file must be in sequent notation.

output_sequent
Use set() or clear() to set or clear this flag.
clear
If this flag is set, then sequent notation is used when clauses are output.

bird_print
Use set() or clear() to set or clear this flag.
clear
If this flag is set, terms constructed with the binary function a are output in combinatory logic notation (without the function symbol a, and left associated unless otherwise indicated). For example, the clause a(a(a(S,x),y),z) = a(a(x,z),a(y,z)) is output as S x y z = x z (y z). Terms cannot be input in combinatory logic notation.

pretty_print
Use set() or clear() to set or clear this flag.
clear
If this flag is set, clauses are output in an indented form that is sometimes easier to read. The parameter pretty_print_indent (default 4) specifies the number of spaces for each indent level.

pretty_print_indent
assign(pretty_print_indent,<I>n</I>)
4, range [0..16]
See flag pretty_print.

control_memory
Use set() or clear() to set or clear this flag.
clear
If this flag is set, then the automatic memory-control feature is enabled.

really_delete_clauses
Use set() or clear() to set or clear this flag.
clear
If this flag is clear, clauses that are deleted by back subsumption or back demodulation are not really removed from memory; they are retained in a special place so that they can be printed if they occur in a proof. If the job involves much back subsumption or back demodulation and if memory conservation is important, these deleted clauses can be removed from memory by setting this flag (and any proof containing such a clause will not be printed in full).

free_all_mem
Use set() or clear() to set or clear this flag.
clear
If this flag is set, then at the end of the search, most dynamically allocated memory is returned to the memory managers. This flag is used mainly for debugging, in particular, to help find memory leaks. Setting this flag will not cause OTTER to use less memory.

index_for_back_demod
Use set() or clear() to set or clear this flag.
set
If this flag is set, all nonvariable terms in all clauses are indexed so that the appropriate ones can be quickly retrieved when applying a dynamic demodulator to the clause space (back demodulation). This type of indexing can use a lot of memory. If the flag is clear, back demodulation still works, but it is much slower.

for_sub_fpa
Use set() or clear() to set or clear this flag.
clear
If this flag is set, FPA indexing is used for forward subsumption. If this flag is clear, discrimination tree indexing is used. Setting this flag can decrease the amount of memory required by OTTER. Discrimination tree indexing can require a lot of memory, but it is usually much faster than FPA indexing.

no_fapl
Use set() or clear() to set or clear this flag.
clear
If this flag is set, positive literals are not indexed for unit conflict or back subsumption. This option should be used only when no negative units will be generated (as with hyperresolution), back subsumption is disabled, and discrimination tree indexing is being used for forward subsumption. This option can save a little time and memory.

no_fanl
Use set() or clear() to set or clear this flag.
clear
If this flag is set, negative literals are not indexed for unit conflict or back subsumption. This option should be used only when no positive units will be generated (as with negative hyperresolution), back subsumption is disabled, and discrimination tree indexing is being used for forward subsumption. This option can save a little time and memory.

fpa_literals
assign(fpa_literals,<I>n</I>)
8, range [0..100]
<I>n</I> is the FPA indexing depth for literals. (FPA literal indexing is used for resolution inference rules, back subsumption, and unit conflict. It is also used for forward subsumption if the flag for_sub_fpa is set.) If <I>n</I> = 0, indexing is by predicate symbol only; if <I>n</I> = 1, indexing looks at the predicate symbol and the leading symbols of the arguments of the literal, and so on. Greater indexing depth requires more memory, but it can be faster. Changing this parameter will not change the clauses that are generated or kept.

fpa_terms
assign(fpa_terms,<I>n</I>)
8, range [0..100]
<I>n</I> is the FPA indexing depth for terms. (FPA term indexing is used for paramodulation inference rules and back demodulation.) If <I>n</I> = 0, indexing is by symbol only; if <I>n</I> = 1, indexing looks at the symbol and the leading symbols of the arguments of the term; and so on. Greater indexing depth requires more memory, but it can be faster. Changing this parameter will not change the clauses that are generated or kept.

heat
assign(heat,<I>n</I>)
1, range [0..100]
To prevent long sequences of hot inferences (i.e., hot inference applied to a clause generated by hot inference, and so on) we consider the heat level of hot inference. The heat level of an ordinary inference is 0, and the heat level of a hotly inferred clause is one more than the heat level of the new-clause parent. The parameter heat is the maximum heat level that will be generated. When a clause is printed, its heat level, if greater than 0, is also printed.

dynamic_heat_weight
assign(dynamic_heat_weight,<I>n</I>)
-infinity, range [-infinity..infinity]
Clauses can be added to the hot list during a search. If the pick_given weight of a kept clause is less than or equal to the parameter dynamic_heat_weight thenthe clause will be added to the hot list and used for subsequent hot inference. Input clauses that are kept during processing of the input are never made into dynamic hot clauses. Dynamic hot clauses can be added to an empty hot list (i.e., no input hot list).

atom_wt_max_args
Use set() or clear() to set or clear this flag.
clear
If this flag is set, the default weight of an atom (the weight if no template matches the atom) is 1 plus the maximum of the weights of the arguments. If this flag is clear, the default weight of an atom is 1 plus the sum of the weights of the arguments.

term_wt_max_args
Use set() or clear() to set or clear this flag.
clear
If this flag is set, the default weight of a term (the weight if no template matches the atom) is 1 plus the maximum of the weights of the arguments. If this flag is clear, the default weight of a term is 1 plus the sum of the weights of the arguments.

neg_weight
assign(neg_weight,<I>n</I>)
0, range [-infinity..infinity]
The value <I>n</I> is the additional weight (positive or negative) that is given to negated literals. Weight templates cannot be used for this purpose because the negation sign on a literal cannot occur in weight templates. (Atoms, not literals, are weighed with weight templates.)