move form to sidekick_base; rename {Term,Ty}.state into store

src/base-solver/sidekick_base_solver.ml

@@ -7,8 +7,6 @@
 
 open Sidekick_base
 
-module Form = Form
-
 (** Argument to the SMT solver *)
 module Solver_arg = struct
   module T = Sidekick_base
@@ -98,7 +96,7 @@ module Th_lra = Sidekick_arith_lra.Make(struct
 
   module Gensym = struct
     type t = {
-      tst: T.state;
+      tst: T.store;
       mutable fresh: int;
     }
 

src/base/Base_types.ml

@@ -270,7 +270,7 @@ let pp_term_view = pp_term_view_gen ~pp_id:ID.pp_name ~pp_t:pp_term
 (** Types *)
 module Ty : sig
   type t = ty
-  type state = unit
+  type store = unit
   type view = ty_view =
     | Ty_bool
     | Ty_real
@@ -294,8 +294,8 @@ module Ty : sig
   val id : t -> int
   val view : t -> view
 
-  val bool : state -> t
-  val real : state -> t
+  val bool : store -> t
+  val real : store -> t
   val atomic : def -> t list -> t
   val id_of_def : def -> ID.t
 
@@ -328,7 +328,7 @@ module Ty : sig
   end
 end = struct
   type t = ty
-  type state = unit
+  type store = unit
   type view = ty_view =
     | Ty_bool
     | Ty_real
@@ -792,27 +792,27 @@ module Term : sig
   val compare : t -> t -> int
   val hash : t -> int
 
-  type state
+  type store
 
-  val create : ?size:int -> unit -> state
+  val create : ?size:int -> unit -> store
 
-  val make : state -> t view -> t
-  val true_ : state -> t
-  val false_ : state -> t
-  val bool : state -> bool -> t
-  val const : state -> fun_ -> t
-  val app_fun : state -> fun_ -> t IArray.t -> t
-  val eq : state -> t -> t -> t
-  val not_ : state -> t -> t
-  val ite : state -> t -> t -> t -> t
+  val make : store -> t view -> t
+  val true_ : store -> t
+  val false_ : store -> t
+  val bool : store -> bool -> t
+  val const : store -> fun_ -> t
+  val app_fun : store -> fun_ -> t IArray.t -> t
+  val eq : store -> t -> t -> t
+  val not_ : store -> t -> t
+  val ite : store -> t -> t -> t -> t
 
-  val select : state -> select -> t -> t
-  val app_cstor : state -> cstor -> t IArray.t -> t
-  val is_a : state -> cstor -> t -> t
-  val lra : state -> (Q.t,t) lra_view -> t
+  val select : store -> select -> t -> t
+  val app_cstor : store -> cstor -> t IArray.t -> t
+  val is_a : store -> cstor -> t -> t
+  val lra : store -> (Q.t,t) lra_view -> t
 
   (** Obtain unsigned version of [t], + the sign as a boolean *)
-  val abs : state -> t -> t * bool
+  val abs : store -> t -> t * bool
 
   module Iter_dag : sig
     type t
@@ -824,7 +824,7 @@ module Term : sig
   val iter_dag_with : order:Iter_dag.order -> t -> t Iter.t
   val iter_dag : t -> t Iter.t
 
-  val map_shallow : state -> (t -> t) -> t -> t
+  val map_shallow : store -> (t -> t) -> t -> t
 
   val pp : t Fmt.printer
 
@@ -877,7 +877,7 @@ end = struct
         t.term_id <- id
     end)
 
-  type state = {
+  type store = {
     tbl : H.t;
     mutable n: int;
     true_ : t lazy_t;
@@ -896,7 +896,7 @@ end = struct
   let[@inline] false_ st = Lazy.force st.false_
   let bool st b = if b then true_ st else false_ st
 
-  let create ?(size=1024) () : state =
+  let create ?(size=1024) () : store =
     let rec st ={
       n=2;
       tbl=H.create ~size ();
@@ -920,7 +920,7 @@ end = struct
   let is_a st c t : t = app_fun st (Fun.is_a c) (IArray.singleton t)
   let app_cstor st c args : t = app_fun st (Fun.cstor c) args
 
-  let[@inline] lra (st:state) (l:(Q.t,t) lra_view) : t =
+  let[@inline] lra (st:store) (l:(Q.t,t) lra_view) : t =
     match l with
     | LRA_other x -> x (* normalize *)
     | _ -> make st (Term_cell.lra l)
@@ -930,7 +930,7 @@ end = struct
     | Bool false -> true_ tst, false
     | Not u -> u, false
     | App_fun ({fun_view=Fun_def def; _}, args) ->
-      def.abs ~self:t args (* TODO: pass state *)
+      def.abs ~self:t args (* TODO: pass store *)
     | LRA (LRA_pred (Neq, a, b)) ->
       lra tst (LRA_pred (Eq,a,b)), false (* != is just not eq *)
     | _ -> t, true
@@ -1001,7 +1001,7 @@ end = struct
 
   let iter_dag t yield = iter_dag_with ~order:Pre t yield
 
-  let map_shallow (tst:state) f (t:t) : t =
+  let map_shallow (tst:store) f (t:t) : t =
     match view t with
     | Bool _ -> t
     | App_fun (hd, a) -> app_fun tst hd (IArray.map f a)

src/base/Form.ml

@@ -8,10 +8,13 @@
     the formulas are turned into clauses automatically for you.
 *)
 
-open Sidekick_base
+module T = Base_types.Term
+module Ty = Base_types.Ty
+module Fun = Base_types.Fun
+module Value = Base_types.Value
 
-module T = Term
 open Sidekick_th_bool_static
+
 exception Not_a_th_term
 
 let id_and = ID.make "and"
@@ -83,7 +86,7 @@ module Funs = struct
   let and_ = mk_fun id_and
   let or_ = mk_fun id_or
   let imply = mk_fun id_imply
-  let ite = Term.ite
+  let ite = T.ite
 end
 
 let as_id id (t:T.t) : T.t IArray.t option =
@@ -173,7 +176,7 @@ let mk_bool st = function
 
 module Gensym = struct
   type t = {
-    tst: T.state;
+    tst: T.store;
     mutable fresh: int;
   }
 

src/base/Sidekick_base.ml

@@ -30,6 +30,7 @@ module Statement = Base_types.Statement
 module Data = Base_types.Data
 module Select = Base_types.Select
 module Proof = Proof
+module Form = Form
 
 (** Concrete implementation of {!Sidekick_core.TERM}
 
@@ -41,7 +42,7 @@ module Arg
     with type Term.t = Term.t
      and type Fun.t = Fun.t
      and type Ty.t = Ty.t
-     and type Term.state = Term.state
+     and type Term.store = Term.store
 = struct
   module Term = Term
   module Fun = Fun

src/base/dune

@@ -2,6 +2,7 @@
  (name sidekick_base)
  (public_name sidekick-base)
  (synopsis "Base term definitions for the standalone SMT solver and library")
- (libraries containers sidekick.core sidekick.util sidekick.arith-lra
+ (libraries containers sidekick.core sidekick.util
+            sidekick.arith-lra sidekick.th-bool-static
             sidekick.zarith zarith)
  (flags :standard -w -32 -open Sidekick_util))

src/cc/Sidekick_cc.ml

@@ -23,7 +23,7 @@ module Make (A: CC_ARG)
   module Lit = A.Lit
   module Actions = A.Actions
   type term = T.Term.t
-  type term_state = T.Term.state
+  type term_store = T.Term.store
   type lit = Lit.t
   type fun_ = T.Fun.t
   type proof = P.t
@@ -243,7 +243,7 @@ module Make (A: CC_ARG)
     | CT_merge of node * node * explanation
 
   type t = {
-    tst: term_state;
+    tst: term_store;
     tbl: node T_tbl.t;
     (* internalization [term -> node] *)
     signatures_tbl : node Sig_tbl.t;
@@ -290,7 +290,7 @@ module Make (A: CC_ARG)
   let[@inline] n_true cc = Lazy.force cc.true_
   let[@inline] n_false cc = Lazy.force cc.false_
   let n_bool cc b = if b then n_true cc else n_false cc
-  let[@inline] term_state cc = cc.tst
+  let[@inline] term_store cc = cc.tst
   let allocate_bitfield ~descr cc =
     Log.debugf 5 (fun k->k "(@[cc.allocate-bit-field@ :descr %s@])" descr);
     Bits.mk_field cc.bitgen
@@ -907,7 +907,7 @@ module Make (A: CC_ARG)
       ?(on_pre_merge=[]) ?(on_post_merge=[]) ?(on_new_term=[])
       ?(on_conflict=[]) ?(on_propagate=[]) ?(on_is_subterm=[])
       ?(size=`Big)
-      (tst:term_state) : t =
+      (tst:term_store) : t =
     let size = match size with `Small -> 128 | `Big -> 2048 in
     let bitgen = Bits.mk_gen () in
     let field_marked_explain = Bits.mk_field bitgen in

src/core/Sidekick_core.ml

@@ -76,9 +76,9 @@ module type TERM = sig
     val hash : t -> int
     val pp : t Fmt.printer
 
-    type state
+    type store
 
-    val bool : state -> t
+    val bool : store -> t
     val is_bool : t -> bool
   end
 
@@ -94,19 +94,19 @@ module type TERM = sig
     val hash : t -> int
     val pp : t Fmt.printer
 
-    (** A state used to create new terms. It is where the hashconsing
-        table should live, along with other all-terms related state. *)
-    type state
+    (** A store used to create new terms. It is where the hashconsing
+        table should live, along with other all-terms related store. *)
+    type store
 
     val ty : t -> Ty.t
 
-    val bool : state -> bool -> t (** build true/false *)
+    val bool : store -> bool -> t (** build true/false *)
 
     val as_bool : t -> bool option
     (** [as_bool t] is [Some true] if [t] is the term [true], and similarly
         for [false]. For other terms it is [None]. *)
 
-    val abs : state -> t -> t * bool
+    val abs : store -> t -> t * bool
     (** [abs t] returns an "absolute value" for the term, along with the
         sign of [t].
 
@@ -114,9 +114,9 @@ module type TERM = sig
         or [(a != b)] into [(a=b, false)]. For terms without a negation this
         should return [(t, true)].
 
-        The state is passed in case a new term needs to be created. *)
+        The store is passed in case a new term needs to be created. *)
 
-    val map_shallow : state -> (t -> t) -> t -> t
+    val map_shallow : store -> (t -> t) -> t -> t
     (** Map function on immediate subterms. This should not be recursive. *)
 
     val iter_dag : t -> (t -> unit) -> unit
@@ -314,7 +314,7 @@ module type CC_S = sig
   module P : PROOF with type term = T.Term.t
   module Lit : LIT with module T = T
   module Actions : CC_ACTIONS with module T = T and module Lit = Lit and module P = P
-  type term_state = T.Term.state
+  type term_store = T.Term.store
   type term = T.Term.t
   type fun_ = T.Fun.t
   type lit = Lit.t
@@ -402,7 +402,7 @@ module type CC_S = sig
 
   (** {3 Accessors} *)
 
-  val term_state : t -> term_state
+  val term_store : t -> term_store
 
   val find : t -> node -> repr
   (** Current representative *)
@@ -459,11 +459,11 @@ module type CC_S = sig
     ?on_propagate:ev_on_propagate list ->
     ?on_is_subterm:ev_on_is_subterm list ->
     ?size:[`Small | `Big] ->
-    term_state ->
+    term_store ->
     t
   (** Create a new congruence closure.
 
-      @param term_state used to be able to create new terms. All terms
+      @param term_store used to be able to create new terms. All terms
       interacting with this congruence closure must belong in this term state
       as well. *)
 
@@ -578,16 +578,16 @@ module type SOLVER_INTERNAL = sig
 
   type ty = T.Ty.t
   type term = T.Term.t
-  type term_state = T.Term.state
-  type ty_state = T.Ty.state
+  type term_store = T.Term.store
+  type ty_store = T.Ty.store
   type proof = P.t
 
   (** {3 Main type for a solver} *)
   type t
   type solver = t
 
-  val tst : t -> term_state
-  val ty_st : t -> ty_state
+  val tst : t -> term_store
+  val ty_st : t -> ty_store
   val stats : t -> Stat.t
 
   (** {3 Actions for the theories} *)
@@ -629,8 +629,8 @@ module type SOLVER_INTERNAL = sig
   module Simplify : sig
     type t
 
-    val tst : t -> term_state
-    val ty_st : t -> ty_state
+    val tst : t -> term_store
+    val ty_st : t -> ty_store
 
     val clear : t -> unit
     (** Reset internal cache, etc. *)
@@ -952,8 +952,8 @@ module type SOLVER = sig
   (** {3 Main API} *)
 
   val stats : t -> Stat.t
-  val tst : t -> T.Term.state
-  val ty_st : t -> T.Ty.state
+  val tst : t -> T.Term.store
+  val ty_st : t -> T.Ty.store
 
   val create :
     ?stat:Stat.t ->
@@ -961,8 +961,8 @@ module type SOLVER = sig
     (* TODO? ?config:Config.t -> *)
     ?store_proof:bool ->
     theories:theory list ->
-    T.Term.state ->
-    T.Ty.state ->
+    T.Term.store ->
+    T.Ty.store ->
     unit ->
     t
   (** Create a new solver.

src/lra/sidekick_arith_lra.ml

@@ -47,14 +47,14 @@ module type ARG = sig
   val view_as_lra : term -> (Q.t, term) lra_view
   (** Project the term into the theory view *)
 
-  val mk_bool : S.T.Term.state -> bool -> term
+  val mk_bool : S.T.Term.store -> bool -> term
 
-  val mk_lra : S.T.Term.state -> (Q.t, term) lra_view -> term
+  val mk_lra : S.T.Term.store -> (Q.t, term) lra_view -> term
   (** Make a term from the given theory view *)
 
-  val ty_lra : S.T.Term.state -> ty
+  val ty_lra : S.T.Term.store -> ty
 
-  val mk_eq : S.T.Term.state -> term -> term -> term
+  val mk_eq : S.T.Term.store -> term -> term -> term
   (** syntactic equality *)
 
   val has_ty_real : term -> bool
@@ -67,9 +67,9 @@ module type ARG = sig
   module Gensym : sig
     type t
 
-    val create : S.T.Term.state -> t
+    val create : S.T.Term.store -> t
 
-    val tst : t -> S.T.Term.state
+    val tst : t -> S.T.Term.store
 
     val copy : t -> t
 
@@ -84,8 +84,8 @@ module type S = sig
   type state
 
   val create : ?stat:Stat.t ->
-    A.S.T.Term.state ->
-    A.S.T.Ty.state ->
+    A.S.T.Term.store ->
+    A.S.T.Ty.store ->
     state
 
   val theory : A.S.theory
@@ -141,8 +141,8 @@ module Make(A : ARG) : S with module A = A = struct
   module Comb_map = CCMap.Make(LE_.Comb)
 
   type state = {
-    tst: T.state;
-    ty_st: Ty.state;
+    tst: T.store;
+    ty_st: Ty.store;
     simps: T.t T.Tbl.t; (* cache *)
     gensym: A.Gensym.t;
     encoded_eqs: unit T.Tbl.t; (* [a=b] gets clause [a = b <=> (a >= b /\ a <= b)] *)

src/mini-cc/Sidekick_mini_cc.ml

@@ -9,11 +9,11 @@ end
 module type S = sig
   type term
   type fun_
-  type term_state
+  type term_store
 
   type t
 
-  val create : term_state -> t
+  val create : term_store -> t
 
   val clear : t -> unit
 
@@ -31,7 +31,7 @@ module Make(A: ARG) = struct
   module T = A.T.Term
   type fun_ = A.T.Fun.t
   type term = T.t
-  type term_state = T.state
+  type term_store = T.store
 
   module T_tbl = CCHashtbl.Make(T)
 

src/mini-cc/Sidekick_mini_cc.mli

@@ -20,12 +20,12 @@ end
 module type S = sig
   type term
   type fun_
-  type term_state
+  type term_store
 
   type t
   (** An instance of the congruence closure. Mutable *)
 
-  val create : term_state -> t
+  val create : term_store -> t
   (** New instance *)
 
   val clear : t -> unit
@@ -49,4 +49,4 @@ end
 module Make(A: ARG)
   : S with type term = A.T.Term.t
        and type fun_ = A.T.Fun.t
-       and type term_state = A.T.Term.state
+       and type term_store = A.T.Term.store

src/msat-solver/Sidekick_msat_solver.ml

@@ -112,8 +112,8 @@ module Make(A : ARG)
     type term = Term.t
     type ty = Ty.t
     type lit = Lit.t
-    type term_state = Term.state
-    type ty_state = Ty.state
+    type term_store = Term.store
+    type ty_store = Ty.store
 
     type th_states =
       | Ths_nil
@@ -128,8 +128,8 @@ module Make(A : ARG)
 
     module Simplify = struct
       type t = {
-        tst: term_state;
-        ty_st: ty_state;
+        tst: term_store;
+        ty_st: ty_store;
         mutable hooks: hook list;
         cache: Term.t Term.Tbl.t;
       }
@@ -182,8 +182,8 @@ module Make(A : ARG)
     type simplify_hook = Simplify.hook
 
     type t = {
-      tst: Term.state; (** state for managing terms *)
-      ty_st: Ty.state;
+      tst: Term.store; (** state for managing terms *)
+      ty_st: Ty.store;
       cc: CC.t lazy_t; (** congruence closure *)
       stat: Stat.t;
       count_axiom: int Stat.counter;
@@ -480,7 +480,7 @@ module Make(A : ARG)
     let[@inline] final_check (self:t) (acts:_ Msat.acts) : unit =
       check_ ~final:true self acts
 
-    let create ~stat (tst:Term.state) (ty_st:Ty.state) () : t =
+    let create ~stat (tst:Term.store) (ty_st:Ty.store) () : t =
       let rec self = {
         tst;
         ty_st;

src/smtlib/Process.ml

@@ -18,7 +18,7 @@ module Check_cc = struct
   module Lit = Solver.Solver_internal.Lit
   module SI = Solver.Solver_internal
   module CC = Solver.Solver_internal.CC
-  module MCC = Sidekick_mini_cc.Make(Solver_arg)
+  module MCC = Sidekick_mini_cc.Make(SBS.Solver_arg)
 
   let pp_c out c = Fmt.fprintf out "(@[%a@])" (Util.pp_list ~sep:" ∨ " Lit.pp) c
   let pp_and out c = Fmt.fprintf out "(@[%a@])" (Util.pp_list ~sep:" ∧ " Lit.pp) c

src/smtlib/Process.mli

@@ -4,9 +4,9 @@ open Sidekick_base
 
 module Solver
   : Sidekick_msat_solver.S with type T.Term.t = Term.t
-                            and type T.Term.state = Term.state
+                            and type T.Term.store = Term.store
                             and type T.Ty.t = Ty.t
-                            and type T.Ty.state = Ty.state
+                            and type T.Ty.store = Ty.store
 
 val th_bool : Solver.theory
 val th_data : Solver.theory

src/smtlib/Sidekick_smtlib.mli

@@ -11,6 +11,6 @@ module Stmt = Sidekick_base.Statement
 module Process = Process
 module Solver = Process.Solver
 
-val parse : Term.state -> string -> Stmt.t list or_error
+val parse : Term.store -> string -> Stmt.t list or_error
 
-val parse_stdin : Term.state -> Stmt.t list or_error
+val parse_stdin : Term.store -> Stmt.t list or_error

src/smtlib/Typecheck.ml

@@ -12,6 +12,7 @@ module BT = Sidekick_base
 module Ty = BT.Ty
 module T = BT.Term
 module Fun = BT.Fun
+module Form = BT.Form
 module Stmt = BT.Statement
 
 type 'a or_error = ('a, string) CCResult.t
@@ -31,13 +32,13 @@ module Ctx = struct
     | K_atomic of Ty.def
 
   type t = {
-    tst: T.state;
+    tst: T.store;
     names: (ID.t * kind) StrTbl.t;
     lets: T.t StrTbl.t;
     mutable loc: Loc.t option; (* current loc *)
   }
 
-  let create (tst:T.state) : t = {
+  let create (tst:T.store) : t = {
     tst;
     names=StrTbl.create 64;
     lets=StrTbl.create 16;

src/smtlib/Typecheck.mli

@@ -13,7 +13,7 @@ type 'a or_error = ('a, string) CCResult.t
 
 module Ctx : sig
   type t
-  val create: T.state -> t
+  val create: T.store -> t
 end
 
 val conv_term : Ctx.t -> PA.term -> T.t

src/th-bool-static/Sidekick_th_bool_static.ml

@@ -39,7 +39,7 @@ module type ARG = sig
   (** Basic boolean logic for a clause [|- c] *)
   val proof_bool_c : string -> term list -> S.P.t
 
-  val mk_bool : S.T.Term.state -> (term, term IArray.t) bool_view -> term
+  val mk_bool : S.T.Term.store -> (term, term IArray.t) bool_view -> term
   (** Make a term from the given boolean view. *)
 
   val check_congruence_classes : bool
@@ -56,7 +56,7 @@ module type ARG = sig
   module Gensym : sig
     type t
 
-    val create : S.T.Term.state -> t
+    val create : S.T.Term.store -> t
     (** New (stateful) generator instance. *)
 
     val fresh_term : t -> pre:string -> S.T.Ty.t -> term
@@ -70,7 +70,7 @@ module type S = sig
 
   type state
 
-  val create : A.S.T.Term.state -> A.S.T.Ty.state -> state
+  val create : A.S.T.Term.store -> A.S.T.Ty.store -> state
 
   val simplify : state -> A.S.Solver_internal.simplify_hook
   (** Simplify given term *)
@@ -96,8 +96,8 @@ module Make(A : ARG) : S with module A = A = struct
   module SI = A.S.Solver_internal
 
   type state = {
-    tst: T.state;
-    ty_st: Ty.state;
+    tst: T.store;
+    ty_st: Ty.store;
     cnf: (Lit.t * SI.P.t) T.Tbl.t; (* tseitin CNF *)
     gensym: A.Gensym.t;
   }

src/th-data/Sidekick_th_data.ml

@@ -67,10 +67,10 @@ module type ARG = sig
 
   val as_datatype : S.T.Ty.t -> (Cstor.t Iter.t, S.T.Ty.t) data_ty_view
   val view_as_data : S.T.Term.t -> (Cstor.t, S.T.Term.t) data_view
-  val mk_cstor : S.T.Term.state -> Cstor.t -> S.T.Term.t IArray.t -> S.T.Term.t
-  val mk_is_a: S.T.Term.state -> Cstor.t -> S.T.Term.t -> S.T.Term.t
-  val mk_sel : S.T.Term.state -> Cstor.t -> int -> S.T.Term.t -> S.T.Term.t
-  val mk_eq : S.T.Term.state -> S.T.Term.t -> S.T.Term.t -> S.T.Term.t
+  val mk_cstor : S.T.Term.store -> Cstor.t -> S.T.Term.t IArray.t -> S.T.Term.t
+  val mk_is_a: S.T.Term.store -> Cstor.t -> S.T.Term.t -> S.T.Term.t
+  val mk_sel : S.T.Term.store -> Cstor.t -> int -> S.T.Term.t -> S.T.Term.t
+  val mk_eq : S.T.Term.store -> S.T.Term.t -> S.T.Term.t -> S.T.Term.t
   val ty_is_finite : S.T.Ty.t -> bool
   val ty_set_is_finite : S.T.Ty.t -> bool -> unit
 
@@ -326,7 +326,7 @@ module Make(A : ARG) : S with module A = A = struct
   module N_tbl = Backtrackable_tbl.Make(N)
 
   type t = {
-    tst: T.state;
+    tst: T.store;
     cstors: ST_cstors.t; (* repr -> cstor for the class *)
     parents: ST_parents.t; (* repr -> parents for the class *)
     cards: Card.t; (* remember finiteness *)

src/th-data/Sidekick_th_data.mli

@@ -53,16 +53,16 @@ module type ARG = sig
   val view_as_data : S.T.Term.t -> (Cstor.t, S.T.Term.t) data_view
   (** Try to view term as a datatype term *)
 
-  val mk_cstor : S.T.Term.state -> Cstor.t -> S.T.Term.t IArray.t -> S.T.Term.t
+  val mk_cstor : S.T.Term.store -> Cstor.t -> S.T.Term.t IArray.t -> S.T.Term.t
   (** Make a constructor application term *)
 
-  val mk_is_a: S.T.Term.state -> Cstor.t -> S.T.Term.t -> S.T.Term.t
+  val mk_is_a: S.T.Term.store -> Cstor.t -> S.T.Term.t -> S.T.Term.t
   (** Make a [is-a] term *)
 
-  val mk_sel : S.T.Term.state -> Cstor.t -> int -> S.T.Term.t -> S.T.Term.t
+  val mk_sel : S.T.Term.store -> Cstor.t -> int -> S.T.Term.t -> S.T.Term.t
   (** Make a selector term *)
 
-  val mk_eq : S.T.Term.state -> S.T.Term.t -> S.T.Term.t -> S.T.Term.t
+  val mk_eq : S.T.Term.store -> S.T.Term.t -> S.T.Term.t -> S.T.Term.t
   (** Make a term equality *)
 
   val ty_is_finite : S.T.Ty.t -> bool