A | |
| add_atom [Solver_types_intf.S] |
Returns the atom associated with the given formula
|
| add_term [Solver_types_intf.S] |
Returns the variable associated with the term
|
| assign [Plugin_intf.S] |
Returns an assignment value for the given term.
|
| assume [Internal.Make] |
Add the list of clauses to the current set of assumptions.
|
| assume [Solver_intf.S] |
Add the list of clauses to the current set of assumptions.
|
| assume [Plugin_intf.S] |
Assume the formulas in the slice, possibly pushing new formulas to be propagated,
and returns the result of the new assumptions.
|
| assume [Theory_intf.S] |
Assume the formulas in the slice, possibly pushing new formulas to be propagated,
and returns the result of the new assumptions.
|
B | |
| backtrack [Plugin_intf.S] |
Backtrack to the given level.
|
| backtrack [Theory_intf.S] |
Backtrack to the given level.
|
C | |
| check [Internal.Make] |
Check the satisfiability of the current model.
|
| check [Res_intf.S] |
Check the contents of a proof.
|
| context [Dedukti.Arg] | |
| current_level [Plugin_intf.S] |
Return the current level of the theory (either the empty/beginning state, or the
last level returned by the
assume function).
|
| current_level [Theory_intf.S] |
Return the current level of the theory (either the empty/beginning state, or the
last level returned by the
assume function).
|
D | |
| debug [Log] |
Simpler version of
Log.debug, without formatting
|
| debugf [Log] |
Emit a debug message at the given level.
|
| dummy [Expr_intf.S.Formula] |
Constant formula.
|
| dummy [Plugin_intf.S] |
A dummy level.
|
| dummy [Theory_intf.S] |
A dummy level.
|
| dummy [Formula_intf.S] |
Formula constant.
|
| dummy_atom [Solver_types_intf.S] | |
| dummy_clause [Solver_types_intf.S] |
Dummy values for use in vector dummys
|
| dummy_var [Solver_types_intf.S] | |
E | |
| elt_of_lit [Solver_types_intf.S] | |
| elt_of_var [Solver_types_intf.S] |
Constructors & destructor for elements
|
| empty_clause [Solver_types_intf.S] |
The empty clause
|
| equal [Expr_intf.S.Formula] |
Equality over formulas.
|
| equal [Expr_intf.S.Term] |
Equality over terms.
|
| equal [Formula_intf.S] |
Equality over formulas.
|
| eval [Internal.Make] |
Returns the valuation of a formula in the current state
of the sat solver.
|
| eval [Plugin_intf.S] |
Returns the evaluation of the formula in the current assignment
|
| eval_level [Internal.Make] |
Return the current assignement of the literals, as well as its
decision level.
|
| expand [Res_intf.S] |
Return the proof step at the root of a given proof.
|
| export_dimacs [Solver_intf.S] |
Prints the entire set of clauses in the input problem
(including hypothesis, lemmas and local assumptions),
in the dimacs format.
|
| export_icnf [Solver_intf.S] |
Export the current problem contents to iCNF format.
|
F | |
| f_false [Tseitin_intf.S] |
The
false formula, i.e a formula that cannot be satisfied.
|
| f_true [Tseitin_intf.S] |
The
true formula, i.e a formula that is always satisfied.
|
| fold [Res_intf.S] | fold f acc p, fold f over the proof p and all its node.
|
| fresh [Sat.Expr] |
Make a fresh atom
|
| fresh [Tseitin_intf.Arg] |
Generate fresh formulas (that are different from any other).
|
| fresh_hname [Solver_types_intf.S] |
Fresh names for clauses
|
| fresh_lname [Solver_types_intf.S] | |
| fresh_name [Solver_types_intf.S] | |
| fresh_tname [Solver_types_intf.S] | |
| full_slice [Internal.Make] |
View the current state of the trail as a slice.
|
G | |
| get_debug [Log] |
Current debug level
|
| get_elt [Solver_types_intf.S] | |
| get_elt_id [Solver_types_intf.S] | |
| get_elt_level [Solver_types_intf.S] | |
| get_elt_weight [Solver_types_intf.S] | |
| get_tag [Solver_intf.S] |
Recover tag from a clause, if any
|
H | |
| hash [Expr_intf.S.Formula] |
Hashing function for formulas.
|
| hash [Expr_intf.S.Term] |
Hashing function for terms.
|
| hash [Formula_intf.S] |
Hashing function for formulas.
|
| history [Internal.Make] |
Returns the history of learnt clauses, with no guarantees on order.
|
| hyps [Internal.Make] |
Returns the vector of assumptions used by the solver.
|
I | |
| if_sat [Plugin_intf.S] |
Called at the end of the search in case a model has been found.
|
| if_sat [Theory_intf.S] |
Called at the end of the search in case a model has been found.
|
| iter_assignable [Plugin_intf.S] |
An iterator over the subterms of a formula that should be assigned a value (usually the poure subterms)
|
| iter_elt [Solver_types_intf.S] |
Read access to the vector of variables created
|
L | |
| lemma_info [Dot.Arg] |
Generate some information about a theory specific lemmas.
|
| local [Internal.Make] |
Add local assumptions
|
M | |
| make [Sat.Expr] |
Make a proposition from an integer.
|
| make_and [Tseitin_intf.S] |
Creates the conjunction of a list of formulas.
|
| make_atom [Tseitin_intf.S] | make_atom p builds the boolean formula equivalent to the atomic formula p.
|
| make_boolean_var [Solver_types_intf.S] |
Returns the variable linked with the given formula, and whether the atom associated with the formula
is
var.pa or var.na
|
| make_clause [Solver_types_intf.S] | make_clause name atoms size premise creates a clause with the given attributes.
|
| make_cnf [Tseitin_intf.S] | make_cnf f returns a conjunctive normal form of f under the form: a
list (which is a conjunction) of lists (which are disjunctions) of
atomic formulas.
|
| make_equiv [Tseitin_intf.S] | make_equiv p q creates the boolena formula "p is equivalent to q".
|
| make_imply [Tseitin_intf.S] | make_imply p q creates the boolean formula "p implies q".
|
| make_not [Tseitin_intf.S] |
Creates the negation of a boolean formula.
|
| make_or [Tseitin_intf.S] |
Creates the disjunction of a list of formulas.
|
| make_xor [Tseitin_intf.S] | make_xor p q creates the boolean formula "p xor q".
|
| mcsat [Solver_types_intf.S] |
TODO:deprecate.
|
| merge [Res_intf.S] |
Merge two sorted atom list using a suitable comparison function.
|
| model [Internal.Make] |
Returns the model found if the formula is satisfiable.
|
N | |
| nb_elt [Solver_types_intf.S] | |
| neg [Tseitin_intf.Arg] |
Negation of atomic formulas.
|
| neg [Expr_intf.S.Formula] |
Formula negation
|
| neg [Formula_intf.S] |
Formula negation.
|
| new_atom [Internal.Make] |
Add a new atom (i.e propositional formula) to the solver.
|
| new_atom [Solver_intf.S] |
Add a new atom (i.e propositional formula) to the solver.
|
| new_lit [Internal.Make] |
Add a new litteral (i.e term) to the solver.
|
| new_lit [Solver_intf.S] |
Add a new litteral (i.e term) to the solver.
|
| norm [Expr_intf.S.Formula] |
Returns a 'normalized' form of the formula, possibly negated
(in which case return
Negated).
|
| norm [Formula_intf.S] |
Returns a 'normalized' form of the formula, possibly negated
(in which case return
Negated).
|
O | |
| of_atom [Solver_types_intf.S] |
Constructors and destructors
|
| of_lit [Solver_types_intf.S] | |
P | |
| pop [Internal.Make] |
Pop a decision level for local assumptions.
|
| pp [Solver_types_intf.S] | |
| pp_atom [Solver_types_intf.S] | |
| pp_clause [Solver_types_intf.S] | |
| pp_dimacs [Solver_types_intf.S] | |
| pp_lit [Solver_types_intf.S] | |
| pp_reason [Solver_types_intf.S] |
Debug function for atoms and clauses (very verbose)
|
| print [Dedukti.Arg] | |
| print [Backend_intf.S] |
A function for printing proofs in the desired format.
|
| print [Tseitin_intf.S] | print fmt f prints the formula on the formatter fmt.
|
| print [Tseitin_intf.Arg] |
Print the given formula.
|
| print [Expr_intf.S.Formula] |
Printing function used among other thing for debugging.
|
| print [Expr_intf.S.Term] |
Printing function used among other for debugging.
|
| print [Formula_intf.S] |
Printing function used among other thing for debugging.
|
| print_atom [Dot.Arg] |
Print the contents of the given atomic formulas.
|
| print_atom [Solver_types_intf.S] | |
| print_clause [Solver_types_intf.S] |
Pretty printing functions for atoms and clauses
|
| print_clause [Res_intf.S] |
A nice looking printer for clauses, which sort the atoms before printing.
|
| print_lit [Solver_types_intf.S] | |
| prove [Dedukti.Arg] | |
| prove [Res_intf.S] |
Given a clause, return a proof of that clause.
|
| prove_atom [Res_intf.S] |
Given an atom
a, returns a proof of the clause [a] if a is true at level 0
|
| prove_unsat [Res_intf.S] |
Given a conflict clause
c, returns a proof of the empty clause.
|
| push [Internal.Make] |
Create a decision level for local assumptions.
|
R | |
| resolve [Res_intf.S] |
Performs a "resolution step" on a sorted list of atoms.
|
S | |
| set_debug [Log] |
Set debug level
|
| set_debug_out [Log] |
Change the output formatter.
|
| set_elt_level [Solver_types_intf.S] | |
| set_elt_weight [Solver_types_intf.S] |
Accessors for elements
|
| solve [Internal.Make] |
Try and solves the current set of assumptions.
|
| solve [Solver_intf.S] |
Try and solves the current set of assumptions.
|
T | |
| temp [Internal.Make] |
Returns the clauses coreesponding to the local assumptions.
|
| to_list [Res_intf.S] |
Returns the sorted list of atoms of a clause.
|
| trail [Internal.Make] |
Returns the current trail.
|
| true_at_level0 [Solver_intf.S] | true_at_level0 a returns true if a was proved at level0, i.e.
|
U | |
| unsat_conflict [Internal.Make] |
Returns the unsat clause found at the toplevel, if it exists (i.e if
solve has raised Unsat)
|
| unsat_core [Solver_intf.S] |
Returns the unsat core of a given proof.
|
| unsat_core [Res_intf.S] |
Returns the unsat_core of the given proof, i.e the lists of conclusions of all leafs of the proof.
|