Module `Solver.Solver_internal`

module T : sig ... end

module Lit : sig ... end

type ty = T.Ty.t
type term = T.Term.t
type term_store = T.Term.store
type ty_store = T.Ty.store
type proof = proof
type dproof = proof -> unit

module P : sig ... end

type t = Sidekick_smt_solver.Make(Solver_arg).Solver_internal.t
type solver = t

val tst : t -> term_store
val ty_st : t -> ty_store
val stats : t -> Sidekick_util.Stat.t
val with_proof : t -> (proof -> unit) -> unit

type theory_actions = Sidekick_smt_solver.Make(Solver_arg).Solver_internal.theory_actions
type lit = Lit.t

val define_const : t -> const:term -> rhs:term -> unit

module CC : sig ... end

val cc : t -> CC.t

module Simplify : sig ... end

type simplify_hook = Simplify.hook

val add_simplifier : t -> Simplify.hook -> unit
val simplifier : t -> Simplify.t
val simplify_t : t -> term -> term option
val simp_t : t -> term -> term

module type PREPROCESS_ACTS = sig ... end

type preprocess_actions = (module PREPROCESS_ACTS)
type preprocess_hook = t -> preprocess_actions -> term -> term option

val on_preprocess : t -> preprocess_hook -> unit
val preprocess_acts_of_acts : t -> theory_actions -> preprocess_actions
val raise_conflict : t -> theory_actions -> lit list -> dproof -> 'a
val push_decision : t -> theory_actions -> lit -> unit
val propagate : t -> theory_actions -> lit -> reason:(unit -> lit list * dproof) -> unit
val propagate_l : t -> theory_actions -> lit -> lit list -> dproof -> unit
val add_clause_temp : t -> theory_actions -> lit list -> dproof -> unit
val add_clause_permanent : t -> theory_actions -> lit list -> dproof -> unit
val mk_lit : t -> theory_actions -> ?⁠sign:bool -> term -> lit
val preprocess_term : t -> preprocess_actions -> term -> term
val add_lit : t -> theory_actions -> ?⁠default_pol:bool -> lit -> unit
val add_lit_t : t -> theory_actions -> ?⁠sign:bool -> term -> unit
val cc_raise_conflict_expl : t -> theory_actions -> CC.Expl.t -> 'a
val cc_find : t -> CC.N.t -> CC.N.t
val cc_are_equal : t -> term -> term -> bool
val cc_merge : t -> theory_actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit
val cc_merge_t : t -> theory_actions -> term -> term -> CC.Expl.t -> unit
val cc_add_term : t -> term -> CC.N.t
val cc_mem_term : t -> term -> bool
val on_cc_pre_merge : t -> (CC.t -> theory_actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit) -> unit
val on_cc_post_merge : t -> (CC.t -> theory_actions -> CC.N.t -> CC.N.t -> unit) -> unit
val on_cc_new_term : t -> (CC.t -> CC.N.t -> term -> unit) -> unit
val on_cc_is_subterm : t -> (CC.N.t -> term -> unit) -> unit
val on_cc_conflict : t -> (CC.t -> th:bool -> lit list -> unit) -> unit
val on_cc_propagate : t -> (CC.t -> lit -> (unit -> lit list * dproof) -> unit) -> unit
val on_partial_check : t -> (t -> theory_actions -> lit Iter.t -> unit) -> unit
val on_final_check : t -> (t -> theory_actions -> lit Iter.t -> unit) -> unit

type model_hook = recurse:(t -> CC.N.t -> term) -> t -> CC.N.t -> term option

val on_model_gen : t -> model_hook -> unit