diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/Gensym/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/Gensym/index.html deleted file mode 100644 index d995757c..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/Gensym/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Gensym (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.Gensym)

Module A.Gensym

type t = Gensym.t
val create : S.T.Term.store -> t
val tst : t -> S.T.Term.store
val copy : t -> t
val fresh_term : t -> pre:string -> S.T.Ty.t -> term
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/Q/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/Q/index.html deleted file mode 100644 index 9f30dc56..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/Q/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Q (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.Q)

Module A.Q

type t = Q.t
val zero : t
val one : t
val minus_one : t
val abs : t -> t
val sign : t -> int
val of_int : int -> t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t CCFormat.printer
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
type bigint = Z.t
val (/) : t -> t -> t
val num : t -> bigint
val denum : t -> bigint
val infinity : t
val minus_infinity : t
val of_bigint : bigint -> t
val is_real : t -> bool
val is_int : t -> bool
val as_int : t -> bigint option
val floor : t -> bigint
val ceil : t -> bigint
val pp_approx : int -> Stdlib.Format.formatter -> t -> unit
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Lit/T/Fun/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Lit/T/Fun/index.html deleted file mode 100644 index ec376d3c..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Lit/T/Fun/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Fun (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Lit.T.Fun)

Module T.Fun

type t = T.Fun.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Lit/T/Term/Tbl/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Lit/T/Term/Tbl/index.html deleted file mode 100644 index a1a606df..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Lit/T/Term/Tbl/index.html +++ /dev/null @@ -1,23 +0,0 @@ - -Tbl (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Lit.T.Term.Tbl)

Module Term.Tbl

type key = t
type !'a t = 'a T.Term.Tbl.t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : ( key -> 'a -> unit ) -> 'a t -> unit
val filter_map_inplace : ( key -> 'a -> 'a option ) -> 'a t -> unit
val fold : ( key -> 'a -> 'b -> 'b ) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib.Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val get : 'a t -> key -> 'a option
val get_or : 'a t -> key -> default:'a -> 'a
val add_list : 'a list t -> key -> 'a -> unit
val incr : ?by:int -> int t -> key -> unit
val decr : ?by:int -> int t -> key -> unit
val keys : 'a t -> key CCHashtbl.iter
val values : 'a t -> 'a CCHashtbl.iter
val keys_list : 'a t -> key list
val values_list : 'a t -> 'a list
val map_list : ( key -> 'a -> 'b ) -> 'a t -> 'b list
val to_iter : 'a t -> (key * 'a) CCHashtbl.iter
val add_iter : 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_iter_with : - f:( key -> 'a -> 'a -> 'a ) -> - 'a t -> - (key * 'a) CCHashtbl.iter -> - unit
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val add_seq_with : - f:( key -> 'a -> 'a -> 'a ) -> - 'a t -> - (key * 'a) Stdlib.Seq.t -> - unit
val of_iter : (key * 'a) CCHashtbl.iter -> 'a t
val of_iter_with : - f:( key -> 'a -> 'a -> 'a ) -> - (key * 'a) CCHashtbl.iter -> - 'a t
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val of_seq_with : - f:( key -> 'a -> 'a -> 'a ) -> - (key * 'a) Stdlib.Seq.t -> - 'a t
val add_iter_count : int t -> key CCHashtbl.iter -> unit
val add_seq_count : int t -> key Stdlib.Seq.t -> unit
val of_iter_count : key CCHashtbl.iter -> int t
val of_seq_count : key Stdlib.Seq.t -> int t
val to_list : 'a t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a t
val of_list_with : f:( key -> 'a -> 'a -> 'a ) -> (key * 'a) list -> 'a t
val update : 'a t -> f:( key -> 'a option -> 'a option ) -> k:key -> unit
val get_or_add : 'a t -> f:( key -> 'a ) -> k:key -> 'a
val pp : - ?pp_start:unit CCHashtbl.printer -> - ?pp_stop:unit CCHashtbl.printer -> - ?pp_sep:unit CCHashtbl.printer -> - ?pp_arrow:unit CCHashtbl.printer -> - key CCHashtbl.printer -> - 'a CCHashtbl.printer -> - 'a t CCHashtbl.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Lit/T/Term/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Lit/T/Term/index.html deleted file mode 100644 index 9aca718f..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Lit/T/Term/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Term (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Lit.T.Term)

Module T.Term

type t = T.Term.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Term.store
val ty : t -> Ty.t
val bool : store -> bool -> t
val as_bool : t -> bool option
val abs : store -> t -> t * bool
val map_shallow : store -> ( t -> t ) -> t -> t
val iter_shallow : store -> ( t -> unit ) -> t -> unit
val iter_dag : t -> ( t -> unit ) -> unit
module Tbl : sig ... end
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Lit/T/Ty/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Lit/T/Ty/index.html deleted file mode 100644 index 49cac7a6..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Lit/T/Ty/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Ty (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Lit.T.Ty)

Module T.Ty

type t = T.Ty.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Ty.store
val bool : store -> t
val is_bool : t -> bool
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Lit/T/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Lit/T/index.html deleted file mode 100644 index 798d8c47..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Lit/T/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -T (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Lit.T)

Module Lit.T

module Fun : sig ... end
module Ty : sig ... end
module Term : sig ... end
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Lit/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Lit/index.html deleted file mode 100644 index 23d0e6e7..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Lit/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Lit (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Lit)

Module S.Lit

module T : sig ... end
type t = S.Lit.t
val term : t -> T.Term.t
val sign : t -> bool
val neg : t -> t
val abs : t -> t
val signed_term : t -> T.Term.t * bool
val atom : ?sign:bool -> T.Term.store -> T.Term.t -> t
val norm_sign : t -> t * bool
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Model/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Model/index.html deleted file mode 100644 index 89326108..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Model/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Model (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Model)

Module S.Model

type t = S.Model.t
val empty : t
val mem : t -> term -> bool
val find : t -> term -> term option
val eval : t -> term -> term option
val pp : t Sidekick_core.Fmt.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/P/Step_vec/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/P/Step_vec/index.html deleted file mode 100644 index eab432d2..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/P/Step_vec/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Step_vec (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.P.Step_vec)

Module P.Step_vec

type elt = proof_step
val size : t -> int
val get : t -> int -> elt
val iter : f:( elt -> unit ) -> t -> unit
val iteri : f:( int -> elt -> unit ) -> t -> unit
val create : ?cap:int -> unit -> t
val clear : t -> unit
val copy : t -> t
val is_empty : t -> bool
val push : t -> elt -> unit
val fast_remove : t -> int -> unit
val filter_in_place : ( elt -> bool ) -> t -> unit
val ensure_size : t -> int -> unit
val pop : t -> elt
val set : t -> int -> elt -> unit
val shrink : t -> int -> unit
val to_iter : t -> elt Iter.t
val to_array : t -> elt array
val fold_left : ( 'a -> elt -> 'a ) -> 'a -> t -> 'a
val pp : elt CCFormat.printer -> t CCFormat.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/P/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/P/index.html deleted file mode 100644 index aca9682b..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/P/index.html +++ /dev/null @@ -1,6 +0,0 @@ - -P (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.P)

Module S.P

type t = proof
type proof_step = proof_step
type term = T.Term.t
type lit = Lit.t
type proof_rule = t -> proof_step
module Step_vec : sig ... end
val enabled : t -> bool
val emit_input_clause : lit Iter.t -> proof_rule
val emit_redundant_clause : lit Iter.t -> hyps:proof_step Iter.t -> proof_rule
val emit_unsat_core : lit Iter.t -> proof_rule
val emit_unsat : proof_step -> t -> unit
val del_clause : proof_step -> lit Iter.t -> t -> unit
val lemma_cc : lit Iter.t -> proof_rule
val define_term : term -> term -> proof_rule
val proof_p1 : proof_step -> proof_step -> proof_rule
val proof_r1 : proof_step -> proof_step -> proof_rule
val proof_res : pivot:term -> proof_step -> proof_step -> proof_rule
val with_defs : proof_step -> proof_step Iter.t -> proof_rule
val lemma_true : term -> proof_rule
val lemma_preprocess : term -> term -> using:proof_step Iter.t -> proof_rule
val lemma_rw_clause : - proof_step -> - res:lit Iter.t -> - using:proof_step Iter.t -> - proof_rule
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Registry/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Registry/index.html deleted file mode 100644 index 9651a966..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Registry/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Registry (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Registry)

Module S.Registry

type t = S.Registry.t
type 'a key = 'a S.Registry.key
val create_key : unit -> 'a key
val create : unit -> t
val get : t -> 'a key -> 'a option
val set : t -> 'a key -> 'a -> unit
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Actions/Lit/T/Fun/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Actions/Lit/T/Fun/index.html deleted file mode 100644 index e789ac2e..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Actions/Lit/T/Fun/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Fun (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Solver_internal.CC.Actions.Lit.T.Fun)

Module T.Fun

type t = T.Fun.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Actions/Lit/T/Term/Tbl/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Actions/Lit/T/Term/Tbl/index.html deleted file mode 100644 index 0b789d60..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Actions/Lit/T/Term/Tbl/index.html +++ /dev/null @@ -1,23 +0,0 @@ - -Tbl (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Solver_internal.CC.Actions.Lit.T.Term.Tbl)

Module Term.Tbl

type key = t
type !'a t = 'a T.Term.Tbl.t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : ( key -> 'a -> unit ) -> 'a t -> unit
val filter_map_inplace : ( key -> 'a -> 'a option ) -> 'a t -> unit
val fold : ( key -> 'a -> 'b -> 'b ) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib.Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val get : 'a t -> key -> 'a option
val get_or : 'a t -> key -> default:'a -> 'a
val add_list : 'a list t -> key -> 'a -> unit
val incr : ?by:int -> int t -> key -> unit
val decr : ?by:int -> int t -> key -> unit
val keys : 'a t -> key CCHashtbl.iter
val values : 'a t -> 'a CCHashtbl.iter
val keys_list : 'a t -> key list
val values_list : 'a t -> 'a list
val map_list : ( key -> 'a -> 'b ) -> 'a t -> 'b list
val to_iter : 'a t -> (key * 'a) CCHashtbl.iter
val add_iter : 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_iter_with : - f:( key -> 'a -> 'a -> 'a ) -> - 'a t -> - (key * 'a) CCHashtbl.iter -> - unit
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val add_seq_with : - f:( key -> 'a -> 'a -> 'a ) -> - 'a t -> - (key * 'a) Stdlib.Seq.t -> - unit
val of_iter : (key * 'a) CCHashtbl.iter -> 'a t
val of_iter_with : - f:( key -> 'a -> 'a -> 'a ) -> - (key * 'a) CCHashtbl.iter -> - 'a t
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val of_seq_with : - f:( key -> 'a -> 'a -> 'a ) -> - (key * 'a) Stdlib.Seq.t -> - 'a t
val add_iter_count : int t -> key CCHashtbl.iter -> unit
val add_seq_count : int t -> key Stdlib.Seq.t -> unit
val of_iter_count : key CCHashtbl.iter -> int t
val of_seq_count : key Stdlib.Seq.t -> int t
val to_list : 'a t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a t
val of_list_with : f:( key -> 'a -> 'a -> 'a ) -> (key * 'a) list -> 'a t
val update : 'a t -> f:( key -> 'a option -> 'a option ) -> k:key -> unit
val get_or_add : 'a t -> f:( key -> 'a ) -> k:key -> 'a
val pp : - ?pp_start:unit CCHashtbl.printer -> - ?pp_stop:unit CCHashtbl.printer -> - ?pp_sep:unit CCHashtbl.printer -> - ?pp_arrow:unit CCHashtbl.printer -> - key CCHashtbl.printer -> - 'a CCHashtbl.printer -> - 'a t CCHashtbl.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Actions/Lit/T/Term/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Actions/Lit/T/Term/index.html deleted file mode 100644 index fca92c9e..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Actions/Lit/T/Term/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Term (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Solver_internal.CC.Actions.Lit.T.Term)

Module T.Term

type t = T.Term.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Term.store
val ty : t -> Ty.t
val bool : store -> bool -> t
val as_bool : t -> bool option
val abs : store -> t -> t * bool
val map_shallow : store -> ( t -> t ) -> t -> t
val iter_shallow : store -> ( t -> unit ) -> t -> unit
val iter_dag : t -> ( t -> unit ) -> unit
module Tbl : sig ... end
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Actions/Lit/T/Ty/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Actions/Lit/T/Ty/index.html deleted file mode 100644 index 7027f651..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Actions/Lit/T/Ty/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Ty (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Solver_internal.CC.Actions.Lit.T.Ty)

Module T.Ty

type t = T.Ty.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Ty.store
val bool : store -> t
val is_bool : t -> bool
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Actions/Lit/T/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Actions/Lit/T/index.html deleted file mode 100644 index d82c5b01..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Actions/Lit/T/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -T (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Solver_internal.CC.Actions.Lit.T)

Module Lit.T

module Fun : sig ... end
module Ty : sig ... end
module Term : sig ... end
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Actions/Lit/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Actions/Lit/index.html deleted file mode 100644 index d7316d86..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Actions/Lit/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Lit (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Solver_internal.CC.Actions.Lit)

Module Actions.Lit

module T : sig ... end
type t = Lit.t
val term : t -> T.Term.t
val sign : t -> bool
val neg : t -> t
val abs : t -> t
val signed_term : t -> T.Term.t * bool
val atom : ?sign:bool -> T.Term.store -> T.Term.t -> t
val norm_sign : t -> t * bool
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Actions/P/Step_vec/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Actions/P/Step_vec/index.html deleted file mode 100644 index 9b63bc1f..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Actions/P/Step_vec/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Step_vec (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Solver_internal.CC.Actions.P.Step_vec)

Module P.Step_vec

type elt = proof_step
val size : t -> int
val get : t -> int -> elt
val iter : f:( elt -> unit ) -> t -> unit
val iteri : f:( int -> elt -> unit ) -> t -> unit
val create : ?cap:int -> unit -> t
val clear : t -> unit
val copy : t -> t
val is_empty : t -> bool
val push : t -> elt -> unit
val fast_remove : t -> int -> unit
val filter_in_place : ( elt -> bool ) -> t -> unit
val ensure_size : t -> int -> unit
val pop : t -> elt
val set : t -> int -> elt -> unit
val shrink : t -> int -> unit
val to_iter : t -> elt Iter.t
val to_array : t -> elt array
val fold_left : ( 'a -> elt -> 'a ) -> 'a -> t -> 'a
val pp : elt CCFormat.printer -> t CCFormat.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Actions/P/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Actions/P/index.html deleted file mode 100644 index 18c78e11..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Actions/P/index.html +++ /dev/null @@ -1,6 +0,0 @@ - -P (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Solver_internal.CC.Actions.P)

Module Actions.P

type t = proof
type proof_step = proof_step
type term = T.Term.t
type lit = Lit.t
type proof_rule = t -> proof_step
module Step_vec : sig ... end
val enabled : t -> bool
val emit_input_clause : lit Iter.t -> proof_rule
val emit_redundant_clause : lit Iter.t -> hyps:proof_step Iter.t -> proof_rule
val emit_unsat_core : lit Iter.t -> proof_rule
val emit_unsat : proof_step -> t -> unit
val del_clause : proof_step -> lit Iter.t -> t -> unit
val lemma_cc : lit Iter.t -> proof_rule
val define_term : term -> term -> proof_rule
val proof_p1 : proof_step -> proof_step -> proof_rule
val proof_r1 : proof_step -> proof_step -> proof_rule
val proof_res : pivot:term -> proof_step -> proof_step -> proof_rule
val with_defs : proof_step -> proof_step Iter.t -> proof_rule
val lemma_true : term -> proof_rule
val lemma_preprocess : term -> term -> using:proof_step Iter.t -> proof_rule
val lemma_rw_clause : - proof_step -> - res:lit Iter.t -> - using:proof_step Iter.t -> - proof_rule
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Actions/T/Fun/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Actions/T/Fun/index.html deleted file mode 100644 index 92809332..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Actions/T/Fun/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Fun (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Solver_internal.CC.Actions.T.Fun)

Module T.Fun

type t = T.Fun.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Actions/T/Term/Tbl/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Actions/T/Term/Tbl/index.html deleted file mode 100644 index 4a2d16c0..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Actions/T/Term/Tbl/index.html +++ /dev/null @@ -1,23 +0,0 @@ - -Tbl (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Solver_internal.CC.Actions.T.Term.Tbl)

Module Term.Tbl

type key = t
type !'a t = 'a T.Term.Tbl.t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : ( key -> 'a -> unit ) -> 'a t -> unit
val filter_map_inplace : ( key -> 'a -> 'a option ) -> 'a t -> unit
val fold : ( key -> 'a -> 'b -> 'b ) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib.Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val get : 'a t -> key -> 'a option
val get_or : 'a t -> key -> default:'a -> 'a
val add_list : 'a list t -> key -> 'a -> unit
val incr : ?by:int -> int t -> key -> unit
val decr : ?by:int -> int t -> key -> unit
val keys : 'a t -> key CCHashtbl.iter
val values : 'a t -> 'a CCHashtbl.iter
val keys_list : 'a t -> key list
val values_list : 'a t -> 'a list
val map_list : ( key -> 'a -> 'b ) -> 'a t -> 'b list
val to_iter : 'a t -> (key * 'a) CCHashtbl.iter
val add_iter : 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_iter_with : - f:( key -> 'a -> 'a -> 'a ) -> - 'a t -> - (key * 'a) CCHashtbl.iter -> - unit
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val add_seq_with : - f:( key -> 'a -> 'a -> 'a ) -> - 'a t -> - (key * 'a) Stdlib.Seq.t -> - unit
val of_iter : (key * 'a) CCHashtbl.iter -> 'a t
val of_iter_with : - f:( key -> 'a -> 'a -> 'a ) -> - (key * 'a) CCHashtbl.iter -> - 'a t
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val of_seq_with : - f:( key -> 'a -> 'a -> 'a ) -> - (key * 'a) Stdlib.Seq.t -> - 'a t
val add_iter_count : int t -> key CCHashtbl.iter -> unit
val add_seq_count : int t -> key Stdlib.Seq.t -> unit
val of_iter_count : key CCHashtbl.iter -> int t
val of_seq_count : key Stdlib.Seq.t -> int t
val to_list : 'a t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a t
val of_list_with : f:( key -> 'a -> 'a -> 'a ) -> (key * 'a) list -> 'a t
val update : 'a t -> f:( key -> 'a option -> 'a option ) -> k:key -> unit
val get_or_add : 'a t -> f:( key -> 'a ) -> k:key -> 'a
val pp : - ?pp_start:unit CCHashtbl.printer -> - ?pp_stop:unit CCHashtbl.printer -> - ?pp_sep:unit CCHashtbl.printer -> - ?pp_arrow:unit CCHashtbl.printer -> - key CCHashtbl.printer -> - 'a CCHashtbl.printer -> - 'a t CCHashtbl.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Actions/T/Term/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Actions/T/Term/index.html deleted file mode 100644 index c6a7b7e4..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Actions/T/Term/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Term (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Solver_internal.CC.Actions.T.Term)

Module T.Term

type t = T.Term.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Term.store
val ty : t -> Ty.t
val bool : store -> bool -> t
val as_bool : t -> bool option
val abs : store -> t -> t * bool
val map_shallow : store -> ( t -> t ) -> t -> t
val iter_shallow : store -> ( t -> unit ) -> t -> unit
val iter_dag : t -> ( t -> unit ) -> unit
module Tbl : sig ... end
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Actions/T/Ty/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Actions/T/Ty/index.html deleted file mode 100644 index 86135aa9..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Actions/T/Ty/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Ty (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Solver_internal.CC.Actions.T.Ty)

Module T.Ty

type t = T.Ty.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Ty.store
val bool : store -> t
val is_bool : t -> bool
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Actions/T/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Actions/T/index.html deleted file mode 100644 index 78d126cf..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Actions/T/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -T (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Solver_internal.CC.Actions.T)

Module Actions.T

module Fun : sig ... end
module Ty : sig ... end
module Term : sig ... end
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Actions/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Actions/index.html deleted file mode 100644 index ca3b3e1b..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Actions/index.html +++ /dev/null @@ -1,10 +0,0 @@ - -Actions (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Solver_internal.CC.Actions)

Module CC.Actions

module T : sig ... end
module Lit : sig ... end
type proof = proof
type proof_step = proof_step
module P : sig ... end
val proof : t -> proof
val raise_conflict : t -> Lit.t list -> proof_step -> 'a
val raise_semantic_conflict : - t -> - Lit.t list -> - (bool * T.Term.t * T.Term.t) list -> - 'a
val propagate : - t -> - Lit.t -> - reason:( unit -> Lit.t list * proof_step ) -> - unit
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Debug_/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Debug_/index.html deleted file mode 100644 index 9035580d..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Debug_/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Debug_ (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Solver_internal.CC.Debug_)

Module CC.Debug_

val pp : t Sidekick_core.Fmt.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Expl/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Expl/index.html deleted file mode 100644 index 167d3610..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Expl/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Expl (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Solver_internal.CC.Expl)

Module CC.Expl

val pp : t Sidekick_core.Fmt.printer
val mk_merge : N.t -> N.t -> t
val mk_merge_t : term -> term -> t
val mk_lit : lit -> t
val mk_same_value : N.t -> N.t -> t
val mk_list : t list -> t
val mk_theory : term -> term -> (term * term * t list) list -> proof_step -> t
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Lit/T/Fun/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Lit/T/Fun/index.html deleted file mode 100644 index 4b1766b8..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Lit/T/Fun/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Fun (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Solver_internal.CC.Lit.T.Fun)

Module T.Fun

type t = T.Fun.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Lit/T/Term/Tbl/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Lit/T/Term/Tbl/index.html deleted file mode 100644 index f7a3c20d..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Lit/T/Term/Tbl/index.html +++ /dev/null @@ -1,23 +0,0 @@ - -Tbl (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Solver_internal.CC.Lit.T.Term.Tbl)

Module Term.Tbl

type key = t
type !'a t = 'a T.Term.Tbl.t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : ( key -> 'a -> unit ) -> 'a t -> unit
val filter_map_inplace : ( key -> 'a -> 'a option ) -> 'a t -> unit
val fold : ( key -> 'a -> 'b -> 'b ) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib.Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val get : 'a t -> key -> 'a option
val get_or : 'a t -> key -> default:'a -> 'a
val add_list : 'a list t -> key -> 'a -> unit
val incr : ?by:int -> int t -> key -> unit
val decr : ?by:int -> int t -> key -> unit
val keys : 'a t -> key CCHashtbl.iter
val values : 'a t -> 'a CCHashtbl.iter
val keys_list : 'a t -> key list
val values_list : 'a t -> 'a list
val map_list : ( key -> 'a -> 'b ) -> 'a t -> 'b list
val to_iter : 'a t -> (key * 'a) CCHashtbl.iter
val add_iter : 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_iter_with : - f:( key -> 'a -> 'a -> 'a ) -> - 'a t -> - (key * 'a) CCHashtbl.iter -> - unit
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val add_seq_with : - f:( key -> 'a -> 'a -> 'a ) -> - 'a t -> - (key * 'a) Stdlib.Seq.t -> - unit
val of_iter : (key * 'a) CCHashtbl.iter -> 'a t
val of_iter_with : - f:( key -> 'a -> 'a -> 'a ) -> - (key * 'a) CCHashtbl.iter -> - 'a t
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val of_seq_with : - f:( key -> 'a -> 'a -> 'a ) -> - (key * 'a) Stdlib.Seq.t -> - 'a t
val add_iter_count : int t -> key CCHashtbl.iter -> unit
val add_seq_count : int t -> key Stdlib.Seq.t -> unit
val of_iter_count : key CCHashtbl.iter -> int t
val of_seq_count : key Stdlib.Seq.t -> int t
val to_list : 'a t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a t
val of_list_with : f:( key -> 'a -> 'a -> 'a ) -> (key * 'a) list -> 'a t
val update : 'a t -> f:( key -> 'a option -> 'a option ) -> k:key -> unit
val get_or_add : 'a t -> f:( key -> 'a ) -> k:key -> 'a
val pp : - ?pp_start:unit CCHashtbl.printer -> - ?pp_stop:unit CCHashtbl.printer -> - ?pp_sep:unit CCHashtbl.printer -> - ?pp_arrow:unit CCHashtbl.printer -> - key CCHashtbl.printer -> - 'a CCHashtbl.printer -> - 'a t CCHashtbl.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Lit/T/Term/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Lit/T/Term/index.html deleted file mode 100644 index d336f9ec..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Lit/T/Term/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Term (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Solver_internal.CC.Lit.T.Term)

Module T.Term

type t = T.Term.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Term.store
val ty : t -> Ty.t
val bool : store -> bool -> t
val as_bool : t -> bool option
val abs : store -> t -> t * bool
val map_shallow : store -> ( t -> t ) -> t -> t
val iter_shallow : store -> ( t -> unit ) -> t -> unit
val iter_dag : t -> ( t -> unit ) -> unit
module Tbl : sig ... end
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Lit/T/Ty/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Lit/T/Ty/index.html deleted file mode 100644 index e974c622..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Lit/T/Ty/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Ty (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Solver_internal.CC.Lit.T.Ty)

Module T.Ty

type t = T.Ty.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Ty.store
val bool : store -> t
val is_bool : t -> bool
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Lit/T/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Lit/T/index.html deleted file mode 100644 index ba57c836..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Lit/T/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -T (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Solver_internal.CC.Lit.T)

Module Lit.T

module Fun : sig ... end
module Ty : sig ... end
module Term : sig ... end
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Lit/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Lit/index.html deleted file mode 100644 index bd0d06f5..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Lit/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Lit (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Solver_internal.CC.Lit)

Module CC.Lit

module T : sig ... end
type t = Lit.t
val term : t -> T.Term.t
val sign : t -> bool
val neg : t -> t
val abs : t -> t
val signed_term : t -> T.Term.t * bool
val atom : ?sign:bool -> T.Term.store -> T.Term.t -> t
val norm_sign : t -> t * bool
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/N/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/N/index.html deleted file mode 100644 index c7fe394e..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/N/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -N (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Solver_internal.CC.N)

Module CC.N

val term : t -> term
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
val is_root : t -> bool
val iter_class : t -> t Iter.t
val iter_parents : t -> t Iter.t
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/P/Step_vec/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/P/Step_vec/index.html deleted file mode 100644 index ab9ad4ae..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/P/Step_vec/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Step_vec (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Solver_internal.CC.P.Step_vec)

Module P.Step_vec

type elt = proof_step
val size : t -> int
val get : t -> int -> elt
val iter : f:( elt -> unit ) -> t -> unit
val iteri : f:( int -> elt -> unit ) -> t -> unit
val create : ?cap:int -> unit -> t
val clear : t -> unit
val copy : t -> t
val is_empty : t -> bool
val push : t -> elt -> unit
val fast_remove : t -> int -> unit
val filter_in_place : ( elt -> bool ) -> t -> unit
val ensure_size : t -> int -> unit
val pop : t -> elt
val set : t -> int -> elt -> unit
val shrink : t -> int -> unit
val to_iter : t -> elt Iter.t
val to_array : t -> elt array
val fold_left : ( 'a -> elt -> 'a ) -> 'a -> t -> 'a
val pp : elt CCFormat.printer -> t CCFormat.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/P/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/P/index.html deleted file mode 100644 index 194989f9..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/P/index.html +++ /dev/null @@ -1,6 +0,0 @@ - -P (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Solver_internal.CC.P)

Module CC.P

type t = proof
type proof_step = proof_step
type lit = lit
type proof_rule = t -> proof_step
module Step_vec : sig ... end
val enabled : t -> bool
val emit_input_clause : lit Iter.t -> proof_rule
val emit_redundant_clause : lit Iter.t -> hyps:proof_step Iter.t -> proof_rule
val emit_unsat_core : lit Iter.t -> proof_rule
val emit_unsat : proof_step -> t -> unit
val del_clause : proof_step -> lit Iter.t -> t -> unit
val lemma_cc : lit Iter.t -> proof_rule
val define_term : term -> term -> proof_rule
val proof_p1 : proof_step -> proof_step -> proof_rule
val proof_r1 : proof_step -> proof_step -> proof_rule
val proof_res : pivot:term -> proof_step -> proof_step -> proof_rule
val with_defs : proof_step -> proof_step Iter.t -> proof_rule
val lemma_true : term -> proof_rule
val lemma_preprocess : term -> term -> using:proof_step Iter.t -> proof_rule
val lemma_rw_clause : - proof_step -> - res:lit Iter.t -> - using:proof_step Iter.t -> - proof_rule
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Resolved_expl/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Resolved_expl/index.html deleted file mode 100644 index 8a732ae8..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/Resolved_expl/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Resolved_expl (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Solver_internal.CC.Resolved_expl)

Module CC.Resolved_expl

type t = S.Solver_internal.CC.Resolved_expl.t = {
lits : lit list;
same_value : (N.t * N.t) list;
pr : proof -> proof_step;
}
val is_semantic : t -> bool
val pp : t Sidekick_core.Fmt.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/T/Fun/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/T/Fun/index.html deleted file mode 100644 index d3bf1ae9..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/T/Fun/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Fun (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Solver_internal.CC.T.Fun)

Module T.Fun

type t = T.Fun.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/T/Term/Tbl/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/T/Term/Tbl/index.html deleted file mode 100644 index f1d8f5d4..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/T/Term/Tbl/index.html +++ /dev/null @@ -1,23 +0,0 @@ - -Tbl (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Solver_internal.CC.T.Term.Tbl)

Module Term.Tbl

type key = t
type !'a t = 'a T.Term.Tbl.t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : ( key -> 'a -> unit ) -> 'a t -> unit
val filter_map_inplace : ( key -> 'a -> 'a option ) -> 'a t -> unit
val fold : ( key -> 'a -> 'b -> 'b ) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib.Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val get : 'a t -> key -> 'a option
val get_or : 'a t -> key -> default:'a -> 'a
val add_list : 'a list t -> key -> 'a -> unit
val incr : ?by:int -> int t -> key -> unit
val decr : ?by:int -> int t -> key -> unit
val keys : 'a t -> key CCHashtbl.iter
val values : 'a t -> 'a CCHashtbl.iter
val keys_list : 'a t -> key list
val values_list : 'a t -> 'a list
val map_list : ( key -> 'a -> 'b ) -> 'a t -> 'b list
val to_iter : 'a t -> (key * 'a) CCHashtbl.iter
val add_iter : 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_iter_with : - f:( key -> 'a -> 'a -> 'a ) -> - 'a t -> - (key * 'a) CCHashtbl.iter -> - unit
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val add_seq_with : - f:( key -> 'a -> 'a -> 'a ) -> - 'a t -> - (key * 'a) Stdlib.Seq.t -> - unit
val of_iter : (key * 'a) CCHashtbl.iter -> 'a t
val of_iter_with : - f:( key -> 'a -> 'a -> 'a ) -> - (key * 'a) CCHashtbl.iter -> - 'a t
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val of_seq_with : - f:( key -> 'a -> 'a -> 'a ) -> - (key * 'a) Stdlib.Seq.t -> - 'a t
val add_iter_count : int t -> key CCHashtbl.iter -> unit
val add_seq_count : int t -> key Stdlib.Seq.t -> unit
val of_iter_count : key CCHashtbl.iter -> int t
val of_seq_count : key Stdlib.Seq.t -> int t
val to_list : 'a t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a t
val of_list_with : f:( key -> 'a -> 'a -> 'a ) -> (key * 'a) list -> 'a t
val update : 'a t -> f:( key -> 'a option -> 'a option ) -> k:key -> unit
val get_or_add : 'a t -> f:( key -> 'a ) -> k:key -> 'a
val pp : - ?pp_start:unit CCHashtbl.printer -> - ?pp_stop:unit CCHashtbl.printer -> - ?pp_sep:unit CCHashtbl.printer -> - ?pp_arrow:unit CCHashtbl.printer -> - key CCHashtbl.printer -> - 'a CCHashtbl.printer -> - 'a t CCHashtbl.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/T/Term/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/T/Term/index.html deleted file mode 100644 index d38fe42c..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/T/Term/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Term (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Solver_internal.CC.T.Term)

Module T.Term

type t = T.Term.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Term.store
val ty : t -> Ty.t
val bool : store -> bool -> t
val as_bool : t -> bool option
val abs : store -> t -> t * bool
val map_shallow : store -> ( t -> t ) -> t -> t
val iter_shallow : store -> ( t -> unit ) -> t -> unit
val iter_dag : t -> ( t -> unit ) -> unit
module Tbl : sig ... end
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/T/Ty/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/T/Ty/index.html deleted file mode 100644 index 0b35acdc..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/T/Ty/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Ty (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Solver_internal.CC.T.Ty)

Module T.Ty

type t = T.Ty.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Ty.store
val bool : store -> t
val is_bool : t -> bool
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/T/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/T/index.html deleted file mode 100644 index d1cfd028..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/T/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -T (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Solver_internal.CC.T)

Module CC.T

module Fun : sig ... end
module Ty : sig ... end
module Term : sig ... end
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/index.html deleted file mode 100644 index 128931a7..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/CC/index.html +++ /dev/null @@ -1,13 +0,0 @@ - -CC (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Solver_internal.CC)

Module Solver_internal.CC

module T : sig ... end
module Lit : sig ... end
type proof = proof
type proof_step = proof_step
module P : sig ... end
module Actions : sig ... end
type term_store = T.Term.store
type term = T.Term.t
type value = term
type fun_ = T.Fun.t
type lit = Lit.t
type actions = Actions.t
module N : sig ... end
module Expl : sig ... end
module Resolved_expl : sig ... end
type node = N.t
type repr = N.t
type explanation = Expl.t
val term_store : t -> term_store
val proof : t -> proof
val find : t -> node -> repr
val add_term : t -> term -> node
val mem_term : t -> term -> bool
type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit
type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit
type ev_on_new_term = t -> N.t -> term -> unit
type ev_on_conflict = t -> th:bool -> lit list -> unit
type ev_on_propagate = t -> lit -> ( unit -> lit list * proof_step ) -> unit
type ev_on_is_subterm = N.t -> term -> unit
val create : - ?stat:Sidekick_util.Stat.t -> - ?on_pre_merge:ev_on_pre_merge list -> - ?on_post_merge:ev_on_post_merge list -> - ?on_new_term:ev_on_new_term list -> - ?on_conflict:ev_on_conflict list -> - ?on_propagate:ev_on_propagate list -> - ?on_is_subterm:ev_on_is_subterm list -> - ?size:[ `Big | `Small ] -> - term_store -> - proof -> - t
val allocate_bitfield : descr:string -> t -> N.bitfield
val get_bitfield : t -> N.bitfield -> N.t -> bool
val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit
val on_pre_merge : t -> ev_on_pre_merge -> unit
val on_post_merge : t -> ev_on_post_merge -> unit
val on_new_term : t -> ev_on_new_term -> unit
val on_conflict : t -> ev_on_conflict -> unit
val on_propagate : t -> ev_on_propagate -> unit
val on_is_subterm : t -> ev_on_is_subterm -> unit
val set_as_lit : t -> N.t -> lit -> unit
val find_t : t -> term -> repr
val add_seq : t -> term Iter.t -> unit
val all_classes : t -> repr Iter.t
val assert_lit : t -> lit -> unit
val assert_lits : t -> lit Iter.t -> unit
val explain_eq : t -> N.t -> N.t -> Resolved_expl.t
val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a
val n_true : t -> N.t
val n_false : t -> N.t
val n_bool : t -> bool -> N.t
val merge : t -> N.t -> N.t -> Expl.t -> unit
val merge_t : t -> term -> term -> Expl.t -> unit
val set_model_value : t -> term -> value -> unit
val with_model_mode : t -> ( unit -> 'a ) -> 'a
val get_model_for_each_class : t -> (repr * N.t Iter.t * value) Iter.t
val check : t -> actions -> unit
val push_level : t -> unit
val pop_levels : t -> int -> unit
val get_model : t -> N.t Iter.t Iter.t
module Debug_ : sig ... end
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/Lit/T/Fun/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/Lit/T/Fun/index.html deleted file mode 100644 index 6c2efc7c..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/Lit/T/Fun/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Fun (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Solver_internal.Lit.T.Fun)

Module T.Fun

type t = T.Fun.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/Lit/T/Term/Tbl/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/Lit/T/Term/Tbl/index.html deleted file mode 100644 index 358063e6..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/Lit/T/Term/Tbl/index.html +++ /dev/null @@ -1,23 +0,0 @@ - -Tbl (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Solver_internal.Lit.T.Term.Tbl)

Module Term.Tbl

type key = t
type !'a t = 'a T.Term.Tbl.t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : ( key -> 'a -> unit ) -> 'a t -> unit
val filter_map_inplace : ( key -> 'a -> 'a option ) -> 'a t -> unit
val fold : ( key -> 'a -> 'b -> 'b ) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib.Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val get : 'a t -> key -> 'a option
val get_or : 'a t -> key -> default:'a -> 'a
val add_list : 'a list t -> key -> 'a -> unit
val incr : ?by:int -> int t -> key -> unit
val decr : ?by:int -> int t -> key -> unit
val keys : 'a t -> key CCHashtbl.iter
val values : 'a t -> 'a CCHashtbl.iter
val keys_list : 'a t -> key list
val values_list : 'a t -> 'a list
val map_list : ( key -> 'a -> 'b ) -> 'a t -> 'b list
val to_iter : 'a t -> (key * 'a) CCHashtbl.iter
val add_iter : 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_iter_with : - f:( key -> 'a -> 'a -> 'a ) -> - 'a t -> - (key * 'a) CCHashtbl.iter -> - unit
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val add_seq_with : - f:( key -> 'a -> 'a -> 'a ) -> - 'a t -> - (key * 'a) Stdlib.Seq.t -> - unit
val of_iter : (key * 'a) CCHashtbl.iter -> 'a t
val of_iter_with : - f:( key -> 'a -> 'a -> 'a ) -> - (key * 'a) CCHashtbl.iter -> - 'a t
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val of_seq_with : - f:( key -> 'a -> 'a -> 'a ) -> - (key * 'a) Stdlib.Seq.t -> - 'a t
val add_iter_count : int t -> key CCHashtbl.iter -> unit
val add_seq_count : int t -> key Stdlib.Seq.t -> unit
val of_iter_count : key CCHashtbl.iter -> int t
val of_seq_count : key Stdlib.Seq.t -> int t
val to_list : 'a t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a t
val of_list_with : f:( key -> 'a -> 'a -> 'a ) -> (key * 'a) list -> 'a t
val update : 'a t -> f:( key -> 'a option -> 'a option ) -> k:key -> unit
val get_or_add : 'a t -> f:( key -> 'a ) -> k:key -> 'a
val pp : - ?pp_start:unit CCHashtbl.printer -> - ?pp_stop:unit CCHashtbl.printer -> - ?pp_sep:unit CCHashtbl.printer -> - ?pp_arrow:unit CCHashtbl.printer -> - key CCHashtbl.printer -> - 'a CCHashtbl.printer -> - 'a t CCHashtbl.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/Lit/T/Term/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/Lit/T/Term/index.html deleted file mode 100644 index c0526880..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/Lit/T/Term/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Term (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Solver_internal.Lit.T.Term)

Module T.Term

type t = T.Term.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Term.store
val ty : t -> Ty.t
val bool : store -> bool -> t
val as_bool : t -> bool option
val abs : store -> t -> t * bool
val map_shallow : store -> ( t -> t ) -> t -> t
val iter_shallow : store -> ( t -> unit ) -> t -> unit
val iter_dag : t -> ( t -> unit ) -> unit
module Tbl : sig ... end
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/Lit/T/Ty/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/Lit/T/Ty/index.html deleted file mode 100644 index 939aead6..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/Lit/T/Ty/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Ty (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Solver_internal.Lit.T.Ty)

Module T.Ty

type t = T.Ty.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Ty.store
val bool : store -> t
val is_bool : t -> bool
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/Lit/T/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/Lit/T/index.html deleted file mode 100644 index f1b30a29..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/Lit/T/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -T (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Solver_internal.Lit.T)

Module Lit.T

module Fun : sig ... end
module Ty : sig ... end
module Term : sig ... end
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/Lit/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/Lit/index.html deleted file mode 100644 index eab1a039..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/Lit/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Lit (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Solver_internal.Lit)

Module Solver_internal.Lit

module T : sig ... end
type t = Lit.t
val term : t -> T.Term.t
val sign : t -> bool
val neg : t -> t
val abs : t -> t
val signed_term : t -> T.Term.t * bool
val atom : ?sign:bool -> T.Term.store -> T.Term.t -> t
val norm_sign : t -> t * bool
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/P/Step_vec/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/P/Step_vec/index.html deleted file mode 100644 index f20de7c0..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/P/Step_vec/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Step_vec (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Solver_internal.P.Step_vec)

Module P.Step_vec

type elt = proof_step
type t = P.Step_vec.t
val size : t -> int
val get : t -> int -> elt
val iter : f:( elt -> unit ) -> t -> unit
val iteri : f:( int -> elt -> unit ) -> t -> unit
val create : ?cap:int -> unit -> t
val clear : t -> unit
val copy : t -> t
val is_empty : t -> bool
val push : t -> elt -> unit
val fast_remove : t -> int -> unit
val filter_in_place : ( elt -> bool ) -> t -> unit
val ensure_size : t -> int -> unit
val pop : t -> elt
val set : t -> int -> elt -> unit
val shrink : t -> int -> unit
val to_iter : t -> elt Iter.t
val to_array : t -> elt array
val fold_left : ( 'a -> elt -> 'a ) -> 'a -> t -> 'a
val pp : elt CCFormat.printer -> t CCFormat.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/P/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/P/index.html deleted file mode 100644 index adef1255..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/P/index.html +++ /dev/null @@ -1,6 +0,0 @@ - -P (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Solver_internal.P)

Module Solver_internal.P

type t = proof
type proof_step = proof_step
type term = T.Term.t
type lit = Lit.t
type proof_rule = t -> proof_step
module Step_vec : sig ... end
val enabled : t -> bool
val emit_input_clause : lit Iter.t -> proof_rule
val emit_redundant_clause : lit Iter.t -> hyps:proof_step Iter.t -> proof_rule
val emit_unsat_core : lit Iter.t -> proof_rule
val emit_unsat : proof_step -> t -> unit
val del_clause : proof_step -> lit Iter.t -> t -> unit
val lemma_cc : lit Iter.t -> proof_rule
val define_term : term -> term -> proof_rule
val proof_p1 : proof_step -> proof_step -> proof_rule
val proof_r1 : proof_step -> proof_step -> proof_rule
val proof_res : pivot:term -> proof_step -> proof_step -> proof_rule
val with_defs : proof_step -> proof_step Iter.t -> proof_rule
val lemma_true : term -> proof_rule
val lemma_preprocess : term -> term -> using:proof_step Iter.t -> proof_rule
val lemma_rw_clause : - proof_step -> - res:lit Iter.t -> - using:proof_step Iter.t -> - proof_rule
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/Registry/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/Registry/index.html deleted file mode 100644 index 4599a3f4..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/Registry/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Registry (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Solver_internal.Registry)

Module Solver_internal.Registry

val create_key : unit -> 'a key
val create : unit -> t
val get : t -> 'a key -> 'a option
val set : t -> 'a key -> 'a -> unit
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/Simplify/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/Simplify/index.html deleted file mode 100644 index be4361f5..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/Simplify/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Simplify (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Solver_internal.Simplify)

Module Solver_internal.Simplify

val tst : t -> term_store
val ty_st : t -> ty_store
val clear : t -> unit
val proof : t -> proof
type hook = t -> term -> (term * proof_step Iter.t) option
val normalize : t -> term -> (term * proof_step) option
val normalize_t : t -> term -> term * proof_step option
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/T/Fun/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/T/Fun/index.html deleted file mode 100644 index 35d2c55a..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/T/Fun/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Fun (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Solver_internal.T.Fun)

Module T.Fun

type t = T.Fun.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/T/Term/Tbl/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/T/Term/Tbl/index.html deleted file mode 100644 index f4f08d89..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/T/Term/Tbl/index.html +++ /dev/null @@ -1,23 +0,0 @@ - -Tbl (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Solver_internal.T.Term.Tbl)

Module Term.Tbl

type key = t
type !'a t = 'a T.Term.Tbl.t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : ( key -> 'a -> unit ) -> 'a t -> unit
val filter_map_inplace : ( key -> 'a -> 'a option ) -> 'a t -> unit
val fold : ( key -> 'a -> 'b -> 'b ) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib.Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val get : 'a t -> key -> 'a option
val get_or : 'a t -> key -> default:'a -> 'a
val add_list : 'a list t -> key -> 'a -> unit
val incr : ?by:int -> int t -> key -> unit
val decr : ?by:int -> int t -> key -> unit
val keys : 'a t -> key CCHashtbl.iter
val values : 'a t -> 'a CCHashtbl.iter
val keys_list : 'a t -> key list
val values_list : 'a t -> 'a list
val map_list : ( key -> 'a -> 'b ) -> 'a t -> 'b list
val to_iter : 'a t -> (key * 'a) CCHashtbl.iter
val add_iter : 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_iter_with : - f:( key -> 'a -> 'a -> 'a ) -> - 'a t -> - (key * 'a) CCHashtbl.iter -> - unit
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val add_seq_with : - f:( key -> 'a -> 'a -> 'a ) -> - 'a t -> - (key * 'a) Stdlib.Seq.t -> - unit
val of_iter : (key * 'a) CCHashtbl.iter -> 'a t
val of_iter_with : - f:( key -> 'a -> 'a -> 'a ) -> - (key * 'a) CCHashtbl.iter -> - 'a t
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val of_seq_with : - f:( key -> 'a -> 'a -> 'a ) -> - (key * 'a) Stdlib.Seq.t -> - 'a t
val add_iter_count : int t -> key CCHashtbl.iter -> unit
val add_seq_count : int t -> key Stdlib.Seq.t -> unit
val of_iter_count : key CCHashtbl.iter -> int t
val of_seq_count : key Stdlib.Seq.t -> int t
val to_list : 'a t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a t
val of_list_with : f:( key -> 'a -> 'a -> 'a ) -> (key * 'a) list -> 'a t
val update : 'a t -> f:( key -> 'a option -> 'a option ) -> k:key -> unit
val get_or_add : 'a t -> f:( key -> 'a ) -> k:key -> 'a
val pp : - ?pp_start:unit CCHashtbl.printer -> - ?pp_stop:unit CCHashtbl.printer -> - ?pp_sep:unit CCHashtbl.printer -> - ?pp_arrow:unit CCHashtbl.printer -> - key CCHashtbl.printer -> - 'a CCHashtbl.printer -> - 'a t CCHashtbl.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/T/Term/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/T/Term/index.html deleted file mode 100644 index cda69752..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/T/Term/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Term (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Solver_internal.T.Term)

Module T.Term

type t = T.Term.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Term.store
val ty : t -> Ty.t
val bool : store -> bool -> t
val as_bool : t -> bool option
val abs : store -> t -> t * bool
val map_shallow : store -> ( t -> t ) -> t -> t
val iter_shallow : store -> ( t -> unit ) -> t -> unit
val iter_dag : t -> ( t -> unit ) -> unit
module Tbl : sig ... end
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/T/Ty/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/T/Ty/index.html deleted file mode 100644 index fe7b6387..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/T/Ty/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Ty (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Solver_internal.T.Ty)

Module T.Ty

type t = T.Ty.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Ty.store
val bool : store -> t
val is_bool : t -> bool
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/T/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/T/index.html deleted file mode 100644 index 449fb0c1..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/T/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -T (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Solver_internal.T)

Module Solver_internal.T

module Fun : sig ... end
module Ty : sig ... end
module Term : sig ... end
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/index.html deleted file mode 100644 index 624ee9a5..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/index.html +++ /dev/null @@ -1,35 +0,0 @@ - -Solver_internal (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Solver_internal)

Module S.Solver_internal

module T : sig ... end
module Lit : sig ... end
type ty = T.Ty.t
type term = T.Term.t
type value = T.Term.t
type term_store = T.Term.store
type ty_store = T.Ty.store
type proof = proof
type proof_step = proof_step
module P : sig ... end
type solver = t
val tst : t -> term_store
val ty_st : t -> ty_store
val stats : t -> Sidekick_util.Stat.t
val proof : t -> proof
module Registry : sig ... end
val registry : t -> Registry.t
type theory_actions = S.Solver_internal.theory_actions
type lit = Lit.t
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 simplify_t : t -> term -> (term * proof_step) option
val simp_t : t -> term -> term * proof_step option
module type PREPROCESS_ACTS = sig ... end
type preprocess_actions = (module PREPROCESS_ACTS)
type preprocess_hook = t -> preprocess_actions -> term -> unit
val on_preprocess : t -> preprocess_hook -> unit
val raise_conflict : t -> theory_actions -> lit list -> proof_step -> 'a
val push_decision : t -> theory_actions -> lit -> unit
val propagate : - t -> - theory_actions -> - lit -> - reason:( unit -> lit list * proof_step ) -> - unit
val propagate_l : t -> theory_actions -> lit -> lit list -> proof_step -> unit
val add_clause_temp : t -> theory_actions -> lit list -> proof_step -> unit
val add_clause_permanent : - t -> - theory_actions -> - lit list -> - proof_step -> - unit
val mk_lit : t -> theory_actions -> ?sign:bool -> term -> lit
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 * proof_step ) -> 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
val on_th_combination : - t -> - ( t -> theory_actions -> (term * value) Iter.t ) -> - unit
val declare_pb_is_incomplete : t -> unit
type model_ask_hook = - recurse:( t -> CC.N.t -> term ) -> - t -> - CC.N.t -> - term option
type model_completion_hook = t -> add:( term -> term -> unit ) -> unit
val on_model : - ?ask:model_ask_hook -> - ?complete:model_completion_hook -> - t -> - unit
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/module-type-PREPROCESS_ACTS/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/module-type-PREPROCESS_ACTS/index.html deleted file mode 100644 index 6782aada..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Solver_internal/module-type-PREPROCESS_ACTS/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -PREPROCESS_ACTS (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Solver_internal.PREPROCESS_ACTS)

Module type Solver_internal.PREPROCESS_ACTS

val proof : proof
val mk_lit : ?sign:bool -> term -> lit
val add_clause : lit list -> proof_step -> unit
val add_lit : ?default_pol:bool -> lit -> unit
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/T/Fun/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/T/Fun/index.html deleted file mode 100644 index d7e2305a..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/T/Fun/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Fun (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.T.Fun)

Module T.Fun

type t = S.T.Fun.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/T/Term/Tbl/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/T/Term/Tbl/index.html deleted file mode 100644 index 32b575cd..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/T/Term/Tbl/index.html +++ /dev/null @@ -1,23 +0,0 @@ - -Tbl (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.T.Term.Tbl)

Module Term.Tbl

type key = t
type !'a t = 'a S.T.Term.Tbl.t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : ( key -> 'a -> unit ) -> 'a t -> unit
val filter_map_inplace : ( key -> 'a -> 'a option ) -> 'a t -> unit
val fold : ( key -> 'a -> 'b -> 'b ) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib.Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val get : 'a t -> key -> 'a option
val get_or : 'a t -> key -> default:'a -> 'a
val add_list : 'a list t -> key -> 'a -> unit
val incr : ?by:int -> int t -> key -> unit
val decr : ?by:int -> int t -> key -> unit
val keys : 'a t -> key CCHashtbl.iter
val values : 'a t -> 'a CCHashtbl.iter
val keys_list : 'a t -> key list
val values_list : 'a t -> 'a list
val map_list : ( key -> 'a -> 'b ) -> 'a t -> 'b list
val to_iter : 'a t -> (key * 'a) CCHashtbl.iter
val add_iter : 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_iter_with : - f:( key -> 'a -> 'a -> 'a ) -> - 'a t -> - (key * 'a) CCHashtbl.iter -> - unit
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val add_seq_with : - f:( key -> 'a -> 'a -> 'a ) -> - 'a t -> - (key * 'a) Stdlib.Seq.t -> - unit
val of_iter : (key * 'a) CCHashtbl.iter -> 'a t
val of_iter_with : - f:( key -> 'a -> 'a -> 'a ) -> - (key * 'a) CCHashtbl.iter -> - 'a t
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val of_seq_with : - f:( key -> 'a -> 'a -> 'a ) -> - (key * 'a) Stdlib.Seq.t -> - 'a t
val add_iter_count : int t -> key CCHashtbl.iter -> unit
val add_seq_count : int t -> key Stdlib.Seq.t -> unit
val of_iter_count : key CCHashtbl.iter -> int t
val of_seq_count : key Stdlib.Seq.t -> int t
val to_list : 'a t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a t
val of_list_with : f:( key -> 'a -> 'a -> 'a ) -> (key * 'a) list -> 'a t
val update : 'a t -> f:( key -> 'a option -> 'a option ) -> k:key -> unit
val get_or_add : 'a t -> f:( key -> 'a ) -> k:key -> 'a
val pp : - ?pp_start:unit CCHashtbl.printer -> - ?pp_stop:unit CCHashtbl.printer -> - ?pp_sep:unit CCHashtbl.printer -> - ?pp_arrow:unit CCHashtbl.printer -> - key CCHashtbl.printer -> - 'a CCHashtbl.printer -> - 'a t CCHashtbl.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/T/Term/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/T/Term/index.html deleted file mode 100644 index 34945563..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/T/Term/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Term (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.T.Term)

Module T.Term

type t = S.T.Term.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = S.T.Term.store
val ty : t -> Ty.t
val bool : store -> bool -> t
val as_bool : t -> bool option
val abs : store -> t -> t * bool
val map_shallow : store -> ( t -> t ) -> t -> t
val iter_shallow : store -> ( t -> unit ) -> t -> unit
val iter_dag : t -> ( t -> unit ) -> unit
module Tbl : sig ... end
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/T/Ty/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/T/Ty/index.html deleted file mode 100644 index fdb576f1..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/T/Ty/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Ty (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.T.Ty)

Module T.Ty

type t = S.T.Ty.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = S.T.Ty.store
val bool : store -> t
val is_bool : t -> bool
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/T/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/T/index.html deleted file mode 100644 index 6ccefc8b..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/T/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -T (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.T)

Module S.T

module Fun : sig ... end
module Ty : sig ... end
module Term : sig ... end
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Unknown/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Unknown/index.html deleted file mode 100644 index 520c7dd1..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/Unknown/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Unknown (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.Unknown)

Module S.Unknown

type t = S.Unknown.t
val pp : t CCFormat.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/index.html deleted file mode 100644 index 08a421c5..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/index.html +++ /dev/null @@ -1,26 +0,0 @@ - -S (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S)

Module A.S

module T : sig ... end
module Lit : sig ... end
type proof = S.proof
type proof_step = S.proof_step
module P : sig ... end
module Solver_internal : sig ... end
type t = S.t
type solver = t
type term = T.Term.t
type ty = T.Ty.t
type lit = Lit.t
module Registry : sig ... end
val registry : t -> Registry.t
module type THEORY = sig ... end
type theory = (module THEORY)
type !'a theory_p = (module THEORY with type t = 'a)
val mk_theory : - name:string -> - create_and_setup:( Solver_internal.t -> 'th ) -> - ?push_level:( 'th -> unit ) -> - ?pop_levels:( 'th -> int -> unit ) -> - unit -> - theory
module Model : sig ... end
module Unknown : sig ... end
val stats : t -> Sidekick_util.Stat.t
val tst : t -> T.Term.store
val ty_st : t -> T.Ty.store
val proof : t -> proof
val create : - ?stat:Sidekick_util.Stat.t -> - ?size:[ `Big | `Small | `Tiny ] -> - proof:proof -> - theories:theory list -> - T.Term.store -> - T.Ty.store -> - unit -> - t
val add_theory : t -> theory -> unit
val add_theory_p : t -> 'a theory_p -> 'a
val add_theory_l : t -> theory list -> unit
val mk_lit_t : t -> ?sign:bool -> term -> lit
val add_clause : t -> lit Sidekick_util.IArray.t -> proof_step -> unit
val add_clause_l : t -> lit list -> proof_step -> unit
val assert_terms : t -> term list -> unit
val assert_term : t -> term -> unit
type res = S.res =
| Sat of Model.t
| Unsat of {
unsat_core : unit -> lit Iter.t;
unsat_proof_step : unit -> proof_step option;
}
| Unknown of Unknown.t
val solve : - ?on_exit:( unit -> unit ) list -> - ?check:bool -> - ?on_progress:( t -> unit ) -> - ?should_stop:( t -> int -> bool ) -> - assumptions:lit list -> - t -> - res
val last_res : t -> res option
val push_assumption : t -> lit -> unit
val pop_assumptions : t -> int -> unit
type propagation_result = S.propagation_result =
| PR_sat
| PR_conflict of {
backtracked : int;
}
| PR_unsat of {
unsat_core : unit -> lit Iter.t;
}
val check_sat_propagations_only : - assumptions:lit list -> - t -> - propagation_result
val pp_stats : t CCFormat.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/module-type-THEORY/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/module-type-THEORY/index.html deleted file mode 100644 index d34b5e00..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/S/module-type-THEORY/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -THEORY (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.S.THEORY)

Module type S.THEORY

type t
val name : string
val create_and_setup : Solver_internal.t -> t
val push_level : t -> unit
val pop_levels : t -> int -> unit
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/Z/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/Z/index.html deleted file mode 100644 index 1bee469c..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/Z/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Z (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A.Z)

Module A.Z

type t = Z.t
val zero : t
val one : t
val minus_one : t
val abs : t -> t
val sign : t -> int
val of_int : int -> t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t CCFormat.printer
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
val succ : t -> t
val pred : t -> t
val gcd : t -> t -> t
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/index.html deleted file mode 100644 index 6f1c33f3..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/A/index.html +++ /dev/null @@ -1,5 +0,0 @@ - -A (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.A)

Module LRA_solver.A

module S : sig ... end
module Z : sig ... end
module Q : sig ... end
type term = S.T.Term.t
type ty = S.T.Ty.t
val view_as_lra : term -> ( Q.t, term ) Sidekick_arith_lra.lra_view
val mk_bool : S.T.Term.store -> bool -> term
val ty_lra : S.T.Term.store -> ty
val mk_eq : S.T.Term.store -> term -> term -> term
val has_ty_real : term -> bool
val lemma_lra : S.Lit.t Iter.t -> S.P.proof_rule
module Gensym : sig ... end
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/SimpSolver/Constraint/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/SimpSolver/Constraint/index.html deleted file mode 100644 index 6ed12364..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/SimpSolver/Constraint/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Constraint (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.SimpSolver.Constraint)

Module SimpSolver.Constraint

type t = Th_lra.SimpSolver.Constraint.t = {
op : op;
lhs : V.t;
rhs : num;
}
val mk : V.t -> op -> num -> t
val leq : V.t -> num -> t
val lt : V.t -> num -> t
val geq : V.t -> num -> t
val gt : V.t -> num -> t
val pp : t Sidekick_util.Fmt.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/SimpSolver/Q/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/SimpSolver/Q/index.html deleted file mode 100644 index 23eec654..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/SimpSolver/Q/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Q (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.SimpSolver.Q)

Module SimpSolver.Q

val zero : t
val one : t
val minus_one : t
val abs : t -> t
val sign : t -> int
val of_int : int -> t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t CCFormat.printer
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
type bigint = Z.t
val (/) : t -> t -> t
val num : t -> bigint
val denum : t -> bigint
val infinity : t
val minus_infinity : t
val of_bigint : bigint -> t
val is_real : t -> bool
val is_int : t -> bool
val as_int : t -> bigint option
val floor : t -> bigint
val ceil : t -> bigint
val pp_approx : int -> Stdlib.Format.formatter -> t -> unit
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/SimpSolver/Subst/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/SimpSolver/Subst/index.html deleted file mode 100644 index 97b06d00..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/SimpSolver/Subst/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Subst (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.SimpSolver.Subst)

Module SimpSolver.Subst

type t = num V_map.t
val eval : t -> V.t -> Q.t option
val to_iter : t -> (V.t * Q.t) Iter.t
val pp : t Sidekick_util.Fmt.printer
val to_string : t -> string
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/SimpSolver/Unsat_cert/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/SimpSolver/Unsat_cert/index.html deleted file mode 100644 index 10889561..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/SimpSolver/Unsat_cert/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Unsat_cert (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.SimpSolver.Unsat_cert)

Module SimpSolver.Unsat_cert

type t = unsat_cert
val lits : t -> V.lit list
val pp : t Sidekick_util.Fmt.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/SimpSolver/V/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/SimpSolver/V/index.html deleted file mode 100644 index 5fb5a134..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/SimpSolver/V/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -V (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.SimpSolver.V)

Module SimpSolver.V

val compare : t -> t -> int
val pp : t Sidekick_util.Fmt.printer
val pp_lit : lit Sidekick_util.Fmt.printer
val not_lit : lit -> lit option
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/SimpSolver/V_map/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/SimpSolver/V_map/index.html deleted file mode 100644 index 694bb10f..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/SimpSolver/V_map/index.html +++ /dev/null @@ -1,32 +0,0 @@ - -V_map (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.SimpSolver.V_map)

Module SimpSolver.V_map

type key = V.t
type !'a t = 'a Th_lra.SimpSolver.V_map.t
val empty : 'a t
val is_empty : 'a t -> bool
val mem : key -> 'a t -> bool
val add : key -> 'a -> 'a t -> 'a t
val singleton : key -> 'a -> 'a t
val remove : key -> 'a t -> 'a t
val merge : - ( key -> 'a option -> 'b option -> 'c option ) -> - 'a t -> - 'b t -> - 'c t
val union : ( key -> 'a -> 'a -> 'a option ) -> 'a t -> 'a t -> 'a t
val compare : ( 'a -> 'a -> int ) -> 'a t -> 'a t -> int
val equal : ( 'a -> 'a -> bool ) -> 'a t -> 'a t -> bool
val iter : ( key -> 'a -> unit ) -> 'a t -> unit
val fold : ( key -> 'a -> 'b -> 'b ) -> 'a t -> 'b -> 'b
val for_all : ( key -> 'a -> bool ) -> 'a t -> bool
val exists : ( key -> 'a -> bool ) -> 'a t -> bool
val filter : ( key -> 'a -> bool ) -> 'a t -> 'a t
val filter_map : ( key -> 'a -> 'b option ) -> 'a t -> 'b t
val partition : ( key -> 'a -> bool ) -> 'a t -> 'a t * 'a t
val cardinal : 'a t -> int
val bindings : 'a t -> (key * 'a) list
val min_binding : 'a t -> key * 'a
val max_binding : 'a t -> key * 'a
val choose : 'a t -> key * 'a
val split : key -> 'a t -> 'a t * 'a option * 'a t
val find : key -> 'a t -> 'a
val find_last : ( key -> bool ) -> 'a t -> key * 'a
val find_last_opt : ( key -> bool ) -> 'a t -> (key * 'a) option
val map : ( 'a -> 'b ) -> 'a t -> 'b t
val mapi : ( key -> 'a -> 'b ) -> 'a t -> 'b t
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_rev_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_from : key -> 'a t -> (key * 'a) Stdlib.Seq.t
val get : key -> 'a t -> 'a option
val get_or : key -> 'a t -> default:'a -> 'a
val update : key -> ( 'a option -> 'a option ) -> 'a t -> 'a t
val choose_opt : 'a t -> (key * 'a) option
val min_binding_opt : 'a t -> (key * 'a) option
val max_binding_opt : 'a t -> (key * 'a) option
val find_opt : key -> 'a t -> 'a option
val find_first : ( key -> bool ) -> 'a t -> key * 'a
val find_first_opt : ( key -> bool ) -> 'a t -> (key * 'a) option
val merge_safe : - f:( key -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option ) -> - 'a t -> - 'b t -> - 'c t
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> 'a t
val add_seq_with : - f:( key -> 'a -> 'a -> 'a ) -> - 'a t -> - (key * 'a) Stdlib.Seq.t -> - 'a t
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val of_seq_with : - f:( key -> 'a -> 'a -> 'a ) -> - (key * 'a) Stdlib.Seq.t -> - 'a t
val add_iter : 'a t -> (key * 'a) CCMap.iter -> 'a t
val add_iter_with : - f:( key -> 'a -> 'a -> 'a ) -> - 'a t -> - (key * 'a) CCMap.iter -> - 'a t
val of_iter : (key * 'a) CCMap.iter -> 'a t
val of_iter_with : f:( key -> 'a -> 'a -> 'a ) -> (key * 'a) CCMap.iter -> 'a t
val to_iter : 'a t -> (key * 'a) CCMap.iter
val of_list : (key * 'a) list -> 'a t
val of_list_with : f:( key -> 'a -> 'a -> 'a ) -> (key * 'a) list -> 'a t
val add_list : 'a t -> (key * 'a) list -> 'a t
val add_list_with : - f:( key -> 'a -> 'a -> 'a ) -> - 'a t -> - (key * 'a) list -> - 'a t
val keys : 'a t -> key CCMap.iter
val values : 'a t -> 'a CCMap.iter
val to_list : 'a t -> (key * 'a) list
val pp : - ?pp_start:unit CCMap.printer -> - ?pp_stop:unit CCMap.printer -> - ?pp_arrow:unit CCMap.printer -> - ?pp_sep:unit CCMap.printer -> - key CCMap.printer -> - 'a CCMap.printer -> - 'a t CCMap.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/SimpSolver/Z/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/SimpSolver/Z/index.html deleted file mode 100644 index a64d8663..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/SimpSolver/Z/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Z (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.SimpSolver.Z)

Module SimpSolver.Z

val zero : t
val one : t
val minus_one : t
val abs : t -> t
val sign : t -> int
val of_int : int -> t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t CCFormat.printer
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
val succ : t -> t
val pred : t -> t
val gcd : t -> t -> t
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/SimpSolver/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/SimpSolver/index.html deleted file mode 100644 index 95b46c7b..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/SimpSolver/index.html +++ /dev/null @@ -1,16 +0,0 @@ - -SimpSolver (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver.SimpSolver)

Module LRA_solver.SimpSolver

module V : sig ... end
module V_map : sig ... end
module Z : sig ... end
module Q : sig ... end
type num = Q.t
module Constraint : sig ... end
module Subst : sig ... end
val create : ?stat:Sidekick_util.Stat.t -> unit -> t
val push_level : t -> unit
val pop_levels : t -> int -> unit
val define : ?is_int:bool -> t -> V.t -> (num * V.t) list -> unit
module Unsat_cert : sig ... end
exception E_unsat of Unsat_cert.t
type ev_on_propagate = V.lit -> reason:V.lit list -> unit
val add_var : ?is_int:bool -> t -> V.t -> unit
val add_constraint : - ?keep_on_backtracking:bool -> - ?is_int:bool -> - on_propagate:ev_on_propagate -> - t -> - Constraint.t -> - V.lit -> - unit
val declare_bound : ?is_int:bool -> t -> Constraint.t -> V.lit -> unit
val check_exn : - on_propagate:( V.lit -> reason:V.lit list -> unit ) -> - t -> - unit
type result = Th_lra.SimpSolver.result =
| Sat of Subst.t
| Unsat of Unsat_cert.t
val check : on_propagate:( V.lit -> reason:V.lit list -> unit ) -> t -> result
val check_branch_and_bound : - on_propagate:( V.lit -> reason:V.lit list -> unit ) -> - max_tree_nodes:int -> - t -> - result option
val n_vars : t -> int
val n_rows : t -> int
val _check_invariants : t -> unit
val _check_cert : unsat_cert -> unit
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/index.html deleted file mode 100644 index e1c69380..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/LRA_solver/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -LRA_solver (sidekick-base.Sidekick_base_solver.Th_lia.A.LRA_solver)

Module A.LRA_solver

module A : sig ... end
module SimpSolver : sig ... end
type state = Th_lra.state
val theory : A.S.theory
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/Q/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/Q/index.html deleted file mode 100644 index 5b0754ac..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/Q/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Q (sidekick-base.Sidekick_base_solver.Th_lia.A.Q)

Module A.Q

type t = Q.t
val zero : t
val one : t
val minus_one : t
val abs : t -> t
val sign : t -> int
val of_int : int -> t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t CCFormat.printer
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
type bigint = Z.t
val (/) : t -> t -> t
val num : t -> bigint
val denum : t -> bigint
val infinity : t
val minus_infinity : t
val of_bigint : bigint -> t
val is_real : t -> bool
val is_int : t -> bool
val as_int : t -> bigint option
val floor : t -> bigint
val ceil : t -> bigint
val pp_approx : int -> Stdlib.Format.formatter -> t -> unit
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Lit/T/Fun/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Lit/T/Fun/index.html deleted file mode 100644 index 98daec25..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Lit/T/Fun/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Fun (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Lit.T.Fun)

Module T.Fun

type t = T.Fun.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Lit/T/Term/Tbl/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Lit/T/Term/Tbl/index.html deleted file mode 100644 index c21ef9aa..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Lit/T/Term/Tbl/index.html +++ /dev/null @@ -1,23 +0,0 @@ - -Tbl (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Lit.T.Term.Tbl)

Module Term.Tbl

type key = t
type !'a t = 'a T.Term.Tbl.t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : ( key -> 'a -> unit ) -> 'a t -> unit
val filter_map_inplace : ( key -> 'a -> 'a option ) -> 'a t -> unit
val fold : ( key -> 'a -> 'b -> 'b ) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib.Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val get : 'a t -> key -> 'a option
val get_or : 'a t -> key -> default:'a -> 'a
val add_list : 'a list t -> key -> 'a -> unit
val incr : ?by:int -> int t -> key -> unit
val decr : ?by:int -> int t -> key -> unit
val keys : 'a t -> key CCHashtbl.iter
val values : 'a t -> 'a CCHashtbl.iter
val keys_list : 'a t -> key list
val values_list : 'a t -> 'a list
val map_list : ( key -> 'a -> 'b ) -> 'a t -> 'b list
val to_iter : 'a t -> (key * 'a) CCHashtbl.iter
val add_iter : 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_iter_with : - f:( key -> 'a -> 'a -> 'a ) -> - 'a t -> - (key * 'a) CCHashtbl.iter -> - unit
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val add_seq_with : - f:( key -> 'a -> 'a -> 'a ) -> - 'a t -> - (key * 'a) Stdlib.Seq.t -> - unit
val of_iter : (key * 'a) CCHashtbl.iter -> 'a t
val of_iter_with : - f:( key -> 'a -> 'a -> 'a ) -> - (key * 'a) CCHashtbl.iter -> - 'a t
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val of_seq_with : - f:( key -> 'a -> 'a -> 'a ) -> - (key * 'a) Stdlib.Seq.t -> - 'a t
val add_iter_count : int t -> key CCHashtbl.iter -> unit
val add_seq_count : int t -> key Stdlib.Seq.t -> unit
val of_iter_count : key CCHashtbl.iter -> int t
val of_seq_count : key Stdlib.Seq.t -> int t
val to_list : 'a t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a t
val of_list_with : f:( key -> 'a -> 'a -> 'a ) -> (key * 'a) list -> 'a t
val update : 'a t -> f:( key -> 'a option -> 'a option ) -> k:key -> unit
val get_or_add : 'a t -> f:( key -> 'a ) -> k:key -> 'a
val pp : - ?pp_start:unit CCHashtbl.printer -> - ?pp_stop:unit CCHashtbl.printer -> - ?pp_sep:unit CCHashtbl.printer -> - ?pp_arrow:unit CCHashtbl.printer -> - key CCHashtbl.printer -> - 'a CCHashtbl.printer -> - 'a t CCHashtbl.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Lit/T/Term/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Lit/T/Term/index.html deleted file mode 100644 index f8c0b52d..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Lit/T/Term/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Term (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Lit.T.Term)

Module T.Term

type t = T.Term.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Term.store
val ty : t -> Ty.t
val bool : store -> bool -> t
val as_bool : t -> bool option
val abs : store -> t -> t * bool
val map_shallow : store -> ( t -> t ) -> t -> t
val iter_shallow : store -> ( t -> unit ) -> t -> unit
val iter_dag : t -> ( t -> unit ) -> unit
module Tbl : sig ... end
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Lit/T/Ty/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Lit/T/Ty/index.html deleted file mode 100644 index c3e33e5d..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Lit/T/Ty/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Ty (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Lit.T.Ty)

Module T.Ty

type t = T.Ty.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Ty.store
val bool : store -> t
val is_bool : t -> bool
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Lit/T/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Lit/T/index.html deleted file mode 100644 index 63f6e38a..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Lit/T/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -T (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Lit.T)

Module Lit.T

module Fun : sig ... end
module Ty : sig ... end
module Term : sig ... end
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Lit/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Lit/index.html deleted file mode 100644 index 36714626..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Lit/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Lit (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Lit)

Module S.Lit

module T : sig ... end
val term : t -> T.Term.t
val sign : t -> bool
val neg : t -> t
val abs : t -> t
val signed_term : t -> T.Term.t * bool
val atom : ?sign:bool -> T.Term.store -> T.Term.t -> t
val norm_sign : t -> t * bool
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Model/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Model/index.html deleted file mode 100644 index 7eec79a3..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Model/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Model (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Model)

Module S.Model

val empty : t
val mem : t -> term -> bool
val find : t -> term -> term option
val eval : t -> term -> term option
val pp : t Sidekick_core.Fmt.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/P/Step_vec/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/P/Step_vec/index.html deleted file mode 100644 index 544fc5c2..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/P/Step_vec/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Step_vec (sidekick-base.Sidekick_base_solver.Th_lia.A.S.P.Step_vec)

Module P.Step_vec

type elt = proof_step
val size : t -> int
val get : t -> int -> elt
val iter : f:( elt -> unit ) -> t -> unit
val iteri : f:( int -> elt -> unit ) -> t -> unit
val create : ?cap:int -> unit -> t
val clear : t -> unit
val copy : t -> t
val is_empty : t -> bool
val push : t -> elt -> unit
val fast_remove : t -> int -> unit
val filter_in_place : ( elt -> bool ) -> t -> unit
val ensure_size : t -> int -> unit
val pop : t -> elt
val set : t -> int -> elt -> unit
val shrink : t -> int -> unit
val to_iter : t -> elt Iter.t
val to_array : t -> elt array
val fold_left : ( 'a -> elt -> 'a ) -> 'a -> t -> 'a
val pp : elt CCFormat.printer -> t CCFormat.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/P/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/P/index.html deleted file mode 100644 index 1a827dcd..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/P/index.html +++ /dev/null @@ -1,6 +0,0 @@ - -P (sidekick-base.Sidekick_base_solver.Th_lia.A.S.P)

Module S.P

type t = proof
type proof_step = proof_step
type term = T.Term.t
type lit = Lit.t
type proof_rule = t -> proof_step
module Step_vec : sig ... end
val enabled : t -> bool
val emit_input_clause : lit Iter.t -> proof_rule
val emit_redundant_clause : lit Iter.t -> hyps:proof_step Iter.t -> proof_rule
val emit_unsat_core : lit Iter.t -> proof_rule
val emit_unsat : proof_step -> t -> unit
val del_clause : proof_step -> lit Iter.t -> t -> unit
val lemma_cc : lit Iter.t -> proof_rule
val define_term : term -> term -> proof_rule
val proof_p1 : proof_step -> proof_step -> proof_rule
val proof_r1 : proof_step -> proof_step -> proof_rule
val proof_res : pivot:term -> proof_step -> proof_step -> proof_rule
val with_defs : proof_step -> proof_step Iter.t -> proof_rule
val lemma_true : term -> proof_rule
val lemma_preprocess : term -> term -> using:proof_step Iter.t -> proof_rule
val lemma_rw_clause : - proof_step -> - res:lit Iter.t -> - using:proof_step Iter.t -> - proof_rule
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Registry/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Registry/index.html deleted file mode 100644 index fae42224..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Registry/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Registry (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Registry)

Module S.Registry

val create_key : unit -> 'a key
val create : unit -> t
val get : t -> 'a key -> 'a option
val set : t -> 'a key -> 'a -> unit
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Actions/Lit/T/Fun/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Actions/Lit/T/Fun/index.html deleted file mode 100644 index 47094b48..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Actions/Lit/T/Fun/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Fun (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Solver_internal.CC.Actions.Lit.T.Fun)

Module T.Fun

type t = T.Fun.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Actions/Lit/T/Term/Tbl/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Actions/Lit/T/Term/Tbl/index.html deleted file mode 100644 index 45741c21..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Actions/Lit/T/Term/Tbl/index.html +++ /dev/null @@ -1,23 +0,0 @@ - -Tbl (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Solver_internal.CC.Actions.Lit.T.Term.Tbl)

Module Term.Tbl

type key = t
type !'a t = 'a T.Term.Tbl.t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : ( key -> 'a -> unit ) -> 'a t -> unit
val filter_map_inplace : ( key -> 'a -> 'a option ) -> 'a t -> unit
val fold : ( key -> 'a -> 'b -> 'b ) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib.Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val get : 'a t -> key -> 'a option
val get_or : 'a t -> key -> default:'a -> 'a
val add_list : 'a list t -> key -> 'a -> unit
val incr : ?by:int -> int t -> key -> unit
val decr : ?by:int -> int t -> key -> unit
val keys : 'a t -> key CCHashtbl.iter
val values : 'a t -> 'a CCHashtbl.iter
val keys_list : 'a t -> key list
val values_list : 'a t -> 'a list
val map_list : ( key -> 'a -> 'b ) -> 'a t -> 'b list
val to_iter : 'a t -> (key * 'a) CCHashtbl.iter
val add_iter : 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_iter_with : - f:( key -> 'a -> 'a -> 'a ) -> - 'a t -> - (key * 'a) CCHashtbl.iter -> - unit
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val add_seq_with : - f:( key -> 'a -> 'a -> 'a ) -> - 'a t -> - (key * 'a) Stdlib.Seq.t -> - unit
val of_iter : (key * 'a) CCHashtbl.iter -> 'a t
val of_iter_with : - f:( key -> 'a -> 'a -> 'a ) -> - (key * 'a) CCHashtbl.iter -> - 'a t
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val of_seq_with : - f:( key -> 'a -> 'a -> 'a ) -> - (key * 'a) Stdlib.Seq.t -> - 'a t
val add_iter_count : int t -> key CCHashtbl.iter -> unit
val add_seq_count : int t -> key Stdlib.Seq.t -> unit
val of_iter_count : key CCHashtbl.iter -> int t
val of_seq_count : key Stdlib.Seq.t -> int t
val to_list : 'a t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a t
val of_list_with : f:( key -> 'a -> 'a -> 'a ) -> (key * 'a) list -> 'a t
val update : 'a t -> f:( key -> 'a option -> 'a option ) -> k:key -> unit
val get_or_add : 'a t -> f:( key -> 'a ) -> k:key -> 'a
val pp : - ?pp_start:unit CCHashtbl.printer -> - ?pp_stop:unit CCHashtbl.printer -> - ?pp_sep:unit CCHashtbl.printer -> - ?pp_arrow:unit CCHashtbl.printer -> - key CCHashtbl.printer -> - 'a CCHashtbl.printer -> - 'a t CCHashtbl.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Actions/Lit/T/Term/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Actions/Lit/T/Term/index.html deleted file mode 100644 index 0088975a..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Actions/Lit/T/Term/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Term (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Solver_internal.CC.Actions.Lit.T.Term)

Module T.Term

type t = T.Term.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Term.store
val ty : t -> Ty.t
val bool : store -> bool -> t
val as_bool : t -> bool option
val abs : store -> t -> t * bool
val map_shallow : store -> ( t -> t ) -> t -> t
val iter_shallow : store -> ( t -> unit ) -> t -> unit
val iter_dag : t -> ( t -> unit ) -> unit
module Tbl : sig ... end
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Actions/Lit/T/Ty/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Actions/Lit/T/Ty/index.html deleted file mode 100644 index 85c639de..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Actions/Lit/T/Ty/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Ty (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Solver_internal.CC.Actions.Lit.T.Ty)

Module T.Ty

type t = T.Ty.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Ty.store
val bool : store -> t
val is_bool : t -> bool
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Actions/Lit/T/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Actions/Lit/T/index.html deleted file mode 100644 index 98bacbef..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Actions/Lit/T/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -T (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Solver_internal.CC.Actions.Lit.T)

Module Lit.T

module Fun : sig ... end
module Ty : sig ... end
module Term : sig ... end
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Actions/Lit/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Actions/Lit/index.html deleted file mode 100644 index cff6aea8..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Actions/Lit/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Lit (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Solver_internal.CC.Actions.Lit)

Module Actions.Lit

module T : sig ... end
type t = Lit.t
val term : t -> T.Term.t
val sign : t -> bool
val neg : t -> t
val abs : t -> t
val signed_term : t -> T.Term.t * bool
val atom : ?sign:bool -> T.Term.store -> T.Term.t -> t
val norm_sign : t -> t * bool
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Actions/P/Step_vec/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Actions/P/Step_vec/index.html deleted file mode 100644 index 51078519..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Actions/P/Step_vec/index.html +++ /dev/null @@ -1,3 +0,0 @@ - -Step_vec (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Solver_internal.CC.Actions.P.Step_vec)

Module P.Step_vec

type elt = proof_step
val size : t -> int
val get : t -> int -> elt
val iter : f:( elt -> unit ) -> t -> unit
val iteri : f:( int -> elt -> unit ) -> t -> unit
val create : ?cap:int -> unit -> t
val clear : t -> unit
val copy : t -> t
val is_empty : t -> bool
val push : t -> elt -> unit
val fast_remove : t -> int -> unit
val filter_in_place : ( elt -> bool ) -> t -> unit
val ensure_size : t -> int -> unit
val pop : t -> elt
val set : t -> int -> elt -> unit
val shrink : t -> int -> unit
val to_iter : t -> elt Iter.t
val to_array : t -> elt array
val fold_left : ( 'a -> elt -> 'a ) -> 'a -> t -> 'a
val pp : elt CCFormat.printer -> t CCFormat.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Actions/P/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Actions/P/index.html deleted file mode 100644 index 5a718769..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Actions/P/index.html +++ /dev/null @@ -1,6 +0,0 @@ - -P (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Solver_internal.CC.Actions.P)

Module Actions.P

type t = proof
type proof_step = proof_step
type term = T.Term.t
type lit = Lit.t
type proof_rule = t -> proof_step
module Step_vec : sig ... end
val enabled : t -> bool
val emit_input_clause : lit Iter.t -> proof_rule
val emit_redundant_clause : lit Iter.t -> hyps:proof_step Iter.t -> proof_rule
val emit_unsat_core : lit Iter.t -> proof_rule
val emit_unsat : proof_step -> t -> unit
val del_clause : proof_step -> lit Iter.t -> t -> unit
val lemma_cc : lit Iter.t -> proof_rule
val define_term : term -> term -> proof_rule
val proof_p1 : proof_step -> proof_step -> proof_rule
val proof_r1 : proof_step -> proof_step -> proof_rule
val proof_res : pivot:term -> proof_step -> proof_step -> proof_rule
val with_defs : proof_step -> proof_step Iter.t -> proof_rule
val lemma_true : term -> proof_rule
val lemma_preprocess : term -> term -> using:proof_step Iter.t -> proof_rule
val lemma_rw_clause : - proof_step -> - res:lit Iter.t -> - using:proof_step Iter.t -> - proof_rule
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Actions/T/Fun/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Actions/T/Fun/index.html deleted file mode 100644 index 42af2922..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Actions/T/Fun/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Fun (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Solver_internal.CC.Actions.T.Fun)

Module T.Fun

type t = T.Fun.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Actions/T/Term/Tbl/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Actions/T/Term/Tbl/index.html deleted file mode 100644 index 8b6d50e5..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Actions/T/Term/Tbl/index.html +++ /dev/null @@ -1,23 +0,0 @@ - -Tbl (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Solver_internal.CC.Actions.T.Term.Tbl)

Module Term.Tbl

type key = t
type !'a t = 'a T.Term.Tbl.t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : ( key -> 'a -> unit ) -> 'a t -> unit
val filter_map_inplace : ( key -> 'a -> 'a option ) -> 'a t -> unit
val fold : ( key -> 'a -> 'b -> 'b ) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib.Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val get : 'a t -> key -> 'a option
val get_or : 'a t -> key -> default:'a -> 'a
val add_list : 'a list t -> key -> 'a -> unit
val incr : ?by:int -> int t -> key -> unit
val decr : ?by:int -> int t -> key -> unit
val keys : 'a t -> key CCHashtbl.iter
val values : 'a t -> 'a CCHashtbl.iter
val keys_list : 'a t -> key list
val values_list : 'a t -> 'a list
val map_list : ( key -> 'a -> 'b ) -> 'a t -> 'b list
val to_iter : 'a t -> (key * 'a) CCHashtbl.iter
val add_iter : 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_iter_with : - f:( key -> 'a -> 'a -> 'a ) -> - 'a t -> - (key * 'a) CCHashtbl.iter -> - unit
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val add_seq_with : - f:( key -> 'a -> 'a -> 'a ) -> - 'a t -> - (key * 'a) Stdlib.Seq.t -> - unit
val of_iter : (key * 'a) CCHashtbl.iter -> 'a t
val of_iter_with : - f:( key -> 'a -> 'a -> 'a ) -> - (key * 'a) CCHashtbl.iter -> - 'a t
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val of_seq_with : - f:( key -> 'a -> 'a -> 'a ) -> - (key * 'a) Stdlib.Seq.t -> - 'a t
val add_iter_count : int t -> key CCHashtbl.iter -> unit
val add_seq_count : int t -> key Stdlib.Seq.t -> unit
val of_iter_count : key CCHashtbl.iter -> int t
val of_seq_count : key Stdlib.Seq.t -> int t
val to_list : 'a t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a t
val of_list_with : f:( key -> 'a -> 'a -> 'a ) -> (key * 'a) list -> 'a t
val update : 'a t -> f:( key -> 'a option -> 'a option ) -> k:key -> unit
val get_or_add : 'a t -> f:( key -> 'a ) -> k:key -> 'a
val pp : - ?pp_start:unit CCHashtbl.printer -> - ?pp_stop:unit CCHashtbl.printer -> - ?pp_sep:unit CCHashtbl.printer -> - ?pp_arrow:unit CCHashtbl.printer -> - key CCHashtbl.printer -> - 'a CCHashtbl.printer -> - 'a t CCHashtbl.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Actions/T/Term/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Actions/T/Term/index.html deleted file mode 100644 index 73b62006..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Actions/T/Term/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Term (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Solver_internal.CC.Actions.T.Term)

Module T.Term

type t = T.Term.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Term.store
val ty : t -> Ty.t
val bool : store -> bool -> t
val as_bool : t -> bool option
val abs : store -> t -> t * bool
val map_shallow : store -> ( t -> t ) -> t -> t
val iter_shallow : store -> ( t -> unit ) -> t -> unit
val iter_dag : t -> ( t -> unit ) -> unit
module Tbl : sig ... end
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Actions/T/Ty/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Actions/T/Ty/index.html deleted file mode 100644 index 0ad30c5c..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Actions/T/Ty/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Ty (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Solver_internal.CC.Actions.T.Ty)

Module T.Ty

type t = T.Ty.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Ty.store
val bool : store -> t
val is_bool : t -> bool
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Actions/T/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Actions/T/index.html deleted file mode 100644 index 85a17832..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Actions/T/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -T (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Solver_internal.CC.Actions.T)

Module Actions.T

module Fun : sig ... end
module Ty : sig ... end
module Term : sig ... end
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Actions/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Actions/index.html deleted file mode 100644 index 7b9c13c5..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Actions/index.html +++ /dev/null @@ -1,10 +0,0 @@ - -Actions (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Solver_internal.CC.Actions)

Module CC.Actions

module T : sig ... end
module Lit : sig ... end
type proof = proof
type proof_step = proof_step
module P : sig ... end
val proof : t -> proof
val raise_conflict : t -> Lit.t list -> proof_step -> 'a
val raise_semantic_conflict : - t -> - Lit.t list -> - (bool * T.Term.t * T.Term.t) list -> - 'a
val propagate : - t -> - Lit.t -> - reason:( unit -> Lit.t list * proof_step ) -> - unit
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Debug_/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Debug_/index.html deleted file mode 100644 index 3f5ceac3..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Debug_/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Debug_ (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Solver_internal.CC.Debug_)

Module CC.Debug_

val pp : t Sidekick_core.Fmt.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Expl/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Expl/index.html deleted file mode 100644 index 5dbe1c2c..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Expl/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Expl (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Solver_internal.CC.Expl)

Module CC.Expl

val pp : t Sidekick_core.Fmt.printer
val mk_merge : N.t -> N.t -> t
val mk_merge_t : term -> term -> t
val mk_lit : lit -> t
val mk_same_value : N.t -> N.t -> t
val mk_list : t list -> t
val mk_theory : term -> term -> (term * term * t list) list -> proof_step -> t
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Lit/T/Fun/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Lit/T/Fun/index.html deleted file mode 100644 index 76aea95b..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Lit/T/Fun/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Fun (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Solver_internal.CC.Lit.T.Fun)

Module T.Fun

type t = T.Fun.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Lit/T/Term/Tbl/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Lit/T/Term/Tbl/index.html deleted file mode 100644 index 39d37bff..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Lit/T/Term/Tbl/index.html +++ /dev/null @@ -1,23 +0,0 @@ - -Tbl (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Solver_internal.CC.Lit.T.Term.Tbl)

Module Term.Tbl

type key = t
type !'a t = 'a T.Term.Tbl.t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : ( key -> 'a -> unit ) -> 'a t -> unit
val filter_map_inplace : ( key -> 'a -> 'a option ) -> 'a t -> unit
val fold : ( key -> 'a -> 'b -> 'b ) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib.Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val get : 'a t -> key -> 'a option
val get_or : 'a t -> key -> default:'a -> 'a
val add_list : 'a list t -> key -> 'a -> unit
val incr : ?by:int -> int t -> key -> unit
val decr : ?by:int -> int t -> key -> unit
val keys : 'a t -> key CCHashtbl.iter
val values : 'a t -> 'a CCHashtbl.iter
val keys_list : 'a t -> key list
val values_list : 'a t -> 'a list
val map_list : ( key -> 'a -> 'b ) -> 'a t -> 'b list
val to_iter : 'a t -> (key * 'a) CCHashtbl.iter
val add_iter : 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_iter_with : - f:( key -> 'a -> 'a -> 'a ) -> - 'a t -> - (key * 'a) CCHashtbl.iter -> - unit
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val add_seq_with : - f:( key -> 'a -> 'a -> 'a ) -> - 'a t -> - (key * 'a) Stdlib.Seq.t -> - unit
val of_iter : (key * 'a) CCHashtbl.iter -> 'a t
val of_iter_with : - f:( key -> 'a -> 'a -> 'a ) -> - (key * 'a) CCHashtbl.iter -> - 'a t
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val of_seq_with : - f:( key -> 'a -> 'a -> 'a ) -> - (key * 'a) Stdlib.Seq.t -> - 'a t
val add_iter_count : int t -> key CCHashtbl.iter -> unit
val add_seq_count : int t -> key Stdlib.Seq.t -> unit
val of_iter_count : key CCHashtbl.iter -> int t
val of_seq_count : key Stdlib.Seq.t -> int t
val to_list : 'a t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a t
val of_list_with : f:( key -> 'a -> 'a -> 'a ) -> (key * 'a) list -> 'a t
val update : 'a t -> f:( key -> 'a option -> 'a option ) -> k:key -> unit
val get_or_add : 'a t -> f:( key -> 'a ) -> k:key -> 'a
val pp : - ?pp_start:unit CCHashtbl.printer -> - ?pp_stop:unit CCHashtbl.printer -> - ?pp_sep:unit CCHashtbl.printer -> - ?pp_arrow:unit CCHashtbl.printer -> - key CCHashtbl.printer -> - 'a CCHashtbl.printer -> - 'a t CCHashtbl.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Lit/T/Term/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Lit/T/Term/index.html deleted file mode 100644 index 7052665e..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Lit/T/Term/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Term (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Solver_internal.CC.Lit.T.Term)

Module T.Term

type t = T.Term.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Term.store
val ty : t -> Ty.t
val bool : store -> bool -> t
val as_bool : t -> bool option
val abs : store -> t -> t * bool
val map_shallow : store -> ( t -> t ) -> t -> t
val iter_shallow : store -> ( t -> unit ) -> t -> unit
val iter_dag : t -> ( t -> unit ) -> unit
module Tbl : sig ... end
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Lit/T/Ty/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Lit/T/Ty/index.html deleted file mode 100644 index b90f0e09..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Lit/T/Ty/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Ty (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Solver_internal.CC.Lit.T.Ty)

Module T.Ty

type t = T.Ty.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Ty.store
val bool : store -> t
val is_bool : t -> bool
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Lit/T/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Lit/T/index.html deleted file mode 100644 index 0d072163..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Lit/T/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -T (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Solver_internal.CC.Lit.T)

Module Lit.T

module Fun : sig ... end
module Ty : sig ... end
module Term : sig ... end
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Lit/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Lit/index.html deleted file mode 100644 index 1608d6d7..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Lit/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Lit (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Solver_internal.CC.Lit)

Module CC.Lit

module T : sig ... end
type t = Lit.t
val term : t -> T.Term.t
val sign : t -> bool
val neg : t -> t
val abs : t -> t
val signed_term : t -> T.Term.t * bool
val atom : ?sign:bool -> T.Term.store -> T.Term.t -> t
val norm_sign : t -> t * bool
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/N/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/N/index.html deleted file mode 100644 index a8d6185f..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/N/index.html +++ /dev/null @@ -1,3 +0,0 @@ - -N (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Solver_internal.CC.N)

Module CC.N

val term : t -> term
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
val is_root : t -> bool
val iter_class : t -> t Iter.t
val iter_parents : t -> t Iter.t
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/P/Step_vec/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/P/Step_vec/index.html deleted file mode 100644 index 782bd0b9..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/P/Step_vec/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Step_vec (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Solver_internal.CC.P.Step_vec)

Module P.Step_vec

type elt = proof_step
val size : t -> int
val get : t -> int -> elt
val iter : f:( elt -> unit ) -> t -> unit
val iteri : f:( int -> elt -> unit ) -> t -> unit
val create : ?cap:int -> unit -> t
val clear : t -> unit
val copy : t -> t
val is_empty : t -> bool
val push : t -> elt -> unit
val fast_remove : t -> int -> unit
val filter_in_place : ( elt -> bool ) -> t -> unit
val ensure_size : t -> int -> unit
val pop : t -> elt
val set : t -> int -> elt -> unit
val shrink : t -> int -> unit
val to_iter : t -> elt Iter.t
val to_array : t -> elt array
val fold_left : ( 'a -> elt -> 'a ) -> 'a -> t -> 'a
val pp : elt CCFormat.printer -> t CCFormat.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/P/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/P/index.html deleted file mode 100644 index 356467c7..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/P/index.html +++ /dev/null @@ -1,6 +0,0 @@ - -P (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Solver_internal.CC.P)

Module CC.P

type t = proof
type proof_step = proof_step
type lit = lit
type proof_rule = t -> proof_step
module Step_vec : sig ... end
val enabled : t -> bool
val emit_input_clause : lit Iter.t -> proof_rule
val emit_redundant_clause : lit Iter.t -> hyps:proof_step Iter.t -> proof_rule
val emit_unsat_core : lit Iter.t -> proof_rule
val emit_unsat : proof_step -> t -> unit
val del_clause : proof_step -> lit Iter.t -> t -> unit
val lemma_cc : lit Iter.t -> proof_rule
val define_term : term -> term -> proof_rule
val proof_p1 : proof_step -> proof_step -> proof_rule
val proof_r1 : proof_step -> proof_step -> proof_rule
val proof_res : pivot:term -> proof_step -> proof_step -> proof_rule
val with_defs : proof_step -> proof_step Iter.t -> proof_rule
val lemma_true : term -> proof_rule
val lemma_preprocess : term -> term -> using:proof_step Iter.t -> proof_rule
val lemma_rw_clause : - proof_step -> - res:lit Iter.t -> - using:proof_step Iter.t -> - proof_rule
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Resolved_expl/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Resolved_expl/index.html deleted file mode 100644 index a102c160..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/Resolved_expl/index.html +++ /dev/null @@ -1,4 +0,0 @@ - -Resolved_expl (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Solver_internal.CC.Resolved_expl)

Module CC.Resolved_expl

type t = - Sidekick_smt_solver.Make(Solver_arg).Solver_internal.CC.Resolved_expl.t = - {
lits : lit list;
same_value : (N.t * N.t) list;
pr : proof -> proof_step;
}
val is_semantic : t -> bool
val pp : t Sidekick_core.Fmt.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/T/Fun/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/T/Fun/index.html deleted file mode 100644 index fd6a0dc0..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/T/Fun/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Fun (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Solver_internal.CC.T.Fun)

Module T.Fun

type t = T.Fun.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/T/Term/Tbl/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/T/Term/Tbl/index.html deleted file mode 100644 index f1612e00..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/T/Term/Tbl/index.html +++ /dev/null @@ -1,23 +0,0 @@ - -Tbl (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Solver_internal.CC.T.Term.Tbl)

Module Term.Tbl

type key = t
type !'a t = 'a T.Term.Tbl.t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : ( key -> 'a -> unit ) -> 'a t -> unit
val filter_map_inplace : ( key -> 'a -> 'a option ) -> 'a t -> unit
val fold : ( key -> 'a -> 'b -> 'b ) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib.Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val get : 'a t -> key -> 'a option
val get_or : 'a t -> key -> default:'a -> 'a
val add_list : 'a list t -> key -> 'a -> unit
val incr : ?by:int -> int t -> key -> unit
val decr : ?by:int -> int t -> key -> unit
val keys : 'a t -> key CCHashtbl.iter
val values : 'a t -> 'a CCHashtbl.iter
val keys_list : 'a t -> key list
val values_list : 'a t -> 'a list
val map_list : ( key -> 'a -> 'b ) -> 'a t -> 'b list
val to_iter : 'a t -> (key * 'a) CCHashtbl.iter
val add_iter : 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_iter_with : - f:( key -> 'a -> 'a -> 'a ) -> - 'a t -> - (key * 'a) CCHashtbl.iter -> - unit
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val add_seq_with : - f:( key -> 'a -> 'a -> 'a ) -> - 'a t -> - (key * 'a) Stdlib.Seq.t -> - unit
val of_iter : (key * 'a) CCHashtbl.iter -> 'a t
val of_iter_with : - f:( key -> 'a -> 'a -> 'a ) -> - (key * 'a) CCHashtbl.iter -> - 'a t
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val of_seq_with : - f:( key -> 'a -> 'a -> 'a ) -> - (key * 'a) Stdlib.Seq.t -> - 'a t
val add_iter_count : int t -> key CCHashtbl.iter -> unit
val add_seq_count : int t -> key Stdlib.Seq.t -> unit
val of_iter_count : key CCHashtbl.iter -> int t
val of_seq_count : key Stdlib.Seq.t -> int t
val to_list : 'a t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a t
val of_list_with : f:( key -> 'a -> 'a -> 'a ) -> (key * 'a) list -> 'a t
val update : 'a t -> f:( key -> 'a option -> 'a option ) -> k:key -> unit
val get_or_add : 'a t -> f:( key -> 'a ) -> k:key -> 'a
val pp : - ?pp_start:unit CCHashtbl.printer -> - ?pp_stop:unit CCHashtbl.printer -> - ?pp_sep:unit CCHashtbl.printer -> - ?pp_arrow:unit CCHashtbl.printer -> - key CCHashtbl.printer -> - 'a CCHashtbl.printer -> - 'a t CCHashtbl.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/T/Term/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/T/Term/index.html deleted file mode 100644 index 6984e2c9..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/T/Term/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Term (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Solver_internal.CC.T.Term)

Module T.Term

type t = T.Term.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Term.store
val ty : t -> Ty.t
val bool : store -> bool -> t
val as_bool : t -> bool option
val abs : store -> t -> t * bool
val map_shallow : store -> ( t -> t ) -> t -> t
val iter_shallow : store -> ( t -> unit ) -> t -> unit
val iter_dag : t -> ( t -> unit ) -> unit
module Tbl : sig ... end
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/T/Ty/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/T/Ty/index.html deleted file mode 100644 index f7f1d30a..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/T/Ty/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Ty (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Solver_internal.CC.T.Ty)

Module T.Ty

type t = T.Ty.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Ty.store
val bool : store -> t
val is_bool : t -> bool
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/T/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/T/index.html deleted file mode 100644 index 5e89f70e..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/T/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -T (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Solver_internal.CC.T)

Module CC.T

module Fun : sig ... end
module Ty : sig ... end
module Term : sig ... end
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/index.html deleted file mode 100644 index d91d8905..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/CC/index.html +++ /dev/null @@ -1,13 +0,0 @@ - -CC (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Solver_internal.CC)

Module Solver_internal.CC

module T : sig ... end
module Lit : sig ... end
type proof = proof
type proof_step = proof_step
module P : sig ... end
module Actions : sig ... end
type term_store = T.Term.store
type term = T.Term.t
type value = term
type fun_ = T.Fun.t
type lit = Lit.t
type actions = Actions.t
module N : sig ... end
module Expl : sig ... end
module Resolved_expl : sig ... end
type node = N.t
type repr = N.t
type explanation = Expl.t
val term_store : t -> term_store
val proof : t -> proof
val find : t -> node -> repr
val add_term : t -> term -> node
val mem_term : t -> term -> bool
type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit
type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit
type ev_on_new_term = t -> N.t -> term -> unit
type ev_on_conflict = t -> th:bool -> lit list -> unit
type ev_on_propagate = t -> lit -> ( unit -> lit list * proof_step ) -> unit
type ev_on_is_subterm = N.t -> term -> unit
val create : - ?stat:Sidekick_util.Stat.t -> - ?on_pre_merge:ev_on_pre_merge list -> - ?on_post_merge:ev_on_post_merge list -> - ?on_new_term:ev_on_new_term list -> - ?on_conflict:ev_on_conflict list -> - ?on_propagate:ev_on_propagate list -> - ?on_is_subterm:ev_on_is_subterm list -> - ?size:[ `Big | `Small ] -> - term_store -> - proof -> - t
val allocate_bitfield : descr:string -> t -> N.bitfield
val get_bitfield : t -> N.bitfield -> N.t -> bool
val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit
val on_pre_merge : t -> ev_on_pre_merge -> unit
val on_post_merge : t -> ev_on_post_merge -> unit
val on_new_term : t -> ev_on_new_term -> unit
val on_conflict : t -> ev_on_conflict -> unit
val on_propagate : t -> ev_on_propagate -> unit
val on_is_subterm : t -> ev_on_is_subterm -> unit
val set_as_lit : t -> N.t -> lit -> unit
val find_t : t -> term -> repr
val add_seq : t -> term Iter.t -> unit
val all_classes : t -> repr Iter.t
val assert_lit : t -> lit -> unit
val assert_lits : t -> lit Iter.t -> unit
val explain_eq : t -> N.t -> N.t -> Resolved_expl.t
val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a
val n_true : t -> N.t
val n_false : t -> N.t
val n_bool : t -> bool -> N.t
val merge : t -> N.t -> N.t -> Expl.t -> unit
val merge_t : t -> term -> term -> Expl.t -> unit
val set_model_value : t -> term -> value -> unit
val with_model_mode : t -> ( unit -> 'a ) -> 'a
val get_model_for_each_class : t -> (repr * N.t Iter.t * value) Iter.t
val check : t -> actions -> unit
val push_level : t -> unit
val pop_levels : t -> int -> unit
val get_model : t -> N.t Iter.t Iter.t
module Debug_ : sig ... end
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/Lit/T/Fun/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/Lit/T/Fun/index.html deleted file mode 100644 index 271d55bd..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/Lit/T/Fun/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Fun (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Solver_internal.Lit.T.Fun)

Module T.Fun

type t = T.Fun.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/Lit/T/Term/Tbl/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/Lit/T/Term/Tbl/index.html deleted file mode 100644 index 5d21a001..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/Lit/T/Term/Tbl/index.html +++ /dev/null @@ -1,23 +0,0 @@ - -Tbl (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Solver_internal.Lit.T.Term.Tbl)

Module Term.Tbl

type key = t
type !'a t = 'a T.Term.Tbl.t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : ( key -> 'a -> unit ) -> 'a t -> unit
val filter_map_inplace : ( key -> 'a -> 'a option ) -> 'a t -> unit
val fold : ( key -> 'a -> 'b -> 'b ) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib.Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val get : 'a t -> key -> 'a option
val get_or : 'a t -> key -> default:'a -> 'a
val add_list : 'a list t -> key -> 'a -> unit
val incr : ?by:int -> int t -> key -> unit
val decr : ?by:int -> int t -> key -> unit
val keys : 'a t -> key CCHashtbl.iter
val values : 'a t -> 'a CCHashtbl.iter
val keys_list : 'a t -> key list
val values_list : 'a t -> 'a list
val map_list : ( key -> 'a -> 'b ) -> 'a t -> 'b list
val to_iter : 'a t -> (key * 'a) CCHashtbl.iter
val add_iter : 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_iter_with : - f:( key -> 'a -> 'a -> 'a ) -> - 'a t -> - (key * 'a) CCHashtbl.iter -> - unit
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val add_seq_with : - f:( key -> 'a -> 'a -> 'a ) -> - 'a t -> - (key * 'a) Stdlib.Seq.t -> - unit
val of_iter : (key * 'a) CCHashtbl.iter -> 'a t
val of_iter_with : - f:( key -> 'a -> 'a -> 'a ) -> - (key * 'a) CCHashtbl.iter -> - 'a t
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val of_seq_with : - f:( key -> 'a -> 'a -> 'a ) -> - (key * 'a) Stdlib.Seq.t -> - 'a t
val add_iter_count : int t -> key CCHashtbl.iter -> unit
val add_seq_count : int t -> key Stdlib.Seq.t -> unit
val of_iter_count : key CCHashtbl.iter -> int t
val of_seq_count : key Stdlib.Seq.t -> int t
val to_list : 'a t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a t
val of_list_with : f:( key -> 'a -> 'a -> 'a ) -> (key * 'a) list -> 'a t
val update : 'a t -> f:( key -> 'a option -> 'a option ) -> k:key -> unit
val get_or_add : 'a t -> f:( key -> 'a ) -> k:key -> 'a
val pp : - ?pp_start:unit CCHashtbl.printer -> - ?pp_stop:unit CCHashtbl.printer -> - ?pp_sep:unit CCHashtbl.printer -> - ?pp_arrow:unit CCHashtbl.printer -> - key CCHashtbl.printer -> - 'a CCHashtbl.printer -> - 'a t CCHashtbl.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/Lit/T/Term/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/Lit/T/Term/index.html deleted file mode 100644 index 2319dba9..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/Lit/T/Term/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Term (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Solver_internal.Lit.T.Term)

Module T.Term

type t = T.Term.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Term.store
val ty : t -> Ty.t
val bool : store -> bool -> t
val as_bool : t -> bool option
val abs : store -> t -> t * bool
val map_shallow : store -> ( t -> t ) -> t -> t
val iter_shallow : store -> ( t -> unit ) -> t -> unit
val iter_dag : t -> ( t -> unit ) -> unit
module Tbl : sig ... end
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/Lit/T/Ty/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/Lit/T/Ty/index.html deleted file mode 100644 index 6f5ef329..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/Lit/T/Ty/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Ty (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Solver_internal.Lit.T.Ty)

Module T.Ty

type t = T.Ty.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Ty.store
val bool : store -> t
val is_bool : t -> bool
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/Lit/T/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/Lit/T/index.html deleted file mode 100644 index 302fb4e0..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/Lit/T/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -T (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Solver_internal.Lit.T)

Module Lit.T

module Fun : sig ... end
module Ty : sig ... end
module Term : sig ... end
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/Lit/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/Lit/index.html deleted file mode 100644 index 02b763d0..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/Lit/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Lit (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Solver_internal.Lit)

Module Solver_internal.Lit

module T : sig ... end
type t = Lit.t
val term : t -> T.Term.t
val sign : t -> bool
val neg : t -> t
val abs : t -> t
val signed_term : t -> T.Term.t * bool
val atom : ?sign:bool -> T.Term.store -> T.Term.t -> t
val norm_sign : t -> t * bool
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/P/Step_vec/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/P/Step_vec/index.html deleted file mode 100644 index 68ef0dea..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/P/Step_vec/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Step_vec (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Solver_internal.P.Step_vec)

Module P.Step_vec

type elt = proof_step
type t = P.Step_vec.t
val size : t -> int
val get : t -> int -> elt
val iter : f:( elt -> unit ) -> t -> unit
val iteri : f:( int -> elt -> unit ) -> t -> unit
val create : ?cap:int -> unit -> t
val clear : t -> unit
val copy : t -> t
val is_empty : t -> bool
val push : t -> elt -> unit
val fast_remove : t -> int -> unit
val filter_in_place : ( elt -> bool ) -> t -> unit
val ensure_size : t -> int -> unit
val pop : t -> elt
val set : t -> int -> elt -> unit
val shrink : t -> int -> unit
val to_iter : t -> elt Iter.t
val to_array : t -> elt array
val fold_left : ( 'a -> elt -> 'a ) -> 'a -> t -> 'a
val pp : elt CCFormat.printer -> t CCFormat.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/P/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/P/index.html deleted file mode 100644 index 86183ffa..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/P/index.html +++ /dev/null @@ -1,6 +0,0 @@ - -P (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Solver_internal.P)

Module Solver_internal.P

type t = proof
type proof_step = proof_step
type term = T.Term.t
type lit = Lit.t
type proof_rule = t -> proof_step
module Step_vec : sig ... end
val enabled : t -> bool
val emit_input_clause : lit Iter.t -> proof_rule
val emit_redundant_clause : lit Iter.t -> hyps:proof_step Iter.t -> proof_rule
val emit_unsat_core : lit Iter.t -> proof_rule
val emit_unsat : proof_step -> t -> unit
val del_clause : proof_step -> lit Iter.t -> t -> unit
val lemma_cc : lit Iter.t -> proof_rule
val define_term : term -> term -> proof_rule
val proof_p1 : proof_step -> proof_step -> proof_rule
val proof_r1 : proof_step -> proof_step -> proof_rule
val proof_res : pivot:term -> proof_step -> proof_step -> proof_rule
val with_defs : proof_step -> proof_step Iter.t -> proof_rule
val lemma_true : term -> proof_rule
val lemma_preprocess : term -> term -> using:proof_step Iter.t -> proof_rule
val lemma_rw_clause : - proof_step -> - res:lit Iter.t -> - using:proof_step Iter.t -> - proof_rule
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/Registry/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/Registry/index.html deleted file mode 100644 index b711745e..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/Registry/index.html +++ /dev/null @@ -1,3 +0,0 @@ - -Registry (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Solver_internal.Registry)

Module Solver_internal.Registry

val create_key : unit -> 'a key
val create : unit -> t
val get : t -> 'a key -> 'a option
val set : t -> 'a key -> 'a -> unit
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/Simplify/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/Simplify/index.html deleted file mode 100644 index 17ce6d94..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/Simplify/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Simplify (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Solver_internal.Simplify)

Module Solver_internal.Simplify

val tst : t -> term_store
val ty_st : t -> ty_store
val clear : t -> unit
val proof : t -> proof
type hook = t -> term -> (term * proof_step Iter.t) option
val normalize : t -> term -> (term * proof_step) option
val normalize_t : t -> term -> term * proof_step option
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/T/Fun/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/T/Fun/index.html deleted file mode 100644 index b8dc1db3..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/T/Fun/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Fun (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Solver_internal.T.Fun)

Module T.Fun

type t = T.Fun.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/T/Term/Tbl/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/T/Term/Tbl/index.html deleted file mode 100644 index f8a00c18..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/T/Term/Tbl/index.html +++ /dev/null @@ -1,23 +0,0 @@ - -Tbl (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Solver_internal.T.Term.Tbl)

Module Term.Tbl

type key = t
type !'a t = 'a T.Term.Tbl.t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : ( key -> 'a -> unit ) -> 'a t -> unit
val filter_map_inplace : ( key -> 'a -> 'a option ) -> 'a t -> unit
val fold : ( key -> 'a -> 'b -> 'b ) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib.Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val get : 'a t -> key -> 'a option
val get_or : 'a t -> key -> default:'a -> 'a
val add_list : 'a list t -> key -> 'a -> unit
val incr : ?by:int -> int t -> key -> unit
val decr : ?by:int -> int t -> key -> unit
val keys : 'a t -> key CCHashtbl.iter
val values : 'a t -> 'a CCHashtbl.iter
val keys_list : 'a t -> key list
val values_list : 'a t -> 'a list
val map_list : ( key -> 'a -> 'b ) -> 'a t -> 'b list
val to_iter : 'a t -> (key * 'a) CCHashtbl.iter
val add_iter : 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_iter_with : - f:( key -> 'a -> 'a -> 'a ) -> - 'a t -> - (key * 'a) CCHashtbl.iter -> - unit
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val add_seq_with : - f:( key -> 'a -> 'a -> 'a ) -> - 'a t -> - (key * 'a) Stdlib.Seq.t -> - unit
val of_iter : (key * 'a) CCHashtbl.iter -> 'a t
val of_iter_with : - f:( key -> 'a -> 'a -> 'a ) -> - (key * 'a) CCHashtbl.iter -> - 'a t
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val of_seq_with : - f:( key -> 'a -> 'a -> 'a ) -> - (key * 'a) Stdlib.Seq.t -> - 'a t
val add_iter_count : int t -> key CCHashtbl.iter -> unit
val add_seq_count : int t -> key Stdlib.Seq.t -> unit
val of_iter_count : key CCHashtbl.iter -> int t
val of_seq_count : key Stdlib.Seq.t -> int t
val to_list : 'a t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a t
val of_list_with : f:( key -> 'a -> 'a -> 'a ) -> (key * 'a) list -> 'a t
val update : 'a t -> f:( key -> 'a option -> 'a option ) -> k:key -> unit
val get_or_add : 'a t -> f:( key -> 'a ) -> k:key -> 'a
val pp : - ?pp_start:unit CCHashtbl.printer -> - ?pp_stop:unit CCHashtbl.printer -> - ?pp_sep:unit CCHashtbl.printer -> - ?pp_arrow:unit CCHashtbl.printer -> - key CCHashtbl.printer -> - 'a CCHashtbl.printer -> - 'a t CCHashtbl.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/T/Term/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/T/Term/index.html deleted file mode 100644 index 4b776ba2..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/T/Term/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Term (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Solver_internal.T.Term)

Module T.Term

type t = T.Term.t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Term.store
val ty : t -> Ty.t
val bool : store -> bool -> t
val as_bool : t -> bool option
val abs : store -> t -> t * bool
val map_shallow : store -> ( t -> t ) -> t -> t
val iter_shallow : store -> ( t -> unit ) -> t -> unit
val iter_dag : t -> ( t -> unit ) -> unit
module Tbl : sig ... end
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/T/Ty/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/T/Ty/index.html deleted file mode 100644 index e394b1ef..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/T/Ty/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Ty (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Solver_internal.T.Ty)

Module T.Ty

type t = T.Ty.t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store = T.Ty.store
val bool : store -> t
val is_bool : t -> bool
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/T/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/T/index.html deleted file mode 100644 index 5be725b1..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/T/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -T (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Solver_internal.T)

Module Solver_internal.T

module Fun : sig ... end
module Ty : sig ... end
module Term : sig ... end
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/index.html deleted file mode 100644 index 934797c1..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/index.html +++ /dev/null @@ -1,37 +0,0 @@ - -Solver_internal (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Solver_internal)

Module S.Solver_internal

module T : sig ... end
module Lit : sig ... end
type ty = T.Ty.t
type term = T.Term.t
type value = T.Term.t
type term_store = T.Term.store
type ty_store = T.Ty.store
type proof = proof
type proof_step = proof_step
module P : sig ... end
type solver = t
val tst : t -> term_store
val ty_st : t -> ty_store
val stats : t -> Sidekick_util.Stat.t
val proof : t -> proof
module Registry : sig ... end
val registry : t -> Registry.t
type lit = Lit.t
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 simplify_t : t -> term -> (term * proof_step) option
val simp_t : t -> term -> term * proof_step option
module type PREPROCESS_ACTS = sig ... end
type preprocess_actions = (module PREPROCESS_ACTS)
type preprocess_hook = t -> preprocess_actions -> term -> unit
val on_preprocess : t -> preprocess_hook -> unit
val raise_conflict : t -> theory_actions -> lit list -> proof_step -> 'a
val push_decision : t -> theory_actions -> lit -> unit
val propagate : - t -> - theory_actions -> - lit -> - reason:( unit -> lit list * proof_step ) -> - unit
val propagate_l : t -> theory_actions -> lit -> lit list -> proof_step -> unit
val add_clause_temp : t -> theory_actions -> lit list -> proof_step -> unit
val add_clause_permanent : - t -> - theory_actions -> - lit list -> - proof_step -> - unit
val mk_lit : t -> theory_actions -> ?sign:bool -> term -> lit
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 * proof_step ) -> 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
val on_th_combination : - t -> - ( t -> theory_actions -> (term * value) Iter.t ) -> - unit
val declare_pb_is_incomplete : t -> unit
type model_ask_hook = - recurse:( t -> CC.N.t -> term ) -> - t -> - CC.N.t -> - term option
type model_completion_hook = t -> add:( term -> term -> unit ) -> unit
val on_model : - ?ask:model_ask_hook -> - ?complete:model_completion_hook -> - t -> - unit
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/module-type-PREPROCESS_ACTS/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/module-type-PREPROCESS_ACTS/index.html deleted file mode 100644 index 1cccbeb8..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Solver_internal/module-type-PREPROCESS_ACTS/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -PREPROCESS_ACTS (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Solver_internal.PREPROCESS_ACTS)

Module type Solver_internal.PREPROCESS_ACTS

val proof : proof
val mk_lit : ?sign:bool -> term -> lit
val add_clause : lit list -> proof_step -> unit
val add_lit : ?default_pol:bool -> lit -> unit
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/T/Fun/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/T/Fun/index.html deleted file mode 100644 index 391716bd..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/T/Fun/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Fun (sidekick-base.Sidekick_base_solver.Th_lia.A.S.T.Fun)

Module T.Fun

val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/T/Term/Tbl/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/T/Term/Tbl/index.html deleted file mode 100644 index 41d82a49..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/T/Term/Tbl/index.html +++ /dev/null @@ -1,23 +0,0 @@ - -Tbl (sidekick-base.Sidekick_base_solver.Th_lia.A.S.T.Term.Tbl)

Module Term.Tbl

type key = t
type !'a t = 'a Solver_arg.T.Term.Tbl.t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : ( key -> 'a -> unit ) -> 'a t -> unit
val filter_map_inplace : ( key -> 'a -> 'a option ) -> 'a t -> unit
val fold : ( key -> 'a -> 'b -> 'b ) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib.Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val get : 'a t -> key -> 'a option
val get_or : 'a t -> key -> default:'a -> 'a
val add_list : 'a list t -> key -> 'a -> unit
val incr : ?by:int -> int t -> key -> unit
val decr : ?by:int -> int t -> key -> unit
val keys : 'a t -> key CCHashtbl.iter
val values : 'a t -> 'a CCHashtbl.iter
val keys_list : 'a t -> key list
val values_list : 'a t -> 'a list
val map_list : ( key -> 'a -> 'b ) -> 'a t -> 'b list
val to_iter : 'a t -> (key * 'a) CCHashtbl.iter
val add_iter : 'a t -> (key * 'a) CCHashtbl.iter -> unit
val add_iter_with : - f:( key -> 'a -> 'a -> 'a ) -> - 'a t -> - (key * 'a) CCHashtbl.iter -> - unit
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val add_seq_with : - f:( key -> 'a -> 'a -> 'a ) -> - 'a t -> - (key * 'a) Stdlib.Seq.t -> - unit
val of_iter : (key * 'a) CCHashtbl.iter -> 'a t
val of_iter_with : - f:( key -> 'a -> 'a -> 'a ) -> - (key * 'a) CCHashtbl.iter -> - 'a t
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val of_seq_with : - f:( key -> 'a -> 'a -> 'a ) -> - (key * 'a) Stdlib.Seq.t -> - 'a t
val add_iter_count : int t -> key CCHashtbl.iter -> unit
val add_seq_count : int t -> key Stdlib.Seq.t -> unit
val of_iter_count : key CCHashtbl.iter -> int t
val of_seq_count : key Stdlib.Seq.t -> int t
val to_list : 'a t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a t
val of_list_with : f:( key -> 'a -> 'a -> 'a ) -> (key * 'a) list -> 'a t
val update : 'a t -> f:( key -> 'a option -> 'a option ) -> k:key -> unit
val get_or_add : 'a t -> f:( key -> 'a ) -> k:key -> 'a
val pp : - ?pp_start:unit CCHashtbl.printer -> - ?pp_stop:unit CCHashtbl.printer -> - ?pp_sep:unit CCHashtbl.printer -> - ?pp_arrow:unit CCHashtbl.printer -> - key CCHashtbl.printer -> - 'a CCHashtbl.printer -> - 'a t CCHashtbl.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/T/Term/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/T/Term/index.html deleted file mode 100644 index 84c64fd5..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/T/Term/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Term (sidekick-base.Sidekick_base_solver.Th_lia.A.S.T.Term)

Module T.Term

val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
val ty : t -> Ty.t
val bool : store -> bool -> t
val as_bool : t -> bool option
val abs : store -> t -> t * bool
val map_shallow : store -> ( t -> t ) -> t -> t
val iter_shallow : store -> ( t -> unit ) -> t -> unit
val iter_dag : t -> ( t -> unit ) -> unit
module Tbl : sig ... end
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/T/Ty/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/T/Ty/index.html deleted file mode 100644 index 2069e6b4..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/T/Ty/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Ty (sidekick-base.Sidekick_base_solver.Th_lia.A.S.T.Ty)

Module T.Ty

val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
val bool : store -> t
val is_bool : t -> bool
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/T/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/T/index.html deleted file mode 100644 index f8c22cd7..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/T/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -T (sidekick-base.Sidekick_base_solver.Th_lia.A.S.T)

Module S.T

module Fun : sig ... end
module Ty : sig ... end
module Term : sig ... end
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Unknown/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Unknown/index.html deleted file mode 100644 index c40d1b97..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/Unknown/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Unknown (sidekick-base.Sidekick_base_solver.Th_lia.A.S.Unknown)

Module S.Unknown

val pp : t CCFormat.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/index.html deleted file mode 100644 index c5f155a5..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/index.html +++ /dev/null @@ -1,28 +0,0 @@ - -S (sidekick-base.Sidekick_base_solver.Th_lia.A.S)

Module A.S

module T : sig ... end
module Lit : sig ... end
type proof = Solver_arg.proof
type proof_step = Solver_arg.proof_step
module P : sig ... end
module Solver_internal : sig ... end
type solver = t
type term = T.Term.t
type ty = T.Ty.t
type lit = Lit.t
module Registry : sig ... end
val registry : t -> Registry.t
module type THEORY = sig ... end
type theory = (module THEORY)
type !'a theory_p = (module THEORY with type t = 'a)
val mk_theory : - name:string -> - create_and_setup:( Solver_internal.t -> 'th ) -> - ?push_level:( 'th -> unit ) -> - ?pop_levels:( 'th -> int -> unit ) -> - unit -> - theory
module Model : sig ... end
module Unknown : sig ... end
val stats : t -> Sidekick_util.Stat.t
val tst : t -> T.Term.store
val ty_st : t -> T.Ty.store
val proof : t -> proof
val create : - ?stat:Sidekick_util.Stat.t -> - ?size:[ `Big | `Small | `Tiny ] -> - proof:proof -> - theories:theory list -> - T.Term.store -> - T.Ty.store -> - unit -> - t
val add_theory : t -> theory -> unit
val add_theory_p : t -> 'a theory_p -> 'a
val add_theory_l : t -> theory list -> unit
val mk_lit_t : t -> ?sign:bool -> term -> lit
val add_clause : t -> lit Sidekick_util.IArray.t -> proof_step -> unit
val add_clause_l : t -> lit list -> proof_step -> unit
val assert_terms : t -> term list -> unit
val assert_term : t -> term -> unit
type res = Sidekick_smt_solver.Make(Solver_arg).res =
| Sat of Model.t
| Unsat of {
unsat_core : unit -> lit Iter.t;
unsat_proof_step : unit -> proof_step option;
}
| Unknown of Unknown.t
val solve : - ?on_exit:( unit -> unit ) list -> - ?check:bool -> - ?on_progress:( t -> unit ) -> - ?should_stop:( t -> int -> bool ) -> - assumptions:lit list -> - t -> - res
val last_res : t -> res option
val push_assumption : t -> lit -> unit
val pop_assumptions : t -> int -> unit
type propagation_result = - Sidekick_smt_solver.Make(Solver_arg).propagation_result = -
| PR_sat
| PR_conflict of {
backtracked : int;
}
| PR_unsat of {
unsat_core : unit -> lit Iter.t;
}
val check_sat_propagations_only : - assumptions:lit list -> - t -> - propagation_result
val pp_stats : t CCFormat.printer
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/module-type-THEORY/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/module-type-THEORY/index.html deleted file mode 100644 index 327bf13d..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/S/module-type-THEORY/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -THEORY (sidekick-base.Sidekick_base_solver.Th_lia.A.S.THEORY)

Module type S.THEORY

type t
val name : string
val create_and_setup : Solver_internal.t -> t
val push_level : t -> unit
val pop_levels : t -> int -> unit
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/Z/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/Z/index.html deleted file mode 100644 index f1d99e1a..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/Z/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Z (sidekick-base.Sidekick_base_solver.Th_lia.A.Z)

Module A.Z

type t = Z.t
val zero : t
val one : t
val minus_one : t
val abs : t -> t
val sign : t -> int
val of_int : int -> t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t CCFormat.printer
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
val succ : t -> t
val pred : t -> t
val gcd : t -> t -> t
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/index.html deleted file mode 100644 index 34be155c..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/A/index.html +++ /dev/null @@ -1,5 +0,0 @@ - -A (sidekick-base.Sidekick_base_solver.Th_lia.A)

Module Th_lia.A

module S : sig ... end
module Z : sig ... end
module Q : sig ... end
module LRA_solver : sig ... end
type term = S.T.Term.t
type ty = S.T.Ty.t
val view_as_lia : term -> ( Z.t, Q.t, term ) Sidekick_arith_lia.lia_view
val mk_bool : S.T.Term.store -> bool -> term
val mk_to_real : S.T.Term.store -> term -> term
val ty_int : S.T.Term.store -> ty
val mk_eq : S.T.Term.store -> term -> term -> term
val has_ty_int : term -> bool
val lemma_lia : S.Lit.t Iter.t -> S.P.proof_rule
val lemma_relax_to_lra : S.Lit.t Iter.t -> S.P.proof_rule
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lia/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lia/index.html deleted file mode 100644 index 20f8644a..00000000 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lia/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Th_lia (sidekick-base.Sidekick_base_solver.Th_lia)

Module Sidekick_base_solver.Th_lia

module A : sig ... end
val theory : A.S.theory
\ No newline at end of file diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/SimpSolver/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/SimpSolver/index.html index 5483b814..4dde719f 100644 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lra/SimpSolver/index.html +++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/SimpSolver/index.html @@ -1,12 +1,11 @@ SimpSolver (sidekick-base.Sidekick_base_solver.Th_lra.SimpSolver)

Module Th_lra.SimpSolver

module V_map : CCMap.S with type key = V.t
module Q : Sidekick_simplex.RATIONAL with type bigint = Z.t
type num = Q.t

Numbers

module Constraint : sig ... end
module Subst : sig ... end
type t
val create : ?stat:Sidekick_util.Stat.t -> unit -> t

Create a new simplex.

val push_level : t -> unit
val pop_levels : t -> int -> unit
val define : ?is_int:bool -> t -> V.t -> (num * V.t) list -> unit

Define a basic variable in terms of other variables. This is useful to "name" a linear expression and get back a variable that can be used in a Constraint.t

type unsat_cert
module Unsat_cert : sig ... end
exception E_unsat of Unsat_cert.t
type ev_on_propagate = V.lit -> reason:V.lit list -> unit
val add_var : ?is_int:bool -> t -> V.t -> unit

Make sure the variable exists in the simplex.

val add_constraint : - ?keep_on_backtracking:bool -> ?is_int:bool -> on_propagate:ev_on_propagate -> t -> Constraint.t -> V.lit -> - unit

Add a constraint to the simplex.

This is removed upon backtracking by default.

  • parameter is_int

    declares whether the constraint's variable is an integer

  • raises Unsat

    if it's immediately obvious that this is not satisfiable.

  • parameter keep_on_backtracking

    if true (default false), the bound is not backtrackable

val declare_bound : ?is_int:bool -> t -> Constraint.t -> V.lit -> unit

Declare that this constraint exists and map it to a literal, so we can possibly propagate it later. Unlike add_constraint this does NOT assert that the constraint is true

val check_exn : + unit

Add a constraint to the simplex.

This is removed upon backtracking by default.

  • parameter is_int

    declares whether the constraint's variable is an integer

  • raises Unsat

    if it's immediately obvious that this is not satisfiable.

val declare_bound : ?is_int:bool -> t -> Constraint.t -> V.lit -> unit

Declare that this constraint exists and map it to a literal, so we can possibly propagate it later. Unlike add_constraint this does NOT assert that the constraint is true

val check_exn : on_propagate:( V.lit -> reason:V.lit list -> unit ) -> t -> unit

Check the whole simplex for satisfiability.

  • parameter on_propagate

    is called with arguments lit, reason whenever reason => lit is found to be true by the simplex.

  • raises Unsat

    if the constraints are not satisfiable.

type result =
| Sat of Subst.t
| Unsat of Unsat_cert.t
val check : on_propagate:( V.lit -> reason:V.lit list -> unit ) -> t -> result

Call check_exn and return a model or a proof of unsat. This does NOT enforce that integer variables map to integer values.

val check_branch_and_bound : diff --git a/dev/sidekick-base/Sidekick_base_solver/index.html b/dev/sidekick-base/Sidekick_base_solver/index.html index d1523ffb..c1fc4506 100644 --- a/dev/sidekick-base/Sidekick_base_solver/index.html +++ b/dev/sidekick-base/Sidekick_base_solver/index.html @@ -1,2 +1,2 @@ -Sidekick_base_solver (sidekick-base.Sidekick_base_solver)

Module Sidekick_base_solver

SMT Solver and Theories for Sidekick_base.

This contains instances of the SMT solver, and theories, from Sidekick_core, using data structures from Sidekick_base.

module Solver_arg : sig ... end

Argument to the SMT solver

module Solver : sig ... end

SMT solver, obtained from Sidekick_smt_solver

module Th_data : sig ... end

Theory of datatypes

module Th_bool : sig ... end

Reducing boolean formulas to clauses

module Gensym : sig ... end
module Th_lra : sig ... end

Theory of Linear Rational Arithmetic

module Th_lia : sig ... end
val th_bool : Solver.theory
val th_data : Solver.theory
val th_lra : Solver.theory
val th_lia : Solver.theory
\ No newline at end of file +Sidekick_base_solver (sidekick-base.Sidekick_base_solver)

Module Sidekick_base_solver

SMT Solver and Theories for Sidekick_base.

This contains instances of the SMT solver, and theories, from Sidekick_core, using data structures from Sidekick_base.

module Solver_arg : sig ... end

Argument to the SMT solver

module Solver : sig ... end

SMT solver, obtained from Sidekick_smt_solver

module Th_data : sig ... end

Theory of datatypes

module Th_bool : sig ... end

Reducing boolean formulas to clauses

module Gensym : sig ... end
module Th_lra : sig ... end

Theory of Linear Rational Arithmetic

val th_bool : Solver.theory
val th_data : Solver.theory
val th_lra : Solver.theory
\ No newline at end of file diff --git a/dev/sidekick-bin/Sidekick_smtlib/Process/index.html b/dev/sidekick-bin/Sidekick_smtlib/Process/index.html index 49b3746d..162a5b19 100644 --- a/dev/sidekick-bin/Sidekick_smtlib/Process/index.html +++ b/dev/sidekick-bin/Sidekick_smtlib/Process/index.html @@ -5,7 +5,7 @@ and type T.Term.store = Sidekick_base.Term.store and type T.Ty.t = Sidekick_base.Ty.t and type T.Ty.store = Sidekick_base.Ty.store - and type proof = Sidekick_base.Proof.t
val th_bool : Solver.theory
val th_data : Solver.theory
val th_lra : Solver.theory
val th_lia : Solver.theory
type 'a or_error = ( 'a, string ) CCResult.t
module Check_cc : sig ... end
val process_stmt : + and type proof = Sidekick_base.Proof.t
val th_bool : Solver.theory
val th_data : Solver.theory
val th_lra : Solver.theory
type 'a or_error = ( 'a, string ) CCResult.t
module Check_cc : sig ... end
val process_stmt : ?gc:bool -> ?restarts:bool -> ?pp_cnf:bool -> diff --git a/dev/sidekick/Sidekick_arith_lia/.dummy b/dev/sidekick/Sidekick_arith_lia/.dummy deleted file mode 100644 index e69de29b..00000000 diff --git a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/LRA_solver/A/Gensym/index.html b/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/LRA_solver/A/Gensym/index.html deleted file mode 100644 index a831aaac..00000000 --- a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/LRA_solver/A/Gensym/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Gensym (sidekick.Sidekick_arith_lia.Make.1-A.LRA_solver.A.Gensym)

Module A.Gensym

type t
val create : S.T.Term.store -> t
val tst : t -> S.T.Term.store
val copy : t -> t
val fresh_term : t -> pre:string -> S.T.Ty.t -> term

Make a fresh term of the given type

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/LRA_solver/A/Q/index.html b/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/LRA_solver/A/Q/index.html deleted file mode 100644 index 6b344216..00000000 --- a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/LRA_solver/A/Q/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Q (sidekick.Sidekick_arith_lia.Make.1-A.LRA_solver.A.Q)

Module A.Q

include Sidekick_arith.NUM with type t = Q.t
type t = Q.t
val zero : t
val one : t
val minus_one : t
val abs : t -> t
val sign : t -> int
val of_int : int -> t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val pp : t CCFormat.printer
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
type bigint = Z.t
val (/) : t -> t -> t
val num : t -> bigint
val denum : t -> bigint
val infinity : t

+infinity

val minus_infinity : t
val of_bigint : bigint -> t
val is_real : t -> bool

A proper real, not nan/infinity

val is_int : t -> bool

Is this a proper integer?

val as_int : t -> bigint option

Convert to an integer if it's one, return None otherwise

val floor : t -> bigint

Integer equal or below

val ceil : t -> bigint

Integer equal or above

val pp_approx : int -> Stdlib.Format.formatter -> t -> unit

Pretty print rational with given amount of precision (for example as a floating point number)

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/LRA_solver/A/Z/index.html b/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/LRA_solver/A/Z/index.html deleted file mode 100644 index b6f5cb02..00000000 --- a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/LRA_solver/A/Z/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Z (sidekick.Sidekick_arith_lia.Make.1-A.LRA_solver.A.Z)

Module A.Z

include Sidekick_arith.NUM
type t
val zero : t
val one : t
val minus_one : t
val abs : t -> t
val sign : t -> int
val of_int : int -> t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val pp : t CCFormat.printer
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
val succ : t -> t
val pred : t -> t
val gcd : t -> t -> t
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/LRA_solver/A/index.html b/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/LRA_solver/A/index.html deleted file mode 100644 index f7c51918..00000000 --- a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/LRA_solver/A/index.html +++ /dev/null @@ -1,5 +0,0 @@ - -A (sidekick.Sidekick_arith_lia.Make.1-A.LRA_solver.A)

Module LRA_solver.A

module S = S
module Q : Sidekick_arith_lra.RATIONAL with type bigint = Z.t with type t = Q.t
type term = S.T.Term.t
type ty = S.T.Ty.t
val view_as_lra : term -> ( Q.t, term ) Sidekick_arith_lra.lra_view

Project the term into the theory view

val mk_bool : S.T.Term.store -> bool -> term

Make a term from the given theory view

val ty_lra : S.T.Term.store -> ty
val mk_eq : S.T.Term.store -> term -> term -> term

syntactic equality

val has_ty_real : term -> bool

Does this term have the type Real

val lemma_lra : S.Lit.t Iter.t -> S.P.proof_rule
module Gensym : sig ... end
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/LRA_solver/SimpSolver/Constraint/index.html b/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/LRA_solver/SimpSolver/Constraint/index.html deleted file mode 100644 index ee7f2c2f..00000000 --- a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/LRA_solver/SimpSolver/Constraint/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Constraint (sidekick.Sidekick_arith_lia.Make.1-A.LRA_solver.SimpSolver.Constraint)

Module SimpSolver.Constraint

type t = {
op : op;
lhs : V.t;
rhs : num;
}

A constraint is the comparison of a variable to a constant.

val mk : V.t -> op -> num -> t
val leq : V.t -> num -> t
val lt : V.t -> num -> t
val geq : V.t -> num -> t
val gt : V.t -> num -> t
val pp : t Sidekick_util.Fmt.printer
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/LRA_solver/SimpSolver/Q/index.html b/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/LRA_solver/SimpSolver/Q/index.html deleted file mode 100644 index 3fd92f4a..00000000 --- a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/LRA_solver/SimpSolver/Q/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Q (sidekick.Sidekick_arith_lia.Make.1-A.LRA_solver.SimpSolver.Q)

Module SimpSolver.Q

include Sidekick_arith.NUM
type t
val zero : t
val one : t
val minus_one : t
val abs : t -> t
val sign : t -> int
val of_int : int -> t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val pp : t CCFormat.printer
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
type bigint = Z.t
val (/) : t -> t -> t
val num : t -> bigint
val denum : t -> bigint
val infinity : t

+infinity

val minus_infinity : t
val of_bigint : bigint -> t
val is_real : t -> bool

A proper real, not nan/infinity

val is_int : t -> bool

Is this a proper integer?

val as_int : t -> bigint option

Convert to an integer if it's one, return None otherwise

val floor : t -> bigint

Integer equal or below

val ceil : t -> bigint

Integer equal or above

val pp_approx : int -> Stdlib.Format.formatter -> t -> unit

Pretty print rational with given amount of precision (for example as a floating point number)

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/LRA_solver/SimpSolver/Subst/index.html b/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/LRA_solver/SimpSolver/Subst/index.html deleted file mode 100644 index fb9880b0..00000000 --- a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/LRA_solver/SimpSolver/Subst/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Subst (sidekick.Sidekick_arith_lia.Make.1-A.LRA_solver.SimpSolver.Subst)

Module SimpSolver.Subst

type t = num V_map.t
val eval : t -> V.t -> Q.t option
val to_iter : t -> (V.t * Q.t) Iter.t
val pp : t Sidekick_util.Fmt.printer
val to_string : t -> string
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/LRA_solver/SimpSolver/Unsat_cert/index.html b/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/LRA_solver/SimpSolver/Unsat_cert/index.html deleted file mode 100644 index 77e1ff9f..00000000 --- a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/LRA_solver/SimpSolver/Unsat_cert/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Unsat_cert (sidekick.Sidekick_arith_lia.Make.1-A.LRA_solver.SimpSolver.Unsat_cert)

Module SimpSolver.Unsat_cert

type t = unsat_cert
val lits : t -> V.lit list
val pp : t Sidekick_util.Fmt.printer
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/LRA_solver/SimpSolver/V/index.html b/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/LRA_solver/SimpSolver/V/index.html deleted file mode 100644 index 571d7c57..00000000 --- a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/LRA_solver/SimpSolver/V/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -V (sidekick.Sidekick_arith_lia.Make.1-A.LRA_solver.SimpSolver.V)

Module SimpSolver.V

type t

Variable type.

val compare : t -> t -> int

Standard comparison function on variables.

val pp : t Sidekick_util.Fmt.printer

Printer for variables.

type lit
val pp_lit : lit Sidekick_util.Fmt.printer
val not_lit : lit -> lit option
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/LRA_solver/SimpSolver/Z/index.html b/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/LRA_solver/SimpSolver/Z/index.html deleted file mode 100644 index 17640f1e..00000000 --- a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/LRA_solver/SimpSolver/Z/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Z (sidekick.Sidekick_arith_lia.Make.1-A.LRA_solver.SimpSolver.Z)

Module SimpSolver.Z

include Sidekick_arith.NUM
type t
val zero : t
val one : t
val minus_one : t
val abs : t -> t
val sign : t -> int
val of_int : int -> t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val pp : t CCFormat.printer
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
val succ : t -> t
val pred : t -> t
val gcd : t -> t -> t
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/LRA_solver/SimpSolver/index.html b/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/LRA_solver/SimpSolver/index.html deleted file mode 100644 index 34096e4e..00000000 --- a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/LRA_solver/SimpSolver/index.html +++ /dev/null @@ -1,16 +0,0 @@ - -SimpSolver (sidekick.Sidekick_arith_lia.Make.1-A.LRA_solver.SimpSolver)

Module LRA_solver.SimpSolver

Simplexe

module V_map : CCMap.S with type key = V.t
module Q : Sidekick_simplex.RATIONAL with type bigint = Z.t
type num = Q.t

Numbers

module Constraint : sig ... end
module Subst : sig ... end
type t
val create : ?stat:Sidekick_util.Stat.t -> unit -> t

Create a new simplex.

val push_level : t -> unit
val pop_levels : t -> int -> unit
val define : ?is_int:bool -> t -> V.t -> (num * V.t) list -> unit

Define a basic variable in terms of other variables. This is useful to "name" a linear expression and get back a variable that can be used in a Constraint.t

type unsat_cert
module Unsat_cert : sig ... end
exception E_unsat of Unsat_cert.t
type ev_on_propagate = V.lit -> reason:V.lit list -> unit
val add_var : ?is_int:bool -> t -> V.t -> unit

Make sure the variable exists in the simplex.

val add_constraint : - ?keep_on_backtracking:bool -> - ?is_int:bool -> - on_propagate:ev_on_propagate -> - t -> - Constraint.t -> - V.lit -> - unit

Add a constraint to the simplex.

This is removed upon backtracking by default.

  • parameter is_int

    declares whether the constraint's variable is an integer

  • raises Unsat

    if it's immediately obvious that this is not satisfiable.

  • parameter keep_on_backtracking

    if true (default false), the bound is not backtrackable

val declare_bound : ?is_int:bool -> t -> Constraint.t -> V.lit -> unit

Declare that this constraint exists and map it to a literal, so we can possibly propagate it later. Unlike add_constraint this does NOT assert that the constraint is true

val check_exn : - on_propagate:( V.lit -> reason:V.lit list -> unit ) -> - t -> - unit

Check the whole simplex for satisfiability.

  • parameter on_propagate

    is called with arguments lit, reason whenever reason => lit is found to be true by the simplex.

  • raises Unsat

    if the constraints are not satisfiable.

type result =
| Sat of Subst.t
| Unsat of Unsat_cert.t
val check : on_propagate:( V.lit -> reason:V.lit list -> unit ) -> t -> result

Call check_exn and return a model or a proof of unsat. This does NOT enforce that integer variables map to integer values.

val check_branch_and_bound : - on_propagate:( V.lit -> reason:V.lit list -> unit ) -> - max_tree_nodes:int -> - t -> - result option

Try to solve and respect the integer constraints.

val n_vars : t -> int
val n_rows : t -> int
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/LRA_solver/index.html b/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/LRA_solver/index.html deleted file mode 100644 index 13f3f8c0..00000000 --- a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/LRA_solver/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -LRA_solver (sidekick.Sidekick_arith_lia.Make.1-A.LRA_solver)

Module 1-A.LRA_solver

module A : Sidekick_arith_lra.ARG with type Q.t = Q.t with module S = S

Simplexe

type state

Key to access the state from outside, available when the theory has been setup

val theory : A.S.theory
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/Q/index.html b/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/Q/index.html deleted file mode 100644 index 9bede7fd..00000000 --- a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/Q/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Q (sidekick.Sidekick_arith_lia.Make.1-A.Q)

Module 1-A.Q

include Sidekick_arith.NUM
type t
val zero : t
val one : t
val minus_one : t
val abs : t -> t
val sign : t -> int
val of_int : int -> t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val pp : t CCFormat.printer
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
type bigint = Z.t
val (/) : t -> t -> t
val num : t -> bigint
val denum : t -> bigint
val infinity : t

+infinity

val minus_infinity : t
val of_bigint : bigint -> t
val is_real : t -> bool

A proper real, not nan/infinity

val is_int : t -> bool

Is this a proper integer?

val as_int : t -> bigint option

Convert to an integer if it's one, return None otherwise

val floor : t -> bigint

Integer equal or below

val ceil : t -> bigint

Integer equal or above

val pp_approx : int -> Stdlib.Format.formatter -> t -> unit

Pretty print rational with given amount of precision (for example as a floating point number)

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/Lit/index.html b/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/Lit/index.html deleted file mode 100644 index c78df551..00000000 --- a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/Lit/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Lit (sidekick.Sidekick_arith_lia.Make.1-A.S.Lit)

Module S.Lit

module T = T

Literals depend on terms

type t

A literal

val term : t -> T.Term.t

Get the (positive) term

val sign : t -> bool

Get the sign. A negated literal has sign false.

val neg : t -> t

Take negation of literal. sign (neg lit) = not (sign lit).

val abs : t -> t

abs lit is like lit but always positive, i.e. sign (abs lit) = true

val signed_term : t -> T.Term.t * bool

Return the atom and the sign

val atom : ?sign:bool -> T.Term.store -> T.Term.t -> t

atom store t makes a literal out of a term, possibly normalizing its sign in the process.

  • parameter sign

    if provided, and sign=false, negate the resulting lit.

val norm_sign : t -> t * bool

norm_sign (+t) is +t, true, and norm_sign (-t) is +t, false. In both cases the term is positive, and the boolean reflects the initial sign.

val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/Model/index.html b/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/Model/index.html deleted file mode 100644 index e5f431cb..00000000 --- a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/Model/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Model (sidekick.Sidekick_arith_lia.Make.1-A.S.Model)

Module S.Model

Models

A model can be produced when the solver is found to be in a satisfiable state after a call to solve.

type t
val empty : t
val mem : t -> term -> bool
val find : t -> term -> term option
val eval : t -> term -> term option
val pp : t Sidekick_core.Fmt.printer
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/P/Step_vec/index.html b/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/P/Step_vec/index.html deleted file mode 100644 index 94050bd2..00000000 --- a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/P/Step_vec/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Step_vec (sidekick.Sidekick_arith_lia.Make.1-A.S.P.Step_vec)

Module P.Step_vec

A vector of steps

include Sidekick_util.Vec_sig.BASE with type elt = proof_step
include Sidekick_util.Vec_sig.BASE_RO with type elt = proof_step
type elt = proof_step
type t
val size : t -> int
val get : t -> int -> elt
val iter : f:( elt -> unit ) -> t -> unit
val iteri : f:( int -> elt -> unit ) -> t -> unit
val create : ?cap:int -> unit -> t
val clear : t -> unit
val copy : t -> t
val is_empty : t -> bool
val push : t -> elt -> unit
val fast_remove : t -> int -> unit

Remove element at index i without preserving order (swap with last element)

val filter_in_place : ( elt -> bool ) -> t -> unit
val ensure_size : t -> int -> unit
val pop : t -> elt
val set : t -> int -> elt -> unit
val shrink : t -> int -> unit
include Sidekick_util.Vec_sig.EXTENSIONS with type t := t and type elt := elt
val to_iter : t -> elt Iter.t
val to_array : t -> elt array
val fold_left : ( 'a -> elt -> 'a ) -> 'a -> t -> 'a
val pp : elt CCFormat.printer -> t CCFormat.printer
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/P/index.html b/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/P/index.html deleted file mode 100644 index 5acbe804..00000000 --- a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/P/index.html +++ /dev/null @@ -1,10 +0,0 @@ - -P (sidekick.Sidekick_arith_lia.Make.1-A.S.P)

Module S.P

type t = proof

The abstract representation of a proof. A proof always proves a clause to be valid (true in every possible interpretation of the problem's assertions, and the theories)

type proof_step = proof_step

Identifier for a proof proof_rule (like a unique ID for a clause previously added/proved)

type term = T.Term.t
type lit = Lit.t
type proof_rule = t -> proof_step
include Sidekick_core.SAT_PROOF - with type t := t - and type lit := lit - and type proof_step := proof_step - and type proof_rule := proof_rule

A vector of steps

val enabled : t -> bool

Returns true if proof production is enabled

val emit_input_clause : lit Iter.t -> proof_rule

Emit an input clause.

val emit_redundant_clause : lit Iter.t -> hyps:proof_step Iter.t -> proof_rule

Emit a clause deduced by the SAT solver, redundant wrt previous clauses. The clause must be RUP wrt hyps.

val emit_unsat_core : lit Iter.t -> proof_rule

Produce a proof of the empty clause given this subset of the assumptions. FIXME: probably needs the list of proof_step that disprove the lits?

val emit_unsat : proof_step -> t -> unit

Signal "unsat" result at the given proof

val del_clause : proof_step -> lit Iter.t -> t -> unit

Forget a clause. Only useful for performance considerations.

val lemma_cc : lit Iter.t -> proof_rule

lemma_cc proof lits asserts that lits form a tautology for the theory of uninterpreted functions.

val define_term : term -> term -> proof_rule

define_term cst u proof defines the new constant cst as being equal to u. The result is a proof of the clause cst = u

val proof_p1 : proof_step -> proof_step -> proof_rule

proof_p1 p1 p2, where p1 proves the unit clause t=u (t:bool) and p2 proves C \/ t, is the rule that produces C \/ u, i.e unit paramodulation.

val proof_r1 : proof_step -> proof_step -> proof_rule

proof_r1 p1 p2, where p1 proves the unit clause |- t (t:bool) and p2 proves C \/ ¬t, is the rule that produces C \/ u, i.e unit resolution.

val proof_res : pivot:term -> proof_step -> proof_step -> proof_rule

proof_res ~pivot p1 p2, where p1 proves the clause |- C \/ l and p2 proves D \/ ¬l, where l is either pivot or ¬pivot, is the rule that produces C \/ D, i.e boolean resolution.

val with_defs : proof_step -> proof_step Iter.t -> proof_rule

with_defs pr defs specifies that pr is valid only in a context where the definitions defs are present.

val lemma_true : term -> proof_rule

lemma_true (true) p asserts the clause (true)

val lemma_preprocess : term -> term -> using:proof_step Iter.t -> proof_rule

lemma_preprocess t u ~using p asserts that t = u is a tautology and that t has been preprocessed into u.

The theorem /\_{eqn in using} eqn |- t=u is proved using congruence closure, and then resolved against the clauses using to obtain a unit equality.

From now on, t and u will be used interchangeably.

  • returns

    a proof_rule ID for the clause (t=u).

val lemma_rw_clause : - proof_step -> - res:lit Iter.t -> - using:proof_step Iter.t -> - proof_rule

lemma_rw_clause prc ~res ~using, where prc is the proof of |- c, uses the equations |- p_i = q_i from using to rewrite some literals of c into res. This is used to preprocess literals of a clause (using lemma_preprocess individually).

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/Registry/index.html b/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/Registry/index.html deleted file mode 100644 index ee528a4e..00000000 --- a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/Registry/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Registry (sidekick.Sidekick_arith_lia.Make.1-A.S.Registry)

Module S.Registry

type t
type 'a key
val create_key : unit -> 'a key

Call this statically, typically at program initialization, for each distinct key.

val create : unit -> t
val get : t -> 'a key -> 'a option
val set : t -> 'a key -> 'a -> unit
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/Solver_internal/CC/Actions/P/Step_vec/index.html b/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/Solver_internal/CC/Actions/P/Step_vec/index.html deleted file mode 100644 index fe9945a9..00000000 --- a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/Solver_internal/CC/Actions/P/Step_vec/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Step_vec (sidekick.Sidekick_arith_lia.Make.1-A.S.Solver_internal.CC.Actions.P.Step_vec)

Module P.Step_vec

A vector of steps

include Sidekick_util.Vec_sig.BASE with type elt = proof_step
include Sidekick_util.Vec_sig.BASE_RO with type elt = proof_step
type elt = proof_step
type t
val size : t -> int
val get : t -> int -> elt
val iter : f:( elt -> unit ) -> t -> unit
val iteri : f:( int -> elt -> unit ) -> t -> unit
val create : ?cap:int -> unit -> t
val clear : t -> unit
val copy : t -> t
val is_empty : t -> bool
val push : t -> elt -> unit
val fast_remove : t -> int -> unit

Remove element at index i without preserving order (swap with last element)

val filter_in_place : ( elt -> bool ) -> t -> unit
val ensure_size : t -> int -> unit
val pop : t -> elt
val set : t -> int -> elt -> unit
val shrink : t -> int -> unit
include Sidekick_util.Vec_sig.EXTENSIONS with type t := t and type elt := elt
val to_iter : t -> elt Iter.t
val to_array : t -> elt array
val fold_left : ( 'a -> elt -> 'a ) -> 'a -> t -> 'a
val pp : elt CCFormat.printer -> t CCFormat.printer
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/Solver_internal/CC/Actions/P/index.html b/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/Solver_internal/CC/Actions/P/index.html deleted file mode 100644 index 5b69903c..00000000 --- a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/Solver_internal/CC/Actions/P/index.html +++ /dev/null @@ -1,10 +0,0 @@ - -P (sidekick.Sidekick_arith_lia.Make.1-A.S.Solver_internal.CC.Actions.P)

Module Actions.P

type t = proof

The abstract representation of a proof. A proof always proves a clause to be valid (true in every possible interpretation of the problem's assertions, and the theories)

type proof_step = proof_step

Identifier for a proof proof_rule (like a unique ID for a clause previously added/proved)

type term = T.Term.t
type lit = Lit.t
type proof_rule = t -> proof_step
include Sidekick_core.SAT_PROOF - with type t := t - and type lit := lit - and type proof_step := proof_step - and type proof_rule := proof_rule

A vector of steps

val enabled : t -> bool

Returns true if proof production is enabled

val emit_input_clause : lit Iter.t -> proof_rule

Emit an input clause.

val emit_redundant_clause : lit Iter.t -> hyps:proof_step Iter.t -> proof_rule

Emit a clause deduced by the SAT solver, redundant wrt previous clauses. The clause must be RUP wrt hyps.

val emit_unsat_core : lit Iter.t -> proof_rule

Produce a proof of the empty clause given this subset of the assumptions. FIXME: probably needs the list of proof_step that disprove the lits?

val emit_unsat : proof_step -> t -> unit

Signal "unsat" result at the given proof

val del_clause : proof_step -> lit Iter.t -> t -> unit

Forget a clause. Only useful for performance considerations.

val lemma_cc : lit Iter.t -> proof_rule

lemma_cc proof lits asserts that lits form a tautology for the theory of uninterpreted functions.

val define_term : term -> term -> proof_rule

define_term cst u proof defines the new constant cst as being equal to u. The result is a proof of the clause cst = u

val proof_p1 : proof_step -> proof_step -> proof_rule

proof_p1 p1 p2, where p1 proves the unit clause t=u (t:bool) and p2 proves C \/ t, is the rule that produces C \/ u, i.e unit paramodulation.

val proof_r1 : proof_step -> proof_step -> proof_rule

proof_r1 p1 p2, where p1 proves the unit clause |- t (t:bool) and p2 proves C \/ ¬t, is the rule that produces C \/ u, i.e unit resolution.

val proof_res : pivot:term -> proof_step -> proof_step -> proof_rule

proof_res ~pivot p1 p2, where p1 proves the clause |- C \/ l and p2 proves D \/ ¬l, where l is either pivot or ¬pivot, is the rule that produces C \/ D, i.e boolean resolution.

val with_defs : proof_step -> proof_step Iter.t -> proof_rule

with_defs pr defs specifies that pr is valid only in a context where the definitions defs are present.

val lemma_true : term -> proof_rule

lemma_true (true) p asserts the clause (true)

val lemma_preprocess : term -> term -> using:proof_step Iter.t -> proof_rule

lemma_preprocess t u ~using p asserts that t = u is a tautology and that t has been preprocessed into u.

The theorem /\_{eqn in using} eqn |- t=u is proved using congruence closure, and then resolved against the clauses using to obtain a unit equality.

From now on, t and u will be used interchangeably.

  • returns

    a proof_rule ID for the clause (t=u).

val lemma_rw_clause : - proof_step -> - res:lit Iter.t -> - using:proof_step Iter.t -> - proof_rule

lemma_rw_clause prc ~res ~using, where prc is the proof of |- c, uses the equations |- p_i = q_i from using to rewrite some literals of c into res. This is used to preprocess literals of a clause (using lemma_preprocess individually).

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/Solver_internal/CC/Actions/index.html b/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/Solver_internal/CC/Actions/index.html deleted file mode 100644 index 1cdac9aa..00000000 --- a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/Solver_internal/CC/Actions/index.html +++ /dev/null @@ -1,15 +0,0 @@ - -Actions (sidekick.Sidekick_arith_lia.Make.1-A.S.Solver_internal.CC.Actions)

Module CC.Actions

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

An action handle. It is used by the congruence closure to perform the actions below. How it performs the actions is not specified and is solver-specific.

val proof : t -> proof
val raise_conflict : t -> Lit.t list -> proof_step -> 'a

raise_conflict acts c pr declares that c is a tautology of the theory of congruence. This does not return (it should raise an exception).

  • parameter pr

    the proof of c being a tautology

val raise_semantic_conflict : - t -> - Lit.t list -> - (bool * T.Term.t * T.Term.t) list -> - 'a

raise_semantic_conflict acts lits same_val declares that the conjunction of all lits (literals true in current trail) and tuples {=,≠}, t_i, u_i implies false.

The {=,≠}, t_i, u_i are pairs of terms with the same value (if = / true) or distinct value (if ≠ / false)) in the current model.

This does not return. It should raise an exception.

val propagate : - t -> - Lit.t -> - reason:( unit -> Lit.t list * proof_step ) -> - unit

propagate acts lit ~reason pr declares that reason() => lit is a tautology.

  • reason() should return a list of literals that are currently true.
  • lit should be a literal of interest (see CC_S.set_as_lit).

This function might never be called, a congruence closure has the right to not propagate and only trigger conflicts.

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/Solver_internal/CC/Expl/index.html b/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/Solver_internal/CC/Expl/index.html deleted file mode 100644 index 5622b259..00000000 --- a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/Solver_internal/CC/Expl/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Expl (sidekick.Sidekick_arith_lia.Make.1-A.S.Solver_internal.CC.Expl)

Module CC.Expl

Explanations

Explanations are specialized proofs, created by the congruence closure when asked to justify why 2 terms are equal.

type t
val pp : t Sidekick_core.Fmt.printer
val mk_merge : N.t -> N.t -> t

Explanation: the nodes were explicitly merged

val mk_merge_t : term -> term -> t

Explanation: the terms were explicitly merged

val mk_lit : lit -> t

Explanation: we merged t and u because of literal t=u, or we merged t and true because of literal t, or t and false because of literal ¬t

val mk_same_value : N.t -> N.t -> t
val mk_list : t list -> t

Conjunction of explanations

val mk_theory : term -> term -> (term * term * t list) list -> proof_step -> t

mk_theory t u expl_sets pr builds a theory explanation for why |- t=u. It depends on sub-explanations expl_sets which are tuples (t_i, u_i, expls_i) where expls_i are explanations that justify t_i = u_i in the current congruence closure.

The proof pr is the theory lemma, of the form (t_i = u_i)_i |- t=u . It is resolved against each expls_i |- t_i=u_i obtained from expl_sets, on pivot t_i=u_i, to obtain a proof of Gamma |- t=u where Gamma is a subset of the literals asserted into the congruence closure.

For example for the lemma a=b deduced by injectivity from Some a=Some b in the theory of datatypes, the arguments would be a, b, [Some a, Some b, mk_merge_t (Some a)(Some b)], pr where pr is the injectivity lemma Some a=Some b |- a=b.

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/Solver_internal/CC/N/index.html b/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/Solver_internal/CC/N/index.html deleted file mode 100644 index b02107b0..00000000 --- a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/Solver_internal/CC/N/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -N (sidekick.Sidekick_arith_lia.Make.1-A.S.Solver_internal.CC.N)

Module CC.N

Equivalence classes.

An equivalence class is a set of terms that are currently equal in the partial model built by the solver. The class is represented by a collection of nodes, one of which is distinguished and is called the "representative".

All information pertaining to the whole equivalence class is stored in this representative's node.

When two classes become equal (are "merged"), one of the two representatives is picked as the representative of the new class. The new class contains the union of the two old classes' nodes.

We also allow theories to store additional information in the representative. This information can be used when two classes are merged, to detect conflicts and solve equations à la Shostak.

type t

An equivalent class, containing terms that are proved to be equal.

A value of type t points to a particular term, but see find to get the representative of the class.

val term : t -> term

Term contained in this equivalence class. If is_root n, then term n is the class' representative term.

val equal : t -> t -> bool

Are two classes physically equal? To check for logical equality, use CC.N.equal (CC.find cc n1) (CC.find cc n2) which checks for equality of representatives.

val hash : t -> int

An opaque hash of this node.

val pp : t Sidekick_core.Fmt.printer

Unspecified printing of the node, for example its term, a unique ID, etc.

val is_root : t -> bool

Is the node a root (ie the representative of its class)? See find to get the root.

val iter_class : t -> t Iter.t

Traverse the congruence class. Precondition: is_root n (see find below)

val iter_parents : t -> t Iter.t

Traverse the parents of the class. Precondition: is_root n (see find below)

type bitfield

A field in the bitfield of this node. This should only be allocated when a theory is initialized.

Bitfields are accessed using preallocated keys. See CC_S.allocate_bitfield.

All fields are initially 0, are backtracked automatically, and are merged automatically when classes are merged.

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/Solver_internal/CC/P/Step_vec/index.html b/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/Solver_internal/CC/P/Step_vec/index.html deleted file mode 100644 index 954f6ea7..00000000 --- a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/Solver_internal/CC/P/Step_vec/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Step_vec (sidekick.Sidekick_arith_lia.Make.1-A.S.Solver_internal.CC.P.Step_vec)

Module P.Step_vec

A vector of steps

include Sidekick_util.Vec_sig.BASE with type elt = proof_step
include Sidekick_util.Vec_sig.BASE_RO with type elt = proof_step
type elt = proof_step
type t
val size : t -> int
val get : t -> int -> elt
val iter : f:( elt -> unit ) -> t -> unit
val iteri : f:( int -> elt -> unit ) -> t -> unit
val create : ?cap:int -> unit -> t
val clear : t -> unit
val copy : t -> t
val is_empty : t -> bool
val push : t -> elt -> unit
val fast_remove : t -> int -> unit

Remove element at index i without preserving order (swap with last element)

val filter_in_place : ( elt -> bool ) -> t -> unit
val ensure_size : t -> int -> unit
val pop : t -> elt
val set : t -> int -> elt -> unit
val shrink : t -> int -> unit
include Sidekick_util.Vec_sig.EXTENSIONS with type t := t and type elt := elt
val to_iter : t -> elt Iter.t
val to_array : t -> elt array
val fold_left : ( 'a -> elt -> 'a ) -> 'a -> t -> 'a
val pp : elt CCFormat.printer -> t CCFormat.printer
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/Solver_internal/CC/P/index.html b/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/Solver_internal/CC/P/index.html deleted file mode 100644 index 1ac0e9f7..00000000 --- a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/Solver_internal/CC/P/index.html +++ /dev/null @@ -1,10 +0,0 @@ - -P (sidekick.Sidekick_arith_lia.Make.1-A.S.Solver_internal.CC.P)

Module CC.P

type t = proof

The abstract representation of a proof. A proof always proves a clause to be valid (true in every possible interpretation of the problem's assertions, and the theories)

type proof_step = proof_step

Identifier for a proof proof_rule (like a unique ID for a clause previously added/proved)

type term
type lit = lit
type proof_rule = t -> proof_step
include Sidekick_core.SAT_PROOF - with type t := t - and type lit := lit - and type proof_step := proof_step - and type proof_rule := proof_rule

A vector of steps

val enabled : t -> bool

Returns true if proof production is enabled

val emit_input_clause : lit Iter.t -> proof_rule

Emit an input clause.

val emit_redundant_clause : lit Iter.t -> hyps:proof_step Iter.t -> proof_rule

Emit a clause deduced by the SAT solver, redundant wrt previous clauses. The clause must be RUP wrt hyps.

val emit_unsat_core : lit Iter.t -> proof_rule

Produce a proof of the empty clause given this subset of the assumptions. FIXME: probably needs the list of proof_step that disprove the lits?

val emit_unsat : proof_step -> t -> unit

Signal "unsat" result at the given proof

val del_clause : proof_step -> lit Iter.t -> t -> unit

Forget a clause. Only useful for performance considerations.

val lemma_cc : lit Iter.t -> proof_rule

lemma_cc proof lits asserts that lits form a tautology for the theory of uninterpreted functions.

val define_term : term -> term -> proof_rule

define_term cst u proof defines the new constant cst as being equal to u. The result is a proof of the clause cst = u

val proof_p1 : proof_step -> proof_step -> proof_rule

proof_p1 p1 p2, where p1 proves the unit clause t=u (t:bool) and p2 proves C \/ t, is the rule that produces C \/ u, i.e unit paramodulation.

val proof_r1 : proof_step -> proof_step -> proof_rule

proof_r1 p1 p2, where p1 proves the unit clause |- t (t:bool) and p2 proves C \/ ¬t, is the rule that produces C \/ u, i.e unit resolution.

val proof_res : pivot:term -> proof_step -> proof_step -> proof_rule

proof_res ~pivot p1 p2, where p1 proves the clause |- C \/ l and p2 proves D \/ ¬l, where l is either pivot or ¬pivot, is the rule that produces C \/ D, i.e boolean resolution.

val with_defs : proof_step -> proof_step Iter.t -> proof_rule

with_defs pr defs specifies that pr is valid only in a context where the definitions defs are present.

val lemma_true : term -> proof_rule

lemma_true (true) p asserts the clause (true)

val lemma_preprocess : term -> term -> using:proof_step Iter.t -> proof_rule

lemma_preprocess t u ~using p asserts that t = u is a tautology and that t has been preprocessed into u.

The theorem /\_{eqn in using} eqn |- t=u is proved using congruence closure, and then resolved against the clauses using to obtain a unit equality.

From now on, t and u will be used interchangeably.

  • returns

    a proof_rule ID for the clause (t=u).

val lemma_rw_clause : - proof_step -> - res:lit Iter.t -> - using:proof_step Iter.t -> - proof_rule

lemma_rw_clause prc ~res ~using, where prc is the proof of |- c, uses the equations |- p_i = q_i from using to rewrite some literals of c into res. This is used to preprocess literals of a clause (using lemma_preprocess individually).

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/Solver_internal/CC/Resolved_expl/index.html b/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/Solver_internal/CC/Resolved_expl/index.html deleted file mode 100644 index 68298a0f..00000000 --- a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/Solver_internal/CC/Resolved_expl/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Resolved_expl (sidekick.Sidekick_arith_lia.Make.1-A.S.Solver_internal.CC.Resolved_expl)

Module CC.Resolved_expl

Resolved explanations.

The congruence closure keeps explanations for why terms are in the same class. However these are represented in a compact, cheap form. To use these explanations we need to resolve them into a resolved explanation, typically a list of literals that are true in the current trail and are responsible for merges.

However, we can also have merged classes because they have the same value in the current model.

type t = {
lits : lit list;
same_value : (N.t * N.t) list;
pr : proof -> proof_step;
}
val is_semantic : t -> bool

is_semantic expl is true if there's at least one pair in expl.same_value.

val pp : t Sidekick_core.Fmt.printer
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/Solver_internal/CC/index.html b/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/Solver_internal/CC/index.html deleted file mode 100644 index dcb649f7..00000000 --- a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/Solver_internal/CC/index.html +++ /dev/null @@ -1,25 +0,0 @@ - -CC (sidekick.Sidekick_arith_lia.Make.1-A.S.Solver_internal.CC)

Module Solver_internal.CC

Congruence closure instance

first, some aliases.

module T = T
module Lit = Lit
type proof = proof
type proof_step = proof_step
module P : - Sidekick_core.PROOF - with type lit = Lit.t - and type t = proof - and type proof_step = proof_step - with type t = proof - with type lit = lit
module Actions : - Sidekick_core.CC_ACTIONS - with module T = T - and module Lit = Lit - and type proof = proof - and type proof_step = proof_step - with type t = theory_actions
type term_store = T.Term.store
type term = T.Term.t
type value = term
type fun_ = T.Fun.t
type lit = Lit.t
type actions = Actions.t
type t

The congruence closure object. It contains a fair amount of state and is mutable and backtrackable.

module N : sig ... end

Equivalence classes.

module Expl : sig ... end

Explanations

module Resolved_expl : sig ... end

Resolved explanations.

type node = N.t

A node of the congruence closure

type repr = N.t

Node that is currently a representative

type explanation = Expl.t

Accessors

val term_store : t -> term_store
val proof : t -> proof
val find : t -> node -> repr

Current representative

val add_term : t -> term -> node

Add the term to the congruence closure, if not present already. Will be backtracked.

val mem_term : t -> term -> bool

Returns true if the term is explicitly present in the congruence closure

Events

Events triggered by the congruence closure, to which other plugins can subscribe.

type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit

ev_on_pre_merge cc acts n1 n2 expl is called right before n1 and n2 are merged with explanation expl.

type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit

ev_on_post_merge cc acts n1 n2 is called right after n1 and n2 were merged. find cc n1 and find cc n2 will return the same node.

type ev_on_new_term = t -> N.t -> term -> unit

ev_on_new_term cc n t is called whenever a new term t is added to the congruence closure. Its node is n.

type ev_on_conflict = t -> th:bool -> lit list -> unit

ev_on_conflict acts ~th c is called when the congruence closure triggers a conflict by asserting the tautology c.

  • parameter th

    true if the explanation for this conflict involves at least one "theory" explanation; i.e. some of the equations participating in the conflict are purely syntactic theories like injectivity of constructors.

type ev_on_propagate = t -> lit -> ( unit -> lit list * proof_step ) -> unit

ev_on_propagate cc lit reason is called whenever reason() => lit is a propagated lemma. See CC_ACTIONS.propagate.

type ev_on_is_subterm = N.t -> term -> unit

ev_on_is_subterm n t is called when n is a subterm of another node for the first time. t is the term corresponding to the node n. This can be useful for theory combination.

val create : - ?stat:Sidekick_util.Stat.t -> - ?on_pre_merge:ev_on_pre_merge list -> - ?on_post_merge:ev_on_post_merge list -> - ?on_new_term:ev_on_new_term list -> - ?on_conflict:ev_on_conflict list -> - ?on_propagate:ev_on_propagate list -> - ?on_is_subterm:ev_on_is_subterm list -> - ?size:[ `Small | `Big ] -> - term_store -> - proof -> - t

Create a new congruence closure.

  • parameter term_store

    used to be able to create new terms. All terms interacting with this congruence closure must belong in this term state as well.

val allocate_bitfield : descr:string -> t -> N.bitfield

Allocate a new node field (see N.bitfield).

This field descriptor is henceforth reserved for all nodes in this congruence closure, and can be set using set_bitfield for each node individually. This can be used to efficiently store some metadata on nodes (e.g. "is there a numeric value in the class" or "is there a constructor term in the class").

There may be restrictions on how many distinct fields are allocated for a given congruence closure (e.g. at most Sys.int_size fields).

val get_bitfield : t -> N.bitfield -> N.t -> bool

Access the bit field of the given node

val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit

Set the bitfield for the node. This will be backtracked. See N.bitfield.

val on_pre_merge : t -> ev_on_pre_merge -> unit

Add a function to be called when two classes are merged

val on_post_merge : t -> ev_on_post_merge -> unit

Add a function to be called when two classes are merged

val on_new_term : t -> ev_on_new_term -> unit

Add a function to be called when a new node is created

val on_conflict : t -> ev_on_conflict -> unit

Called when the congruence closure finds a conflict

val on_propagate : t -> ev_on_propagate -> unit

Called when the congruence closure propagates a literal

val on_is_subterm : t -> ev_on_is_subterm -> unit

Called on terms that are subterms of function symbols

val set_as_lit : t -> N.t -> lit -> unit

map the given node to a literal.

val find_t : t -> term -> repr

Current representative of the term.

  • raises Not_found

    if the term is not already add-ed.

val add_seq : t -> term Iter.t -> unit

Add a sequence of terms to the congruence closure

val all_classes : t -> repr Iter.t

All current classes. This is costly, only use if there is no other solution

val assert_lit : t -> lit -> unit

Given a literal, assume it in the congruence closure and propagate its consequences. Will be backtracked.

Useful for the theory combination or the SAT solver's functor

val assert_lits : t -> lit Iter.t -> unit

Addition of many literals

val explain_eq : t -> N.t -> N.t -> Resolved_expl.t

Explain why the two nodes are equal. Fails if they are not, in an unspecified way.

val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a

Raise a conflict with the given explanation. It must be a theory tautology that expl ==> absurd. To be used in theories.

This fails in an unspecified way if the explanation, once resolved, satisfies Resolved_expl.is_semantic.

val n_true : t -> N.t

Node for true

val n_false : t -> N.t

Node for false

val n_bool : t -> bool -> N.t

Node for either true or false

val merge : t -> N.t -> N.t -> Expl.t -> unit

Merge these two nodes given this explanation. It must be a theory tautology that expl ==> n1 = n2. To be used in theories.

val merge_t : t -> term -> term -> Expl.t -> unit

Shortcut for adding + merging

val set_model_value : t -> term -> value -> unit

Set the value of a term in the model.

val with_model_mode : t -> ( unit -> 'a ) -> 'a

Enter model combination mode.

val get_model_for_each_class : t -> (repr * N.t Iter.t * value) Iter.t

In model combination mode, obtain classes with their values.

val check : t -> actions -> unit

Perform all pending operations done via assert_eq, assert_lit, etc. Will use the actions to propagate literals, declare conflicts, etc.

val push_level : t -> unit

Push backtracking level

val pop_levels : t -> int -> unit

Restore to state n calls to push_level earlier. Used during backtracking.

val get_model : t -> N.t Iter.t Iter.t

get all the equivalence classes so they can be merged in the model

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/Solver_internal/Registry/index.html b/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/Solver_internal/Registry/index.html deleted file mode 100644 index 1550abe5..00000000 --- a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/Solver_internal/Registry/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Registry (sidekick.Sidekick_arith_lia.Make.1-A.S.Solver_internal.Registry)

Module Solver_internal.Registry

type t
type 'a key
val create_key : unit -> 'a key

Call this statically, typically at program initialization, for each distinct key.

val create : unit -> t
val get : t -> 'a key -> 'a option
val set : t -> 'a key -> 'a -> unit
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/Solver_internal/Simplify/index.html b/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/Solver_internal/Simplify/index.html deleted file mode 100644 index 6707bdbc..00000000 --- a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/Solver_internal/Simplify/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Simplify (sidekick.Sidekick_arith_lia.Make.1-A.S.Solver_internal.Simplify)

Module Solver_internal.Simplify

Simplify terms

type t
val tst : t -> term_store
val ty_st : t -> ty_store
val clear : t -> unit

Reset internal cache, etc.

val proof : t -> proof

Access proof

type hook = t -> term -> (term * proof_step Iter.t) option

Given a term, try to simplify it. Return None if it didn't change.

A simple example could be a hook that takes a term t, and if t is app "+" (const x) (const y) where x and y are number, returns Some (const (x+y)), and None otherwise.

The simplifier will take care of simplifying the resulting term further, caching (so that work is not duplicated in subterms), etc.

val normalize : t -> term -> (term * proof_step) option

Normalize a term using all the hooks. This performs a fixpoint, i.e. it only stops when no hook applies anywhere inside the term.

val normalize_t : t -> term -> term * proof_step option

Normalize a term using all the hooks, along with a proof that the simplification is correct. returns t, ø if no simplification occurred.

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/Solver_internal/index.html b/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/Solver_internal/index.html deleted file mode 100644 index 904b61cb..00000000 --- a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/Solver_internal/index.html +++ /dev/null @@ -1,43 +0,0 @@ - -Solver_internal (sidekick.Sidekick_arith_lia.Make.1-A.S.Solver_internal)

Module S.Solver_internal

Internal solver, available to theories.

module T = T
module Lit = Lit
type ty = T.Ty.t
type term = T.Term.t
type value = T.Term.t
type term_store = T.Term.store
type ty_store = T.Ty.store
type clause_pool
type proof = proof
type proof_step = proof_step
module P = P
type t

Main type for a solver

type solver = t
val tst : t -> term_store
val ty_st : t -> ty_store
val stats : t -> Sidekick_util.Stat.t
val proof : t -> proof

Access the proof object

Registry

val registry : t -> Registry.t

A solver contains a registry so that theories can share data

Actions for the theories

type theory_actions

Handle that the theories can use to perform actions.

type lit = Lit.t

Congruence Closure

module CC : - Sidekick_core.CC_S - with module T = T - and module Lit = Lit - and type proof = proof - and type proof_step = proof_step - and type P.t = proof - and type P.lit = lit - and type Actions.t = theory_actions

Congruence closure instance

val cc : t -> CC.t

Congruence closure for this solver

Simplifiers

module Simplify : sig ... end

Simplify terms

type simplify_hook = Simplify.hook
val add_simplifier : t -> Simplify.hook -> unit

Add a simplifier hook for preprocessing.

val simplify_t : t -> term -> (term * proof_step) option

Simplify input term, returns Some u if some simplification occurred.

val simp_t : t -> term -> term * proof_step option

simp_t si t returns u even if no simplification occurred (in which case t == u syntactically). It emits |- t=u. (see simplifier)

Preprocessors

These preprocessors turn mixed, raw literals (possibly simplified) into literals suitable for reasoning. Typically some clauses are also added to the solver.

module type PREPROCESS_ACTS = sig ... end
type preprocess_actions = (module PREPROCESS_ACTS)

Actions available to the preprocessor

type preprocess_hook = t -> preprocess_actions -> term -> unit

Given a term, preprocess it.

The idea is to add literals and clauses to help define the meaning of the term, if needed. For example for boolean formulas, clauses for their Tseitin encoding can be added, with the formula acting as its own proxy symbol.

  • parameter preprocess_actions

    actions available during preprocessing.

val on_preprocess : t -> preprocess_hook -> unit

Add a hook that will be called when terms are preprocessed

hooks for the theory

val raise_conflict : t -> theory_actions -> lit list -> proof_step -> 'a

Give a conflict clause to the solver

val push_decision : t -> theory_actions -> lit -> unit

Ask the SAT solver to decide the given literal in an extension of the current trail. This is useful for theory combination. If the SAT solver backtracks, this (potential) decision is removed and forgotten.

val propagate : - t -> - theory_actions -> - lit -> - reason:( unit -> lit list * proof_step ) -> - unit

Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology

val propagate_l : t -> theory_actions -> lit -> lit list -> proof_step -> unit

Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology

val add_clause_temp : t -> theory_actions -> lit list -> proof_step -> unit

Add local clause to the SAT solver. This clause will be removed when the solver backtracks.

val add_clause_permanent : - t -> - theory_actions -> - lit list -> - proof_step -> - unit

Add toplevel clause to the SAT solver. This clause will not be backtracked.

val mk_lit : t -> theory_actions -> ?sign:bool -> term -> lit

Create a literal. This automatically preprocesses the term.

val add_lit : t -> theory_actions -> ?default_pol:bool -> lit -> unit

Add the given literal to the SAT solver, so it gets assigned a boolean value.

  • parameter default_pol

    default polarity for the corresponding atom

val add_lit_t : t -> theory_actions -> ?sign:bool -> term -> unit

Add the given (signed) bool term to the SAT solver, so it gets assigned a boolean value

val cc_raise_conflict_expl : t -> theory_actions -> CC.Expl.t -> 'a

Raise a conflict with the given congruence closure explanation. it must be a theory tautology that expl ==> absurd. To be used in theories.

val cc_find : t -> CC.N.t -> CC.N.t

Find representative of the node

val cc_are_equal : t -> term -> term -> bool

Are these two terms equal in the congruence closure?

val cc_merge : t -> theory_actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit

Merge these two nodes in the congruence closure, given this explanation. It must be a theory tautology that expl ==> n1 = n2. To be used in theories.

val cc_merge_t : t -> theory_actions -> term -> term -> CC.Expl.t -> unit

Merge these two terms in the congruence closure, given this explanation. See cc_merge

val cc_add_term : t -> term -> CC.N.t

Add/retrieve congruence closure node for this term. To be used in theories

val cc_mem_term : t -> term -> bool

Return true if the term is explicitly in the congruence closure. To be used in theories

val on_cc_pre_merge : - t -> - ( CC.t -> theory_actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit ) -> - unit

Callback for when two classes containing data for this key are merged (called before)

val on_cc_post_merge : - t -> - ( CC.t -> theory_actions -> CC.N.t -> CC.N.t -> unit ) -> - unit

Callback for when two classes containing data for this key are merged (called after)

val on_cc_new_term : t -> ( CC.t -> CC.N.t -> term -> unit ) -> unit

Callback to add data on terms when they are added to the congruence closure

val on_cc_is_subterm : t -> ( CC.N.t -> term -> unit ) -> unit

Callback for when a term is a subterm of another term in the congruence closure

val on_cc_conflict : t -> ( CC.t -> th:bool -> lit list -> unit ) -> unit

Callback called on every CC conflict

val on_cc_propagate : - t -> - ( CC.t -> lit -> ( unit -> lit list * proof_step ) -> unit ) -> - unit

Callback called on every CC propagation

val on_partial_check : - t -> - ( t -> theory_actions -> lit Iter.t -> unit ) -> - unit

Register callbacked to be called with the slice of literals newly added on the trail.

This is called very often and should be efficient. It doesn't have to be complete, only correct. It's given only the slice of the trail consisting in new literals.

val on_final_check : t -> ( t -> theory_actions -> lit Iter.t -> unit ) -> unit

Register callback to be called during the final check.

Must be complete (i.e. must raise a conflict if the set of literals is not satisfiable) and can be expensive. The function is given the whole trail.

val on_th_combination : - t -> - ( t -> theory_actions -> (term * value) Iter.t ) -> - unit

Add a hook called during theory combination. The hook must return an iterator of pairs (t, v) which mean that term t has value v in the model.

Terms with the same value (according to Term.equal) will be merged in the CC; if two terms with different values are merged, we get a semantic conflict and must pick another model.

val declare_pb_is_incomplete : t -> unit

Declare that, in some theory, the problem is outside the logic fragment that is decidable (e.g. if we meet proper NIA formulas). The solver will not reply "SAT" from now on.

Model production

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

A model-production hook to query values from a theory.

It takes the solver, a class, and returns a term for this class. For example, an arithmetic theory might detect that a class contains a numeric constant, and return this constant as a model value.

If no hook assigns a value to a class, a fake value is created for it.

type model_completion_hook = t -> add:( term -> term -> unit ) -> unit

A model production hook, for the theory to add values. The hook is given a add function to add bindings to the model.

val on_model : - ?ask:model_ask_hook -> - ?complete:model_completion_hook -> - t -> - unit

Add model production/completion hooks.

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/Solver_internal/module-type-PREPROCESS_ACTS/index.html b/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/Solver_internal/module-type-PREPROCESS_ACTS/index.html deleted file mode 100644 index 3b442f06..00000000 --- a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/Solver_internal/module-type-PREPROCESS_ACTS/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -PREPROCESS_ACTS (sidekick.Sidekick_arith_lia.Make.1-A.S.Solver_internal.PREPROCESS_ACTS)

Module type Solver_internal.PREPROCESS_ACTS

val proof : proof
val mk_lit : ?sign:bool -> term -> lit

mk_lit t creates a new literal for a boolean term t.

val add_clause : lit list -> proof_step -> unit

pushes a new clause into the SAT solver.

val add_lit : ?default_pol:bool -> lit -> unit

Ensure the literal will be decided/handled by the SAT solver.

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/T/Fun/index.html b/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/T/Fun/index.html deleted file mode 100644 index fd073028..00000000 --- a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/T/Fun/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Fun (sidekick.Sidekick_arith_lia.Make.1-A.S.T.Fun)

Module T.Fun

A function symbol, like "f" or "plus" or "is_human" or "socrates"

type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/T/Term/index.html b/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/T/Term/index.html deleted file mode 100644 index d13968eb..00000000 --- a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/T/Term/index.html +++ /dev/null @@ -1,8 +0,0 @@ - -Term (sidekick.Sidekick_arith_lia.Make.1-A.S.T.Term)

Module T.Term

Term structure.

Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.

type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store

A store used to create new terms. It is where the hashconsing table should live, along with other all-terms related store.

val ty : t -> Ty.t
val bool : store -> bool -> t

build true/false

val as_bool : t -> bool option

as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.

val abs : store -> t -> t * bool

abs t returns an "absolute value" for the term, along with the sign of t.

The idea is that we want to turn not a into (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).

The store is passed in case a new term needs to be created.

val map_shallow : store -> ( t -> t ) -> t -> t

Map function on immediate subterms. This should not be recursive.

val iter_shallow : store -> ( t -> unit ) -> t -> unit

Iterate function on immediate subterms. This should not be recursive.

val iter_dag : t -> ( t -> unit ) -> unit

iter_dag t f calls f once on each subterm of t, t included. It must not traverse t as a tree, but rather as a perfectly shared DAG.

For example, in:

let x = 2 in
-let y = f x x in
-let z = g y x in
-z = z

the DAG has the following nodes:

n1: 2
-n2: f n1 n1
-n3: g n2 n1
-n4: = n3 n3
module Tbl : CCHashtbl.S with type key = t
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/T/Ty/index.html b/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/T/Ty/index.html deleted file mode 100644 index 5cde388d..00000000 --- a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/T/Ty/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Ty (sidekick.Sidekick_arith_lia.Make.1-A.S.T.Ty)

Module T.Ty

Types

Types should be comparable (ideally, in O(1)), and have at least a boolean type available.

type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store
val bool : store -> t
val is_bool : t -> bool
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/T/index.html b/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/T/index.html deleted file mode 100644 index 53794bbf..00000000 --- a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/T/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -T (sidekick.Sidekick_arith_lia.Make.1-A.S.T)

Module S.T

module Fun : sig ... end

A function symbol, like "f" or "plus" or "is_human" or "socrates"

module Ty : sig ... end

Types

module Term : sig ... end

Term structure.

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/Unknown/index.html b/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/Unknown/index.html deleted file mode 100644 index adc95a82..00000000 --- a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/Unknown/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Unknown (sidekick.Sidekick_arith_lia.Make.1-A.S.Unknown)

Module S.Unknown

type t
val pp : t CCFormat.printer
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/index.html b/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/index.html deleted file mode 100644 index 86d698f8..00000000 --- a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/index.html +++ /dev/null @@ -1,37 +0,0 @@ - -S (sidekick.Sidekick_arith_lia.Make.1-A.S)

Module 1-A.S

module Lit : Sidekick_core.LIT with module T = T
type proof
type proof_step
module P : - Sidekick_core.PROOF - with type lit = Lit.t - and type t = proof - and type proof_step = proof_step - 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 type proof_step = proof_step - 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

Value registry

val registry : t -> Registry.t

A solver contains a registry so that theories can share data

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 proof : t -> proof
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 -> proof_step -> 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 -> proof_step -> 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;(*

Unsat core (subset of assumptions), or empty

*)
unsat_proof_step : unit -> proof_step option;(*

Proof step for the empty clause

*)
}		(*

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 ) -> - ?should_stop:( t -> int -> bool ) -> - 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 should_stop

    a callback regularly called with the solver, and with a number of "steps" done since last call. The exact notion of step is not defined, but is guaranteed to increase regularly. The function should return true if it judges solving must stop (returning Unknown), false if solving can proceed.

  • parameter on_exit

    functions to be run before this returns

val last_res : t -> res option

Last result, if any. Some operations will erase this (e.g. assert_term).

val push_assumption : t -> lit -> unit

Pushes an assumption onto the assumption stack. It will remain there until it's pop'd by pop_assumptions.

val pop_assumptions : t -> int -> unit

pop_assumptions solver n removes n assumptions from the stack. It removes the assumptions that were the most recently added via push_assumptions. Note that check_sat_propagations_only can call this if it meets a conflict.

type propagation_result =
| PR_sat
| PR_conflict of {
backtracked : int;
}
| PR_unsat of {
unsat_core : unit -> lit Iter.t;
}
val check_sat_propagations_only : - assumptions:lit list -> - t -> - propagation_result

check_sat_propagations_only solver uses assumptions (including the assumptions parameter, and atoms previously added via push_assumptions) and boolean+theory propagation to quickly assess satisfiability. It is not complete; calling solve is required to get an accurate result.

  • returns

    one of:

    • PR_sat if the current state seems satisfiable
    • PR_conflict {backtracked=n} if a conflict was found and resolved, leading to backtracking n levels of assumptions
    • PR_unsat … if the assumptions were found to be unsatisfiable, with the given core.
val pp_stats : t CCFormat.printer

Print some statistics. What it prints exactly is unspecified.

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/module-type-THEORY/index.html b/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/module-type-THEORY/index.html deleted file mode 100644 index be4e9169..00000000 --- a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/S/module-type-THEORY/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -THEORY (sidekick.Sidekick_arith_lia.Make.1-A.S.THEORY)

Module type S.THEORY

A theory

Theories are abstracted over the concrete implementation of the solver, so they can work with any implementation.

Typically a theory should be a functor taking an argument containing a SOLVER_INTERNAL or even a full SOLVER, and some additional views on terms, literals, etc. that are specific to the theory (e.g. to map terms to linear expressions). The theory can then be instantiated on any kind of solver for any term representation that also satisfies the additional theory-specific requirements. Instantiated theories (ie values of type SOLVER.theory) can be added to the solver.

type t

The theory's state

val name : string

Name of the theory (ideally, unique and short)

val create_and_setup : Solver_internal.t -> t

Instantiate the theory's state for the given (internal) solver, register callbacks, create keys, etc.

Called once for every solver this theory is added to.

val push_level : t -> unit

Push backtracking level. When the corresponding pop is called, the theory's state should be restored to a state equivalent to what it was just before push_level.

it does not have to be exactly the same state, it just needs to be equivalent.

val pop_levels : t -> int -> unit

pop_levels theory n pops n backtracking levels, restoring theory to its state before calling push_level n times.

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/Z/index.html b/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/Z/index.html deleted file mode 100644 index a5bc0274..00000000 --- a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/Z/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Z (sidekick.Sidekick_arith_lia.Make.1-A.Z)

Module 1-A.Z

include Sidekick_arith.NUM
type t
val zero : t
val one : t
val minus_one : t
val abs : t -> t
val sign : t -> int
val of_int : int -> t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val pp : t CCFormat.printer
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
val succ : t -> t
val pred : t -> t
val gcd : t -> t -> t
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/index.html b/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/index.html deleted file mode 100644 index 4667c930..00000000 --- a/dev/sidekick/Sidekick_arith_lia/Make/argument-1-A/index.html +++ /dev/null @@ -1,3 +0,0 @@ - -A (sidekick.Sidekick_arith_lia.Make.1-A)

Parameter Make.1-A

module Z : INT
module Q : RATIONAL with type bigint = Z.t
module LRA_solver : - Sidekick_arith_lra.S with type A.Q.t = Q.t and module A.S = S
type term = S.T.Term.t
type ty = S.T.Ty.t
val view_as_lia : term -> ( Z.t, Q.t, term ) lia_view

Project the term into the theory view

val mk_bool : S.T.Term.store -> bool -> term
val mk_to_real : S.T.Term.store -> term -> term

Wrap term into a to_real projector to rationals

val mk_lia : S.T.Term.store -> ( Z.t, Q.t, term ) lia_view -> term

Make a term from the given theory view

val ty_int : S.T.Term.store -> ty
val mk_eq : S.T.Term.store -> term -> term -> term

syntactic equality

val has_ty_int : term -> bool

Does this term have the type Int

val lemma_lia : S.Lit.t Iter.t -> S.P.proof_rule
val lemma_relax_to_lra : S.Lit.t Iter.t -> S.P.proof_rule
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/Make/index.html b/dev/sidekick/Sidekick_arith_lia/Make/index.html deleted file mode 100644 index f49d76dd..00000000 --- a/dev/sidekick/Sidekick_arith_lia/Make/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Make (sidekick.Sidekick_arith_lia.Make)

Module Sidekick_arith_lia.Make

Parameters

module A : ARG

Signature

module A = A
val theory : A.S.theory
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/index.html b/dev/sidekick/Sidekick_arith_lia/index.html deleted file mode 100644 index 4974676f..00000000 --- a/dev/sidekick/Sidekick_arith_lia/index.html +++ /dev/null @@ -1,5 +0,0 @@ - -Sidekick_arith_lia (sidekick.Sidekick_arith_lia)

Module Sidekick_arith_lia

Linear Rational Arithmetic

module type RATIONAL = Sidekick_arith.RATIONAL
module type INT = Sidekick_arith.INT
module S_op = Sidekick_simplex.Op
type pred = Sidekick_simplex.Predicate.t =
| Leq
| Geq
| Lt
| Gt
| Eq
| Neq
type op = Sidekick_simplex.Binary_op.t =
| Plus
| Minus
type ('num, 'real, 'a) lia_view =
| LIA_pred of pred * 'a * 'a
| LIA_op of op * 'a * 'a
| LIA_mult of 'num * 'a
| LIA_const of 'num
| LIA_other of 'a
val map_view : - ( 'a -> 'b ) -> - ( 'c, 'd, 'a ) lia_view -> - ( 'c, 'e, 'b ) lia_view
module type ARG = sig ... end
module type S = sig ... end
module Make (A : ARG) : S with module A = A
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/LRA_solver/A/Gensym/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-ARG/LRA_solver/A/Gensym/index.html deleted file mode 100644 index 4533fdeb..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/LRA_solver/A/Gensym/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Gensym (sidekick.Sidekick_arith_lia.ARG.LRA_solver.A.Gensym)

Module A.Gensym

type t
val create : S.T.Term.store -> t
val tst : t -> S.T.Term.store
val copy : t -> t
val fresh_term : t -> pre:string -> S.T.Ty.t -> term

Make a fresh term of the given type

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/LRA_solver/A/Q/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-ARG/LRA_solver/A/Q/index.html deleted file mode 100644 index 67f4fc5e..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/LRA_solver/A/Q/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Q (sidekick.Sidekick_arith_lia.ARG.LRA_solver.A.Q)

Module A.Q

include Sidekick_arith.NUM with type t = Q.t
type t = Q.t
val zero : t
val one : t
val minus_one : t
val abs : t -> t
val sign : t -> int
val of_int : int -> t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val pp : t CCFormat.printer
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
type bigint = Z.t
val (/) : t -> t -> t
val num : t -> bigint
val denum : t -> bigint
val infinity : t

+infinity

val minus_infinity : t
val of_bigint : bigint -> t
val is_real : t -> bool

A proper real, not nan/infinity

val is_int : t -> bool

Is this a proper integer?

val as_int : t -> bigint option

Convert to an integer if it's one, return None otherwise

val floor : t -> bigint

Integer equal or below

val ceil : t -> bigint

Integer equal or above

val pp_approx : int -> Stdlib.Format.formatter -> t -> unit

Pretty print rational with given amount of precision (for example as a floating point number)

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/LRA_solver/A/Z/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-ARG/LRA_solver/A/Z/index.html deleted file mode 100644 index 20cf01cb..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/LRA_solver/A/Z/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Z (sidekick.Sidekick_arith_lia.ARG.LRA_solver.A.Z)

Module A.Z

include Sidekick_arith.NUM
type t
val zero : t
val one : t
val minus_one : t
val abs : t -> t
val sign : t -> int
val of_int : int -> t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val pp : t CCFormat.printer
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
val succ : t -> t
val pred : t -> t
val gcd : t -> t -> t
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/LRA_solver/A/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-ARG/LRA_solver/A/index.html deleted file mode 100644 index a0720fe3..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/LRA_solver/A/index.html +++ /dev/null @@ -1,5 +0,0 @@ - -A (sidekick.Sidekick_arith_lia.ARG.LRA_solver.A)

Module LRA_solver.A

module S = S
module Q : Sidekick_arith_lra.RATIONAL with type bigint = Z.t with type t = Q.t
type term = S.T.Term.t
type ty = S.T.Ty.t
val view_as_lra : term -> ( Q.t, term ) Sidekick_arith_lra.lra_view

Project the term into the theory view

val mk_bool : S.T.Term.store -> bool -> term

Make a term from the given theory view

val ty_lra : S.T.Term.store -> ty
val mk_eq : S.T.Term.store -> term -> term -> term

syntactic equality

val has_ty_real : term -> bool

Does this term have the type Real

val lemma_lra : S.Lit.t Iter.t -> S.P.proof_rule
module Gensym : sig ... end
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/LRA_solver/SimpSolver/Constraint/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-ARG/LRA_solver/SimpSolver/Constraint/index.html deleted file mode 100644 index 8f473670..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/LRA_solver/SimpSolver/Constraint/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Constraint (sidekick.Sidekick_arith_lia.ARG.LRA_solver.SimpSolver.Constraint)

Module SimpSolver.Constraint

type t = {
op : op;
lhs : V.t;
rhs : num;
}

A constraint is the comparison of a variable to a constant.

val mk : V.t -> op -> num -> t
val leq : V.t -> num -> t
val lt : V.t -> num -> t
val geq : V.t -> num -> t
val gt : V.t -> num -> t
val pp : t Sidekick_util.Fmt.printer
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/LRA_solver/SimpSolver/Q/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-ARG/LRA_solver/SimpSolver/Q/index.html deleted file mode 100644 index 55e8eb18..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/LRA_solver/SimpSolver/Q/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Q (sidekick.Sidekick_arith_lia.ARG.LRA_solver.SimpSolver.Q)

Module SimpSolver.Q

include Sidekick_arith.NUM
type t
val zero : t
val one : t
val minus_one : t
val abs : t -> t
val sign : t -> int
val of_int : int -> t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val pp : t CCFormat.printer
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
type bigint = Z.t
val (/) : t -> t -> t
val num : t -> bigint
val denum : t -> bigint
val infinity : t

+infinity

val minus_infinity : t
val of_bigint : bigint -> t
val is_real : t -> bool

A proper real, not nan/infinity

val is_int : t -> bool

Is this a proper integer?

val as_int : t -> bigint option

Convert to an integer if it's one, return None otherwise

val floor : t -> bigint

Integer equal or below

val ceil : t -> bigint

Integer equal or above

val pp_approx : int -> Stdlib.Format.formatter -> t -> unit

Pretty print rational with given amount of precision (for example as a floating point number)

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/LRA_solver/SimpSolver/Subst/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-ARG/LRA_solver/SimpSolver/Subst/index.html deleted file mode 100644 index c5e3d9a3..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/LRA_solver/SimpSolver/Subst/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Subst (sidekick.Sidekick_arith_lia.ARG.LRA_solver.SimpSolver.Subst)

Module SimpSolver.Subst

type t = num V_map.t
val eval : t -> V.t -> Q.t option
val to_iter : t -> (V.t * Q.t) Iter.t
val pp : t Sidekick_util.Fmt.printer
val to_string : t -> string
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/LRA_solver/SimpSolver/Unsat_cert/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-ARG/LRA_solver/SimpSolver/Unsat_cert/index.html deleted file mode 100644 index adb47df2..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/LRA_solver/SimpSolver/Unsat_cert/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Unsat_cert (sidekick.Sidekick_arith_lia.ARG.LRA_solver.SimpSolver.Unsat_cert)

Module SimpSolver.Unsat_cert

type t = unsat_cert
val lits : t -> V.lit list
val pp : t Sidekick_util.Fmt.printer
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/LRA_solver/SimpSolver/V/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-ARG/LRA_solver/SimpSolver/V/index.html deleted file mode 100644 index d26e96f1..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/LRA_solver/SimpSolver/V/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -V (sidekick.Sidekick_arith_lia.ARG.LRA_solver.SimpSolver.V)

Module SimpSolver.V

type t

Variable type.

val compare : t -> t -> int

Standard comparison function on variables.

val pp : t Sidekick_util.Fmt.printer

Printer for variables.

type lit
val pp_lit : lit Sidekick_util.Fmt.printer
val not_lit : lit -> lit option
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/LRA_solver/SimpSolver/Z/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-ARG/LRA_solver/SimpSolver/Z/index.html deleted file mode 100644 index ce6236b9..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/LRA_solver/SimpSolver/Z/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Z (sidekick.Sidekick_arith_lia.ARG.LRA_solver.SimpSolver.Z)

Module SimpSolver.Z

include Sidekick_arith.NUM
type t
val zero : t
val one : t
val minus_one : t
val abs : t -> t
val sign : t -> int
val of_int : int -> t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val pp : t CCFormat.printer
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
val succ : t -> t
val pred : t -> t
val gcd : t -> t -> t
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/LRA_solver/SimpSolver/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-ARG/LRA_solver/SimpSolver/index.html deleted file mode 100644 index 810fd60f..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/LRA_solver/SimpSolver/index.html +++ /dev/null @@ -1,16 +0,0 @@ - -SimpSolver (sidekick.Sidekick_arith_lia.ARG.LRA_solver.SimpSolver)

Module LRA_solver.SimpSolver

Simplexe

module V_map : CCMap.S with type key = V.t
module Q : Sidekick_simplex.RATIONAL with type bigint = Z.t
type num = Q.t

Numbers

module Constraint : sig ... end
module Subst : sig ... end
type t
val create : ?stat:Sidekick_util.Stat.t -> unit -> t

Create a new simplex.

val push_level : t -> unit
val pop_levels : t -> int -> unit
val define : ?is_int:bool -> t -> V.t -> (num * V.t) list -> unit

Define a basic variable in terms of other variables. This is useful to "name" a linear expression and get back a variable that can be used in a Constraint.t

type unsat_cert
module Unsat_cert : sig ... end
exception E_unsat of Unsat_cert.t
type ev_on_propagate = V.lit -> reason:V.lit list -> unit
val add_var : ?is_int:bool -> t -> V.t -> unit

Make sure the variable exists in the simplex.

val add_constraint : - ?keep_on_backtracking:bool -> - ?is_int:bool -> - on_propagate:ev_on_propagate -> - t -> - Constraint.t -> - V.lit -> - unit

Add a constraint to the simplex.

This is removed upon backtracking by default.

  • parameter is_int

    declares whether the constraint's variable is an integer

  • raises Unsat

    if it's immediately obvious that this is not satisfiable.

  • parameter keep_on_backtracking

    if true (default false), the bound is not backtrackable

val declare_bound : ?is_int:bool -> t -> Constraint.t -> V.lit -> unit

Declare that this constraint exists and map it to a literal, so we can possibly propagate it later. Unlike add_constraint this does NOT assert that the constraint is true

val check_exn : - on_propagate:( V.lit -> reason:V.lit list -> unit ) -> - t -> - unit

Check the whole simplex for satisfiability.

  • parameter on_propagate

    is called with arguments lit, reason whenever reason => lit is found to be true by the simplex.

  • raises Unsat

    if the constraints are not satisfiable.

type result =
| Sat of Subst.t
| Unsat of Unsat_cert.t
val check : on_propagate:( V.lit -> reason:V.lit list -> unit ) -> t -> result

Call check_exn and return a model or a proof of unsat. This does NOT enforce that integer variables map to integer values.

val check_branch_and_bound : - on_propagate:( V.lit -> reason:V.lit list -> unit ) -> - max_tree_nodes:int -> - t -> - result option

Try to solve and respect the integer constraints.

val n_vars : t -> int
val n_rows : t -> int
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/LRA_solver/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-ARG/LRA_solver/index.html deleted file mode 100644 index 59dae44f..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/LRA_solver/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -LRA_solver (sidekick.Sidekick_arith_lia.ARG.LRA_solver)

Module ARG.LRA_solver

module A : Sidekick_arith_lra.ARG with type Q.t = Q.t with module S = S

Simplexe

type state

Key to access the state from outside, available when the theory has been setup

val theory : A.S.theory
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/Q/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-ARG/Q/index.html deleted file mode 100644 index 4cd14844..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/Q/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Q (sidekick.Sidekick_arith_lia.ARG.Q)

Module ARG.Q

include Sidekick_arith.NUM
type t
val zero : t
val one : t
val minus_one : t
val abs : t -> t
val sign : t -> int
val of_int : int -> t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val pp : t CCFormat.printer
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
type bigint = Z.t
val (/) : t -> t -> t
val num : t -> bigint
val denum : t -> bigint
val infinity : t

+infinity

val minus_infinity : t
val of_bigint : bigint -> t
val is_real : t -> bool

A proper real, not nan/infinity

val is_int : t -> bool

Is this a proper integer?

val as_int : t -> bigint option

Convert to an integer if it's one, return None otherwise

val floor : t -> bigint

Integer equal or below

val ceil : t -> bigint

Integer equal or above

val pp_approx : int -> Stdlib.Format.formatter -> t -> unit

Pretty print rational with given amount of precision (for example as a floating point number)

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/Lit/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/Lit/index.html deleted file mode 100644 index bbefc4c4..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/Lit/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Lit (sidekick.Sidekick_arith_lia.ARG.S.Lit)

Module S.Lit

module T = T

Literals depend on terms

type t

A literal

val term : t -> T.Term.t

Get the (positive) term

val sign : t -> bool

Get the sign. A negated literal has sign false.

val neg : t -> t

Take negation of literal. sign (neg lit) = not (sign lit).

val abs : t -> t

abs lit is like lit but always positive, i.e. sign (abs lit) = true

val signed_term : t -> T.Term.t * bool

Return the atom and the sign

val atom : ?sign:bool -> T.Term.store -> T.Term.t -> t

atom store t makes a literal out of a term, possibly normalizing its sign in the process.

  • parameter sign

    if provided, and sign=false, negate the resulting lit.

val norm_sign : t -> t * bool

norm_sign (+t) is +t, true, and norm_sign (-t) is +t, false. In both cases the term is positive, and the boolean reflects the initial sign.

val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/Model/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/Model/index.html deleted file mode 100644 index 637e2668..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/Model/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Model (sidekick.Sidekick_arith_lia.ARG.S.Model)

Module S.Model

Models

A model can be produced when the solver is found to be in a satisfiable state after a call to solve.

type t
val empty : t
val mem : t -> term -> bool
val find : t -> term -> term option
val eval : t -> term -> term option
val pp : t Sidekick_core.Fmt.printer
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/P/Step_vec/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/P/Step_vec/index.html deleted file mode 100644 index 6b508426..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/P/Step_vec/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Step_vec (sidekick.Sidekick_arith_lia.ARG.S.P.Step_vec)

Module P.Step_vec

A vector of steps

include Sidekick_util.Vec_sig.BASE with type elt = proof_step
include Sidekick_util.Vec_sig.BASE_RO with type elt = proof_step
type elt = proof_step
type t
val size : t -> int
val get : t -> int -> elt
val iter : f:( elt -> unit ) -> t -> unit
val iteri : f:( int -> elt -> unit ) -> t -> unit
val create : ?cap:int -> unit -> t
val clear : t -> unit
val copy : t -> t
val is_empty : t -> bool
val push : t -> elt -> unit
val fast_remove : t -> int -> unit

Remove element at index i without preserving order (swap with last element)

val filter_in_place : ( elt -> bool ) -> t -> unit
val ensure_size : t -> int -> unit
val pop : t -> elt
val set : t -> int -> elt -> unit
val shrink : t -> int -> unit
include Sidekick_util.Vec_sig.EXTENSIONS with type t := t and type elt := elt
val to_iter : t -> elt Iter.t
val to_array : t -> elt array
val fold_left : ( 'a -> elt -> 'a ) -> 'a -> t -> 'a
val pp : elt CCFormat.printer -> t CCFormat.printer
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/P/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/P/index.html deleted file mode 100644 index 169a1307..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/P/index.html +++ /dev/null @@ -1,10 +0,0 @@ - -P (sidekick.Sidekick_arith_lia.ARG.S.P)

Module S.P

type t = proof

The abstract representation of a proof. A proof always proves a clause to be valid (true in every possible interpretation of the problem's assertions, and the theories)

type proof_step = proof_step

Identifier for a proof proof_rule (like a unique ID for a clause previously added/proved)

type term = T.Term.t
type lit = Lit.t
type proof_rule = t -> proof_step
include Sidekick_core.SAT_PROOF - with type t := t - and type lit := lit - and type proof_step := proof_step - and type proof_rule := proof_rule

A vector of steps

val enabled : t -> bool

Returns true if proof production is enabled

val emit_input_clause : lit Iter.t -> proof_rule

Emit an input clause.

val emit_redundant_clause : lit Iter.t -> hyps:proof_step Iter.t -> proof_rule

Emit a clause deduced by the SAT solver, redundant wrt previous clauses. The clause must be RUP wrt hyps.

val emit_unsat_core : lit Iter.t -> proof_rule

Produce a proof of the empty clause given this subset of the assumptions. FIXME: probably needs the list of proof_step that disprove the lits?

val emit_unsat : proof_step -> t -> unit

Signal "unsat" result at the given proof

val del_clause : proof_step -> lit Iter.t -> t -> unit

Forget a clause. Only useful for performance considerations.

val lemma_cc : lit Iter.t -> proof_rule

lemma_cc proof lits asserts that lits form a tautology for the theory of uninterpreted functions.

val define_term : term -> term -> proof_rule

define_term cst u proof defines the new constant cst as being equal to u. The result is a proof of the clause cst = u

val proof_p1 : proof_step -> proof_step -> proof_rule

proof_p1 p1 p2, where p1 proves the unit clause t=u (t:bool) and p2 proves C \/ t, is the rule that produces C \/ u, i.e unit paramodulation.

val proof_r1 : proof_step -> proof_step -> proof_rule

proof_r1 p1 p2, where p1 proves the unit clause |- t (t:bool) and p2 proves C \/ ¬t, is the rule that produces C \/ u, i.e unit resolution.

val proof_res : pivot:term -> proof_step -> proof_step -> proof_rule

proof_res ~pivot p1 p2, where p1 proves the clause |- C \/ l and p2 proves D \/ ¬l, where l is either pivot or ¬pivot, is the rule that produces C \/ D, i.e boolean resolution.

val with_defs : proof_step -> proof_step Iter.t -> proof_rule

with_defs pr defs specifies that pr is valid only in a context where the definitions defs are present.

val lemma_true : term -> proof_rule

lemma_true (true) p asserts the clause (true)

val lemma_preprocess : term -> term -> using:proof_step Iter.t -> proof_rule

lemma_preprocess t u ~using p asserts that t = u is a tautology and that t has been preprocessed into u.

The theorem /\_{eqn in using} eqn |- t=u is proved using congruence closure, and then resolved against the clauses using to obtain a unit equality.

From now on, t and u will be used interchangeably.

  • returns

    a proof_rule ID for the clause (t=u).

val lemma_rw_clause : - proof_step -> - res:lit Iter.t -> - using:proof_step Iter.t -> - proof_rule

lemma_rw_clause prc ~res ~using, where prc is the proof of |- c, uses the equations |- p_i = q_i from using to rewrite some literals of c into res. This is used to preprocess literals of a clause (using lemma_preprocess individually).

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/Registry/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/Registry/index.html deleted file mode 100644 index 521b758c..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/Registry/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Registry (sidekick.Sidekick_arith_lia.ARG.S.Registry)

Module S.Registry

type t
type 'a key
val create_key : unit -> 'a key

Call this statically, typically at program initialization, for each distinct key.

val create : unit -> t
val get : t -> 'a key -> 'a option
val set : t -> 'a key -> 'a -> unit
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/Solver_internal/CC/Actions/P/Step_vec/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/Solver_internal/CC/Actions/P/Step_vec/index.html deleted file mode 100644 index c16c8bfb..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/Solver_internal/CC/Actions/P/Step_vec/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Step_vec (sidekick.Sidekick_arith_lia.ARG.S.Solver_internal.CC.Actions.P.Step_vec)

Module P.Step_vec

A vector of steps

include Sidekick_util.Vec_sig.BASE with type elt = proof_step
include Sidekick_util.Vec_sig.BASE_RO with type elt = proof_step
type elt = proof_step
type t
val size : t -> int
val get : t -> int -> elt
val iter : f:( elt -> unit ) -> t -> unit
val iteri : f:( int -> elt -> unit ) -> t -> unit
val create : ?cap:int -> unit -> t
val clear : t -> unit
val copy : t -> t
val is_empty : t -> bool
val push : t -> elt -> unit
val fast_remove : t -> int -> unit

Remove element at index i without preserving order (swap with last element)

val filter_in_place : ( elt -> bool ) -> t -> unit
val ensure_size : t -> int -> unit
val pop : t -> elt
val set : t -> int -> elt -> unit
val shrink : t -> int -> unit
include Sidekick_util.Vec_sig.EXTENSIONS with type t := t and type elt := elt
val to_iter : t -> elt Iter.t
val to_array : t -> elt array
val fold_left : ( 'a -> elt -> 'a ) -> 'a -> t -> 'a
val pp : elt CCFormat.printer -> t CCFormat.printer
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/Solver_internal/CC/Actions/P/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/Solver_internal/CC/Actions/P/index.html deleted file mode 100644 index 26c1f875..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/Solver_internal/CC/Actions/P/index.html +++ /dev/null @@ -1,10 +0,0 @@ - -P (sidekick.Sidekick_arith_lia.ARG.S.Solver_internal.CC.Actions.P)

Module Actions.P

type t = proof

The abstract representation of a proof. A proof always proves a clause to be valid (true in every possible interpretation of the problem's assertions, and the theories)

type proof_step = proof_step

Identifier for a proof proof_rule (like a unique ID for a clause previously added/proved)

type term = T.Term.t
type lit = Lit.t
type proof_rule = t -> proof_step
include Sidekick_core.SAT_PROOF - with type t := t - and type lit := lit - and type proof_step := proof_step - and type proof_rule := proof_rule

A vector of steps

val enabled : t -> bool

Returns true if proof production is enabled

val emit_input_clause : lit Iter.t -> proof_rule

Emit an input clause.

val emit_redundant_clause : lit Iter.t -> hyps:proof_step Iter.t -> proof_rule

Emit a clause deduced by the SAT solver, redundant wrt previous clauses. The clause must be RUP wrt hyps.

val emit_unsat_core : lit Iter.t -> proof_rule

Produce a proof of the empty clause given this subset of the assumptions. FIXME: probably needs the list of proof_step that disprove the lits?

val emit_unsat : proof_step -> t -> unit

Signal "unsat" result at the given proof

val del_clause : proof_step -> lit Iter.t -> t -> unit

Forget a clause. Only useful for performance considerations.

val lemma_cc : lit Iter.t -> proof_rule

lemma_cc proof lits asserts that lits form a tautology for the theory of uninterpreted functions.

val define_term : term -> term -> proof_rule

define_term cst u proof defines the new constant cst as being equal to u. The result is a proof of the clause cst = u

val proof_p1 : proof_step -> proof_step -> proof_rule

proof_p1 p1 p2, where p1 proves the unit clause t=u (t:bool) and p2 proves C \/ t, is the rule that produces C \/ u, i.e unit paramodulation.

val proof_r1 : proof_step -> proof_step -> proof_rule

proof_r1 p1 p2, where p1 proves the unit clause |- t (t:bool) and p2 proves C \/ ¬t, is the rule that produces C \/ u, i.e unit resolution.

val proof_res : pivot:term -> proof_step -> proof_step -> proof_rule

proof_res ~pivot p1 p2, where p1 proves the clause |- C \/ l and p2 proves D \/ ¬l, where l is either pivot or ¬pivot, is the rule that produces C \/ D, i.e boolean resolution.

val with_defs : proof_step -> proof_step Iter.t -> proof_rule

with_defs pr defs specifies that pr is valid only in a context where the definitions defs are present.

val lemma_true : term -> proof_rule

lemma_true (true) p asserts the clause (true)

val lemma_preprocess : term -> term -> using:proof_step Iter.t -> proof_rule

lemma_preprocess t u ~using p asserts that t = u is a tautology and that t has been preprocessed into u.

The theorem /\_{eqn in using} eqn |- t=u is proved using congruence closure, and then resolved against the clauses using to obtain a unit equality.

From now on, t and u will be used interchangeably.

  • returns

    a proof_rule ID for the clause (t=u).

val lemma_rw_clause : - proof_step -> - res:lit Iter.t -> - using:proof_step Iter.t -> - proof_rule

lemma_rw_clause prc ~res ~using, where prc is the proof of |- c, uses the equations |- p_i = q_i from using to rewrite some literals of c into res. This is used to preprocess literals of a clause (using lemma_preprocess individually).

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/Solver_internal/CC/Actions/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/Solver_internal/CC/Actions/index.html deleted file mode 100644 index 2e6bf03e..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/Solver_internal/CC/Actions/index.html +++ /dev/null @@ -1,15 +0,0 @@ - -Actions (sidekick.Sidekick_arith_lia.ARG.S.Solver_internal.CC.Actions)

Module CC.Actions

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

An action handle. It is used by the congruence closure to perform the actions below. How it performs the actions is not specified and is solver-specific.

val proof : t -> proof
val raise_conflict : t -> Lit.t list -> proof_step -> 'a

raise_conflict acts c pr declares that c is a tautology of the theory of congruence. This does not return (it should raise an exception).

  • parameter pr

    the proof of c being a tautology

val raise_semantic_conflict : - t -> - Lit.t list -> - (bool * T.Term.t * T.Term.t) list -> - 'a

raise_semantic_conflict acts lits same_val declares that the conjunction of all lits (literals true in current trail) and tuples {=,≠}, t_i, u_i implies false.

The {=,≠}, t_i, u_i are pairs of terms with the same value (if = / true) or distinct value (if ≠ / false)) in the current model.

This does not return. It should raise an exception.

val propagate : - t -> - Lit.t -> - reason:( unit -> Lit.t list * proof_step ) -> - unit

propagate acts lit ~reason pr declares that reason() => lit is a tautology.

  • reason() should return a list of literals that are currently true.
  • lit should be a literal of interest (see CC_S.set_as_lit).

This function might never be called, a congruence closure has the right to not propagate and only trigger conflicts.

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/Solver_internal/CC/Expl/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/Solver_internal/CC/Expl/index.html deleted file mode 100644 index 1e2025bf..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/Solver_internal/CC/Expl/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Expl (sidekick.Sidekick_arith_lia.ARG.S.Solver_internal.CC.Expl)

Module CC.Expl

Explanations

Explanations are specialized proofs, created by the congruence closure when asked to justify why 2 terms are equal.

type t
val pp : t Sidekick_core.Fmt.printer
val mk_merge : N.t -> N.t -> t

Explanation: the nodes were explicitly merged

val mk_merge_t : term -> term -> t

Explanation: the terms were explicitly merged

val mk_lit : lit -> t

Explanation: we merged t and u because of literal t=u, or we merged t and true because of literal t, or t and false because of literal ¬t

val mk_same_value : N.t -> N.t -> t
val mk_list : t list -> t

Conjunction of explanations

val mk_theory : term -> term -> (term * term * t list) list -> proof_step -> t

mk_theory t u expl_sets pr builds a theory explanation for why |- t=u. It depends on sub-explanations expl_sets which are tuples (t_i, u_i, expls_i) where expls_i are explanations that justify t_i = u_i in the current congruence closure.

The proof pr is the theory lemma, of the form (t_i = u_i)_i |- t=u . It is resolved against each expls_i |- t_i=u_i obtained from expl_sets, on pivot t_i=u_i, to obtain a proof of Gamma |- t=u where Gamma is a subset of the literals asserted into the congruence closure.

For example for the lemma a=b deduced by injectivity from Some a=Some b in the theory of datatypes, the arguments would be a, b, [Some a, Some b, mk_merge_t (Some a)(Some b)], pr where pr is the injectivity lemma Some a=Some b |- a=b.

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/Solver_internal/CC/N/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/Solver_internal/CC/N/index.html deleted file mode 100644 index e58d05af..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/Solver_internal/CC/N/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -N (sidekick.Sidekick_arith_lia.ARG.S.Solver_internal.CC.N)

Module CC.N

Equivalence classes.

An equivalence class is a set of terms that are currently equal in the partial model built by the solver. The class is represented by a collection of nodes, one of which is distinguished and is called the "representative".

All information pertaining to the whole equivalence class is stored in this representative's node.

When two classes become equal (are "merged"), one of the two representatives is picked as the representative of the new class. The new class contains the union of the two old classes' nodes.

We also allow theories to store additional information in the representative. This information can be used when two classes are merged, to detect conflicts and solve equations à la Shostak.

type t

An equivalent class, containing terms that are proved to be equal.

A value of type t points to a particular term, but see find to get the representative of the class.

val term : t -> term

Term contained in this equivalence class. If is_root n, then term n is the class' representative term.

val equal : t -> t -> bool

Are two classes physically equal? To check for logical equality, use CC.N.equal (CC.find cc n1) (CC.find cc n2) which checks for equality of representatives.

val hash : t -> int

An opaque hash of this node.

val pp : t Sidekick_core.Fmt.printer

Unspecified printing of the node, for example its term, a unique ID, etc.

val is_root : t -> bool

Is the node a root (ie the representative of its class)? See find to get the root.

val iter_class : t -> t Iter.t

Traverse the congruence class. Precondition: is_root n (see find below)

val iter_parents : t -> t Iter.t

Traverse the parents of the class. Precondition: is_root n (see find below)

type bitfield

A field in the bitfield of this node. This should only be allocated when a theory is initialized.

Bitfields are accessed using preallocated keys. See CC_S.allocate_bitfield.

All fields are initially 0, are backtracked automatically, and are merged automatically when classes are merged.

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/Solver_internal/CC/P/Step_vec/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/Solver_internal/CC/P/Step_vec/index.html deleted file mode 100644 index 4782a0c6..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/Solver_internal/CC/P/Step_vec/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Step_vec (sidekick.Sidekick_arith_lia.ARG.S.Solver_internal.CC.P.Step_vec)

Module P.Step_vec

A vector of steps

include Sidekick_util.Vec_sig.BASE with type elt = proof_step
include Sidekick_util.Vec_sig.BASE_RO with type elt = proof_step
type elt = proof_step
type t
val size : t -> int
val get : t -> int -> elt
val iter : f:( elt -> unit ) -> t -> unit
val iteri : f:( int -> elt -> unit ) -> t -> unit
val create : ?cap:int -> unit -> t
val clear : t -> unit
val copy : t -> t
val is_empty : t -> bool
val push : t -> elt -> unit
val fast_remove : t -> int -> unit

Remove element at index i without preserving order (swap with last element)

val filter_in_place : ( elt -> bool ) -> t -> unit
val ensure_size : t -> int -> unit
val pop : t -> elt
val set : t -> int -> elt -> unit
val shrink : t -> int -> unit
include Sidekick_util.Vec_sig.EXTENSIONS with type t := t and type elt := elt
val to_iter : t -> elt Iter.t
val to_array : t -> elt array
val fold_left : ( 'a -> elt -> 'a ) -> 'a -> t -> 'a
val pp : elt CCFormat.printer -> t CCFormat.printer
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/Solver_internal/CC/P/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/Solver_internal/CC/P/index.html deleted file mode 100644 index 7263856e..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/Solver_internal/CC/P/index.html +++ /dev/null @@ -1,10 +0,0 @@ - -P (sidekick.Sidekick_arith_lia.ARG.S.Solver_internal.CC.P)

Module CC.P

type t = proof

The abstract representation of a proof. A proof always proves a clause to be valid (true in every possible interpretation of the problem's assertions, and the theories)

type proof_step = proof_step

Identifier for a proof proof_rule (like a unique ID for a clause previously added/proved)

type term
type lit = lit
type proof_rule = t -> proof_step
include Sidekick_core.SAT_PROOF - with type t := t - and type lit := lit - and type proof_step := proof_step - and type proof_rule := proof_rule

A vector of steps

val enabled : t -> bool

Returns true if proof production is enabled

val emit_input_clause : lit Iter.t -> proof_rule

Emit an input clause.

val emit_redundant_clause : lit Iter.t -> hyps:proof_step Iter.t -> proof_rule

Emit a clause deduced by the SAT solver, redundant wrt previous clauses. The clause must be RUP wrt hyps.

val emit_unsat_core : lit Iter.t -> proof_rule

Produce a proof of the empty clause given this subset of the assumptions. FIXME: probably needs the list of proof_step that disprove the lits?

val emit_unsat : proof_step -> t -> unit

Signal "unsat" result at the given proof

val del_clause : proof_step -> lit Iter.t -> t -> unit

Forget a clause. Only useful for performance considerations.

val lemma_cc : lit Iter.t -> proof_rule

lemma_cc proof lits asserts that lits form a tautology for the theory of uninterpreted functions.

val define_term : term -> term -> proof_rule

define_term cst u proof defines the new constant cst as being equal to u. The result is a proof of the clause cst = u

val proof_p1 : proof_step -> proof_step -> proof_rule

proof_p1 p1 p2, where p1 proves the unit clause t=u (t:bool) and p2 proves C \/ t, is the rule that produces C \/ u, i.e unit paramodulation.

val proof_r1 : proof_step -> proof_step -> proof_rule

proof_r1 p1 p2, where p1 proves the unit clause |- t (t:bool) and p2 proves C \/ ¬t, is the rule that produces C \/ u, i.e unit resolution.

val proof_res : pivot:term -> proof_step -> proof_step -> proof_rule

proof_res ~pivot p1 p2, where p1 proves the clause |- C \/ l and p2 proves D \/ ¬l, where l is either pivot or ¬pivot, is the rule that produces C \/ D, i.e boolean resolution.

val with_defs : proof_step -> proof_step Iter.t -> proof_rule

with_defs pr defs specifies that pr is valid only in a context where the definitions defs are present.

val lemma_true : term -> proof_rule

lemma_true (true) p asserts the clause (true)

val lemma_preprocess : term -> term -> using:proof_step Iter.t -> proof_rule

lemma_preprocess t u ~using p asserts that t = u is a tautology and that t has been preprocessed into u.

The theorem /\_{eqn in using} eqn |- t=u is proved using congruence closure, and then resolved against the clauses using to obtain a unit equality.

From now on, t and u will be used interchangeably.

  • returns

    a proof_rule ID for the clause (t=u).

val lemma_rw_clause : - proof_step -> - res:lit Iter.t -> - using:proof_step Iter.t -> - proof_rule

lemma_rw_clause prc ~res ~using, where prc is the proof of |- c, uses the equations |- p_i = q_i from using to rewrite some literals of c into res. This is used to preprocess literals of a clause (using lemma_preprocess individually).

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/Solver_internal/CC/Resolved_expl/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/Solver_internal/CC/Resolved_expl/index.html deleted file mode 100644 index 8cbfd93f..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/Solver_internal/CC/Resolved_expl/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Resolved_expl (sidekick.Sidekick_arith_lia.ARG.S.Solver_internal.CC.Resolved_expl)

Module CC.Resolved_expl

Resolved explanations.

The congruence closure keeps explanations for why terms are in the same class. However these are represented in a compact, cheap form. To use these explanations we need to resolve them into a resolved explanation, typically a list of literals that are true in the current trail and are responsible for merges.

However, we can also have merged classes because they have the same value in the current model.

type t = {
lits : lit list;
same_value : (N.t * N.t) list;
pr : proof -> proof_step;
}
val is_semantic : t -> bool

is_semantic expl is true if there's at least one pair in expl.same_value.

val pp : t Sidekick_core.Fmt.printer
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/Solver_internal/CC/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/Solver_internal/CC/index.html deleted file mode 100644 index 76515caf..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/Solver_internal/CC/index.html +++ /dev/null @@ -1,25 +0,0 @@ - -CC (sidekick.Sidekick_arith_lia.ARG.S.Solver_internal.CC)

Module Solver_internal.CC

Congruence closure instance

first, some aliases.

module T = T
module Lit = Lit
type proof = proof
type proof_step = proof_step
module P : - Sidekick_core.PROOF - with type lit = Lit.t - and type t = proof - and type proof_step = proof_step - with type t = proof - with type lit = lit
module Actions : - Sidekick_core.CC_ACTIONS - with module T = T - and module Lit = Lit - and type proof = proof - and type proof_step = proof_step - with type t = theory_actions
type term_store = T.Term.store
type term = T.Term.t
type value = term
type fun_ = T.Fun.t
type lit = Lit.t
type actions = Actions.t
type t

The congruence closure object. It contains a fair amount of state and is mutable and backtrackable.

module N : sig ... end

Equivalence classes.

module Expl : sig ... end

Explanations

module Resolved_expl : sig ... end

Resolved explanations.

type node = N.t

A node of the congruence closure

type repr = N.t

Node that is currently a representative

type explanation = Expl.t

Accessors

val term_store : t -> term_store
val proof : t -> proof
val find : t -> node -> repr

Current representative

val add_term : t -> term -> node

Add the term to the congruence closure, if not present already. Will be backtracked.

val mem_term : t -> term -> bool

Returns true if the term is explicitly present in the congruence closure

Events

Events triggered by the congruence closure, to which other plugins can subscribe.

type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit

ev_on_pre_merge cc acts n1 n2 expl is called right before n1 and n2 are merged with explanation expl.

type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit

ev_on_post_merge cc acts n1 n2 is called right after n1 and n2 were merged. find cc n1 and find cc n2 will return the same node.

type ev_on_new_term = t -> N.t -> term -> unit

ev_on_new_term cc n t is called whenever a new term t is added to the congruence closure. Its node is n.

type ev_on_conflict = t -> th:bool -> lit list -> unit

ev_on_conflict acts ~th c is called when the congruence closure triggers a conflict by asserting the tautology c.

  • parameter th

    true if the explanation for this conflict involves at least one "theory" explanation; i.e. some of the equations participating in the conflict are purely syntactic theories like injectivity of constructors.

type ev_on_propagate = t -> lit -> ( unit -> lit list * proof_step ) -> unit

ev_on_propagate cc lit reason is called whenever reason() => lit is a propagated lemma. See CC_ACTIONS.propagate.

type ev_on_is_subterm = N.t -> term -> unit

ev_on_is_subterm n t is called when n is a subterm of another node for the first time. t is the term corresponding to the node n. This can be useful for theory combination.

val create : - ?stat:Sidekick_util.Stat.t -> - ?on_pre_merge:ev_on_pre_merge list -> - ?on_post_merge:ev_on_post_merge list -> - ?on_new_term:ev_on_new_term list -> - ?on_conflict:ev_on_conflict list -> - ?on_propagate:ev_on_propagate list -> - ?on_is_subterm:ev_on_is_subterm list -> - ?size:[ `Small | `Big ] -> - term_store -> - proof -> - t

Create a new congruence closure.

  • parameter term_store

    used to be able to create new terms. All terms interacting with this congruence closure must belong in this term state as well.

val allocate_bitfield : descr:string -> t -> N.bitfield

Allocate a new node field (see N.bitfield).

This field descriptor is henceforth reserved for all nodes in this congruence closure, and can be set using set_bitfield for each node individually. This can be used to efficiently store some metadata on nodes (e.g. "is there a numeric value in the class" or "is there a constructor term in the class").

There may be restrictions on how many distinct fields are allocated for a given congruence closure (e.g. at most Sys.int_size fields).

val get_bitfield : t -> N.bitfield -> N.t -> bool

Access the bit field of the given node

val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit

Set the bitfield for the node. This will be backtracked. See N.bitfield.

val on_pre_merge : t -> ev_on_pre_merge -> unit

Add a function to be called when two classes are merged

val on_post_merge : t -> ev_on_post_merge -> unit

Add a function to be called when two classes are merged

val on_new_term : t -> ev_on_new_term -> unit

Add a function to be called when a new node is created

val on_conflict : t -> ev_on_conflict -> unit

Called when the congruence closure finds a conflict

val on_propagate : t -> ev_on_propagate -> unit

Called when the congruence closure propagates a literal

val on_is_subterm : t -> ev_on_is_subterm -> unit

Called on terms that are subterms of function symbols

val set_as_lit : t -> N.t -> lit -> unit

map the given node to a literal.

val find_t : t -> term -> repr

Current representative of the term.

  • raises Not_found

    if the term is not already add-ed.

val add_seq : t -> term Iter.t -> unit

Add a sequence of terms to the congruence closure

val all_classes : t -> repr Iter.t

All current classes. This is costly, only use if there is no other solution

val assert_lit : t -> lit -> unit

Given a literal, assume it in the congruence closure and propagate its consequences. Will be backtracked.

Useful for the theory combination or the SAT solver's functor

val assert_lits : t -> lit Iter.t -> unit

Addition of many literals

val explain_eq : t -> N.t -> N.t -> Resolved_expl.t

Explain why the two nodes are equal. Fails if they are not, in an unspecified way.

val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a

Raise a conflict with the given explanation. It must be a theory tautology that expl ==> absurd. To be used in theories.

This fails in an unspecified way if the explanation, once resolved, satisfies Resolved_expl.is_semantic.

val n_true : t -> N.t

Node for true

val n_false : t -> N.t

Node for false

val n_bool : t -> bool -> N.t

Node for either true or false

val merge : t -> N.t -> N.t -> Expl.t -> unit

Merge these two nodes given this explanation. It must be a theory tautology that expl ==> n1 = n2. To be used in theories.

val merge_t : t -> term -> term -> Expl.t -> unit

Shortcut for adding + merging

val set_model_value : t -> term -> value -> unit

Set the value of a term in the model.

val with_model_mode : t -> ( unit -> 'a ) -> 'a

Enter model combination mode.

val get_model_for_each_class : t -> (repr * N.t Iter.t * value) Iter.t

In model combination mode, obtain classes with their values.

val check : t -> actions -> unit

Perform all pending operations done via assert_eq, assert_lit, etc. Will use the actions to propagate literals, declare conflicts, etc.

val push_level : t -> unit

Push backtracking level

val pop_levels : t -> int -> unit

Restore to state n calls to push_level earlier. Used during backtracking.

val get_model : t -> N.t Iter.t Iter.t

get all the equivalence classes so they can be merged in the model

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/Solver_internal/Registry/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/Solver_internal/Registry/index.html deleted file mode 100644 index f927ccf9..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/Solver_internal/Registry/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Registry (sidekick.Sidekick_arith_lia.ARG.S.Solver_internal.Registry)

Module Solver_internal.Registry

type t
type 'a key
val create_key : unit -> 'a key

Call this statically, typically at program initialization, for each distinct key.

val create : unit -> t
val get : t -> 'a key -> 'a option
val set : t -> 'a key -> 'a -> unit
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/Solver_internal/Simplify/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/Solver_internal/Simplify/index.html deleted file mode 100644 index 857a4a60..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/Solver_internal/Simplify/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Simplify (sidekick.Sidekick_arith_lia.ARG.S.Solver_internal.Simplify)

Module Solver_internal.Simplify

Simplify terms

type t
val tst : t -> term_store
val ty_st : t -> ty_store
val clear : t -> unit

Reset internal cache, etc.

val proof : t -> proof

Access proof

type hook = t -> term -> (term * proof_step Iter.t) option

Given a term, try to simplify it. Return None if it didn't change.

A simple example could be a hook that takes a term t, and if t is app "+" (const x) (const y) where x and y are number, returns Some (const (x+y)), and None otherwise.

The simplifier will take care of simplifying the resulting term further, caching (so that work is not duplicated in subterms), etc.

val normalize : t -> term -> (term * proof_step) option

Normalize a term using all the hooks. This performs a fixpoint, i.e. it only stops when no hook applies anywhere inside the term.

val normalize_t : t -> term -> term * proof_step option

Normalize a term using all the hooks, along with a proof that the simplification is correct. returns t, ø if no simplification occurred.

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/Solver_internal/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/Solver_internal/index.html deleted file mode 100644 index 2b0eaf3b..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/Solver_internal/index.html +++ /dev/null @@ -1,43 +0,0 @@ - -Solver_internal (sidekick.Sidekick_arith_lia.ARG.S.Solver_internal)

Module S.Solver_internal

Internal solver, available to theories.

module T = T
module Lit = Lit
type ty = T.Ty.t
type term = T.Term.t
type value = T.Term.t
type term_store = T.Term.store
type ty_store = T.Ty.store
type clause_pool
type proof = proof
type proof_step = proof_step
module P = P
type t

Main type for a solver

type solver = t
val tst : t -> term_store
val ty_st : t -> ty_store
val stats : t -> Sidekick_util.Stat.t
val proof : t -> proof

Access the proof object

Registry

val registry : t -> Registry.t

A solver contains a registry so that theories can share data

Actions for the theories

type theory_actions

Handle that the theories can use to perform actions.

type lit = Lit.t

Congruence Closure

module CC : - Sidekick_core.CC_S - with module T = T - and module Lit = Lit - and type proof = proof - and type proof_step = proof_step - and type P.t = proof - and type P.lit = lit - and type Actions.t = theory_actions

Congruence closure instance

val cc : t -> CC.t

Congruence closure for this solver

Simplifiers

module Simplify : sig ... end

Simplify terms

type simplify_hook = Simplify.hook
val add_simplifier : t -> Simplify.hook -> unit

Add a simplifier hook for preprocessing.

val simplify_t : t -> term -> (term * proof_step) option

Simplify input term, returns Some u if some simplification occurred.

val simp_t : t -> term -> term * proof_step option

simp_t si t returns u even if no simplification occurred (in which case t == u syntactically). It emits |- t=u. (see simplifier)

Preprocessors

These preprocessors turn mixed, raw literals (possibly simplified) into literals suitable for reasoning. Typically some clauses are also added to the solver.

module type PREPROCESS_ACTS = sig ... end
type preprocess_actions = (module PREPROCESS_ACTS)

Actions available to the preprocessor

type preprocess_hook = t -> preprocess_actions -> term -> unit

Given a term, preprocess it.

The idea is to add literals and clauses to help define the meaning of the term, if needed. For example for boolean formulas, clauses for their Tseitin encoding can be added, with the formula acting as its own proxy symbol.

  • parameter preprocess_actions

    actions available during preprocessing.

val on_preprocess : t -> preprocess_hook -> unit

Add a hook that will be called when terms are preprocessed

hooks for the theory

val raise_conflict : t -> theory_actions -> lit list -> proof_step -> 'a

Give a conflict clause to the solver

val push_decision : t -> theory_actions -> lit -> unit

Ask the SAT solver to decide the given literal in an extension of the current trail. This is useful for theory combination. If the SAT solver backtracks, this (potential) decision is removed and forgotten.

val propagate : - t -> - theory_actions -> - lit -> - reason:( unit -> lit list * proof_step ) -> - unit

Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology

val propagate_l : t -> theory_actions -> lit -> lit list -> proof_step -> unit

Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology

val add_clause_temp : t -> theory_actions -> lit list -> proof_step -> unit

Add local clause to the SAT solver. This clause will be removed when the solver backtracks.

val add_clause_permanent : - t -> - theory_actions -> - lit list -> - proof_step -> - unit

Add toplevel clause to the SAT solver. This clause will not be backtracked.

val mk_lit : t -> theory_actions -> ?sign:bool -> term -> lit

Create a literal. This automatically preprocesses the term.

val add_lit : t -> theory_actions -> ?default_pol:bool -> lit -> unit

Add the given literal to the SAT solver, so it gets assigned a boolean value.

  • parameter default_pol

    default polarity for the corresponding atom

val add_lit_t : t -> theory_actions -> ?sign:bool -> term -> unit

Add the given (signed) bool term to the SAT solver, so it gets assigned a boolean value

val cc_raise_conflict_expl : t -> theory_actions -> CC.Expl.t -> 'a

Raise a conflict with the given congruence closure explanation. it must be a theory tautology that expl ==> absurd. To be used in theories.

val cc_find : t -> CC.N.t -> CC.N.t

Find representative of the node

val cc_are_equal : t -> term -> term -> bool

Are these two terms equal in the congruence closure?

val cc_merge : t -> theory_actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit

Merge these two nodes in the congruence closure, given this explanation. It must be a theory tautology that expl ==> n1 = n2. To be used in theories.

val cc_merge_t : t -> theory_actions -> term -> term -> CC.Expl.t -> unit

Merge these two terms in the congruence closure, given this explanation. See cc_merge

val cc_add_term : t -> term -> CC.N.t

Add/retrieve congruence closure node for this term. To be used in theories

val cc_mem_term : t -> term -> bool

Return true if the term is explicitly in the congruence closure. To be used in theories

val on_cc_pre_merge : - t -> - ( CC.t -> theory_actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit ) -> - unit

Callback for when two classes containing data for this key are merged (called before)

val on_cc_post_merge : - t -> - ( CC.t -> theory_actions -> CC.N.t -> CC.N.t -> unit ) -> - unit

Callback for when two classes containing data for this key are merged (called after)

val on_cc_new_term : t -> ( CC.t -> CC.N.t -> term -> unit ) -> unit

Callback to add data on terms when they are added to the congruence closure

val on_cc_is_subterm : t -> ( CC.N.t -> term -> unit ) -> unit

Callback for when a term is a subterm of another term in the congruence closure

val on_cc_conflict : t -> ( CC.t -> th:bool -> lit list -> unit ) -> unit

Callback called on every CC conflict

val on_cc_propagate : - t -> - ( CC.t -> lit -> ( unit -> lit list * proof_step ) -> unit ) -> - unit

Callback called on every CC propagation

val on_partial_check : - t -> - ( t -> theory_actions -> lit Iter.t -> unit ) -> - unit

Register callbacked to be called with the slice of literals newly added on the trail.

This is called very often and should be efficient. It doesn't have to be complete, only correct. It's given only the slice of the trail consisting in new literals.

val on_final_check : t -> ( t -> theory_actions -> lit Iter.t -> unit ) -> unit

Register callback to be called during the final check.

Must be complete (i.e. must raise a conflict if the set of literals is not satisfiable) and can be expensive. The function is given the whole trail.

val on_th_combination : - t -> - ( t -> theory_actions -> (term * value) Iter.t ) -> - unit

Add a hook called during theory combination. The hook must return an iterator of pairs (t, v) which mean that term t has value v in the model.

Terms with the same value (according to Term.equal) will be merged in the CC; if two terms with different values are merged, we get a semantic conflict and must pick another model.

val declare_pb_is_incomplete : t -> unit

Declare that, in some theory, the problem is outside the logic fragment that is decidable (e.g. if we meet proper NIA formulas). The solver will not reply "SAT" from now on.

Model production

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

A model-production hook to query values from a theory.

It takes the solver, a class, and returns a term for this class. For example, an arithmetic theory might detect that a class contains a numeric constant, and return this constant as a model value.

If no hook assigns a value to a class, a fake value is created for it.

type model_completion_hook = t -> add:( term -> term -> unit ) -> unit

A model production hook, for the theory to add values. The hook is given a add function to add bindings to the model.

val on_model : - ?ask:model_ask_hook -> - ?complete:model_completion_hook -> - t -> - unit

Add model production/completion hooks.

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/Solver_internal/module-type-PREPROCESS_ACTS/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/Solver_internal/module-type-PREPROCESS_ACTS/index.html deleted file mode 100644 index 826ea7eb..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/Solver_internal/module-type-PREPROCESS_ACTS/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -PREPROCESS_ACTS (sidekick.Sidekick_arith_lia.ARG.S.Solver_internal.PREPROCESS_ACTS)

Module type Solver_internal.PREPROCESS_ACTS

val proof : proof
val mk_lit : ?sign:bool -> term -> lit

mk_lit t creates a new literal for a boolean term t.

val add_clause : lit list -> proof_step -> unit

pushes a new clause into the SAT solver.

val add_lit : ?default_pol:bool -> lit -> unit

Ensure the literal will be decided/handled by the SAT solver.

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/T/Fun/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/T/Fun/index.html deleted file mode 100644 index 39e813a2..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/T/Fun/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Fun (sidekick.Sidekick_arith_lia.ARG.S.T.Fun)

Module T.Fun

A function symbol, like "f" or "plus" or "is_human" or "socrates"

type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/T/Term/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/T/Term/index.html deleted file mode 100644 index 0609e004..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/T/Term/index.html +++ /dev/null @@ -1,8 +0,0 @@ - -Term (sidekick.Sidekick_arith_lia.ARG.S.T.Term)

Module T.Term

Term structure.

Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.

type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store

A store used to create new terms. It is where the hashconsing table should live, along with other all-terms related store.

val ty : t -> Ty.t
val bool : store -> bool -> t

build true/false

val as_bool : t -> bool option

as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.

val abs : store -> t -> t * bool

abs t returns an "absolute value" for the term, along with the sign of t.

The idea is that we want to turn not a into (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).

The store is passed in case a new term needs to be created.

val map_shallow : store -> ( t -> t ) -> t -> t

Map function on immediate subterms. This should not be recursive.

val iter_shallow : store -> ( t -> unit ) -> t -> unit

Iterate function on immediate subterms. This should not be recursive.

val iter_dag : t -> ( t -> unit ) -> unit

iter_dag t f calls f once on each subterm of t, t included. It must not traverse t as a tree, but rather as a perfectly shared DAG.

For example, in:

let x = 2 in
-let y = f x x in
-let z = g y x in
-z = z

the DAG has the following nodes:

n1: 2
-n2: f n1 n1
-n3: g n2 n1
-n4: = n3 n3
module Tbl : CCHashtbl.S with type key = t
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/T/Ty/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/T/Ty/index.html deleted file mode 100644 index 174b3ea7..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/T/Ty/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Ty (sidekick.Sidekick_arith_lia.ARG.S.T.Ty)

Module T.Ty

Types

Types should be comparable (ideally, in O(1)), and have at least a boolean type available.

type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store
val bool : store -> t
val is_bool : t -> bool
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/T/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/T/index.html deleted file mode 100644 index 835f0198..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/T/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -T (sidekick.Sidekick_arith_lia.ARG.S.T)

Module S.T

module Fun : sig ... end

A function symbol, like "f" or "plus" or "is_human" or "socrates"

module Ty : sig ... end

Types

module Term : sig ... end

Term structure.

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/Unknown/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/Unknown/index.html deleted file mode 100644 index 38191872..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/Unknown/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Unknown (sidekick.Sidekick_arith_lia.ARG.S.Unknown)

Module S.Unknown

type t
val pp : t CCFormat.printer
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/index.html deleted file mode 100644 index 1b165886..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/index.html +++ /dev/null @@ -1,37 +0,0 @@ - -S (sidekick.Sidekick_arith_lia.ARG.S)

Module ARG.S

module Lit : Sidekick_core.LIT with module T = T
type proof
type proof_step
module P : - Sidekick_core.PROOF - with type lit = Lit.t - and type t = proof - and type proof_step = proof_step - 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 type proof_step = proof_step - 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

Value registry

val registry : t -> Registry.t

A solver contains a registry so that theories can share data

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 proof : t -> proof
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 -> proof_step -> 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 -> proof_step -> 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;(*

Unsat core (subset of assumptions), or empty

*)
unsat_proof_step : unit -> proof_step option;(*

Proof step for the empty clause

*)
}		(*

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 ) -> - ?should_stop:( t -> int -> bool ) -> - 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 should_stop

    a callback regularly called with the solver, and with a number of "steps" done since last call. The exact notion of step is not defined, but is guaranteed to increase regularly. The function should return true if it judges solving must stop (returning Unknown), false if solving can proceed.

  • parameter on_exit

    functions to be run before this returns

val last_res : t -> res option

Last result, if any. Some operations will erase this (e.g. assert_term).

val push_assumption : t -> lit -> unit

Pushes an assumption onto the assumption stack. It will remain there until it's pop'd by pop_assumptions.

val pop_assumptions : t -> int -> unit

pop_assumptions solver n removes n assumptions from the stack. It removes the assumptions that were the most recently added via push_assumptions. Note that check_sat_propagations_only can call this if it meets a conflict.

type propagation_result =
| PR_sat
| PR_conflict of {
backtracked : int;
}
| PR_unsat of {
unsat_core : unit -> lit Iter.t;
}
val check_sat_propagations_only : - assumptions:lit list -> - t -> - propagation_result

check_sat_propagations_only solver uses assumptions (including the assumptions parameter, and atoms previously added via push_assumptions) and boolean+theory propagation to quickly assess satisfiability. It is not complete; calling solve is required to get an accurate result.

  • returns

    one of:

    • PR_sat if the current state seems satisfiable
    • PR_conflict {backtracked=n} if a conflict was found and resolved, leading to backtracking n levels of assumptions
    • PR_unsat … if the assumptions were found to be unsatisfiable, with the given core.
val pp_stats : t CCFormat.printer

Print some statistics. What it prints exactly is unspecified.

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/module-type-THEORY/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/module-type-THEORY/index.html deleted file mode 100644 index 951fbc29..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/S/module-type-THEORY/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -THEORY (sidekick.Sidekick_arith_lia.ARG.S.THEORY)

Module type S.THEORY

A theory

Theories are abstracted over the concrete implementation of the solver, so they can work with any implementation.

Typically a theory should be a functor taking an argument containing a SOLVER_INTERNAL or even a full SOLVER, and some additional views on terms, literals, etc. that are specific to the theory (e.g. to map terms to linear expressions). The theory can then be instantiated on any kind of solver for any term representation that also satisfies the additional theory-specific requirements. Instantiated theories (ie values of type SOLVER.theory) can be added to the solver.

type t

The theory's state

val name : string

Name of the theory (ideally, unique and short)

val create_and_setup : Solver_internal.t -> t

Instantiate the theory's state for the given (internal) solver, register callbacks, create keys, etc.

Called once for every solver this theory is added to.

val push_level : t -> unit

Push backtracking level. When the corresponding pop is called, the theory's state should be restored to a state equivalent to what it was just before push_level.

it does not have to be exactly the same state, it just needs to be equivalent.

val pop_levels : t -> int -> unit

pop_levels theory n pops n backtracking levels, restoring theory to its state before calling push_level n times.

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/Z/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-ARG/Z/index.html deleted file mode 100644 index c570658e..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/Z/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Z (sidekick.Sidekick_arith_lia.ARG.Z)

Module ARG.Z

include Sidekick_arith.NUM
type t
val zero : t
val one : t
val minus_one : t
val abs : t -> t
val sign : t -> int
val of_int : int -> t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val pp : t CCFormat.printer
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
val succ : t -> t
val pred : t -> t
val gcd : t -> t -> t
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-ARG/index.html deleted file mode 100644 index d87b7ab9..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-ARG/index.html +++ /dev/null @@ -1,3 +0,0 @@ - -ARG (sidekick.Sidekick_arith_lia.ARG)

Module type Sidekick_arith_lia.ARG

module Z : INT
module Q : RATIONAL with type bigint = Z.t
module LRA_solver : - Sidekick_arith_lra.S with type A.Q.t = Q.t and module A.S = S
type term = S.T.Term.t
type ty = S.T.Ty.t
val view_as_lia : term -> ( Z.t, Q.t, term ) lia_view

Project the term into the theory view

val mk_bool : S.T.Term.store -> bool -> term
val mk_to_real : S.T.Term.store -> term -> term

Wrap term into a to_real projector to rationals

val mk_lia : S.T.Term.store -> ( Z.t, Q.t, term ) lia_view -> term

Make a term from the given theory view

val ty_int : S.T.Term.store -> ty
val mk_eq : S.T.Term.store -> term -> term -> term

syntactic equality

val has_ty_int : term -> bool

Does this term have the type Int

val lemma_lia : S.Lit.t Iter.t -> S.P.proof_rule
val lemma_relax_to_lra : S.Lit.t Iter.t -> S.P.proof_rule
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/LRA_solver/A/Gensym/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-S/A/LRA_solver/A/Gensym/index.html deleted file mode 100644 index 20302cb8..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/LRA_solver/A/Gensym/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Gensym (sidekick.Sidekick_arith_lia.S.A.LRA_solver.A.Gensym)

Module A.Gensym

type t
val create : S.T.Term.store -> t
val tst : t -> S.T.Term.store
val copy : t -> t
val fresh_term : t -> pre:string -> S.T.Ty.t -> term

Make a fresh term of the given type

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/LRA_solver/A/Q/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-S/A/LRA_solver/A/Q/index.html deleted file mode 100644 index 4567ea0d..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/LRA_solver/A/Q/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Q (sidekick.Sidekick_arith_lia.S.A.LRA_solver.A.Q)

Module A.Q

include Sidekick_arith.NUM with type t = Q.t
type t = Q.t
val zero : t
val one : t
val minus_one : t
val abs : t -> t
val sign : t -> int
val of_int : int -> t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val pp : t CCFormat.printer
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
type bigint = Z.t
val (/) : t -> t -> t
val num : t -> bigint
val denum : t -> bigint
val infinity : t

+infinity

val minus_infinity : t
val of_bigint : bigint -> t
val is_real : t -> bool

A proper real, not nan/infinity

val is_int : t -> bool

Is this a proper integer?

val as_int : t -> bigint option

Convert to an integer if it's one, return None otherwise

val floor : t -> bigint

Integer equal or below

val ceil : t -> bigint

Integer equal or above

val pp_approx : int -> Stdlib.Format.formatter -> t -> unit

Pretty print rational with given amount of precision (for example as a floating point number)

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/LRA_solver/A/Z/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-S/A/LRA_solver/A/Z/index.html deleted file mode 100644 index d54b7b5f..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/LRA_solver/A/Z/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Z (sidekick.Sidekick_arith_lia.S.A.LRA_solver.A.Z)

Module A.Z

include Sidekick_arith.NUM
type t
val zero : t
val one : t
val minus_one : t
val abs : t -> t
val sign : t -> int
val of_int : int -> t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val pp : t CCFormat.printer
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
val succ : t -> t
val pred : t -> t
val gcd : t -> t -> t
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/LRA_solver/A/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-S/A/LRA_solver/A/index.html deleted file mode 100644 index e7c6dc7f..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/LRA_solver/A/index.html +++ /dev/null @@ -1,5 +0,0 @@ - -A (sidekick.Sidekick_arith_lia.S.A.LRA_solver.A)

Module LRA_solver.A

module S = S
module Q : Sidekick_arith_lra.RATIONAL with type bigint = Z.t with type t = Q.t
type term = S.T.Term.t
type ty = S.T.Ty.t
val view_as_lra : term -> ( Q.t, term ) Sidekick_arith_lra.lra_view

Project the term into the theory view

val mk_bool : S.T.Term.store -> bool -> term

Make a term from the given theory view

val ty_lra : S.T.Term.store -> ty
val mk_eq : S.T.Term.store -> term -> term -> term

syntactic equality

val has_ty_real : term -> bool

Does this term have the type Real

val lemma_lra : S.Lit.t Iter.t -> S.P.proof_rule
module Gensym : sig ... end
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/LRA_solver/SimpSolver/Constraint/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-S/A/LRA_solver/SimpSolver/Constraint/index.html deleted file mode 100644 index f6514d39..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/LRA_solver/SimpSolver/Constraint/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Constraint (sidekick.Sidekick_arith_lia.S.A.LRA_solver.SimpSolver.Constraint)

Module SimpSolver.Constraint

type t = {
op : op;
lhs : V.t;
rhs : num;
}

A constraint is the comparison of a variable to a constant.

val mk : V.t -> op -> num -> t
val leq : V.t -> num -> t
val lt : V.t -> num -> t
val geq : V.t -> num -> t
val gt : V.t -> num -> t
val pp : t Sidekick_util.Fmt.printer
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/LRA_solver/SimpSolver/Q/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-S/A/LRA_solver/SimpSolver/Q/index.html deleted file mode 100644 index eabd8975..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/LRA_solver/SimpSolver/Q/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Q (sidekick.Sidekick_arith_lia.S.A.LRA_solver.SimpSolver.Q)

Module SimpSolver.Q

include Sidekick_arith.NUM
type t
val zero : t
val one : t
val minus_one : t
val abs : t -> t
val sign : t -> int
val of_int : int -> t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val pp : t CCFormat.printer
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
type bigint = Z.t
val (/) : t -> t -> t
val num : t -> bigint
val denum : t -> bigint
val infinity : t

+infinity

val minus_infinity : t
val of_bigint : bigint -> t
val is_real : t -> bool

A proper real, not nan/infinity

val is_int : t -> bool

Is this a proper integer?

val as_int : t -> bigint option

Convert to an integer if it's one, return None otherwise

val floor : t -> bigint

Integer equal or below

val ceil : t -> bigint

Integer equal or above

val pp_approx : int -> Stdlib.Format.formatter -> t -> unit

Pretty print rational with given amount of precision (for example as a floating point number)

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/LRA_solver/SimpSolver/Subst/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-S/A/LRA_solver/SimpSolver/Subst/index.html deleted file mode 100644 index d91e0bbf..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/LRA_solver/SimpSolver/Subst/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Subst (sidekick.Sidekick_arith_lia.S.A.LRA_solver.SimpSolver.Subst)

Module SimpSolver.Subst

type t = num V_map.t
val eval : t -> V.t -> Q.t option
val to_iter : t -> (V.t * Q.t) Iter.t
val pp : t Sidekick_util.Fmt.printer
val to_string : t -> string
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/LRA_solver/SimpSolver/Unsat_cert/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-S/A/LRA_solver/SimpSolver/Unsat_cert/index.html deleted file mode 100644 index 0c1b0811..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/LRA_solver/SimpSolver/Unsat_cert/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Unsat_cert (sidekick.Sidekick_arith_lia.S.A.LRA_solver.SimpSolver.Unsat_cert)

Module SimpSolver.Unsat_cert

type t = unsat_cert
val lits : t -> V.lit list
val pp : t Sidekick_util.Fmt.printer
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/LRA_solver/SimpSolver/V/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-S/A/LRA_solver/SimpSolver/V/index.html deleted file mode 100644 index c49b8bd0..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/LRA_solver/SimpSolver/V/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -V (sidekick.Sidekick_arith_lia.S.A.LRA_solver.SimpSolver.V)

Module SimpSolver.V

type t

Variable type.

val compare : t -> t -> int

Standard comparison function on variables.

val pp : t Sidekick_util.Fmt.printer

Printer for variables.

type lit
val pp_lit : lit Sidekick_util.Fmt.printer
val not_lit : lit -> lit option
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/LRA_solver/SimpSolver/Z/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-S/A/LRA_solver/SimpSolver/Z/index.html deleted file mode 100644 index 0df2694f..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/LRA_solver/SimpSolver/Z/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Z (sidekick.Sidekick_arith_lia.S.A.LRA_solver.SimpSolver.Z)

Module SimpSolver.Z

include Sidekick_arith.NUM
type t
val zero : t
val one : t
val minus_one : t
val abs : t -> t
val sign : t -> int
val of_int : int -> t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val pp : t CCFormat.printer
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
val succ : t -> t
val pred : t -> t
val gcd : t -> t -> t
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/LRA_solver/SimpSolver/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-S/A/LRA_solver/SimpSolver/index.html deleted file mode 100644 index da506670..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/LRA_solver/SimpSolver/index.html +++ /dev/null @@ -1,16 +0,0 @@ - -SimpSolver (sidekick.Sidekick_arith_lia.S.A.LRA_solver.SimpSolver)

Module LRA_solver.SimpSolver

Simplexe

module V_map : CCMap.S with type key = V.t
module Q : Sidekick_simplex.RATIONAL with type bigint = Z.t
type num = Q.t

Numbers

module Constraint : sig ... end
module Subst : sig ... end
type t
val create : ?stat:Sidekick_util.Stat.t -> unit -> t

Create a new simplex.

val push_level : t -> unit
val pop_levels : t -> int -> unit
val define : ?is_int:bool -> t -> V.t -> (num * V.t) list -> unit

Define a basic variable in terms of other variables. This is useful to "name" a linear expression and get back a variable that can be used in a Constraint.t

type unsat_cert
module Unsat_cert : sig ... end
exception E_unsat of Unsat_cert.t
type ev_on_propagate = V.lit -> reason:V.lit list -> unit
val add_var : ?is_int:bool -> t -> V.t -> unit

Make sure the variable exists in the simplex.

val add_constraint : - ?keep_on_backtracking:bool -> - ?is_int:bool -> - on_propagate:ev_on_propagate -> - t -> - Constraint.t -> - V.lit -> - unit

Add a constraint to the simplex.

This is removed upon backtracking by default.

  • parameter is_int

    declares whether the constraint's variable is an integer

  • raises Unsat

    if it's immediately obvious that this is not satisfiable.

  • parameter keep_on_backtracking

    if true (default false), the bound is not backtrackable

val declare_bound : ?is_int:bool -> t -> Constraint.t -> V.lit -> unit

Declare that this constraint exists and map it to a literal, so we can possibly propagate it later. Unlike add_constraint this does NOT assert that the constraint is true

val check_exn : - on_propagate:( V.lit -> reason:V.lit list -> unit ) -> - t -> - unit

Check the whole simplex for satisfiability.

  • parameter on_propagate

    is called with arguments lit, reason whenever reason => lit is found to be true by the simplex.

  • raises Unsat

    if the constraints are not satisfiable.

type result =
| Sat of Subst.t
| Unsat of Unsat_cert.t
val check : on_propagate:( V.lit -> reason:V.lit list -> unit ) -> t -> result

Call check_exn and return a model or a proof of unsat. This does NOT enforce that integer variables map to integer values.

val check_branch_and_bound : - on_propagate:( V.lit -> reason:V.lit list -> unit ) -> - max_tree_nodes:int -> - t -> - result option

Try to solve and respect the integer constraints.

val n_vars : t -> int
val n_rows : t -> int
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/LRA_solver/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-S/A/LRA_solver/index.html deleted file mode 100644 index 7c0c32a4..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/LRA_solver/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -LRA_solver (sidekick.Sidekick_arith_lia.S.A.LRA_solver)

Module A.LRA_solver

module A : Sidekick_arith_lra.ARG with type Q.t = Q.t with module S = S

Simplexe

type state

Key to access the state from outside, available when the theory has been setup

val theory : A.S.theory
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/Q/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-S/A/Q/index.html deleted file mode 100644 index cd35b1a4..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/Q/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Q (sidekick.Sidekick_arith_lia.S.A.Q)

Module A.Q

include Sidekick_arith.NUM
type t
val zero : t
val one : t
val minus_one : t
val abs : t -> t
val sign : t -> int
val of_int : int -> t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val pp : t CCFormat.printer
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
type bigint = Z.t
val (/) : t -> t -> t
val num : t -> bigint
val denum : t -> bigint
val infinity : t

+infinity

val minus_infinity : t
val of_bigint : bigint -> t
val is_real : t -> bool

A proper real, not nan/infinity

val is_int : t -> bool

Is this a proper integer?

val as_int : t -> bigint option

Convert to an integer if it's one, return None otherwise

val floor : t -> bigint

Integer equal or below

val ceil : t -> bigint

Integer equal or above

val pp_approx : int -> Stdlib.Format.formatter -> t -> unit

Pretty print rational with given amount of precision (for example as a floating point number)

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/Lit/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/Lit/index.html deleted file mode 100644 index be9a24dd..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/Lit/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Lit (sidekick.Sidekick_arith_lia.S.A.S.Lit)

Module S.Lit

module T = T

Literals depend on terms

type t

A literal

val term : t -> T.Term.t

Get the (positive) term

val sign : t -> bool

Get the sign. A negated literal has sign false.

val neg : t -> t

Take negation of literal. sign (neg lit) = not (sign lit).

val abs : t -> t

abs lit is like lit but always positive, i.e. sign (abs lit) = true

val signed_term : t -> T.Term.t * bool

Return the atom and the sign

val atom : ?sign:bool -> T.Term.store -> T.Term.t -> t

atom store t makes a literal out of a term, possibly normalizing its sign in the process.

  • parameter sign

    if provided, and sign=false, negate the resulting lit.

val norm_sign : t -> t * bool

norm_sign (+t) is +t, true, and norm_sign (-t) is +t, false. In both cases the term is positive, and the boolean reflects the initial sign.

val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/Model/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/Model/index.html deleted file mode 100644 index 34b43f7b..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/Model/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Model (sidekick.Sidekick_arith_lia.S.A.S.Model)

Module S.Model

Models

A model can be produced when the solver is found to be in a satisfiable state after a call to solve.

type t
val empty : t
val mem : t -> term -> bool
val find : t -> term -> term option
val eval : t -> term -> term option
val pp : t Sidekick_core.Fmt.printer
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/P/Step_vec/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/P/Step_vec/index.html deleted file mode 100644 index 615eb808..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/P/Step_vec/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Step_vec (sidekick.Sidekick_arith_lia.S.A.S.P.Step_vec)

Module P.Step_vec

A vector of steps

include Sidekick_util.Vec_sig.BASE with type elt = proof_step
include Sidekick_util.Vec_sig.BASE_RO with type elt = proof_step
type elt = proof_step
type t
val size : t -> int
val get : t -> int -> elt
val iter : f:( elt -> unit ) -> t -> unit
val iteri : f:( int -> elt -> unit ) -> t -> unit
val create : ?cap:int -> unit -> t
val clear : t -> unit
val copy : t -> t
val is_empty : t -> bool
val push : t -> elt -> unit
val fast_remove : t -> int -> unit

Remove element at index i without preserving order (swap with last element)

val filter_in_place : ( elt -> bool ) -> t -> unit
val ensure_size : t -> int -> unit
val pop : t -> elt
val set : t -> int -> elt -> unit
val shrink : t -> int -> unit
include Sidekick_util.Vec_sig.EXTENSIONS with type t := t and type elt := elt
val to_iter : t -> elt Iter.t
val to_array : t -> elt array
val fold_left : ( 'a -> elt -> 'a ) -> 'a -> t -> 'a
val pp : elt CCFormat.printer -> t CCFormat.printer
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/P/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/P/index.html deleted file mode 100644 index 6c0e8438..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/P/index.html +++ /dev/null @@ -1,10 +0,0 @@ - -P (sidekick.Sidekick_arith_lia.S.A.S.P)

Module S.P

type t = proof

The abstract representation of a proof. A proof always proves a clause to be valid (true in every possible interpretation of the problem's assertions, and the theories)

type proof_step = proof_step

Identifier for a proof proof_rule (like a unique ID for a clause previously added/proved)

type term = T.Term.t
type lit = Lit.t
type proof_rule = t -> proof_step
include Sidekick_core.SAT_PROOF - with type t := t - and type lit := lit - and type proof_step := proof_step - and type proof_rule := proof_rule

A vector of steps

val enabled : t -> bool

Returns true if proof production is enabled

val emit_input_clause : lit Iter.t -> proof_rule

Emit an input clause.

val emit_redundant_clause : lit Iter.t -> hyps:proof_step Iter.t -> proof_rule

Emit a clause deduced by the SAT solver, redundant wrt previous clauses. The clause must be RUP wrt hyps.

val emit_unsat_core : lit Iter.t -> proof_rule

Produce a proof of the empty clause given this subset of the assumptions. FIXME: probably needs the list of proof_step that disprove the lits?

val emit_unsat : proof_step -> t -> unit

Signal "unsat" result at the given proof

val del_clause : proof_step -> lit Iter.t -> t -> unit

Forget a clause. Only useful for performance considerations.

val lemma_cc : lit Iter.t -> proof_rule

lemma_cc proof lits asserts that lits form a tautology for the theory of uninterpreted functions.

val define_term : term -> term -> proof_rule

define_term cst u proof defines the new constant cst as being equal to u. The result is a proof of the clause cst = u

val proof_p1 : proof_step -> proof_step -> proof_rule

proof_p1 p1 p2, where p1 proves the unit clause t=u (t:bool) and p2 proves C \/ t, is the rule that produces C \/ u, i.e unit paramodulation.

val proof_r1 : proof_step -> proof_step -> proof_rule

proof_r1 p1 p2, where p1 proves the unit clause |- t (t:bool) and p2 proves C \/ ¬t, is the rule that produces C \/ u, i.e unit resolution.

val proof_res : pivot:term -> proof_step -> proof_step -> proof_rule

proof_res ~pivot p1 p2, where p1 proves the clause |- C \/ l and p2 proves D \/ ¬l, where l is either pivot or ¬pivot, is the rule that produces C \/ D, i.e boolean resolution.

val with_defs : proof_step -> proof_step Iter.t -> proof_rule

with_defs pr defs specifies that pr is valid only in a context where the definitions defs are present.

val lemma_true : term -> proof_rule

lemma_true (true) p asserts the clause (true)

val lemma_preprocess : term -> term -> using:proof_step Iter.t -> proof_rule

lemma_preprocess t u ~using p asserts that t = u is a tautology and that t has been preprocessed into u.

The theorem /\_{eqn in using} eqn |- t=u is proved using congruence closure, and then resolved against the clauses using to obtain a unit equality.

From now on, t and u will be used interchangeably.

  • returns

    a proof_rule ID for the clause (t=u).

val lemma_rw_clause : - proof_step -> - res:lit Iter.t -> - using:proof_step Iter.t -> - proof_rule

lemma_rw_clause prc ~res ~using, where prc is the proof of |- c, uses the equations |- p_i = q_i from using to rewrite some literals of c into res. This is used to preprocess literals of a clause (using lemma_preprocess individually).

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/Registry/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/Registry/index.html deleted file mode 100644 index 75144380..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/Registry/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Registry (sidekick.Sidekick_arith_lia.S.A.S.Registry)

Module S.Registry

type t
type 'a key
val create_key : unit -> 'a key

Call this statically, typically at program initialization, for each distinct key.

val create : unit -> t
val get : t -> 'a key -> 'a option
val set : t -> 'a key -> 'a -> unit
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/Solver_internal/CC/Actions/P/Step_vec/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/Solver_internal/CC/Actions/P/Step_vec/index.html deleted file mode 100644 index 0fbfaf63..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/Solver_internal/CC/Actions/P/Step_vec/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Step_vec (sidekick.Sidekick_arith_lia.S.A.S.Solver_internal.CC.Actions.P.Step_vec)

Module P.Step_vec

A vector of steps

include Sidekick_util.Vec_sig.BASE with type elt = proof_step
include Sidekick_util.Vec_sig.BASE_RO with type elt = proof_step
type elt = proof_step
type t
val size : t -> int
val get : t -> int -> elt
val iter : f:( elt -> unit ) -> t -> unit
val iteri : f:( int -> elt -> unit ) -> t -> unit
val create : ?cap:int -> unit -> t
val clear : t -> unit
val copy : t -> t
val is_empty : t -> bool
val push : t -> elt -> unit
val fast_remove : t -> int -> unit

Remove element at index i without preserving order (swap with last element)

val filter_in_place : ( elt -> bool ) -> t -> unit
val ensure_size : t -> int -> unit
val pop : t -> elt
val set : t -> int -> elt -> unit
val shrink : t -> int -> unit
include Sidekick_util.Vec_sig.EXTENSIONS with type t := t and type elt := elt
val to_iter : t -> elt Iter.t
val to_array : t -> elt array
val fold_left : ( 'a -> elt -> 'a ) -> 'a -> t -> 'a
val pp : elt CCFormat.printer -> t CCFormat.printer
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/Solver_internal/CC/Actions/P/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/Solver_internal/CC/Actions/P/index.html deleted file mode 100644 index b1916fc7..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/Solver_internal/CC/Actions/P/index.html +++ /dev/null @@ -1,10 +0,0 @@ - -P (sidekick.Sidekick_arith_lia.S.A.S.Solver_internal.CC.Actions.P)

Module Actions.P

type t = proof

The abstract representation of a proof. A proof always proves a clause to be valid (true in every possible interpretation of the problem's assertions, and the theories)

type proof_step = proof_step

Identifier for a proof proof_rule (like a unique ID for a clause previously added/proved)

type term = T.Term.t
type lit = Lit.t
type proof_rule = t -> proof_step
include Sidekick_core.SAT_PROOF - with type t := t - and type lit := lit - and type proof_step := proof_step - and type proof_rule := proof_rule

A vector of steps

val enabled : t -> bool

Returns true if proof production is enabled

val emit_input_clause : lit Iter.t -> proof_rule

Emit an input clause.

val emit_redundant_clause : lit Iter.t -> hyps:proof_step Iter.t -> proof_rule

Emit a clause deduced by the SAT solver, redundant wrt previous clauses. The clause must be RUP wrt hyps.

val emit_unsat_core : lit Iter.t -> proof_rule

Produce a proof of the empty clause given this subset of the assumptions. FIXME: probably needs the list of proof_step that disprove the lits?

val emit_unsat : proof_step -> t -> unit

Signal "unsat" result at the given proof

val del_clause : proof_step -> lit Iter.t -> t -> unit

Forget a clause. Only useful for performance considerations.

val lemma_cc : lit Iter.t -> proof_rule

lemma_cc proof lits asserts that lits form a tautology for the theory of uninterpreted functions.

val define_term : term -> term -> proof_rule

define_term cst u proof defines the new constant cst as being equal to u. The result is a proof of the clause cst = u

val proof_p1 : proof_step -> proof_step -> proof_rule

proof_p1 p1 p2, where p1 proves the unit clause t=u (t:bool) and p2 proves C \/ t, is the rule that produces C \/ u, i.e unit paramodulation.

val proof_r1 : proof_step -> proof_step -> proof_rule

proof_r1 p1 p2, where p1 proves the unit clause |- t (t:bool) and p2 proves C \/ ¬t, is the rule that produces C \/ u, i.e unit resolution.

val proof_res : pivot:term -> proof_step -> proof_step -> proof_rule

proof_res ~pivot p1 p2, where p1 proves the clause |- C \/ l and p2 proves D \/ ¬l, where l is either pivot or ¬pivot, is the rule that produces C \/ D, i.e boolean resolution.

val with_defs : proof_step -> proof_step Iter.t -> proof_rule

with_defs pr defs specifies that pr is valid only in a context where the definitions defs are present.

val lemma_true : term -> proof_rule

lemma_true (true) p asserts the clause (true)

val lemma_preprocess : term -> term -> using:proof_step Iter.t -> proof_rule

lemma_preprocess t u ~using p asserts that t = u is a tautology and that t has been preprocessed into u.

The theorem /\_{eqn in using} eqn |- t=u is proved using congruence closure, and then resolved against the clauses using to obtain a unit equality.

From now on, t and u will be used interchangeably.

  • returns

    a proof_rule ID for the clause (t=u).

val lemma_rw_clause : - proof_step -> - res:lit Iter.t -> - using:proof_step Iter.t -> - proof_rule

lemma_rw_clause prc ~res ~using, where prc is the proof of |- c, uses the equations |- p_i = q_i from using to rewrite some literals of c into res. This is used to preprocess literals of a clause (using lemma_preprocess individually).

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/Solver_internal/CC/Actions/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/Solver_internal/CC/Actions/index.html deleted file mode 100644 index aa152101..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/Solver_internal/CC/Actions/index.html +++ /dev/null @@ -1,15 +0,0 @@ - -Actions (sidekick.Sidekick_arith_lia.S.A.S.Solver_internal.CC.Actions)

Module CC.Actions

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

An action handle. It is used by the congruence closure to perform the actions below. How it performs the actions is not specified and is solver-specific.

val proof : t -> proof
val raise_conflict : t -> Lit.t list -> proof_step -> 'a

raise_conflict acts c pr declares that c is a tautology of the theory of congruence. This does not return (it should raise an exception).

  • parameter pr

    the proof of c being a tautology

val raise_semantic_conflict : - t -> - Lit.t list -> - (bool * T.Term.t * T.Term.t) list -> - 'a

raise_semantic_conflict acts lits same_val declares that the conjunction of all lits (literals true in current trail) and tuples {=,≠}, t_i, u_i implies false.

The {=,≠}, t_i, u_i are pairs of terms with the same value (if = / true) or distinct value (if ≠ / false)) in the current model.

This does not return. It should raise an exception.

val propagate : - t -> - Lit.t -> - reason:( unit -> Lit.t list * proof_step ) -> - unit

propagate acts lit ~reason pr declares that reason() => lit is a tautology.

  • reason() should return a list of literals that are currently true.
  • lit should be a literal of interest (see CC_S.set_as_lit).

This function might never be called, a congruence closure has the right to not propagate and only trigger conflicts.

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/Solver_internal/CC/Expl/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/Solver_internal/CC/Expl/index.html deleted file mode 100644 index 63005105..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/Solver_internal/CC/Expl/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Expl (sidekick.Sidekick_arith_lia.S.A.S.Solver_internal.CC.Expl)

Module CC.Expl

Explanations

Explanations are specialized proofs, created by the congruence closure when asked to justify why 2 terms are equal.

type t
val pp : t Sidekick_core.Fmt.printer
val mk_merge : N.t -> N.t -> t

Explanation: the nodes were explicitly merged

val mk_merge_t : term -> term -> t

Explanation: the terms were explicitly merged

val mk_lit : lit -> t

Explanation: we merged t and u because of literal t=u, or we merged t and true because of literal t, or t and false because of literal ¬t

val mk_same_value : N.t -> N.t -> t
val mk_list : t list -> t

Conjunction of explanations

val mk_theory : term -> term -> (term * term * t list) list -> proof_step -> t

mk_theory t u expl_sets pr builds a theory explanation for why |- t=u. It depends on sub-explanations expl_sets which are tuples (t_i, u_i, expls_i) where expls_i are explanations that justify t_i = u_i in the current congruence closure.

The proof pr is the theory lemma, of the form (t_i = u_i)_i |- t=u . It is resolved against each expls_i |- t_i=u_i obtained from expl_sets, on pivot t_i=u_i, to obtain a proof of Gamma |- t=u where Gamma is a subset of the literals asserted into the congruence closure.

For example for the lemma a=b deduced by injectivity from Some a=Some b in the theory of datatypes, the arguments would be a, b, [Some a, Some b, mk_merge_t (Some a)(Some b)], pr where pr is the injectivity lemma Some a=Some b |- a=b.

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/Solver_internal/CC/N/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/Solver_internal/CC/N/index.html deleted file mode 100644 index cdf3860e..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/Solver_internal/CC/N/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -N (sidekick.Sidekick_arith_lia.S.A.S.Solver_internal.CC.N)

Module CC.N

Equivalence classes.

An equivalence class is a set of terms that are currently equal in the partial model built by the solver. The class is represented by a collection of nodes, one of which is distinguished and is called the "representative".

All information pertaining to the whole equivalence class is stored in this representative's node.

When two classes become equal (are "merged"), one of the two representatives is picked as the representative of the new class. The new class contains the union of the two old classes' nodes.

We also allow theories to store additional information in the representative. This information can be used when two classes are merged, to detect conflicts and solve equations à la Shostak.

type t

An equivalent class, containing terms that are proved to be equal.

A value of type t points to a particular term, but see find to get the representative of the class.

val term : t -> term

Term contained in this equivalence class. If is_root n, then term n is the class' representative term.

val equal : t -> t -> bool

Are two classes physically equal? To check for logical equality, use CC.N.equal (CC.find cc n1) (CC.find cc n2) which checks for equality of representatives.

val hash : t -> int

An opaque hash of this node.

val pp : t Sidekick_core.Fmt.printer

Unspecified printing of the node, for example its term, a unique ID, etc.

val is_root : t -> bool

Is the node a root (ie the representative of its class)? See find to get the root.

val iter_class : t -> t Iter.t

Traverse the congruence class. Precondition: is_root n (see find below)

val iter_parents : t -> t Iter.t

Traverse the parents of the class. Precondition: is_root n (see find below)

type bitfield

A field in the bitfield of this node. This should only be allocated when a theory is initialized.

Bitfields are accessed using preallocated keys. See CC_S.allocate_bitfield.

All fields are initially 0, are backtracked automatically, and are merged automatically when classes are merged.

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/Solver_internal/CC/P/Step_vec/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/Solver_internal/CC/P/Step_vec/index.html deleted file mode 100644 index ec479c03..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/Solver_internal/CC/P/Step_vec/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Step_vec (sidekick.Sidekick_arith_lia.S.A.S.Solver_internal.CC.P.Step_vec)

Module P.Step_vec

A vector of steps

include Sidekick_util.Vec_sig.BASE with type elt = proof_step
include Sidekick_util.Vec_sig.BASE_RO with type elt = proof_step
type elt = proof_step
type t
val size : t -> int
val get : t -> int -> elt
val iter : f:( elt -> unit ) -> t -> unit
val iteri : f:( int -> elt -> unit ) -> t -> unit
val create : ?cap:int -> unit -> t
val clear : t -> unit
val copy : t -> t
val is_empty : t -> bool
val push : t -> elt -> unit
val fast_remove : t -> int -> unit

Remove element at index i without preserving order (swap with last element)

val filter_in_place : ( elt -> bool ) -> t -> unit
val ensure_size : t -> int -> unit
val pop : t -> elt
val set : t -> int -> elt -> unit
val shrink : t -> int -> unit
include Sidekick_util.Vec_sig.EXTENSIONS with type t := t and type elt := elt
val to_iter : t -> elt Iter.t
val to_array : t -> elt array
val fold_left : ( 'a -> elt -> 'a ) -> 'a -> t -> 'a
val pp : elt CCFormat.printer -> t CCFormat.printer
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/Solver_internal/CC/P/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/Solver_internal/CC/P/index.html deleted file mode 100644 index dbda9244..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/Solver_internal/CC/P/index.html +++ /dev/null @@ -1,10 +0,0 @@ - -P (sidekick.Sidekick_arith_lia.S.A.S.Solver_internal.CC.P)

Module CC.P

type t = proof

The abstract representation of a proof. A proof always proves a clause to be valid (true in every possible interpretation of the problem's assertions, and the theories)

type proof_step = proof_step

Identifier for a proof proof_rule (like a unique ID for a clause previously added/proved)

type term
type lit = lit
type proof_rule = t -> proof_step
include Sidekick_core.SAT_PROOF - with type t := t - and type lit := lit - and type proof_step := proof_step - and type proof_rule := proof_rule

A vector of steps

val enabled : t -> bool

Returns true if proof production is enabled

val emit_input_clause : lit Iter.t -> proof_rule

Emit an input clause.

val emit_redundant_clause : lit Iter.t -> hyps:proof_step Iter.t -> proof_rule

Emit a clause deduced by the SAT solver, redundant wrt previous clauses. The clause must be RUP wrt hyps.

val emit_unsat_core : lit Iter.t -> proof_rule

Produce a proof of the empty clause given this subset of the assumptions. FIXME: probably needs the list of proof_step that disprove the lits?

val emit_unsat : proof_step -> t -> unit

Signal "unsat" result at the given proof

val del_clause : proof_step -> lit Iter.t -> t -> unit

Forget a clause. Only useful for performance considerations.

val lemma_cc : lit Iter.t -> proof_rule

lemma_cc proof lits asserts that lits form a tautology for the theory of uninterpreted functions.

val define_term : term -> term -> proof_rule

define_term cst u proof defines the new constant cst as being equal to u. The result is a proof of the clause cst = u

val proof_p1 : proof_step -> proof_step -> proof_rule

proof_p1 p1 p2, where p1 proves the unit clause t=u (t:bool) and p2 proves C \/ t, is the rule that produces C \/ u, i.e unit paramodulation.

val proof_r1 : proof_step -> proof_step -> proof_rule

proof_r1 p1 p2, where p1 proves the unit clause |- t (t:bool) and p2 proves C \/ ¬t, is the rule that produces C \/ u, i.e unit resolution.

val proof_res : pivot:term -> proof_step -> proof_step -> proof_rule

proof_res ~pivot p1 p2, where p1 proves the clause |- C \/ l and p2 proves D \/ ¬l, where l is either pivot or ¬pivot, is the rule that produces C \/ D, i.e boolean resolution.

val with_defs : proof_step -> proof_step Iter.t -> proof_rule

with_defs pr defs specifies that pr is valid only in a context where the definitions defs are present.

val lemma_true : term -> proof_rule

lemma_true (true) p asserts the clause (true)

val lemma_preprocess : term -> term -> using:proof_step Iter.t -> proof_rule

lemma_preprocess t u ~using p asserts that t = u is a tautology and that t has been preprocessed into u.

The theorem /\_{eqn in using} eqn |- t=u is proved using congruence closure, and then resolved against the clauses using to obtain a unit equality.

From now on, t and u will be used interchangeably.

  • returns

    a proof_rule ID for the clause (t=u).

val lemma_rw_clause : - proof_step -> - res:lit Iter.t -> - using:proof_step Iter.t -> - proof_rule

lemma_rw_clause prc ~res ~using, where prc is the proof of |- c, uses the equations |- p_i = q_i from using to rewrite some literals of c into res. This is used to preprocess literals of a clause (using lemma_preprocess individually).

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/Solver_internal/CC/Resolved_expl/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/Solver_internal/CC/Resolved_expl/index.html deleted file mode 100644 index 756cb973..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/Solver_internal/CC/Resolved_expl/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Resolved_expl (sidekick.Sidekick_arith_lia.S.A.S.Solver_internal.CC.Resolved_expl)

Module CC.Resolved_expl

Resolved explanations.

The congruence closure keeps explanations for why terms are in the same class. However these are represented in a compact, cheap form. To use these explanations we need to resolve them into a resolved explanation, typically a list of literals that are true in the current trail and are responsible for merges.

However, we can also have merged classes because they have the same value in the current model.

type t = {
lits : lit list;
same_value : (N.t * N.t) list;
pr : proof -> proof_step;
}
val is_semantic : t -> bool

is_semantic expl is true if there's at least one pair in expl.same_value.

val pp : t Sidekick_core.Fmt.printer
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/Solver_internal/CC/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/Solver_internal/CC/index.html deleted file mode 100644 index 3c7b2aa7..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/Solver_internal/CC/index.html +++ /dev/null @@ -1,25 +0,0 @@ - -CC (sidekick.Sidekick_arith_lia.S.A.S.Solver_internal.CC)

Module Solver_internal.CC

Congruence closure instance

first, some aliases.

module T = T
module Lit = Lit
type proof = proof
type proof_step = proof_step
module P : - Sidekick_core.PROOF - with type lit = Lit.t - and type t = proof - and type proof_step = proof_step - with type t = proof - with type lit = lit
module Actions : - Sidekick_core.CC_ACTIONS - with module T = T - and module Lit = Lit - and type proof = proof - and type proof_step = proof_step - with type t = theory_actions
type term_store = T.Term.store
type term = T.Term.t
type value = term
type fun_ = T.Fun.t
type lit = Lit.t
type actions = Actions.t
type t

The congruence closure object. It contains a fair amount of state and is mutable and backtrackable.

module N : sig ... end

Equivalence classes.

module Expl : sig ... end

Explanations

module Resolved_expl : sig ... end

Resolved explanations.

type node = N.t

A node of the congruence closure

type repr = N.t

Node that is currently a representative

type explanation = Expl.t

Accessors

val term_store : t -> term_store
val proof : t -> proof
val find : t -> node -> repr

Current representative

val add_term : t -> term -> node

Add the term to the congruence closure, if not present already. Will be backtracked.

val mem_term : t -> term -> bool

Returns true if the term is explicitly present in the congruence closure

Events

Events triggered by the congruence closure, to which other plugins can subscribe.

type ev_on_pre_merge = t -> actions -> N.t -> N.t -> Expl.t -> unit

ev_on_pre_merge cc acts n1 n2 expl is called right before n1 and n2 are merged with explanation expl.

type ev_on_post_merge = t -> actions -> N.t -> N.t -> unit

ev_on_post_merge cc acts n1 n2 is called right after n1 and n2 were merged. find cc n1 and find cc n2 will return the same node.

type ev_on_new_term = t -> N.t -> term -> unit

ev_on_new_term cc n t is called whenever a new term t is added to the congruence closure. Its node is n.

type ev_on_conflict = t -> th:bool -> lit list -> unit

ev_on_conflict acts ~th c is called when the congruence closure triggers a conflict by asserting the tautology c.

  • parameter th

    true if the explanation for this conflict involves at least one "theory" explanation; i.e. some of the equations participating in the conflict are purely syntactic theories like injectivity of constructors.

type ev_on_propagate = t -> lit -> ( unit -> lit list * proof_step ) -> unit

ev_on_propagate cc lit reason is called whenever reason() => lit is a propagated lemma. See CC_ACTIONS.propagate.

type ev_on_is_subterm = N.t -> term -> unit

ev_on_is_subterm n t is called when n is a subterm of another node for the first time. t is the term corresponding to the node n. This can be useful for theory combination.

val create : - ?stat:Sidekick_util.Stat.t -> - ?on_pre_merge:ev_on_pre_merge list -> - ?on_post_merge:ev_on_post_merge list -> - ?on_new_term:ev_on_new_term list -> - ?on_conflict:ev_on_conflict list -> - ?on_propagate:ev_on_propagate list -> - ?on_is_subterm:ev_on_is_subterm list -> - ?size:[ `Small | `Big ] -> - term_store -> - proof -> - t

Create a new congruence closure.

  • parameter term_store

    used to be able to create new terms. All terms interacting with this congruence closure must belong in this term state as well.

val allocate_bitfield : descr:string -> t -> N.bitfield

Allocate a new node field (see N.bitfield).

This field descriptor is henceforth reserved for all nodes in this congruence closure, and can be set using set_bitfield for each node individually. This can be used to efficiently store some metadata on nodes (e.g. "is there a numeric value in the class" or "is there a constructor term in the class").

There may be restrictions on how many distinct fields are allocated for a given congruence closure (e.g. at most Sys.int_size fields).

val get_bitfield : t -> N.bitfield -> N.t -> bool

Access the bit field of the given node

val set_bitfield : t -> N.bitfield -> bool -> N.t -> unit

Set the bitfield for the node. This will be backtracked. See N.bitfield.

val on_pre_merge : t -> ev_on_pre_merge -> unit

Add a function to be called when two classes are merged

val on_post_merge : t -> ev_on_post_merge -> unit

Add a function to be called when two classes are merged

val on_new_term : t -> ev_on_new_term -> unit

Add a function to be called when a new node is created

val on_conflict : t -> ev_on_conflict -> unit

Called when the congruence closure finds a conflict

val on_propagate : t -> ev_on_propagate -> unit

Called when the congruence closure propagates a literal

val on_is_subterm : t -> ev_on_is_subterm -> unit

Called on terms that are subterms of function symbols

val set_as_lit : t -> N.t -> lit -> unit

map the given node to a literal.

val find_t : t -> term -> repr

Current representative of the term.

  • raises Not_found

    if the term is not already add-ed.

val add_seq : t -> term Iter.t -> unit

Add a sequence of terms to the congruence closure

val all_classes : t -> repr Iter.t

All current classes. This is costly, only use if there is no other solution

val assert_lit : t -> lit -> unit

Given a literal, assume it in the congruence closure and propagate its consequences. Will be backtracked.

Useful for the theory combination or the SAT solver's functor

val assert_lits : t -> lit Iter.t -> unit

Addition of many literals

val explain_eq : t -> N.t -> N.t -> Resolved_expl.t

Explain why the two nodes are equal. Fails if they are not, in an unspecified way.

val raise_conflict_from_expl : t -> actions -> Expl.t -> 'a

Raise a conflict with the given explanation. It must be a theory tautology that expl ==> absurd. To be used in theories.

This fails in an unspecified way if the explanation, once resolved, satisfies Resolved_expl.is_semantic.

val n_true : t -> N.t

Node for true

val n_false : t -> N.t

Node for false

val n_bool : t -> bool -> N.t

Node for either true or false

val merge : t -> N.t -> N.t -> Expl.t -> unit

Merge these two nodes given this explanation. It must be a theory tautology that expl ==> n1 = n2. To be used in theories.

val merge_t : t -> term -> term -> Expl.t -> unit

Shortcut for adding + merging

val set_model_value : t -> term -> value -> unit

Set the value of a term in the model.

val with_model_mode : t -> ( unit -> 'a ) -> 'a

Enter model combination mode.

val get_model_for_each_class : t -> (repr * N.t Iter.t * value) Iter.t

In model combination mode, obtain classes with their values.

val check : t -> actions -> unit

Perform all pending operations done via assert_eq, assert_lit, etc. Will use the actions to propagate literals, declare conflicts, etc.

val push_level : t -> unit

Push backtracking level

val pop_levels : t -> int -> unit

Restore to state n calls to push_level earlier. Used during backtracking.

val get_model : t -> N.t Iter.t Iter.t

get all the equivalence classes so they can be merged in the model

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/Solver_internal/Registry/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/Solver_internal/Registry/index.html deleted file mode 100644 index 545672c8..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/Solver_internal/Registry/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Registry (sidekick.Sidekick_arith_lia.S.A.S.Solver_internal.Registry)

Module Solver_internal.Registry

type t
type 'a key
val create_key : unit -> 'a key

Call this statically, typically at program initialization, for each distinct key.

val create : unit -> t
val get : t -> 'a key -> 'a option
val set : t -> 'a key -> 'a -> unit
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/Solver_internal/Simplify/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/Solver_internal/Simplify/index.html deleted file mode 100644 index af4fbf1e..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/Solver_internal/Simplify/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Simplify (sidekick.Sidekick_arith_lia.S.A.S.Solver_internal.Simplify)

Module Solver_internal.Simplify

Simplify terms

type t
val tst : t -> term_store
val ty_st : t -> ty_store
val clear : t -> unit

Reset internal cache, etc.

val proof : t -> proof

Access proof

type hook = t -> term -> (term * proof_step Iter.t) option

Given a term, try to simplify it. Return None if it didn't change.

A simple example could be a hook that takes a term t, and if t is app "+" (const x) (const y) where x and y are number, returns Some (const (x+y)), and None otherwise.

The simplifier will take care of simplifying the resulting term further, caching (so that work is not duplicated in subterms), etc.

val normalize : t -> term -> (term * proof_step) option

Normalize a term using all the hooks. This performs a fixpoint, i.e. it only stops when no hook applies anywhere inside the term.

val normalize_t : t -> term -> term * proof_step option

Normalize a term using all the hooks, along with a proof that the simplification is correct. returns t, ø if no simplification occurred.

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/Solver_internal/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/Solver_internal/index.html deleted file mode 100644 index f0dae0dc..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/Solver_internal/index.html +++ /dev/null @@ -1,43 +0,0 @@ - -Solver_internal (sidekick.Sidekick_arith_lia.S.A.S.Solver_internal)

Module S.Solver_internal

Internal solver, available to theories.

module T = T
module Lit = Lit
type ty = T.Ty.t
type term = T.Term.t
type value = T.Term.t
type term_store = T.Term.store
type ty_store = T.Ty.store
type clause_pool
type proof = proof
type proof_step = proof_step
module P = P
type t

Main type for a solver

type solver = t
val tst : t -> term_store
val ty_st : t -> ty_store
val stats : t -> Sidekick_util.Stat.t
val proof : t -> proof

Access the proof object

Registry

val registry : t -> Registry.t

A solver contains a registry so that theories can share data

Actions for the theories

type theory_actions

Handle that the theories can use to perform actions.

type lit = Lit.t

Congruence Closure

module CC : - Sidekick_core.CC_S - with module T = T - and module Lit = Lit - and type proof = proof - and type proof_step = proof_step - and type P.t = proof - and type P.lit = lit - and type Actions.t = theory_actions

Congruence closure instance

val cc : t -> CC.t

Congruence closure for this solver

Simplifiers

module Simplify : sig ... end

Simplify terms

type simplify_hook = Simplify.hook
val add_simplifier : t -> Simplify.hook -> unit

Add a simplifier hook for preprocessing.

val simplify_t : t -> term -> (term * proof_step) option

Simplify input term, returns Some u if some simplification occurred.

val simp_t : t -> term -> term * proof_step option

simp_t si t returns u even if no simplification occurred (in which case t == u syntactically). It emits |- t=u. (see simplifier)

Preprocessors

These preprocessors turn mixed, raw literals (possibly simplified) into literals suitable for reasoning. Typically some clauses are also added to the solver.

module type PREPROCESS_ACTS = sig ... end
type preprocess_actions = (module PREPROCESS_ACTS)

Actions available to the preprocessor

type preprocess_hook = t -> preprocess_actions -> term -> unit

Given a term, preprocess it.

The idea is to add literals and clauses to help define the meaning of the term, if needed. For example for boolean formulas, clauses for their Tseitin encoding can be added, with the formula acting as its own proxy symbol.

  • parameter preprocess_actions

    actions available during preprocessing.

val on_preprocess : t -> preprocess_hook -> unit

Add a hook that will be called when terms are preprocessed

hooks for the theory

val raise_conflict : t -> theory_actions -> lit list -> proof_step -> 'a

Give a conflict clause to the solver

val push_decision : t -> theory_actions -> lit -> unit

Ask the SAT solver to decide the given literal in an extension of the current trail. This is useful for theory combination. If the SAT solver backtracks, this (potential) decision is removed and forgotten.

val propagate : - t -> - theory_actions -> - lit -> - reason:( unit -> lit list * proof_step ) -> - unit

Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology

val propagate_l : t -> theory_actions -> lit -> lit list -> proof_step -> unit

Propagate a boolean using a unit clause. expl => lit must be a theory lemma, that is, a T-tautology

val add_clause_temp : t -> theory_actions -> lit list -> proof_step -> unit

Add local clause to the SAT solver. This clause will be removed when the solver backtracks.

val add_clause_permanent : - t -> - theory_actions -> - lit list -> - proof_step -> - unit

Add toplevel clause to the SAT solver. This clause will not be backtracked.

val mk_lit : t -> theory_actions -> ?sign:bool -> term -> lit

Create a literal. This automatically preprocesses the term.

val add_lit : t -> theory_actions -> ?default_pol:bool -> lit -> unit

Add the given literal to the SAT solver, so it gets assigned a boolean value.

  • parameter default_pol

    default polarity for the corresponding atom

val add_lit_t : t -> theory_actions -> ?sign:bool -> term -> unit

Add the given (signed) bool term to the SAT solver, so it gets assigned a boolean value

val cc_raise_conflict_expl : t -> theory_actions -> CC.Expl.t -> 'a

Raise a conflict with the given congruence closure explanation. it must be a theory tautology that expl ==> absurd. To be used in theories.

val cc_find : t -> CC.N.t -> CC.N.t

Find representative of the node

val cc_are_equal : t -> term -> term -> bool

Are these two terms equal in the congruence closure?

val cc_merge : t -> theory_actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit

Merge these two nodes in the congruence closure, given this explanation. It must be a theory tautology that expl ==> n1 = n2. To be used in theories.

val cc_merge_t : t -> theory_actions -> term -> term -> CC.Expl.t -> unit

Merge these two terms in the congruence closure, given this explanation. See cc_merge

val cc_add_term : t -> term -> CC.N.t

Add/retrieve congruence closure node for this term. To be used in theories

val cc_mem_term : t -> term -> bool

Return true if the term is explicitly in the congruence closure. To be used in theories

val on_cc_pre_merge : - t -> - ( CC.t -> theory_actions -> CC.N.t -> CC.N.t -> CC.Expl.t -> unit ) -> - unit

Callback for when two classes containing data for this key are merged (called before)

val on_cc_post_merge : - t -> - ( CC.t -> theory_actions -> CC.N.t -> CC.N.t -> unit ) -> - unit

Callback for when two classes containing data for this key are merged (called after)

val on_cc_new_term : t -> ( CC.t -> CC.N.t -> term -> unit ) -> unit

Callback to add data on terms when they are added to the congruence closure

val on_cc_is_subterm : t -> ( CC.N.t -> term -> unit ) -> unit

Callback for when a term is a subterm of another term in the congruence closure

val on_cc_conflict : t -> ( CC.t -> th:bool -> lit list -> unit ) -> unit

Callback called on every CC conflict

val on_cc_propagate : - t -> - ( CC.t -> lit -> ( unit -> lit list * proof_step ) -> unit ) -> - unit

Callback called on every CC propagation

val on_partial_check : - t -> - ( t -> theory_actions -> lit Iter.t -> unit ) -> - unit

Register callbacked to be called with the slice of literals newly added on the trail.

This is called very often and should be efficient. It doesn't have to be complete, only correct. It's given only the slice of the trail consisting in new literals.

val on_final_check : t -> ( t -> theory_actions -> lit Iter.t -> unit ) -> unit

Register callback to be called during the final check.

Must be complete (i.e. must raise a conflict if the set of literals is not satisfiable) and can be expensive. The function is given the whole trail.

val on_th_combination : - t -> - ( t -> theory_actions -> (term * value) Iter.t ) -> - unit

Add a hook called during theory combination. The hook must return an iterator of pairs (t, v) which mean that term t has value v in the model.

Terms with the same value (according to Term.equal) will be merged in the CC; if two terms with different values are merged, we get a semantic conflict and must pick another model.

val declare_pb_is_incomplete : t -> unit

Declare that, in some theory, the problem is outside the logic fragment that is decidable (e.g. if we meet proper NIA formulas). The solver will not reply "SAT" from now on.

Model production

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

A model-production hook to query values from a theory.

It takes the solver, a class, and returns a term for this class. For example, an arithmetic theory might detect that a class contains a numeric constant, and return this constant as a model value.

If no hook assigns a value to a class, a fake value is created for it.

type model_completion_hook = t -> add:( term -> term -> unit ) -> unit

A model production hook, for the theory to add values. The hook is given a add function to add bindings to the model.

val on_model : - ?ask:model_ask_hook -> - ?complete:model_completion_hook -> - t -> - unit

Add model production/completion hooks.

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/Solver_internal/module-type-PREPROCESS_ACTS/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/Solver_internal/module-type-PREPROCESS_ACTS/index.html deleted file mode 100644 index 75c1098c..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/Solver_internal/module-type-PREPROCESS_ACTS/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -PREPROCESS_ACTS (sidekick.Sidekick_arith_lia.S.A.S.Solver_internal.PREPROCESS_ACTS)

Module type Solver_internal.PREPROCESS_ACTS

val proof : proof
val mk_lit : ?sign:bool -> term -> lit

mk_lit t creates a new literal for a boolean term t.

val add_clause : lit list -> proof_step -> unit

pushes a new clause into the SAT solver.

val add_lit : ?default_pol:bool -> lit -> unit

Ensure the literal will be decided/handled by the SAT solver.

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/T/Fun/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/T/Fun/index.html deleted file mode 100644 index 5b0e668a..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/T/Fun/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Fun (sidekick.Sidekick_arith_lia.S.A.S.T.Fun)

Module T.Fun

A function symbol, like "f" or "plus" or "is_human" or "socrates"

type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/T/Term/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/T/Term/index.html deleted file mode 100644 index becdb62b..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/T/Term/index.html +++ /dev/null @@ -1,8 +0,0 @@ - -Term (sidekick.Sidekick_arith_lia.S.A.S.T.Term)

Module T.Term

Term structure.

Terms should be hashconsed, with perfect sharing. This allows, for example, Term.Tbl and Term.iter_dag to be efficient.

type t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store

A store used to create new terms. It is where the hashconsing table should live, along with other all-terms related store.

val ty : t -> Ty.t
val bool : store -> bool -> t

build true/false

val as_bool : t -> bool option

as_bool t is Some true if t is the term true, and similarly for false. For other terms it is None.

val abs : store -> t -> t * bool

abs t returns an "absolute value" for the term, along with the sign of t.

The idea is that we want to turn not a into (a, false), or (a != b) into (a=b, false). For terms without a negation this should return (t, true).

The store is passed in case a new term needs to be created.

val map_shallow : store -> ( t -> t ) -> t -> t

Map function on immediate subterms. This should not be recursive.

val iter_shallow : store -> ( t -> unit ) -> t -> unit

Iterate function on immediate subterms. This should not be recursive.

val iter_dag : t -> ( t -> unit ) -> unit

iter_dag t f calls f once on each subterm of t, t included. It must not traverse t as a tree, but rather as a perfectly shared DAG.

For example, in:

let x = 2 in
-let y = f x x in
-let z = g y x in
-z = z

the DAG has the following nodes:

n1: 2
-n2: f n1 n1
-n3: g n2 n1
-n4: = n3 n3
module Tbl : CCHashtbl.S with type key = t
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/T/Ty/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/T/Ty/index.html deleted file mode 100644 index 44d37ef0..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/T/Ty/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Ty (sidekick.Sidekick_arith_lia.S.A.S.T.Ty)

Module T.Ty

Types

Types should be comparable (ideally, in O(1)), and have at least a boolean type available.

type t
val equal : t -> t -> bool
val hash : t -> int
val pp : t Sidekick_core.Fmt.printer
type store
val bool : store -> t
val is_bool : t -> bool
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/T/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/T/index.html deleted file mode 100644 index 24c51303..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/T/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -T (sidekick.Sidekick_arith_lia.S.A.S.T)

Module S.T

module Fun : sig ... end

A function symbol, like "f" or "plus" or "is_human" or "socrates"

module Ty : sig ... end

Types

module Term : sig ... end

Term structure.

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/Unknown/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/Unknown/index.html deleted file mode 100644 index 7b546ec1..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/Unknown/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Unknown (sidekick.Sidekick_arith_lia.S.A.S.Unknown)

Module S.Unknown

type t
val pp : t CCFormat.printer
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/index.html deleted file mode 100644 index 61214000..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/index.html +++ /dev/null @@ -1,37 +0,0 @@ - -S (sidekick.Sidekick_arith_lia.S.A.S)

Module A.S

module Lit : Sidekick_core.LIT with module T = T
type proof
type proof_step
module P : - Sidekick_core.PROOF - with type lit = Lit.t - and type t = proof - and type proof_step = proof_step - 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 type proof_step = proof_step - 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

Value registry

val registry : t -> Registry.t

A solver contains a registry so that theories can share data

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 proof : t -> proof
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 -> proof_step -> 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 -> proof_step -> 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;(*

Unsat core (subset of assumptions), or empty

*)
unsat_proof_step : unit -> proof_step option;(*

Proof step for the empty clause

*)
}		(*

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 ) -> - ?should_stop:( t -> int -> bool ) -> - 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 should_stop

    a callback regularly called with the solver, and with a number of "steps" done since last call. The exact notion of step is not defined, but is guaranteed to increase regularly. The function should return true if it judges solving must stop (returning Unknown), false if solving can proceed.

  • parameter on_exit

    functions to be run before this returns

val last_res : t -> res option

Last result, if any. Some operations will erase this (e.g. assert_term).

val push_assumption : t -> lit -> unit

Pushes an assumption onto the assumption stack. It will remain there until it's pop'd by pop_assumptions.

val pop_assumptions : t -> int -> unit

pop_assumptions solver n removes n assumptions from the stack. It removes the assumptions that were the most recently added via push_assumptions. Note that check_sat_propagations_only can call this if it meets a conflict.

type propagation_result =
| PR_sat
| PR_conflict of {
backtracked : int;
}
| PR_unsat of {
unsat_core : unit -> lit Iter.t;
}
val check_sat_propagations_only : - assumptions:lit list -> - t -> - propagation_result

check_sat_propagations_only solver uses assumptions (including the assumptions parameter, and atoms previously added via push_assumptions) and boolean+theory propagation to quickly assess satisfiability. It is not complete; calling solve is required to get an accurate result.

  • returns

    one of:

    • PR_sat if the current state seems satisfiable
    • PR_conflict {backtracked=n} if a conflict was found and resolved, leading to backtracking n levels of assumptions
    • PR_unsat … if the assumptions were found to be unsatisfiable, with the given core.
val pp_stats : t CCFormat.printer

Print some statistics. What it prints exactly is unspecified.

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/module-type-THEORY/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/module-type-THEORY/index.html deleted file mode 100644 index fb4017fc..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/S/module-type-THEORY/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -THEORY (sidekick.Sidekick_arith_lia.S.A.S.THEORY)

Module type S.THEORY

A theory

Theories are abstracted over the concrete implementation of the solver, so they can work with any implementation.

Typically a theory should be a functor taking an argument containing a SOLVER_INTERNAL or even a full SOLVER, and some additional views on terms, literals, etc. that are specific to the theory (e.g. to map terms to linear expressions). The theory can then be instantiated on any kind of solver for any term representation that also satisfies the additional theory-specific requirements. Instantiated theories (ie values of type SOLVER.theory) can be added to the solver.

type t

The theory's state

val name : string

Name of the theory (ideally, unique and short)

val create_and_setup : Solver_internal.t -> t

Instantiate the theory's state for the given (internal) solver, register callbacks, create keys, etc.

Called once for every solver this theory is added to.

val push_level : t -> unit

Push backtracking level. When the corresponding pop is called, the theory's state should be restored to a state equivalent to what it was just before push_level.

it does not have to be exactly the same state, it just needs to be equivalent.

val pop_levels : t -> int -> unit

pop_levels theory n pops n backtracking levels, restoring theory to its state before calling push_level n times.

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/Z/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-S/A/Z/index.html deleted file mode 100644 index ff1a4430..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/Z/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Z (sidekick.Sidekick_arith_lia.S.A.Z)

Module A.Z

include Sidekick_arith.NUM
type t
val zero : t
val one : t
val minus_one : t
val abs : t -> t
val sign : t -> int
val of_int : int -> t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val pp : t CCFormat.printer
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
val succ : t -> t
val pred : t -> t
val gcd : t -> t -> t
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-S/A/index.html deleted file mode 100644 index 29faecf7..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-S/A/index.html +++ /dev/null @@ -1,3 +0,0 @@ - -A (sidekick.Sidekick_arith_lia.S.A)

Module S.A

module Z : INT
module Q : RATIONAL with type bigint = Z.t
module LRA_solver : - Sidekick_arith_lra.S with type A.Q.t = Q.t and module A.S = S
type term = S.T.Term.t
type ty = S.T.Ty.t
val view_as_lia : term -> ( Z.t, Q.t, term ) lia_view

Project the term into the theory view

val mk_bool : S.T.Term.store -> bool -> term
val mk_to_real : S.T.Term.store -> term -> term

Wrap term into a to_real projector to rationals

val mk_lia : S.T.Term.store -> ( Z.t, Q.t, term ) lia_view -> term

Make a term from the given theory view

val ty_int : S.T.Term.store -> ty
val mk_eq : S.T.Term.store -> term -> term -> term

syntactic equality

val has_ty_int : term -> bool

Does this term have the type Int

val lemma_lia : S.Lit.t Iter.t -> S.P.proof_rule
val lemma_relax_to_lra : S.Lit.t Iter.t -> S.P.proof_rule
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lia/module-type-S/index.html b/dev/sidekick/Sidekick_arith_lia/module-type-S/index.html deleted file mode 100644 index 001875d5..00000000 --- a/dev/sidekick/Sidekick_arith_lia/module-type-S/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -S (sidekick.Sidekick_arith_lia.S)

Module type Sidekick_arith_lia.S

module A : ARG
val theory : A.S.theory
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lra/Make/SimpSolver/index.html b/dev/sidekick/Sidekick_arith_lra/Make/SimpSolver/index.html index 35bde8e2..c1950beb 100644 --- a/dev/sidekick/Sidekick_arith_lra/Make/SimpSolver/index.html +++ b/dev/sidekick/Sidekick_arith_lra/Make/SimpSolver/index.html @@ -1,12 +1,11 @@ SimpSolver (sidekick.Sidekick_arith_lra.Make.SimpSolver)

Module Make.SimpSolver

Simplexe

module V_map : CCMap.S with type key = V.t
module Q : Sidekick_simplex.RATIONAL with type bigint = Z.t
type num = Q.t

Numbers

module Constraint : sig ... end
module Subst : sig ... end
type t
val create : ?stat:Sidekick_util.Stat.t -> unit -> t

Create a new simplex.

val push_level : t -> unit
val pop_levels : t -> int -> unit
val define : ?is_int:bool -> t -> V.t -> (num * V.t) list -> unit

Define a basic variable in terms of other variables. This is useful to "name" a linear expression and get back a variable that can be used in a Constraint.t

type unsat_cert
module Unsat_cert : sig ... end
exception E_unsat of Unsat_cert.t
type ev_on_propagate = V.lit -> reason:V.lit list -> unit
val add_var : ?is_int:bool -> t -> V.t -> unit

Make sure the variable exists in the simplex.

val add_constraint : - ?keep_on_backtracking:bool -> ?is_int:bool -> on_propagate:ev_on_propagate -> t -> Constraint.t -> V.lit -> - unit

Add a constraint to the simplex.

This is removed upon backtracking by default.

  • parameter is_int

    declares whether the constraint's variable is an integer

  • raises Unsat

    if it's immediately obvious that this is not satisfiable.

  • parameter keep_on_backtracking

    if true (default false), the bound is not backtrackable

val declare_bound : ?is_int:bool -> t -> Constraint.t -> V.lit -> unit

Declare that this constraint exists and map it to a literal, so we can possibly propagate it later. Unlike add_constraint this does NOT assert that the constraint is true

val check_exn : + unit

Add a constraint to the simplex.

This is removed upon backtracking by default.

  • parameter is_int

    declares whether the constraint's variable is an integer

  • raises Unsat

    if it's immediately obvious that this is not satisfiable.

val declare_bound : ?is_int:bool -> t -> Constraint.t -> V.lit -> unit

Declare that this constraint exists and map it to a literal, so we can possibly propagate it later. Unlike add_constraint this does NOT assert that the constraint is true

val check_exn : on_propagate:( V.lit -> reason:V.lit list -> unit ) -> t -> unit

Check the whole simplex for satisfiability.

  • parameter on_propagate

    is called with arguments lit, reason whenever reason => lit is found to be true by the simplex.

  • raises Unsat

    if the constraints are not satisfiable.

type result =
| Sat of Subst.t
| Unsat of Unsat_cert.t
val check : on_propagate:( V.lit -> reason:V.lit list -> unit ) -> t -> result

Call check_exn and return a model or a proof of unsat. This does NOT enforce that integer variables map to integer values.

val check_branch_and_bound : diff --git a/dev/sidekick/Sidekick_arith_lra/module-type-S/SimpSolver/index.html b/dev/sidekick/Sidekick_arith_lra/module-type-S/SimpSolver/index.html index 6f2a1acc..07f1d200 100644 --- a/dev/sidekick/Sidekick_arith_lra/module-type-S/SimpSolver/index.html +++ b/dev/sidekick/Sidekick_arith_lra/module-type-S/SimpSolver/index.html @@ -1,12 +1,11 @@ SimpSolver (sidekick.Sidekick_arith_lra.S.SimpSolver)

Module S.SimpSolver

Simplexe

module V_map : CCMap.S with type key = V.t
module Q : Sidekick_simplex.RATIONAL with type bigint = Z.t
type num = Q.t

Numbers

module Constraint : sig ... end
module Subst : sig ... end
type t
val create : ?stat:Sidekick_util.Stat.t -> unit -> t

Create a new simplex.

val push_level : t -> unit
val pop_levels : t -> int -> unit
val define : ?is_int:bool -> t -> V.t -> (num * V.t) list -> unit

Define a basic variable in terms of other variables. This is useful to "name" a linear expression and get back a variable that can be used in a Constraint.t

type unsat_cert
module Unsat_cert : sig ... end
exception E_unsat of Unsat_cert.t
type ev_on_propagate = V.lit -> reason:V.lit list -> unit
val add_var : ?is_int:bool -> t -> V.t -> unit

Make sure the variable exists in the simplex.

val add_constraint : - ?keep_on_backtracking:bool -> ?is_int:bool -> on_propagate:ev_on_propagate -> t -> Constraint.t -> V.lit -> - unit

Add a constraint to the simplex.

This is removed upon backtracking by default.

  • parameter is_int

    declares whether the constraint's variable is an integer

  • raises Unsat

    if it's immediately obvious that this is not satisfiable.

  • parameter keep_on_backtracking

    if true (default false), the bound is not backtrackable

val declare_bound : ?is_int:bool -> t -> Constraint.t -> V.lit -> unit

Declare that this constraint exists and map it to a literal, so we can possibly propagate it later. Unlike add_constraint this does NOT assert that the constraint is true

val check_exn : + unit

Add a constraint to the simplex.

This is removed upon backtracking by default.

  • parameter is_int

    declares whether the constraint's variable is an integer

  • raises Unsat

    if it's immediately obvious that this is not satisfiable.

val declare_bound : ?is_int:bool -> t -> Constraint.t -> V.lit -> unit

Declare that this constraint exists and map it to a literal, so we can possibly propagate it later. Unlike add_constraint this does NOT assert that the constraint is true

val check_exn : on_propagate:( V.lit -> reason:V.lit list -> unit ) -> t -> unit

Check the whole simplex for satisfiability.

  • parameter on_propagate

    is called with arguments lit, reason whenever reason => lit is found to be true by the simplex.

  • raises Unsat

    if the constraints are not satisfiable.

type result =
| Sat of Subst.t
| Unsat of Unsat_cert.t
val check : on_propagate:( V.lit -> reason:V.lit list -> unit ) -> t -> result

Call check_exn and return a model or a proof of unsat. This does NOT enforce that integer variables map to integer values.

val check_branch_and_bound : diff --git a/dev/sidekick/Sidekick_intsolver/.dummy b/dev/sidekick/Sidekick_intsolver/.dummy deleted file mode 100644 index e69de29b..00000000 diff --git a/dev/sidekick/Sidekick_intsolver/Make/Cert/index.html b/dev/sidekick/Sidekick_intsolver/Make/Cert/index.html deleted file mode 100644 index b6a5393d..00000000 --- a/dev/sidekick/Sidekick_intsolver/Make/Cert/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Cert (sidekick.Sidekick_intsolver.Make.Cert)

Module Make.Cert

type t
val pp : t Sidekick_util.Fmt.printer
val lits : t -> A.lit Iter.t
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_intsolver/Make/Model/index.html b/dev/sidekick/Sidekick_intsolver/Make/Model/index.html deleted file mode 100644 index e9dbebe0..00000000 --- a/dev/sidekick/Sidekick_intsolver/Make/Model/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Model (sidekick.Sidekick_intsolver.Make.Model)

Module Make.Model

type t
val pp : t Sidekick_util.Fmt.printer
val eval : t -> A.term -> A.Z.t option
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_intsolver/Make/Op/index.html b/dev/sidekick/Sidekick_intsolver/Make/Op/index.html deleted file mode 100644 index c40eacc6..00000000 --- a/dev/sidekick/Sidekick_intsolver/Make/Op/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Op (sidekick.Sidekick_intsolver.Make.Op)

Module Make.Op

type t =
| Leq
| Lt
| Eq
val pp : t Sidekick_util.Fmt.printer
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_intsolver/Make/argument-1-A/Z/index.html b/dev/sidekick/Sidekick_intsolver/Make/argument-1-A/Z/index.html deleted file mode 100644 index 597cdfb5..00000000 --- a/dev/sidekick/Sidekick_intsolver/Make/argument-1-A/Z/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Z (sidekick.Sidekick_intsolver.Make.1-A.Z)

Module 1-A.Z

include Sidekick_arith.INT
include Sidekick_arith.NUM
type t
val zero : t
val one : t
val minus_one : t
val abs : t -> t
val sign : t -> int
val of_int : int -> t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val pp : t CCFormat.printer
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
val succ : t -> t
val pred : t -> t
val gcd : t -> t -> t
val sqrt : t -> t
val divexact : t -> t -> t
val (/) : t -> t -> t
val ediv : t -> t -> t

Euclidian division

val rem : t -> t -> t
val probab_prime : t -> bool
val pow : t -> int -> t
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_intsolver/Make/argument-1-A/index.html b/dev/sidekick/Sidekick_intsolver/Make/argument-1-A/index.html deleted file mode 100644 index 4d5bb5ff..00000000 --- a/dev/sidekick/Sidekick_intsolver/Make/argument-1-A/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -A (sidekick.Sidekick_intsolver.Make.1-A)

Parameter Make.1-A

type term
type lit
val pp_term : term Sidekick_util.Fmt.printer
val pp_lit : lit Sidekick_util.Fmt.printer
module T_map : CCMap.S with type key = term
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_intsolver/Make/index.html b/dev/sidekick/Sidekick_intsolver/Make/index.html deleted file mode 100644 index 5c05728f..00000000 --- a/dev/sidekick/Sidekick_intsolver/Make/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Make (sidekick.Sidekick_intsolver.Make)

Module Sidekick_intsolver.Make

Parameters

module A : ARG

Signature

module A = A
module Op : sig ... end
type t
val create : unit -> t
val push_level : t -> unit
val pop_levels : t -> int -> unit
val assert_ : t -> (A.Z.t * A.term) list -> Op.t -> A.Z.t -> lit:A.lit -> unit
val define : t -> A.term -> (A.Z.t * A.term) list -> unit
module Cert : sig ... end
module Model : sig ... end
type result =
| Sat of Model.t
| Unsat of Cert.t
val pp_result : result Sidekick_util.Fmt.printer
val check : t -> result
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_intsolver/index.html b/dev/sidekick/Sidekick_intsolver/index.html deleted file mode 100644 index bc80ca56..00000000 --- a/dev/sidekick/Sidekick_intsolver/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Sidekick_intsolver (sidekick.Sidekick_intsolver)

Module Sidekick_intsolver

module type ARG = sig ... end
module type S = sig ... end
module Make (A : ARG) : S with module A = A
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_intsolver/module-type-ARG/Z/index.html b/dev/sidekick/Sidekick_intsolver/module-type-ARG/Z/index.html deleted file mode 100644 index 524feb0b..00000000 --- a/dev/sidekick/Sidekick_intsolver/module-type-ARG/Z/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Z (sidekick.Sidekick_intsolver.ARG.Z)

Module ARG.Z

include Sidekick_arith.INT
include Sidekick_arith.NUM
type t
val zero : t
val one : t
val minus_one : t
val abs : t -> t
val sign : t -> int
val of_int : int -> t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val pp : t CCFormat.printer
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
val succ : t -> t
val pred : t -> t
val gcd : t -> t -> t
val sqrt : t -> t
val divexact : t -> t -> t
val (/) : t -> t -> t
val ediv : t -> t -> t

Euclidian division

val rem : t -> t -> t
val probab_prime : t -> bool
val pow : t -> int -> t
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_intsolver/module-type-ARG/index.html b/dev/sidekick/Sidekick_intsolver/module-type-ARG/index.html deleted file mode 100644 index 81bddd6e..00000000 --- a/dev/sidekick/Sidekick_intsolver/module-type-ARG/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -ARG (sidekick.Sidekick_intsolver.ARG)

Module type Sidekick_intsolver.ARG

type term
type lit
val pp_term : term Sidekick_util.Fmt.printer
val pp_lit : lit Sidekick_util.Fmt.printer
module T_map : CCMap.S with type key = term
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_intsolver/module-type-S/A/Z/index.html b/dev/sidekick/Sidekick_intsolver/module-type-S/A/Z/index.html deleted file mode 100644 index 1c759435..00000000 --- a/dev/sidekick/Sidekick_intsolver/module-type-S/A/Z/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Z (sidekick.Sidekick_intsolver.S.A.Z)

Module A.Z

include Sidekick_arith.INT
include Sidekick_arith.NUM
type t
val zero : t
val one : t
val minus_one : t
val abs : t -> t
val sign : t -> int
val of_int : int -> t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val pp : t CCFormat.printer
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
val succ : t -> t
val pred : t -> t
val gcd : t -> t -> t
val sqrt : t -> t
val divexact : t -> t -> t
val (/) : t -> t -> t
val ediv : t -> t -> t

Euclidian division

val rem : t -> t -> t
val probab_prime : t -> bool
val pow : t -> int -> t
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_intsolver/module-type-S/A/index.html b/dev/sidekick/Sidekick_intsolver/module-type-S/A/index.html deleted file mode 100644 index f5583407..00000000 --- a/dev/sidekick/Sidekick_intsolver/module-type-S/A/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -A (sidekick.Sidekick_intsolver.S.A)

Module S.A

type term
type lit
val pp_term : term Sidekick_util.Fmt.printer
val pp_lit : lit Sidekick_util.Fmt.printer
module T_map : CCMap.S with type key = term
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_intsolver/module-type-S/Cert/index.html b/dev/sidekick/Sidekick_intsolver/module-type-S/Cert/index.html deleted file mode 100644 index e052f156..00000000 --- a/dev/sidekick/Sidekick_intsolver/module-type-S/Cert/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Cert (sidekick.Sidekick_intsolver.S.Cert)

Module S.Cert

type t
val pp : t Sidekick_util.Fmt.printer
val lits : t -> A.lit Iter.t
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_intsolver/module-type-S/Model/index.html b/dev/sidekick/Sidekick_intsolver/module-type-S/Model/index.html deleted file mode 100644 index 7c394701..00000000 --- a/dev/sidekick/Sidekick_intsolver/module-type-S/Model/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Model (sidekick.Sidekick_intsolver.S.Model)

Module S.Model

type t
val pp : t Sidekick_util.Fmt.printer
val eval : t -> A.term -> A.Z.t option
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_intsolver/module-type-S/Op/index.html b/dev/sidekick/Sidekick_intsolver/module-type-S/Op/index.html deleted file mode 100644 index 0777b82f..00000000 --- a/dev/sidekick/Sidekick_intsolver/module-type-S/Op/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -Op (sidekick.Sidekick_intsolver.S.Op)

Module S.Op

type t =
| Leq
| Lt
| Eq
val pp : t Sidekick_util.Fmt.printer
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_intsolver/module-type-S/index.html b/dev/sidekick/Sidekick_intsolver/module-type-S/index.html deleted file mode 100644 index e5a149e8..00000000 --- a/dev/sidekick/Sidekick_intsolver/module-type-S/index.html +++ /dev/null @@ -1,2 +0,0 @@ - -S (sidekick.Sidekick_intsolver.S)

Module type Sidekick_intsolver.S

module A : ARG
module Op : sig ... end
type t
val create : unit -> t
val push_level : t -> unit
val pop_levels : t -> int -> unit
val assert_ : t -> (A.Z.t * A.term) list -> Op.t -> A.Z.t -> lit:A.lit -> unit
val define : t -> A.term -> (A.Z.t * A.term) list -> unit
module Cert : sig ... end
module Model : sig ... end
type result =
| Sat of Model.t
| Unsat of Cert.t
val pp_result : result Sidekick_util.Fmt.printer
val check : t -> result
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_simplex/Make/index.html b/dev/sidekick/Sidekick_simplex/Make/index.html index d2b922f1..e5e11f79 100644 --- a/dev/sidekick/Sidekick_simplex/Make/index.html +++ b/dev/sidekick/Sidekick_simplex/Make/index.html @@ -1,12 +1,11 @@ Make (sidekick.Sidekick_simplex.Make)

Module Sidekick_simplex.Make

Parameters

module Arg : ARG

Signature

module V = Arg.Var
module V_map : CCMap.S with type key = V.t
module Z = Arg.Z
module Q = Arg.Q
type num = Q.t

Numbers

module Constraint : sig ... end
module Subst : sig ... end
type t
val create : ?stat:Sidekick_util.Stat.t -> unit -> t

Create a new simplex.

val push_level : t -> unit
val pop_levels : t -> int -> unit
val define : ?is_int:bool -> t -> V.t -> (num * V.t) list -> unit

Define a basic variable in terms of other variables. This is useful to "name" a linear expression and get back a variable that can be used in a Constraint.t

type unsat_cert
module Unsat_cert : sig ... end
exception E_unsat of Unsat_cert.t
type ev_on_propagate = V.lit -> reason:V.lit list -> unit
val add_var : ?is_int:bool -> t -> V.t -> unit

Make sure the variable exists in the simplex.

val add_constraint : - ?keep_on_backtracking:bool -> ?is_int:bool -> on_propagate:ev_on_propagate -> t -> Constraint.t -> V.lit -> - unit

Add a constraint to the simplex.

This is removed upon backtracking by default.

  • parameter is_int

    declares whether the constraint's variable is an integer

  • raises Unsat

    if it's immediately obvious that this is not satisfiable.

  • parameter keep_on_backtracking

    if true (default false), the bound is not backtrackable

val declare_bound : ?is_int:bool -> t -> Constraint.t -> V.lit -> unit

Declare that this constraint exists and map it to a literal, so we can possibly propagate it later. Unlike add_constraint this does NOT assert that the constraint is true

val check_exn : + unit

Add a constraint to the simplex.

This is removed upon backtracking by default.

  • parameter is_int

    declares whether the constraint's variable is an integer

  • raises Unsat

    if it's immediately obvious that this is not satisfiable.

val declare_bound : ?is_int:bool -> t -> Constraint.t -> V.lit -> unit

Declare that this constraint exists and map it to a literal, so we can possibly propagate it later. Unlike add_constraint this does NOT assert that the constraint is true

val check_exn : on_propagate:( V.lit -> reason:V.lit list -> unit ) -> t -> unit

Check the whole simplex for satisfiability.

  • parameter on_propagate

    is called with arguments lit, reason whenever reason => lit is found to be true by the simplex.

  • raises Unsat

    if the constraints are not satisfiable.

type result =
| Sat of Subst.t
| Unsat of Unsat_cert.t
val check : on_propagate:( V.lit -> reason:V.lit list -> unit ) -> t -> result

Call check_exn and return a model or a proof of unsat. This does NOT enforce that integer variables map to integer values.

val check_branch_and_bound : diff --git a/dev/sidekick/Sidekick_simplex/module-type-S/index.html b/dev/sidekick/Sidekick_simplex/module-type-S/index.html index 6baf8091..2db7cea2 100644 --- a/dev/sidekick/Sidekick_simplex/module-type-S/index.html +++ b/dev/sidekick/Sidekick_simplex/module-type-S/index.html @@ -1,12 +1,11 @@ S (sidekick.Sidekick_simplex.S)

Module type Sidekick_simplex.S

module V : VAR
module V_map : CCMap.S with type key = V.t
module Z : INT
module Q : RATIONAL with type bigint = Z.t
type num = Q.t

Numbers

module Constraint : sig ... end
module Subst : sig ... end
type t
val create : ?stat:Sidekick_util.Stat.t -> unit -> t

Create a new simplex.

val push_level : t -> unit
val pop_levels : t -> int -> unit
val define : ?is_int:bool -> t -> V.t -> (num * V.t) list -> unit

Define a basic variable in terms of other variables. This is useful to "name" a linear expression and get back a variable that can be used in a Constraint.t

type unsat_cert
module Unsat_cert : sig ... end
exception E_unsat of Unsat_cert.t
type ev_on_propagate = V.lit -> reason:V.lit list -> unit
val add_var : ?is_int:bool -> t -> V.t -> unit

Make sure the variable exists in the simplex.

val add_constraint : - ?keep_on_backtracking:bool -> ?is_int:bool -> on_propagate:ev_on_propagate -> t -> Constraint.t -> V.lit -> - unit

Add a constraint to the simplex.

This is removed upon backtracking by default.

  • parameter is_int

    declares whether the constraint's variable is an integer

  • raises Unsat

    if it's immediately obvious that this is not satisfiable.

  • parameter keep_on_backtracking

    if true (default false), the bound is not backtrackable

val declare_bound : ?is_int:bool -> t -> Constraint.t -> V.lit -> unit

Declare that this constraint exists and map it to a literal, so we can possibly propagate it later. Unlike add_constraint this does NOT assert that the constraint is true

val check_exn : + unit

Add a constraint to the simplex.

This is removed upon backtracking by default.

  • parameter is_int

    declares whether the constraint's variable is an integer

  • raises Unsat

    if it's immediately obvious that this is not satisfiable.

val declare_bound : ?is_int:bool -> t -> Constraint.t -> V.lit -> unit

Declare that this constraint exists and map it to a literal, so we can possibly propagate it later. Unlike add_constraint this does NOT assert that the constraint is true

val check_exn : on_propagate:( V.lit -> reason:V.lit list -> unit ) -> t -> unit

Check the whole simplex for satisfiability.

  • parameter on_propagate

    is called with arguments lit, reason whenever reason => lit is found to be true by the simplex.

  • raises Unsat

    if the constraints are not satisfiable.

type result =
| Sat of Subst.t
| Unsat of Unsat_cert.t
val check : on_propagate:( V.lit -> reason:V.lit list -> unit ) -> t -> result

Call check_exn and return a model or a proof of unsat. This does NOT enforce that integer variables map to integer values.

val check_branch_and_bound : diff --git a/dev/sidekick/index.html b/dev/sidekick/index.html index 77a01c96..288be79f 100644 --- a/dev/sidekick/index.html +++ b/dev/sidekick/index.html @@ -1,2 +1,2 @@ -index (sidekick.index)

sidekick index

Library sidekick.arith

The entry point of this library is the module: Sidekick_arith.

Library sidekick.arith-lia

The entry point of this library is the module: Sidekick_arith_lia.

Library sidekick.arith-lra

The entry point of this library is the module: Sidekick_arith_lra.

Library sidekick.cc

The entry point of this library is the module: Sidekick_cc.

Library sidekick.core

The entry point of this library is the module: Sidekick_core.

Library sidekick.drup

The entry point of this library is the module: Sidekick_drup.

Library sidekick.intsolver

The entry point of this library is the module: Sidekick_intsolver.

Library sidekick.lit

The entry point of this library is the module: Sidekick_lit.

Library sidekick.memtrace

The entry point of this library is the module: Sidekick_memtrace.

Library sidekick.mini-cc

The entry point of this library is the module: Sidekick_mini_cc.

Library sidekick.quip

The entry point of this library is the module: Sidekick_quip.

Library sidekick.sat

The entry point of this library is the module: Sidekick_sat.

Library sidekick.sigs

The entry point of this library is the module: Sidekick_sigs.

Library sidekick.simplex

The entry point of this library is the module: Sidekick_simplex.

Library sidekick.smt-solver

The entry point of this library is the module: Sidekick_smt_solver.

Library sidekick.tef

The entry point of this library is the module: Sidekick_tef.

Library sidekick.th-bool-static

The entry point of this library is the module: Sidekick_th_bool_static.

Library sidekick.th-cstor

The entry point of this library is the module: Sidekick_th_cstor.

Library sidekick.th-data

The entry point of this library is the module: Sidekick_th_data.

Library sidekick.util

The entry point of this library is the module: Sidekick_util.

Library sidekick.zarith

The entry point of this library is the module: Sidekick_zarith.

\ No newline at end of file +index (sidekick.index)

sidekick index

Library sidekick.arith

The entry point of this library is the module: Sidekick_arith.

Library sidekick.arith-lra

The entry point of this library is the module: Sidekick_arith_lra.

Library sidekick.cc

The entry point of this library is the module: Sidekick_cc.

Library sidekick.core

The entry point of this library is the module: Sidekick_core.

Library sidekick.drup

The entry point of this library is the module: Sidekick_drup.

Library sidekick.lit

The entry point of this library is the module: Sidekick_lit.

Library sidekick.memtrace

The entry point of this library is the module: Sidekick_memtrace.

Library sidekick.mini-cc

The entry point of this library is the module: Sidekick_mini_cc.

Library sidekick.quip

The entry point of this library is the module: Sidekick_quip.

Library sidekick.sat

The entry point of this library is the module: Sidekick_sat.

Library sidekick.sigs

The entry point of this library is the module: Sidekick_sigs.

Library sidekick.simplex

The entry point of this library is the module: Sidekick_simplex.

Library sidekick.smt-solver

The entry point of this library is the module: Sidekick_smt_solver.

Library sidekick.tef

The entry point of this library is the module: Sidekick_tef.

Library sidekick.th-bool-static

The entry point of this library is the module: Sidekick_th_bool_static.

Library sidekick.th-cstor

The entry point of this library is the module: Sidekick_th_cstor.

Library sidekick.th-data

The entry point of this library is the module: Sidekick_th_data.

Library sidekick.util

The entry point of this library is the module: Sidekick_util.

Library sidekick.zarith

The entry point of this library is the module: Sidekick_zarith.

\ No newline at end of file