diff options
Diffstat (limited to 'src/extraction/smt_checker.mli')
| -rw-r--r-- | src/extraction/smt_checker.mli | 6149 |
1 files changed, 4690 insertions, 1459 deletions
diff --git a/src/extraction/smt_checker.mli b/src/extraction/smt_checker.mli index 841e91e..48aa74c 100644 --- a/src/extraction/smt_checker.mli +++ b/src/extraction/smt_checker.mli @@ -1,24 +1,9 @@ -(**************************************************************************) -(* *) -(* SMTCoq *) -(* Copyright (C) 2011 - 2022 *) -(* *) -(* See file "AUTHORS" for the list of authors *) -(* *) -(* This file is distributed under the terms of the CeCILL-C licence *) -(* *) -(**************************************************************************) - type __ = Obj.t type unit0 = | Tt -val implb : bool -> bool -> bool - -val xorb : bool -> bool -> bool - val negb : bool -> bool type nat = @@ -31,44 +16,27 @@ type 'a option = val option_map : ('a1 -> 'a2) -> 'a1 option -> 'a2 option -val fst : ('a1*'a2) -> 'a1 +val fst : ('a1 * 'a2) -> 'a1 -val snd : ('a1*'a2) -> 'a2 +val snd : ('a1 * 'a2) -> 'a2 type 'a list = | Nil | Cons of 'a * 'a list -val app : 'a1 list -> 'a1 list -> 'a1 list - -val compOpp : ExtrNative.comparison -> ExtrNative.comparison - -type compareSpecT = -| CompEqT -| CompLtT -| CompGtT - -val compareSpec2Type : ExtrNative.comparison -> compareSpecT - -type 'a compSpecT = compareSpecT +val length : 'a1 list -> nat -val compSpec2Type : 'a1 -> 'a1 -> ExtrNative.comparison -> 'a1 compSpecT +val app : 'a1 list -> 'a1 list -> 'a1 list -type 'a sig0 = - 'a - (* singleton inductive, whose constructor was exist *) +val compOpp : int -> int type sumbool = | Left | Right -type 'a sumor = -| Inleft of 'a -| Inright - -val plus : nat -> nat -> nat +val add : nat -> nat -> nat -val nat_iter : nat -> ('a1 -> 'a1) -> 'a1 -> 'a1 +val mul : nat -> nat -> nat type positive = | XI of positive @@ -86,1332 +54,181 @@ type z = val eqb : bool -> bool -> bool -type reflect = -| ReflectT -| ReflectF - -val iff_reflect : bool -> reflect - -module type TotalOrder' = - sig - type t +module type EqLtLe = + sig + type t end -module MakeOrderTac : - functor (O:TotalOrder') -> - sig - +module MakeOrderTac : + functor (O:EqLtLe) -> + functor (P:sig + end) -> + sig end -module MaxLogicalProperties : - functor (O:TotalOrder') -> - functor (M:sig - val max : O.t -> O.t -> O.t - end) -> - sig - module Private_Tac : - sig - - end +module Nat : + sig + val eqb : nat -> nat -> bool end -module Pos : - sig - type t = positive - - val succ : positive -> positive - - val add : positive -> positive -> positive - - val add_carry : positive -> positive -> positive - - val pred_double : positive -> positive - - val pred : positive -> positive - - val pred_N : positive -> n - +module Pos : + sig type mask = | IsNul | IsPos of positive | IsNeg - - val mask_rect : 'a1 -> (positive -> 'a1) -> 'a1 -> mask -> 'a1 - - val mask_rec : 'a1 -> (positive -> 'a1) -> 'a1 -> mask -> 'a1 - - val succ_double_mask : mask -> mask - - val double_mask : mask -> mask - - val double_pred_mask : positive -> mask - - val pred_mask : mask -> mask - - val sub_mask : positive -> positive -> mask - - val sub_mask_carry : positive -> positive -> mask - - val sub : positive -> positive -> positive - - val mul : positive -> positive -> positive - - val iter : positive -> ('a1 -> 'a1) -> 'a1 -> 'a1 - - val pow : positive -> positive -> positive - - val square : positive -> positive - - val div2 : positive -> positive - - val div2_up : positive -> positive - - val size_nat : positive -> nat - - val size : positive -> positive - - val compare_cont : - positive -> positive -> ExtrNative.comparison -> ExtrNative.comparison - - val compare : positive -> positive -> ExtrNative.comparison - - val min : positive -> positive -> positive - - val max : positive -> positive -> positive - - val eqb : positive -> positive -> bool - - val leb : positive -> positive -> bool - - val ltb : positive -> positive -> bool - - val sqrtrem_step : - (positive -> positive) -> (positive -> positive) -> (positive*mask) -> - positive*mask - - val sqrtrem : positive -> positive*mask - - val sqrt : positive -> positive - - val gcdn : nat -> positive -> positive -> positive - - val gcd : positive -> positive -> positive - - val ggcdn : nat -> positive -> positive -> positive*(positive*positive) - - val ggcd : positive -> positive -> positive*(positive*positive) - - val coq_Nsucc_double : n -> n - - val coq_Ndouble : n -> n - - val coq_lor : positive -> positive -> positive - - val coq_land : positive -> positive -> n - - val ldiff : positive -> positive -> n - - val coq_lxor : positive -> positive -> n - - val shiftl_nat : positive -> nat -> positive - - val shiftr_nat : positive -> nat -> positive - - val shiftl : positive -> n -> positive - - val shiftr : positive -> n -> positive - - val testbit_nat : positive -> nat -> bool - - val testbit : positive -> n -> bool - - val iter_op : ('a1 -> 'a1 -> 'a1) -> positive -> 'a1 -> 'a1 - - val to_nat : positive -> nat - - val of_nat : nat -> positive - - val of_succ_nat : nat -> positive end -module Coq_Pos : - sig - module Coq__1 : sig - type t = positive - end - type t = Coq__1.t - +module Coq_Pos : + sig val succ : positive -> positive - + val add : positive -> positive -> positive - + val add_carry : positive -> positive -> positive - + val pred_double : positive -> positive - + val pred : positive -> positive - - val pred_N : positive -> n - + type mask = Pos.mask = | IsNul | IsPos of positive | IsNeg - - val mask_rect : 'a1 -> (positive -> 'a1) -> 'a1 -> mask -> 'a1 - - val mask_rec : 'a1 -> (positive -> 'a1) -> 'a1 -> mask -> 'a1 - + val succ_double_mask : mask -> mask - + val double_mask : mask -> mask - + val double_pred_mask : positive -> mask - - val pred_mask : mask -> mask - + val sub_mask : positive -> positive -> mask - + val sub_mask_carry : positive -> positive -> mask - + val sub : positive -> positive -> positive - + val mul : positive -> positive -> positive - - val iter : positive -> ('a1 -> 'a1) -> 'a1 -> 'a1 - - val pow : positive -> positive -> positive - - val square : positive -> positive - - val div2 : positive -> positive - - val div2_up : positive -> positive - + val size_nat : positive -> nat - - val size : positive -> positive - - val compare_cont : - positive -> positive -> ExtrNative.comparison -> ExtrNative.comparison - - val compare : positive -> positive -> ExtrNative.comparison - - val min : positive -> positive -> positive - + + val compare_cont : int -> positive -> positive -> int + + val compare : positive -> positive -> int + val max : positive -> positive -> positive - + val eqb : positive -> positive -> bool - + val leb : positive -> positive -> bool - - val ltb : positive -> positive -> bool - - val sqrtrem_step : - (positive -> positive) -> (positive -> positive) -> (positive*mask) -> - positive*mask - - val sqrtrem : positive -> positive*mask - - val sqrt : positive -> positive - + val gcdn : nat -> positive -> positive -> positive - + val gcd : positive -> positive -> positive - - val ggcdn : nat -> positive -> positive -> positive*(positive*positive) - - val ggcd : positive -> positive -> positive*(positive*positive) - - val coq_Nsucc_double : n -> n - - val coq_Ndouble : n -> n - - val coq_lor : positive -> positive -> positive - - val coq_land : positive -> positive -> n - - val ldiff : positive -> positive -> n - - val coq_lxor : positive -> positive -> n - - val shiftl_nat : positive -> nat -> positive - - val shiftr_nat : positive -> nat -> positive - - val shiftl : positive -> n -> positive - - val shiftr : positive -> n -> positive - - val testbit_nat : positive -> nat -> bool - - val testbit : positive -> n -> bool - + val iter_op : ('a1 -> 'a1 -> 'a1) -> positive -> 'a1 -> 'a1 - + val to_nat : positive -> nat - - val of_nat : nat -> positive - + val of_succ_nat : nat -> positive - + val eq_dec : positive -> positive -> sumbool - - val peano_rect : 'a1 -> (positive -> 'a1 -> 'a1) -> positive -> 'a1 - - val peano_rec : 'a1 -> (positive -> 'a1 -> 'a1) -> positive -> 'a1 - - type coq_PeanoView = - | PeanoOne - | PeanoSucc of positive * coq_PeanoView - - val coq_PeanoView_rect : - 'a1 -> (positive -> coq_PeanoView -> 'a1 -> 'a1) -> positive -> - coq_PeanoView -> 'a1 - - val coq_PeanoView_rec : - 'a1 -> (positive -> coq_PeanoView -> 'a1 -> 'a1) -> positive -> - coq_PeanoView -> 'a1 - - val peanoView_xO : positive -> coq_PeanoView -> coq_PeanoView - - val peanoView_xI : positive -> coq_PeanoView -> coq_PeanoView - - val peanoView : positive -> coq_PeanoView - - val coq_PeanoView_iter : - 'a1 -> (positive -> 'a1 -> 'a1) -> positive -> coq_PeanoView -> 'a1 - - val eqb_spec : positive -> positive -> reflect - - val switch_Eq : - ExtrNative.comparison -> ExtrNative.comparison -> ExtrNative.comparison - - val mask2cmp : mask -> ExtrNative.comparison - - val leb_spec0 : positive -> positive -> reflect - - val ltb_spec0 : positive -> positive -> reflect - - module Private_Tac : - sig - - end - - module Private_Rev : - sig - module ORev : - sig - type t = Coq__1.t - end - - module MRev : - sig - val max : t -> t -> t - end - - module MPRev : - sig - module Private_Tac : - sig - - end - end - end - - module Private_Dec : - sig - val max_case_strong : - t -> t -> (t -> t -> __ -> 'a1 -> 'a1) -> (__ -> 'a1) -> (__ -> 'a1) -> - 'a1 - - val max_case : - t -> t -> (t -> t -> __ -> 'a1 -> 'a1) -> 'a1 -> 'a1 -> 'a1 - - val max_dec : t -> t -> sumbool - - val min_case_strong : - t -> t -> (t -> t -> __ -> 'a1 -> 'a1) -> (__ -> 'a1) -> (__ -> 'a1) -> - 'a1 - - val min_case : - t -> t -> (t -> t -> __ -> 'a1 -> 'a1) -> 'a1 -> 'a1 -> 'a1 - - val min_dec : t -> t -> sumbool - end - - val max_case_strong : t -> t -> (__ -> 'a1) -> (__ -> 'a1) -> 'a1 - - val max_case : t -> t -> 'a1 -> 'a1 -> 'a1 - - val max_dec : t -> t -> sumbool - - val min_case_strong : t -> t -> (__ -> 'a1) -> (__ -> 'a1) -> 'a1 - - val min_case : t -> t -> 'a1 -> 'a1 -> 'a1 - - val min_dec : t -> t -> sumbool end -module N : - sig - type t = n - - val zero : n - - val one : n - - val two : n - - val succ_double : n -> n - - val double : n -> n - - val succ : n -> n - - val pred : n -> n - - val succ_pos : n -> positive - +module N : + sig val add : n -> n -> n - + val sub : n -> n -> n - - val mul : n -> n -> n - - val compare : n -> n -> ExtrNative.comparison - + + val compare : n -> n -> int + val eqb : n -> n -> bool - + val leb : n -> n -> bool - + val ltb : n -> n -> bool - - val min : n -> n -> n - - val max : n -> n -> n - - val div2 : n -> n - - val even : n -> bool - - val odd : n -> bool - - val pow : n -> n -> n - - val square : n -> n - - val log2 : n -> n - - val size : n -> n - - val size_nat : n -> nat - - val pos_div_eucl : positive -> n -> n*n - - val div_eucl : n -> n -> n*n - - val div : n -> n -> n - - val modulo : n -> n -> n - - val gcd : n -> n -> n - - val ggcd : n -> n -> n*(n*n) - - val sqrtrem : n -> n*n - - val sqrt : n -> n - - val coq_lor : n -> n -> n - - val coq_land : n -> n -> n - - val ldiff : n -> n -> n - - val coq_lxor : n -> n -> n - - val shiftl_nat : n -> nat -> n - - val shiftr_nat : n -> nat -> n - - val shiftl : n -> n -> n - - val shiftr : n -> n -> n - - val testbit_nat : n -> nat -> bool - - val testbit : n -> n -> bool - + val to_nat : n -> nat - + val of_nat : nat -> n - - val iter : n -> ('a1 -> 'a1) -> 'a1 -> 'a1 - - val eq_dec : n -> n -> sumbool - - val discr : n -> positive sumor - - val binary_rect : 'a1 -> (n -> 'a1 -> 'a1) -> (n -> 'a1 -> 'a1) -> n -> 'a1 - - val binary_rec : 'a1 -> (n -> 'a1 -> 'a1) -> (n -> 'a1 -> 'a1) -> n -> 'a1 - - val peano_rect : 'a1 -> (n -> 'a1 -> 'a1) -> n -> 'a1 - - val peano_rec : 'a1 -> (n -> 'a1 -> 'a1) -> n -> 'a1 - - val leb_spec0 : n -> n -> reflect - - val ltb_spec0 : n -> n -> reflect - - module Private_BootStrap : - sig - - end - - val recursion : 'a1 -> (n -> 'a1 -> 'a1) -> n -> 'a1 - - module Private_OrderTac : - sig - module Elts : - sig - type t = n - end - - module Tac : - sig - - end - end - - module Private_NZPow : - sig - - end - - module Private_NZSqrt : - sig - - end - - val sqrt_up : n -> n - - val log2_up : n -> n - - module Private_NZDiv : - sig - - end - - val lcm : n -> n -> n - - val eqb_spec : n -> n -> reflect - - val b2n : bool -> n - - val setbit : n -> n -> n - - val clearbit : n -> n -> n - - val ones : n -> n - - val lnot : n -> n -> n - - module Private_Tac : - sig - - end - - module Private_Rev : - sig - module ORev : - sig - type t = n - end - - module MRev : - sig - val max : n -> n -> n - end - - module MPRev : - sig - module Private_Tac : - sig - - end - end - end - - module Private_Dec : - sig - val max_case_strong : - n -> n -> (n -> n -> __ -> 'a1 -> 'a1) -> (__ -> 'a1) -> (__ -> 'a1) -> - 'a1 - - val max_case : - n -> n -> (n -> n -> __ -> 'a1 -> 'a1) -> 'a1 -> 'a1 -> 'a1 - - val max_dec : n -> n -> sumbool - - val min_case_strong : - n -> n -> (n -> n -> __ -> 'a1 -> 'a1) -> (__ -> 'a1) -> (__ -> 'a1) -> - 'a1 - - val min_case : - n -> n -> (n -> n -> __ -> 'a1 -> 'a1) -> 'a1 -> 'a1 -> 'a1 - - val min_dec : n -> n -> sumbool - end - - val max_case_strong : n -> n -> (__ -> 'a1) -> (__ -> 'a1) -> 'a1 - - val max_case : n -> n -> 'a1 -> 'a1 -> 'a1 - - val max_dec : n -> n -> sumbool - - val min_case_strong : n -> n -> (__ -> 'a1) -> (__ -> 'a1) -> 'a1 - - val min_case : n -> n -> 'a1 -> 'a1 -> 'a1 - - val min_dec : n -> n -> sumbool end -module Z : - sig - type t = z - - val zero : z - - val one : z - - val two : z - +module Z : + sig val double : z -> z - - val succ_double : z -> z - - val pred_double : z -> z - - val pos_sub : positive -> positive -> z - - val add : z -> z -> z - - val opp : z -> z - - val succ : z -> z - - val pred : z -> z - - val sub : z -> z -> z - - val mul : z -> z -> z - - val pow_pos : z -> positive -> z - - val pow : z -> z -> z - - val square : z -> z - - val compare : z -> z -> ExtrNative.comparison - - val sgn : z -> z - - val leb : z -> z -> bool - - val ltb : z -> z -> bool - - val geb : z -> z -> bool - - val gtb : z -> z -> bool - - val eqb : z -> z -> bool - - val max : z -> z -> z - - val min : z -> z -> z - - val abs : z -> z - - val abs_nat : z -> nat - - val abs_N : z -> n - - val to_nat : z -> nat - - val to_N : z -> n - - val of_nat : nat -> z - - val of_N : n -> z - - val iter : z -> ('a1 -> 'a1) -> 'a1 -> 'a1 - - val pos_div_eucl : positive -> z -> z*z - - val div_eucl : z -> z -> z*z - - val div : z -> z -> z - - val modulo : z -> z -> z - - val quotrem : z -> z -> z*z - - val quot : z -> z -> z - - val rem : z -> z -> z - - val even : z -> bool - - val odd : z -> bool - - val div2 : z -> z - - val quot2 : z -> z - - val log2 : z -> z - - val sqrtrem : z -> z*z - - val sqrt : z -> z - - val gcd : z -> z -> z - - val ggcd : z -> z -> z*(z*z) - - val testbit : z -> z -> bool - - val shiftl : z -> z -> z - - val shiftr : z -> z -> z - - val coq_lor : z -> z -> z - - val coq_land : z -> z -> z - - val ldiff : z -> z -> z - - val coq_lxor : z -> z -> z - - val eq_dec : z -> z -> sumbool - - module Private_BootStrap : - sig - - end - - val leb_spec0 : z -> z -> reflect - - val ltb_spec0 : z -> z -> reflect - - module Private_OrderTac : - sig - module Elts : - sig - type t = z - end - - module Tac : - sig - - end - end - - val sqrt_up : z -> z - - val log2_up : z -> z - - module Private_NZDiv : - sig - - end - - module Private_Div : - sig - module Quot2Div : - sig - val div : z -> z -> z - - val modulo : z -> z -> z - end - - module NZQuot : - sig - - end - end - - val lcm : z -> z -> z - - val eqb_spec : z -> z -> reflect - - val b2z : bool -> z - - val setbit : z -> z -> z - - val clearbit : z -> z -> z - - val lnot : z -> z - - val ones : z -> z - - module Private_Tac : - sig - - end - - module Private_Rev : - sig - module ORev : - sig - type t = z - end - - module MRev : - sig - val max : z -> z -> z - end - - module MPRev : - sig - module Private_Tac : - sig - - end - end - end - - module Private_Dec : - sig - val max_case_strong : - z -> z -> (z -> z -> __ -> 'a1 -> 'a1) -> (__ -> 'a1) -> (__ -> 'a1) -> - 'a1 - - val max_case : - z -> z -> (z -> z -> __ -> 'a1 -> 'a1) -> 'a1 -> 'a1 -> 'a1 - - val max_dec : z -> z -> sumbool - - val min_case_strong : - z -> z -> (z -> z -> __ -> 'a1 -> 'a1) -> (__ -> 'a1) -> (__ -> 'a1) -> - 'a1 - - val min_case : - z -> z -> (z -> z -> __ -> 'a1 -> 'a1) -> 'a1 -> 'a1 -> 'a1 - - val min_dec : z -> z -> sumbool - end - - val max_case_strong : z -> z -> (__ -> 'a1) -> (__ -> 'a1) -> 'a1 - - val max_case : z -> z -> 'a1 -> 'a1 -> 'a1 - - val max_dec : z -> z -> sumbool - - val min_case_strong : z -> z -> (__ -> 'a1) -> (__ -> 'a1) -> 'a1 - - val min_case : z -> z -> 'a1 -> 'a1 -> 'a1 - - val min_dec : z -> z -> sumbool - end - -val zeq_bool : z -> z -> bool - -val nth : nat -> 'a1 list -> 'a1 -> 'a1 - -val map : ('a1 -> 'a2) -> 'a1 list -> 'a2 list - -val fold_right : ('a2 -> 'a1 -> 'a1) -> 'a1 -> 'a2 list -> 'a1 - -val existsb : ('a1 -> bool) -> 'a1 list -> bool - -val forallb : ('a1 -> bool) -> 'a1 list -> bool - -type int = ExtrNative.uint - -val lsl0 : int -> int -> int - -val lsr0 : int -> int -> int - -val land0 : int -> int -> int - -val lxor0 : int -> int -> int - -val sub0 : int -> int -> int - -val eqb0 : int -> int -> bool - -val ltb0 : int -> int -> bool - -val leb0 : int -> int -> bool - -val foldi_cont : - (int -> ('a1 -> 'a2) -> 'a1 -> 'a2) -> int -> int -> ('a1 -> 'a2) -> 'a1 -> - 'a2 - -val foldi_down_cont : - (int -> ('a1 -> 'a2) -> 'a1 -> 'a2) -> int -> int -> ('a1 -> 'a2) -> 'a1 -> - 'a2 - -val is_zero : int -> bool - -val is_even : int -> bool - -val compare0 : int -> int -> ExtrNative.comparison - -val foldi : (int -> 'a1 -> 'a1) -> int -> int -> 'a1 -> 'a1 - -val fold : ('a1 -> 'a1) -> int -> int -> 'a1 -> 'a1 - -val foldi_down : (int -> 'a1 -> 'a1) -> int -> int -> 'a1 -> 'a1 - -val forallb0 : (int -> bool) -> int -> int -> bool -val existsb0 : (int -> bool) -> int -> int -> bool - -val cast : int -> int -> (__ -> __ -> __) option - -val reflect_eqb : int -> int -> reflect + val succ_double : z -> z -type 'a array = 'a ExtrNative.parray + val pred_double : z -> z -val make : int -> 'a1 -> 'a1 array + val pos_sub : positive -> positive -> z -val get : 'a1 array -> int -> 'a1 + val add : z -> z -> z -val default : 'a1 array -> 'a1 + val opp : z -> z -val set : 'a1 array -> int -> 'a1 -> 'a1 array + val sub : z -> z -> z -val length : 'a1 array -> int + val mul : z -> z -> z -val to_list : 'a1 array -> 'a1 list + val compare : z -> z -> int -val forallbi : (int -> 'a1 -> bool) -> 'a1 array -> bool + val leb : z -> z -> bool -val forallb1 : ('a1 -> bool) -> 'a1 array -> bool + val ltb : z -> z -> bool -val existsb1 : ('a1 -> bool) -> 'a1 array -> bool + val gtb : z -> z -> bool -val mapi : (int -> 'a1 -> 'a2) -> 'a1 array -> 'a2 array + val eqb : z -> z -> bool -val foldi_left : (int -> 'a1 -> 'a2 -> 'a1) -> 'a1 -> 'a2 array -> 'a1 + val max : z -> z -> z -val fold_left : ('a1 -> 'a2 -> 'a1) -> 'a1 -> 'a2 array -> 'a1 + val abs : z -> z -val foldi_right : (int -> 'a1 -> 'a2 -> 'a2) -> 'a1 array -> 'a2 -> 'a2 + val of_nat : nat -> z -module Valuation : - sig - type t = int -> bool - end + val pos_div_eucl : positive -> z -> z * z -module Var : - sig - val _true : int - - val _false : int - - val interp : Valuation.t -> int -> bool - end + val div_eucl : z -> z -> z * z -module Lit : - sig - val is_pos : int -> bool - - val blit : int -> int - - val lit : int -> int - - val neg : int -> int - - val nlit : int -> int - - val _true : int - - val _false : int - - val eqb : int -> int -> bool - - val interp : Valuation.t -> int -> bool - end + val div : z -> z -> z -module C : - sig - type t = int list - - val interp : Valuation.t -> t -> bool - - val _true : t - - val is_false : t -> bool - - val or_aux : (t -> t -> t) -> int -> t -> t -> int list - - val coq_or : t -> t -> t - - val resolve_aux : (t -> t -> t) -> int -> t -> t -> t - - val resolve : t -> t -> t - end + val gcd : z -> z -> z -module S : - sig - type t = C.t array - - val get : t -> int -> C.t - - val internal_set : t -> int -> C.t -> t - - val make : int -> t - - val insert : int -> int list -> int list - - val sort_uniq : int list -> int list - - val set_clause : t -> int -> C.t -> t - - val set_resolve : t -> int -> int array -> t + val eq_dec : z -> z -> sumbool end -val afold_left : - 'a1 -> ('a1 -> 'a1 -> 'a1) -> ('a2 -> 'a1) -> 'a2 array -> 'a1 - -val afold_right : - 'a1 -> ('a1 -> 'a1 -> 'a1) -> ('a2 -> 'a1) -> 'a2 array -> 'a1 +val nth : nat -> 'a1 list -> 'a1 -> 'a1 -val rev_aux : 'a1 list -> 'a1 list -> 'a1 list +val removelast : 'a1 list -> 'a1 list val rev : 'a1 list -> 'a1 list -val distinct_aux2 : ('a1 -> 'a1 -> bool) -> bool -> 'a1 -> 'a1 list -> bool - -val distinct_aux : ('a1 -> 'a1 -> bool) -> bool -> 'a1 list -> bool - -val distinct : ('a1 -> 'a1 -> bool) -> 'a1 list -> bool - -val forallb2 : ('a1 -> 'a2 -> bool) -> 'a1 list -> 'a2 list -> bool - -module Form : - sig - type form = - | Fatom of int - | Ftrue - | Ffalse - | Fnot2 of int * int - | Fand of int array - | For of int array - | Fimp of int array - | Fxor of int * int - | Fiff of int * int - | Fite of int * int * int - - val form_rect : - (int -> 'a1) -> 'a1 -> 'a1 -> (int -> int -> 'a1) -> (int array -> 'a1) - -> (int array -> 'a1) -> (int array -> 'a1) -> (int -> int -> 'a1) -> - (int -> int -> 'a1) -> (int -> int -> int -> 'a1) -> form -> 'a1 - - val form_rec : - (int -> 'a1) -> 'a1 -> 'a1 -> (int -> int -> 'a1) -> (int array -> 'a1) - -> (int array -> 'a1) -> (int array -> 'a1) -> (int -> int -> 'a1) -> - (int -> int -> 'a1) -> (int -> int -> int -> 'a1) -> form -> 'a1 - - val is_Ftrue : form -> bool - - val is_Ffalse : form -> bool - - val interp_aux : (int -> bool) -> (int -> bool) -> form -> bool - - val t_interp : (int -> bool) -> form array -> bool array - - val lt_form : int -> form -> bool - - val wf : form array -> bool - - val interp_state_var : (int -> bool) -> form array -> int -> bool - - val interp : (int -> bool) -> form array -> form -> bool - - val check_form : form array -> bool - end - -type typ_eqb = { te_eqb : (__ -> __ -> bool); - te_reflect : (__ -> __ -> reflect) } - -type te_carrier = __ - -val te_eqb : typ_eqb -> te_carrier -> te_carrier -> bool - -module Typ : - sig - type coq_type = - | Tindex of int - | TZ - | Tbool - | Tpositive - - val type_rect : (int -> 'a1) -> 'a1 -> 'a1 -> 'a1 -> coq_type -> 'a1 - - val type_rec : (int -> 'a1) -> 'a1 -> 'a1 -> 'a1 -> coq_type -> 'a1 - - type ftype = coq_type list*coq_type - - type interp = __ - - type interp_ftype = __ - - val i_eqb : typ_eqb array -> coq_type -> interp -> interp -> bool - - val reflect_i_eqb : - typ_eqb array -> coq_type -> interp -> interp -> reflect - - type cast_result = - | Cast of (__ -> __ -> __) - | NoCast - - val cast_result_rect : - coq_type -> coq_type -> ((__ -> __ -> __) -> 'a1) -> 'a1 -> cast_result - -> 'a1 - - val cast_result_rec : - coq_type -> coq_type -> ((__ -> __ -> __) -> 'a1) -> 'a1 -> cast_result - -> 'a1 - - val cast : coq_type -> coq_type -> cast_result - - val eqb : coq_type -> coq_type -> bool - - val reflect_eqb : coq_type -> coq_type -> reflect - end - -val list_beq : ('a1 -> 'a1 -> bool) -> 'a1 list -> 'a1 list -> bool - -val reflect_list_beq : - ('a1 -> 'a1 -> bool) -> ('a1 -> 'a1 -> reflect) -> 'a1 list -> 'a1 list -> - reflect - -module Atom : - sig - type cop = - | CO_xH - | CO_Z0 - - val cop_rect : 'a1 -> 'a1 -> cop -> 'a1 - - val cop_rec : 'a1 -> 'a1 -> cop -> 'a1 - - type unop = - | UO_xO - | UO_xI - | UO_Zpos - | UO_Zneg - | UO_Zopp - - val unop_rect : 'a1 -> 'a1 -> 'a1 -> 'a1 -> 'a1 -> unop -> 'a1 - - val unop_rec : 'a1 -> 'a1 -> 'a1 -> 'a1 -> 'a1 -> unop -> 'a1 - - type binop = - | BO_Zplus - | BO_Zminus - | BO_Zmult - | BO_Zlt - | BO_Zle - | BO_Zge - | BO_Zgt - | BO_eq of Typ.coq_type - - val binop_rect : - 'a1 -> 'a1 -> 'a1 -> 'a1 -> 'a1 -> 'a1 -> 'a1 -> (Typ.coq_type -> 'a1) -> - binop -> 'a1 - - val binop_rec : - 'a1 -> 'a1 -> 'a1 -> 'a1 -> 'a1 -> 'a1 -> 'a1 -> (Typ.coq_type -> 'a1) -> - binop -> 'a1 - - type nop = - Typ.coq_type - (* singleton inductive, whose constructor was NO_distinct *) - - val nop_rect : (Typ.coq_type -> 'a1) -> nop -> 'a1 - - val nop_rec : (Typ.coq_type -> 'a1) -> nop -> 'a1 - - type atom = - | Acop of cop - | Auop of unop * int - | Abop of binop * int * int - | Anop of nop * int list - | Aapp of int * int list - - val atom_rect : - (cop -> 'a1) -> (unop -> int -> 'a1) -> (binop -> int -> int -> 'a1) -> - (nop -> int list -> 'a1) -> (int -> int list -> 'a1) -> atom -> 'a1 - - val atom_rec : - (cop -> 'a1) -> (unop -> int -> 'a1) -> (binop -> int -> int -> 'a1) -> - (nop -> int list -> 'a1) -> (int -> int list -> 'a1) -> atom -> 'a1 - - val cop_eqb : cop -> cop -> bool - - val uop_eqb : unop -> unop -> bool - - val bop_eqb : binop -> binop -> bool - - val nop_eqb : nop -> nop -> bool - - val eqb : atom -> atom -> bool - - val reflect_cop_eqb : cop -> cop -> reflect - - val reflect_uop_eqb : unop -> unop -> reflect - - val reflect_bop_eqb : binop -> binop -> reflect - - val reflect_nop_eqb : nop -> nop -> reflect - - val reflect_eqb : atom -> atom -> reflect - - type ('t, 'i) coq_val = { v_type : 't; v_val : 'i } - - val val_rect : ('a1 -> 'a2 -> 'a3) -> ('a1, 'a2) coq_val -> 'a3 - - val val_rec : ('a1 -> 'a2 -> 'a3) -> ('a1, 'a2) coq_val -> 'a3 - - val v_type : ('a1, 'a2) coq_val -> 'a1 - - val v_val : ('a1, 'a2) coq_val -> 'a2 - - type bval = (Typ.coq_type, Typ.interp) coq_val - - val coq_Bval : - typ_eqb array -> Typ.coq_type -> Typ.interp -> (Typ.coq_type, Typ.interp) - coq_val - - type tval = (Typ.ftype, Typ.interp_ftype) coq_val - - val coq_Tval : - typ_eqb array -> Typ.ftype -> Typ.interp_ftype -> (Typ.ftype, - Typ.interp_ftype) coq_val - - val bvtrue : typ_eqb array -> bval - - val bvfalse : typ_eqb array -> bval - - val typ_cop : cop -> Typ.coq_type - - val typ_uop : unop -> Typ.coq_type*Typ.coq_type - - val typ_bop : binop -> (Typ.coq_type*Typ.coq_type)*Typ.coq_type - - val typ_nop : nop -> Typ.coq_type*Typ.coq_type - - val check_args : - (int -> Typ.coq_type) -> int list -> Typ.coq_type list -> bool - - val check_aux : - typ_eqb array -> tval array -> (int -> Typ.coq_type) -> atom -> - Typ.coq_type -> bool - - val check_args_dec : - (int -> Typ.coq_type) -> Typ.coq_type -> int list -> Typ.coq_type list -> - sumbool - - val check_aux_dec : - typ_eqb array -> tval array -> (int -> Typ.coq_type) -> atom -> sumbool - - val apply_unop : - typ_eqb array -> Typ.coq_type -> Typ.coq_type -> (Typ.interp -> - Typ.interp) -> bval -> (Typ.coq_type, Typ.interp) coq_val - - val apply_binop : - typ_eqb array -> Typ.coq_type -> Typ.coq_type -> Typ.coq_type -> - (Typ.interp -> Typ.interp -> Typ.interp) -> bval -> bval -> - (Typ.coq_type, Typ.interp) coq_val - - val apply_func : - typ_eqb array -> Typ.coq_type list -> Typ.coq_type -> Typ.interp_ftype -> - bval list -> bval - - val interp_cop : typ_eqb array -> cop -> (Typ.coq_type, Typ.interp) coq_val - - val interp_uop : - typ_eqb array -> unop -> bval -> (Typ.coq_type, Typ.interp) coq_val - - val interp_bop : - typ_eqb array -> binop -> bval -> bval -> (Typ.coq_type, Typ.interp) - coq_val - - val compute_interp : - typ_eqb array -> (int -> bval) -> Typ.coq_type -> Typ.interp list -> int - list -> Typ.interp list option - - val interp_aux : - typ_eqb array -> tval array -> (int -> bval) -> atom -> bval - - val interp_bool : typ_eqb array -> bval -> bool - - val t_interp : typ_eqb array -> tval array -> atom array -> bval array - - val lt_atom : int -> atom -> bool - - val wf : atom array -> bool - - val get_type' : typ_eqb array -> bval array -> int -> Typ.coq_type - - val get_type : - typ_eqb array -> tval array -> atom array -> int -> Typ.coq_type - - val wt : typ_eqb array -> tval array -> atom array -> bool - - val interp_hatom : typ_eqb array -> tval array -> atom array -> int -> bval - - val interp : typ_eqb array -> tval array -> atom array -> atom -> bval - - val interp_form_hatom : - typ_eqb array -> tval array -> atom array -> int -> bool - - val check_atom : atom array -> bool - end - -val or_of_imp : int array -> int array - -val check_True : C.t - -val check_False : int list - -val check_BuildDef : Form.form array -> int -> C.t - -val check_ImmBuildDef : Form.form array -> S.t -> int -> C.t - -val check_BuildDef2 : Form.form array -> int -> C.t - -val check_ImmBuildDef2 : Form.form array -> S.t -> int -> C.t +val rev_append : 'a1 list -> 'a1 list -> 'a1 list -val check_BuildProj : Form.form array -> int -> int -> C.t +val map : ('a1 -> 'a2) -> 'a1 list -> 'a2 list -val check_ImmBuildProj : Form.form array -> S.t -> int -> int -> C.t +val fold_left : ('a1 -> 'a2 -> 'a1) -> 'a2 list -> 'a1 -> 'a1 -val get_eq : - Form.form array -> Atom.atom array -> int -> (int -> int -> C.t) -> C.t +val fold_right : ('a2 -> 'a1 -> 'a1) -> 'a1 -> 'a2 list -> 'a1 -val check_trans_aux : - Form.form array -> Atom.atom array -> int -> int -> int list -> int -> C.t - -> C.t +val existsb : ('a1 -> bool) -> 'a1 list -> bool -val check_trans : - Form.form array -> Atom.atom array -> int -> int list -> C.t +val forallb : ('a1 -> bool) -> 'a1 list -> bool -val build_congr : - Form.form array -> Atom.atom array -> int option list -> int list -> int - list -> C.t -> C.t +val firstn : nat -> 'a1 list -> 'a1 list -val check_congr : - Form.form array -> Atom.atom array -> int -> int option list -> C.t +val zeq_bool : z -> z -> bool -val check_congr_pred : - Form.form array -> Atom.atom array -> int -> int -> int option list -> C.t +type 'c pExpr = +| PEc of 'c +| PEX of positive +| PEadd of 'c pExpr * 'c pExpr +| PEsub of 'c pExpr * 'c pExpr +| PEmul of 'c pExpr * 'c pExpr +| PEopp of 'c pExpr +| PEpow of 'c pExpr * n type 'c pol = | Pc of 'c @@ -1485,15 +302,6 @@ val psquare : 'a1 -> 'a1 -> ('a1 -> 'a1 -> 'a1) -> ('a1 -> 'a1 -> 'a1) -> ('a1 -> 'a1 -> bool) -> 'a1 pol -> 'a1 pol -type 'c pExpr = -| PEc of 'c -| PEX of positive -| PEadd of 'c pExpr * 'c pExpr -| PEsub of 'c pExpr * 'c pExpr -| PEmul of 'c pExpr * 'c pExpr -| PEopp of 'c pExpr -| PEpow of 'c pExpr * n - val mk_X : 'a1 -> 'a1 -> positive -> 'a1 pol val ppow_pos : @@ -1508,51 +316,105 @@ val norm_aux : 'a1 -> 'a1 -> ('a1 -> 'a1 -> 'a1) -> ('a1 -> 'a1 -> 'a1) -> ('a1 -> 'a1 -> 'a1) -> ('a1 -> 'a1) -> ('a1 -> 'a1 -> bool) -> 'a1 pExpr -> 'a1 pol -type 'a bFormula = -| TT -| FF -| X -| A of 'a -| Cj of 'a bFormula * 'a bFormula -| D of 'a bFormula * 'a bFormula -| N of 'a bFormula -| I of 'a bFormula * 'a bFormula +type kind = +| IsProp +| IsBool + +type ('tA, 'tX, 'aA, 'aF) gFormula = +| TT of kind +| FF of kind +| X of kind * 'tX +| A of kind * 'tA * 'aA +| AND of kind * ('tA, 'tX, 'aA, 'aF) gFormula * ('tA, 'tX, 'aA, 'aF) gFormula +| OR of kind * ('tA, 'tX, 'aA, 'aF) gFormula * ('tA, 'tX, 'aA, 'aF) gFormula +| NOT of kind * ('tA, 'tX, 'aA, 'aF) gFormula +| IMPL of kind * ('tA, 'tX, 'aA, 'aF) gFormula * 'aF option + * ('tA, 'tX, 'aA, 'aF) gFormula +| IFF of kind * ('tA, 'tX, 'aA, 'aF) gFormula * ('tA, 'tX, 'aA, 'aF) gFormula +| EQ of ('tA, 'tX, 'aA, 'aF) gFormula * ('tA, 'tX, 'aA, 'aF) gFormula + +type rtyp = __ + +type eKind = __ -type 'term' clause = 'term' list +type 'a bFormula = ('a, eKind, unit0, unit0) gFormula -type 'term' cnf = 'term' clause list +type ('x, 'annot) clause = ('x * 'annot) list -val tt : 'a1 cnf +type ('x, 'annot) cnf = ('x, 'annot) clause list -val ff : 'a1 cnf +val cnf_tt : ('a1, 'a2) cnf + +val cnf_ff : ('a1, 'a2) cnf val add_term : - ('a1 -> bool) -> ('a1 -> 'a1 -> 'a1 option) -> 'a1 -> 'a1 clause -> 'a1 - clause option + ('a1 -> bool) -> ('a1 -> 'a1 -> 'a1 option) -> ('a1 * 'a2) -> ('a1, 'a2) + clause -> ('a1, 'a2) clause option val or_clause : - ('a1 -> bool) -> ('a1 -> 'a1 -> 'a1 option) -> 'a1 clause -> 'a1 clause -> - 'a1 clause option + ('a1 -> bool) -> ('a1 -> 'a1 -> 'a1 option) -> ('a1, 'a2) clause -> ('a1, + 'a2) clause -> ('a1, 'a2) clause option + +val xor_clause_cnf : + ('a1 -> bool) -> ('a1 -> 'a1 -> 'a1 option) -> ('a1, 'a2) clause -> ('a1, + 'a2) cnf -> ('a1, 'a2) cnf val or_clause_cnf : - ('a1 -> bool) -> ('a1 -> 'a1 -> 'a1 option) -> 'a1 clause -> 'a1 cnf -> 'a1 - cnf + ('a1 -> bool) -> ('a1 -> 'a1 -> 'a1 option) -> ('a1, 'a2) clause -> ('a1, + 'a2) cnf -> ('a1, 'a2) cnf val or_cnf : - ('a1 -> bool) -> ('a1 -> 'a1 -> 'a1 option) -> 'a1 cnf -> 'a1 cnf -> 'a1 - cnf + ('a1 -> bool) -> ('a1 -> 'a1 -> 'a1 option) -> ('a1, 'a2) cnf -> ('a1, 'a2) + cnf -> ('a1, 'a2) cnf + +val and_cnf : ('a1, 'a2) cnf -> ('a1, 'a2) cnf -> ('a1, 'a2) cnf + +type ('term, 'annot, 'tX, 'aF) tFormula = ('term, 'tX, 'annot, 'aF) gFormula + +val is_cnf_tt : ('a1, 'a2) cnf -> bool + +val is_cnf_ff : ('a1, 'a2) cnf -> bool + +val and_cnf_opt : ('a1, 'a2) cnf -> ('a1, 'a2) cnf -> ('a1, 'a2) cnf -val and_cnf : 'a1 cnf -> 'a1 cnf -> 'a1 cnf +val or_cnf_opt : + ('a1 -> bool) -> ('a1 -> 'a1 -> 'a1 option) -> ('a1, 'a2) cnf -> ('a1, 'a2) + cnf -> ('a1, 'a2) cnf + +val mk_and : + ('a2 -> bool) -> ('a2 -> 'a2 -> 'a2 option) -> (bool -> kind -> ('a1, 'a3, + 'a4, 'a5) tFormula -> ('a2, 'a3) cnf) -> kind -> bool -> ('a1, 'a3, 'a4, + 'a5) tFormula -> ('a1, 'a3, 'a4, 'a5) tFormula -> ('a2, 'a3) cnf + +val mk_or : + ('a2 -> bool) -> ('a2 -> 'a2 -> 'a2 option) -> (bool -> kind -> ('a1, 'a3, + 'a4, 'a5) tFormula -> ('a2, 'a3) cnf) -> kind -> bool -> ('a1, 'a3, 'a4, + 'a5) tFormula -> ('a1, 'a3, 'a4, 'a5) tFormula -> ('a2, 'a3) cnf + +val mk_impl : + ('a2 -> bool) -> ('a2 -> 'a2 -> 'a2 option) -> (bool -> kind -> ('a1, 'a3, + 'a4, 'a5) tFormula -> ('a2, 'a3) cnf) -> kind -> bool -> ('a1, 'a3, 'a4, + 'a5) tFormula -> ('a1, 'a3, 'a4, 'a5) tFormula -> ('a2, 'a3) cnf + +val mk_iff : + ('a2 -> bool) -> ('a2 -> 'a2 -> 'a2 option) -> (bool -> kind -> ('a1, 'a3, + 'a4, 'a5) tFormula -> ('a2, 'a3) cnf) -> kind -> bool -> ('a1, 'a3, 'a4, + 'a5) tFormula -> ('a1, 'a3, 'a4, 'a5) tFormula -> ('a2, 'a3) cnf + +val is_bool : kind -> ('a1, 'a2, 'a3, 'a4) tFormula -> bool option val xcnf : - ('a2 -> bool) -> ('a2 -> 'a2 -> 'a2 option) -> ('a1 -> 'a2 cnf) -> ('a1 -> - 'a2 cnf) -> bool -> 'a1 bFormula -> 'a2 cnf + ('a2 -> bool) -> ('a2 -> 'a2 -> 'a2 option) -> ('a1 -> 'a3 -> ('a2, 'a3) + cnf) -> ('a1 -> 'a3 -> ('a2, 'a3) cnf) -> bool -> kind -> ('a1, 'a3, 'a4, + 'a5) tFormula -> ('a2, 'a3) cnf -val cnf_checker : ('a1 list -> 'a2 -> bool) -> 'a1 cnf -> 'a2 list -> bool +val cnf_checker : + (('a1 * 'a2) list -> 'a3 -> bool) -> ('a1, 'a2) cnf -> 'a3 list -> bool val tauto_checker : - ('a2 -> bool) -> ('a2 -> 'a2 -> 'a2 option) -> ('a1 -> 'a2 cnf) -> ('a1 -> - 'a2 cnf) -> ('a2 list -> 'a3 -> bool) -> 'a1 bFormula -> 'a3 list -> bool + ('a2 -> bool) -> ('a2 -> 'a2 -> 'a2 option) -> ('a1 -> 'a3 -> ('a2, 'a3) + cnf) -> ('a1 -> 'a3 -> ('a2, 'a3) cnf) -> (('a2 * 'a3) list -> 'a4 -> bool) + -> ('a1, rtyp, 'a3, unit0) gFormula -> 'a4 list -> bool val cneqb : ('a1 -> 'a1 -> bool) -> 'a1 -> 'a1 -> bool @@ -1566,7 +428,7 @@ type op1 = | Strict | NonStrict -type 'c nFormula = 'c polC*op1 +type 'c nFormula = 'c polC * op1 val opMult : op1 -> op1 -> op1 option @@ -1634,19 +496,23 @@ val psub1 : z pol -> z pol -> z pol val padd1 : z pol -> z pol -> z pol -val norm0 : z pExpr -> z pol +val normZ : z pExpr -> z pol -val xnormalise : z formula -> z nFormula list +val zunsat : z nFormula -> bool -val normalise : z formula -> z nFormula cnf +val zdeduce : z nFormula -> z nFormula -> z nFormula option -val xnegate : z formula -> z nFormula list +val xnnormalise : z formula -> z nFormula -val negate : z formula -> z nFormula cnf +val xnormalise : z nFormula -> z nFormula list -val zunsat : z nFormula -> bool +val cnf_of_list : 'a1 -> z nFormula list -> (z nFormula * 'a1) list list -val zdeduce : z nFormula -> z nFormula -> z nFormula option +val normalise : z formula -> 'a1 -> (z nFormula, 'a1) cnf + +val xnegate : z nFormula -> z nFormula list + +val negate : z formula -> 'a1 -> (z nFormula, 'a1) cnf val ceiling : z -> z -> z @@ -1655,18 +521,19 @@ type zArithProof = | RatProof of zWitness * zArithProof | CutProof of zWitness * zArithProof | EnumProof of zWitness * zWitness * zArithProof list +| ExProof of positive * zArithProof val zgcdM : z -> z -> z -val zgcd_pol : z polC -> z*z +val zgcd_pol : z polC -> z * z val zdiv_pol : z polC -> z -> z polC -val makeCuttingPlane : z polC -> z polC*z +val makeCuttingPlane : z polC -> z polC * z -val genCuttingPlane : z nFormula -> ((z polC*z)*op1) option +val genCuttingPlane : z nFormula -> ((z polC * z) * op1) option -val nformula_of_cutting_plane : ((z polC*z)*op1) -> z nFormula +val nformula_of_cutting_plane : ((z polC * z) * op1) -> z nFormula val is_pol_Z0 : z polC -> bool @@ -1674,228 +541,4592 @@ val eval_Psatz0 : z nFormula list -> zWitness -> z nFormula option val valid_cut_sign : op1 -> bool +val bound_var : positive -> z formula + +val mk_eq_pos : positive -> positive -> positive -> z formula + +val max_var : positive -> z pol -> positive + +val max_var_nformulae : z nFormula list -> positive + val zChecker : z nFormula list -> zArithProof -> bool val zTautoChecker : z formula bFormula -> zArithProof list -> bool +val size : nat + +val lsl0 : Uint63.t -> Uint63.t -> Uint63.t + +val lsr0 : Uint63.t -> Uint63.t -> Uint63.t + +val land0 : Uint63.t -> Uint63.t -> Uint63.t + +val lxor0 : Uint63.t -> Uint63.t -> Uint63.t + +val add0 : Uint63.t -> Uint63.t -> Uint63.t + +val sub0 : Uint63.t -> Uint63.t -> Uint63.t + +val eqb0 : Uint63.t -> Uint63.t -> bool + +val ltb0 : Uint63.t -> Uint63.t -> bool + +val leb0 : Uint63.t -> Uint63.t -> bool + +val digits : Uint63.t + +val is_zero : Uint63.t -> bool + +val is_even : Uint63.t -> bool + +val bit : Uint63.t -> Uint63.t -> bool + +val compare0 : Uint63.t -> Uint63.t -> int + +type 'x compare1 = +| LT +| EQ0 +| GT + +module type OrderedType = + sig + type t + + val compare : t -> t -> t compare1 + + val eq_dec : t -> t -> sumbool + end + +module OrderedTypeFacts : + functor (O:OrderedType) -> + sig + module TO : + sig + type t = O.t + end + + module IsTO : + sig + end + + module OrderTac : + sig + end + + val eq_dec : O.t -> O.t -> sumbool + + val lt_dec : O.t -> O.t -> sumbool + + val eqb : O.t -> O.t -> bool + end + +module KeyOrderedType : + functor (O:OrderedType) -> + sig + module MO : + sig + module TO : + sig + type t = O.t + end + + module IsTO : + sig + end + + module OrderTac : + sig + end + + val eq_dec : O.t -> O.t -> sumbool + + val lt_dec : O.t -> O.t -> sumbool + + val eqb : O.t -> O.t -> bool + end + end + +module Raw : + functor (X:OrderedType) -> + sig + module MX : + sig + module TO : + sig + type t = X.t + end + + module IsTO : + sig + end + + module OrderTac : + sig + end + + val eq_dec : X.t -> X.t -> sumbool + + val lt_dec : X.t -> X.t -> sumbool + + val eqb : X.t -> X.t -> bool + end + + module PX : + sig + module MO : + sig + module TO : + sig + type t = X.t + end + + module IsTO : + sig + end + + module OrderTac : + sig + end + + val eq_dec : X.t -> X.t -> sumbool + + val lt_dec : X.t -> X.t -> sumbool + + val eqb : X.t -> X.t -> bool + end + end + + type key = X.t + + type 'elt t = (X.t * 'elt) list + + val empty : 'a1 t + + val is_empty : 'a1 t -> bool + + val mem : key -> 'a1 t -> bool + + type 'elt coq_R_mem = + | R_mem_0 of 'elt t + | R_mem_1 of 'elt t * X.t * 'elt * (X.t * 'elt) list + | R_mem_2 of 'elt t * X.t * 'elt * (X.t * 'elt) list + | R_mem_3 of 'elt t * X.t * 'elt * (X.t * 'elt) list * bool * 'elt coq_R_mem + + val coq_R_mem_rect : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) list + -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) list -> + __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) list -> __ + -> __ -> __ -> bool -> 'a1 coq_R_mem -> 'a2 -> 'a2) -> 'a1 t -> bool -> + 'a1 coq_R_mem -> 'a2 + + val coq_R_mem_rec : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) list + -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) list -> + __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) list -> __ + -> __ -> __ -> bool -> 'a1 coq_R_mem -> 'a2 -> 'a2) -> 'a1 t -> bool -> + 'a1 coq_R_mem -> 'a2 + + val mem_rect : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) list + -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) list -> + __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) list -> __ + -> __ -> __ -> 'a2 -> 'a2) -> 'a1 t -> 'a2 + + val mem_rec : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) list + -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) list -> + __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) list -> __ + -> __ -> __ -> 'a2 -> 'a2) -> 'a1 t -> 'a2 + + val coq_R_mem_correct : key -> 'a1 t -> bool -> 'a1 coq_R_mem + + val find : key -> 'a1 t -> 'a1 option + + type 'elt coq_R_find = + | R_find_0 of 'elt t + | R_find_1 of 'elt t * X.t * 'elt * (X.t * 'elt) list + | R_find_2 of 'elt t * X.t * 'elt * (X.t * 'elt) list + | R_find_3 of 'elt t * X.t * 'elt * (X.t * 'elt) list * 'elt option + * 'elt coq_R_find + + val coq_R_find_rect : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) list + -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) list -> + __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) list -> __ + -> __ -> __ -> 'a1 option -> 'a1 coq_R_find -> 'a2 -> 'a2) -> 'a1 t -> + 'a1 option -> 'a1 coq_R_find -> 'a2 + + val coq_R_find_rec : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) list + -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) list -> + __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) list -> __ + -> __ -> __ -> 'a1 option -> 'a1 coq_R_find -> 'a2 -> 'a2) -> 'a1 t -> + 'a1 option -> 'a1 coq_R_find -> 'a2 + + val find_rect : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) list + -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) list -> + __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) list -> __ + -> __ -> __ -> 'a2 -> 'a2) -> 'a1 t -> 'a2 + + val find_rec : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) list + -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) list -> + __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) list -> __ + -> __ -> __ -> 'a2 -> 'a2) -> 'a1 t -> 'a2 + + val coq_R_find_correct : key -> 'a1 t -> 'a1 option -> 'a1 coq_R_find + + val add : key -> 'a1 -> 'a1 t -> 'a1 t + + type 'elt coq_R_add = + | R_add_0 of 'elt t + | R_add_1 of 'elt t * X.t * 'elt * (X.t * 'elt) list + | R_add_2 of 'elt t * X.t * 'elt * (X.t * 'elt) list + | R_add_3 of 'elt t * X.t * 'elt * (X.t * 'elt) list * 'elt t + * 'elt coq_R_add + + val coq_R_add_rect : + key -> 'a1 -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a1 t -> 'a1 coq_R_add -> 'a2 -> 'a2) -> 'a1 t + -> 'a1 t -> 'a1 coq_R_add -> 'a2 + + val coq_R_add_rec : + key -> 'a1 -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a1 t -> 'a1 coq_R_add -> 'a2 -> 'a2) -> 'a1 t + -> 'a1 t -> 'a1 coq_R_add -> 'a2 + + val add_rect : + key -> 'a1 -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2 -> 'a2) -> 'a1 t -> 'a2 + + val add_rec : + key -> 'a1 -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2 -> 'a2) -> 'a1 t -> 'a2 + + val coq_R_add_correct : key -> 'a1 -> 'a1 t -> 'a1 t -> 'a1 coq_R_add + + val remove : key -> 'a1 t -> 'a1 t + + type 'elt coq_R_remove = + | R_remove_0 of 'elt t + | R_remove_1 of 'elt t * X.t * 'elt * (X.t * 'elt) list + | R_remove_2 of 'elt t * X.t * 'elt * (X.t * 'elt) list + | R_remove_3 of 'elt t * X.t * 'elt * (X.t * 'elt) list * 'elt t + * 'elt coq_R_remove + + val coq_R_remove_rect : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) list + -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) list -> + __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) list -> __ + -> __ -> __ -> 'a1 t -> 'a1 coq_R_remove -> 'a2 -> 'a2) -> 'a1 t -> 'a1 t + -> 'a1 coq_R_remove -> 'a2 + + val coq_R_remove_rec : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) list + -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) list -> + __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) list -> __ + -> __ -> __ -> 'a1 t -> 'a1 coq_R_remove -> 'a2 -> 'a2) -> 'a1 t -> 'a1 t + -> 'a1 coq_R_remove -> 'a2 + + val remove_rect : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) list + -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) list -> + __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) list -> __ + -> __ -> __ -> 'a2 -> 'a2) -> 'a1 t -> 'a2 + + val remove_rec : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) list + -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) list -> + __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) list -> __ + -> __ -> __ -> 'a2 -> 'a2) -> 'a1 t -> 'a2 + + val coq_R_remove_correct : key -> 'a1 t -> 'a1 t -> 'a1 coq_R_remove + + val elements : 'a1 t -> 'a1 t + + val fold : (key -> 'a1 -> 'a2 -> 'a2) -> 'a1 t -> 'a2 -> 'a2 + + type ('elt, 'a) coq_R_fold = + | R_fold_0 of 'elt t * 'a + | R_fold_1 of 'elt t * 'a * X.t * 'elt * (X.t * 'elt) list * 'a + * ('elt, 'a) coq_R_fold + + val coq_R_fold_rect : + (key -> 'a1 -> 'a2 -> 'a2) -> ('a1 t -> 'a2 -> __ -> 'a3) -> ('a1 t -> + 'a2 -> X.t -> 'a1 -> (X.t * 'a1) list -> __ -> 'a2 -> ('a1, 'a2) + coq_R_fold -> 'a3 -> 'a3) -> 'a1 t -> 'a2 -> 'a2 -> ('a1, 'a2) coq_R_fold + -> 'a3 + + val coq_R_fold_rec : + (key -> 'a1 -> 'a2 -> 'a2) -> ('a1 t -> 'a2 -> __ -> 'a3) -> ('a1 t -> + 'a2 -> X.t -> 'a1 -> (X.t * 'a1) list -> __ -> 'a2 -> ('a1, 'a2) + coq_R_fold -> 'a3 -> 'a3) -> 'a1 t -> 'a2 -> 'a2 -> ('a1, 'a2) coq_R_fold + -> 'a3 + + val fold_rect : + (key -> 'a1 -> 'a2 -> 'a2) -> ('a1 t -> 'a2 -> __ -> 'a3) -> ('a1 t -> + 'a2 -> X.t -> 'a1 -> (X.t * 'a1) list -> __ -> 'a3 -> 'a3) -> 'a1 t -> + 'a2 -> 'a3 + + val fold_rec : + (key -> 'a1 -> 'a2 -> 'a2) -> ('a1 t -> 'a2 -> __ -> 'a3) -> ('a1 t -> + 'a2 -> X.t -> 'a1 -> (X.t * 'a1) list -> __ -> 'a3 -> 'a3) -> 'a1 t -> + 'a2 -> 'a3 + + val coq_R_fold_correct : + (key -> 'a1 -> 'a2 -> 'a2) -> 'a1 t -> 'a2 -> 'a2 -> ('a1, 'a2) coq_R_fold + + val equal : ('a1 -> 'a1 -> bool) -> 'a1 t -> 'a1 t -> bool + + type 'elt coq_R_equal = + | R_equal_0 of 'elt t * 'elt t + | R_equal_1 of 'elt t * 'elt t * X.t * 'elt * (X.t * 'elt) list * X.t + * 'elt * (X.t * 'elt) list * bool * 'elt coq_R_equal + | R_equal_2 of 'elt t * 'elt t * X.t * 'elt * (X.t * 'elt) list * X.t + * 'elt * (X.t * 'elt) list * X.t compare1 + | R_equal_3 of 'elt t * 'elt t * 'elt t * 'elt t + + val coq_R_equal_rect : + ('a1 -> 'a1 -> bool) -> ('a1 t -> 'a1 t -> __ -> __ -> 'a2) -> ('a1 t -> + 'a1 t -> X.t -> 'a1 -> (X.t * 'a1) list -> __ -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> bool -> 'a1 coq_R_equal -> 'a2 -> + 'a2) -> ('a1 t -> 'a1 t -> X.t -> 'a1 -> (X.t * 'a1) list -> __ -> X.t -> + 'a1 -> (X.t * 'a1) list -> __ -> X.t compare1 -> __ -> __ -> 'a2) -> ('a1 + t -> 'a1 t -> 'a1 t -> __ -> 'a1 t -> __ -> __ -> 'a2) -> 'a1 t -> 'a1 t + -> bool -> 'a1 coq_R_equal -> 'a2 + + val coq_R_equal_rec : + ('a1 -> 'a1 -> bool) -> ('a1 t -> 'a1 t -> __ -> __ -> 'a2) -> ('a1 t -> + 'a1 t -> X.t -> 'a1 -> (X.t * 'a1) list -> __ -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> bool -> 'a1 coq_R_equal -> 'a2 -> + 'a2) -> ('a1 t -> 'a1 t -> X.t -> 'a1 -> (X.t * 'a1) list -> __ -> X.t -> + 'a1 -> (X.t * 'a1) list -> __ -> X.t compare1 -> __ -> __ -> 'a2) -> ('a1 + t -> 'a1 t -> 'a1 t -> __ -> 'a1 t -> __ -> __ -> 'a2) -> 'a1 t -> 'a1 t + -> bool -> 'a1 coq_R_equal -> 'a2 + + val equal_rect : + ('a1 -> 'a1 -> bool) -> ('a1 t -> 'a1 t -> __ -> __ -> 'a2) -> ('a1 t -> + 'a1 t -> X.t -> 'a1 -> (X.t * 'a1) list -> __ -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> 'a2 -> 'a2) -> ('a1 t -> 'a1 t -> + X.t -> 'a1 -> (X.t * 'a1) list -> __ -> X.t -> 'a1 -> (X.t * 'a1) list -> + __ -> X.t compare1 -> __ -> __ -> 'a2) -> ('a1 t -> 'a1 t -> 'a1 t -> __ + -> 'a1 t -> __ -> __ -> 'a2) -> 'a1 t -> 'a1 t -> 'a2 + + val equal_rec : + ('a1 -> 'a1 -> bool) -> ('a1 t -> 'a1 t -> __ -> __ -> 'a2) -> ('a1 t -> + 'a1 t -> X.t -> 'a1 -> (X.t * 'a1) list -> __ -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> 'a2 -> 'a2) -> ('a1 t -> 'a1 t -> + X.t -> 'a1 -> (X.t * 'a1) list -> __ -> X.t -> 'a1 -> (X.t * 'a1) list -> + __ -> X.t compare1 -> __ -> __ -> 'a2) -> ('a1 t -> 'a1 t -> 'a1 t -> __ + -> 'a1 t -> __ -> __ -> 'a2) -> 'a1 t -> 'a1 t -> 'a2 + + val coq_R_equal_correct : + ('a1 -> 'a1 -> bool) -> 'a1 t -> 'a1 t -> bool -> 'a1 coq_R_equal + + val map : ('a1 -> 'a2) -> 'a1 t -> 'a2 t + + val mapi : (key -> 'a1 -> 'a2) -> 'a1 t -> 'a2 t + + val option_cons : key -> 'a1 option -> (key * 'a1) list -> (key * 'a1) list + + val map2_l : ('a1 option -> 'a2 option -> 'a3 option) -> 'a1 t -> 'a3 t + + val map2_r : ('a1 option -> 'a2 option -> 'a3 option) -> 'a2 t -> 'a3 t + + val map2 : + ('a1 option -> 'a2 option -> 'a3 option) -> 'a1 t -> 'a2 t -> 'a3 t + + val combine : 'a1 t -> 'a2 t -> ('a1 option * 'a2 option) t + + val fold_right_pair : + ('a1 -> 'a2 -> 'a3 -> 'a3) -> ('a1 * 'a2) list -> 'a3 -> 'a3 + + val map2_alt : + ('a1 option -> 'a2 option -> 'a3 option) -> 'a1 t -> 'a2 t -> (key * 'a3) + list + + val at_least_one : + 'a1 option -> 'a2 option -> ('a1 option * 'a2 option) option + + val at_least_one_then_f : + ('a1 option -> 'a2 option -> 'a3 option) -> 'a1 option -> 'a2 option -> + 'a3 option + end + +module type Int = + sig + type t + + val i2z : t -> z + + val _0 : t + + val _1 : t + + val _2 : t + + val _3 : t + + val add : t -> t -> t + + val opp : t -> t + + val sub : t -> t -> t + + val mul : t -> t -> t + + val max : t -> t -> t + + val eqb : t -> t -> bool + + val ltb : t -> t -> bool + + val leb : t -> t -> bool + + val gt_le_dec : t -> t -> sumbool + + val ge_lt_dec : t -> t -> sumbool + + val eq_dec : t -> t -> sumbool + end + +module Z_as_Int : + sig + type t = z + + val _0 : z + + val _1 : z + + val _2 : z + + val _3 : z + + val add : z -> z -> z + + val opp : z -> z + + val sub : z -> z -> z + + val mul : z -> z -> z + + val max : z -> z -> z + + val eqb : z -> z -> bool + + val ltb : z -> z -> bool + + val leb : z -> z -> bool + + val eq_dec : z -> z -> sumbool + + val gt_le_dec : z -> z -> sumbool + + val ge_lt_dec : z -> z -> sumbool + + val i2z : t -> z + end + +module Coq_Raw : + functor (I:Int) -> + functor (X:OrderedType) -> + sig + type key = X.t + + type 'elt tree = + | Leaf + | Node of 'elt tree * key * 'elt * 'elt tree * I.t + + val tree_rect : + 'a2 -> ('a1 tree -> 'a2 -> key -> 'a1 -> 'a1 tree -> 'a2 -> I.t -> 'a2) + -> 'a1 tree -> 'a2 + + val tree_rec : + 'a2 -> ('a1 tree -> 'a2 -> key -> 'a1 -> 'a1 tree -> 'a2 -> I.t -> 'a2) + -> 'a1 tree -> 'a2 + + val height : 'a1 tree -> I.t + + val cardinal : 'a1 tree -> nat + + val empty : 'a1 tree + + val is_empty : 'a1 tree -> bool + + val mem : X.t -> 'a1 tree -> bool + + val find : X.t -> 'a1 tree -> 'a1 option + + val create : 'a1 tree -> key -> 'a1 -> 'a1 tree -> 'a1 tree + + val assert_false : 'a1 tree -> key -> 'a1 -> 'a1 tree -> 'a1 tree + + val bal : 'a1 tree -> key -> 'a1 -> 'a1 tree -> 'a1 tree + + val add : key -> 'a1 -> 'a1 tree -> 'a1 tree + + val remove_min : + 'a1 tree -> key -> 'a1 -> 'a1 tree -> 'a1 tree * (key * 'a1) + + val merge : 'a1 tree -> 'a1 tree -> 'a1 tree + + val remove : X.t -> 'a1 tree -> 'a1 tree + + val join : 'a1 tree -> key -> 'a1 -> 'a1 tree -> 'a1 tree + + type 'elt triple = { t_left : 'elt tree; t_opt : 'elt option; + t_right : 'elt tree } + + val t_left : 'a1 triple -> 'a1 tree + + val t_opt : 'a1 triple -> 'a1 option + + val t_right : 'a1 triple -> 'a1 tree + + val split : X.t -> 'a1 tree -> 'a1 triple + + val concat : 'a1 tree -> 'a1 tree -> 'a1 tree + + val elements_aux : (key * 'a1) list -> 'a1 tree -> (key * 'a1) list + + val elements : 'a1 tree -> (key * 'a1) list + + val fold : (key -> 'a1 -> 'a2 -> 'a2) -> 'a1 tree -> 'a2 -> 'a2 + + type 'elt enumeration = + | End + | More of key * 'elt * 'elt tree * 'elt enumeration + + val enumeration_rect : + 'a2 -> (key -> 'a1 -> 'a1 tree -> 'a1 enumeration -> 'a2 -> 'a2) -> 'a1 + enumeration -> 'a2 + + val enumeration_rec : + 'a2 -> (key -> 'a1 -> 'a1 tree -> 'a1 enumeration -> 'a2 -> 'a2) -> 'a1 + enumeration -> 'a2 + + val cons : 'a1 tree -> 'a1 enumeration -> 'a1 enumeration + + val equal_more : + ('a1 -> 'a1 -> bool) -> X.t -> 'a1 -> ('a1 enumeration -> bool) -> 'a1 + enumeration -> bool + + val equal_cont : + ('a1 -> 'a1 -> bool) -> 'a1 tree -> ('a1 enumeration -> bool) -> 'a1 + enumeration -> bool + + val equal_end : 'a1 enumeration -> bool + + val equal : ('a1 -> 'a1 -> bool) -> 'a1 tree -> 'a1 tree -> bool + + val map : ('a1 -> 'a2) -> 'a1 tree -> 'a2 tree + + val mapi : (key -> 'a1 -> 'a2) -> 'a1 tree -> 'a2 tree + + val map_option : (key -> 'a1 -> 'a2 option) -> 'a1 tree -> 'a2 tree + + val map2_opt : + (key -> 'a1 -> 'a2 option -> 'a3 option) -> ('a1 tree -> 'a3 tree) -> + ('a2 tree -> 'a3 tree) -> 'a1 tree -> 'a2 tree -> 'a3 tree + + val map2 : + ('a1 option -> 'a2 option -> 'a3 option) -> 'a1 tree -> 'a2 tree -> 'a3 + tree + + module Proofs : + sig + module MX : + sig + module TO : + sig + type t = X.t + end + + module IsTO : + sig + end + + module OrderTac : + sig + end + + val eq_dec : X.t -> X.t -> sumbool + + val lt_dec : X.t -> X.t -> sumbool + + val eqb : X.t -> X.t -> bool + end + + module PX : + sig + module MO : + sig + module TO : + sig + type t = X.t + end + + module IsTO : + sig + end + + module OrderTac : + sig + end + + val eq_dec : X.t -> X.t -> sumbool + + val lt_dec : X.t -> X.t -> sumbool + + val eqb : X.t -> X.t -> bool + end + end + + module L : + sig + module MX : + sig + module TO : + sig + type t = X.t + end + + module IsTO : + sig + end + + module OrderTac : + sig + end + + val eq_dec : X.t -> X.t -> sumbool + + val lt_dec : X.t -> X.t -> sumbool + + val eqb : X.t -> X.t -> bool + end + + module PX : + sig + module MO : + sig + module TO : + sig + type t = X.t + end + + module IsTO : + sig + end + + module OrderTac : + sig + end + + val eq_dec : X.t -> X.t -> sumbool + + val lt_dec : X.t -> X.t -> sumbool + + val eqb : X.t -> X.t -> bool + end + end + + type key = X.t + + type 'elt t = (X.t * 'elt) list + + val empty : 'a1 t + + val is_empty : 'a1 t -> bool + + val mem : key -> 'a1 t -> bool + + type 'elt coq_R_mem = + | R_mem_0 of 'elt t + | R_mem_1 of 'elt t * X.t * 'elt * (X.t * 'elt) list + | R_mem_2 of 'elt t * X.t * 'elt * (X.t * 'elt) list + | R_mem_3 of 'elt t * X.t * 'elt * (X.t * 'elt) list * bool + * 'elt coq_R_mem + + val coq_R_mem_rect : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> bool -> 'a1 coq_R_mem -> 'a2 -> 'a2) -> 'a1 + t -> bool -> 'a1 coq_R_mem -> 'a2 + + val coq_R_mem_rec : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> bool -> 'a1 coq_R_mem -> 'a2 -> 'a2) -> 'a1 + t -> bool -> 'a1 coq_R_mem -> 'a2 + + val mem_rect : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2 -> 'a2) -> 'a1 t -> 'a2 + + val mem_rec : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2 -> 'a2) -> 'a1 t -> 'a2 + + val coq_R_mem_correct : key -> 'a1 t -> bool -> 'a1 coq_R_mem + + val find : key -> 'a1 t -> 'a1 option + + type 'elt coq_R_find = + | R_find_0 of 'elt t + | R_find_1 of 'elt t * X.t * 'elt * (X.t * 'elt) list + | R_find_2 of 'elt t * X.t * 'elt * (X.t * 'elt) list + | R_find_3 of 'elt t * X.t * 'elt * (X.t * 'elt) list * 'elt option + * 'elt coq_R_find + + val coq_R_find_rect : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a1 option -> 'a1 coq_R_find -> 'a2 -> 'a2) + -> 'a1 t -> 'a1 option -> 'a1 coq_R_find -> 'a2 + + val coq_R_find_rec : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a1 option -> 'a1 coq_R_find -> 'a2 -> 'a2) + -> 'a1 t -> 'a1 option -> 'a1 coq_R_find -> 'a2 + + val find_rect : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2 -> 'a2) -> 'a1 t -> 'a2 + + val find_rec : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2 -> 'a2) -> 'a1 t -> 'a2 + + val coq_R_find_correct : key -> 'a1 t -> 'a1 option -> 'a1 coq_R_find + + val add : key -> 'a1 -> 'a1 t -> 'a1 t + + type 'elt coq_R_add = + | R_add_0 of 'elt t + | R_add_1 of 'elt t * X.t * 'elt * (X.t * 'elt) list + | R_add_2 of 'elt t * X.t * 'elt * (X.t * 'elt) list + | R_add_3 of 'elt t * X.t * 'elt * (X.t * 'elt) list * 'elt t + * 'elt coq_R_add + + val coq_R_add_rect : + key -> 'a1 -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> 'a1 t -> 'a1 coq_R_add -> 'a2 + -> 'a2) -> 'a1 t -> 'a1 t -> 'a1 coq_R_add -> 'a2 + + val coq_R_add_rec : + key -> 'a1 -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> 'a1 t -> 'a1 coq_R_add -> 'a2 + -> 'a2) -> 'a1 t -> 'a1 t -> 'a1 coq_R_add -> 'a2 + + val add_rect : + key -> 'a1 -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> 'a2 -> 'a2) -> 'a1 t -> 'a2 + + val add_rec : + key -> 'a1 -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> 'a2 -> 'a2) -> 'a1 t -> 'a2 + + val coq_R_add_correct : key -> 'a1 -> 'a1 t -> 'a1 t -> 'a1 coq_R_add + + val remove : key -> 'a1 t -> 'a1 t + + type 'elt coq_R_remove = + | R_remove_0 of 'elt t + | R_remove_1 of 'elt t * X.t * 'elt * (X.t * 'elt) list + | R_remove_2 of 'elt t * X.t * 'elt * (X.t * 'elt) list + | R_remove_3 of 'elt t * X.t * 'elt * (X.t * 'elt) list * 'elt t + * 'elt coq_R_remove + + val coq_R_remove_rect : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a1 t -> 'a1 coq_R_remove -> 'a2 -> 'a2) -> + 'a1 t -> 'a1 t -> 'a1 coq_R_remove -> 'a2 + + val coq_R_remove_rec : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a1 t -> 'a1 coq_R_remove -> 'a2 -> 'a2) -> + 'a1 t -> 'a1 t -> 'a1 coq_R_remove -> 'a2 + + val remove_rect : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2 -> 'a2) -> 'a1 t -> 'a2 + + val remove_rec : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2 -> 'a2) -> 'a1 t -> 'a2 + + val coq_R_remove_correct : key -> 'a1 t -> 'a1 t -> 'a1 coq_R_remove + + val elements : 'a1 t -> 'a1 t + + val fold : (key -> 'a1 -> 'a2 -> 'a2) -> 'a1 t -> 'a2 -> 'a2 + + type ('elt, 'a) coq_R_fold = + | R_fold_0 of 'elt t * 'a + | R_fold_1 of 'elt t * 'a * X.t * 'elt * (X.t * 'elt) list * 'a + * ('elt, 'a) coq_R_fold + + val coq_R_fold_rect : + (key -> 'a1 -> 'a2 -> 'a2) -> ('a1 t -> 'a2 -> __ -> 'a3) -> ('a1 t + -> 'a2 -> X.t -> 'a1 -> (X.t * 'a1) list -> __ -> 'a2 -> ('a1, 'a2) + coq_R_fold -> 'a3 -> 'a3) -> 'a1 t -> 'a2 -> 'a2 -> ('a1, 'a2) + coq_R_fold -> 'a3 + + val coq_R_fold_rec : + (key -> 'a1 -> 'a2 -> 'a2) -> ('a1 t -> 'a2 -> __ -> 'a3) -> ('a1 t + -> 'a2 -> X.t -> 'a1 -> (X.t * 'a1) list -> __ -> 'a2 -> ('a1, 'a2) + coq_R_fold -> 'a3 -> 'a3) -> 'a1 t -> 'a2 -> 'a2 -> ('a1, 'a2) + coq_R_fold -> 'a3 + + val fold_rect : + (key -> 'a1 -> 'a2 -> 'a2) -> ('a1 t -> 'a2 -> __ -> 'a3) -> ('a1 t + -> 'a2 -> X.t -> 'a1 -> (X.t * 'a1) list -> __ -> 'a3 -> 'a3) -> 'a1 + t -> 'a2 -> 'a3 + + val fold_rec : + (key -> 'a1 -> 'a2 -> 'a2) -> ('a1 t -> 'a2 -> __ -> 'a3) -> ('a1 t + -> 'a2 -> X.t -> 'a1 -> (X.t * 'a1) list -> __ -> 'a3 -> 'a3) -> 'a1 + t -> 'a2 -> 'a3 + + val coq_R_fold_correct : + (key -> 'a1 -> 'a2 -> 'a2) -> 'a1 t -> 'a2 -> 'a2 -> ('a1, 'a2) + coq_R_fold + + val equal : ('a1 -> 'a1 -> bool) -> 'a1 t -> 'a1 t -> bool + + type 'elt coq_R_equal = + | R_equal_0 of 'elt t * 'elt t + | R_equal_1 of 'elt t * 'elt t * X.t * 'elt * (X.t * 'elt) list * + X.t * 'elt * (X.t * 'elt) list * bool * 'elt coq_R_equal + | R_equal_2 of 'elt t * 'elt t * X.t * 'elt * (X.t * 'elt) list * + X.t * 'elt * (X.t * 'elt) list * X.t compare1 + | R_equal_3 of 'elt t * 'elt t * 'elt t * 'elt t + + val coq_R_equal_rect : + ('a1 -> 'a1 -> bool) -> ('a1 t -> 'a1 t -> __ -> __ -> 'a2) -> ('a1 t + -> 'a1 t -> X.t -> 'a1 -> (X.t * 'a1) list -> __ -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> bool -> 'a1 coq_R_equal -> 'a2 + -> 'a2) -> ('a1 t -> 'a1 t -> X.t -> 'a1 -> (X.t * 'a1) list -> __ -> + X.t -> 'a1 -> (X.t * 'a1) list -> __ -> X.t compare1 -> __ -> __ -> + 'a2) -> ('a1 t -> 'a1 t -> 'a1 t -> __ -> 'a1 t -> __ -> __ -> 'a2) + -> 'a1 t -> 'a1 t -> bool -> 'a1 coq_R_equal -> 'a2 + + val coq_R_equal_rec : + ('a1 -> 'a1 -> bool) -> ('a1 t -> 'a1 t -> __ -> __ -> 'a2) -> ('a1 t + -> 'a1 t -> X.t -> 'a1 -> (X.t * 'a1) list -> __ -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> bool -> 'a1 coq_R_equal -> 'a2 + -> 'a2) -> ('a1 t -> 'a1 t -> X.t -> 'a1 -> (X.t * 'a1) list -> __ -> + X.t -> 'a1 -> (X.t * 'a1) list -> __ -> X.t compare1 -> __ -> __ -> + 'a2) -> ('a1 t -> 'a1 t -> 'a1 t -> __ -> 'a1 t -> __ -> __ -> 'a2) + -> 'a1 t -> 'a1 t -> bool -> 'a1 coq_R_equal -> 'a2 + + val equal_rect : + ('a1 -> 'a1 -> bool) -> ('a1 t -> 'a1 t -> __ -> __ -> 'a2) -> ('a1 t + -> 'a1 t -> X.t -> 'a1 -> (X.t * 'a1) list -> __ -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> 'a2 -> 'a2) -> ('a1 t -> 'a1 t + -> X.t -> 'a1 -> (X.t * 'a1) list -> __ -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> X.t compare1 -> __ -> __ -> 'a2) -> ('a1 t -> 'a1 t -> + 'a1 t -> __ -> 'a1 t -> __ -> __ -> 'a2) -> 'a1 t -> 'a1 t -> 'a2 + + val equal_rec : + ('a1 -> 'a1 -> bool) -> ('a1 t -> 'a1 t -> __ -> __ -> 'a2) -> ('a1 t + -> 'a1 t -> X.t -> 'a1 -> (X.t * 'a1) list -> __ -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> 'a2 -> 'a2) -> ('a1 t -> 'a1 t + -> X.t -> 'a1 -> (X.t * 'a1) list -> __ -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> X.t compare1 -> __ -> __ -> 'a2) -> ('a1 t -> 'a1 t -> + 'a1 t -> __ -> 'a1 t -> __ -> __ -> 'a2) -> 'a1 t -> 'a1 t -> 'a2 + + val coq_R_equal_correct : + ('a1 -> 'a1 -> bool) -> 'a1 t -> 'a1 t -> bool -> 'a1 coq_R_equal + + val map : ('a1 -> 'a2) -> 'a1 t -> 'a2 t + + val mapi : (key -> 'a1 -> 'a2) -> 'a1 t -> 'a2 t + + val option_cons : + key -> 'a1 option -> (key * 'a1) list -> (key * 'a1) list + + val map2_l : ('a1 option -> 'a2 option -> 'a3 option) -> 'a1 t -> 'a3 t + + val map2_r : ('a1 option -> 'a2 option -> 'a3 option) -> 'a2 t -> 'a3 t + + val map2 : + ('a1 option -> 'a2 option -> 'a3 option) -> 'a1 t -> 'a2 t -> 'a3 t + + val combine : 'a1 t -> 'a2 t -> ('a1 option * 'a2 option) t + + val fold_right_pair : + ('a1 -> 'a2 -> 'a3 -> 'a3) -> ('a1 * 'a2) list -> 'a3 -> 'a3 + + val map2_alt : + ('a1 option -> 'a2 option -> 'a3 option) -> 'a1 t -> 'a2 t -> + (key * 'a3) list + + val at_least_one : + 'a1 option -> 'a2 option -> ('a1 option * 'a2 option) option + + val at_least_one_then_f : + ('a1 option -> 'a2 option -> 'a3 option) -> 'a1 option -> 'a2 option + -> 'a3 option + end + + type 'elt coq_R_mem = + | R_mem_0 of 'elt tree + | R_mem_1 of 'elt tree * 'elt tree * key * 'elt * 'elt tree * I.t * + bool * 'elt coq_R_mem + | R_mem_2 of 'elt tree * 'elt tree * key * 'elt * 'elt tree * I.t + | R_mem_3 of 'elt tree * 'elt tree * key * 'elt * 'elt tree * I.t * + bool * 'elt coq_R_mem + + val coq_R_mem_rect : + X.t -> ('a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 + -> 'a1 tree -> I.t -> __ -> __ -> __ -> bool -> 'a1 coq_R_mem -> 'a2 -> + 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ -> + __ -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> + I.t -> __ -> __ -> __ -> bool -> 'a1 coq_R_mem -> 'a2 -> 'a2) -> 'a1 + tree -> bool -> 'a1 coq_R_mem -> 'a2 + + val coq_R_mem_rec : + X.t -> ('a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 + -> 'a1 tree -> I.t -> __ -> __ -> __ -> bool -> 'a1 coq_R_mem -> 'a2 -> + 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ -> + __ -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> + I.t -> __ -> __ -> __ -> bool -> 'a1 coq_R_mem -> 'a2 -> 'a2) -> 'a1 + tree -> bool -> 'a1 coq_R_mem -> 'a2 + + type 'elt coq_R_find = + | R_find_0 of 'elt tree + | R_find_1 of 'elt tree * 'elt tree * key * 'elt * 'elt tree * I.t + * 'elt option * 'elt coq_R_find + | R_find_2 of 'elt tree * 'elt tree * key * 'elt * 'elt tree * I.t + | R_find_3 of 'elt tree * 'elt tree * key * 'elt * 'elt tree * I.t + * 'elt option * 'elt coq_R_find + + val coq_R_find_rect : + X.t -> ('a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 + -> 'a1 tree -> I.t -> __ -> __ -> __ -> 'a1 option -> 'a1 coq_R_find -> + 'a2 -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t + -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 + tree -> I.t -> __ -> __ -> __ -> 'a1 option -> 'a1 coq_R_find -> 'a2 -> + 'a2) -> 'a1 tree -> 'a1 option -> 'a1 coq_R_find -> 'a2 + + val coq_R_find_rec : + X.t -> ('a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 + -> 'a1 tree -> I.t -> __ -> __ -> __ -> 'a1 option -> 'a1 coq_R_find -> + 'a2 -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t + -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 + tree -> I.t -> __ -> __ -> __ -> 'a1 option -> 'a1 coq_R_find -> 'a2 -> + 'a2) -> 'a1 tree -> 'a1 option -> 'a1 coq_R_find -> 'a2 + + type 'elt coq_R_bal = + | R_bal_0 of 'elt tree * key * 'elt * 'elt tree + | R_bal_1 of 'elt tree * key * 'elt * 'elt tree * 'elt tree * key * + 'elt * 'elt tree * I.t + | R_bal_2 of 'elt tree * key * 'elt * 'elt tree * 'elt tree * key * + 'elt * 'elt tree * I.t + | R_bal_3 of 'elt tree * key * 'elt * 'elt tree * 'elt tree * key * + 'elt * 'elt tree * I.t * 'elt tree * key * 'elt * 'elt tree * + I.t + | R_bal_4 of 'elt tree * key * 'elt * 'elt tree + | R_bal_5 of 'elt tree * key * 'elt * 'elt tree * 'elt tree * key * + 'elt * 'elt tree * I.t + | R_bal_6 of 'elt tree * key * 'elt * 'elt tree * 'elt tree * key * + 'elt * 'elt tree * I.t + | R_bal_7 of 'elt tree * key * 'elt * 'elt tree * 'elt tree * key * + 'elt * 'elt tree * I.t * 'elt tree * key * 'elt * 'elt tree * + I.t + | R_bal_8 of 'elt tree * key * 'elt * 'elt tree + + val coq_R_bal_rect : + ('a1 tree -> key -> 'a1 -> 'a1 tree -> __ -> __ -> __ -> 'a2) -> ('a1 + tree -> key -> 'a1 -> 'a1 tree -> __ -> __ -> 'a1 tree -> key -> 'a1 -> + 'a1 tree -> I.t -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> key -> 'a1 -> + 'a1 tree -> __ -> __ -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ + -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> key -> 'a1 -> 'a1 tree -> __ + -> __ -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ -> __ -> __ -> + 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ -> 'a2) -> ('a1 tree -> + key -> 'a1 -> 'a1 tree -> __ -> __ -> __ -> __ -> __ -> 'a2) -> ('a1 + tree -> key -> 'a1 -> 'a1 tree -> __ -> __ -> __ -> __ -> 'a1 tree -> + key -> 'a1 -> 'a1 tree -> I.t -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> + key -> 'a1 -> 'a1 tree -> __ -> __ -> __ -> __ -> 'a1 tree -> key -> + 'a1 -> 'a1 tree -> I.t -> __ -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> + key -> 'a1 -> 'a1 tree -> __ -> __ -> __ -> __ -> 'a1 tree -> key -> + 'a1 -> 'a1 tree -> I.t -> __ -> __ -> __ -> 'a1 tree -> key -> 'a1 -> + 'a1 tree -> I.t -> __ -> 'a2) -> ('a1 tree -> key -> 'a1 -> 'a1 tree -> + __ -> __ -> __ -> __ -> 'a2) -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> + 'a1 tree -> 'a1 coq_R_bal -> 'a2 + + val coq_R_bal_rec : + ('a1 tree -> key -> 'a1 -> 'a1 tree -> __ -> __ -> __ -> 'a2) -> ('a1 + tree -> key -> 'a1 -> 'a1 tree -> __ -> __ -> 'a1 tree -> key -> 'a1 -> + 'a1 tree -> I.t -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> key -> 'a1 -> + 'a1 tree -> __ -> __ -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ + -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> key -> 'a1 -> 'a1 tree -> __ + -> __ -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ -> __ -> __ -> + 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ -> 'a2) -> ('a1 tree -> + key -> 'a1 -> 'a1 tree -> __ -> __ -> __ -> __ -> __ -> 'a2) -> ('a1 + tree -> key -> 'a1 -> 'a1 tree -> __ -> __ -> __ -> __ -> 'a1 tree -> + key -> 'a1 -> 'a1 tree -> I.t -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> + key -> 'a1 -> 'a1 tree -> __ -> __ -> __ -> __ -> 'a1 tree -> key -> + 'a1 -> 'a1 tree -> I.t -> __ -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> + key -> 'a1 -> 'a1 tree -> __ -> __ -> __ -> __ -> 'a1 tree -> key -> + 'a1 -> 'a1 tree -> I.t -> __ -> __ -> __ -> 'a1 tree -> key -> 'a1 -> + 'a1 tree -> I.t -> __ -> 'a2) -> ('a1 tree -> key -> 'a1 -> 'a1 tree -> + __ -> __ -> __ -> __ -> 'a2) -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> + 'a1 tree -> 'a1 coq_R_bal -> 'a2 + + type 'elt coq_R_add = + | R_add_0 of 'elt tree + | R_add_1 of 'elt tree * 'elt tree * key * 'elt * 'elt tree * I.t + * 'elt tree * 'elt coq_R_add + | R_add_2 of 'elt tree * 'elt tree * key * 'elt * 'elt tree * I.t + | R_add_3 of 'elt tree * 'elt tree * key * 'elt * 'elt tree * I.t + * 'elt tree * 'elt coq_R_add + + val coq_R_add_rect : + key -> 'a1 -> ('a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key + -> 'a1 -> 'a1 tree -> I.t -> __ -> __ -> __ -> 'a1 tree -> 'a1 + coq_R_add -> 'a2 -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 + tree -> I.t -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key + -> 'a1 -> 'a1 tree -> I.t -> __ -> __ -> __ -> 'a1 tree -> 'a1 + coq_R_add -> 'a2 -> 'a2) -> 'a1 tree -> 'a1 tree -> 'a1 coq_R_add -> 'a2 + + val coq_R_add_rec : + key -> 'a1 -> ('a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key + -> 'a1 -> 'a1 tree -> I.t -> __ -> __ -> __ -> 'a1 tree -> 'a1 + coq_R_add -> 'a2 -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 + tree -> I.t -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key + -> 'a1 -> 'a1 tree -> I.t -> __ -> __ -> __ -> 'a1 tree -> 'a1 + coq_R_add -> 'a2 -> 'a2) -> 'a1 tree -> 'a1 tree -> 'a1 coq_R_add -> 'a2 + + type 'elt coq_R_remove_min = + | R_remove_min_0 of 'elt tree * key * 'elt * 'elt tree + | R_remove_min_1 of 'elt tree * key * 'elt * 'elt tree * 'elt tree * + key * 'elt * 'elt tree * I.t * ('elt tree * (key * 'elt)) + * 'elt coq_R_remove_min * 'elt tree * (key * 'elt) + + val coq_R_remove_min_rect : + ('a1 tree -> key -> 'a1 -> 'a1 tree -> __ -> 'a2) -> ('a1 tree -> key + -> 'a1 -> 'a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ + -> ('a1 tree * (key * 'a1)) -> 'a1 coq_R_remove_min -> 'a2 -> 'a1 tree + -> (key * 'a1) -> __ -> 'a2) -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> + ('a1 tree * (key * 'a1)) -> 'a1 coq_R_remove_min -> 'a2 + + val coq_R_remove_min_rec : + ('a1 tree -> key -> 'a1 -> 'a1 tree -> __ -> 'a2) -> ('a1 tree -> key + -> 'a1 -> 'a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ + -> ('a1 tree * (key * 'a1)) -> 'a1 coq_R_remove_min -> 'a2 -> 'a1 tree + -> (key * 'a1) -> __ -> 'a2) -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> + ('a1 tree * (key * 'a1)) -> 'a1 coq_R_remove_min -> 'a2 + + type 'elt coq_R_merge = + | R_merge_0 of 'elt tree * 'elt tree + | R_merge_1 of 'elt tree * 'elt tree * 'elt tree * key * 'elt * 'elt tree + * I.t + | R_merge_2 of 'elt tree * 'elt tree * 'elt tree * key * 'elt * 'elt tree + * I.t * 'elt tree * key * 'elt * 'elt tree * I.t * 'elt tree + * (key * 'elt) * key * 'elt + + val coq_R_merge_rect : + ('a1 tree -> 'a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> 'a1 + tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ -> __ -> 'a2) -> ('a1 tree + -> 'a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ -> 'a1 + tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ -> 'a1 tree -> (key * 'a1) + -> __ -> key -> 'a1 -> __ -> 'a2) -> 'a1 tree -> 'a1 tree -> 'a1 tree + -> 'a1 coq_R_merge -> 'a2 + + val coq_R_merge_rec : + ('a1 tree -> 'a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> 'a1 + tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ -> __ -> 'a2) -> ('a1 tree + -> 'a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ -> 'a1 + tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ -> 'a1 tree -> (key * 'a1) + -> __ -> key -> 'a1 -> __ -> 'a2) -> 'a1 tree -> 'a1 tree -> 'a1 tree + -> 'a1 coq_R_merge -> 'a2 + + type 'elt coq_R_remove = + | R_remove_0 of 'elt tree + | R_remove_1 of 'elt tree * 'elt tree * key * 'elt * 'elt tree * + I.t * 'elt tree * 'elt coq_R_remove + | R_remove_2 of 'elt tree * 'elt tree * key * 'elt * 'elt tree * I.t + | R_remove_3 of 'elt tree * 'elt tree * key * 'elt * 'elt tree * + I.t * 'elt tree * 'elt coq_R_remove + + val coq_R_remove_rect : + X.t -> ('a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 + -> 'a1 tree -> I.t -> __ -> __ -> __ -> 'a1 tree -> 'a1 coq_R_remove -> + 'a2 -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t + -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 + tree -> I.t -> __ -> __ -> __ -> 'a1 tree -> 'a1 coq_R_remove -> 'a2 -> + 'a2) -> 'a1 tree -> 'a1 tree -> 'a1 coq_R_remove -> 'a2 + + val coq_R_remove_rec : + X.t -> ('a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 + -> 'a1 tree -> I.t -> __ -> __ -> __ -> 'a1 tree -> 'a1 coq_R_remove -> + 'a2 -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t + -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 + tree -> I.t -> __ -> __ -> __ -> 'a1 tree -> 'a1 coq_R_remove -> 'a2 -> + 'a2) -> 'a1 tree -> 'a1 tree -> 'a1 coq_R_remove -> 'a2 + + type 'elt coq_R_concat = + | R_concat_0 of 'elt tree * 'elt tree + | R_concat_1 of 'elt tree * 'elt tree * 'elt tree * key * 'elt + * 'elt tree * I.t + | R_concat_2 of 'elt tree * 'elt tree * 'elt tree * key * 'elt + * 'elt tree * I.t * 'elt tree * key * 'elt * 'elt tree * I.t + * 'elt tree * (key * 'elt) + + val coq_R_concat_rect : + ('a1 tree -> 'a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> 'a1 + tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ -> __ -> 'a2) -> ('a1 tree + -> 'a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ -> 'a1 + tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ -> 'a1 tree -> (key * 'a1) + -> __ -> 'a2) -> 'a1 tree -> 'a1 tree -> 'a1 tree -> 'a1 coq_R_concat + -> 'a2 + + val coq_R_concat_rec : + ('a1 tree -> 'a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> 'a1 + tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ -> __ -> 'a2) -> ('a1 tree + -> 'a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ -> 'a1 + tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ -> 'a1 tree -> (key * 'a1) + -> __ -> 'a2) -> 'a1 tree -> 'a1 tree -> 'a1 tree -> 'a1 coq_R_concat + -> 'a2 + + type 'elt coq_R_split = + | R_split_0 of 'elt tree + | R_split_1 of 'elt tree * 'elt tree * key * 'elt * 'elt tree * I.t + * 'elt triple * 'elt coq_R_split * 'elt tree * 'elt option * 'elt tree + | R_split_2 of 'elt tree * 'elt tree * key * 'elt * 'elt tree * I.t + | R_split_3 of 'elt tree * 'elt tree * key * 'elt * 'elt tree * I.t + * 'elt triple * 'elt coq_R_split * 'elt tree * 'elt option * 'elt tree + + val coq_R_split_rect : + X.t -> ('a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 + -> 'a1 tree -> I.t -> __ -> __ -> __ -> 'a1 triple -> 'a1 coq_R_split + -> 'a2 -> 'a1 tree -> 'a1 option -> 'a1 tree -> __ -> 'a2) -> ('a1 tree + -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ -> __ -> __ -> 'a2) + -> ('a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ -> __ + -> __ -> 'a1 triple -> 'a1 coq_R_split -> 'a2 -> 'a1 tree -> 'a1 option + -> 'a1 tree -> __ -> 'a2) -> 'a1 tree -> 'a1 triple -> 'a1 coq_R_split + -> 'a2 + + val coq_R_split_rec : + X.t -> ('a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 + -> 'a1 tree -> I.t -> __ -> __ -> __ -> 'a1 triple -> 'a1 coq_R_split + -> 'a2 -> 'a1 tree -> 'a1 option -> 'a1 tree -> __ -> 'a2) -> ('a1 tree + -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ -> __ -> __ -> 'a2) + -> ('a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ -> __ + -> __ -> 'a1 triple -> 'a1 coq_R_split -> 'a2 -> 'a1 tree -> 'a1 option + -> 'a1 tree -> __ -> 'a2) -> 'a1 tree -> 'a1 triple -> 'a1 coq_R_split + -> 'a2 + + type ('elt, 'x) coq_R_map_option = + | R_map_option_0 of 'elt tree + | R_map_option_1 of 'elt tree * 'elt tree * key * 'elt * 'elt tree * + I.t * 'x * 'x tree * ('elt, 'x) coq_R_map_option * 'x tree + * ('elt, 'x) coq_R_map_option + | R_map_option_2 of 'elt tree * 'elt tree * key * 'elt * 'elt tree * + I.t * 'x tree * ('elt, 'x) coq_R_map_option * 'x tree + * ('elt, 'x) coq_R_map_option + + val coq_R_map_option_rect : + (key -> 'a1 -> 'a2 option) -> ('a1 tree -> __ -> 'a3) -> ('a1 tree -> + 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ -> 'a2 -> __ -> 'a2 + tree -> ('a1, 'a2) coq_R_map_option -> 'a3 -> 'a2 tree -> ('a1, 'a2) + coq_R_map_option -> 'a3 -> 'a3) -> ('a1 tree -> 'a1 tree -> key -> 'a1 + -> 'a1 tree -> I.t -> __ -> __ -> 'a2 tree -> ('a1, 'a2) + coq_R_map_option -> 'a3 -> 'a2 tree -> ('a1, 'a2) coq_R_map_option -> + 'a3 -> 'a3) -> 'a1 tree -> 'a2 tree -> ('a1, 'a2) coq_R_map_option -> + 'a3 + + val coq_R_map_option_rec : + (key -> 'a1 -> 'a2 option) -> ('a1 tree -> __ -> 'a3) -> ('a1 tree -> + 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ -> 'a2 -> __ -> 'a2 + tree -> ('a1, 'a2) coq_R_map_option -> 'a3 -> 'a2 tree -> ('a1, 'a2) + coq_R_map_option -> 'a3 -> 'a3) -> ('a1 tree -> 'a1 tree -> key -> 'a1 + -> 'a1 tree -> I.t -> __ -> __ -> 'a2 tree -> ('a1, 'a2) + coq_R_map_option -> 'a3 -> 'a2 tree -> ('a1, 'a2) coq_R_map_option -> + 'a3 -> 'a3) -> 'a1 tree -> 'a2 tree -> ('a1, 'a2) coq_R_map_option -> + 'a3 + + type ('elt, 'x0, 'x) coq_R_map2_opt = + | R_map2_opt_0 of 'elt tree * 'x0 tree + | R_map2_opt_1 of 'elt tree * 'x0 tree * 'elt tree * key * 'elt + * 'elt tree * I.t + | R_map2_opt_2 of 'elt tree * 'x0 tree * 'elt tree * key * 'elt + * 'elt tree * I.t * 'x0 tree * key * 'x0 * 'x0 tree * I.t * 'x0 tree + * 'x0 option * 'x0 tree * 'x * 'x tree + * ('elt, 'x0, 'x) coq_R_map2_opt * 'x tree + * ('elt, 'x0, 'x) coq_R_map2_opt + | R_map2_opt_3 of 'elt tree * 'x0 tree * 'elt tree * key * 'elt + * 'elt tree * I.t * 'x0 tree * key * 'x0 * 'x0 tree * I.t * 'x0 tree + * 'x0 option * 'x0 tree * 'x tree * ('elt, 'x0, 'x) coq_R_map2_opt + * 'x tree * ('elt, 'x0, 'x) coq_R_map2_opt + + val coq_R_map2_opt_rect : + (key -> 'a1 -> 'a2 option -> 'a3 option) -> ('a1 tree -> 'a3 tree) -> + ('a2 tree -> 'a3 tree) -> ('a1 tree -> 'a2 tree -> __ -> 'a4) -> ('a1 + tree -> 'a2 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ -> + __ -> 'a4) -> ('a1 tree -> 'a2 tree -> 'a1 tree -> key -> 'a1 -> 'a1 + tree -> I.t -> __ -> 'a2 tree -> key -> 'a2 -> 'a2 tree -> I.t -> __ -> + 'a2 tree -> 'a2 option -> 'a2 tree -> __ -> 'a3 -> __ -> 'a3 tree -> + ('a1, 'a2, 'a3) coq_R_map2_opt -> 'a4 -> 'a3 tree -> ('a1, 'a2, 'a3) + coq_R_map2_opt -> 'a4 -> 'a4) -> ('a1 tree -> 'a2 tree -> 'a1 tree -> + key -> 'a1 -> 'a1 tree -> I.t -> __ -> 'a2 tree -> key -> 'a2 -> 'a2 + tree -> I.t -> __ -> 'a2 tree -> 'a2 option -> 'a2 tree -> __ -> __ -> + 'a3 tree -> ('a1, 'a2, 'a3) coq_R_map2_opt -> 'a4 -> 'a3 tree -> ('a1, + 'a2, 'a3) coq_R_map2_opt -> 'a4 -> 'a4) -> 'a1 tree -> 'a2 tree -> 'a3 + tree -> ('a1, 'a2, 'a3) coq_R_map2_opt -> 'a4 + + val coq_R_map2_opt_rec : + (key -> 'a1 -> 'a2 option -> 'a3 option) -> ('a1 tree -> 'a3 tree) -> + ('a2 tree -> 'a3 tree) -> ('a1 tree -> 'a2 tree -> __ -> 'a4) -> ('a1 + tree -> 'a2 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ -> + __ -> 'a4) -> ('a1 tree -> 'a2 tree -> 'a1 tree -> key -> 'a1 -> 'a1 + tree -> I.t -> __ -> 'a2 tree -> key -> 'a2 -> 'a2 tree -> I.t -> __ -> + 'a2 tree -> 'a2 option -> 'a2 tree -> __ -> 'a3 -> __ -> 'a3 tree -> + ('a1, 'a2, 'a3) coq_R_map2_opt -> 'a4 -> 'a3 tree -> ('a1, 'a2, 'a3) + coq_R_map2_opt -> 'a4 -> 'a4) -> ('a1 tree -> 'a2 tree -> 'a1 tree -> + key -> 'a1 -> 'a1 tree -> I.t -> __ -> 'a2 tree -> key -> 'a2 -> 'a2 + tree -> I.t -> __ -> 'a2 tree -> 'a2 option -> 'a2 tree -> __ -> __ -> + 'a3 tree -> ('a1, 'a2, 'a3) coq_R_map2_opt -> 'a4 -> 'a3 tree -> ('a1, + 'a2, 'a3) coq_R_map2_opt -> 'a4 -> 'a4) -> 'a1 tree -> 'a2 tree -> 'a3 + tree -> ('a1, 'a2, 'a3) coq_R_map2_opt -> 'a4 + + val fold' : (key -> 'a1 -> 'a2 -> 'a2) -> 'a1 tree -> 'a2 -> 'a2 + + val flatten_e : 'a1 enumeration -> (key * 'a1) list + end + end + +module IntMake : + functor (I:Int) -> + functor (X:OrderedType) -> + sig + module E : + sig + type t = X.t + + val compare : t -> t -> t compare1 + + val eq_dec : t -> t -> sumbool + end + + module Raw : + sig + type key = X.t + + type 'elt tree = + | Leaf + | Node of 'elt tree * key * 'elt * 'elt tree * I.t + + val tree_rect : + 'a2 -> ('a1 tree -> 'a2 -> key -> 'a1 -> 'a1 tree -> 'a2 -> I.t -> 'a2) + -> 'a1 tree -> 'a2 + + val tree_rec : + 'a2 -> ('a1 tree -> 'a2 -> key -> 'a1 -> 'a1 tree -> 'a2 -> I.t -> 'a2) + -> 'a1 tree -> 'a2 + + val height : 'a1 tree -> I.t + + val cardinal : 'a1 tree -> nat + + val empty : 'a1 tree + + val is_empty : 'a1 tree -> bool + + val mem : X.t -> 'a1 tree -> bool + + val find : X.t -> 'a1 tree -> 'a1 option + + val create : 'a1 tree -> key -> 'a1 -> 'a1 tree -> 'a1 tree + + val assert_false : 'a1 tree -> key -> 'a1 -> 'a1 tree -> 'a1 tree + + val bal : 'a1 tree -> key -> 'a1 -> 'a1 tree -> 'a1 tree + + val add : key -> 'a1 -> 'a1 tree -> 'a1 tree + + val remove_min : + 'a1 tree -> key -> 'a1 -> 'a1 tree -> 'a1 tree * (key * 'a1) + + val merge : 'a1 tree -> 'a1 tree -> 'a1 tree + + val remove : X.t -> 'a1 tree -> 'a1 tree + + val join : 'a1 tree -> key -> 'a1 -> 'a1 tree -> 'a1 tree + + type 'elt triple = { t_left : 'elt tree; t_opt : 'elt option; + t_right : 'elt tree } + + val t_left : 'a1 triple -> 'a1 tree + + val t_opt : 'a1 triple -> 'a1 option + + val t_right : 'a1 triple -> 'a1 tree + + val split : X.t -> 'a1 tree -> 'a1 triple + + val concat : 'a1 tree -> 'a1 tree -> 'a1 tree + + val elements_aux : (key * 'a1) list -> 'a1 tree -> (key * 'a1) list + + val elements : 'a1 tree -> (key * 'a1) list + + val fold : (key -> 'a1 -> 'a2 -> 'a2) -> 'a1 tree -> 'a2 -> 'a2 + + type 'elt enumeration = + | End + | More of key * 'elt * 'elt tree * 'elt enumeration + + val enumeration_rect : + 'a2 -> (key -> 'a1 -> 'a1 tree -> 'a1 enumeration -> 'a2 -> 'a2) -> 'a1 + enumeration -> 'a2 + + val enumeration_rec : + 'a2 -> (key -> 'a1 -> 'a1 tree -> 'a1 enumeration -> 'a2 -> 'a2) -> 'a1 + enumeration -> 'a2 + + val cons : 'a1 tree -> 'a1 enumeration -> 'a1 enumeration + + val equal_more : + ('a1 -> 'a1 -> bool) -> X.t -> 'a1 -> ('a1 enumeration -> bool) -> 'a1 + enumeration -> bool + + val equal_cont : + ('a1 -> 'a1 -> bool) -> 'a1 tree -> ('a1 enumeration -> bool) -> 'a1 + enumeration -> bool + + val equal_end : 'a1 enumeration -> bool + + val equal : ('a1 -> 'a1 -> bool) -> 'a1 tree -> 'a1 tree -> bool + + val map : ('a1 -> 'a2) -> 'a1 tree -> 'a2 tree + + val mapi : (key -> 'a1 -> 'a2) -> 'a1 tree -> 'a2 tree + + val map_option : (key -> 'a1 -> 'a2 option) -> 'a1 tree -> 'a2 tree + + val map2_opt : + (key -> 'a1 -> 'a2 option -> 'a3 option) -> ('a1 tree -> 'a3 tree) -> + ('a2 tree -> 'a3 tree) -> 'a1 tree -> 'a2 tree -> 'a3 tree + + val map2 : + ('a1 option -> 'a2 option -> 'a3 option) -> 'a1 tree -> 'a2 tree -> 'a3 + tree + + module Proofs : + sig + module MX : + sig + module TO : + sig + type t = X.t + end + + module IsTO : + sig + end + + module OrderTac : + sig + end + + val eq_dec : X.t -> X.t -> sumbool + + val lt_dec : X.t -> X.t -> sumbool + + val eqb : X.t -> X.t -> bool + end + + module PX : + sig + module MO : + sig + module TO : + sig + type t = X.t + end + + module IsTO : + sig + end + + module OrderTac : + sig + end + + val eq_dec : X.t -> X.t -> sumbool + + val lt_dec : X.t -> X.t -> sumbool + + val eqb : X.t -> X.t -> bool + end + end + + module L : + sig + module MX : + sig + module TO : + sig + type t = X.t + end + + module IsTO : + sig + end + + module OrderTac : + sig + end + + val eq_dec : X.t -> X.t -> sumbool + + val lt_dec : X.t -> X.t -> sumbool + + val eqb : X.t -> X.t -> bool + end + + module PX : + sig + module MO : + sig + module TO : + sig + type t = X.t + end + + module IsTO : + sig + end + + module OrderTac : + sig + end + + val eq_dec : X.t -> X.t -> sumbool + + val lt_dec : X.t -> X.t -> sumbool + + val eqb : X.t -> X.t -> bool + end + end + + type key = X.t + + type 'elt t = (X.t * 'elt) list + + val empty : 'a1 t + + val is_empty : 'a1 t -> bool + + val mem : key -> 'a1 t -> bool + + type 'elt coq_R_mem = + | R_mem_0 of 'elt t + | R_mem_1 of 'elt t * X.t * 'elt * (X.t * 'elt) list + | R_mem_2 of 'elt t * X.t * 'elt * (X.t * 'elt) list + | R_mem_3 of 'elt t * X.t * 'elt * (X.t * 'elt) list * bool + * 'elt coq_R_mem + + val coq_R_mem_rect : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 + -> (X.t * 'a1) list -> __ -> __ -> __ -> bool -> 'a1 coq_R_mem -> + 'a2 -> 'a2) -> 'a1 t -> bool -> 'a1 coq_R_mem -> 'a2 + + val coq_R_mem_rec : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 + -> (X.t * 'a1) list -> __ -> __ -> __ -> bool -> 'a1 coq_R_mem -> + 'a2 -> 'a2) -> 'a1 t -> bool -> 'a1 coq_R_mem -> 'a2 + + val mem_rect : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 + -> (X.t * 'a1) list -> __ -> __ -> __ -> 'a2 -> 'a2) -> 'a1 t -> 'a2 + + val mem_rec : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 + -> (X.t * 'a1) list -> __ -> __ -> __ -> 'a2 -> 'a2) -> 'a1 t -> 'a2 + + val coq_R_mem_correct : key -> 'a1 t -> bool -> 'a1 coq_R_mem + + val find : key -> 'a1 t -> 'a1 option + + type 'elt coq_R_find = + | R_find_0 of 'elt t + | R_find_1 of 'elt t * X.t * 'elt * (X.t * 'elt) list + | R_find_2 of 'elt t * X.t * 'elt * (X.t * 'elt) list + | R_find_3 of 'elt t * X.t * 'elt * (X.t * 'elt) list * 'elt option + * 'elt coq_R_find + + val coq_R_find_rect : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 + -> (X.t * 'a1) list -> __ -> __ -> __ -> 'a1 option -> 'a1 + coq_R_find -> 'a2 -> 'a2) -> 'a1 t -> 'a1 option -> 'a1 coq_R_find + -> 'a2 + + val coq_R_find_rec : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 + -> (X.t * 'a1) list -> __ -> __ -> __ -> 'a1 option -> 'a1 + coq_R_find -> 'a2 -> 'a2) -> 'a1 t -> 'a1 option -> 'a1 coq_R_find + -> 'a2 + + val find_rect : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 + -> (X.t * 'a1) list -> __ -> __ -> __ -> 'a2 -> 'a2) -> 'a1 t -> 'a2 + + val find_rec : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 + -> (X.t * 'a1) list -> __ -> __ -> __ -> 'a2 -> 'a2) -> 'a1 t -> 'a2 + + val coq_R_find_correct : key -> 'a1 t -> 'a1 option -> 'a1 coq_R_find + + val add : key -> 'a1 -> 'a1 t -> 'a1 t + + type 'elt coq_R_add = + | R_add_0 of 'elt t + | R_add_1 of 'elt t * X.t * 'elt * (X.t * 'elt) list + | R_add_2 of 'elt t * X.t * 'elt * (X.t * 'elt) list + | R_add_3 of 'elt t * X.t * 'elt * (X.t * 'elt) list * 'elt t + * 'elt coq_R_add + + val coq_R_add_rect : + key -> 'a1 -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 + -> (X.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> + 'a1 -> (X.t * 'a1) list -> __ -> __ -> __ -> 'a1 t -> 'a1 coq_R_add + -> 'a2 -> 'a2) -> 'a1 t -> 'a1 t -> 'a1 coq_R_add -> 'a2 + + val coq_R_add_rec : + key -> 'a1 -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 + -> (X.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> + 'a1 -> (X.t * 'a1) list -> __ -> __ -> __ -> 'a1 t -> 'a1 coq_R_add + -> 'a2 -> 'a2) -> 'a1 t -> 'a1 t -> 'a1 coq_R_add -> 'a2 + + val add_rect : + key -> 'a1 -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 + -> (X.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> + 'a1 -> (X.t * 'a1) list -> __ -> __ -> __ -> 'a2 -> 'a2) -> 'a1 t + -> 'a2 + + val add_rec : + key -> 'a1 -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 + -> (X.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> + 'a1 -> (X.t * 'a1) list -> __ -> __ -> __ -> 'a2 -> 'a2) -> 'a1 t + -> 'a2 + + val coq_R_add_correct : key -> 'a1 -> 'a1 t -> 'a1 t -> 'a1 coq_R_add + + val remove : key -> 'a1 t -> 'a1 t + + type 'elt coq_R_remove = + | R_remove_0 of 'elt t + | R_remove_1 of 'elt t * X.t * 'elt * (X.t * 'elt) list + | R_remove_2 of 'elt t * X.t * 'elt * (X.t * 'elt) list + | R_remove_3 of 'elt t * X.t * 'elt * (X.t * 'elt) list * 'elt t + * 'elt coq_R_remove + + val coq_R_remove_rect : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 + -> (X.t * 'a1) list -> __ -> __ -> __ -> 'a1 t -> 'a1 coq_R_remove + -> 'a2 -> 'a2) -> 'a1 t -> 'a1 t -> 'a1 coq_R_remove -> 'a2 + + val coq_R_remove_rec : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 + -> (X.t * 'a1) list -> __ -> __ -> __ -> 'a1 t -> 'a1 coq_R_remove + -> 'a2 -> 'a2) -> 'a1 t -> 'a1 t -> 'a1 coq_R_remove -> 'a2 + + val remove_rect : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 + -> (X.t * 'a1) list -> __ -> __ -> __ -> 'a2 -> 'a2) -> 'a1 t -> 'a2 + + val remove_rec : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 + -> (X.t * 'a1) list -> __ -> __ -> __ -> 'a2 -> 'a2) -> 'a1 t -> 'a2 + + val coq_R_remove_correct : key -> 'a1 t -> 'a1 t -> 'a1 coq_R_remove + + val elements : 'a1 t -> 'a1 t + + val fold : (key -> 'a1 -> 'a2 -> 'a2) -> 'a1 t -> 'a2 -> 'a2 + + type ('elt, 'a) coq_R_fold = + | R_fold_0 of 'elt t * 'a + | R_fold_1 of 'elt t * 'a * X.t * 'elt * (X.t * 'elt) list * + 'a * ('elt, 'a) coq_R_fold + + val coq_R_fold_rect : + (key -> 'a1 -> 'a2 -> 'a2) -> ('a1 t -> 'a2 -> __ -> 'a3) -> ('a1 t + -> 'a2 -> X.t -> 'a1 -> (X.t * 'a1) list -> __ -> 'a2 -> ('a1, 'a2) + coq_R_fold -> 'a3 -> 'a3) -> 'a1 t -> 'a2 -> 'a2 -> ('a1, 'a2) + coq_R_fold -> 'a3 + + val coq_R_fold_rec : + (key -> 'a1 -> 'a2 -> 'a2) -> ('a1 t -> 'a2 -> __ -> 'a3) -> ('a1 t + -> 'a2 -> X.t -> 'a1 -> (X.t * 'a1) list -> __ -> 'a2 -> ('a1, 'a2) + coq_R_fold -> 'a3 -> 'a3) -> 'a1 t -> 'a2 -> 'a2 -> ('a1, 'a2) + coq_R_fold -> 'a3 + + val fold_rect : + (key -> 'a1 -> 'a2 -> 'a2) -> ('a1 t -> 'a2 -> __ -> 'a3) -> ('a1 t + -> 'a2 -> X.t -> 'a1 -> (X.t * 'a1) list -> __ -> 'a3 -> 'a3) -> + 'a1 t -> 'a2 -> 'a3 + + val fold_rec : + (key -> 'a1 -> 'a2 -> 'a2) -> ('a1 t -> 'a2 -> __ -> 'a3) -> ('a1 t + -> 'a2 -> X.t -> 'a1 -> (X.t * 'a1) list -> __ -> 'a3 -> 'a3) -> + 'a1 t -> 'a2 -> 'a3 + + val coq_R_fold_correct : + (key -> 'a1 -> 'a2 -> 'a2) -> 'a1 t -> 'a2 -> 'a2 -> ('a1, 'a2) + coq_R_fold + + val equal : ('a1 -> 'a1 -> bool) -> 'a1 t -> 'a1 t -> bool + + type 'elt coq_R_equal = + | R_equal_0 of 'elt t * 'elt t + | R_equal_1 of 'elt t * 'elt t * X.t * 'elt * (X.t * 'elt) list * + X.t * 'elt * (X.t * 'elt) list * bool * 'elt coq_R_equal + | R_equal_2 of 'elt t * 'elt t * X.t * 'elt * (X.t * 'elt) list * + X.t * 'elt * (X.t * 'elt) list * X.t compare1 + | R_equal_3 of 'elt t * 'elt t * 'elt t * 'elt t + + val coq_R_equal_rect : + ('a1 -> 'a1 -> bool) -> ('a1 t -> 'a1 t -> __ -> __ -> 'a2) -> ('a1 + t -> 'a1 t -> X.t -> 'a1 -> (X.t * 'a1) list -> __ -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> bool -> 'a1 coq_R_equal -> + 'a2 -> 'a2) -> ('a1 t -> 'a1 t -> X.t -> 'a1 -> (X.t * 'a1) list -> + __ -> X.t -> 'a1 -> (X.t * 'a1) list -> __ -> X.t compare1 -> __ -> + __ -> 'a2) -> ('a1 t -> 'a1 t -> 'a1 t -> __ -> 'a1 t -> __ -> __ + -> 'a2) -> 'a1 t -> 'a1 t -> bool -> 'a1 coq_R_equal -> 'a2 + + val coq_R_equal_rec : + ('a1 -> 'a1 -> bool) -> ('a1 t -> 'a1 t -> __ -> __ -> 'a2) -> ('a1 + t -> 'a1 t -> X.t -> 'a1 -> (X.t * 'a1) list -> __ -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> bool -> 'a1 coq_R_equal -> + 'a2 -> 'a2) -> ('a1 t -> 'a1 t -> X.t -> 'a1 -> (X.t * 'a1) list -> + __ -> X.t -> 'a1 -> (X.t * 'a1) list -> __ -> X.t compare1 -> __ -> + __ -> 'a2) -> ('a1 t -> 'a1 t -> 'a1 t -> __ -> 'a1 t -> __ -> __ + -> 'a2) -> 'a1 t -> 'a1 t -> bool -> 'a1 coq_R_equal -> 'a2 + + val equal_rect : + ('a1 -> 'a1 -> bool) -> ('a1 t -> 'a1 t -> __ -> __ -> 'a2) -> ('a1 + t -> 'a1 t -> X.t -> 'a1 -> (X.t * 'a1) list -> __ -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> 'a2 -> 'a2) -> ('a1 t -> 'a1 + t -> X.t -> 'a1 -> (X.t * 'a1) list -> __ -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> X.t compare1 -> __ -> __ -> 'a2) -> ('a1 + t -> 'a1 t -> 'a1 t -> __ -> 'a1 t -> __ -> __ -> 'a2) -> 'a1 t -> + 'a1 t -> 'a2 + + val equal_rec : + ('a1 -> 'a1 -> bool) -> ('a1 t -> 'a1 t -> __ -> __ -> 'a2) -> ('a1 + t -> 'a1 t -> X.t -> 'a1 -> (X.t * 'a1) list -> __ -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> 'a2 -> 'a2) -> ('a1 t -> 'a1 + t -> X.t -> 'a1 -> (X.t * 'a1) list -> __ -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> X.t compare1 -> __ -> __ -> 'a2) -> ('a1 + t -> 'a1 t -> 'a1 t -> __ -> 'a1 t -> __ -> __ -> 'a2) -> 'a1 t -> + 'a1 t -> 'a2 + + val coq_R_equal_correct : + ('a1 -> 'a1 -> bool) -> 'a1 t -> 'a1 t -> bool -> 'a1 coq_R_equal + + val map : ('a1 -> 'a2) -> 'a1 t -> 'a2 t + + val mapi : (key -> 'a1 -> 'a2) -> 'a1 t -> 'a2 t + + val option_cons : + key -> 'a1 option -> (key * 'a1) list -> (key * 'a1) list + + val map2_l : + ('a1 option -> 'a2 option -> 'a3 option) -> 'a1 t -> 'a3 t + + val map2_r : + ('a1 option -> 'a2 option -> 'a3 option) -> 'a2 t -> 'a3 t + + val map2 : + ('a1 option -> 'a2 option -> 'a3 option) -> 'a1 t -> 'a2 t -> 'a3 t + + val combine : 'a1 t -> 'a2 t -> ('a1 option * 'a2 option) t + + val fold_right_pair : + ('a1 -> 'a2 -> 'a3 -> 'a3) -> ('a1 * 'a2) list -> 'a3 -> 'a3 + + val map2_alt : + ('a1 option -> 'a2 option -> 'a3 option) -> 'a1 t -> 'a2 t -> + (key * 'a3) list + + val at_least_one : + 'a1 option -> 'a2 option -> ('a1 option * 'a2 option) option + + val at_least_one_then_f : + ('a1 option -> 'a2 option -> 'a3 option) -> 'a1 option -> 'a2 + option -> 'a3 option + end + + type 'elt coq_R_mem = + | R_mem_0 of 'elt tree + | R_mem_1 of 'elt tree * 'elt tree * key * 'elt * 'elt tree * I.t + * bool * 'elt coq_R_mem + | R_mem_2 of 'elt tree * 'elt tree * key * 'elt * 'elt tree * I.t + | R_mem_3 of 'elt tree * 'elt tree * key * 'elt * 'elt tree * I.t + * bool * 'elt coq_R_mem + + val coq_R_mem_rect : + X.t -> ('a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 + -> 'a1 tree -> I.t -> __ -> __ -> __ -> bool -> 'a1 coq_R_mem -> 'a2 + -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> + __ -> __ -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 + tree -> I.t -> __ -> __ -> __ -> bool -> 'a1 coq_R_mem -> 'a2 -> 'a2) + -> 'a1 tree -> bool -> 'a1 coq_R_mem -> 'a2 + + val coq_R_mem_rec : + X.t -> ('a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 + -> 'a1 tree -> I.t -> __ -> __ -> __ -> bool -> 'a1 coq_R_mem -> 'a2 + -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> + __ -> __ -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 + tree -> I.t -> __ -> __ -> __ -> bool -> 'a1 coq_R_mem -> 'a2 -> 'a2) + -> 'a1 tree -> bool -> 'a1 coq_R_mem -> 'a2 + + type 'elt coq_R_find = + | R_find_0 of 'elt tree + | R_find_1 of 'elt tree * 'elt tree * key * 'elt * 'elt tree * + I.t * 'elt option * 'elt coq_R_find + | R_find_2 of 'elt tree * 'elt tree * key * 'elt * 'elt tree * I.t + | R_find_3 of 'elt tree * 'elt tree * key * 'elt * 'elt tree * + I.t * 'elt option * 'elt coq_R_find + + val coq_R_find_rect : + X.t -> ('a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 + -> 'a1 tree -> I.t -> __ -> __ -> __ -> 'a1 option -> 'a1 coq_R_find + -> 'a2 -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> + I.t -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 + -> 'a1 tree -> I.t -> __ -> __ -> __ -> 'a1 option -> 'a1 coq_R_find + -> 'a2 -> 'a2) -> 'a1 tree -> 'a1 option -> 'a1 coq_R_find -> 'a2 + + val coq_R_find_rec : + X.t -> ('a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 + -> 'a1 tree -> I.t -> __ -> __ -> __ -> 'a1 option -> 'a1 coq_R_find + -> 'a2 -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> + I.t -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 + -> 'a1 tree -> I.t -> __ -> __ -> __ -> 'a1 option -> 'a1 coq_R_find + -> 'a2 -> 'a2) -> 'a1 tree -> 'a1 option -> 'a1 coq_R_find -> 'a2 + + type 'elt coq_R_bal = + | R_bal_0 of 'elt tree * key * 'elt * 'elt tree + | R_bal_1 of 'elt tree * key * 'elt * 'elt tree * 'elt tree * key + * 'elt * 'elt tree * I.t + | R_bal_2 of 'elt tree * key * 'elt * 'elt tree * 'elt tree * key + * 'elt * 'elt tree * I.t + | R_bal_3 of 'elt tree * key * 'elt * 'elt tree * 'elt tree * key + * 'elt * 'elt tree * I.t * 'elt tree * key * 'elt * 'elt tree * + I.t + | R_bal_4 of 'elt tree * key * 'elt * 'elt tree + | R_bal_5 of 'elt tree * key * 'elt * 'elt tree * 'elt tree * key + * 'elt * 'elt tree * I.t + | R_bal_6 of 'elt tree * key * 'elt * 'elt tree * 'elt tree * key + * 'elt * 'elt tree * I.t + | R_bal_7 of 'elt tree * key * 'elt * 'elt tree * 'elt tree * key + * 'elt * 'elt tree * I.t * 'elt tree * key * 'elt * 'elt tree * + I.t + | R_bal_8 of 'elt tree * key * 'elt * 'elt tree + + val coq_R_bal_rect : + ('a1 tree -> key -> 'a1 -> 'a1 tree -> __ -> __ -> __ -> 'a2) -> ('a1 + tree -> key -> 'a1 -> 'a1 tree -> __ -> __ -> 'a1 tree -> key -> 'a1 + -> 'a1 tree -> I.t -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> key -> + 'a1 -> 'a1 tree -> __ -> __ -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> + I.t -> __ -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> key -> 'a1 -> 'a1 + tree -> __ -> __ -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ + -> __ -> __ -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ -> + 'a2) -> ('a1 tree -> key -> 'a1 -> 'a1 tree -> __ -> __ -> __ -> __ + -> __ -> 'a2) -> ('a1 tree -> key -> 'a1 -> 'a1 tree -> __ -> __ -> + __ -> __ -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ -> __ -> + __ -> 'a2) -> ('a1 tree -> key -> 'a1 -> 'a1 tree -> __ -> __ -> __ + -> __ -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ -> __ -> __ + -> __ -> 'a2) -> ('a1 tree -> key -> 'a1 -> 'a1 tree -> __ -> __ -> + __ -> __ -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ -> __ -> + __ -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ -> 'a2) -> ('a1 + tree -> key -> 'a1 -> 'a1 tree -> __ -> __ -> __ -> __ -> 'a2) -> 'a1 + tree -> key -> 'a1 -> 'a1 tree -> 'a1 tree -> 'a1 coq_R_bal -> 'a2 + + val coq_R_bal_rec : + ('a1 tree -> key -> 'a1 -> 'a1 tree -> __ -> __ -> __ -> 'a2) -> ('a1 + tree -> key -> 'a1 -> 'a1 tree -> __ -> __ -> 'a1 tree -> key -> 'a1 + -> 'a1 tree -> I.t -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> key -> + 'a1 -> 'a1 tree -> __ -> __ -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> + I.t -> __ -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> key -> 'a1 -> 'a1 + tree -> __ -> __ -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ + -> __ -> __ -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ -> + 'a2) -> ('a1 tree -> key -> 'a1 -> 'a1 tree -> __ -> __ -> __ -> __ + -> __ -> 'a2) -> ('a1 tree -> key -> 'a1 -> 'a1 tree -> __ -> __ -> + __ -> __ -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ -> __ -> + __ -> 'a2) -> ('a1 tree -> key -> 'a1 -> 'a1 tree -> __ -> __ -> __ + -> __ -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ -> __ -> __ + -> __ -> 'a2) -> ('a1 tree -> key -> 'a1 -> 'a1 tree -> __ -> __ -> + __ -> __ -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ -> __ -> + __ -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ -> 'a2) -> ('a1 + tree -> key -> 'a1 -> 'a1 tree -> __ -> __ -> __ -> __ -> 'a2) -> 'a1 + tree -> key -> 'a1 -> 'a1 tree -> 'a1 tree -> 'a1 coq_R_bal -> 'a2 + + type 'elt coq_R_add = + | R_add_0 of 'elt tree + | R_add_1 of 'elt tree * 'elt tree * key * 'elt * 'elt tree * I.t + * 'elt tree * 'elt coq_R_add + | R_add_2 of 'elt tree * 'elt tree * key * 'elt * 'elt tree * I.t + | R_add_3 of 'elt tree * 'elt tree * key * 'elt * 'elt tree * I.t + * 'elt tree * 'elt coq_R_add + + val coq_R_add_rect : + key -> 'a1 -> ('a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key + -> 'a1 -> 'a1 tree -> I.t -> __ -> __ -> __ -> 'a1 tree -> 'a1 + coq_R_add -> 'a2 -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 -> + 'a1 tree -> I.t -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> + key -> 'a1 -> 'a1 tree -> I.t -> __ -> __ -> __ -> 'a1 tree -> 'a1 + coq_R_add -> 'a2 -> 'a2) -> 'a1 tree -> 'a1 tree -> 'a1 coq_R_add -> + 'a2 + + val coq_R_add_rec : + key -> 'a1 -> ('a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key + -> 'a1 -> 'a1 tree -> I.t -> __ -> __ -> __ -> 'a1 tree -> 'a1 + coq_R_add -> 'a2 -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 -> + 'a1 tree -> I.t -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> + key -> 'a1 -> 'a1 tree -> I.t -> __ -> __ -> __ -> 'a1 tree -> 'a1 + coq_R_add -> 'a2 -> 'a2) -> 'a1 tree -> 'a1 tree -> 'a1 coq_R_add -> + 'a2 + + type 'elt coq_R_remove_min = + | R_remove_min_0 of 'elt tree * key * 'elt * 'elt tree + | R_remove_min_1 of 'elt tree * key * 'elt * 'elt tree * 'elt tree + * key * 'elt * 'elt tree * I.t * ('elt tree * (key * 'elt)) + * 'elt coq_R_remove_min * 'elt tree * (key * 'elt) + + val coq_R_remove_min_rect : + ('a1 tree -> key -> 'a1 -> 'a1 tree -> __ -> 'a2) -> ('a1 tree -> key + -> 'a1 -> 'a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ + -> ('a1 tree * (key * 'a1)) -> 'a1 coq_R_remove_min -> 'a2 -> 'a1 + tree -> (key * 'a1) -> __ -> 'a2) -> 'a1 tree -> key -> 'a1 -> 'a1 + tree -> ('a1 tree * (key * 'a1)) -> 'a1 coq_R_remove_min -> 'a2 + + val coq_R_remove_min_rec : + ('a1 tree -> key -> 'a1 -> 'a1 tree -> __ -> 'a2) -> ('a1 tree -> key + -> 'a1 -> 'a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ + -> ('a1 tree * (key * 'a1)) -> 'a1 coq_R_remove_min -> 'a2 -> 'a1 + tree -> (key * 'a1) -> __ -> 'a2) -> 'a1 tree -> key -> 'a1 -> 'a1 + tree -> ('a1 tree * (key * 'a1)) -> 'a1 coq_R_remove_min -> 'a2 + + type 'elt coq_R_merge = + | R_merge_0 of 'elt tree * 'elt tree + | R_merge_1 of 'elt tree * 'elt tree * 'elt tree * key * 'elt + * 'elt tree * I.t + | R_merge_2 of 'elt tree * 'elt tree * 'elt tree * key * 'elt + * 'elt tree * I.t * 'elt tree * key * 'elt * 'elt tree * I.t + * 'elt tree * (key * 'elt) * key * 'elt + + val coq_R_merge_rect : + ('a1 tree -> 'a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> 'a1 + tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ -> __ -> 'a2) -> ('a1 + tree -> 'a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ + -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ -> 'a1 tree -> + (key * 'a1) -> __ -> key -> 'a1 -> __ -> 'a2) -> 'a1 tree -> 'a1 tree + -> 'a1 tree -> 'a1 coq_R_merge -> 'a2 + + val coq_R_merge_rec : + ('a1 tree -> 'a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> 'a1 + tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ -> __ -> 'a2) -> ('a1 + tree -> 'a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ + -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ -> 'a1 tree -> + (key * 'a1) -> __ -> key -> 'a1 -> __ -> 'a2) -> 'a1 tree -> 'a1 tree + -> 'a1 tree -> 'a1 coq_R_merge -> 'a2 + + type 'elt coq_R_remove = + | R_remove_0 of 'elt tree + | R_remove_1 of 'elt tree * 'elt tree * key * 'elt * 'elt tree * + I.t * 'elt tree * 'elt coq_R_remove + | R_remove_2 of 'elt tree * 'elt tree * key * 'elt * 'elt tree * I.t + | R_remove_3 of 'elt tree * 'elt tree * key * 'elt * 'elt tree * + I.t * 'elt tree * 'elt coq_R_remove + + val coq_R_remove_rect : + X.t -> ('a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 + -> 'a1 tree -> I.t -> __ -> __ -> __ -> 'a1 tree -> 'a1 coq_R_remove + -> 'a2 -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> + I.t -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 + -> 'a1 tree -> I.t -> __ -> __ -> __ -> 'a1 tree -> 'a1 coq_R_remove + -> 'a2 -> 'a2) -> 'a1 tree -> 'a1 tree -> 'a1 coq_R_remove -> 'a2 + + val coq_R_remove_rec : + X.t -> ('a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 + -> 'a1 tree -> I.t -> __ -> __ -> __ -> 'a1 tree -> 'a1 coq_R_remove + -> 'a2 -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> + I.t -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 + -> 'a1 tree -> I.t -> __ -> __ -> __ -> 'a1 tree -> 'a1 coq_R_remove + -> 'a2 -> 'a2) -> 'a1 tree -> 'a1 tree -> 'a1 coq_R_remove -> 'a2 + + type 'elt coq_R_concat = + | R_concat_0 of 'elt tree * 'elt tree + | R_concat_1 of 'elt tree * 'elt tree * 'elt tree * key * 'elt + * 'elt tree * I.t + | R_concat_2 of 'elt tree * 'elt tree * 'elt tree * key * 'elt + * 'elt tree * I.t * 'elt tree * key * 'elt * 'elt tree * I.t + * 'elt tree * (key * 'elt) + + val coq_R_concat_rect : + ('a1 tree -> 'a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> 'a1 + tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ -> __ -> 'a2) -> ('a1 + tree -> 'a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ + -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ -> 'a1 tree -> + (key * 'a1) -> __ -> 'a2) -> 'a1 tree -> 'a1 tree -> 'a1 tree -> 'a1 + coq_R_concat -> 'a2 + + val coq_R_concat_rec : + ('a1 tree -> 'a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> 'a1 + tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ -> __ -> 'a2) -> ('a1 + tree -> 'a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ + -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ -> 'a1 tree -> + (key * 'a1) -> __ -> 'a2) -> 'a1 tree -> 'a1 tree -> 'a1 tree -> 'a1 + coq_R_concat -> 'a2 + + type 'elt coq_R_split = + | R_split_0 of 'elt tree + | R_split_1 of 'elt tree * 'elt tree * key * 'elt * 'elt tree * + I.t * 'elt triple * 'elt coq_R_split * 'elt tree * 'elt option + * 'elt tree + | R_split_2 of 'elt tree * 'elt tree * key * 'elt * 'elt tree * I.t + | R_split_3 of 'elt tree * 'elt tree * key * 'elt * 'elt tree * + I.t * 'elt triple * 'elt coq_R_split * 'elt tree * 'elt option + * 'elt tree + + val coq_R_split_rect : + X.t -> ('a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 + -> 'a1 tree -> I.t -> __ -> __ -> __ -> 'a1 triple -> 'a1 coq_R_split + -> 'a2 -> 'a1 tree -> 'a1 option -> 'a1 tree -> __ -> 'a2) -> ('a1 + tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ -> __ -> __ + -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> + __ -> __ -> __ -> 'a1 triple -> 'a1 coq_R_split -> 'a2 -> 'a1 tree -> + 'a1 option -> 'a1 tree -> __ -> 'a2) -> 'a1 tree -> 'a1 triple -> 'a1 + coq_R_split -> 'a2 + + val coq_R_split_rec : + X.t -> ('a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 + -> 'a1 tree -> I.t -> __ -> __ -> __ -> 'a1 triple -> 'a1 coq_R_split + -> 'a2 -> 'a1 tree -> 'a1 option -> 'a1 tree -> __ -> 'a2) -> ('a1 + tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ -> __ -> __ + -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> + __ -> __ -> __ -> 'a1 triple -> 'a1 coq_R_split -> 'a2 -> 'a1 tree -> + 'a1 option -> 'a1 tree -> __ -> 'a2) -> 'a1 tree -> 'a1 triple -> 'a1 + coq_R_split -> 'a2 + + type ('elt, 'x) coq_R_map_option = + | R_map_option_0 of 'elt tree + | R_map_option_1 of 'elt tree * 'elt tree * key * 'elt * 'elt tree + * I.t * 'x * 'x tree * ('elt, 'x) coq_R_map_option * 'x tree + * ('elt, 'x) coq_R_map_option + | R_map_option_2 of 'elt tree * 'elt tree * key * 'elt * 'elt tree + * I.t * 'x tree * ('elt, 'x) coq_R_map_option * 'x tree + * ('elt, 'x) coq_R_map_option + + val coq_R_map_option_rect : + (key -> 'a1 -> 'a2 option) -> ('a1 tree -> __ -> 'a3) -> ('a1 tree -> + 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ -> 'a2 -> __ -> 'a2 + tree -> ('a1, 'a2) coq_R_map_option -> 'a3 -> 'a2 tree -> ('a1, 'a2) + coq_R_map_option -> 'a3 -> 'a3) -> ('a1 tree -> 'a1 tree -> key -> + 'a1 -> 'a1 tree -> I.t -> __ -> __ -> 'a2 tree -> ('a1, 'a2) + coq_R_map_option -> 'a3 -> 'a2 tree -> ('a1, 'a2) coq_R_map_option -> + 'a3 -> 'a3) -> 'a1 tree -> 'a2 tree -> ('a1, 'a2) coq_R_map_option -> + 'a3 + + val coq_R_map_option_rec : + (key -> 'a1 -> 'a2 option) -> ('a1 tree -> __ -> 'a3) -> ('a1 tree -> + 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ -> 'a2 -> __ -> 'a2 + tree -> ('a1, 'a2) coq_R_map_option -> 'a3 -> 'a2 tree -> ('a1, 'a2) + coq_R_map_option -> 'a3 -> 'a3) -> ('a1 tree -> 'a1 tree -> key -> + 'a1 -> 'a1 tree -> I.t -> __ -> __ -> 'a2 tree -> ('a1, 'a2) + coq_R_map_option -> 'a3 -> 'a2 tree -> ('a1, 'a2) coq_R_map_option -> + 'a3 -> 'a3) -> 'a1 tree -> 'a2 tree -> ('a1, 'a2) coq_R_map_option -> + 'a3 + + type ('elt, 'x0, 'x) coq_R_map2_opt = + | R_map2_opt_0 of 'elt tree * 'x0 tree + | R_map2_opt_1 of 'elt tree * 'x0 tree * 'elt tree * key * 'elt + * 'elt tree * I.t + | R_map2_opt_2 of 'elt tree * 'x0 tree * 'elt tree * key * 'elt + * 'elt tree * I.t * 'x0 tree * key * 'x0 * 'x0 tree * I.t * + 'x0 tree * 'x0 option * 'x0 tree * 'x * 'x tree + * ('elt, 'x0, 'x) coq_R_map2_opt * 'x tree + * ('elt, 'x0, 'x) coq_R_map2_opt + | R_map2_opt_3 of 'elt tree * 'x0 tree * 'elt tree * key * 'elt + * 'elt tree * I.t * 'x0 tree * key * 'x0 * 'x0 tree * I.t * + 'x0 tree * 'x0 option * 'x0 tree * 'x tree + * ('elt, 'x0, 'x) coq_R_map2_opt * 'x tree + * ('elt, 'x0, 'x) coq_R_map2_opt + + val coq_R_map2_opt_rect : + (key -> 'a1 -> 'a2 option -> 'a3 option) -> ('a1 tree -> 'a3 tree) -> + ('a2 tree -> 'a3 tree) -> ('a1 tree -> 'a2 tree -> __ -> 'a4) -> ('a1 + tree -> 'a2 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ + -> __ -> 'a4) -> ('a1 tree -> 'a2 tree -> 'a1 tree -> key -> 'a1 -> + 'a1 tree -> I.t -> __ -> 'a2 tree -> key -> 'a2 -> 'a2 tree -> I.t -> + __ -> 'a2 tree -> 'a2 option -> 'a2 tree -> __ -> 'a3 -> __ -> 'a3 + tree -> ('a1, 'a2, 'a3) coq_R_map2_opt -> 'a4 -> 'a3 tree -> ('a1, + 'a2, 'a3) coq_R_map2_opt -> 'a4 -> 'a4) -> ('a1 tree -> 'a2 tree -> + 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ -> 'a2 tree -> key -> + 'a2 -> 'a2 tree -> I.t -> __ -> 'a2 tree -> 'a2 option -> 'a2 tree -> + __ -> __ -> 'a3 tree -> ('a1, 'a2, 'a3) coq_R_map2_opt -> 'a4 -> 'a3 + tree -> ('a1, 'a2, 'a3) coq_R_map2_opt -> 'a4 -> 'a4) -> 'a1 tree -> + 'a2 tree -> 'a3 tree -> ('a1, 'a2, 'a3) coq_R_map2_opt -> 'a4 + + val coq_R_map2_opt_rec : + (key -> 'a1 -> 'a2 option -> 'a3 option) -> ('a1 tree -> 'a3 tree) -> + ('a2 tree -> 'a3 tree) -> ('a1 tree -> 'a2 tree -> __ -> 'a4) -> ('a1 + tree -> 'a2 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ + -> __ -> 'a4) -> ('a1 tree -> 'a2 tree -> 'a1 tree -> key -> 'a1 -> + 'a1 tree -> I.t -> __ -> 'a2 tree -> key -> 'a2 -> 'a2 tree -> I.t -> + __ -> 'a2 tree -> 'a2 option -> 'a2 tree -> __ -> 'a3 -> __ -> 'a3 + tree -> ('a1, 'a2, 'a3) coq_R_map2_opt -> 'a4 -> 'a3 tree -> ('a1, + 'a2, 'a3) coq_R_map2_opt -> 'a4 -> 'a4) -> ('a1 tree -> 'a2 tree -> + 'a1 tree -> key -> 'a1 -> 'a1 tree -> I.t -> __ -> 'a2 tree -> key -> + 'a2 -> 'a2 tree -> I.t -> __ -> 'a2 tree -> 'a2 option -> 'a2 tree -> + __ -> __ -> 'a3 tree -> ('a1, 'a2, 'a3) coq_R_map2_opt -> 'a4 -> 'a3 + tree -> ('a1, 'a2, 'a3) coq_R_map2_opt -> 'a4 -> 'a4) -> 'a1 tree -> + 'a2 tree -> 'a3 tree -> ('a1, 'a2, 'a3) coq_R_map2_opt -> 'a4 + + val fold' : (key -> 'a1 -> 'a2 -> 'a2) -> 'a1 tree -> 'a2 -> 'a2 + + val flatten_e : 'a1 enumeration -> (key * 'a1) list + end + end + + type 'elt bst = + 'elt Raw.tree + (* singleton inductive, whose constructor was Bst *) + + val this : 'a1 bst -> 'a1 Raw.tree + + type 'elt t = 'elt bst + + type key = E.t + + val empty : 'a1 t + + val is_empty : 'a1 t -> bool + + val add : key -> 'a1 -> 'a1 t -> 'a1 t + + val remove : key -> 'a1 t -> 'a1 t + + val mem : key -> 'a1 t -> bool + + val find : key -> 'a1 t -> 'a1 option + + val map : ('a1 -> 'a2) -> 'a1 t -> 'a2 t + + val mapi : (key -> 'a1 -> 'a2) -> 'a1 t -> 'a2 t + + val map2 : + ('a1 option -> 'a2 option -> 'a3 option) -> 'a1 t -> 'a2 t -> 'a3 t + + val elements : 'a1 t -> (key * 'a1) list + + val cardinal : 'a1 t -> nat + + val fold : (key -> 'a1 -> 'a2 -> 'a2) -> 'a1 t -> 'a2 -> 'a2 + + val equal : ('a1 -> 'a1 -> bool) -> 'a1 t -> 'a1 t -> bool + end + +module Make : + functor (X:OrderedType) -> + sig + module E : + sig + type t = X.t + + val compare : t -> t -> t compare1 + + val eq_dec : t -> t -> sumbool + end + + module Raw : + sig + type key = X.t + + type 'elt tree = + | Leaf + | Node of 'elt tree * key * 'elt * 'elt tree * Z_as_Int.t + + val tree_rect : + 'a2 -> ('a1 tree -> 'a2 -> key -> 'a1 -> 'a1 tree -> 'a2 -> Z_as_Int.t + -> 'a2) -> 'a1 tree -> 'a2 + + val tree_rec : + 'a2 -> ('a1 tree -> 'a2 -> key -> 'a1 -> 'a1 tree -> 'a2 -> Z_as_Int.t + -> 'a2) -> 'a1 tree -> 'a2 + + val height : 'a1 tree -> Z_as_Int.t + + val cardinal : 'a1 tree -> nat + + val empty : 'a1 tree + + val is_empty : 'a1 tree -> bool + + val mem : X.t -> 'a1 tree -> bool + + val find : X.t -> 'a1 tree -> 'a1 option + + val create : 'a1 tree -> key -> 'a1 -> 'a1 tree -> 'a1 tree + + val assert_false : 'a1 tree -> key -> 'a1 -> 'a1 tree -> 'a1 tree + + val bal : 'a1 tree -> key -> 'a1 -> 'a1 tree -> 'a1 tree + + val add : key -> 'a1 -> 'a1 tree -> 'a1 tree + + val remove_min : + 'a1 tree -> key -> 'a1 -> 'a1 tree -> 'a1 tree * (key * 'a1) + + val merge : 'a1 tree -> 'a1 tree -> 'a1 tree + + val remove : X.t -> 'a1 tree -> 'a1 tree + + val join : 'a1 tree -> key -> 'a1 -> 'a1 tree -> 'a1 tree + + type 'elt triple = { t_left : 'elt tree; t_opt : 'elt option; + t_right : 'elt tree } + + val t_left : 'a1 triple -> 'a1 tree + + val t_opt : 'a1 triple -> 'a1 option + + val t_right : 'a1 triple -> 'a1 tree + + val split : X.t -> 'a1 tree -> 'a1 triple + + val concat : 'a1 tree -> 'a1 tree -> 'a1 tree + + val elements_aux : (key * 'a1) list -> 'a1 tree -> (key * 'a1) list + + val elements : 'a1 tree -> (key * 'a1) list + + val fold : (key -> 'a1 -> 'a2 -> 'a2) -> 'a1 tree -> 'a2 -> 'a2 + + type 'elt enumeration = + | End + | More of key * 'elt * 'elt tree * 'elt enumeration + + val enumeration_rect : + 'a2 -> (key -> 'a1 -> 'a1 tree -> 'a1 enumeration -> 'a2 -> 'a2) -> 'a1 + enumeration -> 'a2 + + val enumeration_rec : + 'a2 -> (key -> 'a1 -> 'a1 tree -> 'a1 enumeration -> 'a2 -> 'a2) -> 'a1 + enumeration -> 'a2 + + val cons : 'a1 tree -> 'a1 enumeration -> 'a1 enumeration + + val equal_more : + ('a1 -> 'a1 -> bool) -> X.t -> 'a1 -> ('a1 enumeration -> bool) -> 'a1 + enumeration -> bool + + val equal_cont : + ('a1 -> 'a1 -> bool) -> 'a1 tree -> ('a1 enumeration -> bool) -> 'a1 + enumeration -> bool + + val equal_end : 'a1 enumeration -> bool + + val equal : ('a1 -> 'a1 -> bool) -> 'a1 tree -> 'a1 tree -> bool + + val map : ('a1 -> 'a2) -> 'a1 tree -> 'a2 tree + + val mapi : (key -> 'a1 -> 'a2) -> 'a1 tree -> 'a2 tree + + val map_option : (key -> 'a1 -> 'a2 option) -> 'a1 tree -> 'a2 tree + + val map2_opt : + (key -> 'a1 -> 'a2 option -> 'a3 option) -> ('a1 tree -> 'a3 tree) -> + ('a2 tree -> 'a3 tree) -> 'a1 tree -> 'a2 tree -> 'a3 tree + + val map2 : + ('a1 option -> 'a2 option -> 'a3 option) -> 'a1 tree -> 'a2 tree -> 'a3 + tree + + module Proofs : + sig + module MX : + sig + module TO : + sig + type t = X.t + end + + module IsTO : + sig + end + + module OrderTac : + sig + end + + val eq_dec : X.t -> X.t -> sumbool + + val lt_dec : X.t -> X.t -> sumbool + + val eqb : X.t -> X.t -> bool + end + + module PX : + sig + module MO : + sig + module TO : + sig + type t = X.t + end + + module IsTO : + sig + end + + module OrderTac : + sig + end + + val eq_dec : X.t -> X.t -> sumbool + + val lt_dec : X.t -> X.t -> sumbool + + val eqb : X.t -> X.t -> bool + end + end + + module L : + sig + module MX : + sig + module TO : + sig + type t = X.t + end + + module IsTO : + sig + end + + module OrderTac : + sig + end + + val eq_dec : X.t -> X.t -> sumbool + + val lt_dec : X.t -> X.t -> sumbool + + val eqb : X.t -> X.t -> bool + end + + module PX : + sig + module MO : + sig + module TO : + sig + type t = X.t + end + + module IsTO : + sig + end + + module OrderTac : + sig + end + + val eq_dec : X.t -> X.t -> sumbool + + val lt_dec : X.t -> X.t -> sumbool + + val eqb : X.t -> X.t -> bool + end + end + + type key = X.t + + type 'elt t = (X.t * 'elt) list + + val empty : 'a1 t + + val is_empty : 'a1 t -> bool + + val mem : key -> 'a1 t -> bool + + type 'elt coq_R_mem = + | R_mem_0 of 'elt t + | R_mem_1 of 'elt t * X.t * 'elt * (X.t * 'elt) list + | R_mem_2 of 'elt t * X.t * 'elt * (X.t * 'elt) list + | R_mem_3 of 'elt t * X.t * 'elt * (X.t * 'elt) list * bool + * 'elt coq_R_mem + + val coq_R_mem_rect : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 + -> (X.t * 'a1) list -> __ -> __ -> __ -> bool -> 'a1 coq_R_mem -> + 'a2 -> 'a2) -> 'a1 t -> bool -> 'a1 coq_R_mem -> 'a2 + + val coq_R_mem_rec : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 + -> (X.t * 'a1) list -> __ -> __ -> __ -> bool -> 'a1 coq_R_mem -> + 'a2 -> 'a2) -> 'a1 t -> bool -> 'a1 coq_R_mem -> 'a2 + + val mem_rect : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 + -> (X.t * 'a1) list -> __ -> __ -> __ -> 'a2 -> 'a2) -> 'a1 t -> 'a2 + + val mem_rec : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 + -> (X.t * 'a1) list -> __ -> __ -> __ -> 'a2 -> 'a2) -> 'a1 t -> 'a2 + + val coq_R_mem_correct : key -> 'a1 t -> bool -> 'a1 coq_R_mem + + val find : key -> 'a1 t -> 'a1 option + + type 'elt coq_R_find = + | R_find_0 of 'elt t + | R_find_1 of 'elt t * X.t * 'elt * (X.t * 'elt) list + | R_find_2 of 'elt t * X.t * 'elt * (X.t * 'elt) list + | R_find_3 of 'elt t * X.t * 'elt * (X.t * 'elt) list * 'elt option + * 'elt coq_R_find + + val coq_R_find_rect : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 + -> (X.t * 'a1) list -> __ -> __ -> __ -> 'a1 option -> 'a1 + coq_R_find -> 'a2 -> 'a2) -> 'a1 t -> 'a1 option -> 'a1 coq_R_find + -> 'a2 + + val coq_R_find_rec : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 + -> (X.t * 'a1) list -> __ -> __ -> __ -> 'a1 option -> 'a1 + coq_R_find -> 'a2 -> 'a2) -> 'a1 t -> 'a1 option -> 'a1 coq_R_find + -> 'a2 + + val find_rect : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 + -> (X.t * 'a1) list -> __ -> __ -> __ -> 'a2 -> 'a2) -> 'a1 t -> 'a2 + + val find_rec : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 + -> (X.t * 'a1) list -> __ -> __ -> __ -> 'a2 -> 'a2) -> 'a1 t -> 'a2 + + val coq_R_find_correct : key -> 'a1 t -> 'a1 option -> 'a1 coq_R_find + + val add : key -> 'a1 -> 'a1 t -> 'a1 t + + type 'elt coq_R_add = + | R_add_0 of 'elt t + | R_add_1 of 'elt t * X.t * 'elt * (X.t * 'elt) list + | R_add_2 of 'elt t * X.t * 'elt * (X.t * 'elt) list + | R_add_3 of 'elt t * X.t * 'elt * (X.t * 'elt) list * 'elt t + * 'elt coq_R_add + + val coq_R_add_rect : + key -> 'a1 -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 + -> (X.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> + 'a1 -> (X.t * 'a1) list -> __ -> __ -> __ -> 'a1 t -> 'a1 coq_R_add + -> 'a2 -> 'a2) -> 'a1 t -> 'a1 t -> 'a1 coq_R_add -> 'a2 + + val coq_R_add_rec : + key -> 'a1 -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 + -> (X.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> + 'a1 -> (X.t * 'a1) list -> __ -> __ -> __ -> 'a1 t -> 'a1 coq_R_add + -> 'a2 -> 'a2) -> 'a1 t -> 'a1 t -> 'a1 coq_R_add -> 'a2 + + val add_rect : + key -> 'a1 -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 + -> (X.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> + 'a1 -> (X.t * 'a1) list -> __ -> __ -> __ -> 'a2 -> 'a2) -> 'a1 t + -> 'a2 + + val add_rec : + key -> 'a1 -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 + -> (X.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> + 'a1 -> (X.t * 'a1) list -> __ -> __ -> __ -> 'a2 -> 'a2) -> 'a1 t + -> 'a2 + + val coq_R_add_correct : key -> 'a1 -> 'a1 t -> 'a1 t -> 'a1 coq_R_add + + val remove : key -> 'a1 t -> 'a1 t + + type 'elt coq_R_remove = + | R_remove_0 of 'elt t + | R_remove_1 of 'elt t * X.t * 'elt * (X.t * 'elt) list + | R_remove_2 of 'elt t * X.t * 'elt * (X.t * 'elt) list + | R_remove_3 of 'elt t * X.t * 'elt * (X.t * 'elt) list * 'elt t + * 'elt coq_R_remove + + val coq_R_remove_rect : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 + -> (X.t * 'a1) list -> __ -> __ -> __ -> 'a1 t -> 'a1 coq_R_remove + -> 'a2 -> 'a2) -> 'a1 t -> 'a1 t -> 'a1 coq_R_remove -> 'a2 + + val coq_R_remove_rec : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 + -> (X.t * 'a1) list -> __ -> __ -> __ -> 'a1 t -> 'a1 coq_R_remove + -> 'a2 -> 'a2) -> 'a1 t -> 'a1 t -> 'a1 coq_R_remove -> 'a2 + + val remove_rect : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 + -> (X.t * 'a1) list -> __ -> __ -> __ -> 'a2 -> 'a2) -> 'a1 t -> 'a2 + + val remove_rec : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> (X.t * 'a1) + list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> X.t -> 'a1 + -> (X.t * 'a1) list -> __ -> __ -> __ -> 'a2 -> 'a2) -> 'a1 t -> 'a2 + + val coq_R_remove_correct : key -> 'a1 t -> 'a1 t -> 'a1 coq_R_remove + + val elements : 'a1 t -> 'a1 t + + val fold : (key -> 'a1 -> 'a2 -> 'a2) -> 'a1 t -> 'a2 -> 'a2 + + type ('elt, 'a) coq_R_fold = + | R_fold_0 of 'elt t * 'a + | R_fold_1 of 'elt t * 'a * X.t * 'elt * (X.t * 'elt) list * + 'a * ('elt, 'a) coq_R_fold + + val coq_R_fold_rect : + (key -> 'a1 -> 'a2 -> 'a2) -> ('a1 t -> 'a2 -> __ -> 'a3) -> ('a1 t + -> 'a2 -> X.t -> 'a1 -> (X.t * 'a1) list -> __ -> 'a2 -> ('a1, 'a2) + coq_R_fold -> 'a3 -> 'a3) -> 'a1 t -> 'a2 -> 'a2 -> ('a1, 'a2) + coq_R_fold -> 'a3 + + val coq_R_fold_rec : + (key -> 'a1 -> 'a2 -> 'a2) -> ('a1 t -> 'a2 -> __ -> 'a3) -> ('a1 t + -> 'a2 -> X.t -> 'a1 -> (X.t * 'a1) list -> __ -> 'a2 -> ('a1, 'a2) + coq_R_fold -> 'a3 -> 'a3) -> 'a1 t -> 'a2 -> 'a2 -> ('a1, 'a2) + coq_R_fold -> 'a3 + + val fold_rect : + (key -> 'a1 -> 'a2 -> 'a2) -> ('a1 t -> 'a2 -> __ -> 'a3) -> ('a1 t + -> 'a2 -> X.t -> 'a1 -> (X.t * 'a1) list -> __ -> 'a3 -> 'a3) -> + 'a1 t -> 'a2 -> 'a3 + + val fold_rec : + (key -> 'a1 -> 'a2 -> 'a2) -> ('a1 t -> 'a2 -> __ -> 'a3) -> ('a1 t + -> 'a2 -> X.t -> 'a1 -> (X.t * 'a1) list -> __ -> 'a3 -> 'a3) -> + 'a1 t -> 'a2 -> 'a3 + + val coq_R_fold_correct : + (key -> 'a1 -> 'a2 -> 'a2) -> 'a1 t -> 'a2 -> 'a2 -> ('a1, 'a2) + coq_R_fold + + val equal : ('a1 -> 'a1 -> bool) -> 'a1 t -> 'a1 t -> bool + + type 'elt coq_R_equal = + | R_equal_0 of 'elt t * 'elt t + | R_equal_1 of 'elt t * 'elt t * X.t * 'elt * (X.t * 'elt) list * + X.t * 'elt * (X.t * 'elt) list * bool * 'elt coq_R_equal + | R_equal_2 of 'elt t * 'elt t * X.t * 'elt * (X.t * 'elt) list * + X.t * 'elt * (X.t * 'elt) list * X.t compare1 + | R_equal_3 of 'elt t * 'elt t * 'elt t * 'elt t + + val coq_R_equal_rect : + ('a1 -> 'a1 -> bool) -> ('a1 t -> 'a1 t -> __ -> __ -> 'a2) -> ('a1 + t -> 'a1 t -> X.t -> 'a1 -> (X.t * 'a1) list -> __ -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> bool -> 'a1 coq_R_equal -> + 'a2 -> 'a2) -> ('a1 t -> 'a1 t -> X.t -> 'a1 -> (X.t * 'a1) list -> + __ -> X.t -> 'a1 -> (X.t * 'a1) list -> __ -> X.t compare1 -> __ -> + __ -> 'a2) -> ('a1 t -> 'a1 t -> 'a1 t -> __ -> 'a1 t -> __ -> __ + -> 'a2) -> 'a1 t -> 'a1 t -> bool -> 'a1 coq_R_equal -> 'a2 + + val coq_R_equal_rec : + ('a1 -> 'a1 -> bool) -> ('a1 t -> 'a1 t -> __ -> __ -> 'a2) -> ('a1 + t -> 'a1 t -> X.t -> 'a1 -> (X.t * 'a1) list -> __ -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> bool -> 'a1 coq_R_equal -> + 'a2 -> 'a2) -> ('a1 t -> 'a1 t -> X.t -> 'a1 -> (X.t * 'a1) list -> + __ -> X.t -> 'a1 -> (X.t * 'a1) list -> __ -> X.t compare1 -> __ -> + __ -> 'a2) -> ('a1 t -> 'a1 t -> 'a1 t -> __ -> 'a1 t -> __ -> __ + -> 'a2) -> 'a1 t -> 'a1 t -> bool -> 'a1 coq_R_equal -> 'a2 + + val equal_rect : + ('a1 -> 'a1 -> bool) -> ('a1 t -> 'a1 t -> __ -> __ -> 'a2) -> ('a1 + t -> 'a1 t -> X.t -> 'a1 -> (X.t * 'a1) list -> __ -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> 'a2 -> 'a2) -> ('a1 t -> 'a1 + t -> X.t -> 'a1 -> (X.t * 'a1) list -> __ -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> X.t compare1 -> __ -> __ -> 'a2) -> ('a1 + t -> 'a1 t -> 'a1 t -> __ -> 'a1 t -> __ -> __ -> 'a2) -> 'a1 t -> + 'a1 t -> 'a2 + + val equal_rec : + ('a1 -> 'a1 -> bool) -> ('a1 t -> 'a1 t -> __ -> __ -> 'a2) -> ('a1 + t -> 'a1 t -> X.t -> 'a1 -> (X.t * 'a1) list -> __ -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> __ -> __ -> 'a2 -> 'a2) -> ('a1 t -> 'a1 + t -> X.t -> 'a1 -> (X.t * 'a1) list -> __ -> X.t -> 'a1 -> + (X.t * 'a1) list -> __ -> X.t compare1 -> __ -> __ -> 'a2) -> ('a1 + t -> 'a1 t -> 'a1 t -> __ -> 'a1 t -> __ -> __ -> 'a2) -> 'a1 t -> + 'a1 t -> 'a2 + + val coq_R_equal_correct : + ('a1 -> 'a1 -> bool) -> 'a1 t -> 'a1 t -> bool -> 'a1 coq_R_equal + + val map : ('a1 -> 'a2) -> 'a1 t -> 'a2 t + + val mapi : (key -> 'a1 -> 'a2) -> 'a1 t -> 'a2 t + + val option_cons : + key -> 'a1 option -> (key * 'a1) list -> (key * 'a1) list + + val map2_l : + ('a1 option -> 'a2 option -> 'a3 option) -> 'a1 t -> 'a3 t + + val map2_r : + ('a1 option -> 'a2 option -> 'a3 option) -> 'a2 t -> 'a3 t + + val map2 : + ('a1 option -> 'a2 option -> 'a3 option) -> 'a1 t -> 'a2 t -> 'a3 t + + val combine : 'a1 t -> 'a2 t -> ('a1 option * 'a2 option) t + + val fold_right_pair : + ('a1 -> 'a2 -> 'a3 -> 'a3) -> ('a1 * 'a2) list -> 'a3 -> 'a3 + + val map2_alt : + ('a1 option -> 'a2 option -> 'a3 option) -> 'a1 t -> 'a2 t -> + (key * 'a3) list + + val at_least_one : + 'a1 option -> 'a2 option -> ('a1 option * 'a2 option) option + + val at_least_one_then_f : + ('a1 option -> 'a2 option -> 'a3 option) -> 'a1 option -> 'a2 + option -> 'a3 option + end + + type 'elt coq_R_mem = + | R_mem_0 of 'elt tree + | R_mem_1 of 'elt tree * 'elt tree * key * 'elt * 'elt tree + * Z_as_Int.t * bool * 'elt coq_R_mem + | R_mem_2 of 'elt tree * 'elt tree * key * 'elt * 'elt tree * Z_as_Int.t + | R_mem_3 of 'elt tree * 'elt tree * key * 'elt * 'elt tree + * Z_as_Int.t * bool * 'elt coq_R_mem + + val coq_R_mem_rect : + X.t -> ('a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 + -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> bool -> 'a1 coq_R_mem + -> 'a2 -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> + Z_as_Int.t -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key + -> 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> bool -> 'a1 + coq_R_mem -> 'a2 -> 'a2) -> 'a1 tree -> bool -> 'a1 coq_R_mem -> 'a2 + + val coq_R_mem_rec : + X.t -> ('a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 + -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> bool -> 'a1 coq_R_mem + -> 'a2 -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> + Z_as_Int.t -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key + -> 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> bool -> 'a1 + coq_R_mem -> 'a2 -> 'a2) -> 'a1 tree -> bool -> 'a1 coq_R_mem -> 'a2 + + type 'elt coq_R_find = + | R_find_0 of 'elt tree + | R_find_1 of 'elt tree * 'elt tree * key * 'elt * 'elt tree + * Z_as_Int.t * 'elt option * 'elt coq_R_find + | R_find_2 of 'elt tree * 'elt tree * key * 'elt * 'elt tree + * Z_as_Int.t + | R_find_3 of 'elt tree * 'elt tree * key * 'elt * 'elt tree + * Z_as_Int.t * 'elt option * 'elt coq_R_find + + val coq_R_find_rect : + X.t -> ('a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 + -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a1 option -> 'a1 + coq_R_find -> 'a2 -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 -> + 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> 'a1 + tree -> key -> 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a1 + option -> 'a1 coq_R_find -> 'a2 -> 'a2) -> 'a1 tree -> 'a1 option -> + 'a1 coq_R_find -> 'a2 + + val coq_R_find_rec : + X.t -> ('a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 + -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a1 option -> 'a1 + coq_R_find -> 'a2 -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 -> + 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> 'a1 + tree -> key -> 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a1 + option -> 'a1 coq_R_find -> 'a2 -> 'a2) -> 'a1 tree -> 'a1 option -> + 'a1 coq_R_find -> 'a2 + + type 'elt coq_R_bal = + | R_bal_0 of 'elt tree * key * 'elt * 'elt tree + | R_bal_1 of 'elt tree * key * 'elt * 'elt tree * 'elt tree * key + * 'elt * 'elt tree * Z_as_Int.t + | R_bal_2 of 'elt tree * key * 'elt * 'elt tree * 'elt tree * key + * 'elt * 'elt tree * Z_as_Int.t + | R_bal_3 of 'elt tree * key * 'elt * 'elt tree * 'elt tree * key + * 'elt * 'elt tree * Z_as_Int.t * 'elt tree * key * 'elt * 'elt tree + * Z_as_Int.t + | R_bal_4 of 'elt tree * key * 'elt * 'elt tree + | R_bal_5 of 'elt tree * key * 'elt * 'elt tree * 'elt tree * key + * 'elt * 'elt tree * Z_as_Int.t + | R_bal_6 of 'elt tree * key * 'elt * 'elt tree * 'elt tree * key + * 'elt * 'elt tree * Z_as_Int.t + | R_bal_7 of 'elt tree * key * 'elt * 'elt tree * 'elt tree * key + * 'elt * 'elt tree * Z_as_Int.t * 'elt tree * key * 'elt * 'elt tree + * Z_as_Int.t + | R_bal_8 of 'elt tree * key * 'elt * 'elt tree + + val coq_R_bal_rect : + ('a1 tree -> key -> 'a1 -> 'a1 tree -> __ -> __ -> __ -> 'a2) -> ('a1 + tree -> key -> 'a1 -> 'a1 tree -> __ -> __ -> 'a1 tree -> key -> 'a1 + -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> + key -> 'a1 -> 'a1 tree -> __ -> __ -> 'a1 tree -> key -> 'a1 -> 'a1 + tree -> Z_as_Int.t -> __ -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> + key -> 'a1 -> 'a1 tree -> __ -> __ -> 'a1 tree -> key -> 'a1 -> 'a1 + tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a1 tree -> key -> 'a1 -> 'a1 + tree -> Z_as_Int.t -> __ -> 'a2) -> ('a1 tree -> key -> 'a1 -> 'a1 + tree -> __ -> __ -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> key -> 'a1 + -> 'a1 tree -> __ -> __ -> __ -> __ -> 'a1 tree -> key -> 'a1 -> 'a1 + tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> key -> + 'a1 -> 'a1 tree -> __ -> __ -> __ -> __ -> 'a1 tree -> key -> 'a1 -> + 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> __ -> 'a2) -> ('a1 tree + -> key -> 'a1 -> 'a1 tree -> __ -> __ -> __ -> __ -> 'a1 tree -> key + -> 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a1 tree -> key + -> 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> 'a2) -> ('a1 tree -> key -> + 'a1 -> 'a1 tree -> __ -> __ -> __ -> __ -> 'a2) -> 'a1 tree -> key -> + 'a1 -> 'a1 tree -> 'a1 tree -> 'a1 coq_R_bal -> 'a2 + + val coq_R_bal_rec : + ('a1 tree -> key -> 'a1 -> 'a1 tree -> __ -> __ -> __ -> 'a2) -> ('a1 + tree -> key -> 'a1 -> 'a1 tree -> __ -> __ -> 'a1 tree -> key -> 'a1 + -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> + key -> 'a1 -> 'a1 tree -> __ -> __ -> 'a1 tree -> key -> 'a1 -> 'a1 + tree -> Z_as_Int.t -> __ -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> + key -> 'a1 -> 'a1 tree -> __ -> __ -> 'a1 tree -> key -> 'a1 -> 'a1 + tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a1 tree -> key -> 'a1 -> 'a1 + tree -> Z_as_Int.t -> __ -> 'a2) -> ('a1 tree -> key -> 'a1 -> 'a1 + tree -> __ -> __ -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> key -> 'a1 + -> 'a1 tree -> __ -> __ -> __ -> __ -> 'a1 tree -> key -> 'a1 -> 'a1 + tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> key -> + 'a1 -> 'a1 tree -> __ -> __ -> __ -> __ -> 'a1 tree -> key -> 'a1 -> + 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> __ -> 'a2) -> ('a1 tree + -> key -> 'a1 -> 'a1 tree -> __ -> __ -> __ -> __ -> 'a1 tree -> key + -> 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a1 tree -> key + -> 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> 'a2) -> ('a1 tree -> key -> + 'a1 -> 'a1 tree -> __ -> __ -> __ -> __ -> 'a2) -> 'a1 tree -> key -> + 'a1 -> 'a1 tree -> 'a1 tree -> 'a1 coq_R_bal -> 'a2 + + type 'elt coq_R_add = + | R_add_0 of 'elt tree + | R_add_1 of 'elt tree * 'elt tree * key * 'elt * 'elt tree + * Z_as_Int.t * 'elt tree * 'elt coq_R_add + | R_add_2 of 'elt tree * 'elt tree * key * 'elt * 'elt tree * Z_as_Int.t + | R_add_3 of 'elt tree * 'elt tree * key * 'elt * 'elt tree + * Z_as_Int.t * 'elt tree * 'elt coq_R_add + + val coq_R_add_rect : + key -> 'a1 -> ('a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key + -> 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a1 tree -> 'a1 + coq_R_add -> 'a2 -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 -> + 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> 'a1 + tree -> key -> 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a1 + tree -> 'a1 coq_R_add -> 'a2 -> 'a2) -> 'a1 tree -> 'a1 tree -> 'a1 + coq_R_add -> 'a2 + + val coq_R_add_rec : + key -> 'a1 -> ('a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key + -> 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a1 tree -> 'a1 + coq_R_add -> 'a2 -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 -> + 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> 'a1 + tree -> key -> 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a1 + tree -> 'a1 coq_R_add -> 'a2 -> 'a2) -> 'a1 tree -> 'a1 tree -> 'a1 + coq_R_add -> 'a2 + + type 'elt coq_R_remove_min = + | R_remove_min_0 of 'elt tree * key * 'elt * 'elt tree + | R_remove_min_1 of 'elt tree * key * 'elt * 'elt tree * 'elt tree + * key * 'elt * 'elt tree * Z_as_Int.t * ('elt tree * (key * 'elt)) + * 'elt coq_R_remove_min * 'elt tree * (key * 'elt) + + val coq_R_remove_min_rect : + ('a1 tree -> key -> 'a1 -> 'a1 tree -> __ -> 'a2) -> ('a1 tree -> key + -> 'a1 -> 'a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> + Z_as_Int.t -> __ -> ('a1 tree * (key * 'a1)) -> 'a1 coq_R_remove_min + -> 'a2 -> 'a1 tree -> (key * 'a1) -> __ -> 'a2) -> 'a1 tree -> key -> + 'a1 -> 'a1 tree -> ('a1 tree * (key * 'a1)) -> 'a1 coq_R_remove_min + -> 'a2 + + val coq_R_remove_min_rec : + ('a1 tree -> key -> 'a1 -> 'a1 tree -> __ -> 'a2) -> ('a1 tree -> key + -> 'a1 -> 'a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> + Z_as_Int.t -> __ -> ('a1 tree * (key * 'a1)) -> 'a1 coq_R_remove_min + -> 'a2 -> 'a1 tree -> (key * 'a1) -> __ -> 'a2) -> 'a1 tree -> key -> + 'a1 -> 'a1 tree -> ('a1 tree * (key * 'a1)) -> 'a1 coq_R_remove_min + -> 'a2 + + type 'elt coq_R_merge = + | R_merge_0 of 'elt tree * 'elt tree + | R_merge_1 of 'elt tree * 'elt tree * 'elt tree * key * 'elt + * 'elt tree * Z_as_Int.t + | R_merge_2 of 'elt tree * 'elt tree * 'elt tree * key * 'elt + * 'elt tree * Z_as_Int.t * 'elt tree * key * 'elt * 'elt tree + * Z_as_Int.t * 'elt tree * (key * 'elt) * key * 'elt + + val coq_R_merge_rect : + ('a1 tree -> 'a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> 'a1 + tree -> key -> 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> 'a2) -> + ('a1 tree -> 'a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> + Z_as_Int.t -> __ -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> Z_as_Int.t + -> __ -> 'a1 tree -> (key * 'a1) -> __ -> key -> 'a1 -> __ -> 'a2) -> + 'a1 tree -> 'a1 tree -> 'a1 tree -> 'a1 coq_R_merge -> 'a2 + + val coq_R_merge_rec : + ('a1 tree -> 'a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> 'a1 + tree -> key -> 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> 'a2) -> + ('a1 tree -> 'a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> + Z_as_Int.t -> __ -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> Z_as_Int.t + -> __ -> 'a1 tree -> (key * 'a1) -> __ -> key -> 'a1 -> __ -> 'a2) -> + 'a1 tree -> 'a1 tree -> 'a1 tree -> 'a1 coq_R_merge -> 'a2 + + type 'elt coq_R_remove = + | R_remove_0 of 'elt tree + | R_remove_1 of 'elt tree * 'elt tree * key * 'elt * 'elt tree + * Z_as_Int.t * 'elt tree * 'elt coq_R_remove + | R_remove_2 of 'elt tree * 'elt tree * key * 'elt * 'elt tree + * Z_as_Int.t + | R_remove_3 of 'elt tree * 'elt tree * key * 'elt * 'elt tree + * Z_as_Int.t * 'elt tree * 'elt coq_R_remove + + val coq_R_remove_rect : + X.t -> ('a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 + -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a1 tree -> 'a1 + coq_R_remove -> 'a2 -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 -> + 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> 'a1 + tree -> key -> 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a1 + tree -> 'a1 coq_R_remove -> 'a2 -> 'a2) -> 'a1 tree -> 'a1 tree -> + 'a1 coq_R_remove -> 'a2 + + val coq_R_remove_rec : + X.t -> ('a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 + -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a1 tree -> 'a1 + coq_R_remove -> 'a2 -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 -> + 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> 'a1 + tree -> key -> 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a1 + tree -> 'a1 coq_R_remove -> 'a2 -> 'a2) -> 'a1 tree -> 'a1 tree -> + 'a1 coq_R_remove -> 'a2 + + type 'elt coq_R_concat = + | R_concat_0 of 'elt tree * 'elt tree + | R_concat_1 of 'elt tree * 'elt tree * 'elt tree * key * 'elt + * 'elt tree * Z_as_Int.t + | R_concat_2 of 'elt tree * 'elt tree * 'elt tree * key * 'elt + * 'elt tree * Z_as_Int.t * 'elt tree * key * 'elt * 'elt tree + * Z_as_Int.t * 'elt tree * (key * 'elt) + + val coq_R_concat_rect : + ('a1 tree -> 'a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> 'a1 + tree -> key -> 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> 'a2) -> + ('a1 tree -> 'a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> + Z_as_Int.t -> __ -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> Z_as_Int.t + -> __ -> 'a1 tree -> (key * 'a1) -> __ -> 'a2) -> 'a1 tree -> 'a1 + tree -> 'a1 tree -> 'a1 coq_R_concat -> 'a2 + + val coq_R_concat_rec : + ('a1 tree -> 'a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> 'a1 + tree -> key -> 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> 'a2) -> + ('a1 tree -> 'a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> + Z_as_Int.t -> __ -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> Z_as_Int.t + -> __ -> 'a1 tree -> (key * 'a1) -> __ -> 'a2) -> 'a1 tree -> 'a1 + tree -> 'a1 tree -> 'a1 coq_R_concat -> 'a2 + + type 'elt coq_R_split = + | R_split_0 of 'elt tree + | R_split_1 of 'elt tree * 'elt tree * key * 'elt * 'elt tree + * Z_as_Int.t * 'elt triple * 'elt coq_R_split * 'elt tree + * 'elt option * 'elt tree + | R_split_2 of 'elt tree * 'elt tree * key * 'elt * 'elt tree + * Z_as_Int.t + | R_split_3 of 'elt tree * 'elt tree * key * 'elt * 'elt tree + * Z_as_Int.t * 'elt triple * 'elt coq_R_split * 'elt tree + * 'elt option * 'elt tree + + val coq_R_split_rect : + X.t -> ('a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 + -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a1 triple -> 'a1 + coq_R_split -> 'a2 -> 'a1 tree -> 'a1 option -> 'a1 tree -> __ -> + 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> Z_as_Int.t + -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 -> + 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a1 triple -> 'a1 + coq_R_split -> 'a2 -> 'a1 tree -> 'a1 option -> 'a1 tree -> __ -> + 'a2) -> 'a1 tree -> 'a1 triple -> 'a1 coq_R_split -> 'a2 + + val coq_R_split_rec : + X.t -> ('a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 + -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a1 triple -> 'a1 + coq_R_split -> 'a2 -> 'a1 tree -> 'a1 option -> 'a1 tree -> __ -> + 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> Z_as_Int.t + -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 -> + 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a1 triple -> 'a1 + coq_R_split -> 'a2 -> 'a1 tree -> 'a1 option -> 'a1 tree -> __ -> + 'a2) -> 'a1 tree -> 'a1 triple -> 'a1 coq_R_split -> 'a2 + + type ('elt, 'x) coq_R_map_option = + | R_map_option_0 of 'elt tree + | R_map_option_1 of 'elt tree * 'elt tree * key * 'elt * 'elt tree + * Z_as_Int.t * 'x * 'x tree * ('elt, 'x) coq_R_map_option * + 'x tree * ('elt, 'x) coq_R_map_option + | R_map_option_2 of 'elt tree * 'elt tree * key * 'elt * 'elt tree + * Z_as_Int.t * 'x tree * ('elt, 'x) coq_R_map_option * 'x tree + * ('elt, 'x) coq_R_map_option + + val coq_R_map_option_rect : + (key -> 'a1 -> 'a2 option) -> ('a1 tree -> __ -> 'a3) -> ('a1 tree -> + 'a1 tree -> key -> 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> 'a2 -> __ + -> 'a2 tree -> ('a1, 'a2) coq_R_map_option -> 'a3 -> 'a2 tree -> + ('a1, 'a2) coq_R_map_option -> 'a3 -> 'a3) -> ('a1 tree -> 'a1 tree + -> key -> 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> 'a2 tree -> + ('a1, 'a2) coq_R_map_option -> 'a3 -> 'a2 tree -> ('a1, 'a2) + coq_R_map_option -> 'a3 -> 'a3) -> 'a1 tree -> 'a2 tree -> ('a1, 'a2) + coq_R_map_option -> 'a3 + + val coq_R_map_option_rec : + (key -> 'a1 -> 'a2 option) -> ('a1 tree -> __ -> 'a3) -> ('a1 tree -> + 'a1 tree -> key -> 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> 'a2 -> __ + -> 'a2 tree -> ('a1, 'a2) coq_R_map_option -> 'a3 -> 'a2 tree -> + ('a1, 'a2) coq_R_map_option -> 'a3 -> 'a3) -> ('a1 tree -> 'a1 tree + -> key -> 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> 'a2 tree -> + ('a1, 'a2) coq_R_map_option -> 'a3 -> 'a2 tree -> ('a1, 'a2) + coq_R_map_option -> 'a3 -> 'a3) -> 'a1 tree -> 'a2 tree -> ('a1, 'a2) + coq_R_map_option -> 'a3 + + type ('elt, 'x0, 'x) coq_R_map2_opt = + | R_map2_opt_0 of 'elt tree * 'x0 tree + | R_map2_opt_1 of 'elt tree * 'x0 tree * 'elt tree * key * 'elt + * 'elt tree * Z_as_Int.t + | R_map2_opt_2 of 'elt tree * 'x0 tree * 'elt tree * key * 'elt + * 'elt tree * Z_as_Int.t * 'x0 tree * key * 'x0 * 'x0 tree + * Z_as_Int.t * 'x0 tree * 'x0 option * 'x0 tree * 'x * 'x tree + * ('elt, 'x0, 'x) coq_R_map2_opt * 'x tree + * ('elt, 'x0, 'x) coq_R_map2_opt + | R_map2_opt_3 of 'elt tree * 'x0 tree * 'elt tree * key * 'elt + * 'elt tree * Z_as_Int.t * 'x0 tree * key * 'x0 * 'x0 tree + * Z_as_Int.t * 'x0 tree * 'x0 option * 'x0 tree * 'x tree + * ('elt, 'x0, 'x) coq_R_map2_opt * 'x tree + * ('elt, 'x0, 'x) coq_R_map2_opt + + val coq_R_map2_opt_rect : + (key -> 'a1 -> 'a2 option -> 'a3 option) -> ('a1 tree -> 'a3 tree) -> + ('a2 tree -> 'a3 tree) -> ('a1 tree -> 'a2 tree -> __ -> 'a4) -> ('a1 + tree -> 'a2 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> Z_as_Int.t + -> __ -> __ -> 'a4) -> ('a1 tree -> 'a2 tree -> 'a1 tree -> key -> + 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> 'a2 tree -> key -> 'a2 -> 'a2 + tree -> Z_as_Int.t -> __ -> 'a2 tree -> 'a2 option -> 'a2 tree -> __ + -> 'a3 -> __ -> 'a3 tree -> ('a1, 'a2, 'a3) coq_R_map2_opt -> 'a4 -> + 'a3 tree -> ('a1, 'a2, 'a3) coq_R_map2_opt -> 'a4 -> 'a4) -> ('a1 + tree -> 'a2 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> Z_as_Int.t + -> __ -> 'a2 tree -> key -> 'a2 -> 'a2 tree -> Z_as_Int.t -> __ -> + 'a2 tree -> 'a2 option -> 'a2 tree -> __ -> __ -> 'a3 tree -> ('a1, + 'a2, 'a3) coq_R_map2_opt -> 'a4 -> 'a3 tree -> ('a1, 'a2, 'a3) + coq_R_map2_opt -> 'a4 -> 'a4) -> 'a1 tree -> 'a2 tree -> 'a3 tree -> + ('a1, 'a2, 'a3) coq_R_map2_opt -> 'a4 + + val coq_R_map2_opt_rec : + (key -> 'a1 -> 'a2 option -> 'a3 option) -> ('a1 tree -> 'a3 tree) -> + ('a2 tree -> 'a3 tree) -> ('a1 tree -> 'a2 tree -> __ -> 'a4) -> ('a1 + tree -> 'a2 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> Z_as_Int.t + -> __ -> __ -> 'a4) -> ('a1 tree -> 'a2 tree -> 'a1 tree -> key -> + 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> 'a2 tree -> key -> 'a2 -> 'a2 + tree -> Z_as_Int.t -> __ -> 'a2 tree -> 'a2 option -> 'a2 tree -> __ + -> 'a3 -> __ -> 'a3 tree -> ('a1, 'a2, 'a3) coq_R_map2_opt -> 'a4 -> + 'a3 tree -> ('a1, 'a2, 'a3) coq_R_map2_opt -> 'a4 -> 'a4) -> ('a1 + tree -> 'a2 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> Z_as_Int.t + -> __ -> 'a2 tree -> key -> 'a2 -> 'a2 tree -> Z_as_Int.t -> __ -> + 'a2 tree -> 'a2 option -> 'a2 tree -> __ -> __ -> 'a3 tree -> ('a1, + 'a2, 'a3) coq_R_map2_opt -> 'a4 -> 'a3 tree -> ('a1, 'a2, 'a3) + coq_R_map2_opt -> 'a4 -> 'a4) -> 'a1 tree -> 'a2 tree -> 'a3 tree -> + ('a1, 'a2, 'a3) coq_R_map2_opt -> 'a4 + + val fold' : (key -> 'a1 -> 'a2 -> 'a2) -> 'a1 tree -> 'a2 -> 'a2 + + val flatten_e : 'a1 enumeration -> (key * 'a1) list + end + end + + type 'elt bst = + 'elt Raw.tree + (* singleton inductive, whose constructor was Bst *) + + val this : 'a1 bst -> 'a1 Raw.tree + + type 'elt t = 'elt bst + + type key = E.t + + val empty : 'a1 t + + val is_empty : 'a1 t -> bool + + val add : key -> 'a1 -> 'a1 t -> 'a1 t + + val remove : key -> 'a1 t -> 'a1 t + + val mem : key -> 'a1 t -> bool + + val find : key -> 'a1 t -> 'a1 option + + val map : ('a1 -> 'a2) -> 'a1 t -> 'a2 t + + val mapi : (key -> 'a1 -> 'a2) -> 'a1 t -> 'a2 t + + val map2 : + ('a1 option -> 'a2 option -> 'a3 option) -> 'a1 t -> 'a2 t -> 'a3 t + + val elements : 'a1 t -> (key * 'a1) list + + val cardinal : 'a1 t -> nat + + val fold : (key -> 'a1 -> 'a2 -> 'a2) -> 'a1 t -> 'a2 -> 'a2 + + val equal : ('a1 -> 'a1 -> bool) -> 'a1 t -> 'a1 t -> bool + end + +module IntOrderedType : + sig + type t = Uint63.t + + val compare : Uint63.t -> Uint63.t -> Uint63.t compare1 + + val eq_dec : Uint63.t -> Uint63.t -> sumbool + end + +module Map : + sig + module E : + sig + type t = Uint63.t + + val compare : Uint63.t -> Uint63.t -> Uint63.t compare1 + + val eq_dec : Uint63.t -> Uint63.t -> sumbool + end + + module Raw : + sig + type key = Uint63.t + + type 'elt tree = + | Leaf + | Node of 'elt tree * key * 'elt * 'elt tree * Z_as_Int.t + + val tree_rect : + 'a2 -> ('a1 tree -> 'a2 -> key -> 'a1 -> 'a1 tree -> 'a2 -> Z_as_Int.t + -> 'a2) -> 'a1 tree -> 'a2 + + val tree_rec : + 'a2 -> ('a1 tree -> 'a2 -> key -> 'a1 -> 'a1 tree -> 'a2 -> Z_as_Int.t + -> 'a2) -> 'a1 tree -> 'a2 + + val height : 'a1 tree -> Z_as_Int.t + + val cardinal : 'a1 tree -> nat + + val empty : 'a1 tree + + val is_empty : 'a1 tree -> bool + + val mem : Uint63.t -> 'a1 tree -> bool + + val find : Uint63.t -> 'a1 tree -> 'a1 option + + val create : 'a1 tree -> key -> 'a1 -> 'a1 tree -> 'a1 tree + + val assert_false : 'a1 tree -> key -> 'a1 -> 'a1 tree -> 'a1 tree + + val bal : 'a1 tree -> key -> 'a1 -> 'a1 tree -> 'a1 tree + + val add : key -> 'a1 -> 'a1 tree -> 'a1 tree + + val remove_min : + 'a1 tree -> key -> 'a1 -> 'a1 tree -> 'a1 tree * (key * 'a1) + + val merge : 'a1 tree -> 'a1 tree -> 'a1 tree + + val remove : Uint63.t -> 'a1 tree -> 'a1 tree + + val join : 'a1 tree -> key -> 'a1 -> 'a1 tree -> 'a1 tree + + type 'elt triple = { t_left : 'elt tree; t_opt : 'elt option; + t_right : 'elt tree } + + val t_left : 'a1 triple -> 'a1 tree + + val t_opt : 'a1 triple -> 'a1 option + + val t_right : 'a1 triple -> 'a1 tree + + val split : Uint63.t -> 'a1 tree -> 'a1 triple + + val concat : 'a1 tree -> 'a1 tree -> 'a1 tree + + val elements_aux : (key * 'a1) list -> 'a1 tree -> (key * 'a1) list + + val elements : 'a1 tree -> (key * 'a1) list + + val fold : (key -> 'a1 -> 'a2 -> 'a2) -> 'a1 tree -> 'a2 -> 'a2 + + type 'elt enumeration = + | End + | More of key * 'elt * 'elt tree * 'elt enumeration + + val enumeration_rect : + 'a2 -> (key -> 'a1 -> 'a1 tree -> 'a1 enumeration -> 'a2 -> 'a2) -> 'a1 + enumeration -> 'a2 + + val enumeration_rec : + 'a2 -> (key -> 'a1 -> 'a1 tree -> 'a1 enumeration -> 'a2 -> 'a2) -> 'a1 + enumeration -> 'a2 + + val cons : 'a1 tree -> 'a1 enumeration -> 'a1 enumeration + + val equal_more : + ('a1 -> 'a1 -> bool) -> Uint63.t -> 'a1 -> ('a1 enumeration -> bool) -> + 'a1 enumeration -> bool + + val equal_cont : + ('a1 -> 'a1 -> bool) -> 'a1 tree -> ('a1 enumeration -> bool) -> 'a1 + enumeration -> bool + + val equal_end : 'a1 enumeration -> bool + + val equal : ('a1 -> 'a1 -> bool) -> 'a1 tree -> 'a1 tree -> bool + + val map : ('a1 -> 'a2) -> 'a1 tree -> 'a2 tree + + val mapi : (key -> 'a1 -> 'a2) -> 'a1 tree -> 'a2 tree + + val map_option : (key -> 'a1 -> 'a2 option) -> 'a1 tree -> 'a2 tree + + val map2_opt : + (key -> 'a1 -> 'a2 option -> 'a3 option) -> ('a1 tree -> 'a3 tree) -> + ('a2 tree -> 'a3 tree) -> 'a1 tree -> 'a2 tree -> 'a3 tree + + val map2 : + ('a1 option -> 'a2 option -> 'a3 option) -> 'a1 tree -> 'a2 tree -> 'a3 + tree + + module Proofs : + sig + module MX : + sig + module TO : + sig + type t = Uint63.t + end + + module IsTO : + sig + end + + module OrderTac : + sig + end + + val eq_dec : Uint63.t -> Uint63.t -> sumbool + + val lt_dec : Uint63.t -> Uint63.t -> sumbool + + val eqb : Uint63.t -> Uint63.t -> bool + end + + module PX : + sig + module MO : + sig + module TO : + sig + type t = Uint63.t + end + + module IsTO : + sig + end + + module OrderTac : + sig + end + + val eq_dec : Uint63.t -> Uint63.t -> sumbool + + val lt_dec : Uint63.t -> Uint63.t -> sumbool + + val eqb : Uint63.t -> Uint63.t -> bool + end + end + + module L : + sig + module MX : + sig + module TO : + sig + type t = Uint63.t + end + + module IsTO : + sig + end + + module OrderTac : + sig + end + + val eq_dec : Uint63.t -> Uint63.t -> sumbool + + val lt_dec : Uint63.t -> Uint63.t -> sumbool + + val eqb : Uint63.t -> Uint63.t -> bool + end + + module PX : + sig + module MO : + sig + module TO : + sig + type t = Uint63.t + end + + module IsTO : + sig + end + + module OrderTac : + sig + end + + val eq_dec : Uint63.t -> Uint63.t -> sumbool + + val lt_dec : Uint63.t -> Uint63.t -> sumbool + + val eqb : Uint63.t -> Uint63.t -> bool + end + end + + type key = Uint63.t + + type 'elt t = (Uint63.t * 'elt) list + + val empty : 'a1 t + + val is_empty : 'a1 t -> bool + + val mem : key -> 'a1 t -> bool + + type 'elt coq_R_mem = + | R_mem_0 of 'elt t + | R_mem_1 of 'elt t * Uint63.t * 'elt * (Uint63.t * 'elt) list + | R_mem_2 of 'elt t * Uint63.t * 'elt * (Uint63.t * 'elt) list + | R_mem_3 of 'elt t * Uint63.t * 'elt * (Uint63.t * 'elt) list * + bool * 'elt coq_R_mem + + val coq_R_mem_rect : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> Uint63.t -> 'a1 -> + (Uint63.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> + Uint63.t -> 'a1 -> (Uint63.t * 'a1) list -> __ -> __ -> __ -> 'a2) + -> ('a1 t -> Uint63.t -> 'a1 -> (Uint63.t * 'a1) list -> __ -> __ + -> __ -> bool -> 'a1 coq_R_mem -> 'a2 -> 'a2) -> 'a1 t -> bool -> + 'a1 coq_R_mem -> 'a2 + + val coq_R_mem_rec : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> Uint63.t -> 'a1 -> + (Uint63.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> + Uint63.t -> 'a1 -> (Uint63.t * 'a1) list -> __ -> __ -> __ -> 'a2) + -> ('a1 t -> Uint63.t -> 'a1 -> (Uint63.t * 'a1) list -> __ -> __ + -> __ -> bool -> 'a1 coq_R_mem -> 'a2 -> 'a2) -> 'a1 t -> bool -> + 'a1 coq_R_mem -> 'a2 + + val mem_rect : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> Uint63.t -> 'a1 -> + (Uint63.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> + Uint63.t -> 'a1 -> (Uint63.t * 'a1) list -> __ -> __ -> __ -> 'a2) + -> ('a1 t -> Uint63.t -> 'a1 -> (Uint63.t * 'a1) list -> __ -> __ + -> __ -> 'a2 -> 'a2) -> 'a1 t -> 'a2 + + val mem_rec : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> Uint63.t -> 'a1 -> + (Uint63.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> + Uint63.t -> 'a1 -> (Uint63.t * 'a1) list -> __ -> __ -> __ -> 'a2) + -> ('a1 t -> Uint63.t -> 'a1 -> (Uint63.t * 'a1) list -> __ -> __ + -> __ -> 'a2 -> 'a2) -> 'a1 t -> 'a2 + + val coq_R_mem_correct : key -> 'a1 t -> bool -> 'a1 coq_R_mem + + val find : key -> 'a1 t -> 'a1 option + + type 'elt coq_R_find = + | R_find_0 of 'elt t + | R_find_1 of 'elt t * Uint63.t * 'elt * (Uint63.t * 'elt) list + | R_find_2 of 'elt t * Uint63.t * 'elt * (Uint63.t * 'elt) list + | R_find_3 of 'elt t * Uint63.t * 'elt * (Uint63.t * 'elt) list + * 'elt option * 'elt coq_R_find + + val coq_R_find_rect : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> Uint63.t -> 'a1 -> + (Uint63.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> + Uint63.t -> 'a1 -> (Uint63.t * 'a1) list -> __ -> __ -> __ -> 'a2) + -> ('a1 t -> Uint63.t -> 'a1 -> (Uint63.t * 'a1) list -> __ -> __ + -> __ -> 'a1 option -> 'a1 coq_R_find -> 'a2 -> 'a2) -> 'a1 t -> + 'a1 option -> 'a1 coq_R_find -> 'a2 + + val coq_R_find_rec : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> Uint63.t -> 'a1 -> + (Uint63.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> + Uint63.t -> 'a1 -> (Uint63.t * 'a1) list -> __ -> __ -> __ -> 'a2) + -> ('a1 t -> Uint63.t -> 'a1 -> (Uint63.t * 'a1) list -> __ -> __ + -> __ -> 'a1 option -> 'a1 coq_R_find -> 'a2 -> 'a2) -> 'a1 t -> + 'a1 option -> 'a1 coq_R_find -> 'a2 + + val find_rect : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> Uint63.t -> 'a1 -> + (Uint63.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> + Uint63.t -> 'a1 -> (Uint63.t * 'a1) list -> __ -> __ -> __ -> 'a2) + -> ('a1 t -> Uint63.t -> 'a1 -> (Uint63.t * 'a1) list -> __ -> __ + -> __ -> 'a2 -> 'a2) -> 'a1 t -> 'a2 + + val find_rec : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> Uint63.t -> 'a1 -> + (Uint63.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> + Uint63.t -> 'a1 -> (Uint63.t * 'a1) list -> __ -> __ -> __ -> 'a2) + -> ('a1 t -> Uint63.t -> 'a1 -> (Uint63.t * 'a1) list -> __ -> __ + -> __ -> 'a2 -> 'a2) -> 'a1 t -> 'a2 + + val coq_R_find_correct : key -> 'a1 t -> 'a1 option -> 'a1 coq_R_find + + val add : key -> 'a1 -> 'a1 t -> 'a1 t + + type 'elt coq_R_add = + | R_add_0 of 'elt t + | R_add_1 of 'elt t * Uint63.t * 'elt * (Uint63.t * 'elt) list + | R_add_2 of 'elt t * Uint63.t * 'elt * (Uint63.t * 'elt) list + | R_add_3 of 'elt t * Uint63.t * 'elt * (Uint63.t * 'elt) list + * 'elt t * 'elt coq_R_add + + val coq_R_add_rect : + key -> 'a1 -> ('a1 t -> __ -> 'a2) -> ('a1 t -> Uint63.t -> 'a1 -> + (Uint63.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> + Uint63.t -> 'a1 -> (Uint63.t * 'a1) list -> __ -> __ -> __ -> 'a2) + -> ('a1 t -> Uint63.t -> 'a1 -> (Uint63.t * 'a1) list -> __ -> __ + -> __ -> 'a1 t -> 'a1 coq_R_add -> 'a2 -> 'a2) -> 'a1 t -> 'a1 t -> + 'a1 coq_R_add -> 'a2 + + val coq_R_add_rec : + key -> 'a1 -> ('a1 t -> __ -> 'a2) -> ('a1 t -> Uint63.t -> 'a1 -> + (Uint63.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> + Uint63.t -> 'a1 -> (Uint63.t * 'a1) list -> __ -> __ -> __ -> 'a2) + -> ('a1 t -> Uint63.t -> 'a1 -> (Uint63.t * 'a1) list -> __ -> __ + -> __ -> 'a1 t -> 'a1 coq_R_add -> 'a2 -> 'a2) -> 'a1 t -> 'a1 t -> + 'a1 coq_R_add -> 'a2 + + val add_rect : + key -> 'a1 -> ('a1 t -> __ -> 'a2) -> ('a1 t -> Uint63.t -> 'a1 -> + (Uint63.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> + Uint63.t -> 'a1 -> (Uint63.t * 'a1) list -> __ -> __ -> __ -> 'a2) + -> ('a1 t -> Uint63.t -> 'a1 -> (Uint63.t * 'a1) list -> __ -> __ + -> __ -> 'a2 -> 'a2) -> 'a1 t -> 'a2 + + val add_rec : + key -> 'a1 -> ('a1 t -> __ -> 'a2) -> ('a1 t -> Uint63.t -> 'a1 -> + (Uint63.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> + Uint63.t -> 'a1 -> (Uint63.t * 'a1) list -> __ -> __ -> __ -> 'a2) + -> ('a1 t -> Uint63.t -> 'a1 -> (Uint63.t * 'a1) list -> __ -> __ + -> __ -> 'a2 -> 'a2) -> 'a1 t -> 'a2 + + val coq_R_add_correct : key -> 'a1 -> 'a1 t -> 'a1 t -> 'a1 coq_R_add + + val remove : key -> 'a1 t -> 'a1 t + + type 'elt coq_R_remove = + | R_remove_0 of 'elt t + | R_remove_1 of 'elt t * Uint63.t * 'elt * (Uint63.t * 'elt) list + | R_remove_2 of 'elt t * Uint63.t * 'elt * (Uint63.t * 'elt) list + | R_remove_3 of 'elt t * Uint63.t * 'elt * (Uint63.t * 'elt) list + * 'elt t * 'elt coq_R_remove + + val coq_R_remove_rect : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> Uint63.t -> 'a1 -> + (Uint63.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> + Uint63.t -> 'a1 -> (Uint63.t * 'a1) list -> __ -> __ -> __ -> 'a2) + -> ('a1 t -> Uint63.t -> 'a1 -> (Uint63.t * 'a1) list -> __ -> __ + -> __ -> 'a1 t -> 'a1 coq_R_remove -> 'a2 -> 'a2) -> 'a1 t -> 'a1 t + -> 'a1 coq_R_remove -> 'a2 + + val coq_R_remove_rec : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> Uint63.t -> 'a1 -> + (Uint63.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> + Uint63.t -> 'a1 -> (Uint63.t * 'a1) list -> __ -> __ -> __ -> 'a2) + -> ('a1 t -> Uint63.t -> 'a1 -> (Uint63.t * 'a1) list -> __ -> __ + -> __ -> 'a1 t -> 'a1 coq_R_remove -> 'a2 -> 'a2) -> 'a1 t -> 'a1 t + -> 'a1 coq_R_remove -> 'a2 + + val remove_rect : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> Uint63.t -> 'a1 -> + (Uint63.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> + Uint63.t -> 'a1 -> (Uint63.t * 'a1) list -> __ -> __ -> __ -> 'a2) + -> ('a1 t -> Uint63.t -> 'a1 -> (Uint63.t * 'a1) list -> __ -> __ + -> __ -> 'a2 -> 'a2) -> 'a1 t -> 'a2 + + val remove_rec : + key -> ('a1 t -> __ -> 'a2) -> ('a1 t -> Uint63.t -> 'a1 -> + (Uint63.t * 'a1) list -> __ -> __ -> __ -> 'a2) -> ('a1 t -> + Uint63.t -> 'a1 -> (Uint63.t * 'a1) list -> __ -> __ -> __ -> 'a2) + -> ('a1 t -> Uint63.t -> 'a1 -> (Uint63.t * 'a1) list -> __ -> __ + -> __ -> 'a2 -> 'a2) -> 'a1 t -> 'a2 + + val coq_R_remove_correct : key -> 'a1 t -> 'a1 t -> 'a1 coq_R_remove + + val elements : 'a1 t -> 'a1 t + + val fold : (key -> 'a1 -> 'a2 -> 'a2) -> 'a1 t -> 'a2 -> 'a2 + + type ('elt, 'a) coq_R_fold = + | R_fold_0 of 'elt t * 'a + | R_fold_1 of 'elt t * 'a * Uint63.t * 'elt * (Uint63.t * 'elt) list + * 'a * ('elt, 'a) coq_R_fold + + val coq_R_fold_rect : + (key -> 'a1 -> 'a2 -> 'a2) -> ('a1 t -> 'a2 -> __ -> 'a3) -> ('a1 t + -> 'a2 -> Uint63.t -> 'a1 -> (Uint63.t * 'a1) list -> __ -> 'a2 -> + ('a1, 'a2) coq_R_fold -> 'a3 -> 'a3) -> 'a1 t -> 'a2 -> 'a2 -> + ('a1, 'a2) coq_R_fold -> 'a3 + + val coq_R_fold_rec : + (key -> 'a1 -> 'a2 -> 'a2) -> ('a1 t -> 'a2 -> __ -> 'a3) -> ('a1 t + -> 'a2 -> Uint63.t -> 'a1 -> (Uint63.t * 'a1) list -> __ -> 'a2 -> + ('a1, 'a2) coq_R_fold -> 'a3 -> 'a3) -> 'a1 t -> 'a2 -> 'a2 -> + ('a1, 'a2) coq_R_fold -> 'a3 + + val fold_rect : + (key -> 'a1 -> 'a2 -> 'a2) -> ('a1 t -> 'a2 -> __ -> 'a3) -> ('a1 t + -> 'a2 -> Uint63.t -> 'a1 -> (Uint63.t * 'a1) list -> __ -> 'a3 -> + 'a3) -> 'a1 t -> 'a2 -> 'a3 + + val fold_rec : + (key -> 'a1 -> 'a2 -> 'a2) -> ('a1 t -> 'a2 -> __ -> 'a3) -> ('a1 t + -> 'a2 -> Uint63.t -> 'a1 -> (Uint63.t * 'a1) list -> __ -> 'a3 -> + 'a3) -> 'a1 t -> 'a2 -> 'a3 + + val coq_R_fold_correct : + (key -> 'a1 -> 'a2 -> 'a2) -> 'a1 t -> 'a2 -> 'a2 -> ('a1, 'a2) + coq_R_fold + + val equal : ('a1 -> 'a1 -> bool) -> 'a1 t -> 'a1 t -> bool + + type 'elt coq_R_equal = + | R_equal_0 of 'elt t * 'elt t + | R_equal_1 of 'elt t * 'elt t * Uint63.t * 'elt + * (Uint63.t * 'elt) list * Uint63.t * 'elt + * (Uint63.t * 'elt) list * bool * 'elt coq_R_equal + | R_equal_2 of 'elt t * 'elt t * Uint63.t * 'elt + * (Uint63.t * 'elt) list * Uint63.t * 'elt + * (Uint63.t * 'elt) list * Uint63.t compare1 + | R_equal_3 of 'elt t * 'elt t * 'elt t * 'elt t + + val coq_R_equal_rect : + ('a1 -> 'a1 -> bool) -> ('a1 t -> 'a1 t -> __ -> __ -> 'a2) -> ('a1 + t -> 'a1 t -> Uint63.t -> 'a1 -> (Uint63.t * 'a1) list -> __ -> + Uint63.t -> 'a1 -> (Uint63.t * 'a1) list -> __ -> __ -> __ -> bool + -> 'a1 coq_R_equal -> 'a2 -> 'a2) -> ('a1 t -> 'a1 t -> Uint63.t -> + 'a1 -> (Uint63.t * 'a1) list -> __ -> Uint63.t -> 'a1 -> + (Uint63.t * 'a1) list -> __ -> Uint63.t compare1 -> __ -> __ -> + 'a2) -> ('a1 t -> 'a1 t -> 'a1 t -> __ -> 'a1 t -> __ -> __ -> 'a2) + -> 'a1 t -> 'a1 t -> bool -> 'a1 coq_R_equal -> 'a2 + + val coq_R_equal_rec : + ('a1 -> 'a1 -> bool) -> ('a1 t -> 'a1 t -> __ -> __ -> 'a2) -> ('a1 + t -> 'a1 t -> Uint63.t -> 'a1 -> (Uint63.t * 'a1) list -> __ -> + Uint63.t -> 'a1 -> (Uint63.t * 'a1) list -> __ -> __ -> __ -> bool + -> 'a1 coq_R_equal -> 'a2 -> 'a2) -> ('a1 t -> 'a1 t -> Uint63.t -> + 'a1 -> (Uint63.t * 'a1) list -> __ -> Uint63.t -> 'a1 -> + (Uint63.t * 'a1) list -> __ -> Uint63.t compare1 -> __ -> __ -> + 'a2) -> ('a1 t -> 'a1 t -> 'a1 t -> __ -> 'a1 t -> __ -> __ -> 'a2) + -> 'a1 t -> 'a1 t -> bool -> 'a1 coq_R_equal -> 'a2 + + val equal_rect : + ('a1 -> 'a1 -> bool) -> ('a1 t -> 'a1 t -> __ -> __ -> 'a2) -> ('a1 + t -> 'a1 t -> Uint63.t -> 'a1 -> (Uint63.t * 'a1) list -> __ -> + Uint63.t -> 'a1 -> (Uint63.t * 'a1) list -> __ -> __ -> __ -> 'a2 + -> 'a2) -> ('a1 t -> 'a1 t -> Uint63.t -> 'a1 -> (Uint63.t * 'a1) + list -> __ -> Uint63.t -> 'a1 -> (Uint63.t * 'a1) list -> __ -> + Uint63.t compare1 -> __ -> __ -> 'a2) -> ('a1 t -> 'a1 t -> 'a1 t + -> __ -> 'a1 t -> __ -> __ -> 'a2) -> 'a1 t -> 'a1 t -> 'a2 + + val equal_rec : + ('a1 -> 'a1 -> bool) -> ('a1 t -> 'a1 t -> __ -> __ -> 'a2) -> ('a1 + t -> 'a1 t -> Uint63.t -> 'a1 -> (Uint63.t * 'a1) list -> __ -> + Uint63.t -> 'a1 -> (Uint63.t * 'a1) list -> __ -> __ -> __ -> 'a2 + -> 'a2) -> ('a1 t -> 'a1 t -> Uint63.t -> 'a1 -> (Uint63.t * 'a1) + list -> __ -> Uint63.t -> 'a1 -> (Uint63.t * 'a1) list -> __ -> + Uint63.t compare1 -> __ -> __ -> 'a2) -> ('a1 t -> 'a1 t -> 'a1 t + -> __ -> 'a1 t -> __ -> __ -> 'a2) -> 'a1 t -> 'a1 t -> 'a2 + + val coq_R_equal_correct : + ('a1 -> 'a1 -> bool) -> 'a1 t -> 'a1 t -> bool -> 'a1 coq_R_equal + + val map : ('a1 -> 'a2) -> 'a1 t -> 'a2 t + + val mapi : (key -> 'a1 -> 'a2) -> 'a1 t -> 'a2 t + + val option_cons : + key -> 'a1 option -> (key * 'a1) list -> (key * 'a1) list + + val map2_l : + ('a1 option -> 'a2 option -> 'a3 option) -> 'a1 t -> 'a3 t + + val map2_r : + ('a1 option -> 'a2 option -> 'a3 option) -> 'a2 t -> 'a3 t + + val map2 : + ('a1 option -> 'a2 option -> 'a3 option) -> 'a1 t -> 'a2 t -> 'a3 t + + val combine : 'a1 t -> 'a2 t -> ('a1 option * 'a2 option) t + + val fold_right_pair : + ('a1 -> 'a2 -> 'a3 -> 'a3) -> ('a1 * 'a2) list -> 'a3 -> 'a3 + + val map2_alt : + ('a1 option -> 'a2 option -> 'a3 option) -> 'a1 t -> 'a2 t -> + (key * 'a3) list + + val at_least_one : + 'a1 option -> 'a2 option -> ('a1 option * 'a2 option) option + + val at_least_one_then_f : + ('a1 option -> 'a2 option -> 'a3 option) -> 'a1 option -> 'a2 + option -> 'a3 option + end + + type 'elt coq_R_mem = + | R_mem_0 of 'elt tree + | R_mem_1 of 'elt tree * 'elt tree * key * 'elt * 'elt tree + * Z_as_Int.t * bool * 'elt coq_R_mem + | R_mem_2 of 'elt tree * 'elt tree * key * 'elt * 'elt tree * Z_as_Int.t + | R_mem_3 of 'elt tree * 'elt tree * key * 'elt * 'elt tree + * Z_as_Int.t * bool * 'elt coq_R_mem + + val coq_R_mem_rect : + Uint63.t -> ('a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key + -> 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> bool -> 'a1 + coq_R_mem -> 'a2 -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 -> + 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> 'a1 + tree -> key -> 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> + bool -> 'a1 coq_R_mem -> 'a2 -> 'a2) -> 'a1 tree -> bool -> 'a1 + coq_R_mem -> 'a2 + + val coq_R_mem_rec : + Uint63.t -> ('a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key + -> 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> bool -> 'a1 + coq_R_mem -> 'a2 -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 -> + 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> 'a1 + tree -> key -> 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> + bool -> 'a1 coq_R_mem -> 'a2 -> 'a2) -> 'a1 tree -> bool -> 'a1 + coq_R_mem -> 'a2 + + type 'elt coq_R_find = + | R_find_0 of 'elt tree + | R_find_1 of 'elt tree * 'elt tree * key * 'elt * 'elt tree + * Z_as_Int.t * 'elt option * 'elt coq_R_find + | R_find_2 of 'elt tree * 'elt tree * key * 'elt * 'elt tree + * Z_as_Int.t + | R_find_3 of 'elt tree * 'elt tree * key * 'elt * 'elt tree + * Z_as_Int.t * 'elt option * 'elt coq_R_find + + val coq_R_find_rect : + Uint63.t -> ('a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key + -> 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a1 option -> + 'a1 coq_R_find -> 'a2 -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 + -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> + 'a1 tree -> key -> 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> + 'a1 option -> 'a1 coq_R_find -> 'a2 -> 'a2) -> 'a1 tree -> 'a1 option + -> 'a1 coq_R_find -> 'a2 + + val coq_R_find_rec : + Uint63.t -> ('a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key + -> 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a1 option -> + 'a1 coq_R_find -> 'a2 -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 + -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> + 'a1 tree -> key -> 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> + 'a1 option -> 'a1 coq_R_find -> 'a2 -> 'a2) -> 'a1 tree -> 'a1 option + -> 'a1 coq_R_find -> 'a2 + + type 'elt coq_R_bal = + | R_bal_0 of 'elt tree * key * 'elt * 'elt tree + | R_bal_1 of 'elt tree * key * 'elt * 'elt tree * 'elt tree * key + * 'elt * 'elt tree * Z_as_Int.t + | R_bal_2 of 'elt tree * key * 'elt * 'elt tree * 'elt tree * key + * 'elt * 'elt tree * Z_as_Int.t + | R_bal_3 of 'elt tree * key * 'elt * 'elt tree * 'elt tree * key + * 'elt * 'elt tree * Z_as_Int.t * 'elt tree * key * 'elt * 'elt tree + * Z_as_Int.t + | R_bal_4 of 'elt tree * key * 'elt * 'elt tree + | R_bal_5 of 'elt tree * key * 'elt * 'elt tree * 'elt tree * key + * 'elt * 'elt tree * Z_as_Int.t + | R_bal_6 of 'elt tree * key * 'elt * 'elt tree * 'elt tree * key + * 'elt * 'elt tree * Z_as_Int.t + | R_bal_7 of 'elt tree * key * 'elt * 'elt tree * 'elt tree * key + * 'elt * 'elt tree * Z_as_Int.t * 'elt tree * key * 'elt * 'elt tree + * Z_as_Int.t + | R_bal_8 of 'elt tree * key * 'elt * 'elt tree + + val coq_R_bal_rect : + ('a1 tree -> key -> 'a1 -> 'a1 tree -> __ -> __ -> __ -> 'a2) -> ('a1 + tree -> key -> 'a1 -> 'a1 tree -> __ -> __ -> 'a1 tree -> key -> 'a1 + -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> + key -> 'a1 -> 'a1 tree -> __ -> __ -> 'a1 tree -> key -> 'a1 -> 'a1 + tree -> Z_as_Int.t -> __ -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> + key -> 'a1 -> 'a1 tree -> __ -> __ -> 'a1 tree -> key -> 'a1 -> 'a1 + tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a1 tree -> key -> 'a1 -> 'a1 + tree -> Z_as_Int.t -> __ -> 'a2) -> ('a1 tree -> key -> 'a1 -> 'a1 + tree -> __ -> __ -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> key -> 'a1 + -> 'a1 tree -> __ -> __ -> __ -> __ -> 'a1 tree -> key -> 'a1 -> 'a1 + tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> key -> + 'a1 -> 'a1 tree -> __ -> __ -> __ -> __ -> 'a1 tree -> key -> 'a1 -> + 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> __ -> 'a2) -> ('a1 tree + -> key -> 'a1 -> 'a1 tree -> __ -> __ -> __ -> __ -> 'a1 tree -> key + -> 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a1 tree -> key + -> 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> 'a2) -> ('a1 tree -> key -> + 'a1 -> 'a1 tree -> __ -> __ -> __ -> __ -> 'a2) -> 'a1 tree -> key -> + 'a1 -> 'a1 tree -> 'a1 tree -> 'a1 coq_R_bal -> 'a2 + + val coq_R_bal_rec : + ('a1 tree -> key -> 'a1 -> 'a1 tree -> __ -> __ -> __ -> 'a2) -> ('a1 + tree -> key -> 'a1 -> 'a1 tree -> __ -> __ -> 'a1 tree -> key -> 'a1 + -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> + key -> 'a1 -> 'a1 tree -> __ -> __ -> 'a1 tree -> key -> 'a1 -> 'a1 + tree -> Z_as_Int.t -> __ -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> + key -> 'a1 -> 'a1 tree -> __ -> __ -> 'a1 tree -> key -> 'a1 -> 'a1 + tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a1 tree -> key -> 'a1 -> 'a1 + tree -> Z_as_Int.t -> __ -> 'a2) -> ('a1 tree -> key -> 'a1 -> 'a1 + tree -> __ -> __ -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> key -> 'a1 + -> 'a1 tree -> __ -> __ -> __ -> __ -> 'a1 tree -> key -> 'a1 -> 'a1 + tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> key -> + 'a1 -> 'a1 tree -> __ -> __ -> __ -> __ -> 'a1 tree -> key -> 'a1 -> + 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> __ -> 'a2) -> ('a1 tree + -> key -> 'a1 -> 'a1 tree -> __ -> __ -> __ -> __ -> 'a1 tree -> key + -> 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a1 tree -> key + -> 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> 'a2) -> ('a1 tree -> key -> + 'a1 -> 'a1 tree -> __ -> __ -> __ -> __ -> 'a2) -> 'a1 tree -> key -> + 'a1 -> 'a1 tree -> 'a1 tree -> 'a1 coq_R_bal -> 'a2 + + type 'elt coq_R_add = + | R_add_0 of 'elt tree + | R_add_1 of 'elt tree * 'elt tree * key * 'elt * 'elt tree + * Z_as_Int.t * 'elt tree * 'elt coq_R_add + | R_add_2 of 'elt tree * 'elt tree * key * 'elt * 'elt tree * Z_as_Int.t + | R_add_3 of 'elt tree * 'elt tree * key * 'elt * 'elt tree + * Z_as_Int.t * 'elt tree * 'elt coq_R_add + + val coq_R_add_rect : + key -> 'a1 -> ('a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key + -> 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a1 tree -> 'a1 + coq_R_add -> 'a2 -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 -> + 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> 'a1 + tree -> key -> 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a1 + tree -> 'a1 coq_R_add -> 'a2 -> 'a2) -> 'a1 tree -> 'a1 tree -> 'a1 + coq_R_add -> 'a2 + + val coq_R_add_rec : + key -> 'a1 -> ('a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key + -> 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a1 tree -> 'a1 + coq_R_add -> 'a2 -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 -> + 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> 'a1 + tree -> key -> 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a1 + tree -> 'a1 coq_R_add -> 'a2 -> 'a2) -> 'a1 tree -> 'a1 tree -> 'a1 + coq_R_add -> 'a2 + + type 'elt coq_R_remove_min = + | R_remove_min_0 of 'elt tree * key * 'elt * 'elt tree + | R_remove_min_1 of 'elt tree * key * 'elt * 'elt tree * 'elt tree + * key * 'elt * 'elt tree * Z_as_Int.t * ('elt tree * (key * 'elt)) + * 'elt coq_R_remove_min * 'elt tree * (key * 'elt) + + val coq_R_remove_min_rect : + ('a1 tree -> key -> 'a1 -> 'a1 tree -> __ -> 'a2) -> ('a1 tree -> key + -> 'a1 -> 'a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> + Z_as_Int.t -> __ -> ('a1 tree * (key * 'a1)) -> 'a1 coq_R_remove_min + -> 'a2 -> 'a1 tree -> (key * 'a1) -> __ -> 'a2) -> 'a1 tree -> key -> + 'a1 -> 'a1 tree -> ('a1 tree * (key * 'a1)) -> 'a1 coq_R_remove_min + -> 'a2 + + val coq_R_remove_min_rec : + ('a1 tree -> key -> 'a1 -> 'a1 tree -> __ -> 'a2) -> ('a1 tree -> key + -> 'a1 -> 'a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> + Z_as_Int.t -> __ -> ('a1 tree * (key * 'a1)) -> 'a1 coq_R_remove_min + -> 'a2 -> 'a1 tree -> (key * 'a1) -> __ -> 'a2) -> 'a1 tree -> key -> + 'a1 -> 'a1 tree -> ('a1 tree * (key * 'a1)) -> 'a1 coq_R_remove_min + -> 'a2 + + type 'elt coq_R_merge = + | R_merge_0 of 'elt tree * 'elt tree + | R_merge_1 of 'elt tree * 'elt tree * 'elt tree * key * 'elt + * 'elt tree * Z_as_Int.t + | R_merge_2 of 'elt tree * 'elt tree * 'elt tree * key * 'elt + * 'elt tree * Z_as_Int.t * 'elt tree * key * 'elt * 'elt tree + * Z_as_Int.t * 'elt tree * (key * 'elt) * key * 'elt + + val coq_R_merge_rect : + ('a1 tree -> 'a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> 'a1 + tree -> key -> 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> 'a2) -> + ('a1 tree -> 'a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> + Z_as_Int.t -> __ -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> Z_as_Int.t + -> __ -> 'a1 tree -> (key * 'a1) -> __ -> key -> 'a1 -> __ -> 'a2) -> + 'a1 tree -> 'a1 tree -> 'a1 tree -> 'a1 coq_R_merge -> 'a2 + + val coq_R_merge_rec : + ('a1 tree -> 'a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> 'a1 + tree -> key -> 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> 'a2) -> + ('a1 tree -> 'a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> + Z_as_Int.t -> __ -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> Z_as_Int.t + -> __ -> 'a1 tree -> (key * 'a1) -> __ -> key -> 'a1 -> __ -> 'a2) -> + 'a1 tree -> 'a1 tree -> 'a1 tree -> 'a1 coq_R_merge -> 'a2 + + type 'elt coq_R_remove = + | R_remove_0 of 'elt tree + | R_remove_1 of 'elt tree * 'elt tree * key * 'elt * 'elt tree + * Z_as_Int.t * 'elt tree * 'elt coq_R_remove + | R_remove_2 of 'elt tree * 'elt tree * key * 'elt * 'elt tree + * Z_as_Int.t + | R_remove_3 of 'elt tree * 'elt tree * key * 'elt * 'elt tree + * Z_as_Int.t * 'elt tree * 'elt coq_R_remove + + val coq_R_remove_rect : + Uint63.t -> ('a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key + -> 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a1 tree -> 'a1 + coq_R_remove -> 'a2 -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 -> + 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> 'a1 + tree -> key -> 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a1 + tree -> 'a1 coq_R_remove -> 'a2 -> 'a2) -> 'a1 tree -> 'a1 tree -> + 'a1 coq_R_remove -> 'a2 + + val coq_R_remove_rec : + Uint63.t -> ('a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key + -> 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a1 tree -> 'a1 + coq_R_remove -> 'a2 -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 -> + 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> 'a1 + tree -> key -> 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a1 + tree -> 'a1 coq_R_remove -> 'a2 -> 'a2) -> 'a1 tree -> 'a1 tree -> + 'a1 coq_R_remove -> 'a2 + + type 'elt coq_R_concat = + | R_concat_0 of 'elt tree * 'elt tree + | R_concat_1 of 'elt tree * 'elt tree * 'elt tree * key * 'elt + * 'elt tree * Z_as_Int.t + | R_concat_2 of 'elt tree * 'elt tree * 'elt tree * key * 'elt + * 'elt tree * Z_as_Int.t * 'elt tree * key * 'elt * 'elt tree + * Z_as_Int.t * 'elt tree * (key * 'elt) + + val coq_R_concat_rect : + ('a1 tree -> 'a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> 'a1 + tree -> key -> 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> 'a2) -> + ('a1 tree -> 'a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> + Z_as_Int.t -> __ -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> Z_as_Int.t + -> __ -> 'a1 tree -> (key * 'a1) -> __ -> 'a2) -> 'a1 tree -> 'a1 + tree -> 'a1 tree -> 'a1 coq_R_concat -> 'a2 + + val coq_R_concat_rec : + ('a1 tree -> 'a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> 'a1 + tree -> key -> 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> 'a2) -> + ('a1 tree -> 'a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> + Z_as_Int.t -> __ -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> Z_as_Int.t + -> __ -> 'a1 tree -> (key * 'a1) -> __ -> 'a2) -> 'a1 tree -> 'a1 + tree -> 'a1 tree -> 'a1 coq_R_concat -> 'a2 + + type 'elt coq_R_split = + | R_split_0 of 'elt tree + | R_split_1 of 'elt tree * 'elt tree * key * 'elt * 'elt tree + * Z_as_Int.t * 'elt triple * 'elt coq_R_split * 'elt tree + * 'elt option * 'elt tree + | R_split_2 of 'elt tree * 'elt tree * key * 'elt * 'elt tree + * Z_as_Int.t + | R_split_3 of 'elt tree * 'elt tree * key * 'elt * 'elt tree + * Z_as_Int.t * 'elt triple * 'elt coq_R_split * 'elt tree + * 'elt option * 'elt tree + + val coq_R_split_rect : + Uint63.t -> ('a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key + -> 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a1 triple -> + 'a1 coq_R_split -> 'a2 -> 'a1 tree -> 'a1 option -> 'a1 tree -> __ -> + 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> Z_as_Int.t + -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 -> + 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a1 triple -> 'a1 + coq_R_split -> 'a2 -> 'a1 tree -> 'a1 option -> 'a1 tree -> __ -> + 'a2) -> 'a1 tree -> 'a1 triple -> 'a1 coq_R_split -> 'a2 + + val coq_R_split_rec : + Uint63.t -> ('a1 tree -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key + -> 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a1 triple -> + 'a1 coq_R_split -> 'a2 -> 'a1 tree -> 'a1 option -> 'a1 tree -> __ -> + 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> Z_as_Int.t + -> __ -> __ -> __ -> 'a2) -> ('a1 tree -> 'a1 tree -> key -> 'a1 -> + 'a1 tree -> Z_as_Int.t -> __ -> __ -> __ -> 'a1 triple -> 'a1 + coq_R_split -> 'a2 -> 'a1 tree -> 'a1 option -> 'a1 tree -> __ -> + 'a2) -> 'a1 tree -> 'a1 triple -> 'a1 coq_R_split -> 'a2 + + type ('elt, 'x) coq_R_map_option = + | R_map_option_0 of 'elt tree + | R_map_option_1 of 'elt tree * 'elt tree * key * 'elt * 'elt tree + * Z_as_Int.t * 'x * 'x tree * ('elt, 'x) coq_R_map_option * + 'x tree * ('elt, 'x) coq_R_map_option + | R_map_option_2 of 'elt tree * 'elt tree * key * 'elt * 'elt tree + * Z_as_Int.t * 'x tree * ('elt, 'x) coq_R_map_option * 'x tree + * ('elt, 'x) coq_R_map_option + + val coq_R_map_option_rect : + (key -> 'a1 -> 'a2 option) -> ('a1 tree -> __ -> 'a3) -> ('a1 tree -> + 'a1 tree -> key -> 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> 'a2 -> __ + -> 'a2 tree -> ('a1, 'a2) coq_R_map_option -> 'a3 -> 'a2 tree -> + ('a1, 'a2) coq_R_map_option -> 'a3 -> 'a3) -> ('a1 tree -> 'a1 tree + -> key -> 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> 'a2 tree -> + ('a1, 'a2) coq_R_map_option -> 'a3 -> 'a2 tree -> ('a1, 'a2) + coq_R_map_option -> 'a3 -> 'a3) -> 'a1 tree -> 'a2 tree -> ('a1, 'a2) + coq_R_map_option -> 'a3 + + val coq_R_map_option_rec : + (key -> 'a1 -> 'a2 option) -> ('a1 tree -> __ -> 'a3) -> ('a1 tree -> + 'a1 tree -> key -> 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> 'a2 -> __ + -> 'a2 tree -> ('a1, 'a2) coq_R_map_option -> 'a3 -> 'a2 tree -> + ('a1, 'a2) coq_R_map_option -> 'a3 -> 'a3) -> ('a1 tree -> 'a1 tree + -> key -> 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> __ -> 'a2 tree -> + ('a1, 'a2) coq_R_map_option -> 'a3 -> 'a2 tree -> ('a1, 'a2) + coq_R_map_option -> 'a3 -> 'a3) -> 'a1 tree -> 'a2 tree -> ('a1, 'a2) + coq_R_map_option -> 'a3 + + type ('elt, 'x0, 'x) coq_R_map2_opt = + | R_map2_opt_0 of 'elt tree * 'x0 tree + | R_map2_opt_1 of 'elt tree * 'x0 tree * 'elt tree * key * 'elt + * 'elt tree * Z_as_Int.t + | R_map2_opt_2 of 'elt tree * 'x0 tree * 'elt tree * key * 'elt + * 'elt tree * Z_as_Int.t * 'x0 tree * key * 'x0 * 'x0 tree + * Z_as_Int.t * 'x0 tree * 'x0 option * 'x0 tree * 'x * 'x tree + * ('elt, 'x0, 'x) coq_R_map2_opt * 'x tree + * ('elt, 'x0, 'x) coq_R_map2_opt + | R_map2_opt_3 of 'elt tree * 'x0 tree * 'elt tree * key * 'elt + * 'elt tree * Z_as_Int.t * 'x0 tree * key * 'x0 * 'x0 tree + * Z_as_Int.t * 'x0 tree * 'x0 option * 'x0 tree * 'x tree + * ('elt, 'x0, 'x) coq_R_map2_opt * 'x tree + * ('elt, 'x0, 'x) coq_R_map2_opt + + val coq_R_map2_opt_rect : + (key -> 'a1 -> 'a2 option -> 'a3 option) -> ('a1 tree -> 'a3 tree) -> + ('a2 tree -> 'a3 tree) -> ('a1 tree -> 'a2 tree -> __ -> 'a4) -> ('a1 + tree -> 'a2 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> Z_as_Int.t + -> __ -> __ -> 'a4) -> ('a1 tree -> 'a2 tree -> 'a1 tree -> key -> + 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> 'a2 tree -> key -> 'a2 -> 'a2 + tree -> Z_as_Int.t -> __ -> 'a2 tree -> 'a2 option -> 'a2 tree -> __ + -> 'a3 -> __ -> 'a3 tree -> ('a1, 'a2, 'a3) coq_R_map2_opt -> 'a4 -> + 'a3 tree -> ('a1, 'a2, 'a3) coq_R_map2_opt -> 'a4 -> 'a4) -> ('a1 + tree -> 'a2 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> Z_as_Int.t + -> __ -> 'a2 tree -> key -> 'a2 -> 'a2 tree -> Z_as_Int.t -> __ -> + 'a2 tree -> 'a2 option -> 'a2 tree -> __ -> __ -> 'a3 tree -> ('a1, + 'a2, 'a3) coq_R_map2_opt -> 'a4 -> 'a3 tree -> ('a1, 'a2, 'a3) + coq_R_map2_opt -> 'a4 -> 'a4) -> 'a1 tree -> 'a2 tree -> 'a3 tree -> + ('a1, 'a2, 'a3) coq_R_map2_opt -> 'a4 + + val coq_R_map2_opt_rec : + (key -> 'a1 -> 'a2 option -> 'a3 option) -> ('a1 tree -> 'a3 tree) -> + ('a2 tree -> 'a3 tree) -> ('a1 tree -> 'a2 tree -> __ -> 'a4) -> ('a1 + tree -> 'a2 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> Z_as_Int.t + -> __ -> __ -> 'a4) -> ('a1 tree -> 'a2 tree -> 'a1 tree -> key -> + 'a1 -> 'a1 tree -> Z_as_Int.t -> __ -> 'a2 tree -> key -> 'a2 -> 'a2 + tree -> Z_as_Int.t -> __ -> 'a2 tree -> 'a2 option -> 'a2 tree -> __ + -> 'a3 -> __ -> 'a3 tree -> ('a1, 'a2, 'a3) coq_R_map2_opt -> 'a4 -> + 'a3 tree -> ('a1, 'a2, 'a3) coq_R_map2_opt -> 'a4 -> 'a4) -> ('a1 + tree -> 'a2 tree -> 'a1 tree -> key -> 'a1 -> 'a1 tree -> Z_as_Int.t + -> __ -> 'a2 tree -> key -> 'a2 -> 'a2 tree -> Z_as_Int.t -> __ -> + 'a2 tree -> 'a2 option -> 'a2 tree -> __ -> __ -> 'a3 tree -> ('a1, + 'a2, 'a3) coq_R_map2_opt -> 'a4 -> 'a3 tree -> ('a1, 'a2, 'a3) + coq_R_map2_opt -> 'a4 -> 'a4) -> 'a1 tree -> 'a2 tree -> 'a3 tree -> + ('a1, 'a2, 'a3) coq_R_map2_opt -> 'a4 + + val fold' : (key -> 'a1 -> 'a2 -> 'a2) -> 'a1 tree -> 'a2 -> 'a2 + + val flatten_e : 'a1 enumeration -> (key * 'a1) list + end + end + + type 'elt bst = + 'elt Raw.tree + (* singleton inductive, whose constructor was Bst *) + + val this : 'a1 bst -> 'a1 Raw.tree + + type 'elt t = 'elt bst + + type key = Uint63.t + + val empty : 'a1 t + + val is_empty : 'a1 t -> bool + + val add : key -> 'a1 -> 'a1 t -> 'a1 t + + val remove : key -> 'a1 t -> 'a1 t + + val mem : key -> 'a1 t -> bool + + val find : key -> 'a1 t -> 'a1 option + + val map : ('a1 -> 'a2) -> 'a1 t -> 'a2 t + + val mapi : (key -> 'a1 -> 'a2) -> 'a1 t -> 'a2 t + + val map2 : + ('a1 option -> 'a2 option -> 'a3 option) -> 'a1 t -> 'a2 t -> 'a3 t + + val elements : 'a1 t -> (key * 'a1) list + + val cardinal : 'a1 t -> nat + + val fold : (key -> 'a1 -> 'a2 -> 'a2) -> 'a1 t -> 'a2 -> 'a2 + + val equal : ('a1 -> 'a1 -> bool) -> 'a1 t -> 'a1 t -> bool + end + +type 'a array = ('a Map.t * 'a) * Uint63.t + +val make : Uint63.t -> 'a1 -> 'a1 array + +val get : 'a1 array -> Uint63.t -> 'a1 + +val default : 'a1 array -> 'a1 + +val set : 'a1 array -> Uint63.t -> 'a1 -> 'a1 array + +val length0 : 'a1 array -> Uint63.t + +val iter_int63_aux : nat -> Uint63.t -> ('a1 -> 'a1) -> 'a1 -> 'a1 + +val iter_int63 : Uint63.t -> ('a1 -> 'a1) -> 'a1 -> 'a1 + +val foldi : (Uint63.t -> 'a1 -> 'a1) -> Uint63.t -> Uint63.t -> 'a1 -> 'a1 + +val to_list : 'a1 array -> 'a1 list + +val amapi : (Uint63.t -> 'a1 -> 'a2) -> 'a1 array -> 'a2 array + +val amap : ('a1 -> 'a2) -> 'a1 array -> 'a2 array + +val afold_left : 'a1 -> ('a1 -> 'a1 -> 'a1) -> 'a1 array -> 'a1 + +val afold_right : 'a1 -> ('a1 -> 'a1 -> 'a1) -> 'a1 array -> 'a1 + +val aexistsbi : (Uint63.t -> 'a1 -> bool) -> 'a1 array -> bool + +val aforallbi : (Uint63.t -> 'a1 -> bool) -> 'a1 array -> bool + +val forallb2 : ('a1 -> 'a2 -> bool) -> 'a1 list -> 'a2 list -> bool + +module RAWBITVECTOR_LIST : + sig + val beq_list : bool list -> bool list -> bool + + val pow2 : nat -> nat + + val _list2nat_be : bool list -> nat -> nat -> nat + + val list2nat_be : bool list -> nat + end + +module Lit : + sig + val is_pos : Uint63.t -> bool + + val blit : Uint63.t -> Uint63.t + + val lit : Uint63.t -> Uint63.t + + val neg : Uint63.t -> Uint63.t + + val nlit : Uint63.t -> Uint63.t + + val _true : Uint63.t + + val _false : Uint63.t + end + +module C : + sig + type t = Uint63.t list + + val _true : t + + val is_false : t -> bool + + val or_aux : (t -> t -> t) -> Uint63.t -> t -> t -> Uint63.t list + + val coq_or : t -> t -> t + + val resolve_aux : (t -> t -> t) -> Uint63.t -> t -> t -> t + + val resolve : t -> t -> t + end + +module S : + sig + type t = C.t array + + val get : t -> Uint63.t -> C.t + + val internal_set : t -> Uint63.t -> C.t -> t + + val make : Uint63.t -> t + + val insert_no_simpl : Uint63.t -> Uint63.t list -> Uint63.t list + + val insert_keep : Uint63.t -> Uint63.t list -> Uint63.t list + + val sort : Uint63.t list -> Uint63.t list + + val sort_keep : Uint63.t list -> Uint63.t list + + val set_clause : t -> Uint63.t -> C.t -> t + + val set_clause_keep : t -> Uint63.t -> C.t -> t + + val set_resolve : t -> Uint63.t -> Uint63.t array -> t + + val subclause : Uint63.t list -> Uint63.t list -> bool + + val check_weaken : t -> Uint63.t -> Uint63.t list -> C.t + + val set_weaken : t -> Uint63.t -> Uint63.t -> Uint63.t list -> t + end + +module Form : + sig + type form = + | Fatom of Uint63.t + | Ftrue + | Ffalse + | Fnot2 of Uint63.t * Uint63.t + | Fand of Uint63.t array + | For of Uint63.t array + | Fimp of Uint63.t array + | Fxor of Uint63.t * Uint63.t + | Fiff of Uint63.t * Uint63.t + | Fite of Uint63.t * Uint63.t * Uint63.t + | FbbT of Uint63.t * Uint63.t list + + val is_Ftrue : form -> bool + + val is_Ffalse : form -> bool + + val lt_form : Uint63.t -> form -> bool + + val wf : form array -> bool + + val check_form : form array -> bool + end + +module Typ : + sig + type coq_type = + | TFArray of coq_type * coq_type + | Tindex of n + | TZ + | Tbool + | Tpositive + | TBV of n + + val eqb : coq_type -> coq_type -> bool + end + +val list_beq : ('a1 -> 'a1 -> bool) -> 'a1 list -> 'a1 list -> bool + +module Atom : + sig + type cop = + | CO_xH + | CO_Z0 + | CO_BV of bool list * n + + type unop = + | UO_xO + | UO_xI + | UO_Zpos + | UO_Zneg + | UO_Zopp + | UO_BVbitOf of n * nat + | UO_BVnot of n + | UO_BVneg of n + | UO_BVextr of n * n * n + | UO_BVzextn of n * n + | UO_BVsextn of n * n + + type binop = + | BO_Zplus + | BO_Zminus + | BO_Zmult + | BO_Zlt + | BO_Zle + | BO_Zge + | BO_Zgt + | BO_eq of Typ.coq_type + | BO_BVand of n + | BO_BVor of n + | BO_BVxor of n + | BO_BVadd of n + | BO_BVmult of n + | BO_BVult of n + | BO_BVslt of n + | BO_BVconcat of n * n + | BO_BVshl of n + | BO_BVshr of n + | BO_select of Typ.coq_type * Typ.coq_type + | BO_diffarray of Typ.coq_type * Typ.coq_type + + type nop = + Typ.coq_type + (* singleton inductive, whose constructor was NO_distinct *) + + type terop = + | TO_store of Typ.coq_type * Typ.coq_type + + type atom = + | Acop of cop + | Auop of unop * Uint63.t + | Abop of binop * Uint63.t * Uint63.t + | Atop of terop * Uint63.t * Uint63.t * Uint63.t + | Anop of nop * Uint63.t list + | Aapp of Uint63.t * Uint63.t list + + val cop_eqb : cop -> cop -> bool + + val uop_eqb : unop -> unop -> bool + + val bop_eqb : binop -> binop -> bool + + val top_eqb : terop -> terop -> bool + + val nop_eqb : nop -> nop -> bool + + val eqb : atom -> atom -> bool + + val lt_atom : Uint63.t -> atom -> bool + + val wf : atom array -> bool + + val check_atom : atom array -> bool + end + +val get_eq : + Form.form array -> Atom.atom array -> Uint63.t -> (Uint63.t -> Uint63.t -> + C.t) -> C.t + +val check_trans_aux : + Form.form array -> Atom.atom array -> Uint63.t -> Uint63.t -> Uint63.t list + -> Uint63.t -> C.t -> C.t + +val check_trans : + Form.form array -> Atom.atom array -> Uint63.t -> Uint63.t list -> C.t + +val build_congr : + Form.form array -> Atom.atom array -> Uint63.t option list -> Uint63.t list + -> Uint63.t list -> C.t -> C.t + +val check_congr : + Form.form array -> Atom.atom array -> Uint63.t -> Uint63.t option list -> + C.t + +val check_congr_pred : + Form.form array -> Atom.atom array -> Uint63.t -> Uint63.t -> Uint63.t + option list -> C.t + val build_positive_atom_aux : - (int -> positive option) -> Atom.atom -> positive option + (Uint63.t -> positive option) -> Atom.atom -> positive option -val build_positive : Atom.atom array -> int -> positive option +val build_positive : Atom.atom array -> Uint63.t -> positive option val build_z_atom_aux : Atom.atom array -> Atom.atom -> z option val build_z_atom : Atom.atom array -> Atom.atom -> z option -type vmap = positive*Atom.atom list +type vmap = positive * Atom.atom list val find_var_aux : Atom.atom -> positive -> Atom.atom list -> positive option -val find_var : vmap -> Atom.atom -> vmap*positive +val find_var : vmap -> Atom.atom -> vmap * positive val empty_vmap : vmap val build_pexpr_atom_aux : - Atom.atom array -> (vmap -> int -> vmap*z pExpr) -> vmap -> Atom.atom -> - vmap*z pExpr + Atom.atom array -> (vmap -> Uint63.t -> vmap * z pExpr) -> vmap -> + Atom.atom -> vmap * z pExpr -val build_pexpr : Atom.atom array -> vmap -> int -> vmap*z pExpr +val build_pexpr : Atom.atom array -> vmap -> Uint63.t -> vmap * z pExpr val build_op2 : Atom.binop -> op2 option val build_formula_atom : - Atom.atom array -> vmap -> Atom.atom -> (vmap*z formula) option + Atom.atom array -> vmap -> Atom.atom -> (vmap * z formula) option -val build_formula : Atom.atom array -> vmap -> int -> (vmap*z formula) option +val build_formula : + Atom.atom array -> vmap -> Uint63.t -> (vmap * z formula) option -val build_not2 : int -> z formula bFormula -> z formula bFormula +val build_not2 : Uint63.t -> z formula bFormula -> z formula bFormula val build_hform : - Atom.atom array -> (vmap -> int -> (vmap*z formula bFormula) option) -> - vmap -> Form.form -> (vmap*z formula bFormula) option + Atom.atom array -> (vmap -> Uint63.t -> (vmap * z formula bFormula) option) + -> vmap -> Form.form -> (vmap * z formula bFormula) option val build_var : - Form.form array -> Atom.atom array -> vmap -> int -> (vmap*z formula + Form.form array -> Atom.atom array -> vmap -> Uint63.t -> (vmap * z formula bFormula) option val build_form : - Form.form array -> Atom.atom array -> vmap -> Form.form -> (vmap*z formula - bFormula) option + Form.form array -> Atom.atom array -> vmap -> Form.form -> (vmap * z + formula bFormula) option val build_nlit : - Form.form array -> Atom.atom array -> vmap -> int -> (vmap*z formula + Form.form array -> Atom.atom array -> vmap -> Uint63.t -> (vmap * z formula bFormula) option val build_clause_aux : - Form.form array -> Atom.atom array -> vmap -> int list -> (vmap*z formula - bFormula) option + Form.form array -> Atom.atom array -> vmap -> Uint63.t list -> (vmap * z + formula bFormula) option val build_clause : - Form.form array -> Atom.atom array -> vmap -> int list -> (vmap*z formula - bFormula) option + Form.form array -> Atom.atom array -> vmap -> Uint63.t list -> (vmap * (z + formula, eKind, unit0, unit0) gFormula) option val get_eq0 : - Form.form array -> Atom.atom array -> int -> (int -> int -> C.t) -> C.t + Form.form array -> Atom.atom array -> Uint63.t -> (Uint63.t -> Uint63.t -> + C.t) -> C.t val get_not_le : - Form.form array -> Atom.atom array -> int -> (int -> int -> C.t) -> C.t + Form.form array -> Atom.atom array -> Uint63.t -> (Uint63.t -> Uint63.t -> + C.t) -> C.t val check_micromega : - Form.form array -> Atom.atom array -> int list -> zArithProof list -> C.t + Form.form array -> Atom.atom array -> Uint63.t list -> zArithProof list -> + C.t -val check_diseq : Form.form array -> Atom.atom array -> int -> C.t +val check_diseq : Form.form array -> Atom.atom array -> Uint63.t -> C.t val check_atom_aux : - Atom.atom array -> (int -> int -> bool) -> Atom.atom -> Atom.atom -> bool + Atom.atom array -> (Uint63.t -> Uint63.t -> bool) -> Atom.atom -> Atom.atom + -> bool -val check_hatom : Atom.atom array -> int -> int -> bool +val check_hatom : Atom.atom array -> Uint63.t -> Uint63.t -> bool -val check_neg_hatom : Atom.atom array -> int -> int -> bool +val check_neg_hatom : Atom.atom array -> Uint63.t -> Uint63.t -> bool -val remove_not : Form.form array -> int -> int +val remove_not : Form.form array -> Uint63.t -> Uint63.t -val get_and : Form.form array -> int -> int array option +val get_and : Form.form array -> Uint63.t -> Uint63.t array option -val get_or : Form.form array -> int -> int array option +val get_or : Form.form array -> Uint63.t -> Uint63.t array option val flatten_op_body : - (int -> int array option) -> (int list -> int -> int list) -> int list -> - int -> int list + (Uint63.t -> Uint63.t array option) -> (Uint63.t list -> Uint63.t -> + Uint63.t list) -> Uint63.t list -> Uint63.t -> Uint63.t list val flatten_op_lit : - (int -> int array option) -> int -> int list -> int -> int list + (Uint63.t -> Uint63.t array option) -> Uint63.t -> Uint63.t list -> + Uint63.t -> Uint63.t list -val flatten_and : Form.form array -> int array -> int list +val flatten_and : Form.form array -> Uint63.t array -> Uint63.t list -val flatten_or : Form.form array -> int array -> int list +val flatten_or : Form.form array -> Uint63.t array -> Uint63.t list val check_flatten_body : - Form.form array -> (int -> int -> bool) -> (int -> int -> bool) -> (int -> - int -> bool) -> int -> int -> bool + Form.form array -> (Uint63.t -> Uint63.t -> bool) -> (Uint63.t -> Uint63.t + -> bool) -> (Uint63.t -> Uint63.t -> bool) -> Uint63.t -> Uint63.t -> bool val check_flatten_aux : - Form.form array -> (int -> int -> bool) -> (int -> int -> bool) -> int -> - int -> bool + Form.form array -> (Uint63.t -> Uint63.t -> bool) -> (Uint63.t -> Uint63.t + -> bool) -> Uint63.t -> Uint63.t -> bool val check_flatten : - Form.form array -> (int -> int -> bool) -> (int -> int -> bool) -> S.t -> - int -> int -> C.t + Form.form array -> (Uint63.t -> Uint63.t -> bool) -> (Uint63.t -> Uint63.t + -> bool) -> S.t -> Uint63.t -> Uint63.t -> C.t val check_spl_arith : - Form.form array -> Atom.atom array -> int list -> int -> zArithProof list - -> C.t + Form.form array -> Atom.atom array -> Uint63.t list -> Uint63.t -> + zArithProof list -> C.t -val check_in : int -> int list -> bool +val check_in : Uint63.t -> Uint63.t list -> bool val check_diseqs_complete_aux : - int -> int list -> (int*int) option array -> bool + Uint63.t -> Uint63.t list -> (Uint63.t * Uint63.t) option array -> bool -val check_diseqs_complete : int list -> (int*int) option array -> bool +val check_diseqs_complete : + Uint63.t list -> (Uint63.t * Uint63.t) option array -> bool val check_diseqs : - Form.form array -> Atom.atom array -> Typ.coq_type -> int list -> int array - -> bool + Form.form array -> Atom.atom array -> Typ.coq_type -> Uint63.t list -> + Uint63.t array -> bool val check_distinct : - Form.form array -> Atom.atom array -> int -> int array -> bool + Form.form array -> Atom.atom array -> Uint63.t -> Uint63.t array -> bool val check_distinct_two_args : - Form.form array -> Atom.atom array -> int -> int -> bool + Form.form array -> Atom.atom array -> Uint63.t -> Uint63.t -> bool val check_lit : - Form.form array -> Atom.atom array -> (int -> int -> bool) -> int -> int -> - bool + Form.form array -> Atom.atom array -> (Uint63.t -> Uint63.t -> bool) -> + Uint63.t -> Uint63.t -> bool val check_form_aux : - Form.form array -> Atom.atom array -> (int -> int -> bool) -> Form.form -> - Form.form -> bool + Form.form array -> Atom.atom array -> (Uint63.t -> Uint63.t -> bool) -> + Form.form -> Form.form -> bool -val check_hform : Form.form array -> Atom.atom array -> int -> int -> bool +val check_hform : + Form.form array -> Atom.atom array -> Uint63.t -> Uint63.t -> bool -val check_lit' : Form.form array -> Atom.atom array -> int -> int -> bool +val check_lit' : + Form.form array -> Atom.atom array -> Uint63.t -> Uint63.t -> bool val check_distinct_elim : - Form.form array -> Atom.atom array -> int list -> int -> int list + Form.form array -> Atom.atom array -> Uint63.t list -> Uint63.t -> Uint63.t + list + +val or_of_imp : Uint63.t array -> Uint63.t array + +val check_True : C.t + +val check_False : Uint63.t list + +val check_BuildDef : Form.form array -> Uint63.t -> C.t + +val check_ImmBuildDef : Form.form array -> S.t -> Uint63.t -> C.t + +val check_BuildDef2 : Form.form array -> Uint63.t -> C.t -type 'step _trace_ = 'step array array +val check_ImmBuildDef2 : Form.form array -> S.t -> Uint63.t -> C.t + +val check_BuildProj : Form.form array -> Uint63.t -> Uint63.t -> C.t + +val check_ImmBuildProj : Form.form array -> S.t -> Uint63.t -> Uint63.t -> C.t + +val check_bbc : Form.form array -> bool list -> Uint63.t list -> bool + +val check_bbConst : Atom.atom array -> Form.form array -> Uint63.t -> C.t + +val check_bb : + Atom.atom array -> Form.form array -> Uint63.t -> Uint63.t list -> nat -> + nat -> bool + +val check_bbVar : Atom.atom array -> Form.form array -> Uint63.t -> C.t + +val check_not : Uint63.t list -> Uint63.t list -> bool + +val check_bbNot : + Atom.atom array -> Form.form array -> S.t -> Uint63.t -> Uint63.t -> C.t + +val check_symopp : + Form.form array -> Uint63.t list -> Uint63.t list -> Uint63.t list -> + Atom.binop -> bool + +val check_bbOp : + Atom.atom array -> Form.form array -> S.t -> Uint63.t -> Uint63.t -> + Uint63.t -> C.t + +val check_eq : + Form.form array -> Uint63.t list -> Uint63.t list -> Uint63.t list -> bool + +val check_bbEq : + Atom.atom array -> Form.form array -> S.t -> Uint63.t -> Uint63.t -> + Uint63.t -> C.t + +type carry = +| Clit of Uint63.t +| Cand of carry * carry +| Cxor of carry * carry +| Cor of carry * carry +| Ciff of carry * carry + +val eq_carry_lit : Form.form array -> carry -> Uint63.t -> bool + +val check_add : + Form.form array -> Uint63.t list -> Uint63.t list -> Uint63.t list -> carry + -> bool + +val check_bbAdd : + Atom.atom array -> Form.form array -> S.t -> Uint63.t -> Uint63.t -> + Uint63.t -> C.t + +val check_neg : Form.form array -> Uint63.t list -> Uint63.t list -> bool + +val check_bbNeg : + Atom.atom array -> Form.form array -> S.t -> Uint63.t -> Uint63.t -> C.t + +val and_with_bit : Uint63.t list -> Uint63.t -> carry list + +val mult_step_k_h : carry list -> carry list -> carry -> z -> carry list + +val mult_step : + Uint63.t list -> Uint63.t list -> carry list -> nat -> nat -> carry list + +val bblast_bvmult : Uint63.t list -> Uint63.t list -> nat -> carry list + +val check_mult : + Form.form array -> Uint63.t list -> Uint63.t list -> Uint63.t list -> bool + +val check_bbMult : + Atom.atom array -> Form.form array -> S.t -> Uint63.t -> Uint63.t -> + Uint63.t -> C.t + +val ult_big_endian_lit_list : Uint63.t list -> Uint63.t list -> carry + +val ult_lit_list : Uint63.t list -> Uint63.t list -> carry + +val check_ult : + Form.form array -> Uint63.t list -> Uint63.t list -> Uint63.t -> bool + +val check_bbUlt : + Atom.atom array -> Form.form array -> S.t -> Uint63.t -> Uint63.t -> + Uint63.t -> C.t + +val slt_big_endian_lit_list : Uint63.t list -> Uint63.t list -> carry + +val slt_lit_list : Uint63.t list -> Uint63.t list -> carry + +val check_slt : + Form.form array -> Uint63.t list -> Uint63.t list -> Uint63.t -> bool + +val check_bbSlt : + Atom.atom array -> Form.form array -> S.t -> Uint63.t -> Uint63.t -> + Uint63.t -> C.t + +val lit_to_carry : Uint63.t list -> carry list + +val check_concat : + Form.form array -> Uint63.t list -> Uint63.t list -> Uint63.t list -> bool + +val check_bbConcat : + Atom.atom array -> Form.form array -> S.t -> Uint63.t -> Uint63.t -> + Uint63.t -> C.t + +val list_diseqb : bool list -> bool list -> bool + +val check_bbDiseq : Atom.atom array -> Form.form array -> Uint63.t -> C.t + +val extract_lit : Uint63.t list -> nat -> nat -> Uint63.t list + +val check_extract : + Form.form array -> Uint63.t list -> Uint63.t list -> n -> n -> bool + +val check_bbExtract : + Atom.atom array -> Form.form array -> S.t -> Uint63.t -> Uint63.t -> C.t + +val extend_lit : Uint63.t list -> nat -> Uint63.t -> Uint63.t list + +val zextend_lit : Uint63.t list -> nat -> Uint63.t list + +val check_zextend : + Form.form array -> Uint63.t list -> Uint63.t list -> n -> bool + +val check_bbZextend : + Atom.atom array -> Form.form array -> S.t -> Uint63.t -> Uint63.t -> C.t + +val mk_list_lit_false : nat -> Uint63.t list + +val sextend_lit : Uint63.t list -> nat -> Uint63.t list + +val check_sextend : + Form.form array -> Uint63.t list -> Uint63.t list -> n -> bool + +val check_bbSextend : + Atom.atom array -> Form.form array -> S.t -> Uint63.t -> Uint63.t -> C.t + +val _shl_lit_be : Uint63.t list -> Uint63.t list + +val nshl_lit_be : Uint63.t list -> nat -> Uint63.t list + +val shl_lit_be : Uint63.t list -> bool list -> Uint63.t list + +val check_shl : + Form.form array -> Uint63.t list -> bool list -> Uint63.t list -> bool + +val check_bbShl : + Atom.atom array -> Form.form array -> S.t -> Uint63.t -> Uint63.t -> + Uint63.t -> C.t + +val _shr_lit_be : Uint63.t list -> Uint63.t list + +val nshr_lit_be : Uint63.t list -> nat -> Uint63.t list + +val shr_lit_be : Uint63.t list -> bool list -> Uint63.t list + +val check_shr : + Form.form array -> Uint63.t list -> bool list -> Uint63.t list -> bool + +val check_bbShr : + Atom.atom array -> Form.form array -> S.t -> Uint63.t -> Uint63.t -> + Uint63.t -> C.t + +val check_roweq : Form.form array -> Atom.atom array -> Uint63.t -> C.t + +val store_of_me : + Atom.atom array -> Uint63.t -> Uint63.t -> + ((Typ.coq_type * Typ.coq_type) * Uint63.t) option + +val check_rowneq : Form.form array -> Atom.atom array -> Uint63.t list -> C.t + +val eq_sel_sym : + Atom.atom array -> Typ.coq_type -> Typ.coq_type -> Uint63.t -> Uint63.t -> + Uint63.t -> Uint63.t -> bool + +val check_ext : Form.form array -> Atom.atom array -> Uint63.t -> C.t + +type 'step _trace_ = 'step list * 'step val _checker_ : - (S.t -> 'a1 -> S.t) -> (C.t -> bool) -> S.t -> 'a1 _trace_ -> int -> bool + (S.t -> 'a1 -> S.t) -> (C.t -> bool) -> S.t -> 'a1 _trace_ -> Uint63.t -> + bool + +module Euf_Checker : + sig + val add_roots : S.t -> Uint63.t array -> Uint63.t array option -> S.t + end -module Euf_Checker : - sig +module Checker_Ext : + sig type step = - | Res of int * int array - | ImmFlatten of int * int * int - | CTrue of int - | CFalse of int - | BuildDef of int * int - | BuildDef2 of int * int - | BuildProj of int * int * int - | ImmBuildDef of int * int - | ImmBuildDef2 of int * int - | ImmBuildProj of int * int * int - | EqTr of int * int * int list - | EqCgr of int * int * int option list - | EqCgrP of int * int * int * int option list - | LiaMicromega of int * int list * zArithProof list - | LiaDiseq of int * int - | SplArith of int * int * int * zArithProof list - | SplDistinctElim of int * int * int - - val step_rect : - (int -> int array -> 'a1) -> (int -> int -> int -> 'a1) -> (int -> 'a1) - -> (int -> 'a1) -> (int -> int -> 'a1) -> (int -> int -> 'a1) -> (int -> - int -> int -> 'a1) -> (int -> int -> 'a1) -> (int -> int -> 'a1) -> (int - -> int -> int -> 'a1) -> (int -> int -> int list -> 'a1) -> (int -> int - -> int option list -> 'a1) -> (int -> int -> int -> int option list -> - 'a1) -> (int -> int list -> zArithProof list -> 'a1) -> (int -> int -> - 'a1) -> (int -> int -> int -> zArithProof list -> 'a1) -> (int -> int -> - int -> 'a1) -> step -> 'a1 - - val step_rec : - (int -> int array -> 'a1) -> (int -> int -> int -> 'a1) -> (int -> 'a1) - -> (int -> 'a1) -> (int -> int -> 'a1) -> (int -> int -> 'a1) -> (int -> - int -> int -> 'a1) -> (int -> int -> 'a1) -> (int -> int -> 'a1) -> (int - -> int -> int -> 'a1) -> (int -> int -> int list -> 'a1) -> (int -> int - -> int option list -> 'a1) -> (int -> int -> int -> int option list -> - 'a1) -> (int -> int list -> zArithProof list -> 'a1) -> (int -> int -> - 'a1) -> (int -> int -> int -> zArithProof list -> 'a1) -> (int -> int -> - int -> 'a1) -> step -> 'a1 - + | Res of Uint63.t * Uint63.t array + | Weaken of Uint63.t * Uint63.t * Uint63.t list + | ImmFlatten of Uint63.t * Uint63.t * Uint63.t + | CTrue of Uint63.t + | CFalse of Uint63.t + | BuildDef of Uint63.t * Uint63.t + | BuildDef2 of Uint63.t * Uint63.t + | BuildProj of Uint63.t * Uint63.t * Uint63.t + | ImmBuildDef of Uint63.t * Uint63.t + | ImmBuildDef2 of Uint63.t * Uint63.t + | ImmBuildProj of Uint63.t * Uint63.t * Uint63.t + | EqTr of Uint63.t * Uint63.t * Uint63.t list + | EqCgr of Uint63.t * Uint63.t * Uint63.t option list + | EqCgrP of Uint63.t * Uint63.t * Uint63.t * Uint63.t option list + | LiaMicromega of Uint63.t * Uint63.t list * zArithProof list + | LiaDiseq of Uint63.t * Uint63.t + | SplArith of Uint63.t * Uint63.t * Uint63.t * zArithProof list + | SplDistinctElim of Uint63.t * Uint63.t * Uint63.t + | BBVar of Uint63.t * Uint63.t + | BBConst of Uint63.t * Uint63.t + | BBOp of Uint63.t * Uint63.t * Uint63.t * Uint63.t + | BBNot of Uint63.t * Uint63.t * Uint63.t + | BBNeg of Uint63.t * Uint63.t * Uint63.t + | BBAdd of Uint63.t * Uint63.t * Uint63.t * Uint63.t + | BBConcat of Uint63.t * Uint63.t * Uint63.t * Uint63.t + | BBMul of Uint63.t * Uint63.t * Uint63.t * Uint63.t + | BBUlt of Uint63.t * Uint63.t * Uint63.t * Uint63.t + | BBSlt of Uint63.t * Uint63.t * Uint63.t * Uint63.t + | BBEq of Uint63.t * Uint63.t * Uint63.t * Uint63.t + | BBDiseq of Uint63.t * Uint63.t + | BBExtract of Uint63.t * Uint63.t * Uint63.t + | BBZextend of Uint63.t * Uint63.t * Uint63.t + | BBSextend of Uint63.t * Uint63.t * Uint63.t + | BBShl of Uint63.t * Uint63.t * Uint63.t * Uint63.t + | BBShr of Uint63.t * Uint63.t * Uint63.t * Uint63.t + | RowEq of Uint63.t * Uint63.t + | RowNeq of Uint63.t * C.t + | Ext of Uint63.t * Uint63.t + val step_checker : Atom.atom array -> Form.form array -> S.t -> step -> S.t - - val euf_checker : + + val checker : Atom.atom array -> Form.form array -> (C.t -> bool) -> S.t -> step - _trace_ -> int -> bool - + _trace_ -> Uint63.t -> bool + type certif = - | Certif of int * step _trace_ * int - - val certif_rect : (int -> step _trace_ -> int -> 'a1) -> certif -> 'a1 - - val certif_rec : (int -> step _trace_ -> int -> 'a1) -> certif -> 'a1 - - val add_roots : S.t -> int array -> int array option -> S.t - - val valid : - typ_eqb array -> Atom.tval array -> Atom.atom array -> Form.form array -> - int array -> bool - - val checker : - typ_eqb array -> Atom.tval array -> Atom.atom array -> Form.form array -> - int array -> int array option -> certif -> bool - - val checker_b : - typ_eqb array -> Atom.tval array -> Atom.atom array -> Form.form array -> - int -> bool -> certif -> bool - - val checker_eq : - typ_eqb array -> Atom.tval array -> Atom.atom array -> Form.form array -> - int -> int -> int -> certif -> bool - + | Certif of Uint63.t * step _trace_ * Uint63.t + val checker_ext : - Atom.atom array -> Form.form array -> int array -> int array option -> - certif -> bool + Atom.atom array -> Form.form array -> Uint63.t array -> Uint63.t array + option -> certif -> bool end - |