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
|