sig
  module T :
    sig
      module ADT :
        sig
          type t = ADT.t
          val hash : t -> int
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val pretty : Format.formatter -> t -> unit
          val id : t -> string
          val basename : t -> string
        end
      module Field :
        sig
          type t = Field.t
          val hash : t -> int
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val pretty : Format.formatter -> t -> unit
          val id : t -> string
          val sort : t -> Qed.Logic.sort
        end
      module Fun :
        sig
          type t = Fun.t
          val hash : t -> int
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val pretty : Format.formatter -> t -> unit
          val id : t -> string
          val category : t -> t Qed.Logic.category
          val params : t -> Qed.Logic.sort list
          val sort : t -> Qed.Logic.sort
        end
      module Var :
        sig
          type t = Qed.Term.Make(ADT)(Field)(Fun).Var.t
          val hash : t -> int
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val pretty : Format.formatter -> t -> unit
          val id : t -> string
          val sort : t -> Qed.Logic.sort
          val basename : t -> string
          val dummy : t
        end
      type term = Qed.Term.Make(ADT)(Field)(Fun).term
      type var = Var.t
      type tau = (Field.t, ADT.t) Qed.Logic.datatype
      type signature = (Field.t, ADT.t) Qed.Logic.funtype
      module Vars :
        sig
          type elt = var
          type t = Qed.Term.Make(ADT)(Field)(Fun).Vars.t
          val empty : t
          val is_empty : t -> bool
          val mem : elt -> t -> bool
          val add : elt -> t -> t
          val singleton : elt -> t
          val remove : elt -> t -> t
          val union : t -> t -> t
          val inter : t -> t -> t
          val diff : t -> t -> t
          val compare : t -> t -> int
          val equal : t -> t -> bool
          val subset : t -> t -> bool
          val iter : (elt -> unit) -> t -> unit
          val fold : (elt -> '-> 'a) -> t -> '-> 'a
          val for_all : (elt -> bool) -> t -> bool
          val exists : (elt -> bool) -> t -> bool
          val filter : (elt -> bool) -> t -> t
          val partition : (elt -> bool) -> t -> t * t
          val cardinal : t -> int
          val elements : t -> elt list
          val min_elt : t -> elt
          val max_elt : t -> elt
          val choose : t -> elt
          val split : elt -> t -> t * bool * t
          val map : (elt -> elt) -> t -> t
          val mapf : (elt -> elt option) -> t -> t
          val intersect : t -> t -> bool
        end
      module Vmap :
        sig
          type key = var
          type 'a t = 'Qed.Term.Make(ADT)(Field)(Fun).Vmap.t
          val is_empty : 'a t -> bool
          val empty : 'a t
          val add : key -> '-> 'a t -> 'a t
          val mem : key -> 'a t -> bool
          val find : key -> 'a t -> 'a
          val remove : key -> 'a t -> 'a t
          val compare : ('-> '-> int) -> 'a t -> 'a t -> int
          val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
          val iter : (key -> '-> unit) -> 'a t -> unit
          val map : (key -> '-> 'b) -> 'a t -> 'b t
          val mapf : (key -> '-> 'b option) -> 'a t -> 'b t
          val filter : (key -> '-> bool) -> 'a t -> 'a t
          val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
          val union : (key -> '-> '-> 'a) -> 'a t -> 'a t -> 'a t
          val inter : (key -> '-> '-> 'a) -> 'a t -> 'a t -> 'a t
          val merge :
            (key -> 'a option -> 'b option -> 'c option) ->
            'a t -> 'b t -> 'c t
        end
      type pool = Qed.Term.Make(ADT)(Field)(Fun).pool
      val pool : ?copy:pool -> unit -> pool
      val add_var : pool -> var -> unit
      val add_vars : pool -> Vars.t -> unit
      val add_term : pool -> term -> unit
      val fresh : pool -> ?basename:string -> tau -> var
      val alpha : pool -> var -> var
      val tau_of_var : var -> tau
      val base_of_var : var -> string
      type 'a symbol = (Field.t, Fun.t, var, 'a) Qed.Logic.term_repr
      type repr = term symbol
      type path = int list
      type record = (Field.t * term) list
      val is_true : term -> Qed.Logic.maybe
      val is_false : term -> Qed.Logic.maybe
      val is_prop : term -> bool
      val is_int : term -> bool
      val is_real : term -> bool
      val is_arith : term -> bool
      val are_equal : term -> term -> Qed.Logic.maybe
      val repr : term -> repr
      val sort : term -> Qed.Logic.sort
      val vars : term -> Vars.t
      val subterm : term -> path -> term
      val change_subterm : term -> path -> term -> term
      val e_true : term
      val e_false : term
      val e_bool : bool -> term
      val e_literal : bool -> term -> term
      val e_int : int -> term
      val e_zint : Qed.Z.t -> term
      val e_real : Qed.R.t -> term
      val e_var : var -> term
      val e_opp : term -> term
      val e_times : Qed.Z.t -> term -> term
      val e_sum : term list -> term
      val e_prod : term list -> term
      val e_add : term -> term -> term
      val e_sub : term -> term -> term
      val e_mul : term -> term -> term
      val e_div : term -> term -> term
      val e_mod : term -> term -> term
      val e_eq : term -> term -> term
      val e_neq : term -> term -> term
      val e_leq : term -> term -> term
      val e_lt : term -> term -> term
      val e_imply : term list -> term -> term
      val e_equiv : term -> term -> term
      val e_and : term list -> term
      val e_or : term list -> term
      val e_not : term -> term
      val e_if : term -> term -> term -> term
      val e_get : term -> term -> term
      val e_set : term -> term -> term -> term
      val e_getfield : term -> Field.t -> term
      val e_record : record -> term
      val e_fun : Fun.t -> term list -> term
      val e_forall : var list -> term -> term
      val e_exists : var list -> term -> term
      val e_lambda : var list -> term -> term
      val e_bind : Qed.Logic.binder -> var -> term -> term
      val e_subst : ?pool:pool -> var -> term -> term -> term
      val e_apply : ?pool:pool -> term -> term list -> term
      val e_repr : repr -> term
      val e_map : (term -> term) -> term -> term
      val e_iter : (term -> unit) -> term -> unit
      val f_map : (Vars.t -> term -> term) -> Vars.t -> term -> term
      val f_iter : (Vars.t -> term -> unit) -> Vars.t -> term -> unit
      val add_builtin : Fun.t -> (term list -> term) -> unit
      val add_builtin_eq : Fun.t -> (term -> term -> term) -> unit
      val e_funop : Fun.t -> term list -> term
      val e_funraw : Fun.t -> term list -> term
      val literal : term -> bool * term
      val congruence_eq : term -> term -> (term * term) list option
      val congruence_neq : term -> term -> (term * term) list option
      val flattenable : term -> bool
      val flattens : term -> term -> bool
      val flatten : term -> term list
      val affine : term -> term Qed.Logic.affine
      val record_with : record -> (term * record) option
      type t = term
      val id : t -> int
      val hash : t -> int
      val equal : t -> t -> bool
      val compare : t -> t -> int
      val pretty : Format.formatter -> t -> unit
      val weigth : t -> int
      val is_closed : t -> bool
      val is_simple : t -> bool
      val is_atomic : t -> bool
      val is_primitive : t -> bool
      val is_neutral : Fun.t -> t -> bool
      val is_absorbant : Fun.t -> t -> bool
      val size : t -> int
      val basename : t -> string
      val pp_id : Format.formatter -> t -> unit
      val pp_rid : Format.formatter -> t -> unit
      val pp_repr : Format.formatter -> repr -> unit
      module Tset :
        sig
          type elt = term
          type t = Qed.Term.Make(ADT)(Field)(Fun).Tset.t
          val empty : t
          val is_empty : t -> bool
          val mem : elt -> t -> bool
          val add : elt -> t -> t
          val singleton : elt -> t
          val remove : elt -> t -> t
          val union : t -> t -> t
          val inter : t -> t -> t
          val diff : t -> t -> t
          val compare : t -> t -> int
          val equal : t -> t -> bool
          val subset : t -> t -> bool
          val iter : (elt -> unit) -> t -> unit
          val fold : (elt -> '-> 'a) -> t -> '-> 'a
          val for_all : (elt -> bool) -> t -> bool
          val exists : (elt -> bool) -> t -> bool
          val filter : (elt -> bool) -> t -> t
          val partition : (elt -> bool) -> t -> t * t
          val cardinal : t -> int
          val elements : t -> elt list
          val min_elt : t -> elt
          val max_elt : t -> elt
          val choose : t -> elt
          val split : elt -> t -> t * bool * t
          val map : (elt -> elt) -> t -> t
          val mapf : (elt -> elt option) -> t -> t
          val intersect : t -> t -> bool
        end
      module Tmap :
        sig
          type key = term
          type 'a t = 'Qed.Term.Make(ADT)(Field)(Fun).Tmap.t
          val is_empty : 'a t -> bool
          val empty : 'a t
          val add : key -> '-> 'a t -> 'a t
          val mem : key -> 'a t -> bool
          val find : key -> 'a t -> 'a
          val remove : key -> 'a t -> 'a t
          val compare : ('-> '-> int) -> 'a t -> 'a t -> int
          val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
          val iter : (key -> '-> unit) -> 'a t -> unit
          val map : (key -> '-> 'b) -> 'a t -> 'b t
          val mapf : (key -> '-> 'b option) -> 'a t -> 'b t
          val filter : (key -> '-> bool) -> 'a t -> 'a t
          val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
          val union : (key -> '-> '-> 'a) -> 'a t -> 'a t -> 'a t
          val inter : (key -> '-> '-> 'a) -> 'a t -> 'a t -> 'a t
          val merge :
            (key -> 'a option -> 'b option -> 'c option) ->
            'a t -> 'b t -> 'c t
        end
      val shared :
        ?shared:(term -> bool) ->
        ?shareable:(term -> bool) -> ?closed:Vars.t -> term list -> term list
      type marks = Qed.Term.Make(ADT)(Field)(Fun).marks
      val marks :
        ?shared:(term -> bool) ->
        ?shareable:(term -> bool) -> ?closed:Vars.t -> unit -> marks
      val mark : marks -> term -> unit
      val defs : marks -> term list
      val debug : Format.formatter -> term -> unit
    end
  module Pretty :
    sig
      type env = Qed.Pretty.Make(T).env
      val empty : env
      val closed : T.Vars.t -> env
      val marks : env -> T.marks
      val bind : string -> T.term -> env -> env
      val fresh : env -> T.term -> string * env
      val pp_tau : Format.formatter -> T.tau -> unit
      val pp_term : env -> Format.formatter -> T.term -> unit
      val pp_def : env -> Format.formatter -> T.term -> unit
    end
  module ADT :
    sig
      type t = ADT.t
      val hash : t -> int
      val equal : t -> t -> bool
      val compare : t -> t -> int
      val pretty : Format.formatter -> t -> unit
      val id : t -> string
      val basename : t -> string
    end
  module Field :
    sig
      type t = Field.t
      val hash : t -> int
      val equal : t -> t -> bool
      val compare : t -> t -> int
      val pretty : Format.formatter -> t -> unit
      val id : t -> string
      val sort : t -> Qed.Logic.sort
    end
  module Fun :
    sig
      type t = Fun.t
      val hash : t -> int
      val equal : t -> t -> bool
      val compare : t -> t -> int
      val pretty : Format.formatter -> t -> unit
      val id : t -> string
      val category : t -> t Qed.Logic.category
      val params : t -> Qed.Logic.sort list
      val sort : t -> Qed.Logic.sort
    end
  module Var :
    sig
      type t = Qed.Term.Make(ADT)(Field)(Fun).Var.t
      val hash : t -> int
      val equal : t -> t -> bool
      val compare : t -> t -> int
      val pretty : Format.formatter -> t -> unit
      val id : t -> string
      val sort : t -> Qed.Logic.sort
      val basename : t -> string
      val dummy : t
    end
  type term = Qed.Term.Make(ADT)(Field)(Fun).term
  type var = Var.t
  type tau = (Field.t, ADT.t) Qed.Logic.datatype
  type signature = (Field.t, ADT.t) Qed.Logic.funtype
  module Vars :
    sig
      type elt = var
      type t = Qed.Term.Make(ADT)(Field)(Fun).Vars.t
      val empty : t
      val is_empty : t -> bool
      val mem : elt -> t -> bool
      val add : elt -> t -> t
      val singleton : elt -> t
      val remove : elt -> t -> t
      val union : t -> t -> t
      val inter : t -> t -> t
      val diff : t -> t -> t
      val compare : t -> t -> int
      val equal : t -> t -> bool
      val subset : t -> t -> bool
      val iter : (elt -> unit) -> t -> unit
      val fold : (elt -> '-> 'a) -> t -> '-> 'a
      val for_all : (elt -> bool) -> t -> bool
      val exists : (elt -> bool) -> t -> bool
      val filter : (elt -> bool) -> t -> t
      val partition : (elt -> bool) -> t -> t * t
      val cardinal : t -> int
      val elements : t -> elt list
      val min_elt : t -> elt
      val max_elt : t -> elt
      val choose : t -> elt
      val split : elt -> t -> t * bool * t
      val map : (elt -> elt) -> t -> t
      val mapf : (elt -> elt option) -> t -> t
      val intersect : t -> t -> bool
    end
  module Vmap :
    sig
      type key = var
      type 'a t = 'Qed.Term.Make(ADT)(Field)(Fun).Vmap.t
      val is_empty : 'a t -> bool
      val empty : 'a t
      val add : key -> '-> 'a t -> 'a t
      val mem : key -> 'a t -> bool
      val find : key -> 'a t -> 'a
      val remove : key -> 'a t -> 'a t
      val compare : ('-> '-> int) -> 'a t -> 'a t -> int
      val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
      val iter : (key -> '-> unit) -> 'a t -> unit
      val map : (key -> '-> 'b) -> 'a t -> 'b t
      val mapf : (key -> '-> 'b option) -> 'a t -> 'b t
      val filter : (key -> '-> bool) -> 'a t -> 'a t
      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
      val union : (key -> '-> '-> 'a) -> 'a t -> 'a t -> 'a t
      val inter : (key -> '-> '-> 'a) -> 'a t -> 'a t -> 'a t
      val merge :
        (key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t
    end
  type pool = Qed.Term.Make(ADT)(Field)(Fun).pool
  val pool : ?copy:pool -> unit -> pool
  val add_var : pool -> var -> unit
  val add_vars : pool -> Vars.t -> unit
  val add_term : pool -> term -> unit
  val fresh : pool -> ?basename:string -> tau -> var
  val alpha : pool -> var -> var
  val tau_of_var : var -> tau
  val base_of_var : var -> string
  type 'a symbol = (Field.t, Fun.t, var, 'a) Qed.Logic.term_repr
  type repr = term symbol
  type path = int list
  type record = (Field.t * term) list
  val is_true : term -> Qed.Logic.maybe
  val is_false : term -> Qed.Logic.maybe
  val is_prop : term -> bool
  val is_int : term -> bool
  val is_real : term -> bool
  val is_arith : term -> bool
  val are_equal : term -> term -> Qed.Logic.maybe
  val repr : term -> repr
  val sort : term -> Qed.Logic.sort
  val vars : term -> Vars.t
  val subterm : term -> path -> term
  val change_subterm : term -> path -> term -> term
  val e_true : term
  val e_false : term
  val e_bool : bool -> term
  val e_literal : bool -> term -> term
  val e_int : int -> term
  val e_zint : Qed.Z.t -> term
  val e_real : Qed.R.t -> term
  val e_var : var -> term
  val e_opp : term -> term
  val e_times : Qed.Z.t -> term -> term
  val e_sum : term list -> term
  val e_prod : term list -> term
  val e_add : term -> term -> term
  val e_sub : term -> term -> term
  val e_mul : term -> term -> term
  val e_div : term -> term -> term
  val e_mod : term -> term -> term
  val e_eq : term -> term -> term
  val e_neq : term -> term -> term
  val e_leq : term -> term -> term
  val e_lt : term -> term -> term
  val e_imply : term list -> term -> term
  val e_equiv : term -> term -> term
  val e_and : term list -> term
  val e_or : term list -> term
  val e_not : term -> term
  val e_if : term -> term -> term -> term
  val e_get : term -> term -> term
  val e_set : term -> term -> term -> term
  val e_getfield : term -> Field.t -> term
  val e_record : record -> term
  val e_fun : Fun.t -> term list -> term
  val e_forall : var list -> term -> term
  val e_exists : var list -> term -> term
  val e_lambda : var list -> term -> term
  val e_bind : Qed.Logic.binder -> var -> term -> term
  val e_subst : ?pool:pool -> var -> term -> term -> term
  val e_apply : ?pool:pool -> term -> term list -> term
  val e_repr : repr -> term
  val e_map : (term -> term) -> term -> term
  val e_iter : (term -> unit) -> term -> unit
  val f_map : (Vars.t -> term -> term) -> Vars.t -> term -> term
  val f_iter : (Vars.t -> term -> unit) -> Vars.t -> term -> unit
  val add_builtin : Fun.t -> (term list -> term) -> unit
  val add_builtin_eq : Fun.t -> (term -> term -> term) -> unit
  val e_funop : Fun.t -> term list -> term
  val e_funraw : Fun.t -> term list -> term
  val literal : term -> bool * term
  val congruence_eq : term -> term -> (term * term) list option
  val congruence_neq : term -> term -> (term * term) list option
  val flattenable : term -> bool
  val flattens : term -> term -> bool
  val flatten : term -> term list
  val affine : term -> term Qed.Logic.affine
  val record_with : record -> (term * record) option
  type t = term
  val id : t -> int
  val hash : t -> int
  val equal : t -> t -> bool
  val compare : t -> t -> int
  val pretty : Format.formatter -> t -> unit
  val weigth : t -> int
  val is_closed : t -> bool
  val is_simple : t -> bool
  val is_atomic : t -> bool
  val is_primitive : t -> bool
  val is_neutral : Fun.t -> t -> bool
  val is_absorbant : Fun.t -> t -> bool
  val size : t -> int
  val basename : t -> string
  val pp_id : Format.formatter -> t -> unit
  val pp_rid : Format.formatter -> t -> unit
  val pp_repr : Format.formatter -> repr -> unit
  module Tset :
    sig
      type elt = term
      type t = Qed.Term.Make(ADT)(Field)(Fun).Tset.t
      val empty : t
      val is_empty : t -> bool
      val mem : elt -> t -> bool
      val add : elt -> t -> t
      val singleton : elt -> t
      val remove : elt -> t -> t
      val union : t -> t -> t
      val inter : t -> t -> t
      val diff : t -> t -> t
      val compare : t -> t -> int
      val equal : t -> t -> bool
      val subset : t -> t -> bool
      val iter : (elt -> unit) -> t -> unit
      val fold : (elt -> '-> 'a) -> t -> '-> 'a
      val for_all : (elt -> bool) -> t -> bool
      val exists : (elt -> bool) -> t -> bool
      val filter : (elt -> bool) -> t -> t
      val partition : (elt -> bool) -> t -> t * t
      val cardinal : t -> int
      val elements : t -> elt list
      val min_elt : t -> elt
      val max_elt : t -> elt
      val choose : t -> elt
      val split : elt -> t -> t * bool * t
      val map : (elt -> elt) -> t -> t
      val mapf : (elt -> elt option) -> t -> t
      val intersect : t -> t -> bool
    end
  module Tmap :
    sig
      type key = term
      type 'a t = 'Qed.Term.Make(ADT)(Field)(Fun).Tmap.t
      val is_empty : 'a t -> bool
      val empty : 'a t
      val add : key -> '-> 'a t -> 'a t
      val mem : key -> 'a t -> bool
      val find : key -> 'a t -> 'a
      val remove : key -> 'a t -> 'a t
      val compare : ('-> '-> int) -> 'a t -> 'a t -> int
      val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
      val iter : (key -> '-> unit) -> 'a t -> unit
      val map : (key -> '-> 'b) -> 'a t -> 'b t
      val mapf : (key -> '-> 'b option) -> 'a t -> 'b t
      val filter : (key -> '-> bool) -> 'a t -> 'a t
      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
      val union : (key -> '-> '-> 'a) -> 'a t -> 'a t -> 'a t
      val inter : (key -> '-> '-> 'a) -> 'a t -> 'a t -> 'a t
      val merge :
        (key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t
    end
  val shared :
    ?shared:(term -> bool) ->
    ?shareable:(term -> bool) -> ?closed:Vars.t -> term list -> term list
  type marks = Qed.Term.Make(ADT)(Field)(Fun).marks
  val marks :
    ?shared:(term -> bool) ->
    ?shareable:(term -> bool) -> ?closed:Vars.t -> unit -> marks
  val mark : marks -> term -> unit
  val defs : marks -> term list
  val debug : Format.formatter -> term -> unit
  type unop = term -> term
  type binop = term -> term -> term
  val e_zero : term
  val e_one : term
  val e_minus_one : term
  val e_zero_real : term
  val hex_of_float : float -> string
  val e_int64 : int64 -> term
  val e_fact : int64 -> term -> term
  val e_bigint : Integer.t -> term
  val e_range : term -> term -> term
  val e_mthfloat : float -> Lang.F.T.term
  val e_hexfloat : float -> Lang.F.T.term
  val e_setfield : term -> Lang.Field.t -> term -> term
  type pred = term
  type cmp = term -> term -> Lang.F.pred
  val p_bool : '-> 'a
  val e_prop : '-> 'a
  val p_bools : '-> 'a
  val e_props : '-> 'a
  val lift : ('-> 'b) -> '-> 'b
  val is_zero : Lang.F.T.term -> bool
  val eqp : t -> t -> bool
  val comparep : t -> t -> int
  val is_ptrue : term -> Qed.Logic.maybe
  val is_pfalse : term -> Qed.Logic.maybe
  val is_equal : term -> term -> Qed.Logic.maybe
  val p_equal : term -> term -> term
  val p_neq : term -> term -> term
  val p_leq : term -> term -> term
  val p_lt : term -> term -> term
  val p_positive : term -> term
  val p_true : term
  val p_false : term
  val p_not : term -> term
  val p_bind : Qed.Logic.binder -> var -> term -> term
  val p_forall : var list -> term -> term
  val p_exists : var list -> term -> term
  val p_subst : ?pool:pool -> var -> term -> term -> term
  val p_and : term -> term -> term
  val p_or : term -> term -> term
  val p_imply : term -> term -> term
  val p_hyps : term list -> term -> term
  val p_equiv : term -> term -> term
  val p_if : term -> term -> term -> term
  val p_conj : term list -> term
  val p_disj : term list -> term
  val p_all : ('-> term) -> 'a list -> term
  val p_any : ('-> term) -> 'a list -> term
  val p_call : Lang.Fun.t -> term list -> term
  val p_close : term -> term
  val occurs : Vars.elt -> term -> bool
  val intersect : term -> term -> bool
  val occursp : Vars.elt -> term -> bool
  val intersectp : term -> term -> bool
  val varsp : term -> Vars.t
  val pred : term -> repr
  val idp : t -> int
  val pp_term : Format.formatter -> Lang.F.T.term -> unit
  val pp_pred : Format.formatter -> Lang.F.T.term -> unit
  val pp_var : Format.formatter -> var -> unit
  val pp_vars : Format.formatter -> Vars.t -> unit
  val debugp : Format.formatter -> Lang.F.T.term -> unit
  type env = Lang.F.Pretty.env
  val empty : Lang.F.Pretty.env
  val closed : Lang.F.T.Vars.t -> Lang.F.Pretty.env
  val marker : Lang.F.Pretty.env -> Lang.F.T.marks
  val mark_e : Lang.F.T.marks -> Lang.F.T.term -> unit
  val mark_p : Lang.F.T.marks -> Lang.F.T.term -> unit
  val define :
    (Lang.F.Pretty.env -> string -> Lang.F.T.term -> 'a) ->
    Lang.F.Pretty.env -> Lang.F.T.marks -> Lang.F.Pretty.env
  val pp_eterm :
    Lang.F.Pretty.env -> Format.formatter -> Lang.F.T.term -> unit
  val pp_epred :
    Lang.F.Pretty.env -> Format.formatter -> Lang.F.T.term -> unit
  module Pmap :
    sig
      type key = term
      type 'a t = 'Qed.Term.Make(ADT)(Field)(Fun).Tmap.t
      val is_empty : 'a t -> bool
      val empty : 'a t
      val add : key -> '-> 'a t -> 'a t
      val mem : key -> 'a t -> bool
      val find : key -> 'a t -> 'a
      val remove : key -> 'a t -> 'a t
      val compare : ('-> '-> int) -> 'a t -> 'a t -> int
      val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
      val iter : (key -> '-> unit) -> 'a t -> unit
      val map : (key -> '-> 'b) -> 'a t -> 'b t
      val mapf : (key -> '-> 'b option) -> 'a t -> 'b t
      val filter : (key -> '-> bool) -> 'a t -> 'a t
      val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
      val union : (key -> '-> '-> 'a) -> 'a t -> 'a t -> 'a t
      val inter : (key -> '-> '-> 'a) -> 'a t -> 'a t -> 'a t
      val merge :
        (key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t
    end
  module Pset :
    sig
      type elt = term
      type t = Qed.Term.Make(ADT)(Field)(Fun).Tset.t
      val empty : t
      val is_empty : t -> bool
      val mem : elt -> t -> bool
      val add : elt -> t -> t
      val singleton : elt -> t
      val remove : elt -> t -> t
      val union : t -> t -> t
      val inter : t -> t -> t
      val diff : t -> t -> t
      val compare : t -> t -> int
      val equal : t -> t -> bool
      val subset : t -> t -> bool
      val iter : (elt -> unit) -> t -> unit
      val fold : (elt -> '-> 'a) -> t -> '-> 'a
      val for_all : (elt -> bool) -> t -> bool
      val exists : (elt -> bool) -> t -> bool
      val filter : (elt -> bool) -> t -> t
      val partition : (elt -> bool) -> t -> t * t
      val cardinal : t -> int
      val elements : t -> elt list
      val min_elt : t -> elt
      val max_elt : t -> elt
      val choose : t -> elt
      val split : elt -> t -> t * bool * t
      val map : (elt -> elt) -> t -> t
      val mapf : (elt -> elt option) -> t -> t
      val intersect : t -> t -> bool
    end
  module P :
    sig
      type pattern = T.Fun.t Qed.Pattern.fpattern
      val pmatch : pattern -> T.term -> T.term array
      val pmatch_all : pattern list -> T.term list -> T.term array
      val instance : T.term array -> pattern -> T.term
    end
  type pattern = Lang.F.P.pattern
  val rewrite :
    name:string ->
    vars:Lang.F.T.tau array ->
    Lang.F.P.pattern -> (term array -> Lang.F.T.term) -> unit
  val add_builtin_1 : Lang.Fun.t -> (term -> term) -> unit
  val add_builtin_2 : Lang.Fun.t -> (term -> term -> term) -> unit
  val add_builtin_peq : Lang.Fun.t -> (term -> term -> term) -> unit
end