Module `Process.Solver`

module T : Sidekick_core.TERM with type Term.t = Sidekick_base.Term.t and type Term.store = Sidekick_base.Term.store and type Ty.t = Sidekick_base.Ty.t and type Ty.store = Sidekick_base.Ty.store

module Lit : Sidekick_core.LIT with module T = T

type proof = Sidekick_base.Proof_stub.t

module P : Sidekick_core.PROOF with type lit = Lit.t and type t = proof and type term = T.Term.t

module Solver_internal : Sidekick_core.SOLVER_INTERNAL with module T = T and module Lit = Lit and type proof = proof and module P = P: Internal solver, available to theories.

type t: The solver's state.

type solver = t
type term = T.Term.t
type ty = T.Ty.t
type lit = Lit.t
type dproof = proof -> unit: Delayed proof. This is used to build a proof step on demand.

module type THEORY = sig ... end

type theory = (module THEORY): A theory that can be used for this particular solver.

type 'a theory_p = (module THEORY with type t = 'a): A theory that can be used for this particular solver, with state of type 'a.

val mk_theory : name:string -> create_and_setup:(Solver_internal.t -> 'th) -> ?⁠push_level:('th -> unit) -> ?⁠pop_levels:('th -> int -> unit) -> unit -> theory: Helper to create a theory.

module Model : sig ... end: Models

module Unknown : sig ... end

Main API

val stats : t -> Sidekick_util.Stat.t

val tst : t -> T.Term.store

val ty_st : t -> T.Ty.store

val create : ?⁠stat:Sidekick_util.Stat.t -> ?⁠size:[ `Big | `Tiny | `Small ] -> proof:proof -> theories:theory list -> T.Term.store -> T.Ty.store -> unit -> t

Create a new solver.

It needs a term state and a type state to manipulate terms and types. All terms and types interacting with this solver will need to come from these exact states.

parameter store_proof: if true, proofs from the SAT solver and theories are retained and potentially accessible after solve returns UNSAT.

parameter size: influences the size of initial allocations.

parameter theories: theories to load from the start. Other theories can be added using add_theory.

val add_theory : t -> theory -> unit: Add a theory to the solver. This should be called before any call to solve or to add_clause and the likes (otherwise the theory will have a partial view of the problem).

val add_theory_p : t -> 'a theory_p -> 'a: Add the given theory and obtain its state

val add_theory_l : t -> theory list -> unit

val mk_lit_t : t -> ?⁠sign:bool -> term -> lit

mk_lit_t _ ~sign t returns lit', where lit' is preprocess(lit) and lit is an internal representation of ± t.

The proof of |- lit = lit' is directly added to the solver's proof.

val add_clause : t -> lit Sidekick_util.IArray.t -> dproof -> unit: add_clause solver cs adds a boolean clause to the solver. Subsequent calls to solve will need to satisfy this clause.

val add_clause_l : t -> lit list -> dproof -> unit: Add a clause to the solver, given as a list.

val assert_terms : t -> term list -> unit: Helper that turns each term into an atom, before adding the result to the solver as an assertion

val assert_term : t -> term -> unit: Helper that turns the term into an atom, before adding the result to the solver as a unit clause assertion

type res = | Sat of Model.t Satisfiable | Unsat of { unsat_core : unit -> lit Iter.t; subset of assumptions responsible for unsat } Unsatisfiable | Unknown of Unknown.t Unknown, obtained after a timeout, memory limit, etc.: Result of solving for the current set of clauses

val solve : ?⁠on_exit:(unit -> unit) list -> ?⁠check:bool -> ?⁠on_progress:(t -> unit) -> assumptions:lit list -> t -> res

solve s checks the satisfiability of the clauses added so far to s.

parameter check: if true, the model is checked before returning.

parameter on_progress: called regularly during solving.

parameter assumptions: a set of atoms held to be true. The unsat core, if any, will be a subset of assumptions.

parameter on_exit: functions to be run before this returns

val pp_stats : t CCFormat.printer: Print some statistics. What it prints exactly is unspecified.