A | |
| active_simplify_rule [Env_intf.S] | |
| any_phase [Phases] | |
| axiom [MetaProverState_intf.S] | |
B | |
| backward_redundant_rule [Env_intf.S] |
find redundant clauses in
ProofState.ActiveSet w.r.t the clause.
|
| backward_simplify_rule [Env_intf.S] |
backward simplification by a unit clause.
|
| binary_inf_rule [Env_intf.S] | |
| bool_lit [Trail] | |
| bool_lit [ProofStep] | |
C | |
| case [Ind_cst] | |
| clause [Sat_solver_intf.S] | |
| clause [Clause_intf.S] | |
| clause_conversion_rule [Env_intf.S] |
A hook to convert a particular statement into a list
of clauses
|
| conversion_result [Env_intf.S] | |
| cover_set [Ind_cst] | |
| cst [Ind_cst] | |
| cut_res [Avatar_intf.S] | |
D | |
| decl [EnumTypes.S] | |
| declare_result [EnumTypes.S] | |
| divides [ArithLit] | num^power divides monome or not.
|
| divisor [ArithLit.Util] | |
E | |
| env_action [Extensions] |
An extension is allowed to modify an environment
|
| env_with_clauses [Phases] | |
| env_with_result [Phases] | |
F | |
| filename [Phases] | |
| flag [SClause] | |
| flag [Clause_intf.S] | |
| form [ProofStep] | |
G | |
| generate_rule [Env_intf.S] |
Generation of clauses regardless of current clause
|
H | |
| hook_from [Literal.Conv] | |
| hook_to [Literal.Conv] | |
I | |
| inductive_path [BBox] | |
| inf_rule [Env_intf.S] |
An inference returns a list of conclusions
|
| is_trivial_rule [Env_intf.S] |
Rule that checks whether the clause is trivial (a tautology)
|
K | |
| key [Flex_state] | |
| kind [ProofStep] |
Classification of proof steps
|
L | |
| lemma [MetaProverState_intf.S] | |
| lit [ArithLit] | |
| lit_rewrite_rule [Env_intf.S] |
Rewrite rule on literals
|
M | |
| monome [Monome] | |
| multi_simpl_rule [Env_intf.S] |
(maybe) rewrite a clause to a set of clauses.
|
O | |
| of_ [ProofStep] |
Proof Step with its conclusion
|
| op [ArithLit] | |
| or_error [MetaProverState_intf] | |
| or_error [MetaProverState] | |
| or_error [Phases] | |
| or_error [Extensions] | |
P | |
| packed [Env] | |
| parametrized [Compute_prec] |
Some values are parametrized by the list of statements
|
| path [Ind_cst] | |
| path_cell [Ind_cst] | |
| payload [Bool_lit_intf.S] |
Additional data carried in the literal
|
| payload [BBox] | |
| phase [Phases] | |
| pre_rewrite [MetaProverState_intf.S] | |
| prec_action [Extensions] |
Actions that modify the set of rules
Compute_prec
|
| print_hook [Literal] |
might print the literal on the given buffer.
|
| printer [Avatar] | |
| profile [ClauseQueue_intf] | |
| profile [ClauseQueue] | |
| proof [Sat_solver_intf] | |
| proof [Clause_intf] | |
| proof [ProofStep] | |
| proof_step [Sat_solver_intf] | |
| proof_step [Clause_intf] | |
R | |
| redundant_rule [Env_intf.S] |
check whether the clause is redundant w.r.t the set
|
| res [Classify_cst] | |
| result [Sat_solver_intf] | |
| result [ProofStep] | |
| rewrite [MetaProverState_intf.S] |
Rewrite system
|
| rule [ProofStep] | |
| rule_clause [Rewrite_rule] | |
| rule_info [ProofStep] | |
| rule_term [Rewrite_rule] | |
| rw_simplify_rule [Env_intf.S] | |
S | |
| save_level [Sat_solver_intf.S] | |
| sequence [ProofStep] | |
| simplify_rule [Env_intf.S] |
Simplify the clause structurally (basic simplifications),
in the simplification monad.
|
| solution [Monome.Int.Solve] |
List of constraints (term = monome).
|
| spec [AC_intf] | |
| spec [AC] | |
| split [Literal.Pos] |
Full description of a position in a literal.
|
| state [Extensions] | |
| state_actions [Extensions] | |
| stats [Env_intf.S] |
statistics on clauses : num active, num passive, num simplification
|
| stats [ProofState_intf.S] |
statistics on the state (num active, num passive, num simplification)
|
| subst [ClauseContext] | |
| szs_status [Saturate] |
The SZS status of a state
|
T | |
| t [MetaProverState_intf.S.Result] | |
| t [Rewrite_rule.Set] | |
| t [Flex_state] | |
| t [Phases] |
Monad type, representing an action starting at phase
'p1
and stopping at phase 'p2
|
| t [Trail] | |
| t [Bool_lit.PAYLOAD] | |
| t [ClauseContext] |
A context is represented as a regular array of literals, containing
at least one specific variable
x, paired with this variable x.
|
| t [Bool_lit_intf.S] | |
| t [BBox] | |
| t [ArithLit.Focus] |
focus on a term in one of the two monomes
|
| t [ArithLit] | |
| t [Monome.Int] | |
| t [Monome.Focus] | |
| t [Monome] |
A monome over terms, with coefficient of type 'a
|
| t [Params] | |
| t [Compute_prec] | |
| t [SimplM] | |
| t [Selection] | |
| t [ProofPrint] | |
| t [ProofStep] |
A proof step, without the conclusion
|
| t [Literals] |
Array of literals
|
| t [Literal] |
a literal, that is, a signed atomic formula
|
| t [Extensions] |
An extension contains a number of actions that can modify the
Flex_state.t
during preprocessing, or modify the Env_intf.S once it is built.
|
| t [SClause] | |
| t [ClauseQueue_intf.S.WeightFun] |
attribute a weight to a clause.
|
| t [Clause_intf.S.WithPos] | |
| t [Clause_intf.S.Eligible] |
Eligibility criterion for a literal
|
| t [Clause_intf.S] | |
| t [ClauseQueue_intf.S] |
A priority queue.
|
| term [MetaProverState_intf] | |
| term [EnumTypes] | |
| term [ClauseContext] | |
| term [ArithLit] | |
| term [Monome] | |
| term [Literals] | |
| term [Literal] | |
| term_rewrite_rule [Env_intf.S] |
Rewrite rule on terms
|
| theory [MetaProverState_intf.S] | |
U | |
| unary_inf_rule [Env_intf.S] | |
| unif [ArithLit] | |
V | |
| valuation [Trail] |
A boolean valuation
|