The options back_demod and back_unit_deletion are applied to clauses in the denials list; in fact, these operations are often the keys to the success of the denials list.
Start with clause c: 1. Simplify c: 1a. demodulate 1b. orient equalities 1c. simplify literals 1d. merge identical literals 1e. unit_deletion 1f. cac_redundancy 2. max_literals check 3. max_vars check 4. safe_unit_conflict check 5. max_weight check 6. subsumption check (forward) 7. assign an ID and keep the clause 8. unsafe unit conflict check 9. check if the clause should be a demodulator ---- (the following steps are delayed until finished with the given clause) --- 15. factor c 16. apply new_constants to c 17. apply back_subsume with c 18. apply back_demod with c 19. apply back_unit_deletion with c 20. move c to the sos listProcessing clauses in denials, both initial clauses and clauses from back_demod and back_unit_deletion.
Start with clause c: 1. Simplify c: 1a. demodulate 1b. orient equalities 1c. simplify literals 1d. merge identical literals 1e. unit_deletion 1f. cac_redundancy 2. unit conflict check 3. append c to the denials list
set(lex_order_vars). clear(lex_order_vars). % default clear
This flag allows an exception to the rule for applying nonorientable demodulators. If the flag is set, variables are treated as constants when comparing terms, with the precedencelex([x,y,z,u,v,w,v6,v7,v8, ...]).
For example, with the (nonorientable) demodulator x*y = y*x, the term v7*v6 can be rewritten to v6*v7. Setting this flag can easily block proofs, but it can also drastically reduce the search space and still allow some proofs to be found.
assign(demod_step_limit, n). % default n=1000, range [-1 .. INT_MAX]
This parameter limits the number of rewrite steps that are applied to a clause during demodulation. If n=-1, there is no limit.
assign(demod_size_limit, n). % default n=1000, range [-1 .. INT_MAX]
This parameter limits the size (measured as symbol count) of terms as they are demodulated. If any term being demodulated has more thann symbols, demodulation of the clause stops. If n=-1, there is no limit.
set(back_demod). clear(back_demod). % default clear
If this flag is set,back demodulation is applied. If an orientable equation is derived, it is appended to the demodulators list. Non-orientable equations are appended based on the settings of the flags lex_dep_demod and lex_dep_demod_sane and the parameter lex_dep_demod_lim.If an equation is added to demodulators, Then each clause in usable or sos that can be rewritten with the equation is copied and deleted, then the copy is treated as if it were generated by an inference rule. In particular, it will be processed, including demodulation, which will apply the new demodulator. Clauses in denials will also be back demodulated and reprocessed, but if they are kept, they will be placed back in denials instead of in sos.
set(lex_dep_demod). % default set clear(lex_dep_demod).
If this flag is set, then non-orientable equations can become demodulators (via the flag back_demod).
assign(lex_dep_demod_lim, n). % default n=11, range [-1 .. INT_MAX]
This parameter is a limit on the flag lex_dep_demod. A non-orientable equation cannot become a demodulator if it has more than n symbols. (The equation (x*y)*z=x*(y*z) has 11 symbols.) If n = -1, there is no limit.
set(lex_dep_demod_sane). % default set clear(lex_dep_demod_sane).
This flag is a restriction on the flag lex_dep_demod. If set, a non-orientable equation can become a demodulator only if its two sides have the same number of symbols.
set(unit_deletion). clear(unit_deletion). % default clear
This flag extends demodulation to include rewriting of literals with unit clauses. For example, if we have the unit clause p(x,a), then we can use it to remove instances of -p(x,a) from generated clauses. This process is like using the unit clause as the demodulator p(x,a) = TRUE. (Unit deletion is not actually implemented as demodulation.)
set(back_unit_deletion). clear(back_unit_deletion). % default clear
This flag is analogous to back demodulation. If set, then each time a unit clause is kept, it is used to apply unit deletion to all clauses in sos, usable, and denials in the same way that back_demodulation works.
set(cac_redundancy). % default set clear(cac_redundancy).
If this flag is set, then an equational redundancy criterion is applied. If Prover9 finds that a binary operation is commutative or associative-commutative, it makes a note and uses that information to simplify clauses that are derived later in the search.If a derived clause contains an equality alpha=beta, in which alpha and beta are equal with respect to commutativity or associativity-commutativity of the the previously noted operations, the equality is simplified to TRUE.
For example, if Prover9 notes that x*y=y*x, and then some time later a clause containing the literal g(u*v)=g(v*u) is derived, that literal will be simplified to TRUE and the clause will be deleted. (Demodulation will not rewrite the two sides to the same term unless the flag lex_dep_demod is set.)
assign(max_literals, n). % default n=-1, range [-1 .. INT_MAX]
Clauses containing more than n literals will be deleted. If= -1, there is no limit. This parameter is never applied to initial clause s.
assign(max_vars, n). % default n=-1, range [-1 .. INT_MAX]
Clauses containing more than n (distinct) variables will be deleted. If= -1, there is no limit. This parameter is never applied to initial clause s.
set(safe_unit_conflict). clear(safe_unit_conflict). % default clear
This flag provides for a safe, but more expensive,unit conflict test. If set, the unit conflict test will be done before the max_weight test is applied. If the flag is clear, the test will be done after the max_weight test is applied, allowing the possibility that a proof will be missed, because the final step was deleted by the max_weight parameter.
assign(max_weight, n). % default n=100, range [INT_MIN .. INT_MAX]
Derived clauses with weight greater then n will be discarded. If= -1, there is no limit. This parameter is never applied to initial clause s.
set(factor). clear(factor). % default clear
If this flag is set,binary factoring is applied to newly-kept clauses.
assign(new_constants, n). % default n=0, range [-1 .. INT_MAX]
If this parameter is greater than 0, then Prover9 will apply a rule that introduces a new constant when it derives an equation that shows the existence of a constant. In particular, if a derived equation has the property that each side has variables and the two sides share no variables, a new constant will be introduced and set equal to one side of the equation. (Back demodulation will derive that the constant is equal to the other side.)For example, if x' * x = y * y' is derived, the equation x' * x = c is produced, where the constant c does not occur anywhere else.
The value of the parameter limits the number of new constants that can be introduced by this rule.
(There is an extension to this rule that introduces (non-constant) function symbols based on the intersection of the variables of the two sides. We have not found the extension to be useful in practice, so we have not included it in Prover9.)
set(back_subsume). % default set clear(back_subsume).
If this flag is set, thenback subsumption is applied with all new clauses. That is, when a new clause is kept, each clause subsumed by the new clause is deleted.