diff --git a/dev/sidekick-base/Sidekick_base/Config/Key/index.html b/dev/sidekick-base/Sidekick_base/Config/Key/index.html index 7f99c503..3976d0e7 100644 --- a/dev/sidekick-base/Sidekick_base/Config/Key/index.html +++ b/dev/sidekick-base/Sidekick_base/Config/Key/index.html @@ -1,2 +1,2 @@ -Key (sidekick-base.Sidekick_base.Config.Key)

Module Config.Key

type 'a t
val create : unit -> 'a t
val equal : 'a t -> 'a t -> bool

Compare two keys that have compatible types

+Key (sidekick-base.Sidekick_base.Config.Key)

Module Config.Key

type 'a t
val create : unit -> 'a t
val equal : 'a t -> 'a t -> bool

Compare two keys that have compatible types

diff --git a/dev/sidekick-base/Sidekick_base/Config/index.html b/dev/sidekick-base/Sidekick_base/Config/index.html index 61cca778..bb821e31 100644 --- a/dev/sidekick-base/Sidekick_base/Config/index.html +++ b/dev/sidekick-base/Sidekick_base/Config/index.html @@ -1,2 +1,2 @@ -Config (sidekick-base.Sidekick_base.Config)

Module Sidekick_base.Config

Configuration

module Key : sig ... end
type t
val empty : t
val mem : _ Key.t -> t -> bool
val add : 'a Key.t -> 'a -> t -> t
val length : t -> int
val cardinal : t -> int
val find : 'a Key.t -> t -> 'a option
val find_exn : 'a Key.t -> t -> 'a
  • raises Not_found

    if the key is not in the table

type pair =
  1. | Pair : 'a Key.t * 'a -> pair
val iter : (pair -> unit) -> t -> unit
val to_iter : t -> pair Iter.t
val of_iter : pair Iter.t -> t
val add_iter : t -> pair Iter.t -> t
val add_list : t -> pair list -> t
val of_list : pair list -> t
val to_list : t -> pair list
+Config (sidekick-base.Sidekick_base.Config)

Module Sidekick_base.Config

Configuration

module Key : sig ... end
type t
val empty : t
val mem : _ Key.t -> t -> bool
val add : 'a Key.t -> 'a -> t -> t
val length : t -> int
val cardinal : t -> int
val find : 'a Key.t -> t -> 'a option
val find_exn : 'a Key.t -> t -> 'a
  • raises Not_found

    if the key is not in the table

type pair =
  1. | Pair : 'a Key.t * 'a -> pair
val iter : (pair -> unit) -> t -> unit
val to_iter : t -> pair Iter.t
val of_iter : pair Iter.t -> t
val add_iter : t -> pair Iter.t -> t
val add_list : t -> pair list -> t
val of_list : pair list -> t
val to_list : t -> pair list
diff --git a/dev/sidekick-base/Sidekick_base/Data_ty/Cstor/index.html b/dev/sidekick-base/Sidekick_base/Data_ty/Cstor/index.html index d3692405..886772f2 100644 --- a/dev/sidekick-base/Sidekick_base/Data_ty/Cstor/index.html +++ b/dev/sidekick-base/Sidekick_base/Data_ty/Cstor/index.html @@ -1,2 +1,2 @@ -Cstor (sidekick-base.Sidekick_base.Data_ty.Cstor)

Module Data_ty.Cstor

type t = cstor
val ty_args : t -> Types_.ty list
val select_idx : t -> int -> select
include Sidekick_sigs.EQ_HASH_PRINT with type t := t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
+Cstor (sidekick-base.Sidekick_base.Data_ty.Cstor)

Module Data_ty.Cstor

type t = cstor
val ty_args : t -> Types_.ty list
val select_idx : t -> int -> select
include Sidekick_sigs.EQ_HASH_PRINT with type t := t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
diff --git a/dev/sidekick-base/Sidekick_base/Data_ty/Select/index.html b/dev/sidekick-base/Sidekick_base/Data_ty/Select/index.html index 0c468443..55515872 100644 --- a/dev/sidekick-base/Sidekick_base/Data_ty/Select/index.html +++ b/dev/sidekick-base/Sidekick_base/Data_ty/Select/index.html @@ -1,2 +1,2 @@ -Select (sidekick-base.Sidekick_base.Data_ty.Select)

Module Data_ty.Select

type t = select
include Sidekick_sigs.EQ_HASH_PRINT with type t := t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
+Select (sidekick-base.Sidekick_base.Data_ty.Select)

Module Data_ty.Select

type t = select
include Sidekick_sigs.EQ_HASH_PRINT with type t := t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
diff --git a/dev/sidekick-base/Sidekick_base/Data_ty/index.html b/dev/sidekick-base/Sidekick_base/Data_ty/index.html index ba3d229b..ad4ec228 100644 --- a/dev/sidekick-base/Sidekick_base/Data_ty/index.html +++ b/dev/sidekick-base/Sidekick_base/Data_ty/index.html @@ -1,2 +1,2 @@ -Data_ty (sidekick-base.Sidekick_base.Data_ty)

Module Sidekick_base.Data_ty

type select = Types_.select = {
  1. select_id : ID.t;
  2. select_cstor : Types_.cstor;
  3. select_ty : Types_.ty lazy_t;
  4. select_i : int;
}
type cstor = Types_.cstor = {
  1. cstor_id : ID.t;
  2. cstor_is_a : ID.t;
  3. mutable cstor_arity : int;
  4. cstor_args : select list lazy_t;
  5. cstor_ty_as_data : Types_.data;
  6. cstor_ty : Types_.ty lazy_t;
}
type t = Types_.data = {
  1. data_id : ID.t;
  2. data_cstors : cstor Sidekick_base__.ID.Map.t lazy_t;
  3. data_as_ty : Types_.ty lazy_t;
}
type Sidekick_core.Const.view +=
  1. | Data of Types_.data
  2. | Cstor of cstor
  3. | Select of select
  4. | Is_a of cstor
include Sidekick_sigs.EQ_HASH_PRINT with type t := t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
module Select : sig ... end
module Cstor : sig ... end
val data_as_ty : t -> Types_.ty
val as_data : Types_.ty -> Types_.data option
val as_select : Types_.term -> select option
val as_cstor : Types_.term -> cstor option
val as_is_a : Types_.term -> cstor option
+Data_ty (sidekick-base.Sidekick_base.Data_ty)

Module Sidekick_base.Data_ty

type select = Types_.select = {
  1. select_id : ID.t;
  2. select_cstor : Types_.cstor;
  3. select_ty : Types_.ty lazy_t;
  4. select_i : int;
}
type cstor = Types_.cstor = {
  1. cstor_id : ID.t;
  2. cstor_is_a : ID.t;
  3. mutable cstor_arity : int;
  4. cstor_args : select list lazy_t;
  5. cstor_ty_as_data : Types_.data;
  6. cstor_ty : Types_.ty lazy_t;
}
type t = Types_.data = {
  1. data_id : ID.t;
  2. data_cstors : cstor Sidekick_base__.ID.Map.t lazy_t;
  3. data_as_ty : Types_.ty lazy_t;
}
type Sidekick_core.Const.view +=
  1. | Data of Types_.data
  2. | Cstor of cstor
  3. | Select of select
  4. | Is_a of cstor
include Sidekick_sigs.EQ_HASH_PRINT with type t := t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
module Select : sig ... end
module Cstor : sig ... end
val data_as_ty : t -> Types_.ty
val as_data : Types_.ty -> Types_.data option
val as_select : Types_.term -> select option
val as_cstor : Types_.term -> cstor option
val as_is_a : Types_.term -> cstor option
diff --git a/dev/sidekick-base/Sidekick_base/Form/index.html b/dev/sidekick-base/Sidekick_base/Form/index.html index 79cc3169..203bb091 100644 --- a/dev/sidekick-base/Sidekick_base/Form/index.html +++ b/dev/sidekick-base/Sidekick_base/Form/index.html @@ -1,2 +1,2 @@ -Form (sidekick-base.Sidekick_base.Form)

Module Sidekick_base.Form

Formulas (boolean terms).

This module defines function symbols, constants, and views to manipulate boolean formulas in Sidekick_base. This is useful to have the ability to use boolean connectives instead of being limited to clauses; by using Sidekick_th_bool_static, the formulas are turned into clauses automatically for you.

type 'a view = 'a Sidekick_core.Bool_view.t =
  1. | B_bool of bool
  2. | B_not of 'a
  3. | B_and of 'a list
  4. | B_or of 'a list
  5. | B_imply of 'a * 'a
  6. | B_equiv of 'a * 'a
  7. | B_xor of 'a * 'a
  8. | B_eq of 'a * 'a
  9. | B_neq of 'a * 'a
  10. | B_ite of 'a * 'a * 'a
  11. | B_atom of 'a
val view : term -> term view
val bool : Sidekick_core.Term.store -> bool -> term
val not_ : Sidekick_core.Term.store -> term -> term
val and_ : Sidekick_core.Term.store -> term -> term -> term
val or_ : Sidekick_core.Term.store -> term -> term -> term
val imply : Sidekick_core.Term.store -> term -> term -> term
val equiv : Sidekick_core.Term.store -> term -> term -> term
val distinct_l : Sidekick_core.Term.store -> term list -> term
val const_decoders : Sidekick_core.Const.decoders
val and_l : Sidekick_core.Term.store -> term list -> term
val or_l : Sidekick_core.Term.store -> term list -> term
val imply_l : Sidekick_core.Term.store -> term list -> term -> term
val mk_of_view : Sidekick_core.Term.store -> term view -> term
+Form (sidekick-base.Sidekick_base.Form)

Module Sidekick_base.Form

Formulas (boolean terms).

This module defines function symbols, constants, and views to manipulate boolean formulas in Sidekick_base. This is useful to have the ability to use boolean connectives instead of being limited to clauses; by using Sidekick_th_bool_static, the formulas are turned into clauses automatically for you.

type 'a view = 'a Sidekick_core.Bool_view.t =
  1. | B_bool of bool
  2. | B_not of 'a
  3. | B_and of 'a list
  4. | B_or of 'a list
  5. | B_imply of 'a * 'a
  6. | B_equiv of 'a * 'a
  7. | B_xor of 'a * 'a
  8. | B_eq of 'a * 'a
  9. | B_neq of 'a * 'a
  10. | B_ite of 'a * 'a * 'a
  11. | B_atom of 'a
val view : term -> term view
val bool : Sidekick_core.Term.store -> bool -> term
val not_ : Sidekick_core.Term.store -> term -> term
val and_ : Sidekick_core.Term.store -> term -> term -> term
val or_ : Sidekick_core.Term.store -> term -> term -> term
val imply : Sidekick_core.Term.store -> term -> term -> term
val equiv : Sidekick_core.Term.store -> term -> term -> term
val distinct_l : Sidekick_core.Term.store -> term list -> term
val const_decoders : Sidekick_core.Const.decoders
val and_l : Sidekick_core.Term.store -> term list -> term
val or_l : Sidekick_core.Term.store -> term list -> term
val imply_l : Sidekick_core.Term.store -> term list -> term -> term
val mk_of_view : Sidekick_core.Term.store -> term view -> term
diff --git a/dev/sidekick-base/Sidekick_base/ID/index.html b/dev/sidekick-base/Sidekick_base/ID/index.html index 9336af81..8303d381 100644 --- a/dev/sidekick-base/Sidekick_base/ID/index.html +++ b/dev/sidekick-base/Sidekick_base/ID/index.html @@ -1,2 +1,2 @@ -ID (sidekick-base.Sidekick_base.ID)

Module Sidekick_base.ID

Unique Identifiers

We use generative identifiers everywhere in Sidekick_base. Unlike strings, there are no risk of collision: during parsing, a new declaration or definition should create a fresh ID.t and associate it with the string name, and later references should look into some hashtable or map to get the ID corresponding to a string.

This allows us to handle definition shadowing or binder shadowing easily.

type t

The opaque type of unique identifiers

val make : string -> t

make s creates a new identifier with name s and some internal information. It is different than any other identifier created before or after, even with the same name.

val makef : ('a, Stdlib.Format.formatter, unit, t) Stdlib.format4 -> 'a

makef "foo %d bar %b" 42 true is like make (Format.asprintf "foo %d bar %b" 42 true).

val copy : t -> t

Fresh copy of the identifier, distinct from it, but with the same name.

val id : t -> int

Unique integer counter for this identifier.

val to_string : t -> string

Print identifier.

val to_string_full : t -> string

Printer name and unique counter for this ID.

include Sidekick_sigs.EQ_ORD_HASH_PRINT with type t := 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_name : t CCFormat.printer
val pp_full : t CCFormat.printer
module Map : CCMap.S with type key = t
module Set : CCSet.S with type elt = t
module Tbl : CCHashtbl.S with type key = t
+ID (sidekick-base.Sidekick_base.ID)

Module Sidekick_base.ID

Unique Identifiers

We use generative identifiers everywhere in Sidekick_base. Unlike strings, there are no risk of collision: during parsing, a new declaration or definition should create a fresh ID.t and associate it with the string name, and later references should look into some hashtable or map to get the ID corresponding to a string.

This allows us to handle definition shadowing or binder shadowing easily.

type t

The opaque type of unique identifiers

val make : string -> t

make s creates a new identifier with name s and some internal information. It is different than any other identifier created before or after, even with the same name.

val makef : ('a, Stdlib.Format.formatter, unit, t) Stdlib.format4 -> 'a

makef "foo %d bar %b" 42 true is like make (Format.asprintf "foo %d bar %b" 42 true).

val copy : t -> t

Fresh copy of the identifier, distinct from it, but with the same name.

val id : t -> int

Unique integer counter for this identifier.

val to_string : t -> string

Print identifier.

val to_string_full : t -> string

Printer name and unique counter for this ID.

include Sidekick_sigs.EQ_ORD_HASH_PRINT with type t := 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_name : t CCFormat.printer
val pp_full : t CCFormat.printer
module Map : CCMap.S with type key = t
module Set : CCSet.S with type elt = t
module Tbl : CCHashtbl.S with type key = t
diff --git a/dev/sidekick-base/Sidekick_base/LRA_term/Op/index.html b/dev/sidekick-base/Sidekick_base/LRA_term/Op/index.html index 2c6927f5..8e53d4b2 100644 --- a/dev/sidekick-base/Sidekick_base/LRA_term/Op/index.html +++ b/dev/sidekick-base/Sidekick_base/LRA_term/Op/index.html @@ -1,2 +1,2 @@ -Op (sidekick-base.Sidekick_base.LRA_term.Op)

Module LRA_term.Op

type t = Sidekick_th_lra.op =
  1. | Plus
  2. | Minus
include Sidekick_sigs.EQ_HASH_PRINT with type t := t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
+Op (sidekick-base.Sidekick_base.LRA_term.Op)

Module LRA_term.Op

type t = Sidekick_th_lra.op =
  1. | Plus
  2. | Minus
include Sidekick_sigs.EQ_HASH_PRINT with type t := t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
diff --git a/dev/sidekick-base/Sidekick_base/LRA_term/Pred/index.html b/dev/sidekick-base/Sidekick_base/LRA_term/Pred/index.html index 34231d71..d24574e3 100644 --- a/dev/sidekick-base/Sidekick_base/LRA_term/Pred/index.html +++ b/dev/sidekick-base/Sidekick_base/LRA_term/Pred/index.html @@ -1,2 +1,2 @@ -Pred (sidekick-base.Sidekick_base.LRA_term.Pred)

Module LRA_term.Pred

type t = Sidekick_th_lra.Predicate.t =
  1. | Leq
  2. | Geq
  3. | Lt
  4. | Gt
  5. | Eq
  6. | Neq
include Sidekick_sigs.EQ_HASH_PRINT with type t := t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
+Pred (sidekick-base.Sidekick_base.LRA_term.Pred)

Module LRA_term.Pred

type t = Sidekick_th_lra.Predicate.t =
  1. | Leq
  2. | Geq
  3. | Lt
  4. | Gt
  5. | Eq
  6. | Neq
include Sidekick_sigs.EQ_HASH_PRINT with type t := t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
diff --git a/dev/sidekick-base/Sidekick_base/LRA_term/View/index.html b/dev/sidekick-base/Sidekick_base/LRA_term/View/index.html index 25be75ab..8e208e81 100644 --- a/dev/sidekick-base/Sidekick_base/LRA_term/View/index.html +++ b/dev/sidekick-base/Sidekick_base/LRA_term/View/index.html @@ -1,2 +1,2 @@ -View (sidekick-base.Sidekick_base.LRA_term.View)

Module LRA_term.View

type ('num, 'a) lra_view = ('num, 'a) Sidekick_th_lra.lra_view =
  1. | LRA_pred of Pred.t * 'a * 'a
  2. | LRA_op of Op.t * 'a * 'a
  3. | LRA_mult of 'num * 'a
  4. | LRA_const of 'num
  5. | LRA_other of 'a
type 'a t = (Q.t, 'a) Sidekick_th_lra.lra_view
val map : f_c:(Q.t -> Q.t) -> ('a -> 'b) -> 'a t -> 'b t
val iter : ('a -> unit) -> 'a t -> unit
val pp : pp_t:'a Sidekick_core.Fmt.printer -> 'a t Sidekick_core.Fmt.printer
val hash : sub_hash:('a -> int) -> 'a t -> int
val equal : sub_eq:('a -> 'b -> bool) -> 'a t -> 'b t -> bool
+View (sidekick-base.Sidekick_base.LRA_term.View)

Module LRA_term.View

type ('num, 'a) lra_view = ('num, 'a) Sidekick_th_lra.lra_view =
  1. | LRA_pred of Pred.t * 'a * 'a
  2. | LRA_op of Op.t * 'a * 'a
  3. | LRA_mult of 'num * 'a
  4. | LRA_const of 'num
  5. | LRA_other of 'a
type 'a t = (Q.t, 'a) Sidekick_th_lra.lra_view
val map : f_c:(Q.t -> Q.t) -> ('a -> 'b) -> 'a t -> 'b t
val iter : ('a -> unit) -> 'a t -> unit
val pp : pp_t:'a Sidekick_core.Fmt.printer -> 'a t Sidekick_core.Fmt.printer
val hash : sub_hash:('a -> int) -> 'a t -> int
val equal : sub_eq:('a -> 'b -> bool) -> 'a t -> 'b t -> bool
diff --git a/dev/sidekick-base/Sidekick_base/LRA_term/index.html b/dev/sidekick-base/Sidekick_base/LRA_term/index.html index 268d42e3..f802f188 100644 --- a/dev/sidekick-base/Sidekick_base/LRA_term/index.html +++ b/dev/sidekick-base/Sidekick_base/LRA_term/index.html @@ -1,2 +1,2 @@ -LRA_term (sidekick-base.Sidekick_base.LRA_term)

Module Sidekick_base.LRA_term

module Pred : sig ... end
module Op : sig ... end
val const_decoders : Sidekick_core.Const.decoders
module View : sig ... end
val term_of_view : Sidekick_core.Term.store -> term View.t -> term
val has_ty_real : term -> bool
val mult_by : Sidekick_core.Term.store -> Q.t -> term -> term
val const : Sidekick_core.Term.store -> Q.t -> term

Helpers

val minus : Sidekick_core.Term.store -> term -> term -> term

View

val view : term -> term View.t

View as LRA

+LRA_term (sidekick-base.Sidekick_base.LRA_term)

Module Sidekick_base.LRA_term

module Pred : sig ... end
module Op : sig ... end
val const_decoders : Sidekick_core.Const.decoders
module View : sig ... end
val term_of_view : Sidekick_core.Term.store -> term View.t -> term
val has_ty_real : term -> bool
val mult_by : Sidekick_core.Term.store -> Q.t -> term -> term
val const : Sidekick_core.Term.store -> Q.t -> term

Helpers

val minus : Sidekick_core.Term.store -> term -> term -> term

View

val view : term -> term View.t

View as LRA

diff --git a/dev/sidekick-base/Sidekick_base/Solver/index.html b/dev/sidekick-base/Sidekick_base/Solver/index.html index eaccd1fa..6b124e4c 100644 --- a/dev/sidekick-base/Sidekick_base/Solver/index.html +++ b/dev/sidekick-base/Sidekick_base/Solver/index.html @@ -1,5 +1,5 @@ -Solver (sidekick-base.Sidekick_base.Solver)

Module Sidekick_base.Solver

include module type of struct include Sidekick_smt_solver.Solver end

The solver's state.

A solver contains a registry so that theories can share data

val mk_theory : +Solver (sidekick-base.Sidekick_base.Solver)

Module Sidekick_base.Solver

include module type of struct include Sidekick_smt_solver.Solver end

The solver's state.

A solver contains a registry so that theories can share data

val mk_theory : name:string -> create_and_setup: (id:Sidekick_smt_solver.Theory_id.t -> diff --git a/dev/sidekick-base/Sidekick_base/Statement/index.html b/dev/sidekick-base/Sidekick_base/Statement/index.html index 8b26b56f..1793e54e 100644 --- a/dev/sidekick-base/Sidekick_base/Statement/index.html +++ b/dev/sidekick-base/Sidekick_base/Statement/index.html @@ -1,2 +1,2 @@ -Statement (sidekick-base.Sidekick_base.Statement)

Module Sidekick_base.Statement

Statements.

A statement is an instruction for the SMT solver to do something, like asserting that a formula is true, declaring a new constant, or checking satisfiabilty of the current set of assertions.

type t = Types_.statement =
  1. | Stmt_set_logic of string
  2. | Stmt_set_option of string list
  3. | Stmt_set_info of string * string
  4. | Stmt_data of Types_.data list
  5. | Stmt_ty_decl of {
    1. name : ID.t;
    2. arity : int;
    3. ty_const : Types_.ty;
    }
    (*

    new atomic cstor

    *)
  6. | Stmt_decl of {
    1. name : ID.t;
    2. ty_args : Types_.ty list;
    3. ty_ret : Types_.ty;
    4. const : Types_.term;
    }
  7. | Stmt_define of Types_.definition list
  8. | Stmt_assert of Types_.term
  9. | Stmt_assert_clause of Types_.term list
  10. | Stmt_check_sat of (bool * Types_.term) list
  11. | Stmt_get_model
  12. | Stmt_get_value of Types_.term list
  13. | Stmt_exit
include Sidekick_sigs.PRINT with type t := t
+Statement (sidekick-base.Sidekick_base.Statement)

Module Sidekick_base.Statement

Statements.

A statement is an instruction for the SMT solver to do something, like asserting that a formula is true, declaring a new constant, or checking satisfiabilty of the current set of assertions.

type t = Types_.statement =
  1. | Stmt_set_logic of string
  2. | Stmt_set_option of string list
  3. | Stmt_set_info of string * string
  4. | Stmt_data of Types_.data list
  5. | Stmt_ty_decl of {
    1. name : ID.t;
    2. arity : int;
    3. ty_const : Types_.ty;
    }
    (*

    new atomic cstor

    *)
  6. | Stmt_decl of {
    1. name : ID.t;
    2. ty_args : Types_.ty list;
    3. ty_ret : Types_.ty;
    4. const : Types_.term;
    }
  7. | Stmt_define of Types_.definition list
  8. | Stmt_assert of Types_.term
  9. | Stmt_assert_clause of Types_.term list
  10. | Stmt_check_sat of (bool * Types_.term) list
  11. | Stmt_get_model
  12. | Stmt_get_value of Types_.term list
  13. | Stmt_exit
include Sidekick_sigs.PRINT with type t := t
diff --git a/dev/sidekick-base/Sidekick_base/Term/index.html b/dev/sidekick-base/Sidekick_base/Term/index.html index 2a9f6e68..8b422523 100644 --- a/dev/sidekick-base/Sidekick_base/Term/index.html +++ b/dev/sidekick-base/Sidekick_base/Term/index.html @@ -1,5 +1,5 @@ -Term (sidekick-base.Sidekick_base.Term)

Module Sidekick_base.Term

include module type of struct include Sidekick_core.Term end
include module type of struct include Sidekick_core_logic.Term end
type t

A term, in the calculus of constructions

The store for terms.

The store is responsible for allocating unique IDs to terms, and enforcing their hashconsing (so that syntactic equality is just a pointer comparison).

type view =
  1. | E_type of int
  2. | E_var of var
  3. | E_bound_var of bvar
  4. | E_app of t * t
  5. | E_lam of string * t * t
  6. | E_pi of string * t * t

View.

A view is the shape of the root node of a term.

include Sidekick_sigs.EQ_ORD_HASH with type t := 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
val pp_debug : t Sidekick_util.Fmt.printer
val pp_debug_with_ids : t Sidekick_util.Fmt.printer

Containers

include Sidekick_sigs.WITH_SET_MAP_TBL with type t := t
include Sidekick_sigs.WITH_WEAK with type t := t
module Weak_set = Sidekick_core.Term.Weak_set
module Weak_map = Sidekick_core.Term.Weak_map

Utils

val view : t -> view
val unfold_app : t -> t * t list
val is_app : t -> bool
val is_const : t -> bool
val is_pi : t -> bool
val iter_dag : ?seen:unit Tbl.t -> iter_ty:bool -> f:(t -> unit) -> t -> 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
+Term (sidekick-base.Sidekick_base.Term)
Module Sidekick_base.Term
include module type of struct include Sidekick_core.Term end
include module type of struct include Sidekick_core_logic.Term end
type t
A term, in the calculus of constructions
The store for terms.
The store is responsible for allocating unique IDs to terms, and enforcing their hashconsing (so that syntactic equality is just a pointer comparison).
type view = 
  1. | E_type of int
  2. | E_var of var
  3. | E_bound_var of bvar
  4. | E_app of t * t
  5. | E_lam of string * t * t
  6. | E_pi of string * t * t
View.
A view is the shape of the root node of a term.
include Sidekick_sigs.EQ_ORD_HASH with type t := 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
val pp_debug : t Sidekick_util.Fmt.printer
val pp_debug_with_ids : t Sidekick_util.Fmt.printer
Containers
include Sidekick_sigs.WITH_SET_MAP_TBL with type t := t
include Sidekick_sigs.WITH_WEAK with type t := t
module Weak_set = Sidekick_core.Term.Weak_set
module Weak_map = Sidekick_core.Term.Weak_map
Utils
val view : t -> view
val unfold_app : t -> t * t list
val is_app : t -> bool
val is_const : t -> bool
val is_pi : t -> bool
val iter_dag : ?seen:unit Tbl.t -> iter_ty:bool -> f:(t -> unit) -> t -> 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
diff --git a/dev/sidekick-base/Sidekick_base/Th_bool/index.html b/dev/sidekick-base/Sidekick_base/Th_bool/index.html
index da64fac8..c62d450b 100644
--- a/dev/sidekick-base/Sidekick_base/Th_bool/index.html
+++ b/dev/sidekick-base/Sidekick_base/Th_bool/index.html
@@ -1,2 +1,2 @@
 
-Th_bool (sidekick-base.Sidekick_base.Th_bool)
Module Sidekick_base.Th_bool
Reducing boolean formulas to clauses
val k_config : [ `Dyn | `Static ] Config.Key.t
val theory_static : Solver.theory
val theory_dyn : Solver.theory
val theory : Config.t -> Solver.theory

+Th_bool (sidekick-base.Sidekick_base.Th_bool)
Module Sidekick_base.Th_bool
Reducing boolean formulas to clauses
val k_config : [ `Dyn | `Static ] Config.Key.t
val theory_static : Solver.theory
val theory_dyn : Solver.theory
val theory : Config.t -> Solver.theory

diff --git a/dev/sidekick-base/Sidekick_base/Th_data/index.html b/dev/sidekick-base/Sidekick_base/Th_data/index.html
index 95a30dc1..1e4b6ba9 100644
--- a/dev/sidekick-base/Sidekick_base/Th_data/index.html
+++ b/dev/sidekick-base/Sidekick_base/Th_data/index.html
@@ -1,2 +1,2 @@
 
-Th_data (sidekick-base.Sidekick_base.Th_data)
Module Sidekick_base.Th_data
Theory of datatypes
val arg : (module Sidekick_th_data.ARG)

+Th_data (sidekick-base.Sidekick_base.Th_data)
Module Sidekick_base.Th_data
Theory of datatypes
val arg : (module Sidekick_th_data.ARG)

diff --git a/dev/sidekick-base/Sidekick_base/Th_lra/index.html b/dev/sidekick-base/Sidekick_base/Th_lra/index.html
index 6209c0bc..668e2132 100644
--- a/dev/sidekick-base/Sidekick_base/Th_lra/index.html
+++ b/dev/sidekick-base/Sidekick_base/Th_lra/index.html
@@ -1,2 +1,2 @@
 
-Th_lra (sidekick-base.Sidekick_base.Th_lra)
Module Sidekick_base.Th_lra
Theory of Linear Rational Arithmetic
val theory : Solver.theory

+Th_lra (sidekick-base.Sidekick_base.Th_lra)
Module Sidekick_base.Th_lra
Theory of Linear Rational Arithmetic
val theory : Solver.theory

diff --git a/dev/sidekick-base/Sidekick_base/Th_ty_unin/index.html b/dev/sidekick-base/Sidekick_base/Th_ty_unin/index.html
index ade219c4..15bda96b 100644
--- a/dev/sidekick-base/Sidekick_base/Th_ty_unin/index.html
+++ b/dev/sidekick-base/Sidekick_base/Th_ty_unin/index.html
@@ -1,2 +1,2 @@
 
-Th_ty_unin (sidekick-base.Sidekick_base.Th_ty_unin)
Module Sidekick_base.Th_ty_unin
val theory : Solver.theory

+Th_ty_unin (sidekick-base.Sidekick_base.Th_ty_unin)
Module Sidekick_base.Th_ty_unin
val theory : Solver.theory

diff --git a/dev/sidekick-base/Sidekick_base/Ty/index.html b/dev/sidekick-base/Sidekick_base/Ty/index.html
index 03d76698..3dcc76d2 100644
--- a/dev/sidekick-base/Sidekick_base/Ty/index.html
+++ b/dev/sidekick-base/Sidekick_base/Ty/index.html
@@ -1,5 +1,5 @@
 
-Ty (sidekick-base.Sidekick_base.Ty)
Module Sidekick_base.Ty
include module type of struct include Sidekick_core.Term end
include module type of struct include Sidekick_core_logic.Term end
The store for terms.
The store is responsible for allocating unique IDs to terms, and enforcing their hashconsing (so that syntactic equality is just a pointer comparison).
type view = 
  1. | E_type of int
  2. | E_var of var
  3. | E_bound_var of bvar
View.
A view is the shape of the root node of a term.
include Sidekick_sigs.EQ_ORD_HASH
+Ty (sidekick-base.Sidekick_base.Ty)
Module Sidekick_base.Ty
include module type of struct include Sidekick_core.Term end
include module type of struct include Sidekick_core_logic.Term end
The store for terms.
The store is responsible for allocating unique IDs to terms, and enforcing their hashconsing (so that syntactic equality is just a pointer comparison).
type view = 
  1. | E_type of int
  2. | E_var of var
  3. | E_bound_var of bvar
View.
A view is the shape of the root node of a term.
include Sidekick_sigs.EQ_ORD_HASH
   with type t := Sidekick_core_logic__.Types_.term
include Sidekick_sigs.EQ with type t := Sidekick_core_logic__.Types_.term
include Sidekick_sigs.ORD with type t := Sidekick_core_logic__.Types_.term
include Sidekick_sigs.HASH with type t := Sidekick_core_logic__.Types_.term
val pp_debug : Sidekick_core_logic__.Types_.term Sidekick_util.Fmt.printer
val pp_debug_with_ids : 
   Sidekick_core_logic__.Types_.term Sidekick_util.Fmt.printer
Containers
include Sidekick_sigs.WITH_SET_MAP_TBL
   with type t := Sidekick_core_logic__.Types_.term
include Sidekick_sigs.WITH_WEAK
diff --git a/dev/sidekick-base/Sidekick_base/Types_/index.html b/dev/sidekick-base/Sidekick_base/Types_/index.html
index 8ebe3580..854fd276 100644
--- a/dev/sidekick-base/Sidekick_base/Types_/index.html
+++ b/dev/sidekick-base/Sidekick_base/Types_/index.html
@@ -1,5 +1,5 @@
 
-Types_ (sidekick-base.Sidekick_base.Types_)
Module Sidekick_base.Types_
include module type of struct include Sidekick_core end
module Fmt = Sidekick_core.Fmt
Re-exports from core-logic
module Const = Sidekick_core.Const
module Str_const = Sidekick_core.Str_const
module Term = Sidekick_core.Term
view
module Bool_view = Sidekick_core.Bool_view
module CC_view = Sidekick_core.CC_view
module Default_cc_view = Sidekick_core.Default_cc_view
Main modules
module Bvar = Sidekick_core.Bvar
module Lit = Sidekick_core.Lit
module Subst = Sidekick_core.Subst
module Var = Sidekick_core.Var
module Box = Sidekick_core.Box
module Gensym = Sidekick_core.Gensym
exception Resource_exhausted
Const decoders for traces
val const_decoders : 
+Types_ (sidekick-base.Sidekick_base.Types_)
Module Sidekick_base.Types_
include module type of struct include Sidekick_core end
module Fmt = Sidekick_core.Fmt
Re-exports from core-logic
module Const = Sidekick_core.Const
module Str_const = Sidekick_core.Str_const
module Term = Sidekick_core.Term
view
module Bool_view = Sidekick_core.Bool_view
module CC_view = Sidekick_core.CC_view
module Default_cc_view = Sidekick_core.Default_cc_view
Main modules
module Bvar = Sidekick_core.Bvar
module Lit = Sidekick_core.Lit
module Subst = Sidekick_core.Subst
module Var = Sidekick_core.Var
module Box = Sidekick_core.Box
module Gensym = Sidekick_core.Gensym
exception Resource_exhausted
Const decoders for traces
val const_decoders : 
   (string
    * Sidekick_core_logic.Const.Ops.t
    * (Sidekick_core_logic__.Types_.term Sidekick_util.Ser_decode.t ->
diff --git a/dev/sidekick-base/Sidekick_base/Uconst/index.html b/dev/sidekick-base/Sidekick_base/Uconst/index.html
index af7e1038..71e58f11 100644
--- a/dev/sidekick-base/Sidekick_base/Uconst/index.html
+++ b/dev/sidekick-base/Sidekick_base/Uconst/index.html
@@ -1,5 +1,5 @@
 
-Uconst (sidekick-base.Sidekick_base.Uconst)
Module Sidekick_base.Uconst
Uninterpreted constants
type t = Types_.uconst = {
  1. uc_id : ID.t;
  2. uc_ty : ty;
}
val id : t -> ID.t
val ty : t -> ty
type Sidekick_core.Const.view += 
  1. | Uconst of t
include Sidekick_sigs.EQ_ORD_HASH_PRINT with type t := 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 const_decoders : Sidekick_core.Const.decoders
val make : ID.t -> ty -> t
Make a new uninterpreted function.
val uconst_of_id : 
+Uconst (sidekick-base.Sidekick_base.Uconst)
Module Sidekick_base.Uconst
Uninterpreted constants
type t = Types_.uconst = {
  1. uc_id : ID.t;
  2. uc_ty : ty;
}
val id : t -> ID.t
val ty : t -> ty
type Sidekick_core.Const.view += 
  1. | Uconst of t
include Sidekick_sigs.EQ_ORD_HASH_PRINT with type t := 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 const_decoders : Sidekick_core.Const.decoders
val make : ID.t -> ty -> t
Make a new uninterpreted function.
val uconst_of_id : 
   Sidekick_core.Term.store ->
   ID.t ->
   ty ->
diff --git a/dev/sidekick-base/Sidekick_base/index.html b/dev/sidekick-base/Sidekick_base/index.html
index 30be6915..abd90bdd 100644
--- a/dev/sidekick-base/Sidekick_base/index.html
+++ b/dev/sidekick-base/Sidekick_base/index.html
@@ -1,5 +1,5 @@
 
-Sidekick_base (sidekick-base.Sidekick_base)
Module Sidekick_base
Sidekick base
This library is a starting point for writing concrete implementations of SMT solvers with Sidekick.
It provides a representation of terms, boolean formulas, linear arithmetic expressions, datatypes for the functors in Sidekick.
In addition, it has a notion of Statement. Statements are instructions for the SMT solver to do something, such as: define a new constant, declare a new constant, assert a formula as being true, set an option, check satisfiability of the set of statements added so far, etc. Logic formats such as SMT-LIB 2.6 are in fact based on a similar notion of statements, and a .smt2 files contains a list of statements.
module Types_ : sig ... end
module Term : sig ... end
module Const = Sidekick_core.Const
module Ty : sig ... end
module ID : sig ... end
Unique Identifiers
module Form : sig ... end
Formulas (boolean terms).
module Data_ty : sig ... end
module Cstor = Data_ty.Cstor
module Select = Data_ty.Select
module Statement : sig ... end
Statements.
module Solver : sig ... end
module Uconst : sig ... end
Uninterpreted constants
module Config : sig ... end
Configuration
module LRA_term : sig ... end
module Th_data : sig ... end
Theory of datatypes
module Th_bool : sig ... end
Reducing boolean formulas to clauses
module Th_lra : sig ... end
Theory of Linear Rational Arithmetic
module Th_ty_unin : sig ... end
val k_th_bool_config : [ `Dyn | `Static ] Config.Key.t
val th_bool : Config.t -> Solver.theory
val th_bool_dyn : Solver.theory
val th_bool_static : Solver.theory
val th_data : Solver.theory
val th_lra : Solver.theory
val th_ty_unin : Solver.theory
val const_decoders : 
+Sidekick_base (sidekick-base.Sidekick_base)
Module Sidekick_base
Sidekick base
This library is a starting point for writing concrete implementations of SMT solvers with Sidekick.
It provides a representation of terms, boolean formulas, linear arithmetic expressions, datatypes for the functors in Sidekick.
In addition, it has a notion of Statement. Statements are instructions for the SMT solver to do something, such as: define a new constant, declare a new constant, assert a formula as being true, set an option, check satisfiability of the set of statements added so far, etc. Logic formats such as SMT-LIB 2.6 are in fact based on a similar notion of statements, and a .smt2 files contains a list of statements.
module Types_ : sig ... end
module Term : sig ... end
module Const = Sidekick_core.Const
module Ty : sig ... end
module ID : sig ... end
Unique Identifiers
module Form : sig ... end
Formulas (boolean terms).
module Data_ty : sig ... end
module Cstor = Data_ty.Cstor
module Select = Data_ty.Select
module Statement : sig ... end
Statements.
module Solver : sig ... end
module Uconst : sig ... end
Uninterpreted constants
module Config : sig ... end
Configuration
module LRA_term : sig ... end
module Th_data : sig ... end
Theory of datatypes
module Th_bool : sig ... end
Reducing boolean formulas to clauses
module Th_lra : sig ... end
Theory of Linear Rational Arithmetic
module Th_ty_unin : sig ... end
val k_th_bool_config : [ `Dyn | `Static ] Config.Key.t
val th_bool : Config.t -> Solver.theory
val th_bool_dyn : Solver.theory
val th_bool_static : Solver.theory
val th_data : Solver.theory
val th_lra : Solver.theory
val th_ty_unin : Solver.theory
val const_decoders : 
   (string
    * Sidekick_core.Const.Ops.t
    * (Sidekick_core_logic__.Types_.term Sidekick_util.Ser_decode.t ->
diff --git a/dev/sidekick-base/Sidekick_smtlib/Check_cc/index.html b/dev/sidekick-base/Sidekick_smtlib/Check_cc/index.html
index eefa87ee..8afe0beb 100644
--- a/dev/sidekick-base/Sidekick_smtlib/Check_cc/index.html
+++ b/dev/sidekick-base/Sidekick_smtlib/Check_cc/index.html
@@ -1,2 +1,2 @@
 
-Check_cc (sidekick-base.Sidekick_smtlib.Check_cc)
Module Sidekick_smtlib.Check_cc
val theory : Solver.cdcl_theory
theory that check validity of EUF conflicts, on the fly

+Check_cc (sidekick-base.Sidekick_smtlib.Check_cc)
Module Sidekick_smtlib.Check_cc
val theory : Solver.cdcl_theory
theory that check validity of EUF conflicts, on the fly

diff --git a/dev/sidekick-base/Sidekick_smtlib/Driver/index.html b/dev/sidekick-base/Sidekick_smtlib/Driver/index.html
index 10a4e6ee..90bf19f8 100644
--- a/dev/sidekick-base/Sidekick_smtlib/Driver/index.html
+++ b/dev/sidekick-base/Sidekick_smtlib/Driver/index.html
@@ -1,5 +1,5 @@
 
-Driver (sidekick-base.Sidekick_smtlib.Driver)
Module Sidekick_smtlib.Driver
Driver.
The driver is responsible for processing statements from a SMTLIB file, and interacting with the solver based on the statement (asserting formulas, calling "solve", etc.)
val th_bool_dyn : Sidekick_base.Solver.theory
val th_bool_static : Sidekick_base.Solver.theory
type 'a or_error = ('a, string) CCResult.t
type t
The SMTLIB driver
val create : 
+Driver (sidekick-base.Sidekick_smtlib.Driver)
Module Sidekick_smtlib.Driver
Driver.
The driver is responsible for processing statements from a SMTLIB file, and interacting with the solver based on the statement (asserting formulas, calling "solve", etc.)
val th_bool_dyn : Sidekick_base.Solver.theory
val th_bool_static : Sidekick_base.Solver.theory
type 'a or_error = ('a, string) CCResult.t
type t
The SMTLIB driver
val create : 
   ?pp_cnf:bool ->
   ?proof_file:string ->
   ?pp_model:bool ->
diff --git a/dev/sidekick-base/Sidekick_smtlib/Model/index.html b/dev/sidekick-base/Sidekick_smtlib/Model/index.html
index 20954607..f93fd81b 100644
--- a/dev/sidekick-base/Sidekick_smtlib/Model/index.html
+++ b/dev/sidekick-base/Sidekick_smtlib/Model/index.html
@@ -1,2 +1,2 @@
 
-Model (sidekick-base.Sidekick_smtlib.Model)
Module Sidekick_smtlib.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
type fun_ = Sidekick_core.Term.t
module TL_map : CCMap.S with type key = value list
val empty : t
val is_empty : t -> bool
val add_fun_entry : fun_ -> value list -> value -> t -> t
val get_fun_entry : fun_ -> value list -> t -> value option
val get_fun_entries : fun_ -> t -> value TL_map.t option
val iter_fun_entries : t -> (fun_ * value TL_map.t) Iter.t
val eval : Sidekick_core.Term.t -> t -> value option
include Sidekick_sigs.PRINT with type t := t

+Model (sidekick-base.Sidekick_smtlib.Model)
Module Sidekick_smtlib.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
type fun_ = Sidekick_core.Term.t
module TL_map : CCMap.S with type key = value list
val empty : t
val is_empty : t -> bool
val add_fun_entry : fun_ -> value list -> value -> t -> t
val get_fun_entry : fun_ -> value list -> t -> value option
val get_fun_entries : fun_ -> t -> value TL_map.t option
val iter_fun_entries : t -> (fun_ * value TL_map.t) Iter.t
val eval : Sidekick_core.Term.t -> t -> value option
include Sidekick_sigs.PRINT with type t := t

diff --git a/dev/sidekick-base/Sidekick_smtlib/Solver/index.html b/dev/sidekick-base/Sidekick_smtlib/Solver/index.html
index 92989135..2aec5727 100644
--- a/dev/sidekick-base/Sidekick_smtlib/Solver/index.html
+++ b/dev/sidekick-base/Sidekick_smtlib/Solver/index.html
@@ -1,2 +1,2 @@
 
-Solver (sidekick-base.Sidekick_smtlib.Solver)
Module Sidekick_smtlib.Solver
module Smt_solver = Sidekick_smt_solver
type t = Asolver.t
type cdcl_theory = Smt_solver.theory

+Solver (sidekick-base.Sidekick_smtlib.Solver)
Module Sidekick_smtlib.Solver
module Smt_solver = Sidekick_smt_solver
type t = Asolver.t
type cdcl_theory = Smt_solver.theory

diff --git a/dev/sidekick-base/Sidekick_smtlib/index.html b/dev/sidekick-base/Sidekick_smtlib/index.html
index 4dedd8c9..c57e3ef5 100644
--- a/dev/sidekick-base/Sidekick_smtlib/index.html
+++ b/dev/sidekick-base/Sidekick_smtlib/index.html
@@ -1,2 +1,2 @@
 
-Sidekick_smtlib (sidekick-base.Sidekick_smtlib)
Module Sidekick_smtlib
SMTLib-2.6 Driver
This library provides a parser, a type-checker, and a driver for processing SMTLib-2 problems.
type 'a or_error = ('a, string) CCResult.t
module Term = Sidekick_base.Term
module Driver : sig ... end
Driver.
module Solver : sig ... end
module Check_cc : sig ... end
module Model : sig ... end
Models
val parse : Term.store -> string -> Stmt.t list or_error
val parse_stdin : Term.store -> Stmt.t list or_error

+Sidekick_smtlib (sidekick-base.Sidekick_smtlib)
Module Sidekick_smtlib
SMTLib-2.6 Driver
This library provides a parser, a type-checker, and a driver for processing SMTLib-2 problems.
type 'a or_error = ('a, string) CCResult.t
module Term = Sidekick_base.Term
module Driver : sig ... end
Driver.
module Solver : sig ... end
module Check_cc : sig ... end
module Model : sig ... end
Models
val parse : Term.store -> string -> Stmt.t list or_error
val parse_stdin : Term.store -> Stmt.t list or_error

diff --git a/dev/sidekick-base/index.html b/dev/sidekick-base/index.html
index 9e25a301..d0ca19f0 100644
--- a/dev/sidekick-base/index.html
+++ b/dev/sidekick-base/index.html
@@ -1,2 +1,2 @@
 
-index (sidekick-base.index)
sidekick-base index
Library sidekick-base
The entry point of this library is the module: Sidekick_base.
Library sidekick-base.smtlib
The entry point of this library is the module: Sidekick_smtlib.

+index (sidekick-base.index)
sidekick-base index
Library sidekick-base
The entry point of this library is the module: Sidekick_base.
Library sidekick-base.smtlib
The entry point of this library is the module: Sidekick_smtlib.

diff --git a/dev/sidekick-bin/Sidekick_bin_lib/Dimacs_lexer/index.html b/dev/sidekick-bin/Sidekick_bin_lib/Dimacs_lexer/index.html
index 5744af7d..5e4dcdc8 100644
--- a/dev/sidekick-bin/Sidekick_bin_lib/Dimacs_lexer/index.html
+++ b/dev/sidekick-bin/Sidekick_bin_lib/Dimacs_lexer/index.html
@@ -1,2 +1,2 @@
 
-Dimacs_lexer (sidekick-bin.Sidekick_bin_lib.Dimacs_lexer)
Module Sidekick_bin_lib.Dimacs_lexer
type token = 
  1. | EOF
  2. | P
  3. | CNF
  4. | ZERO
  5. | LIT of int
val __ocaml_lex_tables : Stdlib.Lexing.lex_tables
val token : Stdlib.Lexing.lexbuf -> token
val __ocaml_lex_token_rec : Stdlib.Lexing.lexbuf -> int -> token
val comment : Stdlib.Lexing.lexbuf -> token
val __ocaml_lex_comment_rec : Stdlib.Lexing.lexbuf -> int -> token

+Dimacs_lexer (sidekick-bin.Sidekick_bin_lib.Dimacs_lexer)
Module Sidekick_bin_lib.Dimacs_lexer
type token = 
  1. | EOF
  2. | P
  3. | CNF
  4. | ZERO
  5. | LIT of int
val __ocaml_lex_tables : Stdlib.Lexing.lex_tables
val token : Stdlib.Lexing.lexbuf -> token
val __ocaml_lex_token_rec : Stdlib.Lexing.lexbuf -> int -> token
val comment : Stdlib.Lexing.lexbuf -> token
val __ocaml_lex_comment_rec : Stdlib.Lexing.lexbuf -> int -> token

diff --git a/dev/sidekick-bin/Sidekick_bin_lib/Dimacs_parser/index.html b/dev/sidekick-bin/Sidekick_bin_lib/Dimacs_parser/index.html
index a7e482ef..f55b2f92 100644
--- a/dev/sidekick-bin/Sidekick_bin_lib/Dimacs_parser/index.html
+++ b/dev/sidekick-bin/Sidekick_bin_lib/Dimacs_parser/index.html
@@ -1,2 +1,2 @@
 
-Dimacs_parser (sidekick-bin.Sidekick_bin_lib.Dimacs_parser)
Module Sidekick_bin_lib.Dimacs_parser
DIMACS parser
type t
val create : Stdlib.in_channel -> t
val parse_header : t -> int * int
val next_clause : t -> int list option
val iter : t -> int list Iter.t

+Dimacs_parser (sidekick-bin.Sidekick_bin_lib.Dimacs_parser)
Module Sidekick_bin_lib.Dimacs_parser
DIMACS parser
type t
val create : Stdlib.in_channel -> t
val parse_header : t -> int * int
val next_clause : t -> int list option
val iter : t -> int list Iter.t

diff --git a/dev/sidekick-bin/Sidekick_bin_lib/Drup_lexer/index.html b/dev/sidekick-bin/Sidekick_bin_lib/Drup_lexer/index.html
index 32645d93..9cb459d3 100644
--- a/dev/sidekick-bin/Sidekick_bin_lib/Drup_lexer/index.html
+++ b/dev/sidekick-bin/Sidekick_bin_lib/Drup_lexer/index.html
@@ -1,2 +1,2 @@
 
-Drup_lexer (sidekick-bin.Sidekick_bin_lib.Drup_lexer)
Module Sidekick_bin_lib.Drup_lexer
type token = 
  1. | EOF
  2. | ZERO
  3. | LIT of int
  4. | D
  5. | R
  6. | I
val __ocaml_lex_tables : Stdlib.Lexing.lex_tables
val token : Stdlib.Lexing.lexbuf -> token
val __ocaml_lex_token_rec : Stdlib.Lexing.lexbuf -> int -> token
val comment : Stdlib.Lexing.lexbuf -> token
val __ocaml_lex_comment_rec : Stdlib.Lexing.lexbuf -> int -> token

+Drup_lexer (sidekick-bin.Sidekick_bin_lib.Drup_lexer)
Module Sidekick_bin_lib.Drup_lexer
type token = 
  1. | EOF
  2. | ZERO
  3. | LIT of int
  4. | D
  5. | R
  6. | I
val __ocaml_lex_tables : Stdlib.Lexing.lex_tables
val token : Stdlib.Lexing.lexbuf -> token
val __ocaml_lex_token_rec : Stdlib.Lexing.lexbuf -> int -> token
val comment : Stdlib.Lexing.lexbuf -> token
val __ocaml_lex_comment_rec : Stdlib.Lexing.lexbuf -> int -> token

diff --git a/dev/sidekick-bin/Sidekick_bin_lib/Drup_parser/index.html b/dev/sidekick-bin/Sidekick_bin_lib/Drup_parser/index.html
index 47312d8e..6efd6423 100644
--- a/dev/sidekick-bin/Sidekick_bin_lib/Drup_parser/index.html
+++ b/dev/sidekick-bin/Sidekick_bin_lib/Drup_parser/index.html
@@ -1,2 +1,2 @@
 
-Drup_parser (sidekick-bin.Sidekick_bin_lib.Drup_parser)
Module Sidekick_bin_lib.Drup_parser
DRUP parser
type t
type event = 
  1. | Input of int list
  2. | Add of int list
  3. | Delete of int list
val create_chan : Stdlib.in_channel -> t
val create_string : string -> t
val next : t -> event option
val iter : t -> event Iter.t

+Drup_parser (sidekick-bin.Sidekick_bin_lib.Drup_parser)
Module Sidekick_bin_lib.Drup_parser
DRUP parser
type t
type event = 
  1. | Input of int list
  2. | Add of int list
  3. | Delete of int list
val create_chan : Stdlib.in_channel -> t
val create_string : string -> t
val next : t -> event option
val iter : t -> event Iter.t

diff --git a/dev/sidekick-bin/Sidekick_bin_lib/Trace_setup/index.html b/dev/sidekick-bin/Sidekick_bin_lib/Trace_setup/index.html
index 8af0f865..5970dd4a 100644
--- a/dev/sidekick-bin/Sidekick_bin_lib/Trace_setup/index.html
+++ b/dev/sidekick-bin/Sidekick_bin_lib/Trace_setup/index.html
@@ -1,2 +1,2 @@
 
-Trace_setup (sidekick-bin.Sidekick_bin_lib.Trace_setup)
Module Sidekick_bin_lib.Trace_setup
val with_trace : (unit -> 'a) -> 'a

+Trace_setup (sidekick-bin.Sidekick_bin_lib.Trace_setup)
Module Sidekick_bin_lib.Trace_setup
val with_trace : (unit -> 'a) -> 'a

diff --git a/dev/sidekick-bin/Sidekick_bin_lib/index.html b/dev/sidekick-bin/Sidekick_bin_lib/index.html
index c9ca5de8..fa005dab 100644
--- a/dev/sidekick-bin/Sidekick_bin_lib/index.html
+++ b/dev/sidekick-bin/Sidekick_bin_lib/index.html
@@ -1,2 +1,2 @@
 
-Sidekick_bin_lib (sidekick-bin.Sidekick_bin_lib)
Module Sidekick_bin_lib
Library for the Sidekick executables
module Dimacs_lexer : sig ... end
module Dimacs_parser : sig ... end
module Drup_lexer : sig ... end
module Drup_parser : sig ... end
module Trace_setup : sig ... end

+Sidekick_bin_lib (sidekick-bin.Sidekick_bin_lib)
Module Sidekick_bin_lib
Library for the Sidekick executables
module Dimacs_lexer : sig ... end
module Dimacs_parser : sig ... end
module Drup_lexer : sig ... end
module Drup_parser : sig ... end
module Trace_setup : sig ... end

diff --git a/dev/sidekick-bin/index.html b/dev/sidekick-bin/index.html
index b0a5b974..d8c8e18f 100644
--- a/dev/sidekick-bin/index.html
+++ b/dev/sidekick-bin/index.html
@@ -1,2 +1,2 @@
 
-index (sidekick-bin.index)
sidekick-bin index
Library sidekick-bin.lib
The entry point of this library is the module: Sidekick_bin_lib.

+index (sidekick-bin.index)
sidekick-bin index
Library sidekick-bin.lib
The entry point of this library is the module: Sidekick_bin_lib.

diff --git a/dev/sidekick/Sidekick_abstract_solver/Asolver/class-type-t/index.html b/dev/sidekick/Sidekick_abstract_solver/Asolver/class-type-t/index.html
index ec635029..c2f5ac43 100644
--- a/dev/sidekick/Sidekick_abstract_solver/Asolver/class-type-t/index.html
+++ b/dev/sidekick/Sidekick_abstract_solver/Asolver/class-type-t/index.html
@@ -1,5 +1,5 @@
 
-t (sidekick.Sidekick_abstract_solver.Asolver.t)
Class type Asolver.t
method assert_term : Sidekick_core.Term.t -> unit
Helper that turns the term into an atom, before adding the result to the solver as a unit clause assertion.
This uses Proof_sat.sat_input_clause to justify the assertion.
method assert_clause : Sidekick_core.Lit.t array -> Proof.Pterm.delayed -> unit
add_clause solver cs adds a boolean clause to the solver. Subsequent calls to solve will need to satisfy this clause.
method assert_clause_l : Sidekick_core.Lit.t list ->
+t (sidekick.Sidekick_abstract_solver.Asolver.t)
Class type Asolver.t
method assert_term : Sidekick_core.Term.t -> unit
Helper that turns the term into an atom, before adding the result to the solver as a unit clause assertion.
This uses Proof_sat.sat_input_clause to justify the assertion.
method assert_clause : Sidekick_core.Lit.t array -> Proof.Pterm.delayed -> unit
add_clause solver cs adds a boolean clause to the solver. Subsequent calls to solve will need to satisfy this clause.
method assert_clause_l : Sidekick_core.Lit.t list ->
   Proof.Pterm.delayed ->
   unit
Add a clause to the solver, given as a list.
method add_ty : ty:Sidekick_core.Term.t -> unit
Add a new sort/atomic type.
method lit_of_term : ?sign:bool -> Sidekick_core.Term.t -> Sidekick_core.Lit.t
Convert a term into a simplified literal.
method solve : ?on_exit:(unit -> unit) list ->
   ?on_progress:(unit -> unit) ->
diff --git a/dev/sidekick/Sidekick_abstract_solver/Asolver/index.html b/dev/sidekick/Sidekick_abstract_solver/Asolver/index.html
index 268f2273..3dc81b96 100644
--- a/dev/sidekick/Sidekick_abstract_solver/Asolver/index.html
+++ b/dev/sidekick/Sidekick_abstract_solver/Asolver/index.html
@@ -1,5 +1,5 @@
 
-Asolver (sidekick.Sidekick_abstract_solver.Asolver)
Module Sidekick_abstract_solver.Asolver
Abstract interface for a solver
module Unknown = Unknown
module Check_res = Check_res
module Proof = Sidekick_proof
class type  t = object ... end
val assert_term : t -> Sidekick_core.Term.t -> unit
val assert_clause : 
+Asolver (sidekick.Sidekick_abstract_solver.Asolver)
Module Sidekick_abstract_solver.Asolver
Abstract interface for a solver
module Unknown = Unknown
module Check_res = Check_res
module Proof = Sidekick_proof
class type  t = object ... end
val assert_term : t -> Sidekick_core.Term.t -> unit
val assert_clause : 
   t ->
   Sidekick_core.Lit.t array ->
   Proof.Pterm.delayed ->
diff --git a/dev/sidekick/Sidekick_abstract_solver/Check_res/index.html b/dev/sidekick/Sidekick_abstract_solver/Check_res/index.html
index ca1e4f38..bc360796 100644
--- a/dev/sidekick/Sidekick_abstract_solver/Check_res/index.html
+++ b/dev/sidekick/Sidekick_abstract_solver/Check_res/index.html
@@ -1,2 +1,2 @@
 
-Check_res (sidekick.Sidekick_abstract_solver.Check_res)
Module Sidekick_abstract_solver.Check_res
Result of solving for the current set of clauses
type sat_result = {
  1. get_value : Sidekick_core.Term.t -> value option;
    (*
    Value for this term
    *)
  2. iter_classes : (Sidekick_core.Term.t Iter.t * value) Iter.t;
    (*
    All equivalence classes in the congruence closure
    *)
  3. eval_lit : Sidekick_core.Lit.t -> bool option;
    (*
    Evaluate literal
    *)
  4. iter_true_lits : Sidekick_core.Lit.t Iter.t;
    (*
    Iterate on literals that are true in the trail
    *)
}
Satisfiable
type unsat_result = {
  1. unsat_core : unit -> Sidekick_core.Lit.t Iter.t;
    (*
    Unsat core (subset of assumptions), or empty
    *)
  2. unsat_proof : unit -> Sidekick_proof.Step.id option;
    (*
    Proof step for the empty clause
    *)
}
Unsatisfiable
type t = 
  1. | Sat of sat_result
  2. | Unsat of unsat_result
  3. | Unknown of Unknown.t
    (*
    Unknown, obtained after a timeout, memory limit, etc.
    *)
Result of calling "check"
val pp : Sidekick_core.Fmt.t -> t -> unit

+Check_res (sidekick.Sidekick_abstract_solver.Check_res)
Module Sidekick_abstract_solver.Check_res
Result of solving for the current set of clauses
type sat_result = {
  1. get_value : Sidekick_core.Term.t -> value option;
    (*
    Value for this term
    *)
  2. iter_classes : (Sidekick_core.Term.t Iter.t * value) Iter.t;
    (*
    All equivalence classes in the congruence closure
    *)
  3. eval_lit : Sidekick_core.Lit.t -> bool option;
    (*
    Evaluate literal
    *)
  4. iter_true_lits : Sidekick_core.Lit.t Iter.t;
    (*
    Iterate on literals that are true in the trail
    *)
}
Satisfiable
type unsat_result = {
  1. unsat_core : unit -> Sidekick_core.Lit.t Iter.t;
    (*
    Unsat core (subset of assumptions), or empty
    *)
  2. unsat_proof : unit -> Sidekick_proof.Step.id option;
    (*
    Proof step for the empty clause
    *)
}
Unsatisfiable
type t = 
  1. | Sat of sat_result
  2. | Unsat of unsat_result
  3. | Unknown of Unknown.t
    (*
    Unknown, obtained after a timeout, memory limit, etc.
    *)
Result of calling "check"
val pp : Sidekick_core.Fmt.t -> t -> unit

diff --git a/dev/sidekick/Sidekick_abstract_solver/Unknown/index.html b/dev/sidekick/Sidekick_abstract_solver/Unknown/index.html
index 8e3f00c0..74cef914 100644
--- a/dev/sidekick/Sidekick_abstract_solver/Unknown/index.html
+++ b/dev/sidekick/Sidekick_abstract_solver/Unknown/index.html
@@ -1,2 +1,2 @@
 
-Unknown (sidekick.Sidekick_abstract_solver.Unknown)
Module Sidekick_abstract_solver.Unknown
type t = 
  1. | U_timeout
  2. | U_max_depth
  3. | U_incomplete
  4. | U_asked_to_stop
val pp : t Sidekick_core.Fmt.printer

+Unknown (sidekick.Sidekick_abstract_solver.Unknown)
Module Sidekick_abstract_solver.Unknown
type t = 
  1. | U_timeout
  2. | U_max_depth
  3. | U_incomplete
  4. | U_asked_to_stop
val pp : t Sidekick_core.Fmt.printer

diff --git a/dev/sidekick/Sidekick_abstract_solver/class-type-t/index.html b/dev/sidekick/Sidekick_abstract_solver/class-type-t/index.html
index 093292f1..69f7d134 100644
--- a/dev/sidekick/Sidekick_abstract_solver/class-type-t/index.html
+++ b/dev/sidekick/Sidekick_abstract_solver/class-type-t/index.html
@@ -1,5 +1,5 @@
 
-t (sidekick.Sidekick_abstract_solver.t)
Class type Sidekick_abstract_solver.t
Main abstract solver type
method assert_term : Sidekick_core.Term.t -> unit
Helper that turns the term into an atom, before adding the result to the solver as a unit clause assertion.
This uses Proof_sat.sat_input_clause to justify the assertion.
method assert_clause : Sidekick_core.Lit.t array ->
+t (sidekick.Sidekick_abstract_solver.t)
Class type Sidekick_abstract_solver.t
Main abstract solver type
method assert_term : Sidekick_core.Term.t -> unit
Helper that turns the term into an atom, before adding the result to the solver as a unit clause assertion.
This uses Proof_sat.sat_input_clause to justify the assertion.
method assert_clause : Sidekick_core.Lit.t array ->
   Asolver.Proof.Pterm.delayed ->
   unit
add_clause solver cs adds a boolean clause to the solver. Subsequent calls to solve will need to satisfy this clause.
method assert_clause_l : Sidekick_core.Lit.t list ->
   Asolver.Proof.Pterm.delayed ->
diff --git a/dev/sidekick/Sidekick_abstract_solver/index.html b/dev/sidekick/Sidekick_abstract_solver/index.html
index c22b7d06..078f7f59 100644
--- a/dev/sidekick/Sidekick_abstract_solver/index.html
+++ b/dev/sidekick/Sidekick_abstract_solver/index.html
@@ -1,2 +1,2 @@
 
-Sidekick_abstract_solver (sidekick.Sidekick_abstract_solver)
Module Sidekick_abstract_solver
Abstract interface for a solver
module Unknown : sig ... end
module Check_res : sig ... end
Result of solving for the current set of clauses
module Asolver : sig ... end
Abstract interface for a solver
class type  t = Asolver.t
Main abstract solver type

+Sidekick_abstract_solver (sidekick.Sidekick_abstract_solver)
Module Sidekick_abstract_solver
Abstract interface for a solver
module Unknown : sig ... end
module Check_res : sig ... end
Result of solving for the current set of clauses
module Asolver : sig ... end
Abstract interface for a solver
class type  t = Asolver.t
Main abstract solver type

diff --git a/dev/sidekick/Sidekick_arith/index.html b/dev/sidekick/Sidekick_arith/index.html
index 62092457..86b113f4 100644
--- a/dev/sidekick/Sidekick_arith/index.html
+++ b/dev/sidekick/Sidekick_arith/index.html
@@ -1,2 +1,2 @@
 
-Sidekick_arith (sidekick.Sidekick_arith)
Module Sidekick_arith
module type NUM = sig ... end
module type INT = sig ... end
module type RATIONAL = sig ... end
module type INT_FULL = sig ... end

+Sidekick_arith (sidekick.Sidekick_arith)
Module Sidekick_arith
module type NUM = sig ... end
module type INT = sig ... end
module type RATIONAL = sig ... end
module type INT_FULL = sig ... end

diff --git a/dev/sidekick/Sidekick_arith/module-type-INT/index.html b/dev/sidekick/Sidekick_arith/module-type-INT/index.html
index 501f0f9e..a1ecd5cc 100644
--- a/dev/sidekick/Sidekick_arith/module-type-INT/index.html
+++ b/dev/sidekick/Sidekick_arith/module-type-INT/index.html
@@ -1,2 +1,2 @@
 
-INT (sidekick.Sidekick_arith.INT)
Module type Sidekick_arith.INT
include 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
val to_string : t -> string
val of_string : string -> t option
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 (+) : 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

+INT (sidekick.Sidekick_arith.INT)
Module type Sidekick_arith.INT
include 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
val to_string : t -> string
val of_string : string -> t option
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 (+) : 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

diff --git a/dev/sidekick/Sidekick_arith/module-type-INT_FULL/index.html b/dev/sidekick/Sidekick_arith/module-type-INT_FULL/index.html
index 5dfb1e75..0485510a 100644
--- a/dev/sidekick/Sidekick_arith/module-type-INT_FULL/index.html
+++ b/dev/sidekick/Sidekick_arith/module-type-INT_FULL/index.html
@@ -1,2 +1,2 @@
 
-INT_FULL (sidekick.Sidekick_arith.INT_FULL)
Module type Sidekick_arith.INT_FULL
include INT
include 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
val to_string : t -> string
val of_string : string -> t option
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 (+) : 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

+INT_FULL (sidekick.Sidekick_arith.INT_FULL)
Module type Sidekick_arith.INT_FULL
include INT
include 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
val to_string : t -> string
val of_string : string -> t option
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 (+) : 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

diff --git a/dev/sidekick/Sidekick_arith/module-type-NUM/index.html b/dev/sidekick/Sidekick_arith/module-type-NUM/index.html
index 590cfed6..f92ddc6f 100644
--- a/dev/sidekick/Sidekick_arith/module-type-NUM/index.html
+++ b/dev/sidekick/Sidekick_arith/module-type-NUM/index.html
@@ -1,2 +1,2 @@
 
-NUM (sidekick.Sidekick_arith.NUM)
Module type 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
val to_string : t -> string
val of_string : string -> t option
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 (+) : 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

+NUM (sidekick.Sidekick_arith.NUM)
Module type 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
val to_string : t -> string
val of_string : string -> t option
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 (+) : 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

diff --git a/dev/sidekick/Sidekick_arith/module-type-RATIONAL/index.html b/dev/sidekick/Sidekick_arith/module-type-RATIONAL/index.html
index 811f788b..8ed6c589 100644
--- a/dev/sidekick/Sidekick_arith/module-type-RATIONAL/index.html
+++ b/dev/sidekick/Sidekick_arith/module-type-RATIONAL/index.html
@@ -1,2 +1,2 @@
 
-RATIONAL (sidekick.Sidekick_arith.RATIONAL)
Module type Sidekick_arith.RATIONAL
include 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
val to_string : t -> string
val of_string : string -> t option
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 (+) : 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
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)

+RATIONAL (sidekick.Sidekick_arith.RATIONAL)
Module type Sidekick_arith.RATIONAL
include 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
val to_string : t -> string
val of_string : string -> t option
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 (+) : 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
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)

diff --git a/dev/sidekick/Sidekick_bencode/Decode/index.html b/dev/sidekick/Sidekick_bencode/Decode/index.html
index 82b4dc90..46634cb7 100644
--- a/dev/sidekick/Sidekick_bencode/Decode/index.html
+++ b/dev/sidekick/Sidekick_bencode/Decode/index.html
@@ -1,2 +1,2 @@
 
-Decode (sidekick.Sidekick_bencode.Decode)
Module Sidekick_bencode.Decode
val of_string : ?idx:int -> string -> (int * t) option
Decode string, and also return how many bytes were consumed.
  • parameter idx 
    initial index (default 0)
val of_string_exn : ?idx:int -> string -> int * t
Parse string.
  • raises Error.Error 
    if the string is not valid bencode.

+Decode (sidekick.Sidekick_bencode.Decode)
Module Sidekick_bencode.Decode
val of_string : ?idx:int -> string -> (int * t) option
Decode string, and also return how many bytes were consumed.
  • parameter idx 
    initial index (default 0)
val of_string_exn : ?idx:int -> string -> int * t
Parse string.
  • raises Error.Error 
    if the string is not valid bencode.

diff --git a/dev/sidekick/Sidekick_bencode/Encode/index.html b/dev/sidekick/Sidekick_bencode/Encode/index.html
index ecd85c2d..9ce5c004 100644
--- a/dev/sidekick/Sidekick_bencode/Encode/index.html
+++ b/dev/sidekick/Sidekick_bencode/Encode/index.html
@@ -1,2 +1,2 @@
 
-Encode (sidekick.Sidekick_bencode.Encode)
Module Sidekick_bencode.Encode
val to_buffer : Stdlib.Buffer.t -> t -> unit
val to_string : t -> string

+Encode (sidekick.Sidekick_bencode.Encode)
Module Sidekick_bencode.Encode
val to_buffer : Stdlib.Buffer.t -> t -> unit
val to_string : t -> string

diff --git a/dev/sidekick/Sidekick_bencode/index.html b/dev/sidekick/Sidekick_bencode/index.html
index eb2018c1..5e0d903f 100644
--- a/dev/sidekick/Sidekick_bencode/index.html
+++ b/dev/sidekick/Sidekick_bencode/index.html
@@ -1,2 +1,2 @@
 
-Sidekick_bencode (sidekick.Sidekick_bencode)
Module Sidekick_bencode
module Encode : sig ... end
module Decode : sig ... end

+Sidekick_bencode (sidekick.Sidekick_bencode)
Module Sidekick_bencode
module Encode : sig ... end
module Decode : sig ... end

diff --git a/dev/sidekick/Sidekick_cc/CC/Handler_action/index.html b/dev/sidekick/Sidekick_cc/CC/Handler_action/index.html
index 4a59c37c..78a96d0a 100644
--- a/dev/sidekick/Sidekick_cc/CC/Handler_action/index.html
+++ b/dev/sidekick/Sidekick_cc/CC/Handler_action/index.html
@@ -1,2 +1,2 @@
 
-Handler_action (sidekick.Sidekick_cc.CC.Handler_action)
Module CC.Handler_action
Handler Actions
Actions that can be scheduled by event handlers.
type t = 
  1. | Act_merge of E_node.t * E_node.t * Expl.t
  2. | Act_propagate of Sidekick_core.Lit.t * propagation_reason
type conflict = 
  1. | Conflict of Expl.t
type or_conflict = (t list, conflict) Stdlib.result
Actions or conflict scheduled by an event handler.
  • Ok acts is a list of merges and propagations
  • Error confl is a conflict to resolve.

+Handler_action (sidekick.Sidekick_cc.CC.Handler_action)
Module CC.Handler_action
Handler Actions
Actions that can be scheduled by event handlers.
type t = 
  1. | Act_merge of E_node.t * E_node.t * Expl.t
  2. | Act_propagate of Sidekick_core.Lit.t * propagation_reason
type conflict = 
  1. | Conflict of Expl.t
type or_conflict = (t list, conflict) Stdlib.result
Actions or conflict scheduled by an event handler.
  • Ok acts is a list of merges and propagations
  • Error confl is a conflict to resolve.

diff --git a/dev/sidekick/Sidekick_cc/CC/Make/argument-1-_/index.html b/dev/sidekick/Sidekick_cc/CC/Make/argument-1-_/index.html
index 1b2a7029..074ca373 100644
--- a/dev/sidekick/Sidekick_cc/CC/Make/argument-1-_/index.html
+++ b/dev/sidekick/Sidekick_cc/CC/Make/argument-1-_/index.html
@@ -1,2 +1,2 @@
 
-_ (sidekick.Sidekick_cc.CC.Make._)
Parameter Make._
val view_as_cc : view_as_cc
View the Term.t through the lens of the congruence closure

+_ (sidekick.Sidekick_cc.CC.Make._)
Parameter Make._
val view_as_cc : view_as_cc
View the Term.t through the lens of the congruence closure

diff --git a/dev/sidekick/Sidekick_cc/CC/Make/index.html b/dev/sidekick/Sidekick_cc/CC/Make/index.html
index 9424f7ee..5f1b2067 100644
--- a/dev/sidekick/Sidekick_cc/CC/Make/index.html
+++ b/dev/sidekick/Sidekick_cc/CC/Make/index.html
@@ -1,5 +1,5 @@
 
-Make (sidekick.Sidekick_cc.CC.Make)
Module CC.Make
Parameters
module _ : ARG
Signature
val create : 
+Make (sidekick.Sidekick_cc.CC.Make)
Module CC.Make
Parameters
module _ : ARG
Signature
val create : 
   ?stat:Sidekick_util.Stat.t ->
   ?size:[ `Small | `Big ] ->
   Sidekick_core.Term.store ->
diff --git a/dev/sidekick/Sidekick_cc/CC/Result_action/index.html b/dev/sidekick/Sidekick_cc/CC/Result_action/index.html
index a0b4f9a3..bdeeec7d 100644
--- a/dev/sidekick/Sidekick_cc/CC/Result_action/index.html
+++ b/dev/sidekick/Sidekick_cc/CC/Result_action/index.html
@@ -1,2 +1,2 @@
 
-Result_action (sidekick.Sidekick_cc.CC.Result_action)
Module CC.Result_action
Result Actions.
Actions returned by the congruence closure after calling check.
type t = 
  1. | Act_propagate of {
    1. lit : Sidekick_core.Lit.t;
    2. reason : propagation_reason;
    }
    (*
    propagate (Lit.t, reason) declares that reason() => Lit.t is a tautology.
    • reason() should return a list of literals that are currently true, as well as a proof.
    • Lit.t should be a literal of interest (see S.set_as_lit).
    This function might never be called, a congruence closure has the right to not propagate and only trigger conflicts.
    *)
type conflict = 
  1. | Conflict of Sidekick_core.Lit.t list * Sidekick_proof.Step.id
    (*
    raise_conflict (c,pr) declares that c is a tautology of the theory of congruence.
    • parameter pr 
      the proof of c being a tautology
    *)
type or_conflict = (t list, conflict) Stdlib.result

+Result_action (sidekick.Sidekick_cc.CC.Result_action)
Module CC.Result_action
Result Actions.
Actions returned by the congruence closure after calling check.
type t = 
  1. | Act_propagate of {
    1. lit : Sidekick_core.Lit.t;
    2. reason : propagation_reason;
    }
    (*
    propagate (Lit.t, reason) declares that reason() => Lit.t is a tautology.
    • reason() should return a list of literals that are currently true, as well as a proof.
    • Lit.t should be a literal of interest (see S.set_as_lit).
    This function might never be called, a congruence closure has the right to not propagate and only trigger conflicts.
    *)
type conflict = 
  1. | Conflict of Sidekick_core.Lit.t list * Sidekick_proof.Step.id
    (*
    raise_conflict (c,pr) declares that c is a tautology of the theory of congruence.
    • parameter pr 
      the proof of c being a tautology
    *)
type or_conflict = (t list, conflict) Stdlib.result

diff --git a/dev/sidekick/Sidekick_cc/CC/index.html b/dev/sidekick/Sidekick_cc/CC/index.html
index c3c6a4a9..82ebe200 100644
--- a/dev/sidekick/Sidekick_cc/CC/index.html
+++ b/dev/sidekick/Sidekick_cc/CC/index.html
@@ -1,5 +1,5 @@
 
-CC (sidekick.Sidekick_cc.CC)
Module Sidekick_cc.CC
Main congruence closure signature.
The congruence closure handles the theory QF_UF (uninterpreted function symbols). It is also responsible for theory combination, and provides a general framework for equality reasoning that other theories piggyback on.
For example, the theory of datatypes relies on the congruence closure to do most of the work, and "only" adds injectivity/disjointness/acyclicity lemmas when needed.
Similarly, a theory of arrays would hook into the congruence closure and assert (dis)equalities as needed.
type e_node = E_node.t
A node of the congruence closure
type repr = E_node.t
Node that is currently a representative.
type explanation = Expl.t
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 allocate_bitfield.
All fields are initially 0, are backtracked automatically, and are merged automatically when classes are merged.
type t
The congruence closure object. It contains a fair amount of state and is mutable and backtrackable.
Accessors
val term_store : t -> Sidekick_core.Term.store
val proof_tracer : t -> Sidekick_proof.Tracer.t
val stat : t -> Sidekick_util.Stat.t
val find : t -> e_node -> repr
Current representative
val add_term : t -> Sidekick_core.Term.t -> e_node
Add the Term.t to the congruence closure, if not present already. Will be backtracked.
val mem_term : t -> Sidekick_core.Term.t -> bool
Returns true if the Term.t is explicitly present in the congruence closure
val allocate_bitfield : t -> descr:string -> bitfield
Allocate a new e_node field (see E_node.bitfield).
This field descriptor is henceforth reserved for all nodes in this congruence closure, and can be set using set_bitfield for each class_ 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.t 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 -> bitfield -> E_node.t -> bool
Access the bit field of the given e_node
val set_bitfield : t -> bitfield -> bool -> E_node.t -> unit
Set the bitfield for the e_node. This will be backtracked. See E_node.bitfield.
type propagation_reason =
+CC (sidekick.Sidekick_cc.CC)
Module Sidekick_cc.CC
Main congruence closure signature.
The congruence closure handles the theory QF_UF (uninterpreted function symbols). It is also responsible for theory combination, and provides a general framework for equality reasoning that other theories piggyback on.
For example, the theory of datatypes relies on the congruence closure to do most of the work, and "only" adds injectivity/disjointness/acyclicity lemmas when needed.
Similarly, a theory of arrays would hook into the congruence closure and assert (dis)equalities as needed.
type e_node = E_node.t
A node of the congruence closure
type repr = E_node.t
Node that is currently a representative.
type explanation = Expl.t
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 allocate_bitfield.
All fields are initially 0, are backtracked automatically, and are merged automatically when classes are merged.
type t
The congruence closure object. It contains a fair amount of state and is mutable and backtrackable.
Accessors
val term_store : t -> Sidekick_core.Term.store
val proof_tracer : t -> Sidekick_proof.Tracer.t
val stat : t -> Sidekick_util.Stat.t
val find : t -> e_node -> repr
Current representative
val add_term : t -> Sidekick_core.Term.t -> e_node
Add the Term.t to the congruence closure, if not present already. Will be backtracked.
val mem_term : t -> Sidekick_core.Term.t -> bool
Returns true if the Term.t is explicitly present in the congruence closure
val allocate_bitfield : t -> descr:string -> bitfield
Allocate a new e_node field (see E_node.bitfield).
This field descriptor is henceforth reserved for all nodes in this congruence closure, and can be set using set_bitfield for each class_ 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.t 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 -> bitfield -> E_node.t -> bool
Access the bit field of the given e_node
val set_bitfield : t -> bitfield -> bool -> E_node.t -> unit
Set the bitfield for the e_node. This will be backtracked. See E_node.bitfield.
type propagation_reason =
   unit ->
   Sidekick_core.Lit.t list * Sidekick_proof.Pterm.delayed
module Handler_action : sig ... end
Handler Actions
module Result_action : sig ... end
Result Actions.
Events
Events triggered by the congruence closure, to which other plugins can subscribe.
val on_pre_merge : 
   t ->
diff --git a/dev/sidekick/Sidekick_cc/CC/module-type-ARG/index.html b/dev/sidekick/Sidekick_cc/CC/module-type-ARG/index.html
index 62ea3cbc..87d01379 100644
--- a/dev/sidekick/Sidekick_cc/CC/module-type-ARG/index.html
+++ b/dev/sidekick/Sidekick_cc/CC/module-type-ARG/index.html
@@ -1,2 +1,2 @@
 
-ARG (sidekick.Sidekick_cc.CC.ARG)
Module type CC.ARG
Arguments to a congruence closure's implementation
val view_as_cc : view_as_cc
View the Term.t through the lens of the congruence closure

+ARG (sidekick.Sidekick_cc.CC.ARG)
Module type CC.ARG
Arguments to a congruence closure's implementation
val view_as_cc : view_as_cc
View the Term.t through the lens of the congruence closure

diff --git a/dev/sidekick/Sidekick_cc/CC/module-type-BUILD/index.html b/dev/sidekick/Sidekick_cc/CC/module-type-BUILD/index.html
index 51914a5f..e1e0fec1 100644
--- a/dev/sidekick/Sidekick_cc/CC/module-type-BUILD/index.html
+++ b/dev/sidekick/Sidekick_cc/CC/module-type-BUILD/index.html
@@ -1,5 +1,5 @@
 
-BUILD (sidekick.Sidekick_cc.CC.BUILD)
Module type CC.BUILD
val create : 
+BUILD (sidekick.Sidekick_cc.CC.BUILD)
Module type CC.BUILD
val create : 
   ?stat:Sidekick_util.Stat.t ->
   ?size:[ `Small | `Big ] ->
   Sidekick_core.Term.store ->
diff --git a/dev/sidekick/Sidekick_cc/E_node/Internal_/index.html b/dev/sidekick/Sidekick_cc/E_node/Internal_/index.html
index b4e9f2ed..e2928e17 100644
--- a/dev/sidekick/Sidekick_cc/E_node/Internal_/index.html
+++ b/dev/sidekick/Sidekick_cc/E_node/Internal_/index.html
@@ -1,2 +1,2 @@
 
-Internal_ (sidekick.Sidekick_cc.E_node.Internal_)
Module E_node.Internal_
val iter_class_ : t -> t Iter.t
val make : Sidekick_core.Term.t -> t

+Internal_ (sidekick.Sidekick_cc.E_node.Internal_)
Module E_node.Internal_
val iter_class_ : t -> t Iter.t
val make : Sidekick_core.Term.t -> t

diff --git a/dev/sidekick/Sidekick_cc/E_node/index.html b/dev/sidekick/Sidekick_cc/E_node/index.html
index eea6f705..65fdfc7d 100644
--- a/dev/sidekick/Sidekick_cc/E_node/index.html
+++ b/dev/sidekick/Sidekick_cc/E_node/index.html
@@ -1,2 +1,2 @@
 
-E_node (sidekick.Sidekick_cc.E_node)
Module Sidekick_cc.E_node
E-node.
An e-node is a node in the congruence closure that is contained in some equivalence classe). 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 its representative's E_node.t.
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 E-node.
A value of type t points to a particular Term.t, but see find to get the representative of the class.
include Sidekick_sigs.PRINT with type t := t
val term : t -> Sidekick_core.Term.t
Term contained in this equivalence class. If is_root n, then Term.t n is the class' representative Term.t.
val equal : t -> t -> bool
Are two classes physically equal? To check for logical equality, use CC.E_node.equal (CC.find cc n1) (CC.find cc n2) which checks for equality of representatives.
val hash : t -> int
An opaque hash of this E_node.t.
val is_root : t -> bool
Is the E_node.t 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)
val as_lit : t -> Sidekick_core.Lit.t option
val swap_next : t -> t -> unit
Swap the next pointer of each node. If their classes were disjoint, they are now unioned.
module Internal_ : sig ... end

+E_node (sidekick.Sidekick_cc.E_node)
Module Sidekick_cc.E_node
E-node.
An e-node is a node in the congruence closure that is contained in some equivalence classe). 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 its representative's E_node.t.
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 E-node.
A value of type t points to a particular Term.t, but see find to get the representative of the class.
include Sidekick_sigs.PRINT with type t := t
val term : t -> Sidekick_core.Term.t
Term contained in this equivalence class. If is_root n, then Term.t n is the class' representative Term.t.
val equal : t -> t -> bool
Are two classes physically equal? To check for logical equality, use CC.E_node.equal (CC.find cc n1) (CC.find cc n2) which checks for equality of representatives.
val hash : t -> int
An opaque hash of this E_node.t.
val is_root : t -> bool
Is the E_node.t 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)
val as_lit : t -> Sidekick_core.Lit.t option
val swap_next : t -> t -> unit
Swap the next pointer of each node. If their classes were disjoint, they are now unioned.
module Internal_ : sig ... end

diff --git a/dev/sidekick/Sidekick_cc/Expl/index.html b/dev/sidekick/Sidekick_cc/Expl/index.html
index bce7be4d..7c988280 100644
--- a/dev/sidekick/Sidekick_cc/Expl/index.html
+++ b/dev/sidekick/Sidekick_cc/Expl/index.html
@@ -1,5 +1,5 @@
 
-Expl (sidekick.Sidekick_cc.Expl)
Module Sidekick_cc.Expl
Explanations
Explanations are specialized proofs, created by the congruence closure when asked to justify why two terms are equal.
type t
include Sidekick_sigs.PRINT with type t := t
val mk_merge : E_node.t -> E_node.t -> t
Explanation: the nodes were explicitly merged
Explanation: the terms were explicitly merged
val mk_lit : Sidekick_core.Lit.t -> 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_list : t list -> t
Conjunction of explanations
val mk_congruence : E_node.t -> E_node.t -> t
val mk_theory : 
+Expl (sidekick.Sidekick_cc.Expl)
Module Sidekick_cc.Expl
Explanations
Explanations are specialized proofs, created by the congruence closure when asked to justify why two terms are equal.
type t
include Sidekick_sigs.PRINT with type t := t
val mk_merge : E_node.t -> E_node.t -> t
Explanation: the nodes were explicitly merged
Explanation: the terms were explicitly merged
val mk_lit : Sidekick_core.Lit.t -> 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_list : t list -> t
Conjunction of explanations
val mk_congruence : E_node.t -> E_node.t -> t
val mk_theory : 
   Sidekick_core.Term.t ->
   Sidekick_core.Term.t ->
   (Sidekick_core.Term.t * Sidekick_core.Term.t * t list) list ->
diff --git a/dev/sidekick/Sidekick_cc/Plugin/Make/argument-1-M/index.html b/dev/sidekick/Sidekick_cc/Plugin/Make/argument-1-M/index.html
index bf321409..8bd6758f 100644
--- a/dev/sidekick/Sidekick_cc/Plugin/Make/argument-1-M/index.html
+++ b/dev/sidekick/Sidekick_cc/Plugin/Make/argument-1-M/index.html
@@ -1,5 +1,5 @@
 
-M (sidekick.Sidekick_cc.Plugin.Make.M)
Parameter Make.M
type t
Some type with a monoid structure
include Sidekick_sigs.PRINT with type t := t
type state
val create : CC.t -> state
Initialize state from the congruence closure
val name : string
name of the monoid structure (short)
val of_term : 
+M (sidekick.Sidekick_cc.Plugin.Make.M)
Parameter Make.M
type t
Some type with a monoid structure
include Sidekick_sigs.PRINT with type t := t
type state
val create : CC.t -> state
Initialize state from the congruence closure
val name : string
name of the monoid structure (short)
val of_term : 
   CC.t ->
   state ->
   E_node.t ->
diff --git a/dev/sidekick/Sidekick_cc/Plugin/Make/index.html b/dev/sidekick/Sidekick_cc/Plugin/Make/index.html
index 7c264155..f070c105 100644
--- a/dev/sidekick/Sidekick_cc/Plugin/Make/index.html
+++ b/dev/sidekick/Sidekick_cc/Plugin/Make/index.html
@@ -1,2 +1,2 @@
 
-Make (sidekick.Sidekick_cc.Plugin.Make)
Module Plugin.Make
Create a plugin builder from the given per-class monoid
Parameters
module M : sig ... end
Signature
module M = M
module type DYN_PL_FOR_M = sig ... end
type t = (module DYN_PL_FOR_M)
val create_and_setup : ?size:int -> CC.t -> t
Create a new monoid state
val mem : t -> E_node.t -> bool
Does the CC.E_node.t have a monoid value?
val get : t -> E_node.t -> M.t option
Get monoid value for this CC.E_node.t, if any
val iter_all : t -> (CC.repr * M.t) Iter.t
include Sidekick_sigs.BACKTRACKABLE0 with type t := t
val n_levels : t -> int
Number of levels
val push_level : t -> unit
Push a backtracking point
val pop_levels : t -> int -> unit
pop_levels st n removes n levels
include Sidekick_sigs.PRINT with type t := t

+Make (sidekick.Sidekick_cc.Plugin.Make)
Module Plugin.Make
Create a plugin builder from the given per-class monoid
Parameters
module M : sig ... end
Signature
module M = M
module type DYN_PL_FOR_M = sig ... end
type t = (module DYN_PL_FOR_M)
val create_and_setup : ?size:int -> CC.t -> t
Create a new monoid state
val mem : t -> E_node.t -> bool
Does the CC.E_node.t have a monoid value?
val get : t -> E_node.t -> M.t option
Get monoid value for this CC.E_node.t, if any
val iter_all : t -> (CC.repr * M.t) Iter.t
include Sidekick_sigs.BACKTRACKABLE0 with type t := t
val n_levels : t -> int
Number of levels
val push_level : t -> unit
Push a backtracking point
val pop_levels : t -> int -> unit
pop_levels st n removes n levels
include Sidekick_sigs.PRINT with type t := t

diff --git a/dev/sidekick/Sidekick_cc/Plugin/Make/module-type-DYN_PL_FOR_M/index.html b/dev/sidekick/Sidekick_cc/Plugin/Make/module-type-DYN_PL_FOR_M/index.html
index a797cd8c..416d3e4c 100644
--- a/dev/sidekick/Sidekick_cc/Plugin/Make/module-type-DYN_PL_FOR_M/index.html
+++ b/dev/sidekick/Sidekick_cc/Plugin/Make/module-type-DYN_PL_FOR_M/index.html
@@ -1,2 +1,2 @@
 
-DYN_PL_FOR_M (sidekick.Sidekick_cc.Plugin.Make.DYN_PL_FOR_M)
Module type Make.DYN_PL_FOR_M
module M = M
include Sidekick_sigs.DYN_BACKTRACKABLE
val n_levels : unit -> int
Number of levels
val push_level : unit -> unit
Push a backtracking point
val pop_levels : int -> unit
pop_levels n removes n levels
val pp : unit Sidekick_cc__.Types_.Fmt.printer
val mem : E_node.t -> bool
Does the CC E_node.t have a monoid value?
val get : E_node.t -> M.t option
Get monoid value for this CC E_node.t, if any
val iter_all : (CC.repr * M.t) Iter.t

+DYN_PL_FOR_M (sidekick.Sidekick_cc.Plugin.Make.DYN_PL_FOR_M)
Module type Make.DYN_PL_FOR_M
module M = M
include Sidekick_sigs.DYN_BACKTRACKABLE
val n_levels : unit -> int
Number of levels
val push_level : unit -> unit
Push a backtracking point
val pop_levels : int -> unit
pop_levels n removes n levels
val pp : unit Sidekick_cc__.Types_.Fmt.printer
val mem : E_node.t -> bool
Does the CC E_node.t have a monoid value?
val get : E_node.t -> M.t option
Get monoid value for this CC E_node.t, if any
val iter_all : (CC.repr * M.t) Iter.t

diff --git a/dev/sidekick/Sidekick_cc/Plugin/index.html b/dev/sidekick/Sidekick_cc/Plugin/index.html
index d95932ee..6301e8e0 100644
--- a/dev/sidekick/Sidekick_cc/Plugin/index.html
+++ b/dev/sidekick/Sidekick_cc/Plugin/index.html
@@ -1,2 +1,2 @@
 
-Plugin (sidekick.Sidekick_cc.Plugin)
Module Sidekick_cc.Plugin
Congruence Closure Plugin
module type EXTENDED_PLUGIN_BUILDER = sig ... end
module Make (M : sig ... end) : EXTENDED_PLUGIN_BUILDER with module M = M
Create a plugin builder from the given per-class monoid

+Plugin (sidekick.Sidekick_cc.Plugin)
Module Sidekick_cc.Plugin
Congruence Closure Plugin
module type EXTENDED_PLUGIN_BUILDER = sig ... end
module Make (M : sig ... end) : EXTENDED_PLUGIN_BUILDER with module M = M
Create a plugin builder from the given per-class monoid

diff --git a/dev/sidekick/Sidekick_cc/Plugin/module-type-EXTENDED_PLUGIN_BUILDER/M/index.html b/dev/sidekick/Sidekick_cc/Plugin/module-type-EXTENDED_PLUGIN_BUILDER/M/index.html
index 944b5844..2832052d 100644
--- a/dev/sidekick/Sidekick_cc/Plugin/module-type-EXTENDED_PLUGIN_BUILDER/M/index.html
+++ b/dev/sidekick/Sidekick_cc/Plugin/module-type-EXTENDED_PLUGIN_BUILDER/M/index.html
@@ -1,5 +1,5 @@
 
-M (sidekick.Sidekick_cc.Plugin.EXTENDED_PLUGIN_BUILDER.M)
Module EXTENDED_PLUGIN_BUILDER.M
type t
Some type with a monoid structure
include Sidekick_sigs.PRINT with type t := t
type state
val create : CC.t -> state
Initialize state from the congruence closure
val name : string
name of the monoid structure (short)
val of_term : 
+M (sidekick.Sidekick_cc.Plugin.EXTENDED_PLUGIN_BUILDER.M)
Module EXTENDED_PLUGIN_BUILDER.M
type t
Some type with a monoid structure
include Sidekick_sigs.PRINT with type t := t
type state
val create : CC.t -> state
Initialize state from the congruence closure
val name : string
name of the monoid structure (short)
val of_term : 
   CC.t ->
   state ->
   E_node.t ->
diff --git a/dev/sidekick/Sidekick_cc/Plugin/module-type-EXTENDED_PLUGIN_BUILDER/index.html b/dev/sidekick/Sidekick_cc/Plugin/module-type-EXTENDED_PLUGIN_BUILDER/index.html
index e16d81fe..aa75f261 100644
--- a/dev/sidekick/Sidekick_cc/Plugin/module-type-EXTENDED_PLUGIN_BUILDER/index.html
+++ b/dev/sidekick/Sidekick_cc/Plugin/module-type-EXTENDED_PLUGIN_BUILDER/index.html
@@ -1,2 +1,2 @@
 
-EXTENDED_PLUGIN_BUILDER (sidekick.Sidekick_cc.Plugin.EXTENDED_PLUGIN_BUILDER)
Module type Plugin.EXTENDED_PLUGIN_BUILDER
module M : sig ... end
module type DYN_PL_FOR_M = sig ... end
type t = (module DYN_PL_FOR_M)
val create_and_setup : ?size:int -> CC.t -> t
Create a new monoid state
val mem : t -> E_node.t -> bool
Does the CC.E_node.t have a monoid value?
val get : t -> E_node.t -> M.t option
Get monoid value for this CC.E_node.t, if any
val iter_all : t -> (CC.repr * M.t) Iter.t
include Sidekick_sigs.BACKTRACKABLE0 with type t := t
val n_levels : t -> int
Number of levels
val push_level : t -> unit
Push a backtracking point
val pop_levels : t -> int -> unit
pop_levels st n removes n levels
include Sidekick_sigs.PRINT with type t := t

+EXTENDED_PLUGIN_BUILDER (sidekick.Sidekick_cc.Plugin.EXTENDED_PLUGIN_BUILDER)
Module type Plugin.EXTENDED_PLUGIN_BUILDER
module M : sig ... end
module type DYN_PL_FOR_M = sig ... end
type t = (module DYN_PL_FOR_M)
val create_and_setup : ?size:int -> CC.t -> t
Create a new monoid state
val mem : t -> E_node.t -> bool
Does the CC.E_node.t have a monoid value?
val get : t -> E_node.t -> M.t option
Get monoid value for this CC.E_node.t, if any
val iter_all : t -> (CC.repr * M.t) Iter.t
include Sidekick_sigs.BACKTRACKABLE0 with type t := t
val n_levels : t -> int
Number of levels
val push_level : t -> unit
Push a backtracking point
val pop_levels : t -> int -> unit
pop_levels st n removes n levels
include Sidekick_sigs.PRINT with type t := t

diff --git a/dev/sidekick/Sidekick_cc/Plugin/module-type-EXTENDED_PLUGIN_BUILDER/module-type-DYN_PL_FOR_M/index.html b/dev/sidekick/Sidekick_cc/Plugin/module-type-EXTENDED_PLUGIN_BUILDER/module-type-DYN_PL_FOR_M/index.html
index a77aedcb..194b087b 100644
--- a/dev/sidekick/Sidekick_cc/Plugin/module-type-EXTENDED_PLUGIN_BUILDER/module-type-DYN_PL_FOR_M/index.html
+++ b/dev/sidekick/Sidekick_cc/Plugin/module-type-EXTENDED_PLUGIN_BUILDER/module-type-DYN_PL_FOR_M/index.html
@@ -1,2 +1,2 @@
 
-DYN_PL_FOR_M (sidekick.Sidekick_cc.Plugin.EXTENDED_PLUGIN_BUILDER.DYN_PL_FOR_M)
Module type EXTENDED_PLUGIN_BUILDER.DYN_PL_FOR_M
module M = M
include Sidekick_sigs.DYN_BACKTRACKABLE
val n_levels : unit -> int
Number of levels
val push_level : unit -> unit
Push a backtracking point
val pop_levels : int -> unit
pop_levels n removes n levels
val pp : unit Sidekick_cc__.Types_.Fmt.printer
val mem : E_node.t -> bool
Does the CC E_node.t have a monoid value?
val get : E_node.t -> M.t option
Get monoid value for this CC E_node.t, if any
val iter_all : (CC.repr * M.t) Iter.t

+DYN_PL_FOR_M (sidekick.Sidekick_cc.Plugin.EXTENDED_PLUGIN_BUILDER.DYN_PL_FOR_M)
Module type EXTENDED_PLUGIN_BUILDER.DYN_PL_FOR_M
module M = M
include Sidekick_sigs.DYN_BACKTRACKABLE
val n_levels : unit -> int
Number of levels
val push_level : unit -> unit
Push a backtracking point
val pop_levels : int -> unit
pop_levels n removes n levels
val pp : unit Sidekick_cc__.Types_.Fmt.printer
val mem : E_node.t -> bool
Does the CC E_node.t have a monoid value?
val get : E_node.t -> M.t option
Get monoid value for this CC E_node.t, if any
val iter_all : (CC.repr * M.t) Iter.t

diff --git a/dev/sidekick/Sidekick_cc/Resolved_expl/index.html b/dev/sidekick/Sidekick_cc/Resolved_expl/index.html
index fc403590..febe6fad 100644
--- a/dev/sidekick/Sidekick_cc/Resolved_expl/index.html
+++ b/dev/sidekick/Sidekick_cc/Resolved_expl/index.html
@@ -1,2 +1,2 @@
 
-Resolved_expl (sidekick.Sidekick_cc.Resolved_expl)
Module Sidekick_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.
include Sidekick_sigs.PRINT with type t := t

+Resolved_expl (sidekick.Sidekick_cc.Resolved_expl)
Module Sidekick_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.
include Sidekick_sigs.PRINT with type t := t

diff --git a/dev/sidekick/Sidekick_cc/Signature/index.html b/dev/sidekick/Sidekick_cc/Signature/index.html
index 5bd77f45..f35974f1 100644
--- a/dev/sidekick/Sidekick_cc/Signature/index.html
+++ b/dev/sidekick/Sidekick_cc/Signature/index.html
@@ -1,5 +1,5 @@
 
-Signature (sidekick.Sidekick_cc.Signature)
Module Sidekick_cc.Signature
A signature is a shallow term shape where immediate subterms are representative
type t =
+Signature (sidekick.Sidekick_cc.Signature)
Module Sidekick_cc.Signature
A signature is a shallow term shape where immediate subterms are representative
type t =
   (Sidekick_core.Const.t,
     Sidekick_cc__.Types_.e_node,
     Sidekick_cc__.Types_.e_node list)
diff --git a/dev/sidekick/Sidekick_cc/index.html b/dev/sidekick/Sidekick_cc/index.html
index 02a497c3..b2d3b403 100644
--- a/dev/sidekick/Sidekick_cc/index.html
+++ b/dev/sidekick/Sidekick_cc/index.html
@@ -1,5 +1,5 @@
 
-Sidekick_cc (sidekick.Sidekick_cc)
Module Sidekick_cc
Congruence Closure Implementation
module type DYN_MONOID_PLUGIN = sig ... end
module type MONOID_PLUGIN_ARG = sig ... end
module type MONOID_PLUGIN_BUILDER = sig ... end
module View = Sidekick_core.CC_view
module E_node : sig ... end
E-node.
module Expl : sig ... end
Explanations
module Signature : sig ... end
A signature is a shallow term shape where immediate subterms are representative
module Resolved_expl : sig ... end
Resolved explanations.
module Plugin : sig ... end
Congruence Closure Plugin
module CC : sig ... end
Main congruence closure signature.
include module type of struct include CC end
type e_node = E_node.t
A node of the congruence closure
type repr = E_node.t
Node that is currently a representative.
type explanation = Expl.t
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 allocate_bitfield.
All fields are initially 0, are backtracked automatically, and are merged automatically when classes are merged.
type t = CC.t
The congruence closure object. It contains a fair amount of state and is mutable and backtrackable.
Accessors
val term_store : t -> Sidekick_core.Term.store
val proof_tracer : t -> Sidekick_proof.Tracer.t
val stat : t -> Sidekick_util.Stat.t
val find : t -> e_node -> repr
Current representative
val add_term : t -> Sidekick_core.Term.t -> e_node
Add the Term.t to the congruence closure, if not present already. Will be backtracked.
val mem_term : t -> Sidekick_core.Term.t -> bool
Returns true if the Term.t is explicitly present in the congruence closure
val allocate_bitfield : t -> descr:string -> bitfield
Allocate a new e_node field (see E_node.bitfield).
This field descriptor is henceforth reserved for all nodes in this congruence closure, and can be set using set_bitfield for each class_ 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.t 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 -> bitfield -> E_node.t -> bool
Access the bit field of the given e_node
val set_bitfield : t -> bitfield -> bool -> E_node.t -> unit
Set the bitfield for the e_node. This will be backtracked. See E_node.bitfield.
type propagation_reason =
+Sidekick_cc (sidekick.Sidekick_cc)
Module Sidekick_cc
Congruence Closure Implementation
module type DYN_MONOID_PLUGIN = sig ... end
module type MONOID_PLUGIN_ARG = sig ... end
module type MONOID_PLUGIN_BUILDER = sig ... end
module View = Sidekick_core.CC_view
module E_node : sig ... end
E-node.
module Expl : sig ... end
Explanations
module Signature : sig ... end
A signature is a shallow term shape where immediate subterms are representative
module Resolved_expl : sig ... end
Resolved explanations.
module Plugin : sig ... end
Congruence Closure Plugin
module CC : sig ... end
Main congruence closure signature.
include module type of struct include CC end
type e_node = E_node.t
A node of the congruence closure
type repr = E_node.t
Node that is currently a representative.
type explanation = Expl.t
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 allocate_bitfield.
All fields are initially 0, are backtracked automatically, and are merged automatically when classes are merged.
type t = CC.t
The congruence closure object. It contains a fair amount of state and is mutable and backtrackable.
Accessors
val term_store : t -> Sidekick_core.Term.store
val proof_tracer : t -> Sidekick_proof.Tracer.t
val stat : t -> Sidekick_util.Stat.t
val find : t -> e_node -> repr
Current representative
val add_term : t -> Sidekick_core.Term.t -> e_node
Add the Term.t to the congruence closure, if not present already. Will be backtracked.
val mem_term : t -> Sidekick_core.Term.t -> bool
Returns true if the Term.t is explicitly present in the congruence closure
val allocate_bitfield : t -> descr:string -> bitfield
Allocate a new e_node field (see E_node.bitfield).
This field descriptor is henceforth reserved for all nodes in this congruence closure, and can be set using set_bitfield for each class_ 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.t 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 -> bitfield -> E_node.t -> bool
Access the bit field of the given e_node
val set_bitfield : t -> bitfield -> bool -> E_node.t -> unit
Set the bitfield for the e_node. This will be backtracked. See E_node.bitfield.
type propagation_reason =
   unit ->
   Sidekick_core.Lit.t list * Sidekick_proof.Pterm.delayed
module Handler_action = CC.Handler_action
Handler Actions
module Result_action = CC.Result_action
Result Actions.
Events
Events triggered by the congruence closure, to which other plugins can subscribe.
val on_pre_merge : 
   t ->
diff --git a/dev/sidekick/Sidekick_cc/module-type-DYN_MONOID_PLUGIN/M/index.html b/dev/sidekick/Sidekick_cc/module-type-DYN_MONOID_PLUGIN/M/index.html
index 81881d35..4e5dfcce 100644
--- a/dev/sidekick/Sidekick_cc/module-type-DYN_MONOID_PLUGIN/M/index.html
+++ b/dev/sidekick/Sidekick_cc/module-type-DYN_MONOID_PLUGIN/M/index.html
@@ -1,5 +1,5 @@
 
-M (sidekick.Sidekick_cc.DYN_MONOID_PLUGIN.M)
Module DYN_MONOID_PLUGIN.M
type t
Some type with a monoid structure
include Sidekick_sigs.PRINT with type t := t
type state
val create : CC.t -> state
Initialize state from the congruence closure
val name : string
name of the monoid structure (short)
val of_term : 
+M (sidekick.Sidekick_cc.DYN_MONOID_PLUGIN.M)
Module DYN_MONOID_PLUGIN.M
type t
Some type with a monoid structure
include Sidekick_sigs.PRINT with type t := t
type state
val create : CC.t -> state
Initialize state from the congruence closure
val name : string
name of the monoid structure (short)
val of_term : 
   CC.t ->
   state ->
   E_node.t ->
diff --git a/dev/sidekick/Sidekick_cc/module-type-DYN_MONOID_PLUGIN/index.html b/dev/sidekick/Sidekick_cc/module-type-DYN_MONOID_PLUGIN/index.html
index 2676798c..5d66dedf 100644
--- a/dev/sidekick/Sidekick_cc/module-type-DYN_MONOID_PLUGIN/index.html
+++ b/dev/sidekick/Sidekick_cc/module-type-DYN_MONOID_PLUGIN/index.html
@@ -1,2 +1,2 @@
 
-DYN_MONOID_PLUGIN (sidekick.Sidekick_cc.DYN_MONOID_PLUGIN)
Module type Sidekick_cc.DYN_MONOID_PLUGIN
module M : sig ... end
include Sidekick_sigs.DYN_BACKTRACKABLE
val n_levels : unit -> int
Number of levels
val push_level : unit -> unit
Push a backtracking point
val pop_levels : int -> unit
pop_levels n removes n levels
val pp : unit Sidekick_cc__.Types_.Fmt.printer
val mem : E_node.t -> bool
Does the CC E_node.t have a monoid value?
val get : E_node.t -> M.t option
Get monoid value for this CC E_node.t, if any
val iter_all : (CC.repr * M.t) Iter.t

+DYN_MONOID_PLUGIN (sidekick.Sidekick_cc.DYN_MONOID_PLUGIN)
Module type Sidekick_cc.DYN_MONOID_PLUGIN
module M : sig ... end
include Sidekick_sigs.DYN_BACKTRACKABLE
val n_levels : unit -> int
Number of levels
val push_level : unit -> unit
Push a backtracking point
val pop_levels : int -> unit
pop_levels n removes n levels
val pp : unit Sidekick_cc__.Types_.Fmt.printer
val mem : E_node.t -> bool
Does the CC E_node.t have a monoid value?
val get : E_node.t -> M.t option
Get monoid value for this CC E_node.t, if any
val iter_all : (CC.repr * M.t) Iter.t

diff --git a/dev/sidekick/Sidekick_cc/module-type-MONOID_PLUGIN_ARG/index.html b/dev/sidekick/Sidekick_cc/module-type-MONOID_PLUGIN_ARG/index.html
index 2a71ce38..d984e618 100644
--- a/dev/sidekick/Sidekick_cc/module-type-MONOID_PLUGIN_ARG/index.html
+++ b/dev/sidekick/Sidekick_cc/module-type-MONOID_PLUGIN_ARG/index.html
@@ -1,5 +1,5 @@
 
-MONOID_PLUGIN_ARG (sidekick.Sidekick_cc.MONOID_PLUGIN_ARG)
Module type Sidekick_cc.MONOID_PLUGIN_ARG
type t
Some type with a monoid structure
include Sidekick_sigs.PRINT with type t := t
type state
val create : CC.t -> state
Initialize state from the congruence closure
val name : string
name of the monoid structure (short)
val of_term : 
+MONOID_PLUGIN_ARG (sidekick.Sidekick_cc.MONOID_PLUGIN_ARG)
Module type Sidekick_cc.MONOID_PLUGIN_ARG
type t
Some type with a monoid structure
include Sidekick_sigs.PRINT with type t := t
type state
val create : CC.t -> state
Initialize state from the congruence closure
val name : string
name of the monoid structure (short)
val of_term : 
   CC.t ->
   state ->
   E_node.t ->
diff --git a/dev/sidekick/Sidekick_cc/module-type-MONOID_PLUGIN_BUILDER/M/index.html b/dev/sidekick/Sidekick_cc/module-type-MONOID_PLUGIN_BUILDER/M/index.html
index 4ec3e7a4..e7079408 100644
--- a/dev/sidekick/Sidekick_cc/module-type-MONOID_PLUGIN_BUILDER/M/index.html
+++ b/dev/sidekick/Sidekick_cc/module-type-MONOID_PLUGIN_BUILDER/M/index.html
@@ -1,5 +1,5 @@
 
-M (sidekick.Sidekick_cc.MONOID_PLUGIN_BUILDER.M)
Module MONOID_PLUGIN_BUILDER.M
type t
Some type with a monoid structure
include Sidekick_sigs.PRINT with type t := t
type state
val create : CC.t -> state
Initialize state from the congruence closure
val name : string
name of the monoid structure (short)
val of_term : 
+M (sidekick.Sidekick_cc.MONOID_PLUGIN_BUILDER.M)
Module MONOID_PLUGIN_BUILDER.M
type t
Some type with a monoid structure
include Sidekick_sigs.PRINT with type t := t
type state
val create : CC.t -> state
Initialize state from the congruence closure
val name : string
name of the monoid structure (short)
val of_term : 
   CC.t ->
   state ->
   E_node.t ->
diff --git a/dev/sidekick/Sidekick_cc/module-type-MONOID_PLUGIN_BUILDER/index.html b/dev/sidekick/Sidekick_cc/module-type-MONOID_PLUGIN_BUILDER/index.html
index 8eeb8b37..c09ee5eb 100644
--- a/dev/sidekick/Sidekick_cc/module-type-MONOID_PLUGIN_BUILDER/index.html
+++ b/dev/sidekick/Sidekick_cc/module-type-MONOID_PLUGIN_BUILDER/index.html
@@ -1,2 +1,2 @@
 
-MONOID_PLUGIN_BUILDER (sidekick.Sidekick_cc.MONOID_PLUGIN_BUILDER)
Module type Sidekick_cc.MONOID_PLUGIN_BUILDER
module M : sig ... end
module type DYN_PL_FOR_M = sig ... end
type t = (module DYN_PL_FOR_M)
val create_and_setup : ?size:int -> CC.t -> t
Create a new monoid state

+MONOID_PLUGIN_BUILDER (sidekick.Sidekick_cc.MONOID_PLUGIN_BUILDER)
Module type Sidekick_cc.MONOID_PLUGIN_BUILDER
module M : sig ... end
module type DYN_PL_FOR_M = sig ... end
type t = (module DYN_PL_FOR_M)
val create_and_setup : ?size:int -> CC.t -> t
Create a new monoid state

diff --git a/dev/sidekick/Sidekick_cc/module-type-MONOID_PLUGIN_BUILDER/module-type-DYN_PL_FOR_M/index.html b/dev/sidekick/Sidekick_cc/module-type-MONOID_PLUGIN_BUILDER/module-type-DYN_PL_FOR_M/index.html
index 7c08e1ab..a9d50ac0 100644
--- a/dev/sidekick/Sidekick_cc/module-type-MONOID_PLUGIN_BUILDER/module-type-DYN_PL_FOR_M/index.html
+++ b/dev/sidekick/Sidekick_cc/module-type-MONOID_PLUGIN_BUILDER/module-type-DYN_PL_FOR_M/index.html
@@ -1,2 +1,2 @@
 
-DYN_PL_FOR_M (sidekick.Sidekick_cc.MONOID_PLUGIN_BUILDER.DYN_PL_FOR_M)
Module type MONOID_PLUGIN_BUILDER.DYN_PL_FOR_M
module M = M
include Sidekick_sigs.DYN_BACKTRACKABLE
val n_levels : unit -> int
Number of levels
val push_level : unit -> unit
Push a backtracking point
val pop_levels : int -> unit
pop_levels n removes n levels
val pp : unit Sidekick_cc__.Types_.Fmt.printer
val mem : E_node.t -> bool
Does the CC E_node.t have a monoid value?
val get : E_node.t -> M.t option
Get monoid value for this CC E_node.t, if any
val iter_all : (CC.repr * M.t) Iter.t

+DYN_PL_FOR_M (sidekick.Sidekick_cc.MONOID_PLUGIN_BUILDER.DYN_PL_FOR_M)
Module type MONOID_PLUGIN_BUILDER.DYN_PL_FOR_M
module M = M
include Sidekick_sigs.DYN_BACKTRACKABLE
val n_levels : unit -> int
Number of levels
val push_level : unit -> unit
Push a backtracking point
val pop_levels : int -> unit
pop_levels n removes n levels
val pp : unit Sidekick_cc__.Types_.Fmt.printer
val mem : E_node.t -> bool
Does the CC E_node.t have a monoid value?
val get : E_node.t -> M.t option
Get monoid value for this CC E_node.t, if any
val iter_all : (CC.repr * M.t) Iter.t

diff --git a/dev/sidekick/Sidekick_cc_plugin/index.html b/dev/sidekick/Sidekick_cc_plugin/index.html
index ed246f56..78962a8b 100644
--- a/dev/sidekick/Sidekick_cc_plugin/index.html
+++ b/dev/sidekick/Sidekick_cc_plugin/index.html
@@ -1,2 +1,2 @@
 
-Sidekick_cc_plugin (sidekick.Sidekick_cc_plugin)
Module Sidekick_cc_plugin

+Sidekick_cc_plugin (sidekick.Sidekick_cc_plugin)
Module Sidekick_cc_plugin

diff --git a/dev/sidekick/Sidekick_core/Bool_view/index.html b/dev/sidekick/Sidekick_core/Bool_view/index.html
index bb4feae5..fb81ae45 100644
--- a/dev/sidekick/Sidekick_core/Bool_view/index.html
+++ b/dev/sidekick/Sidekick_core/Bool_view/index.html
@@ -1,2 +1,2 @@
 
-Bool_view (sidekick.Sidekick_core.Bool_view)
Module Sidekick_core.Bool_view
Boolean-oriented view of terms
type 'a t = 
  1. | B_bool of bool
  2. | B_not of 'a
  3. | B_and of 'a list
  4. | B_or of 'a list
  5. | B_imply of 'a * 'a
  6. | B_equiv of 'a * 'a
  7. | B_xor of 'a * 'a
  8. | B_eq of 'a * 'a
  9. | B_neq of 'a * 'a
  10. | B_ite of 'a * 'a * 'a
  11. | B_atom of 'a
View

+Bool_view (sidekick.Sidekick_core.Bool_view)
Module Sidekick_core.Bool_view
Boolean-oriented view of terms
type 'a t = 
  1. | B_bool of bool
  2. | B_not of 'a
  3. | B_and of 'a list
  4. | B_or of 'a list
  5. | B_imply of 'a * 'a
  6. | B_equiv of 'a * 'a
  7. | B_xor of 'a * 'a
  8. | B_eq of 'a * 'a
  9. | B_neq of 'a * 'a
  10. | B_ite of 'a * 'a * 'a
  11. | B_atom of 'a
View

diff --git a/dev/sidekick/Sidekick_core/Box/index.html b/dev/sidekick/Sidekick_core/Box/index.html
index 71764eef..dd2f854f 100644
--- a/dev/sidekick/Sidekick_core/Box/index.html
+++ b/dev/sidekick/Sidekick_core/Box/index.html
@@ -1,5 +1,5 @@
 
-Box (sidekick.Sidekick_core.Box)
Module Sidekick_core.Box
val box : 
+Box (sidekick.Sidekick_core.Box)
Module Sidekick_core.Box
box tst t makes a new constant that "boxes" t. This way it will be opaque.
val is_box : Sidekick_core_logic.Term.t -> bool

diff --git a/dev/sidekick/Sidekick_core/CC_view/index.html b/dev/sidekick/Sidekick_core/CC_view/index.html
index 04735893..1500e1c6 100644
--- a/dev/sidekick/Sidekick_core/CC_view/index.html
+++ b/dev/sidekick/Sidekick_core/CC_view/index.html
@@ -1,5 +1,5 @@
 
-CC_view (sidekick.Sidekick_core.CC_view)
Module Sidekick_core.CC_view
View terms through the lens of a Congruence Closure
type ('f, 't, 'ts) t = 
  1. | Bool of bool
  2. | App_fun of 'f * 'ts
  3. | App_ho of 't * 't
  4. | If of 't * 't * 't
  5. | Eq of 't * 't
  6. | Not of 't
  7. | Opaque of 't
    (*
    do not enter
    *)
A view of a term fron the point of view of a congruence closure.
  • 'f is the type of function symbols
  • 't is the type of terms
  • 'ts is the type of sequences of terms (arguments of function application)
val map_view : 
+CC_view (sidekick.Sidekick_core.CC_view)
Module Sidekick_core.CC_view
View terms through the lens of a Congruence Closure
type ('f, 't, 'ts) t = 
  1. | Bool of bool
  2. | App_fun of 'f * 'ts
  3. | App_ho of 't * 't
  4. | If of 't * 't * 't
  5. | Eq of 't * 't
  6. | Not of 't
  7. | Opaque of 't
    (*
    do not enter
    *)
A view of a term fron the point of view of a congruence closure.
  • 'f is the type of function symbols
  • 't is the type of terms
  • 'ts is the type of sequences of terms (arguments of function application)
val map_view : 
   f_f:('a -> 'b) ->
   f_t:('c -> 'd) ->
   f_ts:('e -> 'f) ->
diff --git a/dev/sidekick/Sidekick_core/Default_cc_view/index.html b/dev/sidekick/Sidekick_core/Default_cc_view/index.html
index a642d8b0..231ed37b 100644
--- a/dev/sidekick/Sidekick_core/Default_cc_view/index.html
+++ b/dev/sidekick/Sidekick_core/Default_cc_view/index.html
@@ -1,5 +1,5 @@
 
-Default_cc_view (sidekick.Sidekick_core.Default_cc_view)
Module Sidekick_core.Default_cc_view
val view_as_cc : 
+Default_cc_view (sidekick.Sidekick_core.Default_cc_view)
Module Sidekick_core.Default_cc_view
val view_as_cc : 
   Sidekick_core_logic.Term.t ->
   (Sidekick_core_logic.Const.t,
     Sidekick_core_logic.Term.t,
diff --git a/dev/sidekick/Sidekick_core/Gensym/index.html b/dev/sidekick/Sidekick_core/Gensym/index.html
index cfd2b734..420c88ac 100644
--- a/dev/sidekick/Sidekick_core/Gensym/index.html
+++ b/dev/sidekick/Sidekick_core/Gensym/index.html
@@ -1,2 +1,2 @@
 
-Gensym (sidekick.Sidekick_core.Gensym)
Module Sidekick_core.Gensym
Fresh symbol generation
type t
Fresh symbol generator.
The theory needs to be able to create new terms with fresh names, to be used as placeholders for complex formulas during Tseitin encoding.
New (stateful) generator instance.
val fresh_term : t -> pre:string -> ty -> term
Make a fresh term of the given type
val reset : t -> unit
Reset to initial state

+Gensym (sidekick.Sidekick_core.Gensym)
Module Sidekick_core.Gensym
Fresh symbol generation
type t
Fresh symbol generator.
The theory needs to be able to create new terms with fresh names, to be used as placeholders for complex formulas during Tseitin encoding.
New (stateful) generator instance.
val fresh_term : t -> pre:string -> ty -> term
Make a fresh term of the given type
val reset : t -> unit
Reset to initial state

diff --git a/dev/sidekick/Sidekick_core/Lit/index.html b/dev/sidekick/Sidekick_core/Lit/index.html
index 7b3da443..e2f96301 100644
--- a/dev/sidekick/Sidekick_core/Lit/index.html
+++ b/dev/sidekick/Sidekick_core/Lit/index.html
@@ -1,2 +1,2 @@
 
-Lit (sidekick.Sidekick_core.Lit)
Module Sidekick_core.Lit
Literals
Literals are a pair of a boolean-sorted term, and a sign. Positive literals are the same as their term, and negative literals are the negation of their term.
The SAT solver deals only in literals and clauses (sets of literals). Everything else belongs in the SMT solver.
type t
A literal
include Sidekick_sigs.EQ_ORD_HASH_PRINT with type t := 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_limit : max_depth:int -> max_nodes:int -> t Sidekick_util.Fmt.printer
val term : t -> term
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 -> term * bool
Return the atom and the sign
val atom : ?sign:bool -> Sidekick_core_logic.Term.store -> term -> 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 make_eq : ?sign:bool -> Sidekick_core_logic.Term.store -> term -> term -> t
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.
include Sidekick_sigs.WITH_SET_MAP_TBL with type t := t
module Set : CCSet.S with type elt = t
module Map : CCMap.S with type key = t
module Tbl : CCHashtbl.S with type key = t

+Lit (sidekick.Sidekick_core.Lit)
Module Sidekick_core.Lit
Literals
Literals are a pair of a boolean-sorted term, and a sign. Positive literals are the same as their term, and negative literals are the negation of their term.
The SAT solver deals only in literals and clauses (sets of literals). Everything else belongs in the SMT solver.
type t
A literal
include Sidekick_sigs.EQ_ORD_HASH_PRINT with type t := 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_limit : max_depth:int -> max_nodes:int -> t Sidekick_util.Fmt.printer
val term : t -> term
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 -> term * bool
Return the atom and the sign
val atom : ?sign:bool -> Sidekick_core_logic.Term.store -> term -> 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 make_eq : ?sign:bool -> Sidekick_core_logic.Term.store -> term -> term -> t
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.
include Sidekick_sigs.WITH_SET_MAP_TBL with type t := t
module Set : CCSet.S with type elt = t
module Map : CCMap.S with type key = t
module Tbl : CCHashtbl.S with type key = t

diff --git a/dev/sidekick/Sidekick_core/Term/Hooks/index.html b/dev/sidekick/Sidekick_core/Term/Hooks/index.html
index 48dc45e2..1637ae1b 100644
--- a/dev/sidekick/Sidekick_core/Term/Hooks/index.html
+++ b/dev/sidekick/Sidekick_core/Term/Hooks/index.html
@@ -1,5 +1,5 @@
 
-Hooks (sidekick.Sidekick_core.Term.Hooks)
Module Term.Hooks
type t
val empty : t
val add : 
+Hooks (sidekick.Sidekick_core.Term.Hooks)
Module Term.Hooks
type t
val empty : t
val add : 
   (recurse:Sidekick_core_logic.Term.t Sidekick_util.Fmt.printer ->
     Sidekick_util.Fmt.t ->
     Sidekick_core_logic.Term.t ->
diff --git a/dev/sidekick/Sidekick_core/Term/Ref/index.html b/dev/sidekick/Sidekick_core/Term/Ref/index.html
index 07ff070e..f4939cef 100644
--- a/dev/sidekick/Sidekick_core/Term/Ref/index.html
+++ b/dev/sidekick/Sidekick_core/Term/Ref/index.html
@@ -1,5 +1,5 @@
 
-Ref (sidekick.Sidekick_core.Term.Ref)
Module Term.Ref
Term reference
Reference to another term, by a unique ID in a trace.
This allows a trace to contain terms with explicit references to other terms, but where these references have to be followed explicitly. Thus, each term can be deserialized separately.
For example, a proof term for a given lemma might use references to previous lemmas, instead of their direct proof terms; this allows a checker or proof GUI to only read this particular lemma's proof into a term.
val ref : 
+Ref (sidekick.Sidekick_core.Term.Ref)
Module Term.Ref
Term reference
Reference to another term, by a unique ID in a trace.
This allows a trace to contain terms with explicit references to other terms, but where these references have to be followed explicitly. Thus, each term can be deserialized separately.
For example, a proof term for a given lemma might use references to previous lemmas, instead of their direct proof terms; this allows a checker or proof GUI to only read this particular lemma's proof into a term.
val ref : 
   Sidekick_core_logic.Term.store ->
   t ->
   ty:Sidekick_core_logic.Term.t ->
diff --git a/dev/sidekick/Sidekick_core/Term/Trace_reader/index.html b/dev/sidekick/Sidekick_core/Term/Trace_reader/index.html
index f986a655..ae3f5323 100644
--- a/dev/sidekick/Sidekick_core/Term/Trace_reader/index.html
+++ b/dev/sidekick/Sidekick_core/Term/Trace_reader/index.html
@@ -1,5 +1,5 @@
 
-Trace_reader (sidekick.Sidekick_core.Term.Trace_reader)
Module Term.Trace_reader
module Tr = Sidekick_trace
type term_ref = Tr.entry_id
type t
val create : 
+Trace_reader (sidekick.Sidekick_core.Term.Trace_reader)
Module Term.Trace_reader
module Tr = Sidekick_trace
type term_ref = Tr.entry_id
type t
val create : 
   ?const_decoders:const_decoders list ->
   source:Tr.Source.t ->
   Sidekick_core_logic.Term.store ->
diff --git a/dev/sidekick/Sidekick_core/Term/Tracer/class-concrete/index.html b/dev/sidekick/Sidekick_core/Term/Tracer/class-concrete/index.html
index 86567f2b..b76f79ef 100644
--- a/dev/sidekick/Sidekick_core/Term/Tracer/class-concrete/index.html
+++ b/dev/sidekick/Sidekick_core/Term/Tracer/class-concrete/index.html
@@ -1,2 +1,2 @@
 
-concrete (sidekick.Sidekick_core.Term.Tracer.concrete)
Class Tracer.concrete
Concrete implementation of t
method emit_term : Sidekick_core_logic.Term.t -> term_ref

+concrete (sidekick.Sidekick_core.Term.Tracer.concrete)
Class Tracer.concrete
Concrete implementation of t
method emit_term : Sidekick_core_logic.Term.t -> term_ref

diff --git a/dev/sidekick/Sidekick_core/Term/Tracer/class-dummy/index.html b/dev/sidekick/Sidekick_core/Term/Tracer/class-dummy/index.html
index 27920680..a051a8de 100644
--- a/dev/sidekick/Sidekick_core/Term/Tracer/class-dummy/index.html
+++ b/dev/sidekick/Sidekick_core/Term/Tracer/class-dummy/index.html
@@ -1,2 +1,2 @@
 
-dummy (sidekick.Sidekick_core.Term.Tracer.dummy)
Class Tracer.dummy
Dummy implementation, returns Tr.Entry_id.dummy
inherit t
method emit_term : Sidekick_core_logic.Term.t -> term_ref

+dummy (sidekick.Sidekick_core.Term.Tracer.dummy)
Class Tracer.dummy
Dummy implementation, returns Tr.Entry_id.dummy
inherit t
method emit_term : Sidekick_core_logic.Term.t -> term_ref

diff --git a/dev/sidekick/Sidekick_core/Term/Tracer/class-type-t/index.html b/dev/sidekick/Sidekick_core/Term/Tracer/class-type-t/index.html
index dd3aaa0a..a055aad7 100644
--- a/dev/sidekick/Sidekick_core/Term/Tracer/class-type-t/index.html
+++ b/dev/sidekick/Sidekick_core/Term/Tracer/class-type-t/index.html
@@ -1,2 +1,2 @@
 
-t (sidekick.Sidekick_core.Term.Tracer.t)
Class type Tracer.t
method emit_term : Sidekick_core_logic.Term.t -> term_ref

+t (sidekick.Sidekick_core.Term.Tracer.t)
Class type Tracer.t
method emit_term : Sidekick_core_logic.Term.t -> term_ref

diff --git a/dev/sidekick/Sidekick_core/Term/Tracer/index.html b/dev/sidekick/Sidekick_core/Term/Tracer/index.html
index ab270f24..aee60479 100644
--- a/dev/sidekick/Sidekick_core/Term/Tracer/index.html
+++ b/dev/sidekick/Sidekick_core/Term/Tracer/index.html
@@ -1,2 +1,2 @@
 
-Tracer (sidekick.Sidekick_core.Term.Tracer)
Module Term.Tracer
Emit terms in traces.
Traces will contains terms, encoded as a DAG. Each subterm is its own event, and gets a term identifier used in other subsequent entries to refer to it.
module Tr = Sidekick_trace
type term_ref = Sidekick_trace.entry_id
class type  t = object ... end
class dummy : object ... end
Dummy implementation, returns Tr.Entry_id.dummy
class concrete : sink:Tr.Sink.t -> t
Concrete implementation of t
val create : sink:Tr.Sink.t -> unit -> t
create ~sink () makes a tracer that will write terms into the given sink.
val emit' : t -> Sidekick_core_logic.Term.t -> unit

+Tracer (sidekick.Sidekick_core.Term.Tracer)
Module Term.Tracer
Emit terms in traces.
Traces will contains terms, encoded as a DAG. Each subterm is its own event, and gets a term identifier used in other subsequent entries to refer to it.
module Tr = Sidekick_trace
type term_ref = Sidekick_trace.entry_id
class type  t = object ... end
class dummy : object ... end
Dummy implementation, returns Tr.Entry_id.dummy
class concrete : sink:Tr.Sink.t -> t
Concrete implementation of t
val create : sink:Tr.Sink.t -> unit -> t
create ~sink () makes a tracer that will write terms into the given sink.
val emit' : t -> Sidekick_core_logic.Term.t -> unit

diff --git a/dev/sidekick/Sidekick_core/Term/index.html b/dev/sidekick/Sidekick_core/Term/index.html
index cd5a24b1..4e165098 100644
--- a/dev/sidekick/Sidekick_core/Term/index.html
+++ b/dev/sidekick/Sidekick_core/Term/index.html
@@ -1,5 +1,5 @@
 
-Term (sidekick.Sidekick_core.Term)
Module Sidekick_core.Term
include module type of struct include Sidekick_core_logic.Term end
type t
A term, in the calculus of constructions
The store for terms.
The store is responsible for allocating unique IDs to terms, and enforcing their hashconsing (so that syntactic equality is just a pointer comparison).
type view = 
  1. | E_type of int
  2. | E_var of var
  3. | E_bound_var of bvar
  4. | E_app of t * t
  5. | E_lam of string * t * t
  6. | E_pi of string * t * t
View.
A view is the shape of the root node of a term.
include Sidekick_sigs.EQ_ORD_HASH with type t := 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
val pp_debug : t Sidekick_util.Fmt.printer
val pp_debug_with_ids : t Sidekick_util.Fmt.printer
Containers
include Sidekick_sigs.WITH_SET_MAP_TBL with type t := t
include Sidekick_sigs.WITH_WEAK with type t := t
Utils
val view : t -> view
val unfold_app : t -> t * t list
val is_app : t -> bool
val is_const : t -> bool
val is_pi : t -> bool
val iter_dag : ?seen:unit Tbl.t -> iter_ty:bool -> f:(t -> unit) -> t -> 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
+Term (sidekick.Sidekick_core.Term)
Module Sidekick_core.Term
include module type of struct include Sidekick_core_logic.Term end
type t
A term, in the calculus of constructions
The store for terms.
The store is responsible for allocating unique IDs to terms, and enforcing their hashconsing (so that syntactic equality is just a pointer comparison).
type view = 
  1. | E_type of int
  2. | E_var of var
  3. | E_bound_var of bvar
  4. | E_app of t * t
  5. | E_lam of string * t * t
  6. | E_pi of string * t * t
View.
A view is the shape of the root node of a term.
include Sidekick_sigs.EQ_ORD_HASH with type t := 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
val pp_debug : t Sidekick_util.Fmt.printer
val pp_debug_with_ids : t Sidekick_util.Fmt.printer
Containers
include Sidekick_sigs.WITH_SET_MAP_TBL with type t := t
include Sidekick_sigs.WITH_WEAK with type t := t
Utils
val view : t -> view
val unfold_app : t -> t * t list
val is_app : t -> bool
val is_const : t -> bool
val is_pi : t -> bool
val iter_dag : ?seen:unit Tbl.t -> iter_ty:bool -> f:(t -> unit) -> t -> 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
diff --git a/dev/sidekick/Sidekick_core/index.html b/dev/sidekick/Sidekick_core/index.html
index ebc45b86..c3d6432e 100644
--- a/dev/sidekick/Sidekick_core/index.html
+++ b/dev/sidekick/Sidekick_core/index.html
@@ -1,5 +1,5 @@
 
-Sidekick_core (sidekick.Sidekick_core)
Module Sidekick_core
Main Signatures.
Theories and concrete solvers rely on an environment that defines several important types:
  • types
  • terms (to represent logic expressions and formulas)
  • a congruence closure instance
  • a bridge to some SAT solver
In this module we define most of the main signatures used throughout Sidekick.
module Fmt = CCFormat
Re-exports from core-logic
module Term : sig ... end
view
module Bool_view : sig ... end
Boolean-oriented view of terms
module CC_view : sig ... end
View terms through the lens of a Congruence Closure
module Default_cc_view : sig ... end
Main modules
module Lit : sig ... end
Literals
module Box : sig ... end
module Gensym : sig ... end
Fresh symbol generation
exception Resource_exhausted
Const decoders for traces
val const_decoders : 
+Sidekick_core (sidekick.Sidekick_core)
Module Sidekick_core
Main Signatures.
Theories and concrete solvers rely on an environment that defines several important types:
  • types
  • terms (to represent logic expressions and formulas)
  • a congruence closure instance
  • a bridge to some SAT solver
In this module we define most of the main signatures used throughout Sidekick.
module Fmt = CCFormat
Re-exports from core-logic
module Term : sig ... end
view
module Bool_view : sig ... end
Boolean-oriented view of terms
module CC_view : sig ... end
View terms through the lens of a Congruence Closure
module Default_cc_view : sig ... end
Main modules
module Lit : sig ... end
Literals
module Box : sig ... end
module Gensym : sig ... end
Fresh symbol generation
exception Resource_exhausted
Const decoders for traces
val const_decoders : 
   (string
    * Sidekick_core_logic.Const.Ops.t
    * (Sidekick_core_logic__.Types_.term Sidekick_util.Ser_decode.t ->
diff --git a/dev/sidekick/Sidekick_core_logic/Bvar/index.html b/dev/sidekick/Sidekick_core_logic/Bvar/index.html
index 568e0a5a..f3e00de9 100644
--- a/dev/sidekick/Sidekick_core_logic/Bvar/index.html
+++ b/dev/sidekick/Sidekick_core_logic/Bvar/index.html
@@ -1,2 +1,2 @@
 
-Bvar (sidekick.Sidekick_core_logic.Bvar)
Module Sidekick_core_logic.Bvar
Bound variable
type t = {
  1. bv_idx : int;
  2. bv_ty : Sidekick_core_logic__.Types_.term;
}
include Sidekick_sigs.EQ_HASH_PRINT with type t := t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val make : int -> Sidekick_core_logic__.Types_.term -> t
val idx : t -> int
val ty : t -> Sidekick_core_logic__.Types_.term

+Bvar (sidekick.Sidekick_core_logic.Bvar)
Module Sidekick_core_logic.Bvar
Bound variable
type t = {
  1. bv_idx : int;
  2. bv_ty : Sidekick_core_logic__.Types_.term;
}
include Sidekick_sigs.EQ_HASH_PRINT with type t := t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val make : int -> Sidekick_core_logic__.Types_.term -> t
val idx : t -> int
val ty : t -> Sidekick_core_logic__.Types_.term

diff --git a/dev/sidekick/Sidekick_core_logic/Const/Ops/index.html b/dev/sidekick/Sidekick_core_logic/Const/Ops/index.html
index 520d785c..acadcec4 100644
--- a/dev/sidekick/Sidekick_core_logic/Const/Ops/index.html
+++ b/dev/sidekick/Sidekick_core_logic/Const/Ops/index.html
@@ -1,5 +1,5 @@
 
-Ops (sidekick.Sidekick_core_logic.Const.Ops)
Module Const.Ops
type t = {
  1. pp : Sidekick_core_logic__.Types_.const_view Sidekick_util.Fmt.printer;
    (*
    Pretty-print constant
    *)
  2. equal : Sidekick_core_logic__.Types_.const_view ->
+Ops (sidekick.Sidekick_core_logic.Const.Ops)
    Module Const.Ops
    type t = {
    1. pp : Sidekick_core_logic__.Types_.const_view Sidekick_util.Fmt.printer;
      (*
      Pretty-print constant
      *)
    2. equal : Sidekick_core_logic__.Types_.const_view ->
   Sidekick_core_logic__.Types_.const_view ->
   bool;
      (*
      Equality of constant with any other constant
      *)
    3. hash : Sidekick_core_logic__.Types_.const_view -> int;
      (*
      Hash constant
      *)
    4. ser : (Sidekick_core_logic__.Types_.term -> Sidekick_util.Ser_value.t) ->
   Sidekick_core_logic__.Types_.const_view ->
diff --git a/dev/sidekick/Sidekick_core_logic/Const/index.html b/dev/sidekick/Sidekick_core_logic/Const/index.html
index 27fd006d..99911981 100644
--- a/dev/sidekick/Sidekick_core_logic/Const/index.html
+++ b/dev/sidekick/Sidekick_core_logic/Const/index.html
@@ -1,5 +1,5 @@
 
-Const (sidekick.Sidekick_core_logic.Const)
      Module Sidekick_core_logic.Const
      Constants.
      Constants are logical symbols, defined by the user thanks to an open type
      type view = ..
      module Ops : sig ... end
      type t = {
      1. c_view : view;
      2. c_ops : Ops.t;
      3. c_ty : Sidekick_core_logic__.Types_.term;
      }
      val view : t -> view
      val make : view -> Ops.t -> ty:Sidekick_core_logic__.Types_.term -> t
      val ser : 
+Const (sidekick.Sidekick_core_logic.Const)
      Module Sidekick_core_logic.Const
      Constants.
      Constants are logical symbols, defined by the user thanks to an open type
      type view = ..
      module Ops : sig ... end
      type t = {
      1. c_view : view;
      2. c_ops : Ops.t;
      3. c_ty : Sidekick_core_logic__.Types_.term;
      }
      val view : t -> view
      val make : view -> Ops.t -> ty:Sidekick_core_logic__.Types_.term -> t
      val ser : 
   ser_t:(Sidekick_core_logic__.Types_.term -> Sidekick_util.Ser_value.t) ->
   t ->
   string * Sidekick_util.Ser_value.t
      val ty : t -> Sidekick_core_logic__.Types_.term
      type decoders =
diff --git a/dev/sidekick/Sidekick_core_logic/Str_const/index.html b/dev/sidekick/Sidekick_core_logic/Str_const/index.html
index 8cff5f41..caf22a68 100644
--- a/dev/sidekick/Sidekick_core_logic/Str_const/index.html
+++ b/dev/sidekick/Sidekick_core_logic/Str_const/index.html
@@ -1,5 +1,5 @@
 
-Str_const (sidekick.Sidekick_core_logic.Str_const)
      Module Sidekick_core_logic.Str_const
      Basic string constants.
      These constants are a string name, coupled with a type.
      type Sidekick_core_logic__.Types_.const_view += 
      1. | Str of string
      val const_decoders : Const.decoders
      val make : 
+Str_const (sidekick.Sidekick_core_logic.Str_const)
      Module Sidekick_core_logic.Str_const
      Basic string constants.
      These constants are a string name, coupled with a type.
      type Sidekick_core_logic__.Types_.const_view += 
      1. | Str of string
      val const_decoders : Const.decoders
      val make : 
   string ->
   ty:Sidekick_core_logic__.Types_.term ->
   Sidekick_core_logic__.Types_.const
      
diff --git a/dev/sidekick/Sidekick_core_logic/Subst/index.html b/dev/sidekick/Sidekick_core_logic/Subst/index.html
index ccea90fb..a83932c0 100644
--- a/dev/sidekick/Sidekick_core_logic/Subst/index.html
+++ b/dev/sidekick/Sidekick_core_logic/Subst/index.html
@@ -1,5 +1,5 @@
 
-Subst (sidekick.Sidekick_core_logic.Subst)
      Module Sidekick_core_logic.Subst
      Substitutions
      type t
      include Sidekick_sigs.PRINT with type t := t
      val empty : t
      val is_empty : t -> bool
      val of_list : 
+Subst (sidekick.Sidekick_core_logic.Subst)
      Module Sidekick_core_logic.Subst
      Substitutions
      type t
      include Sidekick_sigs.PRINT with type t := t
      val empty : t
      val is_empty : t -> bool
      val of_list : 
   (Sidekick_core_logic__.Types_.var * Sidekick_core_logic__.Types_.term) list ->
   t
      val of_iter : 
   (Sidekick_core_logic__.Types_.var * Sidekick_core_logic__.Types_.term) Iter.t ->
diff --git a/dev/sidekick/Sidekick_core_logic/T_builtins/index.html b/dev/sidekick/Sidekick_core_logic/T_builtins/index.html
index 77c4167b..506720fc 100644
--- a/dev/sidekick/Sidekick_core_logic/T_builtins/index.html
+++ b/dev/sidekick/Sidekick_core_logic/T_builtins/index.html
@@ -1,2 +1,2 @@
 
-T_builtins (sidekick.Sidekick_core_logic.T_builtins)
      Module Sidekick_core_logic.T_builtins
      Core builtins
      type Sidekick_core_logic__.Types_.const_view += 
      1. | C_bool
      2. | C_eq
      3. | C_ite
      4. | C_not
      5. | C_true
      6. | C_false
      7. | C_proof
      val bool : Term.store -> Term.t
      val proof : Term.store -> Term.t
      val c_not : Term.store -> Term.t
      val c_eq : Term.store -> Term.t
      val c_ite : Term.store -> Term.t
      val true_ : Term.store -> Term.t
      val false_ : Term.store -> Term.t
      val bool_val : Term.store -> bool -> Term.t
      val const_decoders : Const.decoders
      val eq : Term.store -> Term.t -> Term.t -> Term.t
      eq a b is a = b
      val not : Term.store -> Term.t -> Term.t
      val ite : Term.store -> Term.t -> Term.t -> Term.t -> Term.t
      ite a b c is if a then b else c
      val is_eq : Term.t -> bool
      val is_bool : Term.t -> bool
      val abs : Term.store -> Term.t -> bool * Term.t
      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 (false, a), or (a != b) into (false, a=b). For terms without a negation this should return (true, t).
      val as_bool_val : Term.t -> bool option
      val open_eq : Term.t -> (Term.t * Term.t) option
      open_eq (a=b) returns Some (a,b), None for other terms.
      
+T_builtins (sidekick.Sidekick_core_logic.T_builtins)
      Module Sidekick_core_logic.T_builtins
      Core builtins
      type Sidekick_core_logic__.Types_.const_view += 
      1. | C_bool
      2. | C_eq
      3. | C_ite
      4. | C_not
      5. | C_true
      6. | C_false
      7. | C_proof
      val bool : Term.store -> Term.t
      val proof : Term.store -> Term.t
      val c_not : Term.store -> Term.t
      val c_eq : Term.store -> Term.t
      val c_ite : Term.store -> Term.t
      val true_ : Term.store -> Term.t
      val false_ : Term.store -> Term.t
      val bool_val : Term.store -> bool -> Term.t
      val const_decoders : Const.decoders
      val eq : Term.store -> Term.t -> Term.t -> Term.t
      eq a b is a = b
      val not : Term.store -> Term.t -> Term.t
      val ite : Term.store -> Term.t -> Term.t -> Term.t -> Term.t
      ite a b c is if a then b else c
      val is_eq : Term.t -> bool
      val is_bool : Term.t -> bool
      val abs : Term.store -> Term.t -> bool * Term.t
      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 (false, a), or (a != b) into (false, a=b). For terms without a negation this should return (true, t).
      val as_bool_val : Term.t -> bool option
      val open_eq : Term.t -> (Term.t * Term.t) option
      open_eq (a=b) returns Some (a,b), None for other terms.
      
diff --git a/dev/sidekick/Sidekick_core_logic/Term/DB/index.html b/dev/sidekick/Sidekick_core_logic/Term/DB/index.html
index 08f4cb73..e68b500b 100644
--- a/dev/sidekick/Sidekick_core_logic/Term/DB/index.html
+++ b/dev/sidekick/Sidekick_core_logic/Term/DB/index.html
@@ -1,2 +1,2 @@
 
-DB (sidekick.Sidekick_core_logic.Term.DB)
      Module Term.DB
      De bruijn indices
      val lam_db : ?var_name:string -> store -> var_ty:t -> t -> t
      lam_db store ~var_ty bod is \ _:var_ty. bod. Not DB shifting is done.
      val pi_db : ?var_name:string -> store -> var_ty:t -> t -> t
      pi_db store ~var_ty bod is pi _:var_ty. bod. Not DB shifting is done.
      val subst_db0 : store -> t -> by:t -> t
      subst_db0 store t ~by replaces bound variable 0 in t with the term by. This is useful, for example, to implement beta-reduction.
      For example, with t being _[0] = (\x. _[2] _[1] x[0]), subst_db0 store t ~by:"hello" is "hello" = (\x. _[2] "hello" x[0]).
      val shift : store -> t -> by:int -> t
      shift store t ~by shifts all bound variables in t that are not closed on, by amount by (which must be >= 0).
      For example, with term t being \x. _[1] _[2] x[0], shift store t ~by:5 is \x. _[6] _[7] x[0].
      val abs_on : store -> var -> t -> t
      abs_on store v t is the term t[v := _[0]]. It replaces v with the bound variable with the same type as v, and the DB index 0, and takes care of shifting if v occurs under binders.
      For example, abs_on store x (\y. x+y) is \y. _[1] y.
      
+DB (sidekick.Sidekick_core_logic.Term.DB)
      Module Term.DB
      De bruijn indices
      val lam_db : ?var_name:string -> store -> var_ty:t -> t -> t
      lam_db store ~var_ty bod is \ _:var_ty. bod. Not DB shifting is done.
      val pi_db : ?var_name:string -> store -> var_ty:t -> t -> t
      pi_db store ~var_ty bod is pi _:var_ty. bod. Not DB shifting is done.
      val subst_db0 : store -> t -> by:t -> t
      subst_db0 store t ~by replaces bound variable 0 in t with the term by. This is useful, for example, to implement beta-reduction.
      For example, with t being _[0] = (\x. _[2] _[1] x[0]), subst_db0 store t ~by:"hello" is "hello" = (\x. _[2] "hello" x[0]).
      val shift : store -> t -> by:int -> t
      shift store t ~by shifts all bound variables in t that are not closed on, by amount by (which must be >= 0).
      For example, with term t being \x. _[1] _[2] x[0], shift store t ~by:5 is \x. _[6] _[7] x[0].
      val abs_on : store -> var -> t -> t
      abs_on store v t is the term t[v := _[0]]. It replaces v with the bound variable with the same type as v, and the DB index 0, and takes care of shifting if v occurs under binders.
      For example, abs_on store x (\y. x+y) is \y. _[1] y.
      
diff --git a/dev/sidekick/Sidekick_core_logic/Term/Store/index.html b/dev/sidekick/Sidekick_core_logic/Term/Store/index.html
index 9ef58146..f20d0742 100644
--- a/dev/sidekick/Sidekick_core_logic/Term/Store/index.html
+++ b/dev/sidekick/Sidekick_core_logic/Term/Store/index.html
@@ -1,2 +1,2 @@
 
-Store (sidekick.Sidekick_core_logic.Term.Store)
      Module Term.Store
      type t = store
      val create : ?size:int -> unit -> t
      val size : t -> int
      
+Store (sidekick.Sidekick_core_logic.Term.Store)
      Module Term.Store
      type t = store
      val create : ?size:int -> unit -> t
      val size : t -> int
      
diff --git a/dev/sidekick/Sidekick_core_logic/Term/index.html b/dev/sidekick/Sidekick_core_logic/Term/index.html
index 7c173008..46ae3f43 100644
--- a/dev/sidekick/Sidekick_core_logic/Term/index.html
+++ b/dev/sidekick/Sidekick_core_logic/Term/index.html
@@ -1,5 +1,5 @@
 
-Term (sidekick.Sidekick_core_logic.Term)
      Module Sidekick_core_logic.Term
      Core logic terms.
      The core terms are expressions in the calculus of constructions, with no universe polymorphism nor cumulativity. It should be fast, with hashconsing; and simple enough (no inductives, no universe trickery).
      It is intended to be the foundation for user-level terms and types and formulas.
      type var = Var.t
      type bvar = Bvar.t
      type nonrec term
      type t = term
      A term, in the calculus of constructions
      type store
      The store for terms.
      The store is responsible for allocating unique IDs to terms, and enforcing their hashconsing (so that syntactic equality is just a pointer comparison).
      type view = 
      1. | E_type of int
      2. | E_var of var
      3. | E_bound_var of bvar
      4. | E_app of t * t
      5. | E_app_fold of {
        1. f : term;
          (*
          function to fold
          *)
        2. args : term list;
          (*
          Arguments to the fold
          *)
        3. acc0 : term;
          (*
          initial accumulator
          *)
        }
      6. | E_lam of string * t * t
      7. | E_pi of string * t * t
      View.
      A view is the shape of the root node of a term.
      include Sidekick_sigs.EQ_ORD_HASH with type t := 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
      val pp_debug : t Sidekick_util.Fmt.printer
      val pp_debug_with_ids : t Sidekick_util.Fmt.printer
      Containers
      include Sidekick_sigs.WITH_SET_MAP_TBL with type t := t
      module Set : CCSet.S with type elt = t
      module Map : CCMap.S with type key = t
      module Tbl : CCHashtbl.S with type key = t
      include Sidekick_sigs.WITH_WEAK with type t := t
      module Weak_set : Stdlib.Weak.S with type data = t
      module Weak_map : Stdlib.Ephemeron.S with type key = t
      Utils
      val view : t -> view
      val unfold_app : t -> t * t list
      val is_app : t -> bool
      val is_const : t -> bool
      val is_pi : t -> bool
      val iter_dag : ?seen:unit Tbl.t -> iter_ty:bool -> f:(t -> unit) -> t -> 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
+Term (sidekick.Sidekick_core_logic.Term)
      Module Sidekick_core_logic.Term
      Core logic terms.
      The core terms are expressions in the calculus of constructions, with no universe polymorphism nor cumulativity. It should be fast, with hashconsing; and simple enough (no inductives, no universe trickery).
      It is intended to be the foundation for user-level terms and types and formulas.
      type var = Var.t
      type bvar = Bvar.t
      type nonrec term
      type t = term
      A term, in the calculus of constructions
      type store
      The store for terms.
      The store is responsible for allocating unique IDs to terms, and enforcing their hashconsing (so that syntactic equality is just a pointer comparison).
      type view = 
      1. | E_type of int
      2. | E_var of var
      3. | E_bound_var of bvar
      4. | E_app of t * t
      5. | E_app_fold of {
        1. f : term;
          (*
          function to fold
          *)
        2. args : term list;
          (*
          Arguments to the fold
          *)
        3. acc0 : term;
          (*
          initial accumulator
          *)
        }
      6. | E_lam of string * t * t
      7. | E_pi of string * t * t
      View.
      A view is the shape of the root node of a term.
      include Sidekick_sigs.EQ_ORD_HASH with type t := 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
      val pp_debug : t Sidekick_util.Fmt.printer
      val pp_debug_with_ids : t Sidekick_util.Fmt.printer
      Containers
      include Sidekick_sigs.WITH_SET_MAP_TBL with type t := t
      module Set : CCSet.S with type elt = t
      module Map : CCMap.S with type key = t
      module Tbl : CCHashtbl.S with type key = t
      include Sidekick_sigs.WITH_WEAK with type t := t
      module Weak_set : Stdlib.Weak.S with type data = t
      module Weak_map : Stdlib.Ephemeron.S with type key = t
      Utils
      val view : t -> view
      val unfold_app : t -> t * t list
      val is_app : t -> bool
      val is_const : t -> bool
      val is_pi : t -> bool
      val iter_dag : ?seen:unit Tbl.t -> iter_ty:bool -> f:(t -> unit) -> t -> 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
diff --git a/dev/sidekick/Sidekick_core_logic/Var/index.html b/dev/sidekick/Sidekick_core_logic/Var/index.html
index 198453d4..3c73f564 100644
--- a/dev/sidekick/Sidekick_core_logic/Var/index.html
+++ b/dev/sidekick/Sidekick_core_logic/Var/index.html
@@ -1,5 +1,5 @@
 
-Var (sidekick.Sidekick_core_logic.Var)
      Module Sidekick_core_logic.Var
      Free variable
      type t = {
      1. v_name : string;
      2. v_ty : Sidekick_core_logic__.Types_.term;
      }
      include Sidekick_sigs.EQ_ORD_HASH_PRINT with type t := 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_with_ty : t Sidekick_util.Fmt.printer
      val make : string -> Sidekick_core_logic__.Types_.term -> t
      val makef : 
+Var (sidekick.Sidekick_core_logic.Var)
      Module Sidekick_core_logic.Var
      Free variable
      type t = {
      1. v_name : string;
      2. v_ty : Sidekick_core_logic__.Types_.term;
      }
      include Sidekick_sigs.EQ_ORD_HASH_PRINT with type t := 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_with_ty : t Sidekick_util.Fmt.printer
      val make : string -> Sidekick_core_logic__.Types_.term -> t
      val makef : 
   ('a, Stdlib.Format.formatter, unit, t) Stdlib.format4 ->
   Sidekick_core_logic__.Types_.term ->
   'a
      val name : t -> string
      val ty : t -> Sidekick_core_logic__.Types_.term
      include Sidekick_sigs.WITH_SET_MAP_TBL with type t := t
      module Set : CCSet.S with type elt = t
      module Map : CCMap.S with type key = t
      module Tbl : CCHashtbl.S with type key = t
      
diff --git a/dev/sidekick/Sidekick_core_logic/index.html b/dev/sidekick/Sidekick_core_logic/index.html
index 022f8423..a8b1eadc 100644
--- a/dev/sidekick/Sidekick_core_logic/index.html
+++ b/dev/sidekick/Sidekick_core_logic/index.html
@@ -1,2 +1,2 @@
 
-Sidekick_core_logic (sidekick.Sidekick_core_logic)
      Module Sidekick_core_logic
      module Term : sig ... end
      Core logic terms.
      module Var : sig ... end
      Free variable
      module Bvar : sig ... end
      Bound variable
      module Const : sig ... end
      Constants.
      module Subst : sig ... end
      Substitutions
      module T_builtins : sig ... end
      Core builtins
      module Store = Term.Store
      module Str_const : sig ... end
      Basic string constants.
      
+Sidekick_core_logic (sidekick.Sidekick_core_logic)
      Module Sidekick_core_logic
      module Term : sig ... end
      Core logic terms.
      module Var : sig ... end
      Free variable
      module Bvar : sig ... end
      Bound variable
      module Const : sig ... end
      Constants.
      module Subst : sig ... end
      Substitutions
      module T_builtins : sig ... end
      Core builtins
      module Store = Term.Store
      module Str_const : sig ... end
      Basic string constants.
      
diff --git a/dev/sidekick/Sidekick_drup/Make/Atom/index.html b/dev/sidekick/Sidekick_drup/Make/Atom/index.html
index 33fba474..5301f52d 100644
--- a/dev/sidekick/Sidekick_drup/Make/Atom/index.html
+++ b/dev/sidekick/Sidekick_drup/Make/Atom/index.html
@@ -1,2 +1,2 @@
 
-Atom (sidekick.Sidekick_drup.Make.Atom)
      Module Make.Atom
      type t = private int
      val equal : t -> t -> bool
      val compare : t -> t -> int
      val hash : t -> int
      val neg : t -> t
      val sign : t -> bool
      val pp : t Fmt.printer
      type atom = t
      val of_int_dimacs : int -> t
      Turn a signed integer into an atom. Positive integers are positive atoms, and -i is neg (of_int i).
      • raises Invalid_argument 
        if the argument is 0
      
+Atom (sidekick.Sidekick_drup.Make.Atom)
      Module Make.Atom
      type t = private int
      val equal : t -> t -> bool
      val compare : t -> t -> int
      val hash : t -> int
      val neg : t -> t
      val sign : t -> bool
      val pp : t Fmt.printer
      type atom = t
      val of_int_dimacs : int -> t
      Turn a signed integer into an atom. Positive integers are positive atoms, and -i is neg (of_int i).
      • raises Invalid_argument 
        if the argument is 0
      
diff --git a/dev/sidekick/Sidekick_drup/Make/Checker/index.html b/dev/sidekick/Sidekick_drup/Make/Checker/index.html
index 13ddbf41..27bedca2 100644
--- a/dev/sidekick/Sidekick_drup/Make/Checker/index.html
+++ b/dev/sidekick/Sidekick_drup/Make/Checker/index.html
@@ -1,2 +1,2 @@
 
-Checker (sidekick.Sidekick_drup.Make.Checker)
      Module Make.Checker
      type t
      val create : Clause.store -> t
      val add_clause : t -> Clause.t -> unit
      val is_valid_drup : t -> Clause.t -> bool
      val del_clause : t -> Clause.t -> unit
      
+Checker (sidekick.Sidekick_drup.Make.Checker)
      Module Make.Checker
      type t
      val create : Clause.store -> t
      val add_clause : t -> Clause.t -> unit
      val is_valid_drup : t -> Clause.t -> bool
      val del_clause : t -> Clause.t -> unit
      
diff --git a/dev/sidekick/Sidekick_drup/Make/Clause/index.html b/dev/sidekick/Sidekick_drup/Make/Clause/index.html
index d8582b07..1517b606 100644
--- a/dev/sidekick/Sidekick_drup/Make/Clause/index.html
+++ b/dev/sidekick/Sidekick_drup/Make/Clause/index.html
@@ -1,2 +1,2 @@
 
-Clause (sidekick.Sidekick_drup.Make.Clause)
      Module Make.Clause
      type store
      val create : unit -> store
      type t
      val size : t -> int
      val get : t -> int -> atom
      val iter : f:(atom -> unit) -> t -> unit
      val pp : t Fmt.printer
      val of_list : store -> atom list -> t
      val of_iter : store -> atom Iter.t -> t
      
+Clause (sidekick.Sidekick_drup.Make.Clause)
      Module Make.Clause
      type store
      val create : unit -> store
      type t
      val size : t -> int
      val get : t -> int -> atom
      val iter : f:(atom -> unit) -> t -> unit
      val pp : t Fmt.printer
      val of_list : store -> atom list -> t
      val of_iter : store -> atom Iter.t -> t
      
diff --git a/dev/sidekick/Sidekick_drup/Make/index.html b/dev/sidekick/Sidekick_drup/Make/index.html
index ae2fadcc..a01c7fe9 100644
--- a/dev/sidekick/Sidekick_drup/Make/index.html
+++ b/dev/sidekick/Sidekick_drup/Make/index.html
@@ -1,2 +1,2 @@
 
-Make (sidekick.Sidekick_drup.Make)
      Module Sidekick_drup.Make
      Parameters
      Signature
      module Atom : sig ... end
      type atom = Atom.t
      module Clause : sig ... end
      type clause = Clause.t
      module Checker : sig ... end
      
+Make (sidekick.Sidekick_drup.Make)
      Module Sidekick_drup.Make
      Parameters
      Signature
      module Atom : sig ... end
      type atom = Atom.t
      module Clause : sig ... end
      type clause = Clause.t
      module Checker : sig ... end
      
diff --git a/dev/sidekick/Sidekick_drup/index.html b/dev/sidekick/Sidekick_drup/index.html
index 19425be9..130935e7 100644
--- a/dev/sidekick/Sidekick_drup/index.html
+++ b/dev/sidekick/Sidekick_drup/index.html
@@ -1,2 +1,2 @@
 
-Sidekick_drup (sidekick.Sidekick_drup)
      Module Sidekick_drup
      DRUP trace checker.
      This module provides a checker for DRUP traces, including proof_rule-by-proof_rule checking for traces that interleave DRUP steps with other kinds of steps.
      module Fmt = CCFormat
      module Veci = Sidekick_util.Veci
      module type S = sig ... end
      An instance of the checker
      module Make () : S
      
+Sidekick_drup (sidekick.Sidekick_drup)
      Module Sidekick_drup
      DRUP trace checker.
      This module provides a checker for DRUP traces, including proof_rule-by-proof_rule checking for traces that interleave DRUP steps with other kinds of steps.
      module Fmt = CCFormat
      module Veci = Sidekick_util.Veci
      module type S = sig ... end
      An instance of the checker
      module Make () : S
      
diff --git a/dev/sidekick/Sidekick_drup/module-type-S/Atom/index.html b/dev/sidekick/Sidekick_drup/module-type-S/Atom/index.html
index b5e5b547..d519d979 100644
--- a/dev/sidekick/Sidekick_drup/module-type-S/Atom/index.html
+++ b/dev/sidekick/Sidekick_drup/module-type-S/Atom/index.html
@@ -1,2 +1,2 @@
 
-Atom (sidekick.Sidekick_drup.S.Atom)
      Module S.Atom
      type t = private int
      val equal : t -> t -> bool
      val compare : t -> t -> int
      val hash : t -> int
      val neg : t -> t
      val sign : t -> bool
      val pp : t Fmt.printer
      type atom = t
      val of_int_dimacs : int -> t
      Turn a signed integer into an atom. Positive integers are positive atoms, and -i is neg (of_int i).
      • raises Invalid_argument 
        if the argument is 0
      
+Atom (sidekick.Sidekick_drup.S.Atom)
      Module S.Atom
      type t = private int
      val equal : t -> t -> bool
      val compare : t -> t -> int
      val hash : t -> int
      val neg : t -> t
      val sign : t -> bool
      val pp : t Fmt.printer
      type atom = t
      val of_int_dimacs : int -> t
      Turn a signed integer into an atom. Positive integers are positive atoms, and -i is neg (of_int i).
      • raises Invalid_argument 
        if the argument is 0
      
diff --git a/dev/sidekick/Sidekick_drup/module-type-S/Checker/index.html b/dev/sidekick/Sidekick_drup/module-type-S/Checker/index.html
index 7050654d..02cc83b8 100644
--- a/dev/sidekick/Sidekick_drup/module-type-S/Checker/index.html
+++ b/dev/sidekick/Sidekick_drup/module-type-S/Checker/index.html
@@ -1,2 +1,2 @@
 
-Checker (sidekick.Sidekick_drup.S.Checker)
      Module S.Checker
      type t
      val create : Clause.store -> t
      val add_clause : t -> Clause.t -> unit
      val is_valid_drup : t -> Clause.t -> bool
      val del_clause : t -> Clause.t -> unit
      
+Checker (sidekick.Sidekick_drup.S.Checker)
      Module S.Checker
      type t
      val create : Clause.store -> t
      val add_clause : t -> Clause.t -> unit
      val is_valid_drup : t -> Clause.t -> bool
      val del_clause : t -> Clause.t -> unit
      
diff --git a/dev/sidekick/Sidekick_drup/module-type-S/Clause/index.html b/dev/sidekick/Sidekick_drup/module-type-S/Clause/index.html
index 36b13c14..b4821632 100644
--- a/dev/sidekick/Sidekick_drup/module-type-S/Clause/index.html
+++ b/dev/sidekick/Sidekick_drup/module-type-S/Clause/index.html
@@ -1,2 +1,2 @@
 
-Clause (sidekick.Sidekick_drup.S.Clause)
      Module S.Clause
      type store
      val create : unit -> store
      type t
      val size : t -> int
      val get : t -> int -> atom
      val iter : f:(atom -> unit) -> t -> unit
      val pp : t Fmt.printer
      val of_list : store -> atom list -> t
      val of_iter : store -> atom Iter.t -> t
      
+Clause (sidekick.Sidekick_drup.S.Clause)
      Module S.Clause
      type store
      val create : unit -> store
      type t
      val size : t -> int
      val get : t -> int -> atom
      val iter : f:(atom -> unit) -> t -> unit
      val pp : t Fmt.printer
      val of_list : store -> atom list -> t
      val of_iter : store -> atom Iter.t -> t
      
diff --git a/dev/sidekick/Sidekick_drup/module-type-S/index.html b/dev/sidekick/Sidekick_drup/module-type-S/index.html
index 9e9d1738..3a590f24 100644
--- a/dev/sidekick/Sidekick_drup/module-type-S/index.html
+++ b/dev/sidekick/Sidekick_drup/module-type-S/index.html
@@ -1,2 +1,2 @@
 
-S (sidekick.Sidekick_drup.S)
      Module type Sidekick_drup.S
      An instance of the checker
      module Atom : sig ... end
      type atom = Atom.t
      module Clause : sig ... end
      type clause = Clause.t
      module Checker : sig ... end
      
+S (sidekick.Sidekick_drup.S)
      Module type Sidekick_drup.S
      An instance of the checker
      module Atom : sig ... end
      type atom = Atom.t
      module Clause : sig ... end
      type clause = Clause.t
      module Checker : sig ... end
      
diff --git a/dev/sidekick/Sidekick_memtrace/index.html b/dev/sidekick/Sidekick_memtrace/index.html
index d5440af3..9cd39dcc 100644
--- a/dev/sidekick/Sidekick_memtrace/index.html
+++ b/dev/sidekick/Sidekick_memtrace/index.html
@@ -1,5 +1,5 @@
 
-Sidekick_memtrace (sidekick.Sidekick_memtrace)
      Module Sidekick_memtrace
      val trace_if_requested : 
+Sidekick_memtrace (sidekick.Sidekick_memtrace)
      Module Sidekick_memtrace
      val trace_if_requested : 
   ?context:string ->
   ?sampling_rate:float ->
   unit ->
diff --git a/dev/sidekick/Sidekick_mini_cc/index.html b/dev/sidekick/Sidekick_mini_cc/index.html
index 62300526..2b8e6309 100644
--- a/dev/sidekick/Sidekick_mini_cc/index.html
+++ b/dev/sidekick/Sidekick_mini_cc/index.html
@@ -1,2 +1,2 @@
 
-Sidekick_mini_cc (sidekick.Sidekick_mini_cc)
      Module Sidekick_mini_cc
      Mini congruence closure
      This implementation is as simple as possible, and doesn't provide backtracking, theories, or explanations. It just decides the satisfiability of a set of (dis)equations.
      module type ARG = sig ... end
      Argument for the functor Make
      type t
      An instance of the congruence closure. Mutable
      val create : arg:(module ARG) -> Sidekick_core.Term.store -> t
      Instantiate the congruence closure for the given argument structure.
      val create_default : Sidekick_core.Term.store -> t
      Use the default cc view
      val clear : t -> unit
      Fully reset the congruence closure's state
      val add_lit : t -> Sidekick_core.Term.t -> bool -> unit
      add_lit cc p sign asserts that p is true if sign, or p is false if not sign. If p is an equation and sign is true, this adds a new equation to the congruence relation.
      val check_sat : t -> bool
      check_sat cc returns true if the current state is satisfiable, false if it's unsatisfiable.
      val classes : t -> Sidekick_core.Term.t Iter.t Iter.t
      Traverse the set of classes in the congruence closure. This should be called only if check returned Sat.
      
+Sidekick_mini_cc (sidekick.Sidekick_mini_cc)
      Module Sidekick_mini_cc
      Mini congruence closure
      This implementation is as simple as possible, and doesn't provide backtracking, theories, or explanations. It just decides the satisfiability of a set of (dis)equations.
      module type ARG = sig ... end
      Argument for the functor Make
      type t
      An instance of the congruence closure. Mutable
      val create : arg:(module ARG) -> Sidekick_core.Term.store -> t
      Instantiate the congruence closure for the given argument structure.
      val create_default : Sidekick_core.Term.store -> t
      Use the default cc view
      val clear : t -> unit
      Fully reset the congruence closure's state
      val add_lit : t -> Sidekick_core.Term.t -> bool -> unit
      add_lit cc p sign asserts that p is true if sign, or p is false if not sign. If p is an equation and sign is true, this adds a new equation to the congruence relation.
      val check_sat : t -> bool
      check_sat cc returns true if the current state is satisfiable, false if it's unsatisfiable.
      val classes : t -> Sidekick_core.Term.t Iter.t Iter.t
      Traverse the set of classes in the congruence closure. This should be called only if check returned Sat.
      
diff --git a/dev/sidekick/Sidekick_mini_cc/module-type-ARG/index.html b/dev/sidekick/Sidekick_mini_cc/module-type-ARG/index.html
index befb7562..c71ebc9a 100644
--- a/dev/sidekick/Sidekick_mini_cc/module-type-ARG/index.html
+++ b/dev/sidekick/Sidekick_mini_cc/module-type-ARG/index.html
@@ -1,5 +1,5 @@
 
-ARG (sidekick.Sidekick_mini_cc.ARG)
      Module type Sidekick_mini_cc.ARG
      Argument for the functor Make
      It only requires a Term.t structure, and a congruence-oriented view.
      val view_as_cc : 
+ARG (sidekick.Sidekick_mini_cc.ARG)
      Module type Sidekick_mini_cc.ARG
      Argument for the functor Make
      It only requires a Term.t structure, and a congruence-oriented view.
      
diff --git a/dev/sidekick/Sidekick_proof/Core_rules/index.html b/dev/sidekick/Sidekick_proof/Core_rules/index.html
index 94d5c6ec..d0419b75 100644
--- a/dev/sidekick/Sidekick_proof/Core_rules/index.html
+++ b/dev/sidekick/Sidekick_proof/Core_rules/index.html
@@ -1,5 +1,5 @@
 
-Core_rules (sidekick.Sidekick_proof.Core_rules)
      Module Sidekick_proof.Core_rules
      Core proofs for SMT and congruence closure.
      val lemma_cc : lit list -> Pterm.t
      lemma_cc proof lits asserts that lits form a tautology for the theory of uninterpreted functions.
      val define_term : 
+Core_rules (sidekick.Sidekick_proof.Core_rules)
      Module Sidekick_proof.Core_rules
      Core proofs for SMT and congruence closure.
      val lemma_cc : lit list -> Pterm.t
      lemma_cc proof lits asserts that lits form a tautology for the theory of uninterpreted functions.
      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 : Pterm.step_id -> Pterm.step_id -> Pterm.t
      proof_p1 p1 p2, where p1 proves the unit clause t=u (t:bool) and p2 proves C \/ t, is the Pterm.t that produces C \/ u, i.e unit paramodulation.
      val proof_r1 : Pterm.step_id -> Pterm.step_id -> Pterm.t
      proof_r1 p1 p2, where p1 proves the unit clause |- t (t:bool) and p2 proves C \/ ¬t, is the Pterm.t that produces C \/ u, i.e unit resolution.
      val proof_res : 
diff --git a/dev/sidekick/Sidekick_proof/Pterm/index.html b/dev/sidekick/Sidekick_proof/Pterm/index.html
index 1d83f518..6ce3a20e 100644
--- a/dev/sidekick/Sidekick_proof/Pterm/index.html
+++ b/dev/sidekick/Sidekick_proof/Pterm/index.html
@@ -1,5 +1,5 @@
 
-Pterm (sidekick.Sidekick_proof.Pterm)
      Module Sidekick_proof.Pterm
      Proof terms.
      A proof term is the description of a reasoning step, that yields a clause.
      type step_id = Step.id
      type local_ref = Step.id
      A local reference is a step id that is only valid in the scope of a P_let. Typically one can use negative integers to avoid accidental shadowing.
      type rule_apply = {
      1. rule_name : string;
      2. lit_args : lit list;
      3. term_args : Sidekick_core.Term.t list;
      4. subst_args : Sidekick_core.Subst.t list;
      5. premises : step_id list;
      6. indices : int list;
      }
      type t = 
      1. | P_ref of step_id
      2. | P_local of local_ref
        (*
        Local reference, in a let
        *)
      3. | P_let of (local_ref * t) list * t
      4. | P_apply of rule_apply
      type delayed = unit -> t
      include Sidekick_sigs.PRINT with type t := t
      val ref : step_id -> t
      val local_ref : local_ref -> t
      val let_ : (local_ref * t) list -> t -> t
      val delay : (unit -> t) -> delayed
      val dummy : t
      Reference to the dummy step
      val apply_rule : 
+Pterm (sidekick.Sidekick_proof.Pterm)
      Module Sidekick_proof.Pterm
      Proof terms.
      A proof term is the description of a reasoning step, that yields a clause.
      type step_id = Step.id
      type local_ref = Step.id
      A local reference is a step id that is only valid in the scope of a P_let. Typically one can use negative integers to avoid accidental shadowing.
      type rule_apply = {
      1. rule_name : string;
      2. lit_args : lit list;
      3. term_args : Sidekick_core.Term.t list;
      4. subst_args : Sidekick_core.Subst.t list;
      5. premises : step_id list;
      6. indices : int list;
      }
      type t = 
      1. | P_ref of step_id
      2. | P_local of local_ref
        (*
        Local reference, in a let
        *)
      3. | P_let of (local_ref * t) list * t
      4. | P_apply of rule_apply
      type delayed = unit -> t
      include Sidekick_sigs.PRINT with type t := t
      val ref : step_id -> t
      val local_ref : local_ref -> t
      val let_ : (local_ref * t) list -> t -> t
      val delay : (unit -> t) -> delayed
      val dummy : t
      Reference to the dummy step
      val apply_rule : 
   ?lits:lit list ->
   ?terms:Sidekick_core.Term.t list ->
   ?substs:Sidekick_core.Subst.t list ->
diff --git a/dev/sidekick/Sidekick_proof/Sat_rules/index.html b/dev/sidekick/Sidekick_proof/Sat_rules/index.html
index 2082bdc3..52add2bf 100644
--- a/dev/sidekick/Sidekick_proof/Sat_rules/index.html
+++ b/dev/sidekick/Sidekick_proof/Sat_rules/index.html
@@ -1,2 +1,2 @@
 
-Sat_rules (sidekick.Sidekick_proof.Sat_rules)
      Module Sidekick_proof.Sat_rules
      SAT-solver proof emission.
      val sat_input_clause : lit list -> Pterm.t
      Emit an input clause.
      val sat_redundant_clause : lit list -> hyps:Step.id Iter.t -> Pterm.t
      Emit a clause deduced by the SAT solver, redundant wrt previous clauses. The clause must be RUP wrt hyps.
      val sat_unsat_core : lit list -> Pterm.t
      TODO: is this relevant here?
      
+Sat_rules (sidekick.Sidekick_proof.Sat_rules)
      Module Sidekick_proof.Sat_rules
      SAT-solver proof emission.
      val sat_input_clause : lit list -> Pterm.t
      Emit an input clause.
      val sat_redundant_clause : lit list -> hyps:Step.id Iter.t -> Pterm.t
      Emit a clause deduced by the SAT solver, redundant wrt previous clauses. The clause must be RUP wrt hyps.
      val sat_unsat_core : lit list -> Pterm.t
      TODO: is this relevant here?
      
diff --git a/dev/sidekick/Sidekick_proof/Step/index.html b/dev/sidekick/Sidekick_proof/Step/index.html
index fc2d1054..96d596b7 100644
--- a/dev/sidekick/Sidekick_proof/Step/index.html
+++ b/dev/sidekick/Sidekick_proof/Step/index.html
@@ -1,2 +1,2 @@
 
-Step (sidekick.Sidekick_proof.Step)
      Module Sidekick_proof.Step
      val equal : id -> id -> bool
      val dummy : id
      val pp : id Sidekick_core.Fmt.printer
      
+Step (sidekick.Sidekick_proof.Step)
      Module Sidekick_proof.Step
      val equal : id -> id -> bool
      val dummy : id
      val pp : id Sidekick_core.Fmt.printer
      
diff --git a/dev/sidekick/Sidekick_proof/Step_vec/index.html b/dev/sidekick/Sidekick_proof/Step_vec/index.html
index c266c8f8..f33b1bdb 100644
--- a/dev/sidekick/Sidekick_proof/Step_vec/index.html
+++ b/dev/sidekick/Sidekick_proof/Step_vec/index.html
@@ -1,2 +1,2 @@
 
-Step_vec (sidekick.Sidekick_proof.Step_vec)
      Module Sidekick_proof.Step_vec
      A vector indexed by steps.
      include Sidekick_util.Vec_sig.BASE with type elt = Step.id
      include Sidekick_util.Vec_sig.BASE_RO with type elt = Step.id
      type elt = Step.id
      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 to_iter : t -> elt Iter.t
      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
      
+Step_vec (sidekick.Sidekick_proof.Step_vec)
      Module Sidekick_proof.Step_vec
      A vector indexed by steps.
      include Sidekick_util.Vec_sig.BASE with type elt = Step.id
      include Sidekick_util.Vec_sig.BASE_RO with type elt = Step.id
      type elt = Step.id
      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 to_iter : t -> elt Iter.t
      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
      
diff --git a/dev/sidekick/Sidekick_proof/Trace_reader/index.html b/dev/sidekick/Sidekick_proof/Trace_reader/index.html
index b4ea9c31..6bd4f499 100644
--- a/dev/sidekick/Sidekick_proof/Trace_reader/index.html
+++ b/dev/sidekick/Sidekick_proof/Trace_reader/index.html
@@ -1,5 +1,5 @@
 
-Trace_reader (sidekick.Sidekick_proof.Trace_reader)
      Module Sidekick_proof.Trace_reader
      module Tr = Sidekick_trace
      type step_id = Step.id
      type t
      val read_step : 
+Trace_reader (sidekick.Sidekick_proof.Trace_reader)
      Module Sidekick_proof.Trace_reader
      module Tr = Sidekick_trace
      type step_id = Step.id
      type t
      val read_step : 
   ?fix:bool ->
   t ->
   step_id ->
diff --git a/dev/sidekick/Sidekick_proof/Tracer/class-concrete/index.html b/dev/sidekick/Sidekick_proof/Tracer/class-concrete/index.html
index 445b83db..397ccbda 100644
--- a/dev/sidekick/Sidekick_proof/Tracer/class-concrete/index.html
+++ b/dev/sidekick/Sidekick_proof/Tracer/class-concrete/index.html
@@ -1,2 +1,2 @@
 
-concrete (sidekick.Sidekick_proof.Tracer.concrete)
      Class Tracer.concrete
      Concrete implementation of t
      inherit Sidekick_core.Term.Tracer.t
      method proof_enabled : bool
      If proof tracing enabled?
      method proof_enable : bool -> unit
      Enable/disable proof tracing, if supported
      method emit_proof_step : Sidekick_proof__.Pterm.delayed -> step_id
      Create a new step in the trace.
      method emit_proof_delete : step_id -> unit
      Forget a step that won't be used in the rest of the trace. Only useful for performance/memory considerations.
      
+concrete (sidekick.Sidekick_proof.Tracer.concrete)
      Class Tracer.concrete
      Concrete implementation of t
      inherit Sidekick_core.Term.Tracer.t
      method proof_enabled : bool
      If proof tracing enabled?
      method proof_enable : bool -> unit
      Enable/disable proof tracing, if supported
      method emit_proof_step : Sidekick_proof__.Pterm.delayed -> step_id
      Create a new step in the trace.
      method emit_proof_delete : step_id -> unit
      Forget a step that won't be used in the rest of the trace. Only useful for performance/memory considerations.
      
diff --git a/dev/sidekick/Sidekick_proof/Tracer/class-dummy/index.html b/dev/sidekick/Sidekick_proof/Tracer/class-dummy/index.html
index 8a5ec9df..7ee8061a 100644
--- a/dev/sidekick/Sidekick_proof/Tracer/class-dummy/index.html
+++ b/dev/sidekick/Sidekick_proof/Tracer/class-dummy/index.html
@@ -1,2 +1,2 @@
 
-dummy (sidekick.Sidekick_proof.Tracer.dummy)
      Class Tracer.dummy
      Dummy proof trace, logs nothing.
      inherit Sidekick_core.Term.Tracer.t
      method proof_enabled : bool
      If proof tracing enabled?
      method proof_enable : bool -> unit
      Enable/disable proof tracing, if supported
      method emit_proof_step : Sidekick_proof__.Pterm.delayed -> step_id
      Create a new step in the trace.
      method emit_proof_delete : step_id -> unit
      Forget a step that won't be used in the rest of the trace. Only useful for performance/memory considerations.
      
+dummy (sidekick.Sidekick_proof.Tracer.dummy)
      Class Tracer.dummy
      Dummy proof trace, logs nothing.
      inherit Sidekick_core.Term.Tracer.t
      method proof_enabled : bool
      If proof tracing enabled?
      method proof_enable : bool -> unit
      Enable/disable proof tracing, if supported
      method emit_proof_step : Sidekick_proof__.Pterm.delayed -> step_id
      Create a new step in the trace.
      method emit_proof_delete : step_id -> unit
      Forget a step that won't be used in the rest of the trace. Only useful for performance/memory considerations.
      
diff --git a/dev/sidekick/Sidekick_proof/Tracer/class-type-t/index.html b/dev/sidekick/Sidekick_proof/Tracer/class-type-t/index.html
index 0178041a..5612719c 100644
--- a/dev/sidekick/Sidekick_proof/Tracer/class-type-t/index.html
+++ b/dev/sidekick/Sidekick_proof/Tracer/class-type-t/index.html
@@ -1,2 +1,2 @@
 
-t (sidekick.Sidekick_proof.Tracer.t)
      Class type Tracer.t
      A proof tracer.
      A proof tracer builds a log of all deductive steps taken by the solver, so we can later reconstruct a certificate for proof-checking.
      Each step in the proof trace should be a valid lemma (of its theory) or a valid consequence of previous steps.
      inherit Sidekick_core.Term.Tracer.t
      method proof_enabled : bool
      If proof tracing enabled?
      method proof_enable : bool -> unit
      Enable/disable proof tracing, if supported
      method emit_proof_step : Sidekick_proof__.Pterm.delayed -> step_id
      Create a new step in the trace.
      method emit_proof_delete : step_id -> unit
      Forget a step that won't be used in the rest of the trace. Only useful for performance/memory considerations.
      
+t (sidekick.Sidekick_proof.Tracer.t)
      Class type Tracer.t
      A proof tracer.
      A proof tracer builds a log of all deductive steps taken by the solver, so we can later reconstruct a certificate for proof-checking.
      Each step in the proof trace should be a valid lemma (of its theory) or a valid consequence of previous steps.
      inherit Sidekick_core.Term.Tracer.t
      method proof_enabled : bool
      If proof tracing enabled?
      method proof_enable : bool -> unit
      Enable/disable proof tracing, if supported
      method emit_proof_step : Sidekick_proof__.Pterm.delayed -> step_id
      Create a new step in the trace.
      method emit_proof_delete : step_id -> unit
      Forget a step that won't be used in the rest of the trace. Only useful for performance/memory considerations.
      
diff --git a/dev/sidekick/Sidekick_proof/Tracer/index.html b/dev/sidekick/Sidekick_proof/Tracer/index.html
index e5bed275..48341191 100644
--- a/dev/sidekick/Sidekick_proof/Tracer/index.html
+++ b/dev/sidekick/Sidekick_proof/Tracer/index.html
@@ -1,2 +1,2 @@
 
-Tracer (sidekick.Sidekick_proof.Tracer)
      Module Sidekick_proof.Tracer
      Proof traces.
      A proof trace is a log of all the deductive reasoning steps made by the SMT solver and other reasoning components. It essentially stores a DAG of all these steps, where each step points (via step_id) to its premises.
      type step_id = Step.id
      Identifier for a tracing step (like a unique ID for a clause previously added/proved)
      class type  t = object ... end
      A proof tracer.
      val enabled : t -> bool
      Is proof tracing enabled?
      val enable : t -> bool -> unit
      Enable proof tracing
      val add_step : t -> Pterm.delayed -> step_id
      Create a new step in the trace.
      val delete : t -> step_id -> unit
      Forget a step that won't be used in the rest of the trace. Only useful for performance/memory considerations.
      class dummy : t
      Dummy proof trace, logs nothing.
      val dummy : t
      Concrete implementation of t
      
+Tracer (sidekick.Sidekick_proof.Tracer)
      Module Sidekick_proof.Tracer
      Proof traces.
      A proof trace is a log of all the deductive reasoning steps made by the SMT solver and other reasoning components. It essentially stores a DAG of all these steps, where each step points (via step_id) to its premises.
      type step_id = Step.id
      Identifier for a tracing step (like a unique ID for a clause previously added/proved)
      class type  t = object ... end
      A proof tracer.
      val enabled : t -> bool
      Is proof tracing enabled?
      val enable : t -> bool -> unit
      Enable proof tracing
      val add_step : t -> Pterm.delayed -> step_id
      Create a new step in the trace.
      val delete : t -> step_id -> unit
      Forget a step that won't be used in the rest of the trace. Only useful for performance/memory considerations.
      class dummy : t
      Dummy proof trace, logs nothing.
      val dummy : t
      Concrete implementation of t
      
diff --git a/dev/sidekick/Sidekick_proof/index.html b/dev/sidekick/Sidekick_proof/index.html
index d0941946..49ddd076 100644
--- a/dev/sidekick/Sidekick_proof/index.html
+++ b/dev/sidekick/Sidekick_proof/index.html
@@ -1,2 +1,2 @@
 
-Sidekick_proof (sidekick.Sidekick_proof)
      Module Sidekick_proof
      module Step : sig ... end
      module Step_vec : sig ... end
      A vector indexed by steps.
      module Sat_rules : sig ... end
      SAT-solver proof emission.
      module Core_rules : sig ... end
      Core proofs for SMT and congruence closure.
      module Pterm : sig ... end
      Proof terms.
      module Tracer : sig ... end
      Proof traces.
      module Trace_reader : sig ... end
      module Arg = Stdlib.Arg
      type term = Pterm.t
      type term_ref = Step.id
      type step_id = Step.id
      
+Sidekick_proof (sidekick.Sidekick_proof)
      Module Sidekick_proof
      module Step : sig ... end
      module Step_vec : sig ... end
      A vector indexed by steps.
      module Sat_rules : sig ... end
      SAT-solver proof emission.
      module Core_rules : sig ... end
      Core proofs for SMT and congruence closure.
      module Pterm : sig ... end
      Proof terms.
      module Tracer : sig ... end
      Proof traces.
      module Trace_reader : sig ... end
      module Arg = Stdlib.Arg
      type term = Pterm.t
      type term_ref = Step.id
      type step_id = Step.id
      
diff --git a/dev/sidekick/Sidekick_quip/Proof/Fun/index.html b/dev/sidekick/Sidekick_quip/Proof/Fun/index.html
index 10c4b25c..b113452c 100644
--- a/dev/sidekick/Sidekick_quip/Proof/Fun/index.html
+++ b/dev/sidekick/Sidekick_quip/Proof/Fun/index.html
@@ -1,2 +1,2 @@
 
-Fun (sidekick.Sidekick_quip.Proof.Fun)
      Module Proof.Fun
      type t = string
      val pp : Sidekick_util.Fmt.t -> t -> unit
      val equal : t -> t -> bool
      val hash : t -> int
      
+Fun (sidekick.Sidekick_quip.Proof.Fun)
      Module Proof.Fun
      type t = string
      val pp : Sidekick_util.Fmt.t -> t -> unit
      val equal : t -> t -> bool
      val hash : t -> int
      
diff --git a/dev/sidekick/Sidekick_quip/Proof/Lit/index.html b/dev/sidekick/Sidekick_quip/Proof/Lit/index.html
index a78f81e5..df9b8049 100644
--- a/dev/sidekick/Sidekick_quip/Proof/Lit/index.html
+++ b/dev/sidekick/Sidekick_quip/Proof/Lit/index.html
@@ -1,5 +1,5 @@
 
-Lit (sidekick.Sidekick_quip.Proof.Lit)
      Module Proof.Lit
      type t = 
      1. | L_eq of term * term
      2. | L_a of bool * term
      val pp_with : 
+Lit (sidekick.Sidekick_quip.Proof.Lit)
      Module Proof.Lit
      type t = 
      1. | L_eq of term * term
      2. | L_a of bool * term
      val pp_with : 
   pp_t:(Sidekick_util.Fmt.t -> term -> unit) ->
   Sidekick_util.Fmt.t ->
   t ->
diff --git a/dev/sidekick/Sidekick_quip/Proof/T/index.html b/dev/sidekick/Sidekick_quip/Proof/T/index.html
index f18326e7..038fafcb 100644
--- a/dev/sidekick/Sidekick_quip/Proof/T/index.html
+++ b/dev/sidekick/Sidekick_quip/Proof/T/index.html
@@ -1,2 +1,2 @@
 
-T (sidekick.Sidekick_quip.Proof.T)
      Module Proof.T
      Representation of terms, with explicit sharing
      type t = 
      1. | Bool of bool
      2. | App_fun of Fun.t * t array
      3. | App_ho of t * t
      4. | Is_a of Fun.t * t
      5. | Ite of t * t * t
      6. | Not of t
      7. | Eq of t * t
      8. | Ref of string
      val view : t -> t
      val equal : t -> t -> bool
      val hash : t -> int
      val true_ : t
      val false_ : t
      val bool : bool -> t
      val not_ : t -> t
      val eq : t -> t -> t
      val ref : string -> t
      val app_fun : Fun.t -> t array -> t
      val const : Fun.t -> t
      val app_ho : t -> t -> t
      val ite : t -> t -> t -> t
      val is_a : Fun.t -> t -> t
      
+T (sidekick.Sidekick_quip.Proof.T)
      Module Proof.T
      Representation of terms, with explicit sharing
      type t = 
      1. | Bool of bool
      2. | App_fun of Fun.t * t array
      3. | App_ho of t * t
      4. | Is_a of Fun.t * t
      5. | Ite of t * t * t
      6. | Not of t
      7. | Eq of t * t
      8. | Ref of string
      val view : t -> t
      val equal : t -> t -> bool
      val hash : t -> int
      val true_ : t
      val false_ : t
      val bool : bool -> t
      val not_ : t -> t
      val eq : t -> t -> t
      val ref : string -> t
      val app_fun : Fun.t -> t array -> t
      val const : Fun.t -> t
      val app_ho : t -> t -> t
      val ite : t -> t -> t -> t
      val is_a : Fun.t -> t -> t
      
diff --git a/dev/sidekick/Sidekick_quip/Proof/Ty/index.html b/dev/sidekick/Sidekick_quip/Proof/Ty/index.html
index cf2af744..0e1bb1c0 100644
--- a/dev/sidekick/Sidekick_quip/Proof/Ty/index.html
+++ b/dev/sidekick/Sidekick_quip/Proof/Ty/index.html
@@ -1,2 +1,2 @@
 
-Ty (sidekick.Sidekick_quip.Proof.Ty)
      Module Proof.Ty
      Representation of types
      type t = 
      1. | Bool
      2. | Arrow of t array * t
      3. | App of string * t array
      4. | Ref of string
      val equal : t -> t -> bool
      val hash : t -> int
      val view : t -> t
      
+Ty (sidekick.Sidekick_quip.Proof.Ty)
      Module Proof.Ty
      Representation of types
      type t = 
      1. | Bool
      2. | Arrow of t array * t
      3. | App of string * t array
      4. | Ref of string
      val equal : t -> t -> bool
      val hash : t -> int
      val view : t -> t
      
diff --git a/dev/sidekick/Sidekick_quip/Proof/index.html b/dev/sidekick/Sidekick_quip/Proof/index.html
index 390a1b49..c9b1f345 100644
--- a/dev/sidekick/Sidekick_quip/Proof/index.html
+++ b/dev/sidekick/Sidekick_quip/Proof/index.html
@@ -1,2 +1,2 @@
 
-Proof (sidekick.Sidekick_quip.Proof)
      Module Sidekick_quip.Proof
      type id = int
      A reference to a previously defined object in the proof
      module Ty : sig ... end
      Representation of types
      module Fun : sig ... end
      module Cstor = Fun
      module T : sig ... end
      Representation of terms, with explicit sharing
      type term = T.t
      type ty = Ty.t
      module Lit : sig ... end
      type clause = Lit.t list
      type t = 
      1. | Unspecified
      2. | Sorry
      3. | Sorry_c of clause
      4. | Named of string
      5. | Refl of term
      6. | CC_lemma_imply of t list * term * term
      7. | CC_lemma of clause
      8. | Assertion of term
      9. | Assertion_c of clause
      10. | Hres of t * hres_step list
      11. | Res of term * t * t
      12. | Res1 of t * t
      13. | Paramod1 of t * t
      14. | Rup of clause * t list
      15. | Clause_rw of {
        1. res : clause;
        2. c0 : t;
        3. using : t list;
          (*
          the rewriting equations/atoms
          *)
        }
      16. | DT_isa_split of ty * term list
      17. | DT_isa_disj of ty * term * term
      18. | DT_cstor_inj of Cstor.t * int * term list * term list
      19. | Bool_true_is_true
      20. | Bool_true_neq_false
      21. | Bool_eq of term * term
      22. | Bool_c of bool_c_name * term list
      23. | Ite_true of term
      24. | Ite_false of term
      25. | LRA of clause
      26. | Composite of {
        1. assumptions : (string * Lit.t) list;
        2. steps : composite_step array;
        }
      and bool_c_name = string
      and composite_step = 
      1. | S_step_c of {
        1. name : string;
        2. res : clause;
        3. proof : t;
        }
        (*
        A named step in Composite, with the expected result. This decouples the checking of the sub-proof, from its use in the rest of the proof, as we can use res even if checking proof failed.
        *)
      2. | S_step_anon of {
        1. name : string;
        2. proof : t;
        }
        (*
        A named intermediate proof, to be reused in subsequent proofs. Unlike S_step_c we do not specify the expected result so if this fails, any proof downstream will also fail.
        *)
      3. | S_define_t of term * term
      4. | S_define_t_name of string * term
      and hres_step = 
      1. | R of {
        1. pivot : term;
        2. p : t;
        }
      2. | R1 of t
      3. | P of {
        1. lhs : term;
        2. rhs : term;
        3. p : t;
        }
      4. | P1 of t
      val r : t -> pivot:term -> hres_step
      val r1 : t -> hres_step
      val p : t -> lhs:term -> rhs:term -> hres_step
      val p1 : t -> hres_step
      val stepc : name:string -> clause -> t -> composite_step
      val step_anon : name:string -> t -> composite_step
      val deft : term -> term -> composite_step
      val deft_name : string -> term -> composite_step
      val is_trivial_refl : t -> bool
      val default : t
      val sorry_c : Lit.t Iter.t -> t
      val sorry_c_l : clause -> t
      val sorry : t
      val refl : term -> t
      val ref_by_name : string -> t
      val cc_lemma : clause -> t
      val cc_imply_l : t list -> term -> term -> t
      val cc_imply2 : t -> t -> term -> term -> t
      val assertion : term -> t
      val assertion_c : Lit.t Iter.t -> t
      val assertion_c_l : clause -> t
      val rup : clause -> t list -> t
      val clause_rw : t -> res:clause -> using:t list -> t
      val composite_a : ?assms:(string * Lit.t) list -> composite_step array -> t
      val composite_l : ?assms:(string * Lit.t) list -> composite_step list -> t
      val composite_iter : ?assms:(string * Lit.t) list -> composite_step Iter.t -> t
      val isa_split : ty -> term Iter.t -> t
      val isa_disj : ty -> term -> term -> t
      val cstor_inj : Cstor.t -> int -> term list -> term list -> t
      val ite_true : term -> t
      val ite_false : term -> t
      val true_is_true : t
      val true_neq_false : t
      val bool_eq : term -> term -> t
      val bool_c : bool_c_name -> term list -> t
      val hres_l : t -> hres_step list -> t
      val hres_iter : t -> hres_step Iter.t -> t
      val res : pivot:term -> t -> t -> t
      val res1 : t -> t -> t
      val paramod1 : t -> t -> t
      val lra_l : clause -> t
      val lra : Lit.t Iter.t -> t
      
+Proof (sidekick.Sidekick_quip.Proof)
      Module Sidekick_quip.Proof
      type id = int
      A reference to a previously defined object in the proof
      module Ty : sig ... end
      Representation of types
      module Fun : sig ... end
      module Cstor = Fun
      module T : sig ... end
      Representation of terms, with explicit sharing
      type term = T.t
      type ty = Ty.t
      module Lit : sig ... end
      type clause = Lit.t list
      type t = 
      1. | Unspecified
      2. | Sorry
      3. | Sorry_c of clause
      4. | Named of string
      5. | Refl of term
      6. | CC_lemma_imply of t list * term * term
      7. | CC_lemma of clause
      8. | Assertion of term
      9. | Assertion_c of clause
      10. | Hres of t * hres_step list
      11. | Res of term * t * t
      12. | Res1 of t * t
      13. | Paramod1 of t * t
      14. | Rup of clause * t list
      15. | Clause_rw of {
        1. res : clause;
        2. c0 : t;
        3. using : t list;
          (*
          the rewriting equations/atoms
          *)
        }
      16. | DT_isa_split of ty * term list
      17. | DT_isa_disj of ty * term * term
      18. | DT_cstor_inj of Cstor.t * int * term list * term list
      19. | Bool_true_is_true
      20. | Bool_true_neq_false
      21. | Bool_eq of term * term
      22. | Bool_c of bool_c_name * term list
      23. | Ite_true of term
      24. | Ite_false of term
      25. | LRA of clause
      26. | Composite of {
        1. assumptions : (string * Lit.t) list;
        2. steps : composite_step array;
        }
      and bool_c_name = string
      and composite_step = 
      1. | S_step_c of {
        1. name : string;
        2. res : clause;
        3. proof : t;
        }
        (*
        A named step in Composite, with the expected result. This decouples the checking of the sub-proof, from its use in the rest of the proof, as we can use res even if checking proof failed.
        *)
      2. | S_step_anon of {
        1. name : string;
        2. proof : t;
        }
        (*
        A named intermediate proof, to be reused in subsequent proofs. Unlike S_step_c we do not specify the expected result so if this fails, any proof downstream will also fail.
        *)
      3. | S_define_t of term * term
      4. | S_define_t_name of string * term
      and hres_step = 
      1. | R of {
        1. pivot : term;
        2. p : t;
        }
      2. | R1 of t
      3. | P of {
        1. lhs : term;
        2. rhs : term;
        3. p : t;
        }
      4. | P1 of t
      val r : t -> pivot:term -> hres_step
      val r1 : t -> hres_step
      val p : t -> lhs:term -> rhs:term -> hres_step
      val p1 : t -> hres_step
      val stepc : name:string -> clause -> t -> composite_step
      val step_anon : name:string -> t -> composite_step
      val deft : term -> term -> composite_step
      val deft_name : string -> term -> composite_step
      val is_trivial_refl : t -> bool
      val default : t
      val sorry_c : Lit.t Iter.t -> t
      val sorry_c_l : clause -> t
      val sorry : t
      val refl : term -> t
      val ref_by_name : string -> t
      val cc_lemma : clause -> t
      val cc_imply_l : t list -> term -> term -> t
      val cc_imply2 : t -> t -> term -> term -> t
      val assertion : term -> t
      val assertion_c : Lit.t Iter.t -> t
      val assertion_c_l : clause -> t
      val rup : clause -> t list -> t
      val clause_rw : t -> res:clause -> using:t list -> t
      val composite_a : ?assms:(string * Lit.t) list -> composite_step array -> t
      val composite_l : ?assms:(string * Lit.t) list -> composite_step list -> t
      val composite_iter : ?assms:(string * Lit.t) list -> composite_step Iter.t -> t
      val isa_split : ty -> term Iter.t -> t
      val isa_disj : ty -> term -> term -> t
      val cstor_inj : Cstor.t -> int -> term list -> term list -> t
      val ite_true : term -> t
      val ite_false : term -> t
      val true_is_true : t
      val true_neq_false : t
      val bool_eq : term -> term -> t
      val bool_c : bool_c_name -> term list -> t
      val hres_l : t -> hres_step list -> t
      val hres_iter : t -> hres_step Iter.t -> t
      val res : pivot:term -> t -> t -> t
      val res1 : t -> t -> t
      val paramod1 : t -> t -> t
      val lra_l : clause -> t
      val lra : Lit.t Iter.t -> t
      
diff --git a/dev/sidekick/Sidekick_quip/index.html b/dev/sidekick/Sidekick_quip/index.html
index f12a0864..d1148244 100644
--- a/dev/sidekick/Sidekick_quip/index.html
+++ b/dev/sidekick/Sidekick_quip/index.html
@@ -1,2 +1,2 @@
 
-Sidekick_quip (sidekick.Sidekick_quip)
      Module Sidekick_quip
      Proofs of unsatisfiability in the Quip proof format..
      This targets Quip as an experimental proof backend.
      module Proof : sig ... end
      type t = Proof.t
      The state holding the whole proof.
      type out_format = 
      1. | Sexp
        (*
        S-expressions
        *)
      2. | CSexp
        (*
        Canonical S-expressions
        *)
      What format to use to serialize the proof?
      val pp_out_format : out_format Sidekick_util.Fmt.printer
      val output : ?fmt:out_format -> Stdlib.out_channel -> t -> unit
      val pp_debug : t Sidekick_util.Fmt.printer
      
+Sidekick_quip (sidekick.Sidekick_quip)
      Module Sidekick_quip
      Proofs of unsatisfiability in the Quip proof format..
      This targets Quip as an experimental proof backend.
      module Proof : sig ... end
      type t = Proof.t
      The state holding the whole proof.
      type out_format = 
      1. | Sexp
        (*
        S-expressions
        *)
      2. | CSexp
        (*
        Canonical S-expressions
        *)
      What format to use to serialize the proof?
      val pp_out_format : out_format Sidekick_util.Fmt.printer
      val output : ?fmt:out_format -> Stdlib.out_channel -> t -> unit
      val pp_debug : t Sidekick_util.Fmt.printer
      
diff --git a/dev/sidekick/Sidekick_sat/Solver/Clause/index.html b/dev/sidekick/Sidekick_sat/Solver/Clause/index.html
index 9a9408ef..967fc2da 100644
--- a/dev/sidekick/Sidekick_sat/Solver/Clause/index.html
+++ b/dev/sidekick/Sidekick_sat/Solver/Clause/index.html
@@ -1,2 +1,2 @@
 
-Clause (sidekick.Sidekick_sat.Solver.Clause)
      Module Solver.Clause
      type t = clause
      val equal : t -> t -> bool
      module Tbl : Stdlib.Hashtbl.S with type key = t
      val pp : store -> t Sidekick_core.Fmt.printer
      Print the clause
      val short_name : store -> t -> string
      Short name for a clause. Unspecified
      val n_atoms : store -> t -> int
      val lits_iter : store -> t -> Sidekick_core.Lit.t Iter.t
      Literals of a clause
      val lits_a : store -> t -> Sidekick_core.Lit.t array
      Atoms of a clause
      val lits_l : store -> t -> Sidekick_core.Lit.t list
      List of atoms of a clause
      
+Clause (sidekick.Sidekick_sat.Solver.Clause)
      Module Solver.Clause
      type t = clause
      val equal : t -> t -> bool
      module Tbl : Stdlib.Hashtbl.S with type key = t
      val pp : store -> t Sidekick_core.Fmt.printer
      Print the clause
      val short_name : store -> t -> string
      Short name for a clause. Unspecified
      val n_atoms : store -> t -> int
      val lits_iter : store -> t -> Sidekick_core.Lit.t Iter.t
      Literals of a clause
      val lits_a : store -> t -> Sidekick_core.Lit.t array
      Atoms of a clause
      val lits_l : store -> t -> Sidekick_core.Lit.t list
      List of atoms of a clause
      
diff --git a/dev/sidekick/Sidekick_sat/Solver/index.html b/dev/sidekick/Sidekick_sat/Solver/index.html
index 397416db..ded163ee 100644
--- a/dev/sidekick/Sidekick_sat/Solver/index.html
+++ b/dev/sidekick/Sidekick_sat/Solver/index.html
@@ -1,5 +1,5 @@
 
-Solver (sidekick.Sidekick_sat.Solver)
      Module Sidekick_sat.Solver
      The external interface implemented by SAT solvers.
      type clause
      type plugin = (module Sidekick_sat__.Sigs.PLUGIN)
      type solver
      The main solver type.
      type store
      Stores atoms, clauses, etc.
      module Clause : sig ... end
      Main Solver Type
      type t = solver
      Main solver type, containing all state for solving.
      val store : t -> store
      Store for the solver
      val stat : t -> Sidekick_util.Stat.t
      Statistics
      val tracer : t -> Tracer.t
      Access the inner proof
      val on_conflict : t -> (Clause.t, unit) Sidekick_util.Event.t
      val on_decision : t -> (Sidekick_core.Lit.t, unit) Sidekick_util.Event.t
      val on_learnt : t -> (Clause.t, unit) Sidekick_util.Event.t
      val on_gc : t -> (Sidekick_core.Lit.t array, unit) Sidekick_util.Event.t
      Types
      type res = 
      1. | Sat of (module Sidekick_sat__.Sigs.SAT_STATE)
        (*
        Returned when the solver reaches SAT, with a model
        *)
      2. | Unsat of (module Sidekick_sat__.Sigs.UNSAT_STATE with type clause = clause)
        (*
        Returned when the solver reaches UNSAT, with a proof
        *)
      Result type for the solver
      exception UndecidedLit
      Exception raised by the evaluating functions when a literal has not yet been assigned a value.
      Base operations
      val assume : t -> Sidekick_core.Lit.t list list -> unit
      Add the list of clauses to the current set of assumptions. Modifies the sat solver state in place.
      val add_clause : 
+Solver (sidekick.Sidekick_sat.Solver)
      Module Sidekick_sat.Solver
      The external interface implemented by SAT solvers.
      type clause
      type plugin = (module Sidekick_sat__.Sigs.PLUGIN)
      type solver
      The main solver type.
      type store
      Stores atoms, clauses, etc.
      module Clause : sig ... end
      Main Solver Type
      type t = solver
      Main solver type, containing all state for solving.
      val store : t -> store
      Store for the solver
      val stat : t -> Sidekick_util.Stat.t
      Statistics
      val tracer : t -> Tracer.t
      Access the inner proof
      val on_conflict : t -> (Clause.t, unit) Sidekick_util.Event.t
      val on_decision : t -> (Sidekick_core.Lit.t, unit) Sidekick_util.Event.t
      val on_learnt : t -> (Clause.t, unit) Sidekick_util.Event.t
      val on_gc : t -> (Sidekick_core.Lit.t array, unit) Sidekick_util.Event.t
      Types
      type res = 
      1. | Sat of (module Sidekick_sat__.Sigs.SAT_STATE)
        (*
        Returned when the solver reaches SAT, with a model
        *)
      2. | Unsat of (module Sidekick_sat__.Sigs.UNSAT_STATE with type clause = clause)
        (*
        Returned when the solver reaches UNSAT, with a proof
        *)
      Result type for the solver
      exception UndecidedLit
      Exception raised by the evaluating functions when a literal has not yet been assigned a value.
      Base operations
      val assume : t -> Sidekick_core.Lit.t list list -> unit
      Add the list of clauses to the current set of assumptions. Modifies the sat solver state in place.
      val add_clause : 
   t ->
   Sidekick_core.Lit.t list ->
   Sidekick_proof.Pterm.delayed ->
diff --git a/dev/sidekick/Sidekick_sat/Tracer/class-dummy/index.html b/dev/sidekick/Sidekick_sat/Tracer/class-dummy/index.html
index b7ca0cc0..da19caf6 100644
--- a/dev/sidekick/Sidekick_sat/Tracer/class-dummy/index.html
+++ b/dev/sidekick/Sidekick_sat/Tracer/class-dummy/index.html
@@ -1,5 +1,5 @@
 
-dummy (sidekick.Sidekick_sat.Tracer.dummy)
      Class Tracer.dummy
      inherit Proof.Tracer.t
      method sat_assert_clause : id:int ->
+dummy (sidekick.Sidekick_sat.Tracer.dummy)
      Class Tracer.dummy
      inherit Proof.Tracer.t
      method sat_assert_clause : id:int ->
   Sidekick_core.Lit.t Iter.t ->
   Proof.Step.id ->
   Tr.Entry_id.t
      method sat_delete_clause : id:int -> Sidekick_core.Lit.t Iter.t -> unit
      method sat_unsat_clause : id:int -> Tr.Entry_id.t
      
diff --git a/dev/sidekick/Sidekick_sat/Tracer/class-type-t/index.html b/dev/sidekick/Sidekick_sat/Tracer/class-type-t/index.html
index 205e3e1f..2f8884f2 100644
--- a/dev/sidekick/Sidekick_sat/Tracer/class-type-t/index.html
+++ b/dev/sidekick/Sidekick_sat/Tracer/class-type-t/index.html
@@ -1,5 +1,5 @@
 
-t (sidekick.Sidekick_sat.Tracer.t)
      Class type Tracer.t
      Tracer for the SAT solver.
      inherit Proof.Tracer.t
      method sat_assert_clause : id:int ->
+t (sidekick.Sidekick_sat.Tracer.t)
      Class type Tracer.t
      Tracer for the SAT solver.
      inherit Proof.Tracer.t
      method sat_assert_clause : id:int ->
   Sidekick_core.Lit.t Iter.t ->
   Proof.Step.id ->
   Tr.Entry_id.t
      method sat_delete_clause : id:int -> Sidekick_core.Lit.t Iter.t -> unit
      method sat_unsat_clause : id:int -> Tr.Entry_id.t
      
diff --git a/dev/sidekick/Sidekick_sat/Tracer/index.html b/dev/sidekick/Sidekick_sat/Tracer/index.html
index e2617bd3..a67c3545 100644
--- a/dev/sidekick/Sidekick_sat/Tracer/index.html
+++ b/dev/sidekick/Sidekick_sat/Tracer/index.html
@@ -1,5 +1,5 @@
 
-Tracer (sidekick.Sidekick_sat.Tracer)
      Module Sidekick_sat.Tracer
      Tracer for clauses and literals
      module Tr = Sidekick_trace
      module Proof = Sidekick_proof
      class type  t = object ... end
      Tracer for the SAT solver.
      class dummy : t
      val dummy : t
      Dummy tracer, recording nothing.
      val assert_clause : 
+Tracer (sidekick.Sidekick_sat.Tracer)
      Module Sidekick_sat.Tracer
      Tracer for clauses and literals
      module Tr = Sidekick_trace
      module Proof = Sidekick_proof
      class type  t = object ... end
      Tracer for the SAT solver.
      class dummy : t
      val dummy : t
      Dummy tracer, recording nothing.
      val assert_clause : 
   t ->
   id:int ->
   Sidekick_core.Lit.t Iter.t ->
diff --git a/dev/sidekick/Sidekick_sat/index.html b/dev/sidekick/Sidekick_sat/index.html
index 22a61129..af88dab6 100644
--- a/dev/sidekick/Sidekick_sat/index.html
+++ b/dev/sidekick/Sidekick_sat/index.html
@@ -1,5 +1,5 @@
 
-Sidekick_sat (sidekick.Sidekick_sat)
      Module Sidekick_sat
      Main API
      module Proof = Sidekick_proof
      exception UndecidedLit
      module type SAT_STATE = sig ... end
      Solver in a "SATISFIABLE" state
      type sat_state = (module SAT_STATE)
      The type of values returned when the solver reaches a SAT state.
      module type UNSAT_STATE = sig ... end
      Solver in an "UNSATISFIABLE" state
      type 'clause unsat_state = (module UNSAT_STATE with type clause = 'clause)
      The type of values returned when the solver reaches an UNSAT state.
      type same_sign = bool
      This type is used during the normalisation of lits. true means the literal stayed the same, false that its sign was flipped.
      type reason = 
      1. | Consequence of unit -> Sidekick_core.Lit.t list * Sidekick_proof.Pterm.delayed
      The type of reasons for propagations of a lit f.
      Consequence (l, p) means that the lits in l imply the propagated lit f. The proof should be a proof of the clause "l implies f".
      invariant: in Consequence (fun () -> l,p), all elements of l must be true in the current trail.
      note on lazyiness: the justification is suspended (using unit -> …) to avoid potentially costly computations that might never be used if this literal is backtracked without participating in a conflict. Therefore the function that produces (l,p) needs only be safe in trails (partial models) that are conservative extensions of the current trail. If the theory isn't robust w.r.t. extensions of the trail (e.g. if its internal state undergoes significant changes), it can be easier to produce the explanation eagerly when propagating, and then use Consequence (fun () -> expl, proof) with the already produced (expl,proof) tuple.
      type lbool = 
      1. | L_true
      2. | L_false
      3. | L_undefined
        (*
        Valuation of an atom
        *)
      val pp_lbool : Sidekick_core.Fmt.t -> lbool -> unit
      module type ACTS = sig ... end
      Actions available to the Plugin.
      type acts = (module ACTS)
      The type for a slice of assertions to assume/propagate in the theory.
      module type THEORY_CDCL_T = sig ... end
      Signature for theories to be given to the CDCL(T) solver
      module type PLUGIN = sig ... end
      module Solver : sig ... end
      The external interface implemented by SAT solvers.
      module Tracer : sig ... end
      Tracer for clauses and literals
      include module type of struct include Solver end
      type clause = Solver.clause
      type plugin = (module Sidekick_sat__.Sigs.PLUGIN)
      type solver = Solver.solver
      The main solver type.
      type store = Solver.store
      Stores atoms, clauses, etc.
      module Clause = Solver.Clause
      Main Solver Type
      type t = solver
      Main solver type, containing all state for solving.
      val store : t -> store
      Store for the solver
      val stat : t -> Sidekick_util.Stat.t
      Statistics
      val tracer : t -> Tracer.t
      Access the inner proof
      val on_conflict : t -> (Clause.t, unit) Sidekick_util.Event.t
      val on_decision : t -> (Sidekick_core.Lit.t, unit) Sidekick_util.Event.t
      val on_learnt : t -> (Clause.t, unit) Sidekick_util.Event.t
      val on_gc : t -> (Sidekick_core.Lit.t array, unit) Sidekick_util.Event.t
      Types
      type res = Solver.res = 
      1. | Sat of (module Sidekick_sat__.Sigs.SAT_STATE)
        (*
        Returned when the solver reaches SAT, with a model
        *)
      2. | Unsat of (module Sidekick_sat__.Sigs.UNSAT_STATE with type clause = clause)
        (*
        Returned when the solver reaches UNSAT, with a proof
        *)
      Result type for the solver
      exception UndecidedLit
      Exception raised by the evaluating functions when a literal has not yet been assigned a value.
      Base operations
      val assume : t -> Sidekick_core.Lit.t list list -> unit
      Add the list of clauses to the current set of assumptions. Modifies the sat solver state in place.
      val add_clause : 
+Sidekick_sat (sidekick.Sidekick_sat)
      Module Sidekick_sat
      Main API
      module Proof = Sidekick_proof
      exception UndecidedLit
      module type SAT_STATE = sig ... end
      Solver in a "SATISFIABLE" state
      type sat_state = (module SAT_STATE)
      The type of values returned when the solver reaches a SAT state.
      module type UNSAT_STATE = sig ... end
      Solver in an "UNSATISFIABLE" state
      type 'clause unsat_state = (module UNSAT_STATE with type clause = 'clause)
      The type of values returned when the solver reaches an UNSAT state.
      type same_sign = bool
      This type is used during the normalisation of lits. true means the literal stayed the same, false that its sign was flipped.
      type reason = 
      1. | Consequence of unit -> Sidekick_core.Lit.t list * Sidekick_proof.Pterm.delayed
      The type of reasons for propagations of a lit f.
      Consequence (l, p) means that the lits in l imply the propagated lit f. The proof should be a proof of the clause "l implies f".
      invariant: in Consequence (fun () -> l,p), all elements of l must be true in the current trail.
      note on lazyiness: the justification is suspended (using unit -> …) to avoid potentially costly computations that might never be used if this literal is backtracked without participating in a conflict. Therefore the function that produces (l,p) needs only be safe in trails (partial models) that are conservative extensions of the current trail. If the theory isn't robust w.r.t. extensions of the trail (e.g. if its internal state undergoes significant changes), it can be easier to produce the explanation eagerly when propagating, and then use Consequence (fun () -> expl, proof) with the already produced (expl,proof) tuple.
      type lbool = 
      1. | L_true
      2. | L_false
      3. | L_undefined
        (*
        Valuation of an atom
        *)
      val pp_lbool : Sidekick_core.Fmt.t -> lbool -> unit
      module type ACTS = sig ... end
      Actions available to the Plugin.
      type acts = (module ACTS)
      The type for a slice of assertions to assume/propagate in the theory.
      module type THEORY_CDCL_T = sig ... end
      Signature for theories to be given to the CDCL(T) solver
      module type PLUGIN = sig ... end
      module Solver : sig ... end
      The external interface implemented by SAT solvers.
      module Tracer : sig ... end
      Tracer for clauses and literals
      include module type of struct include Solver end
      type clause = Solver.clause
      type plugin = (module Sidekick_sat__.Sigs.PLUGIN)
      type solver = Solver.solver
      The main solver type.
      type store = Solver.store
      Stores atoms, clauses, etc.
      module Clause = Solver.Clause
      Main Solver Type
      type t = solver
      Main solver type, containing all state for solving.
      val store : t -> store
      Store for the solver
      val stat : t -> Sidekick_util.Stat.t
      Statistics
      val tracer : t -> Tracer.t
      Access the inner proof
      val on_conflict : t -> (Clause.t, unit) Sidekick_util.Event.t
      val on_decision : t -> (Sidekick_core.Lit.t, unit) Sidekick_util.Event.t
      val on_learnt : t -> (Clause.t, unit) Sidekick_util.Event.t
      val on_gc : t -> (Sidekick_core.Lit.t array, unit) Sidekick_util.Event.t
      Types
      type res = Solver.res = 
      1. | Sat of (module Sidekick_sat__.Sigs.SAT_STATE)
        (*
        Returned when the solver reaches SAT, with a model
        *)
      2. | Unsat of (module Sidekick_sat__.Sigs.UNSAT_STATE with type clause = clause)
        (*
        Returned when the solver reaches UNSAT, with a proof
        *)
      Result type for the solver
      exception UndecidedLit
      Exception raised by the evaluating functions when a literal has not yet been assigned a value.
      Base operations
      val assume : t -> Sidekick_core.Lit.t list list -> unit
      Add the list of clauses to the current set of assumptions. Modifies the sat solver state in place.
      val add_clause : 
   t ->
   Sidekick_core.Lit.t list ->
   Sidekick_proof.Pterm.delayed ->
diff --git a/dev/sidekick/Sidekick_sat/module-type-ACTS/index.html b/dev/sidekick/Sidekick_sat/module-type-ACTS/index.html
index 3d2829cc..9ad3db38 100644
--- a/dev/sidekick/Sidekick_sat/module-type-ACTS/index.html
+++ b/dev/sidekick/Sidekick_sat/module-type-ACTS/index.html
@@ -1,5 +1,5 @@
 
-ACTS (sidekick.Sidekick_sat.ACTS)
      Module type Sidekick_sat.ACTS
      Actions available to the Plugin.
      The plugin provides callbacks for the SAT solver to use. These callbacks are provided with a (module ACTS) so they can modify the SAT solver by adding new lemmas, raise conflicts, etc.
      val proof_tracer : Sidekick_proof.Tracer.t
      val iter_assumptions : (Sidekick_core.Lit.t -> unit) -> unit
      Traverse the new assumptions on the boolean trail.
      val eval_lit : Sidekick_core.Lit.t -> Sidekick_sat__.Sigs.lbool
      Obtain current value of the given literal
      val add_lit : ?default_pol:bool -> Sidekick_core.Lit.t -> unit
      Map the given lit to an internal atom, which will be decided by the SAT solver.
      val add_clause : 
+ACTS (sidekick.Sidekick_sat.ACTS)
      Module type Sidekick_sat.ACTS
      Actions available to the Plugin.
      The plugin provides callbacks for the SAT solver to use. These callbacks are provided with a (module ACTS) so they can modify the SAT solver by adding new lemmas, raise conflicts, etc.
      val proof_tracer : Sidekick_proof.Tracer.t
      val iter_assumptions : (Sidekick_core.Lit.t -> unit) -> unit
      Traverse the new assumptions on the boolean trail.
      val eval_lit : Sidekick_core.Lit.t -> Sidekick_sat__.Sigs.lbool
      Obtain current value of the given literal
      val add_lit : ?default_pol:bool -> Sidekick_core.Lit.t -> unit
      Map the given lit to an internal atom, which will be decided by the SAT solver.
      val add_clause : 
   ?keep:bool ->
   Sidekick_core.Lit.t list ->
   Sidekick_proof.Pterm.delayed ->
diff --git a/dev/sidekick/Sidekick_sat/module-type-PLUGIN/index.html b/dev/sidekick/Sidekick_sat/module-type-PLUGIN/index.html
index 91a048a6..c47eb740 100644
--- a/dev/sidekick/Sidekick_sat/module-type-PLUGIN/index.html
+++ b/dev/sidekick/Sidekick_sat/module-type-PLUGIN/index.html
@@ -1,2 +1,2 @@
 
-PLUGIN (sidekick.Sidekick_sat.PLUGIN)
      Module type Sidekick_sat.PLUGIN
      val push_level : unit -> unit
      Create a new backtrack level
      val pop_levels : int -> unit
      Pop n levels of the theory
      val partial_check : (module Sidekick_sat__.Sigs.ACTS) -> unit
      Assume the lits in the slice, possibly using the slice to push new lits to be propagated or to raising a conflict or to add new lemmas.
      val final_check : (module Sidekick_sat__.Sigs.ACTS) -> unit
      Called at the end of the search in case a model has been found. If no new clause is pushed, then proof search ends and "sat" is returned; if lemmas are added, search is resumed; if a conflict clause is added, search backtracks and then resumes.
      val has_theory : bool
      true iff the solver is parametrized by a theory, not just pure SAT.
      
+PLUGIN (sidekick.Sidekick_sat.PLUGIN)
      Module type Sidekick_sat.PLUGIN
      val push_level : unit -> unit
      Create a new backtrack level
      val pop_levels : int -> unit
      Pop n levels of the theory
      val partial_check : (module Sidekick_sat__.Sigs.ACTS) -> unit
      Assume the lits in the slice, possibly using the slice to push new lits to be propagated or to raising a conflict or to add new lemmas.
      val final_check : (module Sidekick_sat__.Sigs.ACTS) -> unit
      Called at the end of the search in case a model has been found. If no new clause is pushed, then proof search ends and "sat" is returned; if lemmas are added, search is resumed; if a conflict clause is added, search backtracks and then resumes.
      val has_theory : bool
      true iff the solver is parametrized by a theory, not just pure SAT.
      
diff --git a/dev/sidekick/Sidekick_sat/module-type-SAT_STATE/index.html b/dev/sidekick/Sidekick_sat/module-type-SAT_STATE/index.html
index f07efa62..de4d7e85 100644
--- a/dev/sidekick/Sidekick_sat/module-type-SAT_STATE/index.html
+++ b/dev/sidekick/Sidekick_sat/module-type-SAT_STATE/index.html
@@ -1,2 +1,2 @@
 
-SAT_STATE (sidekick.Sidekick_sat.SAT_STATE)
      Module type Sidekick_sat.SAT_STATE
      Solver in a "SATISFIABLE" state
      val eval : Sidekick_core.Lit.t -> bool
      Returns the valuation of a lit in the current state of the sat solver.
      val eval_level : Sidekick_core.Lit.t -> bool * int
      Return the current assignement of the literals, as well as its decision level. If the level is 0, then it is necessary for the literal to have this value; otherwise it is due to choices that can potentially be backtracked.
      val iter_trail : (Sidekick_core.Lit.t -> unit) -> unit
      Iter through the lits in order of decision/propagation (starting from the first propagation, to the last propagation).
      
+SAT_STATE (sidekick.Sidekick_sat.SAT_STATE)
      Module type Sidekick_sat.SAT_STATE
      Solver in a "SATISFIABLE" state
      val eval : Sidekick_core.Lit.t -> bool
      Returns the valuation of a lit in the current state of the sat solver.
      val eval_level : Sidekick_core.Lit.t -> bool * int
      Return the current assignement of the literals, as well as its decision level. If the level is 0, then it is necessary for the literal to have this value; otherwise it is due to choices that can potentially be backtracked.
      val iter_trail : (Sidekick_core.Lit.t -> unit) -> unit
      Iter through the lits in order of decision/propagation (starting from the first propagation, to the last propagation).
      
diff --git a/dev/sidekick/Sidekick_sat/module-type-THEORY_CDCL_T/index.html b/dev/sidekick/Sidekick_sat/module-type-THEORY_CDCL_T/index.html
index d5167d50..c58a0088 100644
--- a/dev/sidekick/Sidekick_sat/module-type-THEORY_CDCL_T/index.html
+++ b/dev/sidekick/Sidekick_sat/module-type-THEORY_CDCL_T/index.html
@@ -1,2 +1,2 @@
 
-THEORY_CDCL_T (sidekick.Sidekick_sat.THEORY_CDCL_T)
      Module type Sidekick_sat.THEORY_CDCL_T
      Signature for theories to be given to the CDCL(T) solver
      val push_level : unit -> unit
      Create a new backtrack level
      val pop_levels : int -> unit
      Pop n levels of the theory
      val partial_check : (module Sidekick_sat__.Sigs.ACTS) -> unit
      Assume the lits in the slice, possibly using the slice to push new lits to be propagated or to raising a conflict or to add new lemmas.
      val final_check : (module Sidekick_sat__.Sigs.ACTS) -> unit
      Called at the end of the search in case a model has been found. If no new clause is pushed, then proof search ends and "sat" is returned; if lemmas are added, search is resumed; if a conflict clause is added, search backtracks and then resumes.
      
+THEORY_CDCL_T (sidekick.Sidekick_sat.THEORY_CDCL_T)
      Module type Sidekick_sat.THEORY_CDCL_T
      Signature for theories to be given to the CDCL(T) solver
      val push_level : unit -> unit
      Create a new backtrack level
      val pop_levels : int -> unit
      Pop n levels of the theory
      val partial_check : (module Sidekick_sat__.Sigs.ACTS) -> unit
      Assume the lits in the slice, possibly using the slice to push new lits to be propagated or to raising a conflict or to add new lemmas.
      val final_check : (module Sidekick_sat__.Sigs.ACTS) -> unit
      Called at the end of the search in case a model has been found. If no new clause is pushed, then proof search ends and "sat" is returned; if lemmas are added, search is resumed; if a conflict clause is added, search backtracks and then resumes.
      
diff --git a/dev/sidekick/Sidekick_sat/module-type-UNSAT_STATE/index.html b/dev/sidekick/Sidekick_sat/module-type-UNSAT_STATE/index.html
index 85b9c862..db355ab9 100644
--- a/dev/sidekick/Sidekick_sat/module-type-UNSAT_STATE/index.html
+++ b/dev/sidekick/Sidekick_sat/module-type-UNSAT_STATE/index.html
@@ -1,2 +1,2 @@
 
-UNSAT_STATE (sidekick.Sidekick_sat.UNSAT_STATE)
      Module type Sidekick_sat.UNSAT_STATE
      Solver in an "UNSATISFIABLE" state
      type clause
      val unsat_conflict : unit -> clause
      Returns the unsat clause found at the toplevel
      val unsat_assumptions : unit -> Sidekick_core.Lit.t Iter.t
      Subset of assumptions responsible for "unsat"
      val unsat_proof : unit -> Sidekick_proof.Step.id
      
+UNSAT_STATE (sidekick.Sidekick_sat.UNSAT_STATE)
      Module type Sidekick_sat.UNSAT_STATE
      Solver in an "UNSATISFIABLE" state
      type clause
      val unsat_conflict : unit -> clause
      Returns the unsat clause found at the toplevel
      val unsat_assumptions : unit -> Sidekick_core.Lit.t Iter.t
      Subset of assumptions responsible for "unsat"
      val unsat_proof : unit -> Sidekick_proof.Step.id
      
diff --git a/dev/sidekick/Sidekick_sigs/index.html b/dev/sidekick/Sidekick_sigs/index.html
index 0db5b942..746bb376 100644
--- a/dev/sidekick/Sidekick_sigs/index.html
+++ b/dev/sidekick/Sidekick_sigs/index.html
@@ -1,2 +1,2 @@
 
-Sidekick_sigs (sidekick.Sidekick_sigs)
      Module Sidekick_sigs
      module type EQ = sig ... end
      module type ORD = sig ... end
      module type HASH = sig ... end
      type 'a printer = Stdlib.Format.formatter -> 'a -> unit
      module type PRINT = sig ... end
      module type EQ_HASH_PRINT = sig ... end
      module type EQ_ORD_HASH_PRINT = sig ... end
      module type EQ_ORD_HASH = sig ... end
      module type DYN_BACKTRACKABLE = sig ... end
      module type BACKTRACKABLE0 = sig ... end
      module type BACKTRACKABLE1 = sig ... end
      module type BACKTRACKABLE1_CB = sig ... end
      module type WITH_SET_MAP_TBL = sig ... end
      module type WITH_WEAK = sig ... end
      
+Sidekick_sigs (sidekick.Sidekick_sigs)
      Module Sidekick_sigs
      module type EQ = sig ... end
      module type ORD = sig ... end
      module type HASH = sig ... end
      type 'a printer = Stdlib.Format.formatter -> 'a -> unit
      module type PRINT = sig ... end
      module type EQ_HASH_PRINT = sig ... end
      module type EQ_ORD_HASH_PRINT = sig ... end
      module type EQ_ORD_HASH = sig ... end
      module type DYN_BACKTRACKABLE = sig ... end
      module type BACKTRACKABLE0 = sig ... end
      module type BACKTRACKABLE1 = sig ... end
      module type BACKTRACKABLE1_CB = sig ... end
      module type WITH_SET_MAP_TBL = sig ... end
      module type WITH_WEAK = sig ... end
      
diff --git a/dev/sidekick/Sidekick_sigs/module-type-BACKTRACKABLE0/index.html b/dev/sidekick/Sidekick_sigs/module-type-BACKTRACKABLE0/index.html
index baff22f3..c613c396 100644
--- a/dev/sidekick/Sidekick_sigs/module-type-BACKTRACKABLE0/index.html
+++ b/dev/sidekick/Sidekick_sigs/module-type-BACKTRACKABLE0/index.html
@@ -1,2 +1,2 @@
 
-BACKTRACKABLE0 (sidekick.Sidekick_sigs.BACKTRACKABLE0)
      Module type Sidekick_sigs.BACKTRACKABLE0
      type t
      val n_levels : t -> int
      Number of levels
      val push_level : t -> unit
      Push a backtracking point
      val pop_levels : t -> int -> unit
      pop_levels st n removes n levels
      
+BACKTRACKABLE0 (sidekick.Sidekick_sigs.BACKTRACKABLE0)
      Module type Sidekick_sigs.BACKTRACKABLE0
      type t
      val n_levels : t -> int
      Number of levels
      val push_level : t -> unit
      Push a backtracking point
      val pop_levels : t -> int -> unit
      pop_levels st n removes n levels
      
diff --git a/dev/sidekick/Sidekick_sigs/module-type-BACKTRACKABLE1/index.html b/dev/sidekick/Sidekick_sigs/module-type-BACKTRACKABLE1/index.html
index 0978d04d..04d1dec9 100644
--- a/dev/sidekick/Sidekick_sigs/module-type-BACKTRACKABLE1/index.html
+++ b/dev/sidekick/Sidekick_sigs/module-type-BACKTRACKABLE1/index.html
@@ -1,2 +1,2 @@
 
-BACKTRACKABLE1 (sidekick.Sidekick_sigs.BACKTRACKABLE1)
      Module type Sidekick_sigs.BACKTRACKABLE1
      type 'a t
      val n_levels : _ t -> int
      Number of levels
      val push_level : _ t -> unit
      Push a backtracking point
      val pop_levels : _ t -> int -> unit
      pop_levels st n removes n levels
      
+BACKTRACKABLE1 (sidekick.Sidekick_sigs.BACKTRACKABLE1)
      Module type Sidekick_sigs.BACKTRACKABLE1
      type 'a t
      val n_levels : _ t -> int
      Number of levels
      val push_level : _ t -> unit
      Push a backtracking point
      val pop_levels : _ t -> int -> unit
      pop_levels st n removes n levels
      
diff --git a/dev/sidekick/Sidekick_sigs/module-type-BACKTRACKABLE1_CB/index.html b/dev/sidekick/Sidekick_sigs/module-type-BACKTRACKABLE1_CB/index.html
index 0d09a9ba..5b1c422d 100644
--- a/dev/sidekick/Sidekick_sigs/module-type-BACKTRACKABLE1_CB/index.html
+++ b/dev/sidekick/Sidekick_sigs/module-type-BACKTRACKABLE1_CB/index.html
@@ -1,2 +1,2 @@
 
-BACKTRACKABLE1_CB (sidekick.Sidekick_sigs.BACKTRACKABLE1_CB)
      Module type Sidekick_sigs.BACKTRACKABLE1_CB
      include BACKTRACKABLE1
      type 'a t
      val n_levels : _ t -> int
      Number of levels
      val push_level : _ t -> unit
      Push a backtracking point
      val pop_levels : 'a t -> int -> f:('a -> unit) -> unit
      pop_levels st n ~f removes n levels, calling f on every removed item
      
+BACKTRACKABLE1_CB (sidekick.Sidekick_sigs.BACKTRACKABLE1_CB)
      Module type Sidekick_sigs.BACKTRACKABLE1_CB
      include BACKTRACKABLE1
      type 'a t
      val n_levels : _ t -> int
      Number of levels
      val push_level : _ t -> unit
      Push a backtracking point
      val pop_levels : 'a t -> int -> f:('a -> unit) -> unit
      pop_levels st n ~f removes n levels, calling f on every removed item
      
diff --git a/dev/sidekick/Sidekick_sigs/module-type-DYN_BACKTRACKABLE/index.html b/dev/sidekick/Sidekick_sigs/module-type-DYN_BACKTRACKABLE/index.html
index 12386bfc..5dbdb520 100644
--- a/dev/sidekick/Sidekick_sigs/module-type-DYN_BACKTRACKABLE/index.html
+++ b/dev/sidekick/Sidekick_sigs/module-type-DYN_BACKTRACKABLE/index.html
@@ -1,2 +1,2 @@
 
-DYN_BACKTRACKABLE (sidekick.Sidekick_sigs.DYN_BACKTRACKABLE)
      Module type Sidekick_sigs.DYN_BACKTRACKABLE
      val n_levels : unit -> int
      Number of levels
      val push_level : unit -> unit
      Push a backtracking point
      val pop_levels : int -> unit
      pop_levels n removes n levels
      
+DYN_BACKTRACKABLE (sidekick.Sidekick_sigs.DYN_BACKTRACKABLE)
      Module type Sidekick_sigs.DYN_BACKTRACKABLE
      val n_levels : unit -> int
      Number of levels
      val push_level : unit -> unit
      Push a backtracking point
      val pop_levels : int -> unit
      pop_levels n removes n levels
      
diff --git a/dev/sidekick/Sidekick_sigs/module-type-EQ/index.html b/dev/sidekick/Sidekick_sigs/module-type-EQ/index.html
index ba47d66d..13c6928d 100644
--- a/dev/sidekick/Sidekick_sigs/module-type-EQ/index.html
+++ b/dev/sidekick/Sidekick_sigs/module-type-EQ/index.html
@@ -1,2 +1,2 @@
 
-EQ (sidekick.Sidekick_sigs.EQ)
      Module type Sidekick_sigs.EQ
      type t
      val equal : t -> t -> bool
      
+EQ (sidekick.Sidekick_sigs.EQ)
      Module type Sidekick_sigs.EQ
      type t
      val equal : t -> t -> bool
      
diff --git a/dev/sidekick/Sidekick_sigs/module-type-EQ_HASH_PRINT/index.html b/dev/sidekick/Sidekick_sigs/module-type-EQ_HASH_PRINT/index.html
index d134e905..74625444 100644
--- a/dev/sidekick/Sidekick_sigs/module-type-EQ_HASH_PRINT/index.html
+++ b/dev/sidekick/Sidekick_sigs/module-type-EQ_HASH_PRINT/index.html
@@ -1,2 +1,2 @@
 
-EQ_HASH_PRINT (sidekick.Sidekick_sigs.EQ_HASH_PRINT)
      Module type Sidekick_sigs.EQ_HASH_PRINT
      include EQ
      type t
      val equal : t -> t -> bool
      include HASH with type t := t
      val hash : t -> int
      include PRINT with type t := t
      val pp : t printer
      
+EQ_HASH_PRINT (sidekick.Sidekick_sigs.EQ_HASH_PRINT)
      Module type Sidekick_sigs.EQ_HASH_PRINT
      include EQ
      type t
      val equal : t -> t -> bool
      include HASH with type t := t
      val hash : t -> int
      include PRINT with type t := t
      val pp : t printer
      
diff --git a/dev/sidekick/Sidekick_sigs/module-type-EQ_ORD_HASH/index.html b/dev/sidekick/Sidekick_sigs/module-type-EQ_ORD_HASH/index.html
index 7f39bf39..3616ccbc 100644
--- a/dev/sidekick/Sidekick_sigs/module-type-EQ_ORD_HASH/index.html
+++ b/dev/sidekick/Sidekick_sigs/module-type-EQ_ORD_HASH/index.html
@@ -1,2 +1,2 @@
 
-EQ_ORD_HASH (sidekick.Sidekick_sigs.EQ_ORD_HASH)
      Module type Sidekick_sigs.EQ_ORD_HASH
      include EQ
      type t
      val equal : t -> t -> bool
      include ORD with type t := t
      val compare : t -> t -> int
      include HASH with type t := t
      val hash : t -> int
      
+EQ_ORD_HASH (sidekick.Sidekick_sigs.EQ_ORD_HASH)
      Module type Sidekick_sigs.EQ_ORD_HASH
      include EQ
      type t
      val equal : t -> t -> bool
      include ORD with type t := t
      val compare : t -> t -> int
      include HASH with type t := t
      val hash : t -> int
      
diff --git a/dev/sidekick/Sidekick_sigs/module-type-EQ_ORD_HASH_PRINT/index.html b/dev/sidekick/Sidekick_sigs/module-type-EQ_ORD_HASH_PRINT/index.html
index 24fccf30..75c847aa 100644
--- a/dev/sidekick/Sidekick_sigs/module-type-EQ_ORD_HASH_PRINT/index.html
+++ b/dev/sidekick/Sidekick_sigs/module-type-EQ_ORD_HASH_PRINT/index.html
@@ -1,2 +1,2 @@
 
-EQ_ORD_HASH_PRINT (sidekick.Sidekick_sigs.EQ_ORD_HASH_PRINT)
      Module type Sidekick_sigs.EQ_ORD_HASH_PRINT
      include EQ
      type t
      val equal : t -> t -> bool
      include ORD with type t := t
      val compare : t -> t -> int
      include HASH with type t := t
      val hash : t -> int
      include PRINT with type t := t
      val pp : t printer
      
+EQ_ORD_HASH_PRINT (sidekick.Sidekick_sigs.EQ_ORD_HASH_PRINT)
      Module type Sidekick_sigs.EQ_ORD_HASH_PRINT
      include EQ
      type t
      val equal : t -> t -> bool
      include ORD with type t := t
      val compare : t -> t -> int
      include HASH with type t := t
      val hash : t -> int
      include PRINT with type t := t
      val pp : t printer
      
diff --git a/dev/sidekick/Sidekick_sigs/module-type-HASH/index.html b/dev/sidekick/Sidekick_sigs/module-type-HASH/index.html
index 824fe530..ec260c70 100644
--- a/dev/sidekick/Sidekick_sigs/module-type-HASH/index.html
+++ b/dev/sidekick/Sidekick_sigs/module-type-HASH/index.html
@@ -1,2 +1,2 @@
 
-HASH (sidekick.Sidekick_sigs.HASH)
      Module type Sidekick_sigs.HASH
      type t
      val hash : t -> int
      
+HASH (sidekick.Sidekick_sigs.HASH)
      Module type Sidekick_sigs.HASH
      type t
      val hash : t -> int
      
diff --git a/dev/sidekick/Sidekick_sigs/module-type-ORD/index.html b/dev/sidekick/Sidekick_sigs/module-type-ORD/index.html
index 1cc7d569..e28c25d5 100644
--- a/dev/sidekick/Sidekick_sigs/module-type-ORD/index.html
+++ b/dev/sidekick/Sidekick_sigs/module-type-ORD/index.html
@@ -1,2 +1,2 @@
 
-ORD (sidekick.Sidekick_sigs.ORD)
      Module type Sidekick_sigs.ORD
      type t
      val compare : t -> t -> int
      
+ORD (sidekick.Sidekick_sigs.ORD)
      Module type Sidekick_sigs.ORD
      type t
      val compare : t -> t -> int
      
diff --git a/dev/sidekick/Sidekick_sigs/module-type-PRINT/index.html b/dev/sidekick/Sidekick_sigs/module-type-PRINT/index.html
index ff02c457..4d423d21 100644
--- a/dev/sidekick/Sidekick_sigs/module-type-PRINT/index.html
+++ b/dev/sidekick/Sidekick_sigs/module-type-PRINT/index.html
@@ -1,2 +1,2 @@
 
-PRINT (sidekick.Sidekick_sigs.PRINT)
      Module type Sidekick_sigs.PRINT
      type t
      val pp : t printer
      
+PRINT (sidekick.Sidekick_sigs.PRINT)
      Module type Sidekick_sigs.PRINT
      type t
      val pp : t printer
      
diff --git a/dev/sidekick/Sidekick_sigs/module-type-WITH_SET_MAP_TBL/index.html b/dev/sidekick/Sidekick_sigs/module-type-WITH_SET_MAP_TBL/index.html
index d866581e..019a34eb 100644
--- a/dev/sidekick/Sidekick_sigs/module-type-WITH_SET_MAP_TBL/index.html
+++ b/dev/sidekick/Sidekick_sigs/module-type-WITH_SET_MAP_TBL/index.html
@@ -1,2 +1,2 @@
 
-WITH_SET_MAP_TBL (sidekick.Sidekick_sigs.WITH_SET_MAP_TBL)
      Module type Sidekick_sigs.WITH_SET_MAP_TBL
      type t
      module Set : CCSet.S with type elt = t
      module Map : CCMap.S with type key = t
      module Tbl : CCHashtbl.S with type key = t
      
+WITH_SET_MAP_TBL (sidekick.Sidekick_sigs.WITH_SET_MAP_TBL)
      Module type Sidekick_sigs.WITH_SET_MAP_TBL
      type t
      module Set : CCSet.S with type elt = t
      module Map : CCMap.S with type key = t
      module Tbl : CCHashtbl.S with type key = t
      
diff --git a/dev/sidekick/Sidekick_sigs/module-type-WITH_WEAK/index.html b/dev/sidekick/Sidekick_sigs/module-type-WITH_WEAK/index.html
index 821edc6c..c5e0c0b5 100644
--- a/dev/sidekick/Sidekick_sigs/module-type-WITH_WEAK/index.html
+++ b/dev/sidekick/Sidekick_sigs/module-type-WITH_WEAK/index.html
@@ -1,2 +1,2 @@
 
-WITH_WEAK (sidekick.Sidekick_sigs.WITH_WEAK)
      Module type Sidekick_sigs.WITH_WEAK
      type t
      module Weak_set : Stdlib.Weak.S with type data = t
      module Weak_map : Stdlib.Ephemeron.S with type key = t
      
+WITH_WEAK (sidekick.Sidekick_sigs.WITH_WEAK)
      Module type Sidekick_sigs.WITH_WEAK
      type t
      module Weak_set : Stdlib.Weak.S with type data = t
      module Weak_map : Stdlib.Ephemeron.S with type key = t
      
diff --git a/dev/sidekick/Sidekick_simplex/Binary_op/index.html b/dev/sidekick/Sidekick_simplex/Binary_op/index.html
index f16a4bbc..9072ea0b 100644
--- a/dev/sidekick/Sidekick_simplex/Binary_op/index.html
+++ b/dev/sidekick/Sidekick_simplex/Binary_op/index.html
@@ -1,2 +1,2 @@
 
-Binary_op (sidekick.Sidekick_simplex.Binary_op)
      Module Sidekick_simplex.Binary_op
      type t = 
      1. | Plus
      2. | Minus
      val to_string : t -> string
      
+Binary_op (sidekick.Sidekick_simplex.Binary_op)
      Module Sidekick_simplex.Binary_op
      type t = 
      1. | Plus
      2. | Minus
      val to_string : t -> string
      
diff --git a/dev/sidekick/Sidekick_simplex/Linear_expr/Make/Comb/Infix/index.html b/dev/sidekick/Sidekick_simplex/Linear_expr/Make/Comb/Infix/index.html
index 8c03312e..bf00ed1e 100644
--- a/dev/sidekick/Sidekick_simplex/Linear_expr/Make/Comb/Infix/index.html
+++ b/dev/sidekick/Sidekick_simplex/Linear_expr/Make/Comb/Infix/index.html
@@ -1,2 +1,2 @@
 
-Infix (sidekick.Sidekick_simplex.Linear_expr.Make.Comb.Infix)
      Module Comb.Infix
      Infix operations on combinations
      This module defines usual operations on linear combinations, as infix operators to ease reading of complex computations.
      val (+) : t -> t -> t
      Addition between combinations.
      val (-) : t -> t -> t
      Substraction between combinations.
      val (*) : C.t -> t -> t
      Multiplication by a constant.
      
+Infix (sidekick.Sidekick_simplex.Linear_expr.Make.Comb.Infix)
      Module Comb.Infix
      Infix operations on combinations
      This module defines usual operations on linear combinations, as infix operators to ease reading of complex computations.
      val (+) : t -> t -> t
      Addition between combinations.
      val (-) : t -> t -> t
      Substraction between combinations.
      val (*) : C.t -> t -> t
      Multiplication by a constant.
      
diff --git a/dev/sidekick/Sidekick_simplex/Linear_expr/Make/Comb/index.html b/dev/sidekick/Sidekick_simplex/Linear_expr/Make/Comb/index.html
index 919354eb..104a0769 100644
--- a/dev/sidekick/Sidekick_simplex/Linear_expr/Make/Comb/index.html
+++ b/dev/sidekick/Sidekick_simplex/Linear_expr/Make/Comb/index.html
@@ -1,2 +1,2 @@
 
-Comb (sidekick.Sidekick_simplex.Linear_expr.Make.Comb)
      Module Make.Comb
      Combinations.
      This module defines linear combnations as mapping from variables to coefficients. This allows for very fast computations.
      type t
      The type of linear combinations.
      val compare : t -> t -> int
      Comparisons on linear combinations.
      val pp : t Sidekick_util.Fmt.printer
      Printer for linear combinations.
      val is_empty : t -> bool
      Is the given expression empty ?
      Creation
      val empty : t
      The empty linear combination.
      val monomial : C.t -> var -> t
      monome n v creates the linear combination n * v
      val monomial1 : var -> t
      monome1 v creates the linear combination 1 * v
      val as_singleton : t -> (C.t * var) option
      as_singleton l returns Some (c,x) if l = c * x, None otherwise
      val add : C.t -> var -> t -> t
      add n v t adds the monome n * v to the combination t.
      val map : f:(var -> var) -> t -> t
      module Infix : sig ... end
      Infix operations on combinations
      Include the previous module.
      include module type of Infix
      Infix operations on combinations
      This module defines usual operations on linear combinations, as infix operators to ease reading of complex computations.
      val (+) : t -> t -> t
      Addition between combinations.
      val (-) : t -> t -> t
      Substraction between combinations.
      val (*) : C.t -> t -> t
      Multiplication by a constant.
      val iter : (var -> C.t -> unit) -> t -> unit
      val of_list : (C.t * var) list -> t
      val to_list : t -> (C.t * var) list
      Converters to and from lists of monomes.
      val of_map : C.t Var_map.t -> t
      val to_map : t -> C.t Var_map.t
      Semantics
      val eval : subst -> t -> C.t
      Evaluate a linear combination given a substitution for its variables. TODO: document potential exceptions raised ?
      
+Comb (sidekick.Sidekick_simplex.Linear_expr.Make.Comb)
      Module Make.Comb
      Combinations.
      This module defines linear combnations as mapping from variables to coefficients. This allows for very fast computations.
      type t
      The type of linear combinations.
      val compare : t -> t -> int
      Comparisons on linear combinations.
      val pp : t Sidekick_util.Fmt.printer
      Printer for linear combinations.
      val is_empty : t -> bool
      Is the given expression empty ?
      Creation
      val empty : t
      The empty linear combination.
      val monomial : C.t -> var -> t
      monome n v creates the linear combination n * v
      val monomial1 : var -> t
      monome1 v creates the linear combination 1 * v
      val as_singleton : t -> (C.t * var) option
      as_singleton l returns Some (c,x) if l = c * x, None otherwise
      val add : C.t -> var -> t -> t
      add n v t adds the monome n * v to the combination t.
      val map : f:(var -> var) -> t -> t
      module Infix : sig ... end
      Infix operations on combinations
      Include the previous module.
      include module type of Infix
      Infix operations on combinations
      This module defines usual operations on linear combinations, as infix operators to ease reading of complex computations.
      val (+) : t -> t -> t
      Addition between combinations.
      val (-) : t -> t -> t
      Substraction between combinations.
      val (*) : C.t -> t -> t
      Multiplication by a constant.
      val iter : (var -> C.t -> unit) -> t -> unit
      val of_list : (C.t * var) list -> t
      val to_list : t -> (C.t * var) list
      Converters to and from lists of monomes.
      val of_map : C.t Var_map.t -> t
      val to_map : t -> C.t Var_map.t
      Semantics
      val eval : subst -> t -> C.t
      Evaluate a linear combination given a substitution for its variables. TODO: document potential exceptions raised ?
      
diff --git a/dev/sidekick/Sidekick_simplex/Linear_expr/Make/Constr/index.html b/dev/sidekick/Sidekick_simplex/Linear_expr/Make/Constr/index.html
index 40e8e843..2d77cdfa 100644
--- a/dev/sidekick/Sidekick_simplex/Linear_expr/Make/Constr/index.html
+++ b/dev/sidekick/Sidekick_simplex/Linear_expr/Make/Constr/index.html
@@ -1,2 +1,2 @@
 
-Constr (sidekick.Sidekick_simplex.Linear_expr.Make.Constr)
      Module Make.Constr
      Linear constraints.
      Represents constraints on linear expressions.
      Arithmetic comparison operators.
      type t = {
      1. expr : Expr.t;
      2. op : op;
      }
      Linear constraints. Expressions are implicitly compared to zero.
      val compare : t -> t -> int
      Standard comparison function.
      val pp : t Sidekick_util.Fmt.printer
      Standard printing function.
      val of_expr : Expr.t -> Linear_expr_intf.bool_op -> t
      val make : Comb.t -> Linear_expr_intf.bool_op -> C.t -> t
      Create a constraint from a linear expression/combination and a constant.
      val geq : Comb.t -> C.t -> t
      val leq : Comb.t -> C.t -> t
      val gt : Comb.t -> C.t -> t
      val lt : Comb.t -> C.t -> t
      val eq : Comb.t -> C.t -> t
      val neq : Comb.t -> C.t -> t
      val geq0 : Expr.t -> t
      val leq0 : Expr.t -> t
      val gt0 : Expr.t -> t
      val lt0 : Expr.t -> t
      val eq0 : Expr.t -> t
      val neq0 : Expr.t -> t
      val expr : t -> Expr.t
      Extract the given part from a constraint.
      Split the linear combinations from the constant
      val eval : subst -> t -> bool
      Evaluate the given constraint under a substitution.
      
+Constr (sidekick.Sidekick_simplex.Linear_expr.Make.Constr)
      Module Make.Constr
      Linear constraints.
      Represents constraints on linear expressions.
      Arithmetic comparison operators.
      type t = {
      1. expr : Expr.t;
      2. op : op;
      }
      Linear constraints. Expressions are implicitly compared to zero.
      val compare : t -> t -> int
      Standard comparison function.
      val pp : t Sidekick_util.Fmt.printer
      Standard printing function.
      val of_expr : Expr.t -> Linear_expr_intf.bool_op -> t
      val make : Comb.t -> Linear_expr_intf.bool_op -> C.t -> t
      Create a constraint from a linear expression/combination and a constant.
      val geq : Comb.t -> C.t -> t
      val leq : Comb.t -> C.t -> t
      val gt : Comb.t -> C.t -> t
      val lt : Comb.t -> C.t -> t
      val eq : Comb.t -> C.t -> t
      val neq : Comb.t -> C.t -> t
      val geq0 : Expr.t -> t
      val leq0 : Expr.t -> t
      val gt0 : Expr.t -> t
      val lt0 : Expr.t -> t
      val eq0 : Expr.t -> t
      val neq0 : Expr.t -> t
      val expr : t -> Expr.t
      Extract the given part from a constraint.
      Split the linear combinations from the constant
      val eval : subst -> t -> bool
      Evaluate the given constraint under a substitution.
      
diff --git a/dev/sidekick/Sidekick_simplex/Linear_expr/Make/Expr/Infix/index.html b/dev/sidekick/Sidekick_simplex/Linear_expr/Make/Expr/Infix/index.html
index d0d9155d..05c6fe0a 100644
--- a/dev/sidekick/Sidekick_simplex/Linear_expr/Make/Expr/Infix/index.html
+++ b/dev/sidekick/Sidekick_simplex/Linear_expr/Make/Expr/Infix/index.html
@@ -1,2 +1,2 @@
 
-Infix (sidekick.Sidekick_simplex.Linear_expr.Make.Expr.Infix)
      Module Expr.Infix
      Infix operations on expressions
      This module defines usual operations on linear expressions, as infix operators to ease reading of complex computations.
      val (+) : t -> t -> t
      Addition between expressions.
      val (-) : t -> t -> t
      Substraction between expressions.
      val (*) : C.t -> t -> t
      Multiplication by a constant.
      
+Infix (sidekick.Sidekick_simplex.Linear_expr.Make.Expr.Infix)
      Module Expr.Infix
      Infix operations on expressions
      This module defines usual operations on linear expressions, as infix operators to ease reading of complex computations.
      val (+) : t -> t -> t
      Addition between expressions.
      val (-) : t -> t -> t
      Substraction between expressions.
      val (*) : C.t -> t -> t
      Multiplication by a constant.
      
diff --git a/dev/sidekick/Sidekick_simplex/Linear_expr/Make/Expr/index.html b/dev/sidekick/Sidekick_simplex/Linear_expr/Make/Expr/index.html
index c86635f2..14ea3e21 100644
--- a/dev/sidekick/Sidekick_simplex/Linear_expr/Make/Expr/index.html
+++ b/dev/sidekick/Sidekick_simplex/Linear_expr/Make/Expr/index.html
@@ -1,2 +1,2 @@
 
-Expr (sidekick.Sidekick_simplex.Linear_expr.Make.Expr)
      Module Make.Expr
      Linear expressions represent linear arithmetic expressions as a linear combination and a constant.
      type t
      The type of linear expressions.
      val comb : t -> Comb.t
      val const : t -> C.t
      val is_zero : t -> bool
      val is_const : t -> bool
      val compare : t -> t -> int
      Standard comparison function on expressions.
      val pp : t Sidekick_util.Fmt.printer
      Standard printing function on expressions.
      val zero : t
      The expression 2.
      val of_const : C.t -> t
      The constant expression.
      val of_comb : Comb.t -> t
      Combination without constant
      val of_list : C.t -> (C.t * Var.t) list -> t
      val make : Comb.t -> C.t -> t
      make c n makes the linear expression c + n.
      val map : f:(var -> var) -> t -> t
      val monomial : C.t -> var -> t
      val monomial1 : var -> t
      module Infix : sig ... end
      Infix operations on expressions
      Include the previous module.
      include module type of Infix
      Infix operations on expressions
      This module defines usual operations on linear expressions, as infix operators to ease reading of complex computations.
      val (+) : t -> t -> t
      Addition between expressions.
      val (-) : t -> t -> t
      Substraction between expressions.
      val (*) : C.t -> t -> t
      Multiplication by a constant.
      Semantics
      val eval : subst -> t -> C.t
      Evaluate a linear expression given a substitution for its variables. TODO: document potential exceptions raised ?
      
+Expr (sidekick.Sidekick_simplex.Linear_expr.Make.Expr)
      Module Make.Expr
      Linear expressions represent linear arithmetic expressions as a linear combination and a constant.
      type t
      The type of linear expressions.
      val comb : t -> Comb.t
      val const : t -> C.t
      val is_zero : t -> bool
      val is_const : t -> bool
      val compare : t -> t -> int
      Standard comparison function on expressions.
      val pp : t Sidekick_util.Fmt.printer
      Standard printing function on expressions.
      val zero : t
      The expression 2.
      val of_const : C.t -> t
      The constant expression.
      val of_comb : Comb.t -> t
      Combination without constant
      val of_list : C.t -> (C.t * Var.t) list -> t
      val make : Comb.t -> C.t -> t
      make c n makes the linear expression c + n.
      val map : f:(var -> var) -> t -> t
      val monomial : C.t -> var -> t
      val monomial1 : var -> t
      module Infix : sig ... end
      Infix operations on expressions
      Include the previous module.
      include module type of Infix
      Infix operations on expressions
      This module defines usual operations on linear expressions, as infix operators to ease reading of complex computations.
      val (+) : t -> t -> t
      Addition between expressions.
      val (-) : t -> t -> t
      Substraction between expressions.
      val (*) : C.t -> t -> t
      Multiplication by a constant.
      Semantics
      val eval : subst -> t -> C.t
      Evaluate a linear expression given a substitution for its variables. TODO: document potential exceptions raised ?
      
diff --git a/dev/sidekick/Sidekick_simplex/Linear_expr/Make/argument-1-C/index.html b/dev/sidekick/Sidekick_simplex/Linear_expr/Make/argument-1-C/index.html
index 7d065796..4516fb64 100644
--- a/dev/sidekick/Sidekick_simplex/Linear_expr/Make/argument-1-C/index.html
+++ b/dev/sidekick/Sidekick_simplex/Linear_expr/Make/argument-1-C/index.html
@@ -1,2 +1,2 @@
 
-C (sidekick.Sidekick_simplex.Linear_expr.Make.C)
      Parameter Make.C
      type t
      val equal : t -> t -> bool
      Equality on coefficients.
      val compare : t -> t -> int
      Comparison on coefficients.
      val pp : t Sidekick_util.Fmt.printer
      Printer for coefficients.
      val zero : t
      The zero coefficient.
      val one : t
      The one coefficient (to rule them all, :p).
      val neg : t -> t
      Unary negation
      val (+) : t -> t -> t
      val (-) : t -> t -> t
      val (*) : t -> t -> t
      Standard operations on coefficients.
      
+C (sidekick.Sidekick_simplex.Linear_expr.Make.C)
      Parameter Make.C
      type t
      val equal : t -> t -> bool
      Equality on coefficients.
      val compare : t -> t -> int
      Comparison on coefficients.
      val pp : t Sidekick_util.Fmt.printer
      Printer for coefficients.
      val zero : t
      The zero coefficient.
      val one : t
      The one coefficient (to rule them all, :p).
      val neg : t -> t
      Unary negation
      val (+) : t -> t -> t
      val (-) : t -> t -> t
      val (*) : t -> t -> t
      Standard operations on coefficients.
      
diff --git a/dev/sidekick/Sidekick_simplex/Linear_expr/Make/argument-2-Var/index.html b/dev/sidekick/Sidekick_simplex/Linear_expr/Make/argument-2-Var/index.html
index 2490c45a..355b97e4 100644
--- a/dev/sidekick/Sidekick_simplex/Linear_expr/Make/argument-2-Var/index.html
+++ b/dev/sidekick/Sidekick_simplex/Linear_expr/Make/argument-2-Var/index.html
@@ -1,2 +1,2 @@
 
-Var (sidekick.Sidekick_simplex.Linear_expr.Make.Var)
      Parameter Make.Var
      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
      
+Var (sidekick.Sidekick_simplex.Linear_expr.Make.Var)
      Parameter Make.Var
      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
      
diff --git a/dev/sidekick/Sidekick_simplex/Linear_expr/Make/index.html b/dev/sidekick/Sidekick_simplex/Linear_expr/Make/index.html
index 48c3e8c8..34487f3b 100644
--- a/dev/sidekick/Sidekick_simplex/Linear_expr/Make/index.html
+++ b/dev/sidekick/Sidekick_simplex/Linear_expr/Make/index.html
@@ -1,2 +1,2 @@
 
-Make (sidekick.Sidekick_simplex.Linear_expr.Make)
      Module Linear_expr.Make
      Parameters
      module C : COEFF
      module Var : VAR
      Signature
      module C = C
      Coeficients used. Can be integers as well as rationals.
      module Var = Var
      Variables used in expressions.
      type var = Var.t
      The type of variables appearing in expressions.
      module Var_map = CCMap.Make(Var)
      Maps from variables, used for expressions as well as substitutions.
      type subst = Var.t -> C.t
      Type for substitutions.
      module Comb : sig ... end
      Combinations.
      Linear expressions.
      module Expr : sig ... end
      Linear expressions represent linear arithmetic expressions as a linear combination and a constant.
      module Constr : sig ... end
      
+Make (sidekick.Sidekick_simplex.Linear_expr.Make)
      Module Linear_expr.Make
      Parameters
      module C : COEFF
      module Var : VAR
      Signature
      module C = C
      Coeficients used. Can be integers as well as rationals.
      module Var = Var
      Variables used in expressions.
      type var = Var.t
      The type of variables appearing in expressions.
      module Var_map = CCMap.Make(Var)
      Maps from variables, used for expressions as well as substitutions.
      type subst = Var.t -> C.t
      Type for substitutions.
      module Comb : sig ... end
      Combinations.
      Linear expressions.
      module Expr : sig ... end
      Linear expressions represent linear arithmetic expressions as a linear combination and a constant.
      module Constr : sig ... end
      
diff --git a/dev/sidekick/Sidekick_simplex/Linear_expr/index.html b/dev/sidekick/Sidekick_simplex/Linear_expr/index.html
index 2ecdc678..3e94a500 100644
--- a/dev/sidekick/Sidekick_simplex/Linear_expr/index.html
+++ b/dev/sidekick/Sidekick_simplex/Linear_expr/index.html
@@ -1,5 +1,5 @@
 
-Linear_expr (sidekick.Sidekick_simplex.Linear_expr)
      Module Sidekick_simplex.Linear_expr
      Arithmetic expressions
      module type COEFF = Linear_expr_intf.COEFF
      module type VAR = Linear_expr_intf.VAR
      module type S = Linear_expr_intf.S
      type nonrec bool_op = Linear_expr_intf.bool_op = 
      1. | Leq
      2. | Geq
      3. | Lt
      4. | Gt
      5. | Eq
      6. | Neq
      module Make
+Linear_expr (sidekick.Sidekick_simplex.Linear_expr)
      Module Sidekick_simplex.Linear_expr
      Arithmetic expressions
      module type COEFF = Linear_expr_intf.COEFF
      module type VAR = Linear_expr_intf.VAR
      module type S = Linear_expr_intf.S
      type nonrec bool_op = Linear_expr_intf.bool_op = 
      1. | Leq
      2. | Geq
      3. | Lt
      4. | Gt
      5. | Eq
      6. | Neq
      module Make
   (C : COEFF)
   (Var : VAR) : 
   S with module C = C and module Var = Var and module Var_map = CCMap.Make(Var)
      
diff --git a/dev/sidekick/Sidekick_simplex/Linear_expr_intf/index.html b/dev/sidekick/Sidekick_simplex/Linear_expr_intf/index.html
index a88c9de9..6793e023 100644
--- a/dev/sidekick/Sidekick_simplex/Linear_expr_intf/index.html
+++ b/dev/sidekick/Sidekick_simplex/Linear_expr_intf/index.html
@@ -1,2 +1,2 @@
 
-Linear_expr_intf (sidekick.Sidekick_simplex.Linear_expr_intf)
      Module Sidekick_simplex.Linear_expr_intf
      Linear expressions interface
      module type COEFF = sig ... end
      module type VAR = sig ... end
      type bool_op = Predicate.t = 
      1. | Leq
      2. | Geq
      3. | Lt
      4. | Gt
      5. | Eq
      6. | Neq
      type op = Binary_op.t = 
      1. | Plus
      2. | Minus
      Linear expressions & formulas
      module type S = sig ... end
      Linear expressions & formulas.
      
+Linear_expr_intf (sidekick.Sidekick_simplex.Linear_expr_intf)
      Module Sidekick_simplex.Linear_expr_intf
      Linear expressions interface
      module type COEFF = sig ... end
      module type VAR = sig ... end
      type bool_op = Predicate.t = 
      1. | Leq
      2. | Geq
      3. | Lt
      4. | Gt
      5. | Eq
      6. | Neq
      type op = Binary_op.t = 
      1. | Plus
      2. | Minus
      Linear expressions & formulas
      module type S = sig ... end
      Linear expressions & formulas.
      
diff --git a/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-COEFF/index.html b/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-COEFF/index.html
index deecbb44..cd781165 100644
--- a/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-COEFF/index.html
+++ b/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-COEFF/index.html
@@ -1,2 +1,2 @@
 
-COEFF (sidekick.Sidekick_simplex.Linear_expr_intf.COEFF)
      Module type Linear_expr_intf.COEFF
      Coefficients
      Coefficients are used in expressions. They usually are either rationals, or integers.
      type t
      val equal : t -> t -> bool
      Equality on coefficients.
      val compare : t -> t -> int
      Comparison on coefficients.
      val pp : t Sidekick_util.Fmt.printer
      Printer for coefficients.
      val zero : t
      The zero coefficient.
      val one : t
      The one coefficient (to rule them all, :p).
      val neg : t -> t
      Unary negation
      val (+) : t -> t -> t
      val (-) : t -> t -> t
      val (*) : t -> t -> t
      Standard operations on coefficients.
      
+COEFF (sidekick.Sidekick_simplex.Linear_expr_intf.COEFF)
      Module type Linear_expr_intf.COEFF
      Coefficients
      Coefficients are used in expressions. They usually are either rationals, or integers.
      type t
      val equal : t -> t -> bool
      Equality on coefficients.
      val compare : t -> t -> int
      Comparison on coefficients.
      val pp : t Sidekick_util.Fmt.printer
      Printer for coefficients.
      val zero : t
      The zero coefficient.
      val one : t
      The one coefficient (to rule them all, :p).
      val neg : t -> t
      Unary negation
      val (+) : t -> t -> t
      val (-) : t -> t -> t
      val (*) : t -> t -> t
      Standard operations on coefficients.
      
diff --git a/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/C/index.html b/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/C/index.html
index 59e06bb6..a60b7a29 100644
--- a/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/C/index.html
+++ b/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/C/index.html
@@ -1,2 +1,2 @@
 
-C (sidekick.Sidekick_simplex.Linear_expr_intf.S.C)
      Module S.C
      Coeficients used. Can be integers as well as rationals.
      type t
      val equal : t -> t -> bool
      Equality on coefficients.
      val compare : t -> t -> int
      Comparison on coefficients.
      val pp : t Sidekick_util.Fmt.printer
      Printer for coefficients.
      val zero : t
      The zero coefficient.
      val one : t
      The one coefficient (to rule them all, :p).
      val neg : t -> t
      Unary negation
      val (+) : t -> t -> t
      val (-) : t -> t -> t
      val (*) : t -> t -> t
      Standard operations on coefficients.
      
+C (sidekick.Sidekick_simplex.Linear_expr_intf.S.C)
      Module S.C
      Coeficients used. Can be integers as well as rationals.
      type t
      val equal : t -> t -> bool
      Equality on coefficients.
      val compare : t -> t -> int
      Comparison on coefficients.
      val pp : t Sidekick_util.Fmt.printer
      Printer for coefficients.
      val zero : t
      The zero coefficient.
      val one : t
      The one coefficient (to rule them all, :p).
      val neg : t -> t
      Unary negation
      val (+) : t -> t -> t
      val (-) : t -> t -> t
      val (*) : t -> t -> t
      Standard operations on coefficients.
      
diff --git a/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/Comb/Infix/index.html b/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/Comb/Infix/index.html
index f55f8837..1e7ec42e 100644
--- a/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/Comb/Infix/index.html
+++ b/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/Comb/Infix/index.html
@@ -1,2 +1,2 @@
 
-Infix (sidekick.Sidekick_simplex.Linear_expr_intf.S.Comb.Infix)
      Module Comb.Infix
      Infix operations on combinations
      This module defines usual operations on linear combinations, as infix operators to ease reading of complex computations.
      val (+) : t -> t -> t
      Addition between combinations.
      val (-) : t -> t -> t
      Substraction between combinations.
      val (*) : C.t -> t -> t
      Multiplication by a constant.
      
+Infix (sidekick.Sidekick_simplex.Linear_expr_intf.S.Comb.Infix)
      Module Comb.Infix
      Infix operations on combinations
      This module defines usual operations on linear combinations, as infix operators to ease reading of complex computations.
      val (+) : t -> t -> t
      Addition between combinations.
      val (-) : t -> t -> t
      Substraction between combinations.
      val (*) : C.t -> t -> t
      Multiplication by a constant.
      
diff --git a/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/Comb/index.html b/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/Comb/index.html
index a7e8e3c6..2c97547d 100644
--- a/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/Comb/index.html
+++ b/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/Comb/index.html
@@ -1,2 +1,2 @@
 
-Comb (sidekick.Sidekick_simplex.Linear_expr_intf.S.Comb)
      Module S.Comb
      Combinations.
      This module defines linear combnations as mapping from variables to coefficients. This allows for very fast computations.
      type t
      The type of linear combinations.
      val compare : t -> t -> int
      Comparisons on linear combinations.
      val pp : t Sidekick_util.Fmt.printer
      Printer for linear combinations.
      val is_empty : t -> bool
      Is the given expression empty ?
      Creation
      val empty : t
      The empty linear combination.
      val monomial : C.t -> var -> t
      monome n v creates the linear combination n * v
      val monomial1 : var -> t
      monome1 v creates the linear combination 1 * v
      val as_singleton : t -> (C.t * var) option
      as_singleton l returns Some (c,x) if l = c * x, None otherwise
      val add : C.t -> var -> t -> t
      add n v t adds the monome n * v to the combination t.
      val map : f:(var -> var) -> t -> t
      module Infix : sig ... end
      Infix operations on combinations
      Include the previous module.
      include module type of Infix
      Infix operations on combinations
      This module defines usual operations on linear combinations, as infix operators to ease reading of complex computations.
      val (+) : t -> t -> t
      Addition between combinations.
      val (-) : t -> t -> t
      Substraction between combinations.
      val (*) : C.t -> t -> t
      Multiplication by a constant.
      val iter : (var -> C.t -> unit) -> t -> unit
      val of_list : (C.t * var) list -> t
      val to_list : t -> (C.t * var) list
      Converters to and from lists of monomes.
      val of_map : C.t Var_map.t -> t
      val to_map : t -> C.t Var_map.t
      Semantics
      val eval : subst -> t -> C.t
      Evaluate a linear combination given a substitution for its variables. TODO: document potential exceptions raised ?
      
+Comb (sidekick.Sidekick_simplex.Linear_expr_intf.S.Comb)
      Module S.Comb
      Combinations.
      This module defines linear combnations as mapping from variables to coefficients. This allows for very fast computations.
      type t
      The type of linear combinations.
      val compare : t -> t -> int
      Comparisons on linear combinations.
      val pp : t Sidekick_util.Fmt.printer
      Printer for linear combinations.
      val is_empty : t -> bool
      Is the given expression empty ?
      Creation
      val empty : t
      The empty linear combination.
      val monomial : C.t -> var -> t
      monome n v creates the linear combination n * v
      val monomial1 : var -> t
      monome1 v creates the linear combination 1 * v
      val as_singleton : t -> (C.t * var) option
      as_singleton l returns Some (c,x) if l = c * x, None otherwise
      val add : C.t -> var -> t -> t
      add n v t adds the monome n * v to the combination t.
      val map : f:(var -> var) -> t -> t
      module Infix : sig ... end
      Infix operations on combinations
      Include the previous module.
      include module type of Infix
      Infix operations on combinations
      This module defines usual operations on linear combinations, as infix operators to ease reading of complex computations.
      val (+) : t -> t -> t
      Addition between combinations.
      val (-) : t -> t -> t
      Substraction between combinations.
      val (*) : C.t -> t -> t
      Multiplication by a constant.
      val iter : (var -> C.t -> unit) -> t -> unit
      val of_list : (C.t * var) list -> t
      val to_list : t -> (C.t * var) list
      Converters to and from lists of monomes.
      val of_map : C.t Var_map.t -> t
      val to_map : t -> C.t Var_map.t
      Semantics
      val eval : subst -> t -> C.t
      Evaluate a linear combination given a substitution for its variables. TODO: document potential exceptions raised ?
      
diff --git a/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/Constr/index.html b/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/Constr/index.html
index 4e47cf64..42874136 100644
--- a/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/Constr/index.html
+++ b/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/Constr/index.html
@@ -1,2 +1,2 @@
 
-Constr (sidekick.Sidekick_simplex.Linear_expr_intf.S.Constr)
      Module S.Constr
      Linear constraints.
      Represents constraints on linear expressions.
      type op = bool_op
      Arithmetic comparison operators.
      type t = {
      1. expr : Expr.t;
      2. op : op;
      }
      Linear constraints. Expressions are implicitly compared to zero.
      val compare : t -> t -> int
      Standard comparison function.
      val pp : t Sidekick_util.Fmt.printer
      Standard printing function.
      val of_expr : Expr.t -> bool_op -> t
      val make : Comb.t -> bool_op -> C.t -> t
      Create a constraint from a linear expression/combination and a constant.
      val geq : Comb.t -> C.t -> t
      val leq : Comb.t -> C.t -> t
      val gt : Comb.t -> C.t -> t
      val lt : Comb.t -> C.t -> t
      val eq : Comb.t -> C.t -> t
      val neq : Comb.t -> C.t -> t
      val geq0 : Expr.t -> t
      val leq0 : Expr.t -> t
      val gt0 : Expr.t -> t
      val lt0 : Expr.t -> t
      val eq0 : Expr.t -> t
      val neq0 : Expr.t -> t
      val op : t -> bool_op
      val expr : t -> Expr.t
      Extract the given part from a constraint.
      val split : t -> Comb.t * bool_op * C.t
      Split the linear combinations from the constant
      val eval : subst -> t -> bool
      Evaluate the given constraint under a substitution.
      
+Constr (sidekick.Sidekick_simplex.Linear_expr_intf.S.Constr)
      Module S.Constr
      Linear constraints.
      Represents constraints on linear expressions.
      type op = bool_op
      Arithmetic comparison operators.
      type t = {
      1. expr : Expr.t;
      2. op : op;
      }
      Linear constraints. Expressions are implicitly compared to zero.
      val compare : t -> t -> int
      Standard comparison function.
      val pp : t Sidekick_util.Fmt.printer
      Standard printing function.
      val of_expr : Expr.t -> bool_op -> t
      val make : Comb.t -> bool_op -> C.t -> t
      Create a constraint from a linear expression/combination and a constant.
      val geq : Comb.t -> C.t -> t
      val leq : Comb.t -> C.t -> t
      val gt : Comb.t -> C.t -> t
      val lt : Comb.t -> C.t -> t
      val eq : Comb.t -> C.t -> t
      val neq : Comb.t -> C.t -> t
      val geq0 : Expr.t -> t
      val leq0 : Expr.t -> t
      val gt0 : Expr.t -> t
      val lt0 : Expr.t -> t
      val eq0 : Expr.t -> t
      val neq0 : Expr.t -> t
      val op : t -> bool_op
      val expr : t -> Expr.t
      Extract the given part from a constraint.
      val split : t -> Comb.t * bool_op * C.t
      Split the linear combinations from the constant
      val eval : subst -> t -> bool
      Evaluate the given constraint under a substitution.
      
diff --git a/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/Expr/Infix/index.html b/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/Expr/Infix/index.html
index fba53cd5..7caff54e 100644
--- a/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/Expr/Infix/index.html
+++ b/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/Expr/Infix/index.html
@@ -1,2 +1,2 @@
 
-Infix (sidekick.Sidekick_simplex.Linear_expr_intf.S.Expr.Infix)
      Module Expr.Infix
      Infix operations on expressions
      This module defines usual operations on linear expressions, as infix operators to ease reading of complex computations.
      val (+) : t -> t -> t
      Addition between expressions.
      val (-) : t -> t -> t
      Substraction between expressions.
      val (*) : C.t -> t -> t
      Multiplication by a constant.
      
+Infix (sidekick.Sidekick_simplex.Linear_expr_intf.S.Expr.Infix)
      Module Expr.Infix
      Infix operations on expressions
      This module defines usual operations on linear expressions, as infix operators to ease reading of complex computations.
      val (+) : t -> t -> t
      Addition between expressions.
      val (-) : t -> t -> t
      Substraction between expressions.
      val (*) : C.t -> t -> t
      Multiplication by a constant.
      
diff --git a/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/Expr/index.html b/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/Expr/index.html
index bcf31f92..51704f3d 100644
--- a/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/Expr/index.html
+++ b/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/Expr/index.html
@@ -1,2 +1,2 @@
 
-Expr (sidekick.Sidekick_simplex.Linear_expr_intf.S.Expr)
      Module S.Expr
      Linear expressions represent linear arithmetic expressions as a linear combination and a constant.
      type t
      The type of linear expressions.
      val comb : t -> Comb.t
      val const : t -> C.t
      val is_zero : t -> bool
      val is_const : t -> bool
      val compare : t -> t -> int
      Standard comparison function on expressions.
      val pp : t Sidekick_util.Fmt.printer
      Standard printing function on expressions.
      val zero : t
      The expression 2.
      val of_const : C.t -> t
      The constant expression.
      val of_comb : Comb.t -> t
      Combination without constant
      val of_list : C.t -> (C.t * Var.t) list -> t
      val make : Comb.t -> C.t -> t
      make c n makes the linear expression c + n.
      val map : f:(var -> var) -> t -> t
      val monomial : C.t -> var -> t
      val monomial1 : var -> t
      module Infix : sig ... end
      Infix operations on expressions
      Include the previous module.
      include module type of Infix
      Infix operations on expressions
      This module defines usual operations on linear expressions, as infix operators to ease reading of complex computations.
      val (+) : t -> t -> t
      Addition between expressions.
      val (-) : t -> t -> t
      Substraction between expressions.
      val (*) : C.t -> t -> t
      Multiplication by a constant.
      Semantics
      val eval : subst -> t -> C.t
      Evaluate a linear expression given a substitution for its variables. TODO: document potential exceptions raised ?
      
+Expr (sidekick.Sidekick_simplex.Linear_expr_intf.S.Expr)
      Module S.Expr
      Linear expressions represent linear arithmetic expressions as a linear combination and a constant.
      type t
      The type of linear expressions.
      val comb : t -> Comb.t
      val const : t -> C.t
      val is_zero : t -> bool
      val is_const : t -> bool
      val compare : t -> t -> int
      Standard comparison function on expressions.
      val pp : t Sidekick_util.Fmt.printer
      Standard printing function on expressions.
      val zero : t
      The expression 2.
      val of_const : C.t -> t
      The constant expression.
      val of_comb : Comb.t -> t
      Combination without constant
      val of_list : C.t -> (C.t * Var.t) list -> t
      val make : Comb.t -> C.t -> t
      make c n makes the linear expression c + n.
      val map : f:(var -> var) -> t -> t
      val monomial : C.t -> var -> t
      val monomial1 : var -> t
      module Infix : sig ... end
      Infix operations on expressions
      Include the previous module.
      include module type of Infix
      Infix operations on expressions
      This module defines usual operations on linear expressions, as infix operators to ease reading of complex computations.
      val (+) : t -> t -> t
      Addition between expressions.
      val (-) : t -> t -> t
      Substraction between expressions.
      val (*) : C.t -> t -> t
      Multiplication by a constant.
      Semantics
      val eval : subst -> t -> C.t
      Evaluate a linear expression given a substitution for its variables. TODO: document potential exceptions raised ?
      
diff --git a/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/Var/index.html b/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/Var/index.html
index 335eb511..9698cc1c 100644
--- a/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/Var/index.html
+++ b/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/Var/index.html
@@ -1,2 +1,2 @@
 
-Var (sidekick.Sidekick_simplex.Linear_expr_intf.S.Var)
      Module S.Var
      Variables used in expressions.
      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
      
+Var (sidekick.Sidekick_simplex.Linear_expr_intf.S.Var)
      Module S.Var
      Variables used in expressions.
      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
      
diff --git a/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/index.html b/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/index.html
index 768bd952..71a9caae 100644
--- a/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/index.html
+++ b/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-S/index.html
@@ -1,2 +1,2 @@
 
-S (sidekick.Sidekick_simplex.Linear_expr_intf.S)
      Module type Linear_expr_intf.S
      Linear expressions & formulas.
      This modules defines linear expressions (which are linear combinations of variables), and linear constraints, where the value of a linear expressions is constrained.
      module C : COEFF
      Coeficients used. Can be integers as well as rationals.
      module Var : VAR
      Variables used in expressions.
      type var = Var.t
      The type of variables appearing in expressions.
      module Var_map : CCMap.S with type key = var
      Maps from variables, used for expressions as well as substitutions.
      type subst = Var.t -> C.t
      Type for substitutions.
      module Comb : sig ... end
      Combinations.
      Linear expressions.
      module Expr : sig ... end
      Linear expressions represent linear arithmetic expressions as a linear combination and a constant.
      module Constr : sig ... end
      
+S (sidekick.Sidekick_simplex.Linear_expr_intf.S)
      Module type Linear_expr_intf.S
      Linear expressions & formulas.
      This modules defines linear expressions (which are linear combinations of variables), and linear constraints, where the value of a linear expressions is constrained.
      module C : COEFF
      Coeficients used. Can be integers as well as rationals.
      module Var : VAR
      Variables used in expressions.
      type var = Var.t
      The type of variables appearing in expressions.
      module Var_map : CCMap.S with type key = var
      Maps from variables, used for expressions as well as substitutions.
      type subst = Var.t -> C.t
      Type for substitutions.
      module Comb : sig ... end
      Combinations.
      Linear expressions.
      module Expr : sig ... end
      Linear expressions represent linear arithmetic expressions as a linear combination and a constant.
      module Constr : sig ... end
      
diff --git a/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-VAR/index.html b/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-VAR/index.html
index 925368c7..2e7f74f2 100644
--- a/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-VAR/index.html
+++ b/dev/sidekick/Sidekick_simplex/Linear_expr_intf/module-type-VAR/index.html
@@ -1,2 +1,2 @@
 
-VAR (sidekick.Sidekick_simplex.Linear_expr_intf.VAR)
      Module type Linear_expr_intf.VAR
      Variable interface
      Standard interface for variables that are meant to be used in expressions.
      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
      
+VAR (sidekick.Sidekick_simplex.Linear_expr_intf.VAR)
      Module type Linear_expr_intf.VAR
      Variable interface
      Standard interface for variables that are meant to be used in expressions.
      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
      
diff --git a/dev/sidekick/Sidekick_simplex/Make/Constraint/index.html b/dev/sidekick/Sidekick_simplex/Make/Constraint/index.html
index c5036b28..5d667d80 100644
--- a/dev/sidekick/Sidekick_simplex/Make/Constraint/index.html
+++ b/dev/sidekick/Sidekick_simplex/Make/Constraint/index.html
@@ -1,2 +1,2 @@
 
-Constraint (sidekick.Sidekick_simplex.Make.Constraint)
      Module Make.Constraint
      type op = Op.t
      type t = {
      1. op : op;
      2. lhs : V.t;
      3. 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
      
+Constraint (sidekick.Sidekick_simplex.Make.Constraint)
      Module Make.Constraint
      type op = Op.t
      type t = {
      1. op : op;
      2. lhs : V.t;
      3. 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
      
diff --git a/dev/sidekick/Sidekick_simplex/Make/Subst/index.html b/dev/sidekick/Sidekick_simplex/Make/Subst/index.html
index 6099482f..dc0584ef 100644
--- a/dev/sidekick/Sidekick_simplex/Make/Subst/index.html
+++ b/dev/sidekick/Sidekick_simplex/Make/Subst/index.html
@@ -1,2 +1,2 @@
 
-Subst (sidekick.Sidekick_simplex.Make.Subst)
      Module Make.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
      
+Subst (sidekick.Sidekick_simplex.Make.Subst)
      Module Make.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
      
diff --git a/dev/sidekick/Sidekick_simplex/Make/Unsat_cert/index.html b/dev/sidekick/Sidekick_simplex/Make/Unsat_cert/index.html
index 8b653240..b0907025 100644
--- a/dev/sidekick/Sidekick_simplex/Make/Unsat_cert/index.html
+++ b/dev/sidekick/Sidekick_simplex/Make/Unsat_cert/index.html
@@ -1,2 +1,2 @@
 
-Unsat_cert (sidekick.Sidekick_simplex.Make.Unsat_cert)
      Module Make.Unsat_cert
      type t = unsat_cert
      val lits : t -> V.lit list
      val pp : t Sidekick_util.Fmt.printer
      
+Unsat_cert (sidekick.Sidekick_simplex.Make.Unsat_cert)
      Module Make.Unsat_cert
      type t = unsat_cert
      val lits : t -> V.lit list
      val pp : t Sidekick_util.Fmt.printer
      
diff --git a/dev/sidekick/Sidekick_simplex/Make/argument-1-Arg/Q/index.html b/dev/sidekick/Sidekick_simplex/Make/argument-1-Arg/Q/index.html
index 914ba965..122d4b97 100644
--- a/dev/sidekick/Sidekick_simplex/Make/argument-1-Arg/Q/index.html
+++ b/dev/sidekick/Sidekick_simplex/Make/argument-1-Arg/Q/index.html
@@ -1,2 +1,2 @@
 
-Q (sidekick.Sidekick_simplex.Make.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
      val to_string : t -> string
      val of_string : string -> t option
      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 (+) : 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)
      
+Q (sidekick.Sidekick_simplex.Make.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
      val to_string : t -> string
      val of_string : string -> t option
      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 (+) : 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)
      
diff --git a/dev/sidekick/Sidekick_simplex/Make/argument-1-Arg/Var/index.html b/dev/sidekick/Sidekick_simplex/Make/argument-1-Arg/Var/index.html
index c9258ef8..218680b0 100644
--- a/dev/sidekick/Sidekick_simplex/Make/argument-1-Arg/Var/index.html
+++ b/dev/sidekick/Sidekick_simplex/Make/argument-1-Arg/Var/index.html
@@ -1,2 +1,2 @@
 
-Var (sidekick.Sidekick_simplex.Make.Arg.Var)
      Module Arg.Var
      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
      
+Var (sidekick.Sidekick_simplex.Make.Arg.Var)
      Module Arg.Var
      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
      
diff --git a/dev/sidekick/Sidekick_simplex/Make/argument-1-Arg/Z/index.html b/dev/sidekick/Sidekick_simplex/Make/argument-1-Arg/Z/index.html
index 472e5f39..f0b0e7c9 100644
--- a/dev/sidekick/Sidekick_simplex/Make/argument-1-Arg/Z/index.html
+++ b/dev/sidekick/Sidekick_simplex/Make/argument-1-Arg/Z/index.html
@@ -1,2 +1,2 @@
 
-Z (sidekick.Sidekick_simplex.Make.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
      val to_string : t -> string
      val of_string : string -> t option
      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 (+) : 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
      
+Z (sidekick.Sidekick_simplex.Make.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
      val to_string : t -> string
      val of_string : string -> t option
      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 (+) : 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
      
diff --git a/dev/sidekick/Sidekick_simplex/Make/argument-1-Arg/index.html b/dev/sidekick/Sidekick_simplex/Make/argument-1-Arg/index.html
index 29680c5c..3d52c869 100644
--- a/dev/sidekick/Sidekick_simplex/Make/argument-1-Arg/index.html
+++ b/dev/sidekick/Sidekick_simplex/Make/argument-1-Arg/index.html
@@ -1,2 +1,2 @@
 
-Arg (sidekick.Sidekick_simplex.Make.Arg)
      Parameter Make.Arg
      module Z : INT
      module Q : RATIONAL with type bigint = Z.t
      module Var : VAR
      val mk_lit : Var.t -> Op.t -> Q.t -> Var.lit
      Create new literals
      
+Arg (sidekick.Sidekick_simplex.Make.Arg)
      Parameter Make.Arg
      module Z : INT
      module Q : RATIONAL with type bigint = Z.t
      module Var : VAR
      val mk_lit : Var.t -> Op.t -> Q.t -> Var.lit
      Create new literals
      
diff --git a/dev/sidekick/Sidekick_simplex/Make/index.html b/dev/sidekick/Sidekick_simplex/Make/index.html
index 6f6745b1..c825f066 100644
--- a/dev/sidekick/Sidekick_simplex/Make/index.html
+++ b/dev/sidekick/Sidekick_simplex/Make/index.html
@@ -1,5 +1,5 @@
 
-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 : 
+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 : 
   ?is_int:bool ->
   on_propagate:ev_on_propagate ->
   t ->
diff --git a/dev/sidekick/Sidekick_simplex/Op/index.html b/dev/sidekick/Sidekick_simplex/Op/index.html
index 13e001b3..a2051d5e 100644
--- a/dev/sidekick/Sidekick_simplex/Op/index.html
+++ b/dev/sidekick/Sidekick_simplex/Op/index.html
@@ -1,2 +1,2 @@
 
-Op (sidekick.Sidekick_simplex.Op)
      Module Sidekick_simplex.Op
      Simplex operator
      type t = 
      1. | Leq
      2. | Lt
      3. | Geq
      4. | Gt
      val neg_sign : t -> t
      val not_ : t -> t
      val to_string : t -> string
      val pp : Sidekick_util.Fmt.t -> t -> unit
      
+Op (sidekick.Sidekick_simplex.Op)
      Module Sidekick_simplex.Op
      Simplex operator
      type t = 
      1. | Leq
      2. | Lt
      3. | Geq
      4. | Gt
      val neg_sign : t -> t
      val not_ : t -> t
      val to_string : t -> string
      val pp : Sidekick_util.Fmt.t -> t -> unit
      
diff --git a/dev/sidekick/Sidekick_simplex/Predicate/index.html b/dev/sidekick/Sidekick_simplex/Predicate/index.html
index dbdfc8f0..482b0caa 100644
--- a/dev/sidekick/Sidekick_simplex/Predicate/index.html
+++ b/dev/sidekick/Sidekick_simplex/Predicate/index.html
@@ -1,2 +1,2 @@
 
-Predicate (sidekick.Sidekick_simplex.Predicate)
      Module Sidekick_simplex.Predicate
      type t = 
      1. | Leq
      2. | Geq
      3. | Lt
      4. | Gt
      5. | Eq
      6. | Neq
      val neg : t -> t
      val neg_sign : t -> t
      val to_string : t -> string
      val pp : Sidekick_util.Fmt.t -> t -> unit
      
+Predicate (sidekick.Sidekick_simplex.Predicate)
      Module Sidekick_simplex.Predicate
      type t = 
      1. | Leq
      2. | Geq
      3. | Lt
      4. | Gt
      5. | Eq
      6. | Neq
      val neg : t -> t
      val neg_sign : t -> t
      val to_string : t -> string
      val pp : Sidekick_util.Fmt.t -> t -> unit
      
diff --git a/dev/sidekick/Sidekick_simplex/index.html b/dev/sidekick/Sidekick_simplex/index.html
index 8cd39f4f..8a9909b0 100644
--- a/dev/sidekick/Sidekick_simplex/index.html
+++ b/dev/sidekick/Sidekick_simplex/index.html
@@ -1,4 +1,4 @@
 
-Sidekick_simplex (sidekick.Sidekick_simplex)
      Module Sidekick_simplex
      Fast Simplex for CDCL(T)
      We follow the paper "Integrating Simplex with DPLL(T )" from de Moura and Dutertre.
      module Linear_expr_intf : sig ... end
      module Linear_expr : sig ... end
      Arithmetic expressions
      module Predicate : sig ... end
      module Binary_op : sig ... end
      module type INT = Sidekick_arith.INT
      module type RATIONAL = Sidekick_arith.RATIONAL
      module type VAR = Linear_expr_intf.VAR
      module Op : sig ... end
      Simplex operator
      module type S = sig ... end
      module type ARG = sig ... end
      module Make
+Sidekick_simplex (sidekick.Sidekick_simplex)
      Module Sidekick_simplex
      Fast Simplex for CDCL(T)
      We follow the paper "Integrating Simplex with DPLL(T )" from de Moura and Dutertre.
      module Linear_expr_intf : sig ... end
      module Linear_expr : sig ... end
      Arithmetic expressions
      module Predicate : sig ... end
      module Binary_op : sig ... end
      module type INT = Sidekick_arith.INT
      module type RATIONAL = Sidekick_arith.RATIONAL
      module type VAR = Linear_expr_intf.VAR
      module Op : sig ... end
      Simplex operator
      module type S = sig ... end
      module type ARG = sig ... end
      module Make
   (Arg : ARG) : 
   S with module V = Arg.Var and module Z = Arg.Z and module Q = Arg.Q
      
diff --git a/dev/sidekick/Sidekick_simplex/module-type-ARG/Q/index.html b/dev/sidekick/Sidekick_simplex/module-type-ARG/Q/index.html
index 1a9c1f4d..7fc8567c 100644
--- a/dev/sidekick/Sidekick_simplex/module-type-ARG/Q/index.html
+++ b/dev/sidekick/Sidekick_simplex/module-type-ARG/Q/index.html
@@ -1,2 +1,2 @@
 
-Q (sidekick.Sidekick_simplex.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
      val to_string : t -> string
      val of_string : string -> t option
      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 (+) : 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)
      
+Q (sidekick.Sidekick_simplex.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
      val to_string : t -> string
      val of_string : string -> t option
      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 (+) : 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)
      
diff --git a/dev/sidekick/Sidekick_simplex/module-type-ARG/Var/index.html b/dev/sidekick/Sidekick_simplex/module-type-ARG/Var/index.html
index 63151a78..973b1c9b 100644
--- a/dev/sidekick/Sidekick_simplex/module-type-ARG/Var/index.html
+++ b/dev/sidekick/Sidekick_simplex/module-type-ARG/Var/index.html
@@ -1,2 +1,2 @@
 
-Var (sidekick.Sidekick_simplex.ARG.Var)
      Module ARG.Var
      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
      
+Var (sidekick.Sidekick_simplex.ARG.Var)
      Module ARG.Var
      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
      
diff --git a/dev/sidekick/Sidekick_simplex/module-type-ARG/Z/index.html b/dev/sidekick/Sidekick_simplex/module-type-ARG/Z/index.html
index b065643a..82cf8895 100644
--- a/dev/sidekick/Sidekick_simplex/module-type-ARG/Z/index.html
+++ b/dev/sidekick/Sidekick_simplex/module-type-ARG/Z/index.html
@@ -1,2 +1,2 @@
 
-Z (sidekick.Sidekick_simplex.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
      val to_string : t -> string
      val of_string : string -> t option
      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 (+) : 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
      
+Z (sidekick.Sidekick_simplex.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
      val to_string : t -> string
      val of_string : string -> t option
      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 (+) : 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
      
diff --git a/dev/sidekick/Sidekick_simplex/module-type-ARG/index.html b/dev/sidekick/Sidekick_simplex/module-type-ARG/index.html
index 5fae058d..51b7e0f1 100644
--- a/dev/sidekick/Sidekick_simplex/module-type-ARG/index.html
+++ b/dev/sidekick/Sidekick_simplex/module-type-ARG/index.html
@@ -1,2 +1,2 @@
 
-ARG (sidekick.Sidekick_simplex.ARG)
      Module type Sidekick_simplex.ARG
      module Z : INT
      module Q : RATIONAL with type bigint = Z.t
      module Var : VAR
      val mk_lit : Var.t -> Op.t -> Q.t -> Var.lit
      Create new literals
      
+ARG (sidekick.Sidekick_simplex.ARG)
      Module type Sidekick_simplex.ARG
      module Z : INT
      module Q : RATIONAL with type bigint = Z.t
      module Var : VAR
      val mk_lit : Var.t -> Op.t -> Q.t -> Var.lit
      Create new literals
      
diff --git a/dev/sidekick/Sidekick_simplex/module-type-S/Constraint/index.html b/dev/sidekick/Sidekick_simplex/module-type-S/Constraint/index.html
index 7f508faf..d5f680a1 100644
--- a/dev/sidekick/Sidekick_simplex/module-type-S/Constraint/index.html
+++ b/dev/sidekick/Sidekick_simplex/module-type-S/Constraint/index.html
@@ -1,2 +1,2 @@
 
-Constraint (sidekick.Sidekick_simplex.S.Constraint)
      Module S.Constraint
      type op = Op.t
      type t = {
      1. op : op;
      2. lhs : V.t;
      3. 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
      
+Constraint (sidekick.Sidekick_simplex.S.Constraint)
      Module S.Constraint
      type op = Op.t
      type t = {
      1. op : op;
      2. lhs : V.t;
      3. 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
      
diff --git a/dev/sidekick/Sidekick_simplex/module-type-S/Q/index.html b/dev/sidekick/Sidekick_simplex/module-type-S/Q/index.html
index c31f78b0..ad603715 100644
--- a/dev/sidekick/Sidekick_simplex/module-type-S/Q/index.html
+++ b/dev/sidekick/Sidekick_simplex/module-type-S/Q/index.html
@@ -1,2 +1,2 @@
 
-Q (sidekick.Sidekick_simplex.S.Q)
      Module S.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
      val to_string : t -> string
      val of_string : string -> t option
      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 (+) : 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)
      
+Q (sidekick.Sidekick_simplex.S.Q)
      Module S.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
      val to_string : t -> string
      val of_string : string -> t option
      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 (+) : 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)
      
diff --git a/dev/sidekick/Sidekick_simplex/module-type-S/Subst/index.html b/dev/sidekick/Sidekick_simplex/module-type-S/Subst/index.html
index c9ca6ecc..677d1a92 100644
--- a/dev/sidekick/Sidekick_simplex/module-type-S/Subst/index.html
+++ b/dev/sidekick/Sidekick_simplex/module-type-S/Subst/index.html
@@ -1,2 +1,2 @@
 
-Subst (sidekick.Sidekick_simplex.S.Subst)
      Module S.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
      
+Subst (sidekick.Sidekick_simplex.S.Subst)
      Module S.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
      
diff --git a/dev/sidekick/Sidekick_simplex/module-type-S/Unsat_cert/index.html b/dev/sidekick/Sidekick_simplex/module-type-S/Unsat_cert/index.html
index 80166d4f..eae94484 100644
--- a/dev/sidekick/Sidekick_simplex/module-type-S/Unsat_cert/index.html
+++ b/dev/sidekick/Sidekick_simplex/module-type-S/Unsat_cert/index.html
@@ -1,2 +1,2 @@
 
-Unsat_cert (sidekick.Sidekick_simplex.S.Unsat_cert)
      Module S.Unsat_cert
      type t = unsat_cert
      val lits : t -> V.lit list
      val pp : t Sidekick_util.Fmt.printer
      
+Unsat_cert (sidekick.Sidekick_simplex.S.Unsat_cert)
      Module S.Unsat_cert
      type t = unsat_cert
      val lits : t -> V.lit list
      val pp : t Sidekick_util.Fmt.printer
      
diff --git a/dev/sidekick/Sidekick_simplex/module-type-S/V/index.html b/dev/sidekick/Sidekick_simplex/module-type-S/V/index.html
index 1d4a58e9..6d3949f3 100644
--- a/dev/sidekick/Sidekick_simplex/module-type-S/V/index.html
+++ b/dev/sidekick/Sidekick_simplex/module-type-S/V/index.html
@@ -1,2 +1,2 @@
 
-V (sidekick.Sidekick_simplex.S.V)
      Module S.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
      
+V (sidekick.Sidekick_simplex.S.V)
      Module S.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
      
diff --git a/dev/sidekick/Sidekick_simplex/module-type-S/Z/index.html b/dev/sidekick/Sidekick_simplex/module-type-S/Z/index.html
index 636fbcbc..6dd09497 100644
--- a/dev/sidekick/Sidekick_simplex/module-type-S/Z/index.html
+++ b/dev/sidekick/Sidekick_simplex/module-type-S/Z/index.html
@@ -1,2 +1,2 @@
 
-Z (sidekick.Sidekick_simplex.S.Z)
      Module S.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
      val to_string : t -> string
      val of_string : string -> t option
      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 (+) : 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
      
+Z (sidekick.Sidekick_simplex.S.Z)
      Module S.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
      val to_string : t -> string
      val of_string : string -> t option
      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 (+) : 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
      
diff --git a/dev/sidekick/Sidekick_simplex/module-type-S/index.html b/dev/sidekick/Sidekick_simplex/module-type-S/index.html
index be4e3fa8..862aca4c 100644
--- a/dev/sidekick/Sidekick_simplex/module-type-S/index.html
+++ b/dev/sidekick/Sidekick_simplex/module-type-S/index.html
@@ -1,5 +1,5 @@
 
-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 : 
+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 : 
   ?is_int:bool ->
   on_propagate:ev_on_propagate ->
   t ->
diff --git a/dev/sidekick/Sidekick_simplify/index.html b/dev/sidekick/Sidekick_simplify/index.html
index 61434053..24406cce 100644
--- a/dev/sidekick/Sidekick_simplify/index.html
+++ b/dev/sidekick/Sidekick_simplify/index.html
@@ -1,5 +1,5 @@
 
-Sidekick_simplify (sidekick.Sidekick_simplify)
      Module Sidekick_simplify
      Term simplifier
      type t
      Create a simplifier
      val clear : t -> unit
      Reset internal cache, etc.
      val proof : t -> Sidekick_proof.Tracer.t
      Access proof
      type hook =
+Sidekick_simplify (sidekick.Sidekick_simplify)
      Module Sidekick_simplify
      Term simplifier
      type t
      Create a simplifier
      val clear : t -> unit
      Reset internal cache, etc.
      val proof : t -> Sidekick_proof.Tracer.t
      Access proof
      Given a Term.t, try to simplify it. Return None if it didn't change.
      A simple example could be a hook that takes a Term.t 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.t further, caching (so that work is not duplicated in subterms), etc.
      val add_hook : t -> hook -> unit
      val normalize : 
diff --git a/dev/sidekick/Sidekick_smt_solver/Find_foreign/index.html b/dev/sidekick/Sidekick_smt_solver/Find_foreign/index.html
index 7ea21219..af3ca2d2 100644
--- a/dev/sidekick/Sidekick_smt_solver/Find_foreign/index.html
+++ b/dev/sidekick/Sidekick_smt_solver/Find_foreign/index.html
@@ -1,2 +1,2 @@
 
-Find_foreign (sidekick.Sidekick_smt_solver.Find_foreign)
      Module Sidekick_smt_solver.Find_foreign
      Find foreign variables.
      This module is a modular discoverer of foreign variables (and boolean terms). It should run after preprocessing of terms.
      module type ACTIONS = sig ... end
      type actions = (module ACTIONS)
      type t
      type hook = actions -> is_sub:bool -> Sidekick_core.Term.t -> unit
      val create : unit -> t
      val add_hook : t -> hook -> unit
      Register a hook to detect foreign subterms
      val traverse_term : t -> actions -> Sidekick_core.Term.t -> unit
      Traverse subterms of this term to detect foreign variables and boolean subterms.
      
+Find_foreign (sidekick.Sidekick_smt_solver.Find_foreign)
      Module Sidekick_smt_solver.Find_foreign
      Find foreign variables.
      This module is a modular discoverer of foreign variables (and boolean terms). It should run after preprocessing of terms.
      module type ACTIONS = sig ... end
      type actions = (module ACTIONS)
      type t
      type hook = actions -> is_sub:bool -> Sidekick_core.Term.t -> unit
      val create : unit -> t
      val add_hook : t -> hook -> unit
      Register a hook to detect foreign subterms
      val traverse_term : t -> actions -> Sidekick_core.Term.t -> unit
      Traverse subterms of this term to detect foreign variables and boolean subterms.
      
diff --git a/dev/sidekick/Sidekick_smt_solver/Find_foreign/module-type-ACTIONS/index.html b/dev/sidekick/Sidekick_smt_solver/Find_foreign/module-type-ACTIONS/index.html
index 56d8253d..b15fe648 100644
--- a/dev/sidekick/Sidekick_smt_solver/Find_foreign/module-type-ACTIONS/index.html
+++ b/dev/sidekick/Sidekick_smt_solver/Find_foreign/module-type-ACTIONS/index.html
@@ -1,2 +1,2 @@
 
-ACTIONS (sidekick.Sidekick_smt_solver.Find_foreign.ACTIONS)
      Module type Find_foreign.ACTIONS
      val declare_need_th_combination : Sidekick_core.Term.t -> unit
      Declare that this term is a foreign variable in some other subterm.
      val add_lit_for_bool_term : ?default_pol:bool -> Sidekick_core.Term.t -> unit
      Add the (boolean) term to the SAT solver
      
+ACTIONS (sidekick.Sidekick_smt_solver.Find_foreign.ACTIONS)
      Module type Find_foreign.ACTIONS
      val declare_need_th_combination : Sidekick_core.Term.t -> unit
      Declare that this term is a foreign variable in some other subterm.
      val add_lit_for_bool_term : ?default_pol:bool -> Sidekick_core.Term.t -> unit
      Add the (boolean) term to the SAT solver
      
diff --git a/dev/sidekick/Sidekick_smt_solver/Model/index.html b/dev/sidekick/Sidekick_smt_solver/Model/index.html
index 3d6e6657..08da9d9e 100644
--- a/dev/sidekick/Sidekick_smt_solver/Model/index.html
+++ b/dev/sidekick/Sidekick_smt_solver/Model/index.html
@@ -1,2 +1,2 @@
 
-Model (sidekick.Sidekick_smt_solver.Model)
      Module Sidekick_smt_solver.Model
      SMT models.
      The solver models are partially evaluated; the frontend might ask for values for terms not explicitly present in them.
      type t = {
      1. eval : Sidekick_core.Term.t -> Sigs.value option;
      2. map : Sigs.value Sidekick_smt_solver__.Sigs.Term.Map.t;
      }
      val is_empty : t -> bool
      val eval : t -> Sidekick_core.Term.t -> Sigs.value option
      val pp : Sidekick_smt_solver__.Sigs.Fmt.t -> t -> unit
      
+Model (sidekick.Sidekick_smt_solver.Model)
      Module Sidekick_smt_solver.Model
      SMT models.
      The solver models are partially evaluated; the frontend might ask for values for terms not explicitly present in them.
      type t = {
      1. eval : Sidekick_core.Term.t -> Sigs.value option;
      2. map : Sigs.value Sidekick_smt_solver__.Sigs.Term.Map.t;
      }
      val is_empty : t -> bool
      val eval : t -> Sidekick_core.Term.t -> Sigs.value option
      val pp : Sidekick_smt_solver__.Sigs.Fmt.t -> t -> unit
      
diff --git a/dev/sidekick/Sidekick_smt_solver/Model_builder/index.html b/dev/sidekick/Sidekick_smt_solver/Model_builder/index.html
index 53fffc83..7f051679 100644
--- a/dev/sidekick/Sidekick_smt_solver/Model_builder/index.html
+++ b/dev/sidekick/Sidekick_smt_solver/Model_builder/index.html
@@ -1,5 +1,5 @@
 
-Model_builder (sidekick.Sidekick_smt_solver.Model_builder)
      Module Sidekick_smt_solver.Model_builder
      Model Builder.
      This contains a partial model, in construction. It is accessible to every theory, so they can contribute partial values.
      TODO: seen values?
      type t
      include Sidekick_sigs.PRINT with type t := t
      val create : Sidekick_core.Term.store -> t
      val mem : t -> Sidekick_core.Term.t -> bool
      val require_eval : t -> Sidekick_core.Term.t -> unit
      Require that this term gets a value, and assign it to all terms in the given class.
      val add : 
+Model_builder (sidekick.Sidekick_smt_solver.Model_builder)
      Module Sidekick_smt_solver.Model_builder
      Model Builder.
      This contains a partial model, in construction. It is accessible to every theory, so they can contribute partial values.
      TODO: seen values?
      type t
      include Sidekick_sigs.PRINT with type t := t
      val create : Sidekick_core.Term.store -> t
      val mem : t -> Sidekick_core.Term.t -> bool
      val require_eval : t -> Sidekick_core.Term.t -> unit
      Require that this term gets a value, and assign it to all terms in the given class.
      val add : 
   t ->
   ?subs:Sidekick_core.Term.t list ->
   Sidekick_core.Term.t ->
diff --git a/dev/sidekick/Sidekick_smt_solver/Preprocess/index.html b/dev/sidekick/Sidekick_smt_solver/Preprocess/index.html
index 52033ff6..8265c6fc 100644
--- a/dev/sidekick/Sidekick_smt_solver/Preprocess/index.html
+++ b/dev/sidekick/Sidekick_smt_solver/Preprocess/index.html
@@ -1,5 +1,5 @@
 
-Preprocess (sidekick.Sidekick_smt_solver.Preprocess)
      Module Sidekick_smt_solver.Preprocess
      Preprocessor
      The preprocessor turn mixed, raw literals (possibly simplified) into literals suitable for reasoning. Every literal undergoes preprocessing. Typically some clauses are also added to the solver on the side, and some subterms are found to be foreign variables.
      type t
      Preprocessor
      val create : 
+Preprocess (sidekick.Sidekick_smt_solver.Preprocess)
      Module Sidekick_smt_solver.Preprocess
      Preprocessor
      The preprocessor turn mixed, raw literals (possibly simplified) into literals suitable for reasoning. Every literal undergoes preprocessing. Typically some clauses are also added to the solver on the side, and some subterms are found to be foreign variables.
      type t
      Preprocessor
      val create : 
   ?stat:Sidekick_util.Stat.t ->
   proof:Sidekick_proof.Tracer.t ->
   cc:Sidekick_cc.CC.t ->
diff --git a/dev/sidekick/Sidekick_smt_solver/Preprocess/module-type-PREPROCESS_ACTS/index.html b/dev/sidekick/Sidekick_smt_solver/Preprocess/module-type-PREPROCESS_ACTS/index.html
index d2459da1..8ebd1a91 100644
--- a/dev/sidekick/Sidekick_smt_solver/Preprocess/module-type-PREPROCESS_ACTS/index.html
+++ b/dev/sidekick/Sidekick_smt_solver/Preprocess/module-type-PREPROCESS_ACTS/index.html
@@ -1,2 +1,2 @@
 
-PREPROCESS_ACTS (sidekick.Sidekick_smt_solver.Preprocess.PREPROCESS_ACTS)
      Module type Preprocess.PREPROCESS_ACTS
      Actions given to preprocessor hooks
      val proof_tracer : Sidekick_proof.Tracer.t
      val mk_lit : ?sign:bool -> Sigs.term -> Sigs.lit
      mk_lit t creates a new literal for a boolean term t.
      val add_clause : Sigs.lit list -> Sigs.step_id -> unit
      pushes a new clause into the SAT solver.
      val add_lit : ?default_pol:bool -> Sigs.lit -> unit
      Ensure the literal will be decided/handled by the SAT solver.
      
+PREPROCESS_ACTS (sidekick.Sidekick_smt_solver.Preprocess.PREPROCESS_ACTS)
      Module type Preprocess.PREPROCESS_ACTS
      Actions given to preprocessor hooks
      val proof_tracer : Sidekick_proof.Tracer.t
      val mk_lit : ?sign:bool -> Sigs.term -> Sigs.lit
      mk_lit t creates a new literal for a boolean term t.
      val add_clause : Sigs.lit list -> Sigs.step_id -> unit
      pushes a new clause into the SAT solver.
      val add_lit : ?default_pol:bool -> Sigs.lit -> unit
      Ensure the literal will be decided/handled by the SAT solver.
      
diff --git a/dev/sidekick/Sidekick_smt_solver/Registry/index.html b/dev/sidekick/Sidekick_smt_solver/Registry/index.html
index 880514db..bd4eb02c 100644
--- a/dev/sidekick/Sidekick_smt_solver/Registry/index.html
+++ b/dev/sidekick/Sidekick_smt_solver/Registry/index.html
@@ -1,2 +1,2 @@
 
-Registry (sidekick.Sidekick_smt_solver.Registry)
      Module Sidekick_smt_solver.Registry
      Registry to extract values
      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
      
+Registry (sidekick.Sidekick_smt_solver.Registry)
      Module Sidekick_smt_solver.Registry
      Registry to extract values
      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
      
diff --git a/dev/sidekick/Sidekick_smt_solver/Sigs/index.html b/dev/sidekick/Sidekick_smt_solver/Sigs/index.html
index 3ca6817d..5915b177 100644
--- a/dev/sidekick/Sidekick_smt_solver/Sigs/index.html
+++ b/dev/sidekick/Sidekick_smt_solver/Sigs/index.html
@@ -1,5 +1,5 @@
 
-Sigs (sidekick.Sidekick_smt_solver.Sigs)
      Module Sidekick_smt_solver.Sigs
      Signature for the main SMT solver types.
      Theories and concrete solvers rely on an environment that defines several important types:
      • sorts
      • terms (to represent logic expressions and formulas)
      • a congruence closure instance
      • a bridge to some SAT solver
      In this module we collect signatures defined elsewhere and define the module types for the main SMT solver.
      include module type of struct include Sidekick_core end
      module Fmt = Sidekick_core.Fmt
      Re-exports from core-logic
      module Const = Sidekick_core.Const
      module Str_const = Sidekick_core.Str_const
      module Term = Sidekick_core.Term
      view
      module Bool_view = Sidekick_core.Bool_view
      module CC_view = Sidekick_core.CC_view
      module Default_cc_view = Sidekick_core.Default_cc_view
      Main modules
      module Bvar = Sidekick_core.Bvar
      module Lit = Sidekick_core.Lit
      module Subst = Sidekick_core.Subst
      module Var = Sidekick_core.Var
      module Box = Sidekick_core.Box
      module Gensym = Sidekick_core.Gensym
      exception Resource_exhausted
      Const decoders for traces
      val const_decoders : 
+Sigs (sidekick.Sidekick_smt_solver.Sigs)
      Module Sidekick_smt_solver.Sigs
      Signature for the main SMT solver types.
      Theories and concrete solvers rely on an environment that defines several important types:
      • sorts
      • terms (to represent logic expressions and formulas)
      • a congruence closure instance
      • a bridge to some SAT solver
      In this module we collect signatures defined elsewhere and define the module types for the main SMT solver.
      include module type of struct include Sidekick_core end
      module Fmt = Sidekick_core.Fmt
      Re-exports from core-logic
      module Const = Sidekick_core.Const
      module Str_const = Sidekick_core.Str_const
      module Term = Sidekick_core.Term
      view
      module Bool_view = Sidekick_core.Bool_view
      module CC_view = Sidekick_core.CC_view
      module Default_cc_view = Sidekick_core.Default_cc_view
      Main modules
      module Bvar = Sidekick_core.Bvar
      module Lit = Sidekick_core.Lit
      module Subst = Sidekick_core.Subst
      module Var = Sidekick_core.Var
      module Box = Sidekick_core.Box
      module Gensym = Sidekick_core.Gensym
      exception Resource_exhausted
      Const decoders for traces
      val const_decoders : 
   (string
    * Sidekick_core_logic.Const.Ops.t
    * (Sidekick_core_logic__.Types_.term Sidekick_util.Ser_decode.t ->
diff --git a/dev/sidekick/Sidekick_smt_solver/Sigs/module-type-ARG/index.html b/dev/sidekick/Sidekick_smt_solver/Sigs/module-type-ARG/index.html
index 94142939..2df01959 100644
--- a/dev/sidekick/Sidekick_smt_solver/Sigs/module-type-ARG/index.html
+++ b/dev/sidekick/Sidekick_smt_solver/Sigs/module-type-ARG/index.html
@@ -1,2 +1,2 @@
 
-ARG (sidekick.Sidekick_smt_solver.Sigs.ARG)
      Module type Sigs.ARG
      Argument to pass to the functor Make in order to create a new Msat-based SMT solver.
      val view_as_cc : Sidekick_cc.view_as_cc
      
+ARG (sidekick.Sidekick_smt_solver.Sigs.ARG)
      Module type Sigs.ARG
      Argument to pass to the functor Make in order to create a new Msat-based SMT solver.
      val view_as_cc : Sidekick_cc.view_as_cc
      
diff --git a/dev/sidekick/Sidekick_smt_solver/Solver/index.html b/dev/sidekick/Sidekick_smt_solver/Solver/index.html
index e50807b6..3eb15184 100644
--- a/dev/sidekick/Sidekick_smt_solver/Solver/index.html
+++ b/dev/sidekick/Sidekick_smt_solver/Solver/index.html
@@ -1,5 +1,5 @@
 
-Solver (sidekick.Sidekick_smt_solver.Solver)
      Module Sidekick_smt_solver.Solver
      Main solver type, user facing.
      This is the solver a user of sidekick can see, after instantiating everything. The user can add some theories, clauses, etc. and asks the solver to check satisfiability.
      Theory implementors will mostly interact with SOLVER_INTERNAL.
      type t
      The solver's state.
      val registry : t -> Registry.t
      A solver contains a registry so that theories can share data
      type theory = Theory.t
      val mk_theory : 
+Solver (sidekick.Sidekick_smt_solver.Solver)
      Module Sidekick_smt_solver.Solver
      Main solver type, user facing.
      This is the solver a user of sidekick can see, after instantiating everything. The user can add some theories, clauses, etc. and asks the solver to check satisfiability.
      Theory implementors will mostly interact with SOLVER_INTERNAL.
      type t
      The solver's state.
      val registry : t -> Registry.t
      A solver contains a registry so that theories can share data
      type theory = Theory.t
      val mk_theory : 
   name:string ->
   create_and_setup:(id:Theory_id.t -> Solver_internal.t -> 'th) ->
   ?push_level:('th -> unit) ->
diff --git a/dev/sidekick/Sidekick_smt_solver/Solver_internal/Perform_delayed/argument-1-A/index.html b/dev/sidekick/Sidekick_smt_solver/Solver_internal/Perform_delayed/argument-1-A/index.html
index a7fd243a..67927fe7 100644
--- a/dev/sidekick/Sidekick_smt_solver/Solver_internal/Perform_delayed/argument-1-A/index.html
+++ b/dev/sidekick/Sidekick_smt_solver/Solver_internal/Perform_delayed/argument-1-A/index.html
@@ -1,5 +1,5 @@
 
-A (sidekick.Sidekick_smt_solver.Solver_internal.Perform_delayed.A)
      Parameter Perform_delayed.A
      type t
      val add_clause : 
+A (sidekick.Sidekick_smt_solver.Solver_internal.Perform_delayed.A)
      Parameter Perform_delayed.A
      type t
      val add_clause : 
   solver ->
   t ->
   keep:bool ->
diff --git a/dev/sidekick/Sidekick_smt_solver/Solver_internal/Perform_delayed/index.html b/dev/sidekick/Sidekick_smt_solver/Solver_internal/Perform_delayed/index.html
index 5ee4b1b5..734beef8 100644
--- a/dev/sidekick/Sidekick_smt_solver/Solver_internal/Perform_delayed/index.html
+++ b/dev/sidekick/Sidekick_smt_solver/Solver_internal/Perform_delayed/index.html
@@ -1,2 +1,2 @@
 
-Perform_delayed (sidekick.Sidekick_smt_solver.Solver_internal.Perform_delayed)
      Module Solver_internal.Perform_delayed
      Parameters
      module A : PERFORM_ACTS
      Signature
      val top : t -> A.t -> unit
      
+Perform_delayed (sidekick.Sidekick_smt_solver.Solver_internal.Perform_delayed)
      Module Solver_internal.Perform_delayed
      Parameters
      module A : PERFORM_ACTS
      Signature
      val top : t -> A.t -> unit
      
diff --git a/dev/sidekick/Sidekick_smt_solver/Solver_internal/index.html b/dev/sidekick/Sidekick_smt_solver/Solver_internal/index.html
index 4dd9c9c5..a8237429 100644
--- a/dev/sidekick/Sidekick_smt_solver/Solver_internal/index.html
+++ b/dev/sidekick/Sidekick_smt_solver/Solver_internal/index.html
@@ -1,5 +1,5 @@
 
-Solver_internal (sidekick.Sidekick_smt_solver.Solver_internal)
      Module Sidekick_smt_solver.Solver_internal
      A view of the solver from a theory's point of view.
      Theories should interact with the solver via this module, to assert new lemmas, propagate literals, access the congruence closure, etc.
      type t
      Main type for the SMT solver
      type solver = t
      val tst : t -> Sigs.term_store
      val stats : t -> Sidekick_util.Stat.t
      val tracer : t -> Tracer.t
      Access the tracer object
      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.
      Congruence Closure
      val cc : t -> Sidekick_cc.CC.t
      Congruence closure for this solver
      Backtracking
      include Sidekick_sigs.BACKTRACKABLE0 with type t := t
      val n_levels : t -> int
      Number of levels
      val push_level : t -> unit
      Push a backtracking point
      val pop_levels : t -> int -> unit
      pop_levels st n removes n levels
      Interface to SAT
      val to_sat_plugin : t -> (module Sidekick_sat.PLUGIN)
      Simplifiers
      type simplify_hook = Sidekick_simplify.hook
      val simplifier : t -> Sidekick_simplify.t
      val add_simplifier : t -> Sidekick_simplify.hook -> unit
      Add a simplifier hook for preprocessing.
      val simplify_t : t -> Sigs.term -> (Sigs.term * Sigs.step_id) option
      Simplify input term, returns Some u if some simplification occurred.
      val simp_t : t -> Sigs.term -> Sigs.term * Sigs.step_id 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 = Preprocess.PREPROCESS_ACTS
      type preprocess_actions = (module PREPROCESS_ACTS)
      Actions available to the preprocessor
      type preprocess_hook =
+Solver_internal (sidekick.Sidekick_smt_solver.Solver_internal)
      Module Sidekick_smt_solver.Solver_internal
      A view of the solver from a theory's point of view.
      Theories should interact with the solver via this module, to assert new lemmas, propagate literals, access the congruence closure, etc.
      type t
      Main type for the SMT solver
      type solver = t
      val tst : t -> Sigs.term_store
      val stats : t -> Sidekick_util.Stat.t
      val tracer : t -> Tracer.t
      Access the tracer object
      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.
      Congruence Closure
      val cc : t -> Sidekick_cc.CC.t
      Congruence closure for this solver
      Backtracking
      include Sidekick_sigs.BACKTRACKABLE0 with type t := t
      val n_levels : t -> int
      Number of levels
      val push_level : t -> unit
      Push a backtracking point
      val pop_levels : t -> int -> unit
      pop_levels st n removes n levels
      Interface to SAT
      val to_sat_plugin : t -> (module Sidekick_sat.PLUGIN)
      Simplifiers
      type simplify_hook = Sidekick_simplify.hook
      val simplifier : t -> Sidekick_simplify.t
      val add_simplifier : t -> Sidekick_simplify.hook -> unit
      Add a simplifier hook for preprocessing.
      val simplify_t : t -> Sigs.term -> (Sigs.term * Sigs.step_id) option
      Simplify input term, returns Some u if some simplification occurred.
      val simp_t : t -> Sigs.term -> Sigs.term * Sigs.step_id 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 = Preprocess.PREPROCESS_ACTS
      type preprocess_actions = (module PREPROCESS_ACTS)
      Actions available to the preprocessor
      type preprocess_hook =
   Preprocess.t ->
   is_sub:bool ->
   recurse:(Sigs.term -> Sigs.term) ->
diff --git a/dev/sidekick/Sidekick_smt_solver/Solver_internal/module-type-PERFORM_ACTS/index.html b/dev/sidekick/Sidekick_smt_solver/Solver_internal/module-type-PERFORM_ACTS/index.html
index 1e6a3dcb..f88a6309 100644
--- a/dev/sidekick/Sidekick_smt_solver/Solver_internal/module-type-PERFORM_ACTS/index.html
+++ b/dev/sidekick/Sidekick_smt_solver/Solver_internal/module-type-PERFORM_ACTS/index.html
@@ -1,5 +1,5 @@
 
-PERFORM_ACTS (sidekick.Sidekick_smt_solver.Solver_internal.PERFORM_ACTS)
      Module type Solver_internal.PERFORM_ACTS
      type t
      val add_clause : 
+PERFORM_ACTS (sidekick.Sidekick_smt_solver.Solver_internal.PERFORM_ACTS)
      Module type Solver_internal.PERFORM_ACTS
      type t
      val add_clause : 
   solver ->
   t ->
   keep:bool ->
diff --git a/dev/sidekick/Sidekick_smt_solver/Theory/index.html b/dev/sidekick/Sidekick_smt_solver/Theory/index.html
index 6fabf709..d51d1a17 100644
--- a/dev/sidekick/Sidekick_smt_solver/Theory/index.html
+++ b/dev/sidekick/Sidekick_smt_solver/Theory/index.html
@@ -1,5 +1,5 @@
 
-Theory (sidekick.Sidekick_smt_solver.Theory)
      Module Sidekick_smt_solver.Theory
      Signatures for theory plugins
      module type S = sig ... end
      A theory
      type t = (module S)
      A theory that can be used for this particular solver.
      type 'a p = (module S with type t = 'a)
      A theory that can be used for this particular solver, with state of type 'a.
      val name : t -> string
      Name of the theory
      val make : 
+Theory (sidekick.Sidekick_smt_solver.Theory)
      Module Sidekick_smt_solver.Theory
      Signatures for theory plugins
      module type S = sig ... end
      A theory
      type t = (module S)
      A theory that can be used for this particular solver.
      type 'a p = (module S with type t = 'a)
      A theory that can be used for this particular solver, with state of type 'a.
      val name : t -> string
      Name of the theory
      val make : 
   name:string ->
   create_and_setup:(id:Theory_id.t -> Solver_internal.t -> 'st) ->
   ?push_level:('st0 -> unit) ->
diff --git a/dev/sidekick/Sidekick_smt_solver/Theory/module-type-S/index.html b/dev/sidekick/Sidekick_smt_solver/Theory/module-type-S/index.html
index 2b876bd5..a3c52a4b 100644
--- a/dev/sidekick/Sidekick_smt_solver/Theory/module-type-S/index.html
+++ b/dev/sidekick/Sidekick_smt_solver/Theory/module-type-S/index.html
@@ -1,2 +1,2 @@
 
-S (sidekick.Sidekick_smt_solver.Theory.S)
      Module type Theory.S
      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
      val name : string
      val create_and_setup : id:Theory_id.t -> Solver_internal.t -> t
      val push_level : t -> unit
      val pop_levels : t -> int -> unit
      
+S (sidekick.Sidekick_smt_solver.Theory.S)
      Module type Theory.S
      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
      val name : string
      val create_and_setup : id:Theory_id.t -> Solver_internal.t -> t
      val push_level : t -> unit
      val pop_levels : t -> int -> unit
      
diff --git a/dev/sidekick/Sidekick_smt_solver/Theory_id/index.html b/dev/sidekick/Sidekick_smt_solver/Theory_id/index.html
index 6face3a4..ce0edd85 100644
--- a/dev/sidekick/Sidekick_smt_solver/Theory_id/index.html
+++ b/dev/sidekick/Sidekick_smt_solver/Theory_id/index.html
@@ -1,2 +1,2 @@
 
-Theory_id (sidekick.Sidekick_smt_solver.Theory_id)
      Module Sidekick_smt_solver.Theory_id
      type t = private int
      include Sidekick_sigs.EQ_ORD_HASH_PRINT with type t := 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
      type state
      val create : unit -> state
      val fresh : state -> t
      module Set : CCSet.S with type elt = t
      
+Theory_id (sidekick.Sidekick_smt_solver.Theory_id)
      Module Sidekick_smt_solver.Theory_id
      type t = private int
      include Sidekick_sigs.EQ_ORD_HASH_PRINT with type t := 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
      type state
      val create : unit -> state
      val fresh : state -> t
      module Set : CCSet.S with type elt = t
      
diff --git a/dev/sidekick/Sidekick_smt_solver/Trace_reader/index.html b/dev/sidekick/Sidekick_smt_solver/Trace_reader/index.html
index 8ed95c38..7ae5d2a2 100644
--- a/dev/sidekick/Sidekick_smt_solver/Trace_reader/index.html
+++ b/dev/sidekick/Sidekick_smt_solver/Trace_reader/index.html
@@ -1,5 +1,5 @@
 
-Trace_reader (sidekick.Sidekick_smt_solver.Trace_reader)
      Module Sidekick_smt_solver.Trace_reader
      Read trace
      module Proof = Sidekick_proof
      module Tr = Sidekick_trace
      type entry = 
      1. | Assert of Sidekick_core.Term.t
      2. | Assert_clause of {
        1. id : int;
        2. c : Sidekick_core.Lit.t list;
        3. p : Proof.Pterm.t option;
        }
      val pp_entry : entry Sidekick_core.Fmt.printer
      type t
      val create : 
+Trace_reader (sidekick.Sidekick_smt_solver.Trace_reader)
      Module Sidekick_smt_solver.Trace_reader
      Read trace
      module Proof = Sidekick_proof
      module Tr = Sidekick_trace
      type entry = 
      1. | Assert of Sidekick_core.Term.t
      2. | Assert_clause of {
        1. id : int;
        2. c : Sidekick_core.Lit.t list;
        3. p : Proof.Pterm.t option;
        }
      val pp_entry : entry Sidekick_core.Fmt.printer
      type t
      val create : 
   ?const_decoders:Sidekick_core.Const.decoders list ->
   Sidekick_core.Term.store ->
   Tr.Source.t ->
diff --git a/dev/sidekick/Sidekick_smt_solver/Tracer/class-concrete/index.html b/dev/sidekick/Sidekick_smt_solver/Tracer/class-concrete/index.html
index e1e846af..d9c41c8a 100644
--- a/dev/sidekick/Sidekick_smt_solver/Tracer/class-concrete/index.html
+++ b/dev/sidekick/Sidekick_smt_solver/Tracer/class-concrete/index.html
@@ -1,2 +1,2 @@
 
-concrete (sidekick.Sidekick_smt_solver.Tracer.concrete)
      Class Tracer.concrete
      Tracer emitting to a sink
      inherit Sidekick_core.Term.Tracer.t
      inherit Sidekick_sat.Tracer.t
      inherit Sidekick_proof.Tracer.t
      method emit_assert_term : Sidekick_core.Term.t -> Tr.Entry_id.t
      Emit an assertion
      
+concrete (sidekick.Sidekick_smt_solver.Tracer.concrete)
      Class Tracer.concrete
      Tracer emitting to a sink
      inherit Sidekick_core.Term.Tracer.t
      inherit Sidekick_sat.Tracer.t
      inherit Sidekick_proof.Tracer.t
      method emit_assert_term : Sidekick_core.Term.t -> Tr.Entry_id.t
      Emit an assertion
      
diff --git a/dev/sidekick/Sidekick_smt_solver/Tracer/class-dummy/index.html b/dev/sidekick/Sidekick_smt_solver/Tracer/class-dummy/index.html
index b200772b..cd776869 100644
--- a/dev/sidekick/Sidekick_smt_solver/Tracer/class-dummy/index.html
+++ b/dev/sidekick/Sidekick_smt_solver/Tracer/class-dummy/index.html
@@ -1,2 +1,2 @@
 
-dummy (sidekick.Sidekick_smt_solver.Tracer.dummy)
      Class Tracer.dummy
      Dummy tracer
      inherit Sidekick_core.Term.Tracer.t
      inherit Sidekick_sat.Tracer.t
      inherit Sidekick_proof.Tracer.t
      method emit_assert_term : Sidekick_core.Term.t -> Tr.Entry_id.t
      Emit an assertion
      
+dummy (sidekick.Sidekick_smt_solver.Tracer.dummy)
      Class Tracer.dummy
      Dummy tracer
      inherit Sidekick_core.Term.Tracer.t
      inherit Sidekick_sat.Tracer.t
      inherit Sidekick_proof.Tracer.t
      method emit_assert_term : Sidekick_core.Term.t -> Tr.Entry_id.t
      Emit an assertion
      
diff --git a/dev/sidekick/Sidekick_smt_solver/Tracer/class-type-t/index.html b/dev/sidekick/Sidekick_smt_solver/Tracer/class-type-t/index.html
index 240dbe9b..58bebf01 100644
--- a/dev/sidekick/Sidekick_smt_solver/Tracer/class-type-t/index.html
+++ b/dev/sidekick/Sidekick_smt_solver/Tracer/class-type-t/index.html
@@ -1,2 +1,2 @@
 
-t (sidekick.Sidekick_smt_solver.Tracer.t)
      Class type Tracer.t
      inherit Sidekick_core.Term.Tracer.t
      inherit Sidekick_sat.Tracer.t
      inherit Sidekick_proof.Tracer.t
      method emit_assert_term : Sidekick_core.Term.t -> Tr.Entry_id.t
      Emit an assertion
      
+t (sidekick.Sidekick_smt_solver.Tracer.t)
      Class type Tracer.t
      inherit Sidekick_core.Term.Tracer.t
      inherit Sidekick_sat.Tracer.t
      inherit Sidekick_proof.Tracer.t
      method emit_assert_term : Sidekick_core.Term.t -> Tr.Entry_id.t
      Emit an assertion
      
diff --git a/dev/sidekick/Sidekick_smt_solver/Tracer/index.html b/dev/sidekick/Sidekick_smt_solver/Tracer/index.html
index b19b7725..e8127f9c 100644
--- a/dev/sidekick/Sidekick_smt_solver/Tracer/index.html
+++ b/dev/sidekick/Sidekick_smt_solver/Tracer/index.html
@@ -1,5 +1,5 @@
 
-Tracer (sidekick.Sidekick_smt_solver.Tracer)
      Module Sidekick_smt_solver.Tracer
      Tracer for SMT solvers.
      The tracer is used to track clauses and terms used or deduced during proof search.
      module Tr = Sidekick_trace
      module Proof = Sidekick_proof
      class type  t = object ... end
      class dummy : t
      Dummy tracer
      class concrete : Tr.Sink.t -> t
      Tracer emitting to a sink
      val dummy : t
      val make : sink:Tr.Sink.t -> unit -> t
      val assert_term : t -> Sidekick_core.Term.t -> Tr.Entry_id.t
      val assert_term' : t -> Sidekick_core.Term.t -> unit
      val assert_clause : 
+Tracer (sidekick.Sidekick_smt_solver.Tracer)
      Module Sidekick_smt_solver.Tracer
      Tracer for SMT solvers.
      The tracer is used to track clauses and terms used or deduced during proof search.
      module Tr = Sidekick_trace
      module Proof = Sidekick_proof
      class type  t = object ... end
      class dummy : t
      Dummy tracer
      class concrete : Tr.Sink.t -> t
      Tracer emitting to a sink
      val dummy : t
      val make : sink:Tr.Sink.t -> unit -> t
      val assert_term : t -> Sidekick_core.Term.t -> Tr.Entry_id.t
      val assert_term' : t -> Sidekick_core.Term.t -> unit
      val assert_clause : 
   t ->
   id:int ->
   Sidekick_core.Lit.t Iter.t ->
diff --git a/dev/sidekick/Sidekick_smt_solver/index.html b/dev/sidekick/Sidekick_smt_solver/index.html
index 60afcfe1..fa91b3fa 100644
--- a/dev/sidekick/Sidekick_smt_solver/index.html
+++ b/dev/sidekick/Sidekick_smt_solver/index.html
@@ -1,2 +1,2 @@
 
-Sidekick_smt_solver (sidekick.Sidekick_smt_solver)
      Module Sidekick_smt_solver
      Core of the SMT solver using Sidekick_sat
      Sidekick_sat (in src/sat/) is a modular SAT solver in pure OCaml.
      This builds a SMT solver on top of it.
      module Sigs : sig ... end
      Signature for the main SMT solver types.
      module Model_builder : sig ... end
      Model Builder.
      module Registry : sig ... end
      Registry to extract values
      module Solver_internal : sig ... end
      A view of the solver from a theory's point of view.
      module Solver : sig ... end
      Main solver type, user facing.
      module Model : sig ... end
      SMT models.
      module Theory : sig ... end
      Signatures for theory plugins
      module Theory_id : sig ... end
      module Preprocess : sig ... end
      Preprocessor
      module Find_foreign : sig ... end
      Find foreign variables.
      module Tracer : sig ... end
      Tracer for SMT solvers.
      module Trace_reader : sig ... end
      Read trace
      type theory = Theory.t
      type solver = Solver.t
      
+Sidekick_smt_solver (sidekick.Sidekick_smt_solver)
      Module Sidekick_smt_solver
      Core of the SMT solver using Sidekick_sat
      Sidekick_sat (in src/sat/) is a modular SAT solver in pure OCaml.
      This builds a SMT solver on top of it.
      module Sigs : sig ... end
      Signature for the main SMT solver types.
      module Model_builder : sig ... end
      Model Builder.
      module Registry : sig ... end
      Registry to extract values
      module Solver_internal : sig ... end
      A view of the solver from a theory's point of view.
      module Solver : sig ... end
      Main solver type, user facing.
      module Model : sig ... end
      SMT models.
      module Theory : sig ... end
      Signatures for theory plugins
      module Theory_id : sig ... end
      module Preprocess : sig ... end
      Preprocessor
      module Find_foreign : sig ... end
      Find foreign variables.
      module Tracer : sig ... end
      Tracer for SMT solvers.
      module Trace_reader : sig ... end
      Read trace
      type theory = Theory.t
      type solver = Solver.t
      
diff --git a/dev/sidekick/Sidekick_th_bool_dyn/Intf/index.html b/dev/sidekick/Sidekick_th_bool_dyn/Intf/index.html
index a52aa580..c9c6c20a 100644
--- a/dev/sidekick/Sidekick_th_bool_dyn/Intf/index.html
+++ b/dev/sidekick/Sidekick_th_bool_dyn/Intf/index.html
@@ -1,2 +1,2 @@
 
-Intf (sidekick.Sidekick_th_bool_dyn.Intf)
      Module Sidekick_th_bool_dyn.Intf
      module Proof = Sidekick_proof
      module SMT = Sidekick_smt_solver
      module Simplify = Sidekick_simplify
      type 'a bool_view = 'a Sidekick_core.Bool_view.t = 
      1. | B_bool of bool
      2. | B_not of 'a
      3. | B_and of 'a list
      4. | B_or of 'a list
      5. | B_imply of 'a * 'a
      6. | B_equiv of 'a * 'a
      7. | B_xor of 'a * 'a
      8. | B_eq of 'a * 'a
      9. | B_neq of 'a * 'a
      10. | B_ite of 'a * 'a * 'a
      11. | B_atom of 'a
      Boolean-oriented view of terms
      module type ARG = sig ... end
      Argument to the theory
      
+Intf (sidekick.Sidekick_th_bool_dyn.Intf)
      Module Sidekick_th_bool_dyn.Intf
      module Proof = Sidekick_proof
      module SMT = Sidekick_smt_solver
      module Simplify = Sidekick_simplify
      type 'a bool_view = 'a Sidekick_core.Bool_view.t = 
      1. | B_bool of bool
      2. | B_not of 'a
      3. | B_and of 'a list
      4. | B_or of 'a list
      5. | B_imply of 'a * 'a
      6. | B_equiv of 'a * 'a
      7. | B_xor of 'a * 'a
      8. | B_eq of 'a * 'a
      9. | B_neq of 'a * 'a
      10. | B_ite of 'a * 'a * 'a
      11. | B_atom of 'a
      Boolean-oriented view of terms
      module type ARG = sig ... end
      Argument to the theory
      
diff --git a/dev/sidekick/Sidekick_th_bool_dyn/Intf/module-type-ARG/index.html b/dev/sidekick/Sidekick_th_bool_dyn/Intf/module-type-ARG/index.html
index 10ee399f..122a7048 100644
--- a/dev/sidekick/Sidekick_th_bool_dyn/Intf/module-type-ARG/index.html
+++ b/dev/sidekick/Sidekick_th_bool_dyn/Intf/module-type-ARG/index.html
@@ -1,2 +1,2 @@
 
-ARG (sidekick.Sidekick_th_bool_dyn.Intf.ARG)
      Module type Intf.ARG
      Argument to the theory
      val view_as_bool : term -> term bool_view
      Project the term into the boolean view.
      Make a term from the given boolean view.
      
+ARG (sidekick.Sidekick_th_bool_dyn.Intf.ARG)
      Module type Intf.ARG
      Argument to the theory
      val view_as_bool : term -> term bool_view
      Project the term into the boolean view.
      Make a term from the given boolean view.
      
diff --git a/dev/sidekick/Sidekick_th_bool_dyn/Proof_rules/index.html b/dev/sidekick/Sidekick_th_bool_dyn/Proof_rules/index.html
index 0866d605..6858b28d 100644
--- a/dev/sidekick/Sidekick_th_bool_dyn/Proof_rules/index.html
+++ b/dev/sidekick/Sidekick_th_bool_dyn/Proof_rules/index.html
@@ -1,2 +1,2 @@
 
-Proof_rules (sidekick.Sidekick_th_bool_dyn.Proof_rules)
      Module Sidekick_th_bool_dyn.Proof_rules
      module Proof = Sidekick_proof
      val lemma_bool_tauto : lit list -> Proof.Pterm.t
      Boolean tautology lemma (clause)
      val lemma_bool_c : string -> term list -> Proof.Pterm.t
      Basic boolean logic lemma for a clause |- c. proof_bool_c b name cs is the Proof.Pterm.t designated by name.
      val lemma_bool_equiv : term -> term -> Proof.Pterm.t
      Boolean tautology lemma (equivalence)
      val lemma_ite_true : ite:term -> Proof.Pterm.t
      lemma a ==> ite a b c = b
      val lemma_ite_false : ite:term -> Proof.Pterm.t
      lemma ¬a ==> ite a b c = c
      
+Proof_rules (sidekick.Sidekick_th_bool_dyn.Proof_rules)
      Module Sidekick_th_bool_dyn.Proof_rules
      module Proof = Sidekick_proof
      val lemma_bool_tauto : lit list -> Proof.Pterm.t
      Boolean tautology lemma (clause)
      val lemma_bool_c : string -> term list -> Proof.Pterm.t
      Basic boolean logic lemma for a clause |- c. proof_bool_c b name cs is the Proof.Pterm.t designated by name.
      val lemma_bool_equiv : term -> term -> Proof.Pterm.t
      Boolean tautology lemma (equivalence)
      val lemma_ite_true : ite:term -> Proof.Pterm.t
      lemma a ==> ite a b c = b
      val lemma_ite_false : ite:term -> Proof.Pterm.t
      lemma ¬a ==> ite a b c = c
      
diff --git a/dev/sidekick/Sidekick_th_bool_dyn/index.html b/dev/sidekick/Sidekick_th_bool_dyn/index.html
index f7c69870..be89f4dd 100644
--- a/dev/sidekick/Sidekick_th_bool_dyn/index.html
+++ b/dev/sidekick/Sidekick_th_bool_dyn/index.html
@@ -1,2 +1,2 @@
 
-Sidekick_th_bool_dyn (sidekick.Sidekick_th_bool_dyn)
      Module Sidekick_th_bool_dyn
      Theory of boolean formulas.
      This handles formulas containing "and", "or", "=>", "if-then-else", etc.
      The difference with Sidekick_th_bool_static is that here, clausification of a formula F is done only when F is on the trail.
      module Intf : sig ... end
      module Proof_rules : sig ... end
      module type ARG = Intf.ARG
      val theory : (module ARG) -> Intf.SMT.Theory.t
      
+Sidekick_th_bool_dyn (sidekick.Sidekick_th_bool_dyn)
      Module Sidekick_th_bool_dyn
      Theory of boolean formulas.
      This handles formulas containing "and", "or", "=>", "if-then-else", etc.
      The difference with Sidekick_th_bool_static is that here, clausification of a formula F is done only when F is on the trail.
      module Intf : sig ... end
      module Proof_rules : sig ... end
      module type ARG = Intf.ARG
      val theory : (module ARG) -> Intf.SMT.Theory.t
      
diff --git a/dev/sidekick/Sidekick_th_bool_static/Intf/index.html b/dev/sidekick/Sidekick_th_bool_static/Intf/index.html
index a7a6ba26..e08be8b8 100644
--- a/dev/sidekick/Sidekick_th_bool_static/Intf/index.html
+++ b/dev/sidekick/Sidekick_th_bool_static/Intf/index.html
@@ -1,2 +1,2 @@
 
-Intf (sidekick.Sidekick_th_bool_static.Intf)
      Module Sidekick_th_bool_static.Intf
      module Proof = Sidekick_proof
      module SMT = Sidekick_smt_solver
      module Simplify = Sidekick_simplify
      type 'a bool_view = 'a Sidekick_core.Bool_view.t = 
      1. | B_bool of bool
      2. | B_not of 'a
      3. | B_and of 'a list
      4. | B_or of 'a list
      5. | B_imply of 'a * 'a
      6. | B_equiv of 'a * 'a
      7. | B_xor of 'a * 'a
      8. | B_eq of 'a * 'a
      9. | B_neq of 'a * 'a
      10. | B_ite of 'a * 'a * 'a
      11. | B_atom of 'a
      Boolean-oriented view of terms
      module type ARG = sig ... end
      Argument to the theory
      
+Intf (sidekick.Sidekick_th_bool_static.Intf)
      Module Sidekick_th_bool_static.Intf
      module Proof = Sidekick_proof
      module SMT = Sidekick_smt_solver
      module Simplify = Sidekick_simplify
      type 'a bool_view = 'a Sidekick_core.Bool_view.t = 
      1. | B_bool of bool
      2. | B_not of 'a
      3. | B_and of 'a list
      4. | B_or of 'a list
      5. | B_imply of 'a * 'a
      6. | B_equiv of 'a * 'a
      7. | B_xor of 'a * 'a
      8. | B_eq of 'a * 'a
      9. | B_neq of 'a * 'a
      10. | B_ite of 'a * 'a * 'a
      11. | B_atom of 'a
      Boolean-oriented view of terms
      module type ARG = sig ... end
      Argument to the theory
      
diff --git a/dev/sidekick/Sidekick_th_bool_static/Intf/module-type-ARG/index.html b/dev/sidekick/Sidekick_th_bool_static/Intf/module-type-ARG/index.html
index 458f0fb7..d56addc5 100644
--- a/dev/sidekick/Sidekick_th_bool_static/Intf/module-type-ARG/index.html
+++ b/dev/sidekick/Sidekick_th_bool_static/Intf/module-type-ARG/index.html
@@ -1,2 +1,2 @@
 
-ARG (sidekick.Sidekick_th_bool_static.Intf.ARG)
      Module type Intf.ARG
      Argument to the theory
      val view_as_bool : term -> term bool_view
      Project the term into the boolean view.
      Make a term from the given boolean view.
      
+ARG (sidekick.Sidekick_th_bool_static.Intf.ARG)
      Module type Intf.ARG
      Argument to the theory
      val view_as_bool : term -> term bool_view
      Project the term into the boolean view.
      Make a term from the given boolean view.
      
diff --git a/dev/sidekick/Sidekick_th_bool_static/Proof_rules/index.html b/dev/sidekick/Sidekick_th_bool_static/Proof_rules/index.html
index 276e5c28..9a9fbb16 100644
--- a/dev/sidekick/Sidekick_th_bool_static/Proof_rules/index.html
+++ b/dev/sidekick/Sidekick_th_bool_static/Proof_rules/index.html
@@ -1,2 +1,2 @@
 
-Proof_rules (sidekick.Sidekick_th_bool_static.Proof_rules)
      Module Sidekick_th_bool_static.Proof_rules
      module Proof = Sidekick_proof
      val lemma_bool_tauto : lit list -> Proof.Pterm.t
      Boolean tautology lemma (clause)
      val lemma_bool_c : string -> term list -> Proof.Pterm.t
      Basic boolean logic lemma for a clause |- c. proof_bool_c b name cs is the Proof_term.t designated by name.
      val lemma_bool_equiv : term -> term -> Proof.Pterm.t
      Boolean tautology lemma (equivalence)
      val lemma_ite_true : ite:term -> Proof.Pterm.t
      lemma a ==> ite a b c = b
      val lemma_ite_false : ite:term -> Proof.Pterm.t
      lemma ¬a ==> ite a b c = c
      
+Proof_rules (sidekick.Sidekick_th_bool_static.Proof_rules)
      Module Sidekick_th_bool_static.Proof_rules
      module Proof = Sidekick_proof
      val lemma_bool_tauto : lit list -> Proof.Pterm.t
      Boolean tautology lemma (clause)
      val lemma_bool_c : string -> term list -> Proof.Pterm.t
      Basic boolean logic lemma for a clause |- c. proof_bool_c b name cs is the Proof_term.t designated by name.
      val lemma_bool_equiv : term -> term -> Proof.Pterm.t
      Boolean tautology lemma (equivalence)
      val lemma_ite_true : ite:term -> Proof.Pterm.t
      lemma a ==> ite a b c = b
      val lemma_ite_false : ite:term -> Proof.Pterm.t
      lemma ¬a ==> ite a b c = c
      
diff --git a/dev/sidekick/Sidekick_th_bool_static/index.html b/dev/sidekick/Sidekick_th_bool_static/index.html
index 227762c5..b7faa6d0 100644
--- a/dev/sidekick/Sidekick_th_bool_static/index.html
+++ b/dev/sidekick/Sidekick_th_bool_static/index.html
@@ -1,2 +1,2 @@
 
-Sidekick_th_bool_static (sidekick.Sidekick_th_bool_static)
      Module Sidekick_th_bool_static
      Theory of boolean formulas.
      This handles formulas containing "and", "or", "=>", "if-then-else", etc.
      module Intf : sig ... end
      module Proof_rules : sig ... end
      module type ARG = Intf.ARG
      val theory : (module ARG) -> Intf.SMT.Theory.t
      
+Sidekick_th_bool_static (sidekick.Sidekick_th_bool_static)
      Module Sidekick_th_bool_static
      Theory of boolean formulas.
      This handles formulas containing "and", "or", "=>", "if-then-else", etc.
      module Intf : sig ... end
      module Proof_rules : sig ... end
      module type ARG = Intf.ARG
      val theory : (module ARG) -> Intf.SMT.Theory.t
      
diff --git a/dev/sidekick/Sidekick_th_cstor/index.html b/dev/sidekick/Sidekick_th_cstor/index.html
index a78af586..91fbfade 100644
--- a/dev/sidekick/Sidekick_th_cstor/index.html
+++ b/dev/sidekick/Sidekick_th_cstor/index.html
@@ -1,2 +1,2 @@
 
-Sidekick_th_cstor (sidekick.Sidekick_th_cstor)
      Module Sidekick_th_cstor
      Theory for constructors
      module SMT = Sidekick_smt_solver
      type ('c, 't) cstor_view = 
      1. | T_cstor of 'c * 't array
      2. | T_other of 't
      module type ARG = sig ... end
      val make : (module ARG) -> SMT.theory
      
+Sidekick_th_cstor (sidekick.Sidekick_th_cstor)
      Module Sidekick_th_cstor
      Theory for constructors
      module SMT = Sidekick_smt_solver
      type ('c, 't) cstor_view = 
      1. | T_cstor of 'c * 't array
      2. | T_other of 't
      module type ARG = sig ... end
      val make : (module ARG) -> SMT.theory
      
diff --git a/dev/sidekick/Sidekick_th_cstor/module-type-ARG/index.html b/dev/sidekick/Sidekick_th_cstor/module-type-ARG/index.html
index 8786160f..5e5162db 100644
--- a/dev/sidekick/Sidekick_th_cstor/module-type-ARG/index.html
+++ b/dev/sidekick/Sidekick_th_cstor/module-type-ARG/index.html
@@ -1,4 +1,4 @@
 
-ARG (sidekick.Sidekick_th_cstor.ARG)
      Module type Sidekick_th_cstor.ARG
      val view_as_cstor : 
+ARG (sidekick.Sidekick_th_cstor.ARG)
      Module type Sidekick_th_cstor.ARG
      
diff --git a/dev/sidekick/Sidekick_th_data/index.html b/dev/sidekick/Sidekick_th_data/index.html
index fc772944..a5d1548c 100644
--- a/dev/sidekick/Sidekick_th_data/index.html
+++ b/dev/sidekick/Sidekick_th_data/index.html
@@ -1,2 +1,2 @@
 
-Sidekick_th_data (sidekick.Sidekick_th_data)
      Module Sidekick_th_data
      Theory for datatypes.
      module SMT = Sidekick_smt_solver
      type ('c, 't) data_view = 
      1. | T_cstor of 'c * 't list
      2. | T_select of 'c * int * 't
      3. | T_is_a of 'c * 't
      4. | T_other of 't
      Datatype-oriented view of terms.
      • 'c is the representation of constructors
      • 't is the representation of terms
      type ('c, 'ty) data_ty_view = 
      1. | Ty_arrow of 'ty list * 'ty
      2. | Ty_data of {
        1. cstors : 'c;
        }
      3. | Ty_other of {
        1. sub : 'ty list;
        }
      View of types in a way that is directly useful for the theory of datatypes
      module type DATA_TY = sig ... end
      An abtract representation of a datatype
      module type ARG = sig ... end
      val make : (module ARG) -> SMT.theory
      
+Sidekick_th_data (sidekick.Sidekick_th_data)
      Module Sidekick_th_data
      Theory for datatypes.
      module SMT = Sidekick_smt_solver
      type ('c, 't) data_view = 
      1. | T_cstor of 'c * 't list
      2. | T_select of 'c * int * 't
      3. | T_is_a of 'c * 't
      4. | T_other of 't
      Datatype-oriented view of terms.
      • 'c is the representation of constructors
      • 't is the representation of terms
      type ('c, 'ty) data_ty_view = 
      1. | Ty_arrow of 'ty list * 'ty
      2. | Ty_data of {
        1. cstors : 'c;
        }
      3. | Ty_other of {
        1. sub : 'ty list;
        }
      View of types in a way that is directly useful for the theory of datatypes
      module type DATA_TY = sig ... end
      An abtract representation of a datatype
      module type ARG = sig ... end
      val make : (module ARG) -> SMT.theory
      
diff --git a/dev/sidekick/Sidekick_th_data/module-type-ARG/Cstor/index.html b/dev/sidekick/Sidekick_th_data/module-type-ARG/Cstor/index.html
index a0508f53..5ae35da8 100644
--- a/dev/sidekick/Sidekick_th_data/module-type-ARG/Cstor/index.html
+++ b/dev/sidekick/Sidekick_th_data/module-type-ARG/Cstor/index.html
@@ -1,2 +1,2 @@
 
-Cstor (sidekick.Sidekick_th_data.ARG.Cstor)
      Module ARG.Cstor
      Constructor symbols.
      A constructor is an injective symbol, part of a datatype (or "sum type"). For example, in type option a = Some a | None, the constructors are Some and None.
      type t
      Constructor
      val ty_args : t -> ty list
      Type arguments, for a polymorphic constructor
      include Sidekick_sigs.EQ with type t := t
      val equal : t -> t -> bool
      include Sidekick_sigs.PRINT with type t := t
      
+Cstor (sidekick.Sidekick_th_data.ARG.Cstor)
      Module ARG.Cstor
      Constructor symbols.
      A constructor is an injective symbol, part of a datatype (or "sum type"). For example, in type option a = Some a | None, the constructors are Some and None.
      type t
      Constructor
      val ty_args : t -> ty list
      Type arguments, for a polymorphic constructor
      include Sidekick_sigs.EQ with type t := t
      val equal : t -> t -> bool
      include Sidekick_sigs.PRINT with type t := t
      
diff --git a/dev/sidekick/Sidekick_th_data/module-type-ARG/index.html b/dev/sidekick/Sidekick_th_data/module-type-ARG/index.html
index 3690ca0b..bc4b6569 100644
--- a/dev/sidekick/Sidekick_th_data/module-type-ARG/index.html
+++ b/dev/sidekick/Sidekick_th_data/module-type-ARG/index.html
@@ -1,5 +1,5 @@
 
-ARG (sidekick.Sidekick_th_data.ARG)
      Module type Sidekick_th_data.ARG
      module Cstor : sig ... end
      Constructor symbols.
      val as_datatype : ty -> (Cstor.t list, ty) data_ty_view
      Try to view type as a datatype (with its constructors)
      val view_as_data : 
+ARG (sidekick.Sidekick_th_data.ARG)
      Module type Sidekick_th_data.ARG
      module Cstor : sig ... end
      Constructor symbols.
      val as_datatype : ty -> (Cstor.t list, ty) data_ty_view
      Try to view type as a datatype (with its constructors)
      Try to view Term.t as a datatype Term.t
      val mk_cstor : 
   Sidekick_core.Term.store ->
diff --git a/dev/sidekick/Sidekick_th_data/module-type-DATA_TY/index.html b/dev/sidekick/Sidekick_th_data/module-type-DATA_TY/index.html
index 7797fe0c..08fc8187 100644
--- a/dev/sidekick/Sidekick_th_data/module-type-DATA_TY/index.html
+++ b/dev/sidekick/Sidekick_th_data/module-type-DATA_TY/index.html
@@ -1,2 +1,2 @@
 
-DATA_TY (sidekick.Sidekick_th_data.DATA_TY)
      Module type Sidekick_th_data.DATA_TY
      An abtract representation of a datatype
      type t
      type cstor
      val equal : t -> t -> bool
      val finite : t -> bool
      val set_finite : t -> bool -> unit
      val view : t -> (cstor, t) data_ty_view
      val cstor_args : cstor -> t list
      
+DATA_TY (sidekick.Sidekick_th_data.DATA_TY)
      Module type Sidekick_th_data.DATA_TY
      An abtract representation of a datatype
      type t
      type cstor
      val equal : t -> t -> bool
      val finite : t -> bool
      val set_finite : t -> bool -> unit
      val view : t -> (cstor, t) data_ty_view
      val cstor_args : cstor -> t list
      
diff --git a/dev/sidekick/Sidekick_th_lra/Intf/index.html b/dev/sidekick/Sidekick_th_lra/Intf/index.html
index 29ae5416..fad29bd2 100644
--- a/dev/sidekick/Sidekick_th_lra/Intf/index.html
+++ b/dev/sidekick/Sidekick_th_lra/Intf/index.html
@@ -1,2 +1,2 @@
 
-Intf (sidekick.Sidekick_th_lra.Intf)
      Module Sidekick_th_lra.Intf
      module SMT = Sidekick_smt_solver
      module Proof = Sidekick_proof
      module Predicate = Sidekick_simplex.Predicate
      module Linear_expr = Sidekick_simplex.Linear_expr
      module Linear_expr_intf = Sidekick_simplex.Linear_expr_intf
      module type INT = Sidekick_arith.INT
      module type RATIONAL = Sidekick_arith.RATIONAL
      module S_op = Sidekick_simplex.Op
      type pred = Linear_expr_intf.bool_op = 
      1. | Leq
      2. | Geq
      3. | Lt
      4. | Gt
      5. | Eq
      6. | Neq
      type op = Linear_expr_intf.op = 
      1. | Plus
      2. | Minus
      type ('num, 'a) lra_view = 
      1. | LRA_pred of pred * 'a * 'a
      2. | LRA_op of op * 'a * 'a
      3. | LRA_mult of 'num * 'a
      4. | LRA_const of 'num
      5. | LRA_other of 'a
      val map_view : ('a -> 'b) -> ('c, 'd) lra_view -> ('e, 'f) lra_view
      module type ARG = sig ... end
      
+Intf (sidekick.Sidekick_th_lra.Intf)
      Module Sidekick_th_lra.Intf
      module SMT = Sidekick_smt_solver
      module Proof = Sidekick_proof
      module Predicate = Sidekick_simplex.Predicate
      module Linear_expr = Sidekick_simplex.Linear_expr
      module Linear_expr_intf = Sidekick_simplex.Linear_expr_intf
      module type INT = Sidekick_arith.INT
      module type RATIONAL = Sidekick_arith.RATIONAL
      module S_op = Sidekick_simplex.Op
      type pred = Linear_expr_intf.bool_op = 
      1. | Leq
      2. | Geq
      3. | Lt
      4. | Gt
      5. | Eq
      6. | Neq
      type op = Linear_expr_intf.op = 
      1. | Plus
      2. | Minus
      type ('num, 'a) lra_view = 
      1. | LRA_pred of pred * 'a * 'a
      2. | LRA_op of op * 'a * 'a
      3. | LRA_mult of 'num * 'a
      4. | LRA_const of 'num
      5. | LRA_other of 'a
      val map_view : ('a -> 'b) -> ('c, 'd) lra_view -> ('e, 'f) lra_view
      module type ARG = sig ... end
      
diff --git a/dev/sidekick/Sidekick_th_lra/Intf/module-type-ARG/Q/index.html b/dev/sidekick/Sidekick_th_lra/Intf/module-type-ARG/Q/index.html
index f71000bc..1cef115d 100644
--- a/dev/sidekick/Sidekick_th_lra/Intf/module-type-ARG/Q/index.html
+++ b/dev/sidekick/Sidekick_th_lra/Intf/module-type-ARG/Q/index.html
@@ -1,2 +1,2 @@
 
-Q (sidekick.Sidekick_th_lra.Intf.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
      val to_string : t -> string
      val of_string : string -> t option
      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 (+) : 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)
      
+Q (sidekick.Sidekick_th_lra.Intf.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
      val to_string : t -> string
      val of_string : string -> t option
      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 (+) : 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)
      
diff --git a/dev/sidekick/Sidekick_th_lra/Intf/module-type-ARG/Z/index.html b/dev/sidekick/Sidekick_th_lra/Intf/module-type-ARG/Z/index.html
index e1d65af1..7eb724c8 100644
--- a/dev/sidekick/Sidekick_th_lra/Intf/module-type-ARG/Z/index.html
+++ b/dev/sidekick/Sidekick_th_lra/Intf/module-type-ARG/Z/index.html
@@ -1,2 +1,2 @@
 
-Z (sidekick.Sidekick_th_lra.Intf.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
      val to_string : t -> string
      val of_string : string -> t option
      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 (+) : 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
      
+Z (sidekick.Sidekick_th_lra.Intf.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
      val to_string : t -> string
      val of_string : string -> t option
      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 (+) : 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
      
diff --git a/dev/sidekick/Sidekick_th_lra/Intf/module-type-ARG/index.html b/dev/sidekick/Sidekick_th_lra/Intf/module-type-ARG/index.html
index 9aed36a1..218ec2f0 100644
--- a/dev/sidekick/Sidekick_th_lra/Intf/module-type-ARG/index.html
+++ b/dev/sidekick/Sidekick_th_lra/Intf/module-type-ARG/index.html
@@ -1,5 +1,5 @@
 
-ARG (sidekick.Sidekick_th_lra.Intf.ARG)
      Module type Intf.ARG
      module Z : INT
      module Q : RATIONAL with type bigint = Z.t
      Project the Term.t into the theory view
      val mk_lra : 
+ARG (sidekick.Sidekick_th_lra.Intf.ARG)
      Module type Intf.ARG
      module Z : INT
      module Q : RATIONAL with type bigint = Z.t
      Project the Term.t into the theory view
      Make a Term.t from the given theory view
      val ty_real : Sidekick_core.Term.store -> ty
      Build the type Q
      val has_ty_real : Sidekick_core.Term.t -> bool
      Does this term have the type Real
      
diff --git a/dev/sidekick/Sidekick_th_lra/index.html b/dev/sidekick/Sidekick_th_lra/index.html
index 1fb2cb23..375d4d2c 100644
--- a/dev/sidekick/Sidekick_th_lra/index.html
+++ b/dev/sidekick/Sidekick_th_lra/index.html
@@ -1,2 +1,2 @@
 
-Sidekick_th_lra (sidekick.Sidekick_th_lra)
      Module Sidekick_th_lra
      Linear Rational Arithmetic
      module Intf : sig ... end
      module Predicate = Intf.Predicate
      module SMT = Sidekick_smt_solver
      module type INT = Intf.INT
      module type RATIONAL = Intf.RATIONAL
      module S_op = Sidekick_simplex.Op
      type pred = Intf.pred = 
      1. | Leq
      2. | Geq
      3. | Lt
      4. | Gt
      5. | Eq
      6. | Neq
      type op = Intf.op = 
      1. | Plus
      2. | Minus
      type ('num, 'a) lra_view = ('num, 'a) Intf.lra_view = 
      1. | LRA_pred of pred * 'a * 'a
      2. | LRA_op of op * 'a * 'a
      3. | LRA_mult of 'num * 'a
      4. | LRA_const of 'num
      5. | LRA_other of 'a
      val map_view : ('a -> 'b) -> ('c, 'a) lra_view -> ('c, 'b) lra_view
      module type ARG = Intf.ARG
      val theory : (module ARG) -> SMT.Theory.t
      
+Sidekick_th_lra (sidekick.Sidekick_th_lra)
      Module Sidekick_th_lra
      Linear Rational Arithmetic
      module Intf : sig ... end
      module Predicate = Intf.Predicate
      module SMT = Sidekick_smt_solver
      module type INT = Intf.INT
      module type RATIONAL = Intf.RATIONAL
      module S_op = Sidekick_simplex.Op
      type pred = Intf.pred = 
      1. | Leq
      2. | Geq
      3. | Lt
      4. | Gt
      5. | Eq
      6. | Neq
      type op = Intf.op = 
      1. | Plus
      2. | Minus
      type ('num, 'a) lra_view = ('num, 'a) Intf.lra_view = 
      1. | LRA_pred of pred * 'a * 'a
      2. | LRA_op of op * 'a * 'a
      3. | LRA_mult of 'num * 'a
      4. | LRA_const of 'num
      5. | LRA_other of 'a
      val map_view : ('a -> 'b) -> ('c, 'a) lra_view -> ('c, 'b) lra_view
      module type ARG = Intf.ARG
      val theory : (module ARG) -> SMT.Theory.t
      
diff --git a/dev/sidekick/Sidekick_th_ty_unin/index.html b/dev/sidekick/Sidekick_th_ty_unin/index.html
index 633635e4..2bd1d604 100644
--- a/dev/sidekick/Sidekick_th_ty_unin/index.html
+++ b/dev/sidekick/Sidekick_th_ty_unin/index.html
@@ -1,2 +1,2 @@
 
-Sidekick_th_ty_unin (sidekick.Sidekick_th_ty_unin)
      Module Sidekick_th_ty_unin
      module type ARG = sig ... end
      val theory : (module ARG) -> Sidekick_smt_solver.Theory.t
      Theory of uninterpreted types
      
+Sidekick_th_ty_unin (sidekick.Sidekick_th_ty_unin)
      Module Sidekick_th_ty_unin
      module type ARG = sig ... end
      val theory : (module ARG) -> Sidekick_smt_solver.Theory.t
      Theory of uninterpreted types
      
diff --git a/dev/sidekick/Sidekick_th_ty_unin/module-type-ARG/index.html b/dev/sidekick/Sidekick_th_ty_unin/module-type-ARG/index.html
index e6d39eb5..0fbdfb27 100644
--- a/dev/sidekick/Sidekick_th_ty_unin/module-type-ARG/index.html
+++ b/dev/sidekick/Sidekick_th_ty_unin/module-type-ARG/index.html
@@ -1,2 +1,2 @@
 
-ARG (sidekick.Sidekick_th_ty_unin.ARG)
      Module type Sidekick_th_ty_unin.ARG
      val ty_is_unin : ty -> bool
      
+ARG (sidekick.Sidekick_th_ty_unin.ARG)
      Module type Sidekick_th_ty_unin.ARG
      val ty_is_unin : ty -> bool
      
diff --git a/dev/sidekick/Sidekick_trace/Entry_id/index.html b/dev/sidekick/Sidekick_trace/Entry_id/index.html
index 868165b4..d29a2980 100644
--- a/dev/sidekick/Sidekick_trace/Entry_id/index.html
+++ b/dev/sidekick/Sidekick_trace/Entry_id/index.html
@@ -1,2 +1,2 @@
 
-Entry_id (sidekick.Sidekick_trace.Entry_id)
      Module Sidekick_trace.Entry_id
      Entry in the sink.
      This integer tag represent a single entry in a trace, for example a line if we serialized using line-separate json values. In general each entry has its own unique ID that is monotonically increasing with time.
      include sig ... end
      type t = int
      val equal : t -> t -> bool
      val compare : t -> t -> int
      val hash : int CCHash.t
      val pp : int CCFormat.printer
      val to_int : 'a -> 'a
      val of_int_unsafe : int -> t
      val dummy : t
      Dummy id
      
+Entry_id (sidekick.Sidekick_trace.Entry_id)
      Module Sidekick_trace.Entry_id
      Entry in the sink.
      This integer tag represent a single entry in a trace, for example a line if we serialized using line-separate json values. In general each entry has its own unique ID that is monotonically increasing with time.
      include sig ... end
      type t = int
      val equal : t -> t -> bool
      val compare : t -> t -> int
      val hash : int CCHash.t
      val pp : int CCFormat.printer
      val to_int : 'a -> 'a
      val of_int_unsafe : int -> t
      val dummy : t
      Dummy id
      
diff --git a/dev/sidekick/Sidekick_trace/Sink/index.html b/dev/sidekick/Sidekick_trace/Sink/index.html
index b9218c40..6049c43e 100644
--- a/dev/sidekick/Sidekick_trace/Sink/index.html
+++ b/dev/sidekick/Sidekick_trace/Sink/index.html
@@ -1,2 +1,2 @@
 
-Sink (sidekick.Sidekick_trace.Sink)
      Module Sidekick_trace.Sink
      An IO sink for serialization/tracing
      A trace is emitted on the fly into a sink. The sink collects or writes entries that are emitted into it.
      type tag = string
      module type S = sig ... end
      type t = (module S)
      Trace sink
      val emit : t -> tag:tag -> Sidekick_util.Ser_value.t -> Entry_id.t
      val emit' : t -> tag:tag -> Sidekick_util.Ser_value.t -> unit
      val null : t
      Sink that writes nowhere, just eats bytes.
      val of_out_channel_using_bencode : Stdlib.out_channel -> t
      A sink that emits entries using Bencode into the given channel
      val of_buffer_using_bencode : Stdlib.Buffer.t -> t
      Emit entries into the given buffer, in Bencode.
      
+Sink (sidekick.Sidekick_trace.Sink)
      Module Sidekick_trace.Sink
      An IO sink for serialization/tracing
      A trace is emitted on the fly into a sink. The sink collects or writes entries that are emitted into it.
      type tag = string
      module type S = sig ... end
      type t = (module S)
      Trace sink
      val emit : t -> tag:tag -> Sidekick_util.Ser_value.t -> Entry_id.t
      val emit' : t -> tag:tag -> Sidekick_util.Ser_value.t -> unit
      val null : t
      Sink that writes nowhere, just eats bytes.
      val of_out_channel_using_bencode : Stdlib.out_channel -> t
      A sink that emits entries using Bencode into the given channel
      val of_buffer_using_bencode : Stdlib.Buffer.t -> t
      Emit entries into the given buffer, in Bencode.
      
diff --git a/dev/sidekick/Sidekick_trace/Sink/module-type-S/index.html b/dev/sidekick/Sidekick_trace/Sink/module-type-S/index.html
index 4bbf3993..f40d7618 100644
--- a/dev/sidekick/Sidekick_trace/Sink/module-type-S/index.html
+++ b/dev/sidekick/Sidekick_trace/Sink/module-type-S/index.html
@@ -1,2 +1,2 @@
 
-S (sidekick.Sidekick_trace.Sink.S)
      Module type Sink.S
      
+S (sidekick.Sidekick_trace.Sink.S)
      Module type Sink.S
      
diff --git a/dev/sidekick/Sidekick_trace/Source/index.html b/dev/sidekick/Sidekick_trace/Source/index.html
index 32420542..55ada517 100644
--- a/dev/sidekick/Sidekick_trace/Source/index.html
+++ b/dev/sidekick/Sidekick_trace/Source/index.html
@@ -1,5 +1,5 @@
 
-Source (sidekick.Sidekick_trace.Source)
      Module Sidekick_trace.Source
      Source to read a trace.
      A source is an IO input source that allows the read of individual entries of the trace, by providing their entry ID. It also allows to iterate on entries in chronological order.
      type tag = string
      module type S = sig ... end
      type t = (module S)
      val get_entry : t -> Entry_id.t -> (tag * Sidekick_util.Ser_value.t) option
      val get_entry_exn : t -> Entry_id.t -> tag * Sidekick_util.Ser_value.t
      val iter_all : 
+Source (sidekick.Sidekick_trace.Source)
      Module Sidekick_trace.Source
      Source to read a trace.
      A source is an IO input source that allows the read of individual entries of the trace, by providing their entry ID. It also allows to iterate on entries in chronological order.
      type tag = string
      module type S = sig ... end
      type t = (module S)
      val get_entry : t -> Entry_id.t -> (tag * Sidekick_util.Ser_value.t) option
      val get_entry_exn : t -> Entry_id.t -> tag * Sidekick_util.Ser_value.t
      val iter_all : 
   t ->
   (Entry_id.t -> tag:tag -> Sidekick_util.Ser_value.t -> unit) ->
   unit
      val of_string_using_bencode : string -> t
      Decode string, where entries are offsets
      
diff --git a/dev/sidekick/Sidekick_trace/Source/module-type-S/index.html b/dev/sidekick/Sidekick_trace/Source/module-type-S/index.html
index 5907d787..1e619117 100644
--- a/dev/sidekick/Sidekick_trace/Source/module-type-S/index.html
+++ b/dev/sidekick/Sidekick_trace/Source/module-type-S/index.html
@@ -1,4 +1,4 @@
 
-S (sidekick.Sidekick_trace.Source.S)
      Module type Source.S
      val get_entry : Entry_id.t -> tag * Sidekick_util.Ser_value.t
      • raises Not_found 
        if there is no such entry
      val iter_all : 
+S (sidekick.Sidekick_trace.Source.S)
      Module type Source.S
      val get_entry : Entry_id.t -> tag * Sidekick_util.Ser_value.t
      • raises Not_found 
        if there is no such entry
      val iter_all : 
   (Entry_id.t -> tag:tag -> Sidekick_util.Ser_value.t -> unit) ->
   unit
      Iterate on all entries
      
diff --git a/dev/sidekick/Sidekick_trace/index.html b/dev/sidekick/Sidekick_trace/index.html
index bf4f14a2..dae863c4 100644
--- a/dev/sidekick/Sidekick_trace/index.html
+++ b/dev/sidekick/Sidekick_trace/index.html
@@ -1,2 +1,2 @@
 
-Sidekick_trace (sidekick.Sidekick_trace)
      Module Sidekick_trace
      Tracing.
      Sidekick should be able to emit traces of some or all of the events happening inside its components (SAT solver, SMT solver, theories, etc.).
      Traces can be written to disk and read back later from another process.
      The two initial intended use cases are:
      • proof production (trace all inferences; reconstruct a proof from them starting from the inference of false)
      • debugging (trace some inferences/internal states/partial models; double check them later)
      Exports
      module Sink : sig ... end
      An IO sink for serialization/tracing
      module Source : sig ... end
      Source to read a trace.
      module Entry_id : sig ... end
      Entry in the sink.
      type entry_id = Entry_id.t
      
+Sidekick_trace (sidekick.Sidekick_trace)
      Module Sidekick_trace
      Tracing.
      Sidekick should be able to emit traces of some or all of the events happening inside its components (SAT solver, SMT solver, theories, etc.).
      Traces can be written to disk and read back later from another process.
      The two initial intended use cases are:
      • proof production (trace all inferences; reconstruct a proof from them starting from the inference of false)
      • debugging (trace some inferences/internal states/partial models; double check them later)
      Exports
      module Sink : sig ... end
      An IO sink for serialization/tracing
      module Source : sig ... end
      Source to read a trace.
      module Entry_id : sig ... end
      Entry in the sink.
      type entry_id = Entry_id.t
      
diff --git a/dev/sidekick/Sidekick_util/Backtrack_stack/index.html b/dev/sidekick/Sidekick_util/Backtrack_stack/index.html
index 728c080c..e7ad4be6 100644
--- a/dev/sidekick/Sidekick_util/Backtrack_stack/index.html
+++ b/dev/sidekick/Sidekick_util/Backtrack_stack/index.html
@@ -1,2 +1,2 @@
 
-Backtrack_stack (sidekick.Sidekick_util.Backtrack_stack)
      Module Sidekick_util.Backtrack_stack
      A backtracking stack
      type 'a t
      val create : unit -> 'a t
      val push : 'a t -> 'a -> unit
      Push an element onto the stack
      val push_if_nonzero_level : 'a t -> 'a -> unit
      Push an element onto the stack if level > 0
      include Sidekick_sigs.BACKTRACKABLE1_CB with type 'a t := 'a t
      include Sidekick_sigs.BACKTRACKABLE1 with type 'a t := 'a t
      val n_levels : _ t -> int
      Number of levels
      val push_level : _ t -> unit
      Push a backtracking point
      val pop_levels : 'a t -> int -> f:('a -> unit) -> unit
      pop_levels st n ~f removes n levels, calling f on every removed item
      val iter : f:('a -> unit) -> 'a t -> unit
      
+Backtrack_stack (sidekick.Sidekick_util.Backtrack_stack)
      Module Sidekick_util.Backtrack_stack
      A backtracking stack
      type 'a t
      val create : unit -> 'a t
      val push : 'a t -> 'a -> unit
      Push an element onto the stack
      val push_if_nonzero_level : 'a t -> 'a -> unit
      Push an element onto the stack if level > 0
      include Sidekick_sigs.BACKTRACKABLE1_CB with type 'a t := 'a t
      include Sidekick_sigs.BACKTRACKABLE1 with type 'a t := 'a t
      val n_levels : _ t -> int
      Number of levels
      val push_level : _ t -> unit
      Push a backtracking point
      val pop_levels : 'a t -> int -> f:('a -> unit) -> unit
      pop_levels st n ~f removes n levels, calling f on every removed item
      val iter : f:('a -> unit) -> 'a t -> unit
      
diff --git a/dev/sidekick/Sidekick_util/Backtrackable_ref/index.html b/dev/sidekick/Sidekick_util/Backtrackable_ref/index.html
index 86045706..662da60d 100644
--- a/dev/sidekick/Sidekick_util/Backtrackable_ref/index.html
+++ b/dev/sidekick/Sidekick_util/Backtrackable_ref/index.html
@@ -1,2 +1,2 @@
 
-Backtrackable_ref (sidekick.Sidekick_util.Backtrackable_ref)
      Module Sidekick_util.Backtrackable_ref
      Backtrackable ref
      type 'a t
      val create : ?copy:('a -> 'a) -> 'a -> 'a t
      Create a backtrackable reference holding the given value initially.
      • parameter copy 
        if provided, will be used to copy the value when push_level is called.
      val set : 'a t -> 'a -> unit
      Set the reference's current content
      val get : 'a t -> 'a
      Get the reference's current content
      val update : 'a t -> ('a -> 'a) -> unit
      Update the reference's current content
      include Sidekick_sigs.BACKTRACKABLE1 with type 'a t := 'a t
      val n_levels : _ t -> int
      Number of levels
      val push_level : _ t -> unit
      Push a backtracking point
      val pop_levels : _ t -> int -> unit
      pop_levels st n removes n levels
      
+Backtrackable_ref (sidekick.Sidekick_util.Backtrackable_ref)
      Module Sidekick_util.Backtrackable_ref
      Backtrackable ref
      type 'a t
      val create : ?copy:('a -> 'a) -> 'a -> 'a t
      Create a backtrackable reference holding the given value initially.
      • parameter copy 
        if provided, will be used to copy the value when push_level is called.
      val set : 'a t -> 'a -> unit
      Set the reference's current content
      val get : 'a t -> 'a
      Get the reference's current content
      val update : 'a t -> ('a -> 'a) -> unit
      Update the reference's current content
      include Sidekick_sigs.BACKTRACKABLE1 with type 'a t := 'a t
      val n_levels : _ t -> int
      Number of levels
      val push_level : _ t -> unit
      Push a backtracking point
      val pop_levels : _ t -> int -> unit
      pop_levels st n removes n levels
      
diff --git a/dev/sidekick/Sidekick_util/Backtrackable_tbl/Make/argument-1-A/index.html b/dev/sidekick/Sidekick_util/Backtrackable_tbl/Make/argument-1-A/index.html
index ddf5763b..931c46d2 100644
--- a/dev/sidekick/Sidekick_util/Backtrackable_tbl/Make/argument-1-A/index.html
+++ b/dev/sidekick/Sidekick_util/Backtrackable_tbl/Make/argument-1-A/index.html
@@ -1,2 +1,2 @@
 
-A (sidekick.Sidekick_util.Backtrackable_tbl.Make.A)
      Parameter Make.A
      type t
      val equal : t -> t -> bool
      val hash : t -> int
      
+A (sidekick.Sidekick_util.Backtrackable_tbl.Make.A)
      Parameter Make.A
      type t
      val equal : t -> t -> bool
      val hash : t -> int
      
diff --git a/dev/sidekick/Sidekick_util/Backtrackable_tbl/Make/index.html b/dev/sidekick/Sidekick_util/Backtrackable_tbl/Make/index.html
index 178d9247..68ecc169 100644
--- a/dev/sidekick/Sidekick_util/Backtrackable_tbl/Make/index.html
+++ b/dev/sidekick/Sidekick_util/Backtrackable_tbl/Make/index.html
@@ -1,2 +1,2 @@
 
-Make (sidekick.Sidekick_util.Backtrackable_tbl.Make)
      Module Backtrackable_tbl.Make
      Parameters
      module A : ARG
      Signature
      type key = A.t
      type 'a t
      val create : ?size:int -> unit -> 'a t
      val find : 'a t -> key -> 'a
      • raises Not_found 
        if the key is not present
      val get : 'a t -> key -> 'a option
      val mem : _ t -> key -> bool
      val length : _ t -> int
      val iter : (key -> 'a -> unit) -> 'a t -> unit
      val to_iter : 'a t -> (key * 'a) Iter.t
      val add : 'a t -> key -> 'a -> unit
      val remove : _ t -> key -> unit
      include Sidekick_sigs.BACKTRACKABLE1 with type 'a t := 'a t
      val n_levels : _ t -> int
      Number of levels
      val push_level : _ t -> unit
      Push a backtracking point
      val pop_levels : _ t -> int -> unit
      pop_levels st n removes n levels
      
+Make (sidekick.Sidekick_util.Backtrackable_tbl.Make)
      Module Backtrackable_tbl.Make
      Parameters
      module A : ARG
      Signature
      type key = A.t
      type 'a t
      val create : ?size:int -> unit -> 'a t
      val find : 'a t -> key -> 'a
      • raises Not_found 
        if the key is not present
      val get : 'a t -> key -> 'a option
      val mem : _ t -> key -> bool
      val length : _ t -> int
      val iter : (key -> 'a -> unit) -> 'a t -> unit
      val to_iter : 'a t -> (key * 'a) Iter.t
      val add : 'a t -> key -> 'a -> unit
      val remove : _ t -> key -> unit
      include Sidekick_sigs.BACKTRACKABLE1 with type 'a t := 'a t
      val n_levels : _ t -> int
      Number of levels
      val push_level : _ t -> unit
      Push a backtracking point
      val pop_levels : _ t -> int -> unit
      pop_levels st n removes n levels
      
diff --git a/dev/sidekick/Sidekick_util/Backtrackable_tbl/index.html b/dev/sidekick/Sidekick_util/Backtrackable_tbl/index.html
index 9862c677..e40a79d3 100644
--- a/dev/sidekick/Sidekick_util/Backtrackable_tbl/index.html
+++ b/dev/sidekick/Sidekick_util/Backtrackable_tbl/index.html
@@ -1,2 +1,2 @@
 
-Backtrackable_tbl (sidekick.Sidekick_util.Backtrackable_tbl)
      Module Sidekick_util.Backtrackable_tbl
      A backtrackable hashtable
      module type S = sig ... end
      module type ARG = sig ... end
      module Make (A : ARG) : S with type key = A.t
      
+Backtrackable_tbl (sidekick.Sidekick_util.Backtrackable_tbl)
      Module Sidekick_util.Backtrackable_tbl
      A backtrackable hashtable
      module type S = sig ... end
      module type ARG = sig ... end
      module Make (A : ARG) : S with type key = A.t
      
diff --git a/dev/sidekick/Sidekick_util/Backtrackable_tbl/module-type-ARG/index.html b/dev/sidekick/Sidekick_util/Backtrackable_tbl/module-type-ARG/index.html
index 96c1691a..daa48403 100644
--- a/dev/sidekick/Sidekick_util/Backtrackable_tbl/module-type-ARG/index.html
+++ b/dev/sidekick/Sidekick_util/Backtrackable_tbl/module-type-ARG/index.html
@@ -1,2 +1,2 @@
 
-ARG (sidekick.Sidekick_util.Backtrackable_tbl.ARG)
      Module type Backtrackable_tbl.ARG
      type t
      val equal : t -> t -> bool
      val hash : t -> int
      
+ARG (sidekick.Sidekick_util.Backtrackable_tbl.ARG)
      Module type Backtrackable_tbl.ARG
      type t
      val equal : t -> t -> bool
      val hash : t -> int
      
diff --git a/dev/sidekick/Sidekick_util/Backtrackable_tbl/module-type-S/index.html b/dev/sidekick/Sidekick_util/Backtrackable_tbl/module-type-S/index.html
index 6cee9c0d..acf4fef6 100644
--- a/dev/sidekick/Sidekick_util/Backtrackable_tbl/module-type-S/index.html
+++ b/dev/sidekick/Sidekick_util/Backtrackable_tbl/module-type-S/index.html
@@ -1,2 +1,2 @@
 
-S (sidekick.Sidekick_util.Backtrackable_tbl.S)
      Module type Backtrackable_tbl.S
      type key
      type 'a t
      val create : ?size:int -> unit -> 'a t
      val find : 'a t -> key -> 'a
      • raises Not_found 
        if the key is not present
      val get : 'a t -> key -> 'a option
      val mem : _ t -> key -> bool
      val length : _ t -> int
      val iter : (key -> 'a -> unit) -> 'a t -> unit
      val to_iter : 'a t -> (key * 'a) Iter.t
      val add : 'a t -> key -> 'a -> unit
      val remove : _ t -> key -> unit
      include Sidekick_sigs.BACKTRACKABLE1 with type 'a t := 'a t
      val n_levels : _ t -> int
      Number of levels
      val push_level : _ t -> unit
      Push a backtracking point
      val pop_levels : _ t -> int -> unit
      pop_levels st n removes n levels
      
+S (sidekick.Sidekick_util.Backtrackable_tbl.S)
      Module type Backtrackable_tbl.S
      type key
      type 'a t
      val create : ?size:int -> unit -> 'a t
      val find : 'a t -> key -> 'a
      • raises Not_found 
        if the key is not present
      val get : 'a t -> key -> 'a option
      val mem : _ t -> key -> bool
      val length : _ t -> int
      val iter : (key -> 'a -> unit) -> 'a t -> unit
      val to_iter : 'a t -> (key * 'a) Iter.t
      val add : 'a t -> key -> 'a -> unit
      val remove : _ t -> key -> unit
      include Sidekick_sigs.BACKTRACKABLE1 with type 'a t := 'a t
      val n_levels : _ t -> int
      Number of levels
      val push_level : _ t -> unit
      Push a backtracking point
      val pop_levels : _ t -> int -> unit
      pop_levels st n removes n levels
      
diff --git a/dev/sidekick/Sidekick_util/Bag/index.html b/dev/sidekick/Sidekick_util/Bag/index.html
index 5716c91e..db61abe1 100644
--- a/dev/sidekick/Sidekick_util/Bag/index.html
+++ b/dev/sidekick/Sidekick_util/Bag/index.html
@@ -1,2 +1,2 @@
 
-Bag (sidekick.Sidekick_util.Bag)
      Module Sidekick_util.Bag
      Ordered Bag of Elements
      A data structure where we can have duplicate elements, optimized for fast concatenation and size.
      type +'a t = private 
      1. | E
      2. | L of 'a
      3. | N of 'a t * 'a t
      val empty : 'a t
      val is_empty : _ t -> bool
      val return : 'a -> 'a t
      val cons : 'a -> 'a t -> 'a t
      val snoc : 'a t -> 'a -> 'a t
      val append : 'a t -> 'a t -> 'a t
      val of_iter : 'a Iter.t -> 'a t
      val to_iter : 'a t -> 'a Iter.t
      val to_list : 'a t -> 'a list
      val fold : ('a -> 'b -> 'a) -> 'a -> 'b t -> 'a
      val iter : ('a -> unit) -> 'a t -> unit
      val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
      Are the two bags equal, element wise?
      
+Bag (sidekick.Sidekick_util.Bag)
      Module Sidekick_util.Bag
      Ordered Bag of Elements
      A data structure where we can have duplicate elements, optimized for fast concatenation and size.
      type +'a t = private 
      1. | E
      2. | L of 'a
      3. | N of 'a t * 'a t
      val empty : 'a t
      val is_empty : _ t -> bool
      val return : 'a -> 'a t
      val cons : 'a -> 'a t -> 'a t
      val snoc : 'a t -> 'a -> 'a t
      val append : 'a t -> 'a t -> 'a t
      val of_iter : 'a Iter.t -> 'a t
      val to_iter : 'a t -> 'a Iter.t
      val to_list : 'a t -> 'a list
      val fold : ('a -> 'b -> 'a) -> 'a -> 'b t -> 'a
      val iter : ('a -> unit) -> 'a t -> unit
      val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
      Are the two bags equal, element wise?
      
diff --git a/dev/sidekick/Sidekick_util/Bitvec/index.html b/dev/sidekick/Sidekick_util/Bitvec/index.html
index 242f6e65..28a6b675 100644
--- a/dev/sidekick/Sidekick_util/Bitvec/index.html
+++ b/dev/sidekick/Sidekick_util/Bitvec/index.html
@@ -1,2 +1,2 @@
 
-Bitvec (sidekick.Sidekick_util.Bitvec)
      Module Sidekick_util.Bitvec
      Bitvector.
      This provides compact storage with O(1) access to a range of bits, like bool Vec.t but packed better.
      type t
      val create : unit -> t
      val ensure_size : t -> int -> unit
      ensure_size bv i ensures that i is a valid index in bv
      val get : t -> int -> bool
      val set : t -> int -> bool -> unit
      val clear_all : t -> unit
      
+Bitvec (sidekick.Sidekick_util.Bitvec)
      Module Sidekick_util.Bitvec
      Bitvector.
      This provides compact storage with O(1) access to a range of bits, like bool Vec.t but packed better.
      type t
      val create : unit -> t
      val ensure_size : t -> int -> unit
      ensure_size bv i ensures that i is a valid index in bv
      val get : t -> int -> bool
      val set : t -> int -> bool -> unit
      val clear_all : t -> unit
      
diff --git a/dev/sidekick/Sidekick_util/Chunk_stack/Buf/index.html b/dev/sidekick/Sidekick_util/Chunk_stack/Buf/index.html
index 85bc0485..8a316aa5 100644
--- a/dev/sidekick/Sidekick_util/Chunk_stack/Buf/index.html
+++ b/dev/sidekick/Sidekick_util/Chunk_stack/Buf/index.html
@@ -1,2 +1,2 @@
 
-Buf (sidekick.Sidekick_util.Chunk_stack.Buf)
      Module Chunk_stack.Buf
      A hand made buffer
      type t = {
      1. mutable b : bytes;
      2. mutable len : int;
      }
      val create : ?cap:int -> unit -> t
      val clear : t -> unit
      val contents : t -> string
      
+Buf (sidekick.Sidekick_util.Chunk_stack.Buf)
      Module Chunk_stack.Buf
      A hand made buffer
      type t = {
      1. mutable b : bytes;
      2. mutable len : int;
      }
      val create : ?cap:int -> unit -> t
      val clear : t -> unit
      val contents : t -> string
      
diff --git a/dev/sidekick/Sidekick_util/Chunk_stack/Reader/index.html b/dev/sidekick/Sidekick_util/Chunk_stack/Reader/index.html
index 42926790..280a222a 100644
--- a/dev/sidekick/Sidekick_util/Chunk_stack/Reader/index.html
+++ b/dev/sidekick/Sidekick_util/Chunk_stack/Reader/index.html
@@ -1,2 +1,2 @@
 
-Reader (sidekick.Sidekick_util.Chunk_stack.Reader)
      Module Chunk_stack.Reader
      type t
      val next : t -> yield:(bytes -> int -> int -> 'a) -> finish:(unit -> 'a) -> 'a
      Read next chunk, call yield with a slice of bytes, otherwise call finish().
      val next_string : t -> string option
      Read next chunk as a string
      val empty : t
      val from_buf : Buf.t -> t
      val from_channel_backward : ?close_at_end:bool -> Stdlib.in_channel -> t
      Read channel from the end, assuming that is possible.
      val with_file_backward : string -> (t -> 'a) -> 'a
      read_file_backward filename f calls f with an iterator over chunks of the file, read from the end.
      Each chunk is assumed to be followed by its length as an int32 LE.
      
+Reader (sidekick.Sidekick_util.Chunk_stack.Reader)
      Module Chunk_stack.Reader
      type t
      val next : t -> yield:(bytes -> int -> int -> 'a) -> finish:(unit -> 'a) -> 'a
      Read next chunk, call yield with a slice of bytes, otherwise call finish().
      val next_string : t -> string option
      Read next chunk as a string
      val empty : t
      val from_buf : Buf.t -> t
      val from_channel_backward : ?close_at_end:bool -> Stdlib.in_channel -> t
      Read channel from the end, assuming that is possible.
      val with_file_backward : string -> (t -> 'a) -> 'a
      read_file_backward filename f calls f with an iterator over chunks of the file, read from the end.
      Each chunk is assumed to be followed by its length as an int32 LE.
      
diff --git a/dev/sidekick/Sidekick_util/Chunk_stack/Writer/index.html b/dev/sidekick/Sidekick_util/Chunk_stack/Writer/index.html
index ba1b101b..4aa77381 100644
--- a/dev/sidekick/Sidekick_util/Chunk_stack/Writer/index.html
+++ b/dev/sidekick/Sidekick_util/Chunk_stack/Writer/index.html
@@ -1,2 +1,2 @@
 
-Writer (sidekick.Sidekick_util.Chunk_stack.Writer)
      Module Chunk_stack.Writer
      Create a stack of chunks.
      type t
      val dummy : t
      val into_buf : Buf.t -> t
      val into_channel : Stdlib.out_channel -> t
      val add_buf : t -> Buf.t -> unit
      val add_bytes : t -> bytes -> int -> int -> unit
      val add_string : t -> string -> unit
      val add_buffer : t -> Stdlib.Buffer.t -> unit
      
+Writer (sidekick.Sidekick_util.Chunk_stack.Writer)
      Module Chunk_stack.Writer
      Create a stack of chunks.
      type t
      val dummy : t
      val into_buf : Buf.t -> t
      val into_channel : Stdlib.out_channel -> t
      val add_buf : t -> Buf.t -> unit
      val add_bytes : t -> bytes -> int -> int -> unit
      val add_string : t -> string -> unit
      val add_buffer : t -> Stdlib.Buffer.t -> unit
      
diff --git a/dev/sidekick/Sidekick_util/Chunk_stack/index.html b/dev/sidekick/Sidekick_util/Chunk_stack/index.html
index 13fed45c..911bb765 100644
--- a/dev/sidekick/Sidekick_util/Chunk_stack/index.html
+++ b/dev/sidekick/Sidekick_util/Chunk_stack/index.html
@@ -1,2 +1,2 @@
 
-Chunk_stack (sidekick.Sidekick_util.Chunk_stack)
      Module Sidekick_util.Chunk_stack
      Manage a list of chunks.
      A chunk is used for serializing proof traces, possibly on disk. This way we do not have to keep the whole proof in memory. Each chunk is typically one step of the proof search.
      We produce chunks in forward order (chronological order of their discovery), but once we find a proof of "false", we work our way backward to find chunks transitively needed by this proof of false. Once we obtain this subset of the chunks (as a graph in memory) we can emit a proper proof with no redundant information.
      module Buf : sig ... end
      A hand made buffer
      module Writer : sig ... end
      Create a stack of chunks.
      module Reader : sig ... end
      
+Chunk_stack (sidekick.Sidekick_util.Chunk_stack)
      Module Sidekick_util.Chunk_stack
      Manage a list of chunks.
      A chunk is used for serializing proof traces, possibly on disk. This way we do not have to keep the whole proof in memory. Each chunk is typically one step of the proof search.
      We produce chunks in forward order (chronological order of their discovery), but once we find a proof of "false", we work our way backward to find chunks transitively needed by this proof of false. Once we obtain this subset of the chunks (as a graph in memory) we can emit a proper proof with no redundant information.
      module Buf : sig ... end
      A hand made buffer
      module Writer : sig ... end
      Create a stack of chunks.
      module Reader : sig ... end
      
diff --git a/dev/sidekick/Sidekick_util/Error/index.html b/dev/sidekick/Sidekick_util/Error/index.html
index 43b0b9da..cd8c4183 100644
--- a/dev/sidekick/Sidekick_util/Error/index.html
+++ b/dev/sidekick/Sidekick_util/Error/index.html
@@ -1,2 +1,2 @@
 
-Error (sidekick.Sidekick_util.Error)
      Module Sidekick_util.Error
      exception Error of string
      val errorf : ('a, Stdlib.Format.formatter, unit, 'b) Stdlib.format4 -> 'a
      type nonrec 'a result = ('a, string) Stdlib.result
      val try_ : (unit -> 'a) -> 'a result
      
+Error (sidekick.Sidekick_util.Error)
      Module Sidekick_util.Error
      exception Error of string
      val errorf : ('a, Stdlib.Format.formatter, unit, 'b) Stdlib.format4 -> 'a
      type nonrec 'a result = ('a, string) Stdlib.result
      val try_ : (unit -> 'a) -> 'a result
      
diff --git a/dev/sidekick/Sidekick_util/Event/Emitter/index.html b/dev/sidekick/Sidekick_util/Event/Emitter/index.html
index 89bcc599..cb19fd2c 100644
--- a/dev/sidekick/Sidekick_util/Event/Emitter/index.html
+++ b/dev/sidekick/Sidekick_util/Event/Emitter/index.html
@@ -1,2 +1,2 @@
 
-Emitter (sidekick.Sidekick_util.Event.Emitter)
      Module Event.Emitter
      type ('a, 'b) t
      val create : unit -> ('a, 'b) t
      val emit : ('a, unit) t -> 'a -> unit
      val emit_collect : ('a, 'b) t -> 'a -> 'b list
      val emit_iter : ('a, 'b) t -> 'a -> f:('b -> unit) -> unit
      
+Emitter (sidekick.Sidekick_util.Event.Emitter)
      Module Event.Emitter
      type ('a, 'b) t
      val create : unit -> ('a, 'b) t
      val emit : ('a, unit) t -> 'a -> unit
      val emit_collect : ('a, 'b) t -> 'a -> 'b list
      val emit_iter : ('a, 'b) t -> 'a -> f:('b -> unit) -> unit
      
diff --git a/dev/sidekick/Sidekick_util/Event/index.html b/dev/sidekick/Sidekick_util/Event/index.html
index 46dd6781..c96cc2c7 100644
--- a/dev/sidekick/Sidekick_util/Event/index.html
+++ b/dev/sidekick/Sidekick_util/Event/index.html
@@ -1,2 +1,2 @@
 
-Event (sidekick.Sidekick_util.Event)
      Module Sidekick_util.Event
      Event pattern.
      This provides a basic observer pattern, where events are emitted from some source (with an attached value), and callbacks that were registered will receive this value.
      type ('a, 'b) t
      An event emitting values of type 'a, where subscribers return values of type 'b.
      module Emitter : sig ... end
      val on : ('a, 'b) t -> f:('a -> 'b) -> unit
      val of_emitter : ('a, 'b) Emitter.t -> ('a, 'b) t
      val emit : ('a, unit) Emitter.t -> 'a -> unit
      val emit_collect : ('a, 'b) Emitter.t -> 'a -> 'b list
      val emit_iter : ('a, 'b) Emitter.t -> 'a -> f:('b -> unit) -> unit
      
+Event (sidekick.Sidekick_util.Event)
      Module Sidekick_util.Event
      Event pattern.
      This provides a basic observer pattern, where events are emitted from some source (with an attached value), and callbacks that were registered will receive this value.
      type ('a, 'b) t
      An event emitting values of type 'a, where subscribers return values of type 'b.
      module Emitter : sig ... end
      val on : ('a, 'b) t -> f:('a -> 'b) -> unit
      val of_emitter : ('a, 'b) Emitter.t -> ('a, 'b) t
      val emit : ('a, unit) Emitter.t -> 'a -> unit
      val emit_collect : ('a, 'b) Emitter.t -> 'a -> 'b list
      val emit_iter : ('a, 'b) Emitter.t -> 'a -> f:('b -> unit) -> unit
      
diff --git a/dev/sidekick/Sidekick_util/Hash/index.html b/dev/sidekick/Sidekick_util/Hash/index.html
index 1ca0d409..a5060a39 100644
--- a/dev/sidekick/Sidekick_util/Hash/index.html
+++ b/dev/sidekick/Sidekick_util/Hash/index.html
@@ -1,2 +1,2 @@
 
-Hash (sidekick.Sidekick_util.Hash)
      Module Sidekick_util.Hash
      type 'a t = 'a -> int
      val bool : bool t
      val int : int t
      val string : string t
      val combine : 'a t -> int -> 'a -> int
      val pair : 'a t -> 'b t -> ('a * 'b) t
      val opt : 'a t -> 'a option t
      val list : 'a t -> 'a list t
      val array : 'a t -> 'a array t
      val iarray : 'a t -> 'a array t
      val seq : 'a t -> 'a Iter.t t
      val combine2 : int -> int -> int
      val combine3 : int -> int -> int -> int
      val combine4 : int -> int -> int -> int -> int
      val poly : 'a t
      the regular polymorphic hash function
      
+Hash (sidekick.Sidekick_util.Hash)
      Module Sidekick_util.Hash
      type 'a t = 'a -> int
      val bool : bool t
      val int : int t
      val string : string t
      val combine : 'a t -> int -> 'a -> int
      val pair : 'a t -> 'b t -> ('a * 'b) t
      val opt : 'a t -> 'a option t
      val list : 'a t -> 'a list t
      val array : 'a t -> 'a array t
      val iarray : 'a t -> 'a array t
      val seq : 'a t -> 'a Iter.t t
      val combine2 : int -> int -> int
      val combine3 : int -> int -> int -> int
      val combine4 : int -> int -> int -> int -> int
      val poly : 'a t
      the regular polymorphic hash function
      
diff --git a/dev/sidekick/Sidekick_util/Int_id/Make/index.html b/dev/sidekick/Sidekick_util/Int_id/Make/index.html
index 79c6730f..7802c2cb 100644
--- a/dev/sidekick/Sidekick_util/Int_id/Make/index.html
+++ b/dev/sidekick/Sidekick_util/Int_id/Make/index.html
@@ -1,2 +1,2 @@
 
-Make (sidekick.Sidekick_util.Int_id.Make)
      Module Int_id.Make
      Generate a new type for integer identifiers
      Parameters
      Signature
      type t = int
      val equal : t -> t -> bool
      val compare : t -> t -> int
      val hash : int CCHash.t
      val pp : int CCFormat.printer
      val to_int : 'a -> 'b
      val of_int_unsafe : int -> t
      
+Make (sidekick.Sidekick_util.Int_id.Make)
      Module Int_id.Make
      Generate a new type for integer identifiers
      Parameters
      Signature
      type t = int
      val equal : t -> t -> bool
      val compare : t -> t -> int
      val hash : int CCHash.t
      val pp : int CCFormat.printer
      val to_int : 'a -> 'b
      val of_int_unsafe : int -> t
      
diff --git a/dev/sidekick/Sidekick_util/Int_id/index.html b/dev/sidekick/Sidekick_util/Int_id/index.html
index f4bcca3d..ada1927c 100644
--- a/dev/sidekick/Sidekick_util/Int_id/index.html
+++ b/dev/sidekick/Sidekick_util/Int_id/index.html
@@ -1,2 +1,2 @@
 
-Int_id (sidekick.Sidekick_util.Int_id)
      Module Sidekick_util.Int_id
      Integer-based identifiers.
      module type S = sig ... end
      module Make () : sig ... end
      Generate a new type for integer identifiers
      
+Int_id (sidekick.Sidekick_util.Int_id)
      Module Sidekick_util.Int_id
      Integer-based identifiers.
      module type S = sig ... end
      module Make () : sig ... end
      Generate a new type for integer identifiers
      
diff --git a/dev/sidekick/Sidekick_util/Int_id/module-type-S/index.html b/dev/sidekick/Sidekick_util/Int_id/module-type-S/index.html
index 6f02d439..c344b9ee 100644
--- a/dev/sidekick/Sidekick_util/Int_id/module-type-S/index.html
+++ b/dev/sidekick/Sidekick_util/Int_id/module-type-S/index.html
@@ -1,2 +1,2 @@
 
-S (sidekick.Sidekick_util.Int_id.S)
      Module type Int_id.S
      type t = private int
      include Sidekick_sigs.EQ_ORD_HASH_PRINT with type t := 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 to_int : t -> int
      val of_int_unsafe : int -> t
      
+S (sidekick.Sidekick_util.Int_id.S)
      Module type Int_id.S
      type t = private int
      include Sidekick_sigs.EQ_ORD_HASH_PRINT with type t := 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 to_int : t -> int
      val of_int_unsafe : int -> t
      
diff --git a/dev/sidekick/Sidekick_util/Log/index.html b/dev/sidekick/Sidekick_util/Log/index.html
index 5c495cc8..32665042 100644
--- a/dev/sidekick/Sidekick_util/Log/index.html
+++ b/dev/sidekick/Sidekick_util/Log/index.html
@@ -1,5 +1,5 @@
 
-Log (sidekick.Sidekick_util.Log)
      Module Sidekick_util.Log
      Logging function, for debugging
      val enabled : bool
      val set_debug : int -> unit
      Set debug level
      val get_debug : unit -> int
      Current debug level
      val debugf : 
+Log (sidekick.Sidekick_util.Log)
      Module Sidekick_util.Log
      Logging function, for debugging
      val enabled : bool
      val set_debug : int -> unit
      Set debug level
      val get_debug : unit -> int
      Current debug level
      val debugf : 
   int ->
   ((('a, Stdlib.Format.formatter, unit, unit) Stdlib.format4 -> 'a) -> unit) ->
   unit
      Emit a debug message at the given level. If the level is lower than get_debug (), the message will indeed be emitted
      val debug : int -> string -> unit
      Simpler version of debug, without formatting
      val set_debug_out : Stdlib.Format.formatter -> unit
      Change the output formatter.
      
diff --git a/dev/sidekick/Sidekick_util/Profile/index.html b/dev/sidekick/Sidekick_util/Profile/index.html
index de5bc975..b25d5b8b 100644
--- a/dev/sidekick/Sidekick_util/Profile/index.html
+++ b/dev/sidekick/Sidekick_util/Profile/index.html
@@ -1,5 +1,5 @@
 
-Profile (sidekick.Sidekick_util.Profile)
      Module Sidekick_util.Profile
      include module type of struct include Trace_core end
      type span = int64
      type user_data = [ 
      1. | `Bool of bool
      2. | `Float of float
      3. | `Int of int
      4. | `None
      5. | `String of string
       ]
      type explicit_span = Trace_core__Types.explicit_span = {
      1. span : span;
      2. mutable meta : Trace_core__.Meta_map.t;
      }
      module Collector : sig ... end
      module Meta_map : sig ... end
      val enabled : unit -> bool
      val with_span : 
+Profile (sidekick.Sidekick_util.Profile)
      Module Sidekick_util.Profile
      include module type of struct include Trace_core end
      type span = int64
      type user_data = [ 
      1. | `Bool of bool
      2. | `Float of float
      3. | `Int of int
      4. | `None
      5. | `String of string
       ]
      type explicit_span = Trace_core__Types.explicit_span = {
      1. span : span;
      2. mutable meta : Trace_core__.Meta_map.t;
      }
      module Collector : sig ... end
      module Meta_map : sig ... end
      val enabled : unit -> bool
      val with_span : 
   ?__FUNCTION__:string ->
   __FILE__:string ->
   __LINE__:int ->
diff --git a/dev/sidekick/Sidekick_util/Ser_decode/Error/index.html b/dev/sidekick/Sidekick_util/Ser_decode/Error/index.html
index e3747987..9e5846a7 100644
--- a/dev/sidekick/Sidekick_util/Ser_decode/Error/index.html
+++ b/dev/sidekick/Sidekick_util/Ser_decode/Error/index.html
@@ -1,2 +1,2 @@
 
-Error (sidekick.Sidekick_util.Ser_decode.Error)
      Module Ser_decode.Error
      Errors
      type t
      include Sidekick_sigs.PRINT with type t := t
      val to_string : t -> string
      val of_string : string -> Ser_value.t -> t
      
+Error (sidekick.Sidekick_util.Ser_decode.Error)
      Module Ser_decode.Error
      Errors
      type t
      include Sidekick_sigs.PRINT with type t := t
      val to_string : t -> string
      val of_string : string -> Ser_value.t -> t
      
diff --git a/dev/sidekick/Sidekick_util/Ser_decode/Infix/index.html b/dev/sidekick/Sidekick_util/Ser_decode/Infix/index.html
index 9a60828a..9a0a02d9 100644
--- a/dev/sidekick/Sidekick_util/Ser_decode/Infix/index.html
+++ b/dev/sidekick/Sidekick_util/Ser_decode/Infix/index.html
@@ -1,2 +1,2 @@
 
-Infix (sidekick.Sidekick_util.Ser_decode.Infix)
      Module Ser_decode.Infix
      val (>|=) : 'a t -> ('a -> 'b) -> 'b t
      val (>>=) : 'a t -> ('a -> 'b t) -> 'b t
      val let+ : 'a t -> ('a -> 'b) -> 'b t
      val and+ : 'a t -> 'b t -> ('a * 'b) t
      val let* : 'a t -> ('a -> 'b t) -> 'b t
      val and* : 'a t -> 'b t -> ('a * 'b) t
      
+Infix (sidekick.Sidekick_util.Ser_decode.Infix)
      Module Ser_decode.Infix
      val (>|=) : 'a t -> ('a -> 'b) -> 'b t
      val (>>=) : 'a t -> ('a -> 'b t) -> 'b t
      val let+ : 'a t -> ('a -> 'b) -> 'b t
      val and+ : 'a t -> 'b t -> ('a * 'b) t
      val let* : 'a t -> ('a -> 'b t) -> 'b t
      val and* : 'a t -> 'b t -> ('a * 'b) t
      
diff --git a/dev/sidekick/Sidekick_util/Ser_decode/index.html b/dev/sidekick/Sidekick_util/Ser_decode/index.html
index f9f94449..77eff82b 100644
--- a/dev/sidekick/Sidekick_util/Ser_decode/index.html
+++ b/dev/sidekick/Sidekick_util/Ser_decode/index.html
@@ -1,2 +1,2 @@
 
-Ser_decode (sidekick.Sidekick_util.Ser_decode)
      Module Sidekick_util.Ser_decode
      Decoders for Ser_value.
      Combinators to decode values.
      module Error : sig ... end
      Errors
      Main combinators
      type +'a t
      Decode a value of type 'a
      val int : int t
      val bool : bool t
      val string : string t
      val return : 'a -> 'a t
      val return_result : ('a, string) Stdlib.result -> 'a t
      val return_result_err : ('a, Error.t) Stdlib.result -> 'a t
      val delay : (unit -> 'a t) -> 'a t
      val fail : string -> 'a t
      val failf : ('a, Stdlib.Format.formatter, unit, 'b t) Stdlib.format4 -> 'a
      val fail_err : Error.t -> 'a t
      val unwrap_opt : string -> 'a option -> 'a t
      Unwrap option, or fail
      val any : Ser_value.t t
      val list : 'a t -> 'a list t
      val tup2 : 'a t -> 'b t -> ('a * 'b) t
      val tup3 : 'a t -> 'b t -> 'c t -> ('a * 'b * 'c) t
      val tup4 : 'a t -> 'b t -> 'c t -> 'd t -> ('a * 'b * 'c * 'd) t
      val dict_field : string -> 'a t -> 'a t
      val dict_field_opt : string -> 'a t -> 'a option t
      val dict_field_or : 'a -> string -> 'a t -> 'a t
      val both : 'a t -> 'b t -> ('a * 'b) t
      val reflect : 'a t -> Ser_value.t -> ('a, Error.t) Stdlib.result t
      reflect dec v returns the result of decoding v with dec
      val reflect_or_fail : 'a t -> Ser_value.t -> 'a t
      val try_l : 'a t list -> 'a t
      try_l fs tries each f in fs turn by turn, until one succeeds
      module Infix : sig ... end
      include module type of Infix
      val (>|=) : 'a t -> ('a -> 'b) -> 'b t
      val (>>=) : 'a t -> ('a -> 'b t) -> 'b t
      val let+ : 'a t -> ('a -> 'b) -> 'b t
      val and+ : 'a t -> 'b t -> ('a * 'b) t
      val let* : 'a t -> ('a -> 'b t) -> 'b t
      val and* : 'a t -> 'b t -> ('a * 'b) t
      Deserializing
      val run : 'a t -> Ser_value.t -> ('a, Error.t) Stdlib.result
      val run_exn : 'a t -> Ser_value.t -> 'a
      • raises Error.Error 
        in case of failure
      
+Ser_decode (sidekick.Sidekick_util.Ser_decode)
      Module Sidekick_util.Ser_decode
      Decoders for Ser_value.
      Combinators to decode values.
      module Error : sig ... end
      Errors
      Main combinators
      type +'a t
      Decode a value of type 'a
      val int : int t
      val bool : bool t
      val string : string t
      val return : 'a -> 'a t
      val return_result : ('a, string) Stdlib.result -> 'a t
      val return_result_err : ('a, Error.t) Stdlib.result -> 'a t
      val delay : (unit -> 'a t) -> 'a t
      val fail : string -> 'a t
      val failf : ('a, Stdlib.Format.formatter, unit, 'b t) Stdlib.format4 -> 'a
      val fail_err : Error.t -> 'a t
      val unwrap_opt : string -> 'a option -> 'a t
      Unwrap option, or fail
      val any : Ser_value.t t
      val list : 'a t -> 'a list t
      val tup2 : 'a t -> 'b t -> ('a * 'b) t
      val tup3 : 'a t -> 'b t -> 'c t -> ('a * 'b * 'c) t
      val tup4 : 'a t -> 'b t -> 'c t -> 'd t -> ('a * 'b * 'c * 'd) t
      val dict_field : string -> 'a t -> 'a t
      val dict_field_opt : string -> 'a t -> 'a option t
      val dict_field_or : 'a -> string -> 'a t -> 'a t
      val both : 'a t -> 'b t -> ('a * 'b) t
      val reflect : 'a t -> Ser_value.t -> ('a, Error.t) Stdlib.result t
      reflect dec v returns the result of decoding v with dec
      val reflect_or_fail : 'a t -> Ser_value.t -> 'a t
      val try_l : 'a t list -> 'a t
      try_l fs tries each f in fs turn by turn, until one succeeds
      module Infix : sig ... end
      include module type of Infix
      val (>|=) : 'a t -> ('a -> 'b) -> 'b t
      val (>>=) : 'a t -> ('a -> 'b t) -> 'b t
      val let+ : 'a t -> ('a -> 'b) -> 'b t
      val and+ : 'a t -> 'b t -> ('a * 'b) t
      val let* : 'a t -> ('a -> 'b t) -> 'b t
      val and* : 'a t -> 'b t -> ('a * 'b) t
      Deserializing
      val run : 'a t -> Ser_value.t -> ('a, Error.t) Stdlib.result
      val run_exn : 'a t -> Ser_value.t -> 'a
      • raises Error.Error 
        in case of failure
      
diff --git a/dev/sidekick/Sidekick_util/Ser_value/index.html b/dev/sidekick/Sidekick_util/Ser_value/index.html
index db074203..fc3a19d9 100644
--- a/dev/sidekick/Sidekick_util/Ser_value/index.html
+++ b/dev/sidekick/Sidekick_util/Ser_value/index.html
@@ -1,2 +1,2 @@
 
-Ser_value (sidekick.Sidekick_util.Ser_value)
      Module Sidekick_util.Ser_value
      Serialization representation.
      A Ser_value.t describes how to serialized some structured data into bytes. It reflects the shape of the structured data but does not commit to a particular serialization format.
      type t = private 
      1. | Null
      2. | Bool of bool
      3. | Str of string
      4. | Bytes of string
      5. | Int of int
      6. | List of t list
      val null : t
      val bool : bool -> t
      val int : int -> t
      val string : string -> t
      val bytes : string -> t
      val list : t list -> t
      val dict : t Sidekick_util__.Util.Str_map.t -> t
      val dict_of_list : (string * t) list -> t
      val is_null : t -> bool
      include Sidekick_sigs.PRINT with type t := t
      
+Ser_value (sidekick.Sidekick_util.Ser_value)
      Module Sidekick_util.Ser_value
      Serialization representation.
      A Ser_value.t describes how to serialized some structured data into bytes. It reflects the shape of the structured data but does not commit to a particular serialization format.
      type t = private 
      1. | Null
      2. | Bool of bool
      3. | Str of string
      4. | Bytes of string
      5. | Int of int
      6. | List of t list
      val null : t
      val bool : bool -> t
      val int : int -> t
      val string : string -> t
      val bytes : string -> t
      val list : t list -> t
      val dict : t Sidekick_util__.Util.Str_map.t -> t
      val dict_of_list : (string * t) list -> t
      val is_null : t -> bool
      include Sidekick_sigs.PRINT with type t := t
      
diff --git a/dev/sidekick/Sidekick_util/Stat/index.html b/dev/sidekick/Sidekick_util/Stat/index.html
index 267621bc..66a11838 100644
--- a/dev/sidekick/Sidekick_util/Stat/index.html
+++ b/dev/sidekick/Sidekick_util/Stat/index.html
@@ -1,2 +1,2 @@
 
-Stat (sidekick.Sidekick_util.Stat)
      Module Sidekick_util.Stat
      Statistics
      module Fmt = CCFormat
      type t
      val create : unit -> t
      type 'a counter
      val mk_int : t -> string -> int counter
      val mk_float : t -> string -> float counter
      val incr : int counter -> unit
      val incr_f : float counter -> float -> unit
      val set : 'a counter -> 'a -> unit
      type ex_counter
      Existential counter
      val all : t -> ex_counter Iter.t
      val pp_counters : ex_counter Iter.t Fmt.printer
      val pp : t Fmt.printer
      val global : t
      Global statistics, by default
      
+Stat (sidekick.Sidekick_util.Stat)
      Module Sidekick_util.Stat
      Statistics
      module Fmt = CCFormat
      type t
      val create : unit -> t
      type 'a counter
      val mk_int : t -> string -> int counter
      val mk_float : t -> string -> float counter
      val incr : int counter -> unit
      val incr_f : float counter -> float -> unit
      val set : 'a counter -> 'a -> unit
      type ex_counter
      Existential counter
      val all : t -> ex_counter Iter.t
      val pp_counters : ex_counter Iter.t Fmt.printer
      val pp : t Fmt.printer
      val global : t
      Global statistics, by default
      
diff --git a/dev/sidekick/Sidekick_util/Util/index.html b/dev/sidekick/Sidekick_util/Util/index.html
index 9658d102..f1362227 100644
--- a/dev/sidekick/Sidekick_util/Util/index.html
+++ b/dev/sidekick/Sidekick_util/Util/index.html
@@ -1,2 +1,2 @@
 
-Util (sidekick.Sidekick_util.Util)
      Module Sidekick_util.Util
      Utils
      type 'a printer = 'a CCFormat.printer
      val pp_list : ?sep:string -> 'a printer -> 'a list printer
      val pp_iter : ?sep:string -> 'a printer -> 'a Iter.t printer
      val pp_array : ?sep:string -> 'a printer -> 'a array printer
      val pp_pair : ?sep:string -> 'a printer -> 'b printer -> ('a * 'b) printer
      val flat_map_l_arr : ('a -> 'b array) -> 'a list -> 'b list
      val array_of_list_map : ('a -> 'b) -> 'a list -> 'b array
      array_of_list_map f l is the same as Array.of_list @@ List.map f l
      val array_to_list_map : ('a -> 'b) -> 'a array -> 'b list
      val lazy_map : ('a -> 'b) -> 'a lazy_t -> 'b lazy_t
      val lazy_map2 : ('a -> 'b -> 'c) -> 'a lazy_t -> 'b lazy_t -> 'c lazy_t
      val array_iteri2 : f:(int -> 'a -> 'b -> unit) -> 'a array -> 'b array -> unit
      val setup_gc : unit -> unit
      Change parameters of the GC
      module Int_set : CCSet.S with type elt = int
      module Int_map : CCMap.S with type key = int
      module Int_tbl : CCHashtbl.S with type key = int
      module Str_tbl : CCHashtbl.S with type key = string
      module Str_map : CCMap.S with type key = string
      
+Util (sidekick.Sidekick_util.Util)
      Module Sidekick_util.Util
      Utils
      type 'a printer = 'a CCFormat.printer
      val pp_list : ?sep:string -> 'a printer -> 'a list printer
      val pp_iter : ?sep:string -> 'a printer -> 'a Iter.t printer
      val pp_array : ?sep:string -> 'a printer -> 'a array printer
      val pp_pair : ?sep:string -> 'a printer -> 'b printer -> ('a * 'b) printer
      val flat_map_l_arr : ('a -> 'b array) -> 'a list -> 'b list
      val array_of_list_map : ('a -> 'b) -> 'a list -> 'b array
      array_of_list_map f l is the same as Array.of_list @@ List.map f l
      val array_to_list_map : ('a -> 'b) -> 'a array -> 'b list
      val lazy_map : ('a -> 'b) -> 'a lazy_t -> 'b lazy_t
      val lazy_map2 : ('a -> 'b -> 'c) -> 'a lazy_t -> 'b lazy_t -> 'c lazy_t
      val array_iteri2 : f:(int -> 'a -> 'b -> unit) -> 'a array -> 'b array -> unit
      val setup_gc : unit -> unit
      Change parameters of the GC
      module Int_set : CCSet.S with type elt = int
      module Int_map : CCMap.S with type key = int
      module Int_tbl : CCHashtbl.S with type key = int
      module Str_tbl : CCHashtbl.S with type key = string
      module Str_map : CCMap.S with type key = string
      
diff --git a/dev/sidekick/Sidekick_util/Vec/index.html b/dev/sidekick/Sidekick_util/Vec/index.html
index ec4c3971..b702fef8 100644
--- a/dev/sidekick/Sidekick_util/Vec/index.html
+++ b/dev/sidekick/Sidekick_util/Vec/index.html
@@ -1,5 +1,5 @@
 
-Vec (sidekick.Sidekick_util.Vec)
      Module Sidekick_util.Vec
      Vectors
      A resizable array, workhorse of imperative programming :-). This implementation originated in alt-ergo-zero but has been basically rewritten from scratch several times since.
      type 'a t
      Abstract type of vectors of 'a
      val make : int -> 'a -> 'a t
      make cap dummy creates a new vector filled with dummy. The vector is initially empty but its underlying array has capacity cap. dummy will stay alive as long as the vector
      val create : unit -> 'a t
      val to_list : 'a t -> 'a list
      Returns the list of elements of the vector
      val to_array : 'a t -> 'a array
      val of_list : 'a list -> 'a t
      val clear : 'a t -> unit
      Set size to 0, doesn't free elements
      val ensure_size : 'a t -> elt:'a -> int -> unit
      ensure size is at least n
      val ensure_size_with : 'a t -> (unit -> 'a) -> int -> unit
      ensure size is at least n
      val shrink : 'a t -> int -> unit
      shrink vec sz resets size of vec to sz. Assumes sz >=0 && sz <= size vec
      val pop_exn : 'a t -> 'a
      Pop last element and return it.
      • raises Invalid_argument 
        if the vector is empty
      val pop : 'a t -> 'a option
      val size : 'a t -> int
      val is_empty : 'a t -> bool
      val is_full : 'a t -> bool
      Is the capacity of the vector equal to the number of its elements?
      val push : 'a t -> 'a -> unit
      Push element into the vector
      val get : 'a t -> int -> 'a
      get the element at the given index, or
      • raises Invalid_argument 
        if the index is not valid
      val set : 'a t -> int -> 'a -> unit
      set the element at the given index, either already set or the first free slot if not (is_full vec), or
      • raises Invalid_argument 
        if the index is not valid
      val copy : 'a t -> 'a t
      Fresh copy
      val fast_remove : 'a t -> int -> unit
      Remove element at index i without preserving order (swap with last element)
      val append : into:'a t -> 'a t -> unit
      append ~into v pushes elements of v in the vector into
      val prepend : 'a t -> into:'a t -> unit
      prepend v ~into pushes all elements of v into into, at the beginning. consumes v.
      val filter_in_place : ('a -> bool) -> 'a t -> unit
      filter_in_place f v removes from v the elements that do not satisfy f
      val sort : 'a t -> ('a -> 'a -> int) -> unit
      Sort in place the array
      val iter : f:('a -> unit) -> 'a t -> unit
      Iterate on elements
      val rev_iter : f:('a -> unit) -> 'a t -> unit
      val to_iter : 'a t -> 'a Iter.t
      val iteri : f:(int -> 'a -> unit) -> 'a t -> unit
      Iterate on elements with their index
      val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b
      Fold over elements
      val exists : ('a -> bool) -> 'a t -> bool
      Does there exist an element that satisfies the predicate?
      val for_all : ('a -> bool) -> 'a t -> bool
      Do all elements satisfy the predicate?
      val pp : 
+Vec (sidekick.Sidekick_util.Vec)
      Module Sidekick_util.Vec
      Vectors
      A resizable array, workhorse of imperative programming :-). This implementation originated in alt-ergo-zero but has been basically rewritten from scratch several times since.
      type 'a t
      Abstract type of vectors of 'a
      val make : int -> 'a -> 'a t
      make cap dummy creates a new vector filled with dummy. The vector is initially empty but its underlying array has capacity cap. dummy will stay alive as long as the vector
      val create : unit -> 'a t
      val to_list : 'a t -> 'a list
      Returns the list of elements of the vector
      val to_array : 'a t -> 'a array
      val of_list : 'a list -> 'a t
      val clear : 'a t -> unit
      Set size to 0, doesn't free elements
      val ensure_size : 'a t -> elt:'a -> int -> unit
      ensure size is at least n
      val ensure_size_with : 'a t -> (unit -> 'a) -> int -> unit
      ensure size is at least n
      val shrink : 'a t -> int -> unit
      shrink vec sz resets size of vec to sz. Assumes sz >=0 && sz <= size vec
      val pop_exn : 'a t -> 'a
      Pop last element and return it.
      • raises Invalid_argument 
        if the vector is empty
      val pop : 'a t -> 'a option
      val size : 'a t -> int
      val is_empty : 'a t -> bool
      val is_full : 'a t -> bool
      Is the capacity of the vector equal to the number of its elements?
      val push : 'a t -> 'a -> unit
      Push element into the vector
      val get : 'a t -> int -> 'a
      get the element at the given index, or
      • raises Invalid_argument 
        if the index is not valid
      val set : 'a t -> int -> 'a -> unit
      set the element at the given index, either already set or the first free slot if not (is_full vec), or
      • raises Invalid_argument 
        if the index is not valid
      val copy : 'a t -> 'a t
      Fresh copy
      val fast_remove : 'a t -> int -> unit
      Remove element at index i without preserving order (swap with last element)
      val append : into:'a t -> 'a t -> unit
      append ~into v pushes elements of v in the vector into
      val prepend : 'a t -> into:'a t -> unit
      prepend v ~into pushes all elements of v into into, at the beginning. consumes v.
      val filter_in_place : ('a -> bool) -> 'a t -> unit
      filter_in_place f v removes from v the elements that do not satisfy f
      val sort : 'a t -> ('a -> 'a -> int) -> unit
      Sort in place the array
      val iter : f:('a -> unit) -> 'a t -> unit
      Iterate on elements
      val rev_iter : f:('a -> unit) -> 'a t -> unit
      val to_iter : 'a t -> 'a Iter.t
      val iteri : f:(int -> 'a -> unit) -> 'a t -> unit
      Iterate on elements with their index
      val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b
      Fold over elements
      val exists : ('a -> bool) -> 'a t -> bool
      Does there exist an element that satisfies the predicate?
      val for_all : ('a -> bool) -> 'a t -> bool
      Do all elements satisfy the predicate?
      val pp : 
   ?sep:string ->
   (Stdlib.Format.formatter -> 'a -> unit) ->
   Stdlib.Format.formatter ->
diff --git a/dev/sidekick/Sidekick_util/Vec_float/index.html b/dev/sidekick/Sidekick_util/Vec_float/index.html
index 28299c6b..507a55d1 100644
--- a/dev/sidekick/Sidekick_util/Vec_float/index.html
+++ b/dev/sidekick/Sidekick_util/Vec_float/index.html
@@ -1,2 +1,2 @@
 
-Vec_float (sidekick.Sidekick_util.Vec_float)
      Module Sidekick_util.Vec_float
      Vectors of floats
      These vectors are more optimized than Vec.
      include Vec_sig.S with type elt := float
      include Vec_sig.BASE with type elt := float
      include Vec_sig.BASE_RO with type elt := float
      type t
      val size : t -> int
      val get : t -> int -> float
      val iter : f:(float -> unit) -> t -> unit
      val iteri : f:(int -> float -> unit) -> t -> unit
      val to_iter : t -> float Iter.t
      val create : ?cap:int -> unit -> t
      val clear : t -> unit
      val copy : t -> t
      val is_empty : t -> bool
      val push : t -> float -> unit
      val fast_remove : t -> int -> unit
      Remove element at index i without preserving order (swap with last element)
      val filter_in_place : (float -> bool) -> t -> unit
      val ensure_size : t -> int -> unit
      val pop : t -> float
      val set : t -> int -> float -> unit
      val shrink : t -> int -> unit
      include Vec_sig.EXTENSIONS with type t := t and type elt := float
      val to_array : t -> float array
      val fold_left : ('a -> float -> 'a) -> 'a -> t -> 'a
      val pp : float CCFormat.printer -> t CCFormat.printer
      
+Vec_float (sidekick.Sidekick_util.Vec_float)
      Module Sidekick_util.Vec_float
      Vectors of floats
      These vectors are more optimized than Vec.
      include Vec_sig.S with type elt := float
      include Vec_sig.BASE with type elt := float
      include Vec_sig.BASE_RO with type elt := float
      type t
      val size : t -> int
      val get : t -> int -> float
      val iter : f:(float -> unit) -> t -> unit
      val iteri : f:(int -> float -> unit) -> t -> unit
      val to_iter : t -> float Iter.t
      val create : ?cap:int -> unit -> t
      val clear : t -> unit
      val copy : t -> t
      val is_empty : t -> bool
      val push : t -> float -> unit
      val fast_remove : t -> int -> unit
      Remove element at index i without preserving order (swap with last element)
      val filter_in_place : (float -> bool) -> t -> unit
      val ensure_size : t -> int -> unit
      val pop : t -> float
      val set : t -> int -> float -> unit
      val shrink : t -> int -> unit
      include Vec_sig.EXTENSIONS with type t := t and type elt := float
      val to_array : t -> float array
      val fold_left : ('a -> float -> 'a) -> 'a -> t -> 'a
      val pp : float CCFormat.printer -> t CCFormat.printer
      
diff --git a/dev/sidekick/Sidekick_util/Vec_sig/Make_extensions/argument-1-B/index.html b/dev/sidekick/Sidekick_util/Vec_sig/Make_extensions/argument-1-B/index.html
index 2eb6ea48..df95ee72 100644
--- a/dev/sidekick/Sidekick_util/Vec_sig/Make_extensions/argument-1-B/index.html
+++ b/dev/sidekick/Sidekick_util/Vec_sig/Make_extensions/argument-1-B/index.html
@@ -1,2 +1,2 @@
 
-B (sidekick.Sidekick_util.Vec_sig.Make_extensions.B)
      Parameter Make_extensions.B
      type elt
      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 to_iter : t -> elt Iter.t
      
+B (sidekick.Sidekick_util.Vec_sig.Make_extensions.B)
      Parameter Make_extensions.B
      type elt
      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 to_iter : t -> elt Iter.t
      
diff --git a/dev/sidekick/Sidekick_util/Vec_sig/Make_extensions/index.html b/dev/sidekick/Sidekick_util/Vec_sig/Make_extensions/index.html
index 7e027707..3fd2e2a4 100644
--- a/dev/sidekick/Sidekick_util/Vec_sig/Make_extensions/index.html
+++ b/dev/sidekick/Sidekick_util/Vec_sig/Make_extensions/index.html
@@ -1,2 +1,2 @@
 
-Make_extensions (sidekick.Sidekick_util.Vec_sig.Make_extensions)
      Module Vec_sig.Make_extensions
      Parameters
      module B : BASE_RO
      Signature
      val to_array : B.t -> B.elt array
      val fold_left : ('a -> B.elt -> 'a) -> 'a -> B.t -> 'a
      val pp : B.elt CCFormat.printer -> B.t CCFormat.printer
      
+Make_extensions (sidekick.Sidekick_util.Vec_sig.Make_extensions)
      Module Vec_sig.Make_extensions
      Parameters
      module B : BASE_RO
      Signature
      val to_array : B.t -> B.elt array
      val fold_left : ('a -> B.elt -> 'a) -> 'a -> B.t -> 'a
      val pp : B.elt CCFormat.printer -> B.t CCFormat.printer
      
diff --git a/dev/sidekick/Sidekick_util/Vec_sig/index.html b/dev/sidekick/Sidekick_util/Vec_sig/index.html
index 88b37059..42ee6832 100644
--- a/dev/sidekick/Sidekick_util/Vec_sig/index.html
+++ b/dev/sidekick/Sidekick_util/Vec_sig/index.html
@@ -1,4 +1,4 @@
 
-Vec_sig (sidekick.Sidekick_util.Vec_sig)
      Module Sidekick_util.Vec_sig
      module type BASE_RO = sig ... end
      Basics
      module type BASE = sig ... end
      module type EXTENSIONS = sig ... end
      module type S = sig ... end
      module Make_extensions
+Vec_sig (sidekick.Sidekick_util.Vec_sig)
      Module Sidekick_util.Vec_sig
      module type BASE_RO = sig ... end
      Basics
      module type BASE = sig ... end
      module type EXTENSIONS = sig ... end
      module type S = sig ... end
      module Make_extensions
   (B : BASE_RO) : 
   EXTENSIONS with type t := B.t and type elt := B.elt
      
diff --git a/dev/sidekick/Sidekick_util/Vec_sig/module-type-BASE/index.html b/dev/sidekick/Sidekick_util/Vec_sig/module-type-BASE/index.html
index 0b62ad16..5f06f37f 100644
--- a/dev/sidekick/Sidekick_util/Vec_sig/module-type-BASE/index.html
+++ b/dev/sidekick/Sidekick_util/Vec_sig/module-type-BASE/index.html
@@ -1,2 +1,2 @@
 
-BASE (sidekick.Sidekick_util.Vec_sig.BASE)
      Module type Vec_sig.BASE
      include BASE_RO
      type elt
      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 to_iter : t -> elt Iter.t
      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
      
+BASE (sidekick.Sidekick_util.Vec_sig.BASE)
      Module type Vec_sig.BASE
      include BASE_RO
      type elt
      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 to_iter : t -> elt Iter.t
      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
      
diff --git a/dev/sidekick/Sidekick_util/Vec_sig/module-type-BASE_RO/index.html b/dev/sidekick/Sidekick_util/Vec_sig/module-type-BASE_RO/index.html
index 1c7fdfa1..75cef1ee 100644
--- a/dev/sidekick/Sidekick_util/Vec_sig/module-type-BASE_RO/index.html
+++ b/dev/sidekick/Sidekick_util/Vec_sig/module-type-BASE_RO/index.html
@@ -1,2 +1,2 @@
 
-BASE_RO (sidekick.Sidekick_util.Vec_sig.BASE_RO)
      Module type Vec_sig.BASE_RO
      Basics
      type elt
      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 to_iter : t -> elt Iter.t
      
+BASE_RO (sidekick.Sidekick_util.Vec_sig.BASE_RO)
      Module type Vec_sig.BASE_RO
      Basics
      type elt
      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 to_iter : t -> elt Iter.t
      
diff --git a/dev/sidekick/Sidekick_util/Vec_sig/module-type-EXTENSIONS/index.html b/dev/sidekick/Sidekick_util/Vec_sig/module-type-EXTENSIONS/index.html
index 9bd94fe3..a523f3c5 100644
--- a/dev/sidekick/Sidekick_util/Vec_sig/module-type-EXTENSIONS/index.html
+++ b/dev/sidekick/Sidekick_util/Vec_sig/module-type-EXTENSIONS/index.html
@@ -1,2 +1,2 @@
 
-EXTENSIONS (sidekick.Sidekick_util.Vec_sig.EXTENSIONS)
      Module type Vec_sig.EXTENSIONS
      type elt
      type t
      val to_array : t -> elt array
      val fold_left : ('a -> elt -> 'a) -> 'a -> t -> 'a
      val pp : elt CCFormat.printer -> t CCFormat.printer
      
+EXTENSIONS (sidekick.Sidekick_util.Vec_sig.EXTENSIONS)
      Module type Vec_sig.EXTENSIONS
      type elt
      type t
      val to_array : t -> elt array
      val fold_left : ('a -> elt -> 'a) -> 'a -> t -> 'a
      val pp : elt CCFormat.printer -> t CCFormat.printer
      
diff --git a/dev/sidekick/Sidekick_util/Vec_sig/module-type-S/index.html b/dev/sidekick/Sidekick_util/Vec_sig/module-type-S/index.html
index ca7c50ec..809a6fc9 100644
--- a/dev/sidekick/Sidekick_util/Vec_sig/module-type-S/index.html
+++ b/dev/sidekick/Sidekick_util/Vec_sig/module-type-S/index.html
@@ -1,2 +1,2 @@
 
-S (sidekick.Sidekick_util.Vec_sig.S)
      Module type Vec_sig.S
      include BASE
      include BASE_RO
      type elt
      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 to_iter : t -> elt Iter.t
      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 EXTENSIONS with type t := t and type elt := elt
      val to_array : t -> elt array
      val fold_left : ('a -> elt -> 'a) -> 'a -> t -> 'a
      val pp : elt CCFormat.printer -> t CCFormat.printer
      
+S (sidekick.Sidekick_util.Vec_sig.S)
      Module type Vec_sig.S
      include BASE
      include BASE_RO
      type elt
      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 to_iter : t -> elt Iter.t
      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 EXTENSIONS with type t := t and type elt := elt
      val to_array : t -> elt array
      val fold_left : ('a -> elt -> 'a) -> 'a -> t -> 'a
      val pp : elt CCFormat.printer -> t CCFormat.printer
      
diff --git a/dev/sidekick/Sidekick_util/Veci/index.html b/dev/sidekick/Sidekick_util/Veci/index.html
index 2d108cb3..b6d0f01a 100644
--- a/dev/sidekick/Sidekick_util/Veci/index.html
+++ b/dev/sidekick/Sidekick_util/Veci/index.html
@@ -1,2 +1,2 @@
 
-Veci (sidekick.Sidekick_util.Veci)
      Module Sidekick_util.Veci
      Vectors of int32 integers
      These vectors are more optimized than Vec.
      include Vec_sig.S with type elt := int
      include Vec_sig.BASE with type elt := int
      include Vec_sig.BASE_RO with type elt := int
      type t
      val size : t -> int
      val get : t -> int -> int
      val iter : f:(int -> unit) -> t -> unit
      val iteri : f:(int -> int -> unit) -> t -> unit
      val to_iter : t -> int Iter.t
      val create : ?cap:int -> unit -> t
      val clear : t -> unit
      val copy : t -> t
      val is_empty : t -> bool
      val push : t -> int -> unit
      val fast_remove : t -> int -> unit
      Remove element at index i without preserving order (swap with last element)
      val filter_in_place : (int -> bool) -> t -> unit
      val ensure_size : t -> int -> unit
      val pop : t -> int
      val set : t -> int -> int -> unit
      val shrink : t -> int -> unit
      include Vec_sig.EXTENSIONS with type t := t and type elt := int
      val to_array : t -> int array
      val fold_left : ('a -> int -> 'a) -> 'a -> t -> 'a
      val pp : int CCFormat.printer -> t CCFormat.printer
      val push_i32 : t -> int32 -> unit
      val get_i32 : t -> int -> int32
      val set_i32 : t -> int -> int32 -> unit
      
+Veci (sidekick.Sidekick_util.Veci)
      Module Sidekick_util.Veci
      Vectors of int32 integers
      These vectors are more optimized than Vec.
      include Vec_sig.S with type elt := int
      include Vec_sig.BASE with type elt := int
      include Vec_sig.BASE_RO with type elt := int
      type t
      val size : t -> int
      val get : t -> int -> int
      val iter : f:(int -> unit) -> t -> unit
      val iteri : f:(int -> int -> unit) -> t -> unit
      val to_iter : t -> int Iter.t
      val create : ?cap:int -> unit -> t
      val clear : t -> unit
      val copy : t -> t
      val is_empty : t -> bool
      val push : t -> int -> unit
      val fast_remove : t -> int -> unit
      Remove element at index i without preserving order (swap with last element)
      val filter_in_place : (int -> bool) -> t -> unit
      val ensure_size : t -> int -> unit
      val pop : t -> int
      val set : t -> int -> int -> unit
      val shrink : t -> int -> unit
      include Vec_sig.EXTENSIONS with type t := t and type elt := int
      val to_array : t -> int array
      val fold_left : ('a -> int -> 'a) -> 'a -> t -> 'a
      val pp : int CCFormat.printer -> t CCFormat.printer
      val push_i32 : t -> int32 -> unit
      val get_i32 : t -> int -> int32
      val set_i32 : t -> int -> int32 -> unit
      
diff --git a/dev/sidekick/Sidekick_util/index.html b/dev/sidekick/Sidekick_util/index.html
index da1e18c4..06b4085d 100644
--- a/dev/sidekick/Sidekick_util/index.html
+++ b/dev/sidekick/Sidekick_util/index.html
@@ -1,2 +1,2 @@
 
-Sidekick_util (sidekick.Sidekick_util)
      Module Sidekick_util
      module Fmt = CCFormat
      module Util : sig ... end
      module Vec : sig ... end
      Vectors
      module Veci : sig ... end
      Vectors of int32 integers
      module Vec_float : sig ... end
      Vectors of floats
      module Vec_sig : sig ... end
      module Bitvec : sig ... end
      Bitvector.
      module Int_id : sig ... end
      Integer-based identifiers.
      module Int_tbl = Util.Int_tbl
      module Int_set = Util.Int_set
      module Int_map = Util.Int_map
      module Event : sig ... end
      Event pattern.
      module Backtrack_stack : sig ... end
      module Backtrackable_tbl : sig ... end
      module Backtrackable_ref : sig ... end
      module Log : sig ... end
      Logging function, for debugging
      module Error : sig ... end
      module Bag : sig ... end
      module Stat : sig ... end
      module Hash : sig ... end
      module Profile : sig ... end
      module Chunk_stack : sig ... end
      Manage a list of chunks.
      module Ser_value : sig ... end
      Serialization representation.
      module Ser_decode : sig ... end
      Decoders for Ser_value.
      val let@ : ('a -> 'b) -> 'a -> 'b
      
+Sidekick_util (sidekick.Sidekick_util)
      Module Sidekick_util
      module Fmt = CCFormat
      module Util : sig ... end
      module Vec : sig ... end
      Vectors
      module Veci : sig ... end
      Vectors of int32 integers
      module Vec_float : sig ... end
      Vectors of floats
      module Vec_sig : sig ... end
      module Bitvec : sig ... end
      Bitvector.
      module Int_id : sig ... end
      Integer-based identifiers.
      module Int_tbl = Util.Int_tbl
      module Int_set = Util.Int_set
      module Int_map = Util.Int_map
      module Event : sig ... end
      Event pattern.
      module Backtrack_stack : sig ... end
      module Backtrackable_tbl : sig ... end
      module Backtrackable_ref : sig ... end
      module Log : sig ... end
      Logging function, for debugging
      module Error : sig ... end
      module Bag : sig ... end
      module Stat : sig ... end
      module Hash : sig ... end
      module Profile : sig ... end
      module Chunk_stack : sig ... end
      Manage a list of chunks.
      module Ser_value : sig ... end
      Serialization representation.
      module Ser_decode : sig ... end
      Decoders for Ser_value.
      val let@ : ('a -> 'b) -> 'a -> 'b
      
diff --git a/dev/sidekick/Sidekick_zarith/Int/index.html b/dev/sidekick/Sidekick_zarith/Int/index.html
index a4e5ad8a..b412bdc9 100644
--- a/dev/sidekick/Sidekick_zarith/Int/index.html
+++ b/dev/sidekick/Sidekick_zarith/Int/index.html
@@ -1,2 +1,2 @@
 
-Int (sidekick.Sidekick_zarith.Int)
      Module Sidekick_zarith.Int
      include Sidekick_arith.INT with type t = Z.t
      include Sidekick_arith.NUM with type t = Z.t
      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 to_string : t -> string
      val of_string : string -> t option
      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 (+) : 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
      
+Int (sidekick.Sidekick_zarith.Int)
      Module Sidekick_zarith.Int
      include Sidekick_arith.INT with type t = Z.t
      include Sidekick_arith.NUM with type t = Z.t
      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 to_string : t -> string
      val of_string : string -> t option
      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 (+) : 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
      
diff --git a/dev/sidekick/Sidekick_zarith/Rational/index.html b/dev/sidekick/Sidekick_zarith/Rational/index.html
index 47ba662b..7e8290bb 100644
--- a/dev/sidekick/Sidekick_zarith/Rational/index.html
+++ b/dev/sidekick/Sidekick_zarith/Rational/index.html
@@ -1,2 +1,2 @@
 
-Rational (sidekick.Sidekick_zarith.Rational)
      Module Sidekick_zarith.Rational
      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
      val to_string : t -> string
      val of_string : string -> t option
      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 (+) : 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)
      
+Rational (sidekick.Sidekick_zarith.Rational)
      Module Sidekick_zarith.Rational
      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
      val to_string : t -> string
      val of_string : string -> t option
      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 (+) : 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)
      
diff --git a/dev/sidekick/Sidekick_zarith/index.html b/dev/sidekick/Sidekick_zarith/index.html
index a640021c..30b52bf7 100644
--- a/dev/sidekick/Sidekick_zarith/index.html
+++ b/dev/sidekick/Sidekick_zarith/index.html
@@ -1,3 +1,3 @@
 
-Sidekick_zarith (sidekick.Sidekick_zarith)
      Module Sidekick_zarith
      module Int : Sidekick_arith.INT_FULL with type t = Z.t
      module Rational : 
+Sidekick_zarith (sidekick.Sidekick_zarith)
      Module Sidekick_zarith
      module Int : Sidekick_arith.INT_FULL with type t = Z.t
      module Rational : 
   Sidekick_arith.RATIONAL with type t = Q.t and type bigint = Z.t
      
diff --git a/dev/sidekick/index.html b/dev/sidekick/index.html
index 541bb585..ed8c6fb1 100644
--- a/dev/sidekick/index.html
+++ b/dev/sidekick/index.html
@@ -1,2 +1,2 @@
 
-index (sidekick.index)
      sidekick index
      Library sidekick.abstract-solver
      The entry point of this library is the module: Sidekick_abstract_solver.
      Library sidekick.arith
      The entry point of this library is the module: Sidekick_arith.
      Library sidekick.bencode
      The entry point of this library is the module: Sidekick_bencode.
      Library sidekick.cc
      The entry point of this library is the module: Sidekick_cc.
      Library sidekick.cc.plugin
      The entry point of this library is the module: Sidekick_cc_plugin.
      Library sidekick.core
      The entry point of this library is the module: Sidekick_core.
      Library sidekick.core-logic
      The entry point of this library is the module: Sidekick_core_logic.
      Library sidekick.drup
      The entry point of this library is the module: Sidekick_drup.
      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.proof
      The entry point of this library is the module: Sidekick_proof.
      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.simplify
      The entry point of this library is the module: Sidekick_simplify.
      Library sidekick.smt-solver
      The entry point of this library is the module: Sidekick_smt_solver.
      Library sidekick.th-bool-dyn
      The entry point of this library is the module: Sidekick_th_bool_dyn.
      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.th-lra
      The entry point of this library is the module: Sidekick_th_lra.
      Library sidekick.th-ty-unin
      The entry point of this library is the module: Sidekick_th_ty_unin.
      Library sidekick.trace
      The entry point of this library is the module: Sidekick_trace.
      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.
      
+index (sidekick.index)
      sidekick index
      Library sidekick.abstract-solver
      The entry point of this library is the module: Sidekick_abstract_solver.
      Library sidekick.arith
      The entry point of this library is the module: Sidekick_arith.
      Library sidekick.bencode
      The entry point of this library is the module: Sidekick_bencode.
      Library sidekick.cc
      The entry point of this library is the module: Sidekick_cc.
      Library sidekick.cc.plugin
      The entry point of this library is the module: Sidekick_cc_plugin.
      Library sidekick.core
      The entry point of this library is the module: Sidekick_core.
      Library sidekick.core-logic
      The entry point of this library is the module: Sidekick_core_logic.
      Library sidekick.drup
      The entry point of this library is the module: Sidekick_drup.
      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.proof
      The entry point of this library is the module: Sidekick_proof.
      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.simplify
      The entry point of this library is the module: Sidekick_simplify.
      Library sidekick.smt-solver
      The entry point of this library is the module: Sidekick_smt_solver.
      Library sidekick.th-bool-dyn
      The entry point of this library is the module: Sidekick_th_bool_dyn.
      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.th-lra
      The entry point of this library is the module: Sidekick_th_lra.
      Library sidekick.th-ty-unin
      The entry point of this library is the module: Sidekick_th_ty_unin.
      Library sidekick.trace
      The entry point of this library is the module: Sidekick_trace.
      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.