aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorckeller <ckeller@users.noreply.github.com>2022-07-30 16:42:50 +0200
committerGitHub <noreply@github.com>2022-07-30 16:42:50 +0200
commitde9c46d059ddd38c0c1922d91cb788c3d550d488 (patch)
treedb0cdadd6853877cc02be40b325388f0a4d68a24
parentd5697269991500ed1b4b3e6bbec6108ea3a059bb (diff)
downloadsmtcoq-de9c46d059ddd38c0c1922d91cb788c3d550d488.tar.gz
smtcoq-de9c46d059ddd38c0c1922d91cb788c3d550d488.zip
Extraction for Coq 8.13 (#109)
Extraction is back! Some new features: * Not only an executable is generated, but the ZChaff and veriT checkers are available through a package called Smtcoq_extr * The command-line arguments are better handled * The veriT checker is now the default
Diffstat
-rw-r--r--src/Trace.v229
-rw-r--r--src/extraction/Extract.v9
-rw-r--r--src/extraction/Makefile47
-rw-r--r--src/extraction/extrNative.ml344
-rw-r--r--src/extraction/extrNative.mli79
-rw-r--r--src/extraction/sat_checker.ml2726
-rw-r--r--src/extraction/sat_checker.mli4201
-rw-r--r--src/extraction/smt_checker.ml10629
-rw-r--r--src/extraction/smt_checker.mli6149
-rw-r--r--src/extraction/smtcoq.ml43
-rw-r--r--src/extraction/smtcoq.mli17
-rw-r--r--src/extraction/test.ml89
-rw-r--r--src/extraction/verit_checker.ml444
-rw-r--r--src/extraction/verit_checker.mli44
-rw-r--r--src/extraction/zchaff_checker.ml127
-rw-r--r--src/extraction/zchaff_checker.mli12
-rw-r--r--src/smtlib2/smtlib2_genConstr.mli6
-rw-r--r--src/trace/smtCommands.mli3
-rw-r--r--src/verit/verit.mli9
-rw-r--r--src/zchaff/zchaff.mli8
20 files changed, 17578 insertions, 7637 deletions
diff --git a/src/Trace.v b/src/Trace.v
index ad4c41e..906ec46 100644
--- a/src/Trace.v
+++ b/src/Trace.v
@@ -364,7 +364,8 @@ Inductive step :=
| RowNeq (pos:int) (cl: C.t)
| Ext (pos:int) (res: _lit)
(* Offer the possibility to discharge parts of the proof to (manual) Coq proofs.
- WARNING: this breaks extraction. *)
+ This breaks extraction, which is what the extractable version of
+ the checker is now in a separate module. *)
| Hole (pos:int) (prem_id:list clause_id) (prem:list C.t) (concl:C.t)
(p:interp_conseq_uf (Form.interp_state_var (Atom.interp_form_hatom t_i t_func t_atom) (Atom.interp_form_hatom_bv t_i t_func t_atom) t_form) prem concl)
| ForallInst (pos:int) (lemma:Prop) (plemma:lemma) (concl:C.t)
@@ -749,27 +750,6 @@ Inductive step :=
destruct H as [H1 H2]; case_eq (Lit.interp (Form.interp_state_var (Atom.interp_form_hatom t_i t_func t_atom) (Atom.interp_form_hatom_bv t_i t_func t_atom) t_form) l1); intro Heq1; case_eq (Lit.interp (Form.interp_state_var (Atom.interp_form_hatom t_i t_func t_atom) (Atom.interp_form_hatom_bv t_i t_func t_atom) t_form) l2); intro Heq2; auto with smtcoq_core; elim (checker_correct H3); unfold valid; apply afold_left_andb_true; rewrite length_amap; intros i Hi; rewrite get_amap by assumption; rewrite get_make; unfold Lit.interp; rewrite Heq'; unfold Var.interp; rewrite Form.wf_interp_form; auto with smtcoq_core; rewrite Heq; simpl; rewrite Heq1, Heq2; auto with smtcoq_core.
Qed.
-
- (* Checker for extraction, that does not know the evaluation contexts.
- TODO: show that there always exists a well-typed evaluation
- context. *)
-
- (*
- Definition checker_ext t_atom t_form d used_roots (c:certif) :=
- let (nclauses, t, confl) := c in
- Form.check_form t_form && Atom.check_atom t_atom &&
- euf_checker t_atom t_form C.is_false (add_roots (S.make nclauses) d used_roots) t confl.
- Implicit Arguments checker_ext [].
-
- Lemma checker_ext_correct : forall t_atom t_form d used_roots c,
- checker_ext t_atom t_form d used_roots c = true ->
- forall t_i t_func, Atom.wt t_i t_func t_atom ->
- ~ valid t_func t_atom t_form d.
- Proof.
- unfold checker_ext; intros t_atom t_form d used_roots (nclauses, t, confl); rewrite !andb_true_iff; intros [[H1 H2] H3]; intros t_i t_func H10 H; eelim euf_checker_correct; try eassumption; apply add_roots_correct; try eassumption; apply S.valid_make; destruct (Form.check_form_correct (Atom.interp_form_hatom t_i t_func t_atom) _ H1) as [_ H4]; auto with smtcoq_core.
- Qed.
- *)
-
End Checker.
End Euf_Checker.
@@ -899,6 +879,211 @@ Register Euf_Checker.Hole as SMTCoq.Trace.Euf_Checker.Hole.
Register Euf_Checker.ForallInst as SMTCoq.Trace.Euf_Checker.ForallInst.
+(* Checker for extraction, that does not know the evaluation contexts.
+ TODO: show that there always exists a well-typed evaluation
+ context. *)
+
+Module Checker_Ext.
+
+ Section Checker.
+
+ Variable t_atom : array Atom.atom.
+ Variable t_form : array Form.form.
+
+ Inductive step :=
+ | Res (pos:int) (res:resolution)
+ | Weaken (pos:int) (cid:clause_id) (cl:list _lit)
+ | ImmFlatten (pos:int) (cid:clause_id) (lf:_lit)
+ | CTrue (pos:int)
+ | CFalse (pos:int)
+ | BuildDef (pos:int) (l:_lit)
+ | BuildDef2 (pos:int) (l:_lit)
+ | BuildProj (pos:int) (l:_lit) (i:int)
+ | ImmBuildDef (pos:int) (cid:clause_id)
+ | ImmBuildDef2 (pos:int) (cid:clause_id)
+ | ImmBuildProj (pos:int) (cid:clause_id) (i:int)
+ | EqTr (pos:int) (l:_lit) (fl: list _lit)
+ | EqCgr (pos:int) (l:_lit) (fl: list (option _lit))
+ | EqCgrP (pos:int) (l1:_lit) (l2:_lit) (fl: list (option _lit))
+ | LiaMicromega (pos:int) (cl:list _lit) (c:list ZMicromega.ZArithProof)
+ | LiaDiseq (pos:int) (l:_lit)
+ | SplArith (pos:int) (orig:clause_id) (res:_lit) (l:list ZMicromega.ZArithProof)
+ | SplDistinctElim (pos:int) (orig:clause_id) (res:_lit)
+ (* Bit-blasting *)
+ | BBVar (pos:int) (res:_lit)
+ | BBConst (pos:int) (res:_lit)
+ | BBOp (pos:int) (orig1 orig2:clause_id) (res:_lit)
+ | BBNot (pos:int) (orig:clause_id) (res:_lit)
+ | BBNeg (pos:int) (orig:clause_id) (res:_lit)
+ | BBAdd (pos:int) (orig1 orig2:clause_id) (res:_lit)
+ | BBConcat (pos:int) (orig1 orig2:clause_id) (res:_lit)
+ | BBMul (pos:int) (orig1 orig2:clause_id) (res:_lit)
+ | BBUlt (pos:int) (orig1 orig2:clause_id) (res:_lit)
+ | BBSlt (pos:int) (orig1 orig2:clause_id) (res:_lit)
+ | BBEq (pos:int) (orig1 orig2:clause_id) (res:_lit)
+ | BBDiseq (pos:int) (res:_lit)
+ | BBExtract (pos:int) (orig:clause_id) (res:_lit)
+ | BBZextend (pos:int) (orig:clause_id) (res:_lit)
+ | BBSextend (pos:int) (orig:clause_id) (res:_lit)
+ | BBShl (pos:int) (orig1 orig2:clause_id) (res:_lit)
+ | BBShr (pos:int) (orig1 orig2:clause_id) (res:_lit)
+ | RowEq (pos:int) (res: _lit)
+ | RowNeq (pos:int) (cl: C.t)
+ | Ext (pos:int) (res: _lit)
+ .
+
+ Local Open Scope list_scope.
+
+ Local Notation check_flatten t_atom t_form := (check_flatten t_form (check_hatom t_atom) (check_neg_hatom t_atom)) (only parsing).
+
+ Definition step_checker s (st:step) :=
+ match st with
+ | Res pos res => S.set_resolve s pos res
+ | Weaken pos cid cl => S.set_weaken s pos cid cl
+ | ImmFlatten pos cid lf => S.set_clause s pos (check_flatten t_atom t_form s cid lf)
+ | CTrue pos => S.set_clause s pos Cnf.check_True
+ | CFalse pos => S.set_clause s pos Cnf.check_False
+ | BuildDef pos l => S.set_clause s pos (check_BuildDef t_form l)
+ | BuildDef2 pos l => S.set_clause s pos (check_BuildDef2 t_form l)
+ | BuildProj pos l i => S.set_clause s pos (check_BuildProj t_form l i)
+ | ImmBuildDef pos cid => S.set_clause s pos (check_ImmBuildDef t_form s cid)
+ | ImmBuildDef2 pos cid => S.set_clause s pos (check_ImmBuildDef2 t_form s cid)
+ | ImmBuildProj pos cid i => S.set_clause s pos (check_ImmBuildProj t_form s cid i)
+ | EqTr pos l fl => S.set_clause s pos (check_trans t_form t_atom l fl)
+ | EqCgr pos l fl => S.set_clause s pos (check_congr t_form t_atom l fl)
+ | EqCgrP pos l1 l2 fl => S.set_clause s pos (check_congr_pred t_form t_atom l1 l2 fl)
+ | LiaMicromega pos cl c => S.set_clause s pos (check_micromega t_form t_atom cl c)
+ | LiaDiseq pos l => S.set_clause s pos (check_diseq t_form t_atom l)
+ | SplArith pos orig res l => S.set_clause s pos (check_spl_arith t_form t_atom (S.get s orig) res l)
+ | SplDistinctElim pos orig res => S.set_clause s pos (check_distinct_elim t_form t_atom (S.get s orig) res)
+ | BBVar pos res => S.set_clause s pos (check_bbVar t_atom t_form res)
+ | BBConst pos res => S.set_clause s pos (check_bbConst t_atom t_form res)
+ | BBOp pos orig1 orig2 res => S.set_clause s pos (check_bbOp t_atom t_form s orig1 orig2 res)
+ | BBNot pos orig res => S.set_clause s pos (check_bbNot t_atom t_form s orig res)
+ | BBNeg pos orig res => S.set_clause s pos (check_bbNeg t_atom t_form s orig res)
+ | BBAdd pos orig1 orig2 res => S.set_clause s pos (check_bbAdd t_atom t_form s orig1 orig2 res)
+ | BBConcat pos orig1 orig2 res => S.set_clause s pos (check_bbConcat t_atom t_form s orig1 orig2 res)
+ | BBMul pos orig1 orig2 res => S.set_clause s pos (check_bbMult t_atom t_form s orig1 orig2 res)
+ | BBUlt pos orig1 orig2 res => S.set_clause s pos (check_bbUlt t_atom t_form s orig1 orig2 res)
+ | BBSlt pos orig1 orig2 res => S.set_clause s pos (check_bbSlt t_atom t_form s orig1 orig2 res)
+ | BBEq pos orig1 orig2 res => S.set_clause s pos (check_bbEq t_atom t_form s orig1 orig2 res)
+ | BBDiseq pos res => S.set_clause s pos (check_bbDiseq t_atom t_form res)
+ | BBExtract pos orig res => S.set_clause s pos (check_bbExtract t_atom t_form s orig res)
+ | BBZextend pos orig res => S.set_clause s pos (check_bbZextend t_atom t_form s orig res)
+ | BBSextend pos orig res => S.set_clause s pos (check_bbSextend t_atom t_form s orig res)
+ | BBShl pos orig1 orig2 res => S.set_clause s pos (check_bbShl t_atom t_form s orig1 orig2 res)
+ | BBShr pos orig1 orig2 res => S.set_clause s pos (check_bbShr t_atom t_form s orig1 orig2 res)
+ | RowEq pos res => S.set_clause s pos (check_roweq t_form t_atom res)
+ | RowNeq pos cl => S.set_clause s pos (check_rowneq t_form t_atom cl)
+ | Ext pos res => S.set_clause s pos (check_ext t_form t_atom res)
+ end.
+
+ (* Opaque S.set_weaken. *)
+
+ Lemma step_checker_correct :
+ Form.check_form t_form -> Atom.check_atom t_atom ->
+ forall t_i t_func,
+ let rho := Form.interp_state_var (Atom.interp_form_hatom t_i t_func t_atom) (Atom.interp_form_hatom_bv t_i t_func t_atom) t_form in
+ Atom.wt t_i t_func t_atom ->
+ forall s, S.valid rho s ->
+ forall st : step, S.valid rho (step_checker s st).
+ Proof.
+ set (empty_bv := (fun (a:Atom.atom) s => BITVECTOR_LIST.zeros s)).
+ intros H1 H2 t_i t_func rho H10 s Hs. destruct (Form.check_form_correct (Atom.interp_form_hatom t_i t_func t_atom) (Atom.interp_form_hatom_bv t_i t_func t_atom) _ H1)
+ as [[Ht1 Ht2] Ht3]. destruct (Atom.check_atom_correct _ H2) as
+ [Ha1 Ha2]. intros [pos res|pos cid c|pos cid lf|pos|pos|pos l|pos l|pos l i|pos cid
+ |pos cid|pos cid i|pos l fl|pos l fl|pos l1 l2 fl|pos cl c|pos l|pos orig res l
+ |pos orig res|pos res|pos res|pos orig1 orig2 res|pos orig res|pos orig res
+ |pos orig1 orig2 res|pos orig1 orig2 res
+ |pos orig1 orig2 res|pos orig1 orig2 res|pos orig1 orig2 res|pos orig1 orig2 res
+ |pos cl |pos orig res |pos orig res |pos orig res | pos orig1 orig2 res | pos orig1 orig2 res |pos res|pos res
+ |pos res]; simpl; try apply S.valid_set_clause; auto with smtcoq_core.
+ - apply S.valid_set_resolve; auto with smtcoq_core.
+ - apply S.valid_set_weaken; auto with smtcoq_core.
+ - apply valid_check_flatten; auto with smtcoq_core; intros h1 h2 H.
+ + rewrite (Syntactic.check_hatom_correct_bool _ _ _ Ha1 Ha2 _ _ H); auto with smtcoq_core.
+ + rewrite (Syntactic.check_neg_hatom_correct_bool _ _ _ H10 Ha1 Ha2 _ _ H); auto with smtcoq_core.
+ - apply valid_check_True; auto with smtcoq_core.
+ - apply valid_check_False; auto with smtcoq_core.
+ - apply valid_check_BuildDef; auto with smtcoq_core.
+ - apply valid_check_BuildDef2; auto with smtcoq_core.
+ - apply valid_check_BuildProj; auto with smtcoq_core.
+ - apply valid_check_ImmBuildDef; auto with smtcoq_core.
+ - apply valid_check_ImmBuildDef2; auto with smtcoq_core.
+ - apply valid_check_ImmBuildProj; auto with smtcoq_core.
+ - apply valid_check_trans; auto with smtcoq_core.
+ - apply valid_check_congr; auto with smtcoq_core.
+ - apply valid_check_congr_pred; auto with smtcoq_core.
+ - apply valid_check_micromega; auto with smtcoq_core.
+ - apply valid_check_diseq; auto with smtcoq_core.
+ - apply valid_check_spl_arith; auto with smtcoq_core.
+ - apply valid_check_distinct_elim; auto with smtcoq_core.
+ - eapply valid_check_bbVar; eauto with smtcoq_core.
+ - apply valid_check_bbConst; auto with smtcoq_core.
+ - apply valid_check_bbOp; auto with smtcoq_core.
+ - apply valid_check_bbNot; auto with smtcoq_core.
+ - apply valid_check_bbNeg; auto with smtcoq_core.
+ - apply valid_check_bbAdd; auto with smtcoq_core.
+ - apply valid_check_bbConcat; auto with smtcoq_core.
+ - apply valid_check_bbMult; auto with smtcoq_core.
+ - apply valid_check_bbUlt; auto with smtcoq_core.
+ - apply valid_check_bbSlt; auto with smtcoq_core.
+ - apply valid_check_bbEq; auto with smtcoq_core.
+ - apply valid_check_bbDiseq; auto with smtcoq_core.
+ - apply valid_check_bbExtract; auto with smtcoq_core.
+ - apply valid_check_bbZextend; auto with smtcoq_core.
+ - apply valid_check_bbSextend; auto with smtcoq_core.
+ - apply valid_check_bbShl; auto with smtcoq_core.
+ - apply valid_check_bbShr; auto with smtcoq_core.
+ - apply valid_check_roweq; auto with smtcoq_core.
+ - apply valid_check_rowneq; auto with smtcoq_core.
+ - apply valid_check_ext; auto with smtcoq_core.
+ Qed.
+
+ Definition checker s t := _checker_ (step_checker) s t.
+
+ Lemma checker_correct :
+ Form.check_form t_form -> Atom.check_atom t_atom ->
+ forall t_i t_func,
+ let rho := Form.interp_state_var (Atom.interp_form_hatom t_i t_func t_atom) (Atom.interp_form_hatom_bv t_i t_func t_atom) t_form in
+ Atom.wt t_i t_func t_atom ->
+ forall s t confl,
+ checker C.is_false s t confl ->
+ ~ (S.valid rho s).
+ Proof.
+ unfold checker; intros H1 H2 t_i t_func rho H10; apply _checker__correct.
+ intros c H; apply C.is_false_correct; auto with smtcoq_core.
+ apply step_checker_correct; auto with smtcoq_core.
+ Qed.
+
+ Inductive certif :=
+ | Certif : int -> _trace_ step -> int -> certif.
+
+ Definition checker_ext d used_roots (c:certif) :=
+ let (nclauses, t, confl) := c in
+ Form.check_form t_form && Atom.check_atom t_atom &&
+ checker C.is_false (Euf_Checker.add_roots (S.make nclauses) d used_roots) t confl.
+
+ Lemma checker_ext_correct : forall d used_roots c,
+ checker_ext d used_roots c = true ->
+ forall t_i t_func, Atom.wt t_i t_func t_atom ->
+ ~ Euf_Checker.valid t_func t_atom t_form d.
+ Proof.
+ unfold checker_ext.
+ intros d used_roots (nclauses, t, confl).
+ rewrite !andb_true_iff.
+ intros [[H1 H2] H3] t_i t_func H10 H.
+ eelim checker_correct; try eassumption.
+ apply Euf_Checker.add_roots_correct; try assumption.
+ apply S.valid_make.
+ destruct (Form.check_form_correct (Atom.interp_form_hatom t_i t_func t_atom) (Atom.interp_form_hatom_bv t_i t_func t_atom) _ H1) as [_ H4]; auto with smtcoq_core.
+ Qed.
+
+ End Checker.
+
+End Checker_Ext.
+
+
(*
Local Variables:
coq-load-path: ((rec "." "SMTCoq"))
diff --git a/src/extraction/Extract.v b/src/extraction/Extract.v
index 138a2ba..da484b5 100644
--- a/src/extraction/Extract.v
+++ b/src/extraction/Extract.v
@@ -10,13 +10,12 @@
(**************************************************************************)
-Require Int63Native.
-Require Import ExtractNative.
-Require Import SMTCoq.
+Add Rec LoadPath "." as SMTCoq.
-Extract Constant Int63Native.eqb => "fun i j -> ExtrNative.compare i j = ExtrNative.Eq".
+Require Import ExtrOCamlInt63.
+Require Import SMTCoq.
Set Extraction AccessOpaque.
Extraction "extraction/sat_checker.ml" Sat_Checker.checker.
-Extraction "extraction/smt_checker.ml" Euf_Checker.checker_ext.
+Extraction "extraction/smt_checker.ml" Checker_Ext.checker_ext.
diff --git a/src/extraction/Makefile b/src/extraction/Makefile
index 354dd53..399c5cf 100644
--- a/src/extraction/Makefile
+++ b/src/extraction/Makefile
@@ -1,45 +1,56 @@
# List of user's files and name of the final program (edit this part)
-USERFILES=smtcoq.ml smtcoq.mli
-PROGRAM=smtcoq
+USERFILES=smtcoq.ml
# USERFILES=test.ml
-# PROGRAM=test
-# USERFILES=../../../../examples/example.ml
-# PROGRAM=../../../../examples/example
+PROGRAM=smtcoq
# Compilation
-COQTOP=$(COQBIN)../
+LIB=smtcoq_extr.cmx
+
+COQLIBPATH=$(shell coqtop -where)/
FLAGS=-rectypes
-COMPILEFLAGS=-cclib -lunix
+COMPILEFLAGS=-for-pack Smtcoq_extr
+PROGRAMFLAGS=-cclib -lunix -linkall
+LIBFLAGS=-cclib -lunix -pack
-SMTLIB=-I .. -I ../zchaff -I ../verit -I ../trace -I ../smtlib2 -I ../lia -I ../euf -I ../cnf -I ../../3rdparty/alt-ergo
-COQLIB=-I ${COQTOP}kernel -I ${COQTOP}lib -I ${COQTOP}library -I ${COQTOP}parsing -I ${COQTOP}pretyping -I ${COQTOP}interp -I ${COQTOP}proofs -I ${COQTOP}tactics -I ${COQTOP}toplevel -I ${COQTOP}plugins/btauto -I ${COQTOP}plugins/cc -I ${COQTOP}plugins/decl_mode -I ${COQTOP}plugins/extraction -I ${COQTOP}plugins/field -I ${COQTOP}plugins/firstorder -I ${COQTOP}plugins/fourier -I ${COQTOP}plugins/funind -I ${COQTOP}plugins/micromega -I ${COQTOP}plugins/nsatz -I ${COQTOP}plugins/omega -I ${COQTOP}plugins/quote -I ${COQTOP}plugins/ring -I ${COQTOP}plugins/romega -I ${COQTOP}plugins/rtauto -I ${COQTOP}plugins/setoid_ring -I ${COQTOP}plugins/syntax -I ${COQTOP}plugins/xml -I /usr/lib/ocaml/camlp5
+SMTLIB=-I ..
+COQLIB=-I ${COQLIBPATH}kernel -I ${COQLIBPATH}lib -I ${COQLIBPATH}library -I ${COQLIBPATH}parsing -I ${COQLIBPATH}pretyping -I ${COQLIBPATH}interp -I ${COQLIBPATH}proofs -I ${COQLIBPATH}tactics -I ${COQLIBPATH}toplevel -I ${COQLIBPATH}plugins/btauto -I ${COQLIBPATH}plugins/cc -I ${COQLIBPATH}plugins/decl_mode -I ${COQLIBPATH}plugins/extraction -I ${COQLIBPATH}plugins/field -I ${COQLIBPATH}plugins/firstorder -I ${COQLIBPATH}plugins/fourier -I ${COQLIBPATH}plugins/funind -I ${COQLIBPATH}plugins/micromega -I ${COQLIBPATH}plugins/nsatz -I ${COQLIBPATH}plugins/omega -I ${COQLIBPATH}plugins/quote -I ${COQLIBPATH}plugins/ring -I ${COQLIBPATH}plugins/romega -I ${COQLIBPATH}plugins/rtauto -I ${COQLIBPATH}plugins/setoid_ring -I ${COQLIBPATH}plugins/syntax -I ${COQLIBPATH}plugins/xml -I ${COQLIBPATH}clib -I ${COQLIBPATH}gramlib/.pack -I ${COQLIBPATH}engine -I ${COQLIBPATH}config -I ${COQLIBPATH}printing -I ${COQLIBPATH}vernac -I ${COQLIBPATH}plugins/ltac -I ${COQLIBPATH}stm -I ${COQLIBPATH}kernel/byterun
+
+COQCMX=unix.cmxa threads.cmxa nums.cmxa str.cmxa zarith.cmxa dynlink.cmxa clib.cmxa config.cmxa lib.cmxa gramlib.cmxa kernel.cmxa library.cmxa engine.cmxa pretyping.cmxa interp.cmxa proofs.cmxa parsing.cmxa printing.cmxa tactics.cmxa vernac.cmxa stm.cmxa toplevel.cmxa ltac_plugin.cmx micromega_plugin.cmx
+SMTCOQCMX=smtcoq_plugin.cmx
+
+MLIFILES=sat_checker.mli zchaff_checker.mli smt_checker.mli verit_checker.mli
+MLFILES=sat_checker.ml zchaff_checker.ml smt_checker.ml verit_checker.ml
+CMI=$(MLIFILES:%.mli=%.cmi)
+CMX=$(MLFILES:%.ml=%.cmx)
-CMXA=nums.cmxa str.cmxa unix.cmxa gramlib.cmxa dynlink.cmxa ${COQTOP}kernel/byterun/coq_fix_code.o ${COQTOP}kernel/byterun/coq_interp.o ${COQTOP}kernel/byterun/coq_memory.o ${COQTOP}kernel/byterun/coq_values.o clib.cmxa lib.cmxa kernel.cmxa library.cmxa pretyping.cmxa interp.cmxa proofs.cmxa parsing.cmxa tactics.cmxa toplevel.cmxa micromega_plugin.cmxa smtcoq.cmxa
-CMI=extrNative.cmi sat_checker.cmi zchaff_checker.cmi smt_checker.cmi verit_checker.cmi
-CMX=extrNative.cmx sat_checker.cmx zchaff_checker.cmx smt_checker.cmx verit_checker.cmx
-USERML=$(filter %.ml,$(USERFILES))
-USERCMX=$(USERML:%.ml=%.cmx)
USERMLI=$(filter %.mli,$(USERFILES))
+USERML=$(filter %.ml,$(USERFILES))
USERCMI=$(USERMLI:%.mli=%.cmi)
+USERCMX=$(USERML:%.ml=%.cmx)
OCAMLC=ocamlc
OCAMLOPT=ocamlopt
+OCAMLFIND=ocamlfind
+OCAMLFINDLIB=-I +threads -package zarith
-all: $(PROGRAM)
+all: $(LIB) $(PROGRAM)
%.cmi: %.mli
$(OCAMLC) -c $(FLAGS) $(SMTLIB) $(COQLIB) $<
%.cmx: %.ml
- $(OCAMLOPT) -c $(FLAGS) $(SMTLIB) $(COQLIB) $<
+ $(OCAMLOPT) -c $(FLAGS) $(COMPILEFLAGS) $(SMTLIB) $(COQLIB) $<
+
+$(LIB): $(CMI) $(CMX)
+ $(OCAMLFIND) $(OCAMLOPT) $(FLAGS) $(OCAMLFINDLIB) $(SMTLIB) $(COQLIB) -o $@ $(LIBFLAGS) $(CMX)
-$(PROGRAM): $(CMI) $(CMX) $(USERCMI) $(USERCMX)
- $(OCAMLOPT) $(FLAGS) $(SMTLIB) $(COQLIB) -o $@ $(COMPILEFLAGS) $(CMXA) $(CMX) $(USERCMX)
+$(PROGRAM): $(LIB) $(USERCMI) $(USERCMX)
+ $(OCAMLFIND) $(OCAMLOPT) $(FLAGS) $(OCAMLFINDLIB) $(SMTLIB) $(COQLIB) -o $@ $(PROGRAMFLAGS) $(COQCMX) $(SMTCOQCMX) $(LIB) $(USERCMX)
.PHONY: clean mrproper
diff --git a/src/extraction/extrNative.ml b/src/extraction/extrNative.ml
deleted file mode 100644
index cc366db..0000000
--- a/src/extraction/extrNative.ml
+++ /dev/null
@@ -1,344 +0,0 @@
-(**************************************************************************)
-(* *)
-(* 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 comparison = Eq | Lt | Gt
-
-type 'a carry = C0 of 'a | C1 of 'a
-
-type uint = int
-
- (* to be used only on 32 bits achitectures *)
-let maxuint31 = Int32.of_string "0x7FFFFFFF"
-let uint_32 i = Int32.logand (Int32.of_int i) maxuint31
-
-let select f32 f64 = if Sys.word_size = 64 then f64 else f32
-
- (* conversion to an int *)
-let to_int i = i
-
-let of_int_32 i = i
-let of_int_64 i = i land 0x7FFFFFFF
-
-let of_int = select of_int_32 of_int_64
-let of_uint i = i
-
- (* convertion of an uint31 to a string *)
-let to_string_32 i = Int32.to_string (uint_32 i)
-let to_string_64 = string_of_int
-
-let to_string = select to_string_32 to_string_64
-let of_string s =
- let i32 = Int32.of_string s in
- if Int32.compare Int32.zero i32 <= 0
- && Int32.compare i32 maxuint31 <= 0
- then Int32.to_int i32
- else raise (Failure "int_of_string")
-
-
-
- (* logical shift *)
-let l_sl x y =
- of_int (if 0 <= y && y < 31 then x lsl y else 0)
-
-let l_sr x y =
- if 0 <= y && y < 31 then x lsr y else 0
-
-let l_and x y = x land y
-let l_or x y = x lor y
-let l_xor x y = x lxor y
-
- (* addition of int31 *)
-let add x y = of_int (x + y)
-
- (* subtraction *)
-let sub x y = of_int (x - y)
-
- (* multiplication *)
-let mul x y = of_int (x * y)
-
- (* exact multiplication *)
-let mulc_32 x y =
- let x = Int64.of_int32 (uint_32 x) in
- let y = Int64.of_int32 (uint_32 y) in
- let m = Int64.mul x y in
- let l = Int64.to_int m in
- let h = Int64.to_int (Int64.shift_right_logical m 31) in
- h,l
-
-let mulc_64 x y =
- let m = x * y in
- let l = of_int_64 m in
- let h = of_int_64 (m lsr 31) in
- h, l
-let mulc = select mulc_32 mulc_64
-
- (* division *)
-let div_32 x y =
- if y = 0 then 0 else
- Int32.to_int (Int32.div (uint_32 x) (uint_32 y))
-let div_64 x y = if y = 0 then 0 else x / y
-let div = select div_32 div_64
-
- (* modulo *)
-let rem_32 x y =
- if y = 0 then 0
- else Int32.to_int (Int32.rem (uint_32 x) (uint_32 y))
-let rem_64 x y = if y = 0 then 0 else x mod y
-let rem = select rem_32 rem_64
-
- (* division of two numbers by one *)
-let div21_32 xh xl y =
- if y = 0 then (0,0)
- else
- let x =
- Int64.logor
- (Int64.shift_left (Int64.of_int32 (uint_32 xh)) 31)
- (Int64.of_int32 (uint_32 xl)) in
- let y = Int64.of_int32 (uint_32 y) in
- let q = Int64.div x y in
- let r = Int64.rem x y in
- Int64.to_int q, Int64.to_int r
-let div21_64 xh xl y =
- if y = 0 then (0,0)
- else
- let x = (xh lsl 31) lor xl in
- let q = x / y in
- let r = x mod y in
- q, r
-let div21 = select div21_32 div21_64
-
- (* comparison *)
-let lt_32 x y = (x lxor 0x40000000) < (y lxor 0x40000000)
-(* if 0 <= x then
- if 0 <= y then x < y
- else true
- else if 0 <= y then false
- else x < y *)
-(* Int32.compare (uint_32 x) (uint_32 y) < 0 *)
-
-let lt_64 x y = x < y
-let lt = select lt_32 lt_64
-
-let le_32 x y =
- (x lxor 0x40000000) <= (y lxor 0x40000000)
-(*
- if 0 <= x then
- if 0 <= y then x <= y
- else true
- else if 0 <= y then false
- else x <= y
-*)
-(*Int32.compare (uint_32 x) (uint_32 y) <= 0*)
-let le_64 x y = x <= y
-let le = select le_32 le_64
-
-let eq x y = x == y
-
-let cmp_32 x y = Int32.compare (uint_32 x) (uint_32 y)
-let cmp_64 x y = compare x y
-let compare = select cmp_32 cmp_64
-
-let compare x y =
- match compare x y with
- | x when x < 0 -> Lt
- | 0 -> Eq
- | _ -> Gt
-
- (* head tail *)
-
-let head0 x =
- let r = ref 0 in
- let x = ref x in
- if !x land 0x7FFF0000 = 0 then r := !r + 15
- else x := !x lsr 15;
- if !x land 0xFF00 = 0 then (x := !x lsl 8; r := !r + 8);
- if !x land 0xF000 = 0 then (x := !x lsl 4; r := !r + 4);
- if !x land 0xC000 = 0 then (x := !x lsl 2; r := !r + 2);
- if !x land 0x8000 = 0 then (x := !x lsl 1; r := !r + 1);
- if !x land 0x8000 = 0 then ( r := !r + 1);
- !r;;
-
-let tail0 x =
- let r = ref 0 in
- let x = ref x in
- if !x land 0xFFFF = 0 then (x := !x lsr 16; r := !r + 16);
- if !x land 0xFF = 0 then (x := !x lsr 8; r := !r + 8);
- if !x land 0xF = 0 then (x := !x lsr 4; r := !r + 4);
- if !x land 0x3 = 0 then (x := !x lsr 2; r := !r + 2);
- if !x land 0x1 = 0 then ( r := !r + 1);
- !r
-
-let addc x y =
- let s = add x y in
- if lt s x then C1 s else C0 s
-
-let addcarryc x y =
- let s = add (x+1) y in
- if le s x then C1 s else C0 s
-
-let subc x y =
- let s = sub x y in
- if lt x y then C1 s else C0 s
-
-let subcarryc x y =
- let s = sub (x-1) y in
- if le x y then C1 s else C0 s
-
-let diveucl x y = div x y, rem x y
-
-let diveucl_21 = div21
-
-let addmuldiv p i j =
- let p' = to_int p in
- of_uint (l_or
- (l_sl i p)
- (l_sr j (of_int (31 - p'))))
-
-let rec foldi_cont f min max cont a =
- if lt min max then f min (foldi_cont f (add min 1) max cont) a
- else if min = max then f min cont a
- else cont a
-
-let rec foldi_down_cont f max min cont a =
- if lt min max then
- f max (foldi_down_cont f (sub max 1) min cont) a
- else if min = max then f min cont a
- else cont a
-
-let print_uint x =
- Printf.fprintf stderr "%s" (to_string x);
- flush stderr;
- x
-
-(* Les Tableaux maintenant *)
-
-let max_array_length32 = 4194303 (* Sys.max_array_length on arch32 *)
-
-type 'a parray = ('a kind) ref
-and 'a kind =
- | Array of 'a array
- (* | Matrix of 'a array array *)
- | Updated of int * 'a * 'a parray
-
-let of_array t = ref (Array t)
-
-let parray_make n def =
- let n = to_int n in
- let n =
- if 0 <= n && n < max_array_length32 then n + 1
- else max_array_length32 in
- ref (Array (Array.make n def))
-
-let rec get_updated p n =
- match !p with
- | Array t ->
- let l = Array.length t in
- if 0 <= n && n < l then Array.unsafe_get t n
- else (Array.unsafe_get t (l-1))
- | Updated (k,e,p) -> if n = k then e else get_updated p n
-
-let parray_get p n =
- let n = to_int n in
- match !p with
- | Array t ->
- let l = Array.length t in
- if 0 <= n && n < l then Array.unsafe_get t n
- else (Array.unsafe_get t (l-1))
- | Updated _ -> get_updated p n
-
-
-let rec default_updated p =
- match !p with
- | Array t -> Array.unsafe_get t (Array.length t - 1)
- | Updated (_,_,p) -> default_updated p
-
-let parray_default p =
- match !p with
- | Array t -> Array.unsafe_get t (Array.length t - 1)
- | Updated (_,_,p) -> default_updated p
-
-let rec length p =
- match !p with
- | Array t -> of_int (Array.length t - 1) (* The default value *)
- | Updated (_, _, p) -> length p
-
-let parray_length p =
- match !p with
- | Array t -> of_int (Array.length t - 1)
- | Updated (_, _, p) -> length p
-
-let parray_set p n e =
- let kind = !p in
- let n = to_int n in
- match kind with
- | Array t ->
- if 0 <= n && n < Array.length t - 1 then
- let res = ref kind in
- p := Updated (n, Array.unsafe_get t n, res);
- Array.unsafe_set t n e;
- res
- else p
- | Updated _ ->
- if 0 <= n && n < to_int (parray_length p) then
- ref (Updated(n, e, p))
- else p
-
-
-let rec copy_updated p =
- match !p with
- | Array t -> Array.copy t
- | Updated (n,e,p) ->
- let t = copy_updated p in
- Array.unsafe_set t n e; t
-
-let parray_copy p =
- let t =
- match !p with
- | Array t -> Array.copy t
- | Updated _ -> copy_updated p in
- ref (Array t)
-
-let rec rerootk t k =
- match !t with
- | Array _ -> k ()
- | Updated (i, v, t') ->
- let k' () =
- begin match !t' with
- | Array a as n ->
- let v' = a.(i) in
- a.(i) <- v;
- t := n;
- t' := Updated (i, v', t)
- | Updated _ -> assert false
- end; k() in
- rerootk t' k'
-
-let parray_reroot t = rerootk t (fun () -> t)
-
-let parray_init n f def =
- let n = to_int n in
- let n =
- if 0 <= n && n < max_array_length32 then n + 1
- else max_array_length32 in
- let t = Array.make n def in
- for i = 0 to n - 2 do Array.unsafe_set t i (f i) done;
- ref (Array t)
-
-let parray_map f p =
- match !p with
- | Array t -> ref (Array (Array.map f t))
- | _ ->
- let len = to_int (length p) in
- ref (Array
- (Array.init (len + 1)
- (fun i -> f (parray_get p (of_int i)))))
-
diff --git a/src/extraction/extrNative.mli b/src/extraction/extrNative.mli
deleted file mode 100644
index 775f187..0000000
--- a/src/extraction/extrNative.mli
+++ /dev/null
@@ -1,79 +0,0 @@
-(**************************************************************************)
-(* *)
-(* 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 comparison = Eq | Lt | Gt
-type 'a carry = C0 of 'a | C1 of 'a
-
-(*s Unsigned Int *)
-type uint
-
-(* Conversion with int *)
-val to_int : uint -> int
-val of_int : int -> uint
-val of_uint : int -> uint
-
-(* Conversion with string *)
-val to_string : uint -> string
-val of_string : string -> uint
-
-(* logical operations *)
-val l_sl : uint -> uint -> uint
-val l_sr : uint -> uint -> uint
-val l_and : uint -> uint -> uint
-val l_or : uint -> uint -> uint
-val l_xor : uint -> uint -> uint
-
-(* arithmetic operations *)
-val add : uint -> uint -> uint
-val sub : uint -> uint -> uint
-val mul : uint -> uint -> uint
-val mulc : uint -> uint -> uint * uint
-val div : uint -> uint -> uint
-val rem : uint -> uint -> uint
-
-val lt : uint -> uint -> bool
-val le : uint -> uint -> bool
-val eq : uint -> uint -> bool
-val compare : uint -> uint -> comparison
-
-val head0 : uint -> uint
-val tail0 : uint -> uint
-
-val addc : uint -> uint -> uint carry
-val addcarryc : uint -> uint -> uint carry
-val subc : uint -> uint -> uint carry
-val subcarryc : uint -> uint -> uint carry
-val diveucl : uint -> uint -> uint * uint
-val diveucl_21 : uint -> uint -> uint -> uint * uint
-val addmuldiv : uint -> uint -> uint -> uint
-
-val foldi_cont :
- (uint -> ('a -> 'b) -> 'a -> 'b) -> uint -> uint -> ('a -> 'b) -> 'a -> 'b
-val foldi_down_cont :
- (uint -> ('a -> 'b) -> 'a -> 'b) -> uint -> uint -> ('a -> 'b) -> 'a -> 'b
-val print_uint : uint -> uint
-
-
-(*s Persistant array *)
-
-type 'a parray
-
-val of_array : 'a array -> 'a parray
-
-val parray_make : uint -> 'a -> 'a parray
-val parray_get : 'a parray -> uint -> 'a
-val parray_default : 'a parray -> 'a
-val parray_length : 'a parray -> uint
-val parray_set : 'a parray -> uint -> 'a -> 'a parray
-val parray_copy : 'a parray -> 'a parray
-val parray_reroot : 'a parray -> 'a parray
-
diff --git a/src/extraction/sat_checker.ml b/src/extraction/sat_checker.ml
index 839f95b..9d881f4 100644
--- a/src/extraction/sat_checker.ml
+++ b/src/extraction/sat_checker.ml
@@ -1,14 +1,6 @@
-(**************************************************************************)
-(* *)
-(* 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
+let __ = let rec f _ = Obj.repr f in Obj.repr f
(** val negb : bool -> bool **)
@@ -16,232 +8,2400 @@ let negb = function
| true -> false
| false -> true
+type nat =
+| O
+| S of nat
+
+type 'a option =
+| Some of 'a
+| None
+
+(** val fst : ('a1 * 'a2) -> 'a1 **)
+
+let fst = function
+| (x, _) -> x
+
+(** val snd : ('a1 * 'a2) -> 'a2 **)
+
+let snd = function
+| (_, y) -> y
+
type 'a list =
| Nil
| Cons of 'a * 'a list
-(** val existsb : ('a1 -> bool) -> 'a1 list -> bool **)
+(** val app : 'a1 list -> 'a1 list -> 'a1 list **)
+
+let rec app l m =
+ match l with
+ | Nil -> m
+ | Cons (a, l1) -> Cons (a, (app l1 m))
+
+(** val compOpp : int -> int **)
+
+let compOpp = function
+| 0 -> 0
+| (-1) -> 1
+| 1 -> (-1)
+
+type sumbool =
+| Left
+| Right
+
+(** val add : nat -> nat -> nat **)
+
+let rec add n m =
+ match n with
+ | O -> m
+ | S p -> S (add p m)
+
+type positive =
+| XI of positive
+| XO of positive
+| XH
+
+type z =
+| Z0
+| Zpos of positive
+| Zneg of positive
+
+module type EqLtLe =
+ sig
+ type t
+ end
+
+module MakeOrderTac =
+ functor (O:EqLtLe) ->
+ functor (P:sig
+ end) ->
+ struct
+ end
+
+module Pos =
+ struct
+ (** val succ : positive -> positive **)
+
+ let rec succ = function
+ | XI p -> XO (succ p)
+ | XO p -> XI p
+ | XH -> XO XH
+
+ (** val add : positive -> positive -> positive **)
+
+ let rec add x y =
+ match x with
+ | XI p ->
+ (match y with
+ | XI q -> XO (add_carry p q)
+ | XO q -> XI (add p q)
+ | XH -> XO (succ p))
+ | XO p ->
+ (match y with
+ | XI q -> XI (add p q)
+ | XO q -> XO (add p q)
+ | XH -> XI p)
+ | XH -> (match y with
+ | XI q -> XO (succ q)
+ | XO q -> XI q
+ | XH -> XO XH)
+
+ (** val add_carry : positive -> positive -> positive **)
+
+ and add_carry x y =
+ match x with
+ | XI p ->
+ (match y with
+ | XI q -> XI (add_carry p q)
+ | XO q -> XO (add_carry p q)
+ | XH -> XI (succ p))
+ | XO p ->
+ (match y with
+ | XI q -> XO (add_carry p q)
+ | XO q -> XI (add p q)
+ | XH -> XO (succ p))
+ | XH ->
+ (match y with
+ | XI q -> XI (succ q)
+ | XO q -> XO (succ q)
+ | XH -> XI XH)
+
+ (** val pred_double : positive -> positive **)
+
+ let rec pred_double = function
+ | XI p -> XI (XO p)
+ | XO p -> XI (pred_double p)
+ | XH -> XH
+
+ (** val mul : positive -> positive -> positive **)
+
+ let rec mul x y =
+ match x with
+ | XI p -> add y (XO (mul p y))
+ | XO p -> XO (mul p y)
+ | XH -> y
+
+ (** val compare_cont : int -> positive -> positive -> int **)
+
+ let rec compare_cont r x y =
+ match x with
+ | XI p ->
+ (match y with
+ | XI q -> compare_cont r p q
+ | XO q -> compare_cont 1 p q
+ | XH -> 1)
+ | XO p ->
+ (match y with
+ | XI q -> compare_cont (-1) p q
+ | XO q -> compare_cont r p q
+ | XH -> 1)
+ | XH -> (match y with
+ | XH -> r
+ | _ -> (-1))
+
+ (** val compare : positive -> positive -> int **)
+
+ let compare =
+ compare_cont 0
+
+ (** val eqb : positive -> positive -> bool **)
+
+ let rec eqb p q =
+ match p with
+ | XI p0 -> (match q with
+ | XI q0 -> eqb p0 q0
+ | _ -> false)
+ | XO p0 -> (match q with
+ | XO q0 -> eqb p0 q0
+ | _ -> false)
+ | XH -> (match q with
+ | XH -> true
+ | _ -> false)
+
+ (** val eq_dec : positive -> positive -> sumbool **)
+
+ let rec eq_dec p x0 =
+ match p with
+ | XI p0 -> (match x0 with
+ | XI p1 -> eq_dec p0 p1
+ | _ -> Right)
+ | XO p0 -> (match x0 with
+ | XO p1 -> eq_dec p0 p1
+ | _ -> Right)
+ | XH -> (match x0 with
+ | XH -> Left
+ | _ -> Right)
+ end
+
+module Z =
+ struct
+ (** val double : z -> z **)
+
+ let double = function
+ | Z0 -> Z0
+ | Zpos p -> Zpos (XO p)
+ | Zneg p -> Zneg (XO p)
+
+ (** val succ_double : z -> z **)
+
+ let succ_double = function
+ | Z0 -> Zpos XH
+ | Zpos p -> Zpos (XI p)
+ | Zneg p -> Zneg (Pos.pred_double p)
+
+ (** val pred_double : z -> z **)
+
+ let pred_double = function
+ | Z0 -> Zneg XH
+ | Zpos p -> Zpos (Pos.pred_double p)
+ | Zneg p -> Zneg (XI p)
+
+ (** val pos_sub : positive -> positive -> z **)
+
+ let rec pos_sub x y =
+ match x with
+ | XI p ->
+ (match y with
+ | XI q -> double (pos_sub p q)
+ | XO q -> succ_double (pos_sub p q)
+ | XH -> Zpos (XO p))
+ | XO p ->
+ (match y with
+ | XI q -> pred_double (pos_sub p q)
+ | XO q -> double (pos_sub p q)
+ | XH -> Zpos (Pos.pred_double p))
+ | XH ->
+ (match y with
+ | XI q -> Zneg (XO q)
+ | XO q -> Zneg (Pos.pred_double q)
+ | XH -> Z0)
+
+ (** val add : z -> z -> z **)
+
+ let add x y =
+ match x with
+ | Z0 -> y
+ | Zpos x' ->
+ (match y with
+ | Z0 -> x
+ | Zpos y' -> Zpos (Pos.add x' y')
+ | Zneg y' -> pos_sub x' y')
+ | Zneg x' ->
+ (match y with
+ | Z0 -> x
+ | Zpos y' -> pos_sub y' x'
+ | Zneg y' -> Zneg (Pos.add x' y'))
+
+ (** val opp : z -> z **)
+
+ let opp = function
+ | Z0 -> Z0
+ | Zpos x0 -> Zneg x0
+ | Zneg x0 -> Zpos x0
+
+ (** val sub : z -> z -> z **)
+
+ let sub m n =
+ add m (opp n)
+
+ (** val mul : z -> z -> z **)
+
+ let mul x y =
+ match x with
+ | Z0 -> Z0
+ | Zpos x' ->
+ (match y with
+ | Z0 -> Z0
+ | Zpos y' -> Zpos (Pos.mul x' y')
+ | Zneg y' -> Zneg (Pos.mul x' y'))
+ | Zneg x' ->
+ (match y with
+ | Z0 -> Z0
+ | Zpos y' -> Zneg (Pos.mul x' y')
+ | Zneg y' -> Zpos (Pos.mul x' y'))
+
+ (** val compare : z -> z -> int **)
+
+ let compare x y =
+ match x with
+ | Z0 -> (match y with
+ | Z0 -> 0
+ | Zpos _ -> (-1)
+ | Zneg _ -> 1)
+ | Zpos x' -> (match y with
+ | Zpos y' -> Pos.compare x' y'
+ | _ -> 1)
+ | Zneg x' ->
+ (match y with
+ | Zneg y' -> compOpp (Pos.compare x' y')
+ | _ -> (-1))
+
+ (** val leb : z -> z -> bool **)
+
+ let leb x y =
+ match compare x y with
+ | 1 -> false
+ | _ -> true
+
+ (** val ltb : z -> z -> bool **)
+
+ let ltb x y =
+ match compare x y with
+ | (-1) -> true
+ | _ -> false
+
+ (** val eqb : z -> z -> bool **)
+
+ let eqb x y =
+ match x with
+ | Z0 -> (match y with
+ | Z0 -> true
+ | _ -> false)
+ | Zpos p -> (match y with
+ | Zpos q -> Pos.eqb p q
+ | _ -> false)
+ | Zneg p -> (match y with
+ | Zneg q -> Pos.eqb p q
+ | _ -> false)
-let rec existsb f = function
-| Nil -> false
-| Cons (a, l0) -> if f a then true else existsb f l0
+ (** val max : z -> z -> z **)
-type int = ExtrNative.uint
+ let max n m =
+ match compare n m with
+ | (-1) -> m
+ | _ -> n
-(** val lsl0 : int -> int -> int **)
+ (** val eq_dec : z -> z -> sumbool **)
-let lsl0 = ExtrNative.l_sl
+ let eq_dec x y =
+ match x with
+ | Z0 -> (match y with
+ | Z0 -> Left
+ | _ -> Right)
+ | Zpos x0 -> (match y with
+ | Zpos p0 -> Pos.eq_dec x0 p0
+ | _ -> Right)
+ | Zneg x0 -> (match y with
+ | Zneg p0 -> Pos.eq_dec x0 p0
+ | _ -> Right)
+ end
+
+(** val rev : 'a1 list -> 'a1 list **)
+
+let rec rev = function
+| Nil -> Nil
+| Cons (x, l') -> app (rev l') (Cons (x, Nil))
+
+(** val fold_left : ('a1 -> 'a2 -> 'a1) -> 'a2 list -> 'a1 -> 'a1 **)
+
+let rec fold_left f l a0 =
+ match l with
+ | Nil -> a0
+ | Cons (b, t0) -> fold_left f t0 (f a0 b)
+
+(** val fold_right : ('a2 -> 'a1 -> 'a1) -> 'a1 -> 'a2 list -> 'a1 **)
+
+let rec fold_right f a0 = function
+| Nil -> a0
+| Cons (b, t0) -> f b (fold_right f a0 t0)
+
+(** val size : nat **)
-(** val lsr0 : int -> int -> int **)
+let size =
+ S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S
+ (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S
+ (S (S (S (S (S (S (S (S (S (S (S (S (S (S
+ O))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
-let lsr0 = ExtrNative.l_sr
+(** val lsl0 : Uint63.t -> Uint63.t -> Uint63.t **)
-(** val land0 : int -> int -> int **)
+let lsl0 = Uint63.l_sl
-let land0 = ExtrNative.l_and
+(** val lsr0 : Uint63.t -> Uint63.t -> Uint63.t **)
-(** val lxor0 : int -> int -> int **)
+let lsr0 = Uint63.l_sr
-let lxor0 = ExtrNative.l_xor
+(** val lxor0 : Uint63.t -> Uint63.t -> Uint63.t **)
-(** val sub : int -> int -> int **)
+let lxor0 = Uint63.l_xor
-let sub = ExtrNative.sub
+(** val add0 : Uint63.t -> Uint63.t -> Uint63.t **)
-(** val eqb : int -> int -> bool **)
+let add0 = Uint63.add
-let eqb = fun i j -> ExtrNative.compare i j = ExtrNative.Eq
+(** val sub0 : Uint63.t -> Uint63.t -> Uint63.t **)
-(** val foldi_cont :
- (int -> ('a1 -> 'a2) -> 'a1 -> 'a2) -> int -> int -> ('a1 -> 'a2) -> 'a1
- -> 'a2 **)
+let sub0 = Uint63.sub
-let foldi_cont = ExtrNative.foldi_cont
+(** val eqb0 : Uint63.t -> Uint63.t -> bool **)
-(** val foldi_down_cont :
- (int -> ('a1 -> 'a2) -> 'a1 -> 'a2) -> int -> int -> ('a1 -> 'a2) -> 'a1
- -> 'a2 **)
+let eqb0 = Uint63.equal
-let foldi_down_cont = ExtrNative.foldi_down_cont
+(** val ltb0 : Uint63.t -> Uint63.t -> bool **)
-(** val is_zero : int -> bool **)
+let ltb0 = Uint63.lt
+
+(** val leb0 : Uint63.t -> Uint63.t -> bool **)
+
+let leb0 = Uint63.le
+
+(** val digits : Uint63.t **)
+
+let digits =
+ (Uint63.of_int (63))
+
+(** val is_zero : Uint63.t -> bool **)
let is_zero i =
- eqb i (ExtrNative.of_uint(0))
+ eqb0 i (Uint63.of_int (0))
-(** val is_even : int -> bool **)
+(** val bit : Uint63.t -> Uint63.t -> bool **)
-let is_even i =
- is_zero (land0 i (ExtrNative.of_uint(1)))
+let bit i n =
+ negb (is_zero (lsl0 (lsr0 i n) (sub0 digits (Uint63.of_int (1)))))
-(** val compare : int -> int -> ExtrNative.comparison **)
+(** val compare0 : Uint63.t -> Uint63.t -> int **)
-let compare = ExtrNative.compare
+let compare0 = Uint63.compare
-(** val foldi : (int -> 'a1 -> 'a1) -> int -> int -> 'a1 -> 'a1 **)
+type 'x compare1 =
+| LT
+| EQ
+| GT
-let foldi f from to0 =
- foldi_cont (fun i cont a -> cont (f i a)) from to0 (fun a -> a)
+module type OrderedType =
+ sig
+ type t
-(** val foldi_down : (int -> 'a1 -> 'a1) -> int -> int -> 'a1 -> 'a1 **)
+ val compare : t -> t -> t compare1
-let foldi_down f from downto0 =
- foldi_down_cont (fun i cont a -> cont (f i a)) from downto0 (fun a -> a)
+ val eq_dec : t -> t -> sumbool
+ end
-type 'a array = 'a ExtrNative.parray
+module OrderedTypeFacts =
+ functor (O:OrderedType) ->
+ struct
+ module TO =
+ struct
+ type t = O.t
+ end
-(** val make : int -> 'a1 -> 'a1 array **)
+ module IsTO =
+ struct
+ end
-let make = ExtrNative.parray_make
+ module OrderTac = MakeOrderTac(TO)(IsTO)
-module Coq__1 = struct
- (** val get : 'a1 array -> int -> 'a1 **)
-
- let get = ExtrNative.parray_get
-end
-let get = Coq__1.get
+ (** val eq_dec : O.t -> O.t -> sumbool **)
-(** val set : 'a1 array -> int -> 'a1 -> 'a1 array **)
+ let eq_dec =
+ O.eq_dec
-let set = ExtrNative.parray_set
+ (** val lt_dec : O.t -> O.t -> sumbool **)
-(** val length : 'a1 array -> int **)
+ let lt_dec x y =
+ match O.compare x y with
+ | LT -> Left
+ | _ -> Right
-let length = ExtrNative.parray_length
+ (** val eqb : O.t -> O.t -> bool **)
-(** val to_list : 'a1 array -> 'a1 list **)
+ let eqb x y =
+ match eq_dec x y with
+ | Left -> true
+ | Right -> false
+ end
-let to_list t0 =
- let len = length t0 in
- if eqb (ExtrNative.of_uint(0)) len
- then Nil
- else foldi_down (fun i l -> Cons ((get t0 i), l))
- (sub len (ExtrNative.of_uint(1))) (ExtrNative.of_uint(0)) Nil
+module KeyOrderedType =
+ functor (O:OrderedType) ->
+ struct
+ module MO = OrderedTypeFacts(O)
+ end
-(** val fold_left : ('a1 -> 'a2 -> 'a1) -> 'a1 -> 'a2 array -> 'a1 **)
+module Raw =
+ functor (X:OrderedType) ->
+ struct
+ module MX = OrderedTypeFacts(X)
-let fold_left f a t0 =
- let len = length t0 in
- if eqb (ExtrNative.of_uint(0)) len
- then a
- else foldi (fun i a0 -> f a0 (get t0 i)) (ExtrNative.of_uint(0))
- (sub (length t0) (ExtrNative.of_uint(1))) a
-
-(** val foldi_right :
- (int -> 'a1 -> 'a2 -> 'a2) -> 'a1 array -> 'a2 -> 'a2 **)
-
-let foldi_right f t0 b =
- let len = length t0 in
- if eqb (ExtrNative.of_uint(0)) len
- then b
- else foldi_down (fun i b0 -> f i (get t0 i) b0)
- (sub len (ExtrNative.of_uint(1))) (ExtrNative.of_uint(0)) b
-
-module Valuation =
- struct
- type t = int -> bool
+ module PX = KeyOrderedType(X)
+
+ type key = X.t
+
+ type 'elt t = (X.t * 'elt) list
+
+ (** val empty : 'a1 t **)
+
+ let empty =
+ Nil
+
+ (** val is_empty : 'a1 t -> bool **)
+
+ let is_empty = function
+ | Nil -> true
+ | Cons (_, _) -> false
+
+ (** val mem : key -> 'a1 t -> bool **)
+
+ let rec mem k = function
+ | Nil -> false
+ | Cons (p, l) ->
+ let (k', _) = p in
+ (match X.compare k k' with
+ | LT -> false
+ | EQ -> true
+ | GT -> mem k l)
+
+ 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 **)
+
+ let rec coq_R_mem_rect k f f0 f1 f2 _ _ = function
+ | R_mem_0 s -> f s __
+ | R_mem_1 (s, k', _x, l) -> f0 s k' _x l __ __ __
+ | R_mem_2 (s, k', _x, l) -> f1 s k' _x l __ __ __
+ | R_mem_3 (s, k', _x, l, _res, r0) ->
+ f2 s k' _x l __ __ __ _res r0 (coq_R_mem_rect k f f0 f1 f2 l _res r0)
+
+ (** 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 **)
+
+ let rec coq_R_mem_rec k f f0 f1 f2 _ _ = function
+ | R_mem_0 s -> f s __
+ | R_mem_1 (s, k', _x, l) -> f0 s k' _x l __ __ __
+ | R_mem_2 (s, k', _x, l) -> f1 s k' _x l __ __ __
+ | R_mem_3 (s, k', _x, l, _res, r0) ->
+ f2 s k' _x l __ __ __ _res r0 (coq_R_mem_rec k f f0 f1 f2 l _res r0)
+
+ (** 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 **)
+
+ let rec mem_rect k f2 f1 f0 f s =
+ let f3 = f2 s in
+ let f4 = f1 s in
+ let f5 = f0 s in
+ let f6 = f s in
+ (match s with
+ | Nil -> f3 __
+ | Cons (p, l) ->
+ let (t0, e) = p in
+ let f7 = f6 t0 e l __ in
+ let f8 = fun _ _ -> let hrec = mem_rect k f2 f1 f0 f l in f7 __ __ hrec
+ in
+ let f9 = f5 t0 e l __ in
+ let f10 = f4 t0 e l __ in
+ (match X.compare k t0 with
+ | LT -> f10 __ __
+ | EQ -> f9 __ __
+ | GT -> f8 __ __))
+
+ (** 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 **)
+
+ let mem_rec =
+ mem_rect
+
+ (** val coq_R_mem_correct : key -> 'a1 t -> bool -> 'a1 coq_R_mem **)
+
+ let coq_R_mem_correct k s _res =
+ Obj.magic mem_rect k (fun y _ _ _ -> R_mem_0 y)
+ (fun y y0 y1 y2 _ _ _ _ _ -> R_mem_1 (y, y0, y1, y2))
+ (fun y y0 y1 y2 _ _ _ _ _ -> R_mem_2 (y, y0, y1, y2))
+ (fun y y0 y1 y2 _ _ _ y6 _ _ -> R_mem_3 (y, y0, y1, y2, (mem k y2),
+ (y6 (mem k y2) __))) s _res __
+
+ (** val find : key -> 'a1 t -> 'a1 option **)
+
+ let rec find k = function
+ | Nil -> None
+ | Cons (p, s') ->
+ let (k', x) = p in
+ (match X.compare k k' with
+ | LT -> None
+ | EQ -> Some x
+ | GT -> find k s')
+
+ 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 **)
+
+ let rec coq_R_find_rect k f f0 f1 f2 _ _ = function
+ | R_find_0 s -> f s __
+ | R_find_1 (s, k', x, s') -> f0 s k' x s' __ __ __
+ | R_find_2 (s, k', x, s') -> f1 s k' x s' __ __ __
+ | R_find_3 (s, k', x, s', _res, r0) ->
+ f2 s k' x s' __ __ __ _res r0 (coq_R_find_rect k f f0 f1 f2 s' _res r0)
+
+ (** 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 **)
+
+ let rec coq_R_find_rec k f f0 f1 f2 _ _ = function
+ | R_find_0 s -> f s __
+ | R_find_1 (s, k', x, s') -> f0 s k' x s' __ __ __
+ | R_find_2 (s, k', x, s') -> f1 s k' x s' __ __ __
+ | R_find_3 (s, k', x, s', _res, r0) ->
+ f2 s k' x s' __ __ __ _res r0 (coq_R_find_rec k f f0 f1 f2 s' _res r0)
+
+ (** 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 **)
+
+ let rec find_rect k f2 f1 f0 f s =
+ let f3 = f2 s in
+ let f4 = f1 s in
+ let f5 = f0 s in
+ let f6 = f s in
+ (match s with
+ | Nil -> f3 __
+ | Cons (p, l) ->
+ let (t0, e) = p in
+ let f7 = f6 t0 e l __ in
+ let f8 = fun _ _ ->
+ let hrec = find_rect k f2 f1 f0 f l in f7 __ __ hrec
+ in
+ let f9 = f5 t0 e l __ in
+ let f10 = f4 t0 e l __ in
+ (match X.compare k t0 with
+ | LT -> f10 __ __
+ | EQ -> f9 __ __
+ | GT -> f8 __ __))
+
+ (** 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 **)
+
+ let find_rec =
+ find_rect
+
+ (** val coq_R_find_correct :
+ key -> 'a1 t -> 'a1 option -> 'a1 coq_R_find **)
+
+ let coq_R_find_correct k s _res =
+ Obj.magic find_rect k (fun y _ _ _ -> R_find_0 y)
+ (fun y y0 y1 y2 _ _ _ _ _ -> R_find_1 (y, y0, y1, y2))
+ (fun y y0 y1 y2 _ _ _ _ _ -> R_find_2 (y, y0, y1, y2))
+ (fun y y0 y1 y2 _ _ _ y6 _ _ -> R_find_3 (y, y0, y1, y2, (find k y2),
+ (y6 (find k y2) __))) s _res __
+
+ (** val add : key -> 'a1 -> 'a1 t -> 'a1 t **)
+
+ let rec add k x s = match s with
+ | Nil -> Cons ((k, x), Nil)
+ | Cons (p, l) ->
+ let (k', y) = p in
+ (match X.compare k k' with
+ | LT -> Cons ((k, x), s)
+ | EQ -> Cons ((k, x), l)
+ | GT -> Cons ((k', y), (add k x l)))
+
+ 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 **)
+
+ let rec coq_R_add_rect k x f f0 f1 f2 _ _ = function
+ | R_add_0 s -> f s __
+ | R_add_1 (s, k', y, l) -> f0 s k' y l __ __ __
+ | R_add_2 (s, k', y, l) -> f1 s k' y l __ __ __
+ | R_add_3 (s, k', y, l, _res, r0) ->
+ f2 s k' y l __ __ __ _res r0 (coq_R_add_rect k x f f0 f1 f2 l _res r0)
+
+ (** 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 **)
+
+ let rec coq_R_add_rec k x f f0 f1 f2 _ _ = function
+ | R_add_0 s -> f s __
+ | R_add_1 (s, k', y, l) -> f0 s k' y l __ __ __
+ | R_add_2 (s, k', y, l) -> f1 s k' y l __ __ __
+ | R_add_3 (s, k', y, l, _res, r0) ->
+ f2 s k' y l __ __ __ _res r0 (coq_R_add_rec k x f f0 f1 f2 l _res r0)
+
+ (** 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 **)
+
+ let rec add_rect k x f2 f1 f0 f s =
+ let f3 = f2 s in
+ let f4 = f1 s in
+ let f5 = f0 s in
+ let f6 = f s in
+ (match s with
+ | Nil -> f3 __
+ | Cons (p, l) ->
+ let (t0, e) = p in
+ let f7 = f6 t0 e l __ in
+ let f8 = fun _ _ ->
+ let hrec = add_rect k x f2 f1 f0 f l in f7 __ __ hrec
+ in
+ let f9 = f5 t0 e l __ in
+ let f10 = f4 t0 e l __ in
+ (match X.compare k t0 with
+ | LT -> f10 __ __
+ | EQ -> f9 __ __
+ | GT -> f8 __ __))
+
+ (** 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 **)
+
+ let add_rec =
+ add_rect
+
+ (** val coq_R_add_correct :
+ key -> 'a1 -> 'a1 t -> 'a1 t -> 'a1 coq_R_add **)
+
+ let coq_R_add_correct k x s _res =
+ add_rect k x (fun y _ _ _ -> R_add_0 y) (fun y y0 y1 y2 _ _ _ _ _ ->
+ R_add_1 (y, y0, y1, y2)) (fun y y0 y1 y2 _ _ _ _ _ -> R_add_2 (y, y0,
+ y1, y2)) (fun y y0 y1 y2 _ _ _ y6 _ _ -> R_add_3 (y, y0, y1, y2,
+ (add k x y2), (y6 (add k x y2) __))) s _res __
+
+ (** val remove : key -> 'a1 t -> 'a1 t **)
+
+ let rec remove k s = match s with
+ | Nil -> Nil
+ | Cons (p, l) ->
+ let (k', x) = p in
+ (match X.compare k k' with
+ | LT -> s
+ | EQ -> l
+ | GT -> Cons ((k', x), (remove k l)))
+
+ 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 **)
+
+ let rec coq_R_remove_rect k f f0 f1 f2 _ _ = function
+ | R_remove_0 s -> f s __
+ | R_remove_1 (s, k', x, l) -> f0 s k' x l __ __ __
+ | R_remove_2 (s, k', x, l) -> f1 s k' x l __ __ __
+ | R_remove_3 (s, k', x, l, _res, r0) ->
+ f2 s k' x l __ __ __ _res r0 (coq_R_remove_rect k f f0 f1 f2 l _res r0)
+
+ (** 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 **)
+
+ let rec coq_R_remove_rec k f f0 f1 f2 _ _ = function
+ | R_remove_0 s -> f s __
+ | R_remove_1 (s, k', x, l) -> f0 s k' x l __ __ __
+ | R_remove_2 (s, k', x, l) -> f1 s k' x l __ __ __
+ | R_remove_3 (s, k', x, l, _res, r0) ->
+ f2 s k' x l __ __ __ _res r0 (coq_R_remove_rec k f f0 f1 f2 l _res r0)
+
+ (** 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 **)
+
+ let rec remove_rect k f2 f1 f0 f s =
+ let f3 = f2 s in
+ let f4 = f1 s in
+ let f5 = f0 s in
+ let f6 = f s in
+ (match s with
+ | Nil -> f3 __
+ | Cons (p, l) ->
+ let (t0, e) = p in
+ let f7 = f6 t0 e l __ in
+ let f8 = fun _ _ ->
+ let hrec = remove_rect k f2 f1 f0 f l in f7 __ __ hrec
+ in
+ let f9 = f5 t0 e l __ in
+ let f10 = f4 t0 e l __ in
+ (match X.compare k t0 with
+ | LT -> f10 __ __
+ | EQ -> f9 __ __
+ | GT -> f8 __ __))
+
+ (** 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 **)
+
+ let remove_rec =
+ remove_rect
+
+ (** val coq_R_remove_correct : key -> 'a1 t -> 'a1 t -> 'a1 coq_R_remove **)
+
+ let coq_R_remove_correct k s _res =
+ Obj.magic remove_rect k (fun y _ _ _ -> R_remove_0 y)
+ (fun y y0 y1 y2 _ _ _ _ _ -> R_remove_1 (y, y0, y1, y2))
+ (fun y y0 y1 y2 _ _ _ _ _ -> R_remove_2 (y, y0, y1, y2))
+ (fun y y0 y1 y2 _ _ _ y6 _ _ -> R_remove_3 (y, y0, y1, y2,
+ (remove k y2), (y6 (remove k y2) __))) s _res __
+
+ (** val elements : 'a1 t -> 'a1 t **)
+
+ let elements m =
+ m
+
+ (** val fold : (key -> 'a1 -> 'a2 -> 'a2) -> 'a1 t -> 'a2 -> 'a2 **)
+
+ let rec fold f m acc =
+ match m with
+ | Nil -> acc
+ | Cons (p, m') -> let (k, e) = p in fold f m' (f k e acc)
+
+ 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 **)
+
+ let rec coq_R_fold_rect f f0 f1 _ _ _ = function
+ | R_fold_0 (m, acc) -> f0 m acc __
+ | R_fold_1 (m, acc, k, e, m', _res, r0) ->
+ f1 m acc k e m' __ _res r0
+ (coq_R_fold_rect f f0 f1 m' (f k e acc) _res r0)
+
+ (** 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 **)
+
+ let rec coq_R_fold_rec f f0 f1 _ _ _ = function
+ | R_fold_0 (m, acc) -> f0 m acc __
+ | R_fold_1 (m, acc, k, e, m', _res, r0) ->
+ f1 m acc k e m' __ _res r0 (coq_R_fold_rec f f0 f1 m' (f k e acc) _res r0)
+
+ (** 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 **)
+
+ let rec fold_rect f1 f0 f m acc =
+ let f2 = f0 m acc in
+ let f3 = f m acc in
+ (match m with
+ | Nil -> f2 __
+ | Cons (p, l) ->
+ let (t0, e) = p in
+ let f4 = f3 t0 e l __ in
+ let hrec = fold_rect f1 f0 f l (f1 t0 e acc) in f4 hrec)
+
+ (** 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 **)
+
+ let fold_rec =
+ fold_rect
+
+ (** val coq_R_fold_correct :
+ (key -> 'a1 -> 'a2 -> 'a2) -> 'a1 t -> 'a2 -> 'a2 -> ('a1, 'a2)
+ coq_R_fold **)
+
+ let coq_R_fold_correct f m acc _res =
+ fold_rect f (fun y y0 _ _ _ -> R_fold_0 (y, y0))
+ (fun y y0 y1 y2 y3 _ y5 _ _ -> R_fold_1 (y, y0, y1, y2, y3,
+ (fold f y3 (f y1 y2 y0)), (y5 (fold f y3 (f y1 y2 y0)) __))) m acc _res
+ __
+
+ (** val equal : ('a1 -> 'a1 -> bool) -> 'a1 t -> 'a1 t -> bool **)
+
+ let rec equal cmp m m' =
+ match m with
+ | Nil -> (match m' with
+ | Nil -> true
+ | Cons (_, _) -> false)
+ | Cons (p, l) ->
+ let (x, e) = p in
+ (match m' with
+ | Nil -> false
+ | Cons (p0, l') ->
+ let (x', e') = p0 in
+ (match X.compare x x' with
+ | EQ -> if cmp e e' then equal cmp l l' else false
+ | _ -> false))
+
+ 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 **)
+
+ let rec coq_R_equal_rect cmp f f0 f1 f2 _ _ _ = function
+ | R_equal_0 (m, m') -> f m m' __ __
+ | R_equal_1 (m, m', x, e, l, x', e', l', _res, r0) ->
+ f0 m m' x e l __ x' e' l' __ __ __ _res r0
+ (coq_R_equal_rect cmp f f0 f1 f2 l l' _res r0)
+ | R_equal_2 (m, m', x, e, l, x', e', l', _x) ->
+ f1 m m' x e l __ x' e' l' __ _x __ __
+ | R_equal_3 (m, m', _x, _x0) -> f2 m m' _x __ _x0 __ __
+
+ (** 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 **)
+
+ let rec coq_R_equal_rec cmp f f0 f1 f2 _ _ _ = function
+ | R_equal_0 (m, m') -> f m m' __ __
+ | R_equal_1 (m, m', x, e, l, x', e', l', _res, r0) ->
+ f0 m m' x e l __ x' e' l' __ __ __ _res r0
+ (coq_R_equal_rec cmp f f0 f1 f2 l l' _res r0)
+ | R_equal_2 (m, m', x, e, l, x', e', l', _x) ->
+ f1 m m' x e l __ x' e' l' __ _x __ __
+ | R_equal_3 (m, m', _x, _x0) -> f2 m m' _x __ _x0 __ __
+
+ (** 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 **)
+
+ let rec equal_rect cmp f2 f1 f0 f m m' =
+ let f3 = f2 m m' in
+ let f4 = f1 m m' in
+ let f5 = f0 m m' in
+ let f6 = f m m' in
+ let f7 = f6 m __ in
+ let f8 = f7 m' __ in
+ (match m with
+ | Nil ->
+ let f9 = f3 __ in (match m' with
+ | Nil -> f9 __
+ | Cons (_, _) -> f8 __)
+ | Cons (p, l) ->
+ let (t0, e) = p in
+ let f9 = f5 t0 e l __ in
+ let f10 = f4 t0 e l __ in
+ (match m' with
+ | Nil -> f8 __
+ | Cons (p0, l0) ->
+ let (t1, e0) = p0 in
+ let f11 = f9 t1 e0 l0 __ in
+ let f12 = let _x = X.compare t0 t1 in f11 _x __ in
+ let f13 = f10 t1 e0 l0 __ in
+ let f14 = fun _ _ ->
+ let hrec = equal_rect cmp f2 f1 f0 f l l0 in f13 __ __ hrec
+ in
+ (match X.compare t0 t1 with
+ | EQ -> f14 __ __
+ | _ -> f12 __)))
+
+ (** 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 **)
+
+ let equal_rec =
+ equal_rect
+
+ (** val coq_R_equal_correct :
+ ('a1 -> 'a1 -> bool) -> 'a1 t -> 'a1 t -> bool -> 'a1 coq_R_equal **)
+
+ let coq_R_equal_correct cmp m m' _res =
+ equal_rect cmp (fun y y0 _ _ _ _ -> R_equal_0 (y, y0))
+ (fun y y0 y1 y2 y3 _ y5 y6 y7 _ _ _ y11 _ _ -> R_equal_1 (y, y0, y1,
+ y2, y3, y5, y6, y7, (equal cmp y3 y7), (y11 (equal cmp y3 y7) __)))
+ (fun y y0 y1 y2 y3 _ y5 y6 y7 _ y9 _ _ _ _ -> R_equal_2 (y, y0, y1, y2,
+ y3, y5, y6, y7, y9)) (fun y y0 y1 _ y3 _ _ _ _ -> R_equal_3 (y, y0, y1,
+ y3)) m m' _res __
+
+ (** val map : ('a1 -> 'a2) -> 'a1 t -> 'a2 t **)
+
+ let rec map f = function
+ | Nil -> Nil
+ | Cons (p, m') -> let (k, e) = p in Cons ((k, (f e)), (map f m'))
+
+ (** val mapi : (key -> 'a1 -> 'a2) -> 'a1 t -> 'a2 t **)
+
+ let rec mapi f = function
+ | Nil -> Nil
+ | Cons (p, m') -> let (k, e) = p in Cons ((k, (f k e)), (mapi f m'))
+
+ (** val option_cons :
+ key -> 'a1 option -> (key * 'a1) list -> (key * 'a1) list **)
+
+ let option_cons k o l =
+ match o with
+ | Some e -> Cons ((k, e), l)
+ | None -> l
+
+ (** val map2_l :
+ ('a1 option -> 'a2 option -> 'a3 option) -> 'a1 t -> 'a3 t **)
+
+ let rec map2_l f = function
+ | Nil -> Nil
+ | Cons (p, l) ->
+ let (k, e) = p in option_cons k (f (Some e) None) (map2_l f l)
+
+ (** val map2_r :
+ ('a1 option -> 'a2 option -> 'a3 option) -> 'a2 t -> 'a3 t **)
+
+ let rec map2_r f = function
+ | Nil -> Nil
+ | Cons (p, l') ->
+ let (k, e') = p in option_cons k (f None (Some e')) (map2_r f l')
+
+ (** val map2 :
+ ('a1 option -> 'a2 option -> 'a3 option) -> 'a1 t -> 'a2 t -> 'a3 t **)
+
+ let rec map2 f m = match m with
+ | Nil -> map2_r f
+ | Cons (p, l) ->
+ let (k, e) = p in
+ let rec map2_aux m' = match m' with
+ | Nil -> map2_l f m
+ | Cons (p0, l') ->
+ let (k', e') = p0 in
+ (match X.compare k k' with
+ | LT -> option_cons k (f (Some e) None) (map2 f l m')
+ | EQ -> option_cons k (f (Some e) (Some e')) (map2 f l l')
+ | GT -> option_cons k' (f None (Some e')) (map2_aux l'))
+ in map2_aux
+
+ (** val combine : 'a1 t -> 'a2 t -> ('a1 option * 'a2 option) t **)
+
+ let rec combine m = match m with
+ | Nil -> map (fun e' -> (None, (Some e')))
+ | Cons (p, l) ->
+ let (k, e) = p in
+ let rec combine_aux m' = match m' with
+ | Nil -> map (fun e0 -> ((Some e0), None)) m
+ | Cons (p0, l') ->
+ let (k', e') = p0 in
+ (match X.compare k k' with
+ | LT -> Cons ((k, ((Some e), None)), (combine l m'))
+ | EQ -> Cons ((k, ((Some e), (Some e'))), (combine l l'))
+ | GT -> Cons ((k', (None, (Some e'))), (combine_aux l')))
+ in combine_aux
+
+ (** val fold_right_pair :
+ ('a1 -> 'a2 -> 'a3 -> 'a3) -> ('a1 * 'a2) list -> 'a3 -> 'a3 **)
+
+ let fold_right_pair f l i =
+ fold_right (fun p -> f (fst p) (snd p)) i l
+
+ (** val map2_alt :
+ ('a1 option -> 'a2 option -> 'a3 option) -> 'a1 t -> 'a2 t ->
+ (key * 'a3) list **)
+
+ let map2_alt f m m' =
+ let m0 = combine m m' in
+ let m1 = map (fun p -> f (fst p) (snd p)) m0 in
+ fold_right_pair option_cons m1 Nil
+
+ (** val at_least_one :
+ 'a1 option -> 'a2 option -> ('a1 option * 'a2 option) option **)
+
+ let at_least_one o o' =
+ match o with
+ | Some _ -> Some (o, o')
+ | None -> (match o' with
+ | Some _ -> Some (o, o')
+ | None -> None)
+
+ (** val at_least_one_then_f :
+ ('a1 option -> 'a2 option -> 'a3 option) -> 'a1 option -> 'a2 option ->
+ 'a3 option **)
+
+ let at_least_one_then_f f o o' =
+ match o with
+ | Some _ -> f o o'
+ | None -> (match o' with
+ | Some _ -> f o o'
+ | None -> None)
end
-module Var =
- struct
- (** val _true : int **)
-
- let _true =
- (ExtrNative.of_uint(0))
-
- (** val _false : int **)
-
- let _false =
- (ExtrNative.of_uint(1))
-
- (** val interp : Valuation.t -> int -> bool **)
-
- let interp rho x =
- rho x
+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 Lit =
- struct
- (** val is_pos : int -> bool **)
-
- let is_pos l =
- is_even l
-
- (** val blit : int -> int **)
-
- let blit l =
- lsr0 l (ExtrNative.of_uint(1))
-
- (** val lit : int -> int **)
-
- let lit x =
- lsl0 x (ExtrNative.of_uint(1))
-
- (** val neg : int -> int **)
-
- let neg l =
- lxor0 l (ExtrNative.of_uint(1))
-
- (** val nlit : int -> int **)
-
- let nlit x =
- neg (lit x)
-
- (** val _true : int **)
-
+module Z_as_Int =
+ struct
+ type t = z
+
+ (** val _0 : z **)
+
+ let _0 =
+ Z0
+
+ (** val _1 : z **)
+
+ let _1 =
+ Zpos XH
+
+ (** val _2 : z **)
+
+ let _2 =
+ Zpos (XO XH)
+
+ (** val _3 : z **)
+
+ let _3 =
+ Zpos (XI XH)
+
+ (** val add : z -> z -> z **)
+
+ let add =
+ Z.add
+
+ (** val opp : z -> z **)
+
+ let opp =
+ Z.opp
+
+ (** val sub : z -> z -> z **)
+
+ let sub =
+ Z.sub
+
+ (** val mul : z -> z -> z **)
+
+ let mul =
+ Z.mul
+
+ (** val max : z -> z -> z **)
+
+ let max =
+ Z.max
+
+ (** val eqb : z -> z -> bool **)
+
+ let eqb =
+ Z.eqb
+
+ (** val ltb : z -> z -> bool **)
+
+ let ltb =
+ Z.ltb
+
+ (** val leb : z -> z -> bool **)
+
+ let leb =
+ Z.leb
+
+ (** val eq_dec : z -> z -> sumbool **)
+
+ let eq_dec =
+ Z.eq_dec
+
+ (** val gt_le_dec : z -> z -> sumbool **)
+
+ let gt_le_dec i j =
+ let b = Z.ltb j i in if b then Left else Right
+
+ (** val ge_lt_dec : z -> z -> sumbool **)
+
+ let ge_lt_dec i j =
+ let b = Z.ltb i j in if b then Right else Left
+
+ (** val i2z : t -> z **)
+
+ let i2z n =
+ n
+ end
+
+module Coq_Raw =
+ functor (I:Int) ->
+ functor (X:OrderedType) ->
+ struct
+ 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 **)
+
+ let rec tree_rect f f0 = function
+ | Leaf -> f
+ | Node (t1, k, y, t2, t3) ->
+ f0 t1 (tree_rect f f0 t1) k y t2 (tree_rect f f0 t2) t3
+
+ (** val tree_rec :
+ 'a2 -> ('a1 tree -> 'a2 -> key -> 'a1 -> 'a1 tree -> 'a2 -> I.t -> 'a2)
+ -> 'a1 tree -> 'a2 **)
+
+ let rec tree_rec f f0 = function
+ | Leaf -> f
+ | Node (t1, k, y, t2, t3) ->
+ f0 t1 (tree_rec f f0 t1) k y t2 (tree_rec f f0 t2) t3
+
+ (** val height : 'a1 tree -> I.t **)
+
+ let height = function
+ | Leaf -> I._0
+ | Node (_, _, _, _, h) -> h
+
+ (** val cardinal : 'a1 tree -> nat **)
+
+ let rec cardinal = function
+ | Leaf -> O
+ | Node (l, _, _, r, _) -> S (add (cardinal l) (cardinal r))
+
+ (** val empty : 'a1 tree **)
+
+ let empty =
+ Leaf
+
+ (** val is_empty : 'a1 tree -> bool **)
+
+ let is_empty = function
+ | Leaf -> true
+ | Node (_, _, _, _, _) -> false
+
+ (** val mem : X.t -> 'a1 tree -> bool **)
+
+ let rec mem x = function
+ | Leaf -> false
+ | Node (l, y, _, r, _) ->
+ (match X.compare x y with
+ | LT -> mem x l
+ | EQ -> true
+ | GT -> mem x r)
+
+ (** val find : X.t -> 'a1 tree -> 'a1 option **)
+
+ let rec find x = function
+ | Leaf -> None
+ | Node (l, y, d, r, _) ->
+ (match X.compare x y with
+ | LT -> find x l
+ | EQ -> Some d
+ | GT -> find x r)
+
+ (** val create : 'a1 tree -> key -> 'a1 -> 'a1 tree -> 'a1 tree **)
+
+ let create l x e r =
+ Node (l, x, e, r, (I.add (I.max (height l) (height r)) I._1))
+
+ (** val assert_false : 'a1 tree -> key -> 'a1 -> 'a1 tree -> 'a1 tree **)
+
+ let assert_false =
+ create
+
+ (** val bal : 'a1 tree -> key -> 'a1 -> 'a1 tree -> 'a1 tree **)
+
+ let bal l x d r =
+ let hl = height l in
+ let hr = height r in
+ (match I.gt_le_dec hl (I.add hr I._2) with
+ | Left ->
+ (match l with
+ | Leaf -> assert_false l x d r
+ | Node (ll, lx, ld, lr, _) ->
+ (match I.ge_lt_dec (height ll) (height lr) with
+ | Left -> create ll lx ld (create lr x d r)
+ | Right ->
+ (match lr with
+ | Leaf -> assert_false l x d r
+ | Node (lrl, lrx, lrd, lrr, _) ->
+ create (create ll lx ld lrl) lrx lrd (create lrr x d r))))
+ | Right ->
+ (match I.gt_le_dec hr (I.add hl I._2) with
+ | Left ->
+ (match r with
+ | Leaf -> assert_false l x d r
+ | Node (rl, rx, rd, rr, _) ->
+ (match I.ge_lt_dec (height rr) (height rl) with
+ | Left -> create (create l x d rl) rx rd rr
+ | Right ->
+ (match rl with
+ | Leaf -> assert_false l x d r
+ | Node (rll, rlx, rld, rlr, _) ->
+ create (create l x d rll) rlx rld (create rlr rx rd rr))))
+ | Right -> create l x d r))
+
+ (** val add : key -> 'a1 -> 'a1 tree -> 'a1 tree **)
+
+ let rec add x d = function
+ | Leaf -> Node (Leaf, x, d, Leaf, I._1)
+ | Node (l, y, d', r, h) ->
+ (match X.compare x y with
+ | LT -> bal (add x d l) y d' r
+ | EQ -> Node (l, y, d, r, h)
+ | GT -> bal l y d' (add x d r))
+
+ (** val remove_min :
+ 'a1 tree -> key -> 'a1 -> 'a1 tree -> 'a1 tree * (key * 'a1) **)
+
+ let rec remove_min l x d r =
+ match l with
+ | Leaf -> (r, (x, d))
+ | Node (ll, lx, ld, lr, _) ->
+ let (l', m) = remove_min ll lx ld lr in ((bal l' x d r), m)
+
+ (** val merge : 'a1 tree -> 'a1 tree -> 'a1 tree **)
+
+ let merge s1 s2 =
+ match s1 with
+ | Leaf -> s2
+ | Node (_, _, _, _, _) ->
+ (match s2 with
+ | Leaf -> s1
+ | Node (l2, x2, d2, r2, _) ->
+ let (s2', p) = remove_min l2 x2 d2 r2 in
+ let (x, d) = p in bal s1 x d s2')
+
+ (** val remove : X.t -> 'a1 tree -> 'a1 tree **)
+
+ let rec remove x = function
+ | Leaf -> Leaf
+ | Node (l, y, d, r, _) ->
+ (match X.compare x y with
+ | LT -> bal (remove x l) y d r
+ | EQ -> merge l r
+ | GT -> bal l y d (remove x r))
+
+ (** val join : 'a1 tree -> key -> 'a1 -> 'a1 tree -> 'a1 tree **)
+
+ let rec join l = match l with
+ | Leaf -> add
+ | Node (ll, lx, ld, lr, lh) ->
+ (fun x d ->
+ let rec join_aux r = match r with
+ | Leaf -> add x d l
+ | Node (rl, rx, rd, rr, rh) ->
+ (match I.gt_le_dec lh (I.add rh I._2) with
+ | Left -> bal ll lx ld (join lr x d r)
+ | Right ->
+ (match I.gt_le_dec rh (I.add lh I._2) with
+ | Left -> bal (join_aux rl) rx rd rr
+ | Right -> create l x d r))
+ in join_aux)
+
+ type 'elt triple = { t_left : 'elt tree; t_opt : 'elt option;
+ t_right : 'elt tree }
+
+ (** val t_left : 'a1 triple -> 'a1 tree **)
+
+ let t_left t0 =
+ t0.t_left
+
+ (** val t_opt : 'a1 triple -> 'a1 option **)
+
+ let t_opt t0 =
+ t0.t_opt
+
+ (** val t_right : 'a1 triple -> 'a1 tree **)
+
+ let t_right t0 =
+ t0.t_right
+
+ (** val split : X.t -> 'a1 tree -> 'a1 triple **)
+
+ let rec split x = function
+ | Leaf -> { t_left = Leaf; t_opt = None; t_right = Leaf }
+ | Node (l, y, d, r, _) ->
+ (match X.compare x y with
+ | LT ->
+ let { t_left = ll; t_opt = o; t_right = rl } = split x l in
+ { t_left = ll; t_opt = o; t_right = (join rl y d r) }
+ | EQ -> { t_left = l; t_opt = (Some d); t_right = r }
+ | GT ->
+ let { t_left = rl; t_opt = o; t_right = rr } = split x r in
+ { t_left = (join l y d rl); t_opt = o; t_right = rr })
+
+ (** val concat : 'a1 tree -> 'a1 tree -> 'a1 tree **)
+
+ let concat m1 m2 =
+ match m1 with
+ | Leaf -> m2
+ | Node (_, _, _, _, _) ->
+ (match m2 with
+ | Leaf -> m1
+ | Node (l2, x2, d2, r2, _) ->
+ let (m2', xd) = remove_min l2 x2 d2 r2 in
+ join m1 (fst xd) (snd xd) m2')
+
+ (** val elements_aux : (key * 'a1) list -> 'a1 tree -> (key * 'a1) list **)
+
+ let rec elements_aux acc = function
+ | Leaf -> acc
+ | Node (l, x, d, r, _) ->
+ elements_aux (Cons ((x, d), (elements_aux acc r))) l
+
+ (** val elements : 'a1 tree -> (key * 'a1) list **)
+
+ let elements m =
+ elements_aux Nil m
+
+ (** val fold : (key -> 'a1 -> 'a2 -> 'a2) -> 'a1 tree -> 'a2 -> 'a2 **)
+
+ let rec fold f m a =
+ match m with
+ | Leaf -> a
+ | Node (l, x, d, r, _) -> fold f r (f x d (fold f l a))
+
+ 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 **)
+
+ let rec enumeration_rect f f0 = function
+ | End -> f
+ | More (k, e0, t0, e1) -> f0 k e0 t0 e1 (enumeration_rect f f0 e1)
+
+ (** val enumeration_rec :
+ 'a2 -> (key -> 'a1 -> 'a1 tree -> 'a1 enumeration -> 'a2 -> 'a2) -> 'a1
+ enumeration -> 'a2 **)
+
+ let rec enumeration_rec f f0 = function
+ | End -> f
+ | More (k, e0, t0, e1) -> f0 k e0 t0 e1 (enumeration_rec f f0 e1)
+
+ (** val cons : 'a1 tree -> 'a1 enumeration -> 'a1 enumeration **)
+
+ let rec cons m e =
+ match m with
+ | Leaf -> e
+ | Node (l, x, d, r, _) -> cons l (More (x, d, r, e))
+
+ (** val equal_more :
+ ('a1 -> 'a1 -> bool) -> X.t -> 'a1 -> ('a1 enumeration -> bool) -> 'a1
+ enumeration -> bool **)
+
+ let equal_more cmp x1 d1 cont = function
+ | End -> false
+ | More (x2, d2, r2, e3) ->
+ (match X.compare x1 x2 with
+ | EQ -> if cmp d1 d2 then cont (cons r2 e3) else false
+ | _ -> false)
+
+ (** val equal_cont :
+ ('a1 -> 'a1 -> bool) -> 'a1 tree -> ('a1 enumeration -> bool) -> 'a1
+ enumeration -> bool **)
+
+ let rec equal_cont cmp m1 cont e2 =
+ match m1 with
+ | Leaf -> cont e2
+ | Node (l1, x1, d1, r1, _) ->
+ equal_cont cmp l1 (equal_more cmp x1 d1 (equal_cont cmp r1 cont)) e2
+
+ (** val equal_end : 'a1 enumeration -> bool **)
+
+ let equal_end = function
+ | End -> true
+ | More (_, _, _, _) -> false
+
+ (** val equal : ('a1 -> 'a1 -> bool) -> 'a1 tree -> 'a1 tree -> bool **)
+
+ let equal cmp m1 m2 =
+ equal_cont cmp m1 equal_end (cons m2 End)
+
+ (** val map : ('a1 -> 'a2) -> 'a1 tree -> 'a2 tree **)
+
+ let rec map f = function
+ | Leaf -> Leaf
+ | Node (l, x, d, r, h) -> Node ((map f l), x, (f d), (map f r), h)
+
+ (** val mapi : (key -> 'a1 -> 'a2) -> 'a1 tree -> 'a2 tree **)
+
+ let rec mapi f = function
+ | Leaf -> Leaf
+ | Node (l, x, d, r, h) -> Node ((mapi f l), x, (f x d), (mapi f r), h)
+
+ (** val map_option : (key -> 'a1 -> 'a2 option) -> 'a1 tree -> 'a2 tree **)
+
+ let rec map_option f = function
+ | Leaf -> Leaf
+ | Node (l, x, d, r, _) ->
+ (match f x d with
+ | Some d' -> join (map_option f l) x d' (map_option f r)
+ | None -> concat (map_option f l) (map_option f r))
+
+ (** val map2_opt :
+ (key -> 'a1 -> 'a2 option -> 'a3 option) -> ('a1 tree -> 'a3 tree) ->
+ ('a2 tree -> 'a3 tree) -> 'a1 tree -> 'a2 tree -> 'a3 tree **)
+
+ let rec map2_opt f mapl mapr m1 m2 =
+ match m1 with
+ | Leaf -> mapr m2
+ | Node (l1, x1, d1, r1, _) ->
+ (match m2 with
+ | Leaf -> mapl m1
+ | Node (_, _, _, _, _) ->
+ let { t_left = l2'; t_opt = o2; t_right = r2' } = split x1 m2 in
+ (match f x1 d1 o2 with
+ | Some e ->
+ join (map2_opt f mapl mapr l1 l2') x1 e
+ (map2_opt f mapl mapr r1 r2')
+ | None ->
+ concat (map2_opt f mapl mapr l1 l2') (map2_opt f mapl mapr r1 r2')))
+
+ (** val map2 :
+ ('a1 option -> 'a2 option -> 'a3 option) -> 'a1 tree -> 'a2 tree -> 'a3
+ tree **)
+
+ let map2 f =
+ map2_opt (fun _ d o -> f (Some d) o)
+ (map_option (fun _ d -> f (Some d) None))
+ (map_option (fun _ d' -> f None (Some d')))
+
+ module Proofs =
+ struct
+ module MX = OrderedTypeFacts(X)
+
+ module PX = KeyOrderedType(X)
+
+ module L = Raw(X)
+
+ 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 **)
+
+ let rec coq_R_mem_rect x f f0 f1 f2 _ _ = function
+ | R_mem_0 m -> f m __
+ | R_mem_1 (m, l, y, _x, r0, _x0, _res, r1) ->
+ f0 m l y _x r0 _x0 __ __ __ _res r1
+ (coq_R_mem_rect x f f0 f1 f2 l _res r1)
+ | R_mem_2 (m, l, y, _x, r0, _x0) -> f1 m l y _x r0 _x0 __ __ __
+ | R_mem_3 (m, l, y, _x, r0, _x0, _res, r1) ->
+ f2 m l y _x r0 _x0 __ __ __ _res r1
+ (coq_R_mem_rect x f f0 f1 f2 r0 _res r1)
+
+ (** 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 **)
+
+ let rec coq_R_mem_rec x f f0 f1 f2 _ _ = function
+ | R_mem_0 m -> f m __
+ | R_mem_1 (m, l, y, _x, r0, _x0, _res, r1) ->
+ f0 m l y _x r0 _x0 __ __ __ _res r1
+ (coq_R_mem_rec x f f0 f1 f2 l _res r1)
+ | R_mem_2 (m, l, y, _x, r0, _x0) -> f1 m l y _x r0 _x0 __ __ __
+ | R_mem_3 (m, l, y, _x, r0, _x0, _res, r1) ->
+ f2 m l y _x r0 _x0 __ __ __ _res r1
+ (coq_R_mem_rec x f f0 f1 f2 r0 _res r1)
+
+ 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 **)
+
+ let rec coq_R_find_rect x f f0 f1 f2 _ _ = function
+ | R_find_0 m -> f m __
+ | R_find_1 (m, l, y, d, r0, _x, _res, r1) ->
+ f0 m l y d r0 _x __ __ __ _res r1
+ (coq_R_find_rect x f f0 f1 f2 l _res r1)
+ | R_find_2 (m, l, y, d, r0, _x) -> f1 m l y d r0 _x __ __ __
+ | R_find_3 (m, l, y, d, r0, _x, _res, r1) ->
+ f2 m l y d r0 _x __ __ __ _res r1
+ (coq_R_find_rect x f f0 f1 f2 r0 _res r1)
+
+ (** 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 **)
+
+ let rec coq_R_find_rec x f f0 f1 f2 _ _ = function
+ | R_find_0 m -> f m __
+ | R_find_1 (m, l, y, d, r0, _x, _res, r1) ->
+ f0 m l y d r0 _x __ __ __ _res r1
+ (coq_R_find_rec x f f0 f1 f2 l _res r1)
+ | R_find_2 (m, l, y, d, r0, _x) -> f1 m l y d r0 _x __ __ __
+ | R_find_3 (m, l, y, d, r0, _x, _res, r1) ->
+ f2 m l y d r0 _x __ __ __ _res r1
+ (coq_R_find_rec x f f0 f1 f2 r0 _res r1)
+
+ 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 **)
+
+ let coq_R_bal_rect f f0 f1 f2 f3 f4 f5 f6 f7 _ _ _ _ _ = function
+ | R_bal_0 (x, x0, x1, x2) -> f x x0 x1 x2 __ __ __
+ | R_bal_1 (x, x0, x1, x2, x3, x4, x5, x6, x7) ->
+ f0 x x0 x1 x2 __ __ x3 x4 x5 x6 x7 __ __ __
+ | R_bal_2 (x, x0, x1, x2, x3, x4, x5, x6, x7) ->
+ f1 x x0 x1 x2 __ __ x3 x4 x5 x6 x7 __ __ __ __
+ | R_bal_3 (x, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) ->
+ f2 x x0 x1 x2 __ __ x3 x4 x5 x6 x7 __ __ __ x8 x9 x10 x11 x12 __
+ | R_bal_4 (x, x0, x1, x2) -> f3 x x0 x1 x2 __ __ __ __ __
+ | R_bal_5 (x, x0, x1, x2, x3, x4, x5, x6, x7) ->
+ f4 x x0 x1 x2 __ __ __ __ x3 x4 x5 x6 x7 __ __ __
+ | R_bal_6 (x, x0, x1, x2, x3, x4, x5, x6, x7) ->
+ f5 x x0 x1 x2 __ __ __ __ x3 x4 x5 x6 x7 __ __ __ __
+ | R_bal_7 (x, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) ->
+ f6 x x0 x1 x2 __ __ __ __ x3 x4 x5 x6 x7 __ __ __ x8 x9 x10 x11 x12 __
+ | R_bal_8 (x, x0, x1, x2) -> f7 x x0 x1 x2 __ __ __ __
+
+ (** 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 **)
+
+ let coq_R_bal_rec f f0 f1 f2 f3 f4 f5 f6 f7 _ _ _ _ _ = function
+ | R_bal_0 (x, x0, x1, x2) -> f x x0 x1 x2 __ __ __
+ | R_bal_1 (x, x0, x1, x2, x3, x4, x5, x6, x7) ->
+ f0 x x0 x1 x2 __ __ x3 x4 x5 x6 x7 __ __ __
+ | R_bal_2 (x, x0, x1, x2, x3, x4, x5, x6, x7) ->
+ f1 x x0 x1 x2 __ __ x3 x4 x5 x6 x7 __ __ __ __
+ | R_bal_3 (x, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) ->
+ f2 x x0 x1 x2 __ __ x3 x4 x5 x6 x7 __ __ __ x8 x9 x10 x11 x12 __
+ | R_bal_4 (x, x0, x1, x2) -> f3 x x0 x1 x2 __ __ __ __ __
+ | R_bal_5 (x, x0, x1, x2, x3, x4, x5, x6, x7) ->
+ f4 x x0 x1 x2 __ __ __ __ x3 x4 x5 x6 x7 __ __ __
+ | R_bal_6 (x, x0, x1, x2, x3, x4, x5, x6, x7) ->
+ f5 x x0 x1 x2 __ __ __ __ x3 x4 x5 x6 x7 __ __ __ __
+ | R_bal_7 (x, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) ->
+ f6 x x0 x1 x2 __ __ __ __ x3 x4 x5 x6 x7 __ __ __ x8 x9 x10 x11 x12 __
+ | R_bal_8 (x, x0, x1, x2) -> f7 x x0 x1 x2 __ __ __ __
+
+ 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 **)
+
+ let rec coq_R_add_rect x d f f0 f1 f2 _ _ = function
+ | R_add_0 m -> f m __
+ | R_add_1 (m, l, y, d', r0, h, _res, r1) ->
+ f0 m l y d' r0 h __ __ __ _res r1
+ (coq_R_add_rect x d f f0 f1 f2 l _res r1)
+ | R_add_2 (m, l, y, d', r0, h) -> f1 m l y d' r0 h __ __ __
+ | R_add_3 (m, l, y, d', r0, h, _res, r1) ->
+ f2 m l y d' r0 h __ __ __ _res r1
+ (coq_R_add_rect x d f f0 f1 f2 r0 _res r1)
+
+ (** 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 **)
+
+ let rec coq_R_add_rec x d f f0 f1 f2 _ _ = function
+ | R_add_0 m -> f m __
+ | R_add_1 (m, l, y, d', r0, h, _res, r1) ->
+ f0 m l y d' r0 h __ __ __ _res r1
+ (coq_R_add_rec x d f f0 f1 f2 l _res r1)
+ | R_add_2 (m, l, y, d', r0, h) -> f1 m l y d' r0 h __ __ __
+ | R_add_3 (m, l, y, d', r0, h, _res, r1) ->
+ f2 m l y d' r0 h __ __ __ _res r1
+ (coq_R_add_rec x d f f0 f1 f2 r0 _res r1)
+
+ 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 **)
+
+ let rec coq_R_remove_min_rect f f0 _ _ _ _ _ = function
+ | R_remove_min_0 (l, x, d, r0) -> f l x d r0 __
+ | R_remove_min_1 (l, x, d, r0, ll, lx, ld, lr, _x, _res, r1, l', m) ->
+ f0 l x d r0 ll lx ld lr _x __ _res r1
+ (coq_R_remove_min_rect f f0 ll lx ld lr _res r1) l' m __
+
+ (** 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 **)
+
+ let rec coq_R_remove_min_rec f f0 _ _ _ _ _ = function
+ | R_remove_min_0 (l, x, d, r0) -> f l x d r0 __
+ | R_remove_min_1 (l, x, d, r0, ll, lx, ld, lr, _x, _res, r1, l', m) ->
+ f0 l x d r0 ll lx ld lr _x __ _res r1
+ (coq_R_remove_min_rec f f0 ll lx ld lr _res r1) l' m __
+
+ 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 **)
+
+ let coq_R_merge_rect f f0 f1 _ _ _ = function
+ | R_merge_0 (x, x0) -> f x x0 __
+ | R_merge_1 (x, x0, x1, x2, x3, x4, x5) -> f0 x x0 x1 x2 x3 x4 x5 __ __
+ | R_merge_2 (x, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12,
+ x13, x14) ->
+ f1 x x0 x1 x2 x3 x4 x5 __ x6 x7 x8 x9 x10 __ x11 x12 __ x13 x14 __
+
+ (** 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 **)
+
+ let coq_R_merge_rec f f0 f1 _ _ _ = function
+ | R_merge_0 (x, x0) -> f x x0 __
+ | R_merge_1 (x, x0, x1, x2, x3, x4, x5) -> f0 x x0 x1 x2 x3 x4 x5 __ __
+ | R_merge_2 (x, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12,
+ x13, x14) ->
+ f1 x x0 x1 x2 x3 x4 x5 __ x6 x7 x8 x9 x10 __ x11 x12 __ x13 x14 __
+
+ 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 **)
+
+ let rec coq_R_remove_rect x f f0 f1 f2 _ _ = function
+ | R_remove_0 m -> f m __
+ | R_remove_1 (m, l, y, d, r0, _x, _res, r1) ->
+ f0 m l y d r0 _x __ __ __ _res r1
+ (coq_R_remove_rect x f f0 f1 f2 l _res r1)
+ | R_remove_2 (m, l, y, d, r0, _x) -> f1 m l y d r0 _x __ __ __
+ | R_remove_3 (m, l, y, d, r0, _x, _res, r1) ->
+ f2 m l y d r0 _x __ __ __ _res r1
+ (coq_R_remove_rect x f f0 f1 f2 r0 _res r1)
+
+ (** 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 **)
+
+ let rec coq_R_remove_rec x f f0 f1 f2 _ _ = function
+ | R_remove_0 m -> f m __
+ | R_remove_1 (m, l, y, d, r0, _x, _res, r1) ->
+ f0 m l y d r0 _x __ __ __ _res r1
+ (coq_R_remove_rec x f f0 f1 f2 l _res r1)
+ | R_remove_2 (m, l, y, d, r0, _x) -> f1 m l y d r0 _x __ __ __
+ | R_remove_3 (m, l, y, d, r0, _x, _res, r1) ->
+ f2 m l y d r0 _x __ __ __ _res r1
+ (coq_R_remove_rec x f f0 f1 f2 r0 _res r1)
+
+ 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 **)
+
+ let coq_R_concat_rect f f0 f1 _ _ _ = function
+ | R_concat_0 (x, x0) -> f x x0 __
+ | R_concat_1 (x, x0, x1, x2, x3, x4, x5) -> f0 x x0 x1 x2 x3 x4 x5 __ __
+ | R_concat_2 (x, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) ->
+ f1 x x0 x1 x2 x3 x4 x5 __ x6 x7 x8 x9 x10 __ x11 x12 __
+
+ (** 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 **)
+
+ let coq_R_concat_rec f f0 f1 _ _ _ = function
+ | R_concat_0 (x, x0) -> f x x0 __
+ | R_concat_1 (x, x0, x1, x2, x3, x4, x5) -> f0 x x0 x1 x2 x3 x4 x5 __ __
+ | R_concat_2 (x, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) ->
+ f1 x x0 x1 x2 x3 x4 x5 __ x6 x7 x8 x9 x10 __ x11 x12 __
+
+ 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 **)
+
+ let rec coq_R_split_rect x f f0 f1 f2 _ _ = function
+ | R_split_0 m -> f m __
+ | R_split_1 (m, l, y, d, r0, _x, _res, r1, ll, o, rl) ->
+ f0 m l y d r0 _x __ __ __ _res r1
+ (coq_R_split_rect x f f0 f1 f2 l _res r1) ll o rl __
+ | R_split_2 (m, l, y, d, r0, _x) -> f1 m l y d r0 _x __ __ __
+ | R_split_3 (m, l, y, d, r0, _x, _res, r1, rl, o, rr) ->
+ f2 m l y d r0 _x __ __ __ _res r1
+ (coq_R_split_rect x f f0 f1 f2 r0 _res r1) rl o rr __
+
+ (** 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 **)
+
+ let rec coq_R_split_rec x f f0 f1 f2 _ _ = function
+ | R_split_0 m -> f m __
+ | R_split_1 (m, l, y, d, r0, _x, _res, r1, ll, o, rl) ->
+ f0 m l y d r0 _x __ __ __ _res r1
+ (coq_R_split_rec x f f0 f1 f2 l _res r1) ll o rl __
+ | R_split_2 (m, l, y, d, r0, _x) -> f1 m l y d r0 _x __ __ __
+ | R_split_3 (m, l, y, d, r0, _x, _res, r1, rl, o, rr) ->
+ f2 m l y d r0 _x __ __ __ _res r1
+ (coq_R_split_rec x f f0 f1 f2 r0 _res r1) rl o rr __
+
+ 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 **)
+
+ let rec coq_R_map_option_rect f f0 f1 f2 _ _ = function
+ | R_map_option_0 m -> f0 m __
+ | R_map_option_1 (m, l, x, d, r0, _x, d', _res0, r1, _res, r2) ->
+ f1 m l x d r0 _x __ d' __ _res0 r1
+ (coq_R_map_option_rect f f0 f1 f2 l _res0 r1) _res r2
+ (coq_R_map_option_rect f f0 f1 f2 r0 _res r2)
+ | R_map_option_2 (m, l, x, d, r0, _x, _res0, r1, _res, r2) ->
+ f2 m l x d r0 _x __ __ _res0 r1
+ (coq_R_map_option_rect f f0 f1 f2 l _res0 r1) _res r2
+ (coq_R_map_option_rect f f0 f1 f2 r0 _res r2)
+
+ (** 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 **)
+
+ let rec coq_R_map_option_rec f f0 f1 f2 _ _ = function
+ | R_map_option_0 m -> f0 m __
+ | R_map_option_1 (m, l, x, d, r0, _x, d', _res0, r1, _res, r2) ->
+ f1 m l x d r0 _x __ d' __ _res0 r1
+ (coq_R_map_option_rec f f0 f1 f2 l _res0 r1) _res r2
+ (coq_R_map_option_rec f f0 f1 f2 r0 _res r2)
+ | R_map_option_2 (m, l, x, d, r0, _x, _res0, r1, _res, r2) ->
+ f2 m l x d r0 _x __ __ _res0 r1
+ (coq_R_map_option_rec f f0 f1 f2 l _res0 r1) _res r2
+ (coq_R_map_option_rec f f0 f1 f2 r0 _res r2)
+
+ 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 **)
+
+ let rec coq_R_map2_opt_rect f mapl mapr f0 f1 f2 f3 _ _ _ = function
+ | R_map2_opt_0 (m1, m2) -> f0 m1 m2 __
+ | R_map2_opt_1 (m1, m2, l1, x1, d1, r1, _x) ->
+ f1 m1 m2 l1 x1 d1 r1 _x __ __
+ | R_map2_opt_2 (m1, m2, l1, x1, d1, r1, _x, _x0, _x1, _x2, _x3, _x4, l2',
+ o2, r2', e, _res0, r0, _res, r2) ->
+ f2 m1 m2 l1 x1 d1 r1 _x __ _x0 _x1 _x2 _x3 _x4 __ l2' o2 r2' __ e __
+ _res0 r0
+ (coq_R_map2_opt_rect f mapl mapr f0 f1 f2 f3 l1 l2' _res0 r0) _res r2
+ (coq_R_map2_opt_rect f mapl mapr f0 f1 f2 f3 r1 r2' _res r2)
+ | R_map2_opt_3 (m1, m2, l1, x1, d1, r1, _x, _x0, _x1, _x2, _x3, _x4, l2',
+ o2, r2', _res0, r0, _res, r2) ->
+ f3 m1 m2 l1 x1 d1 r1 _x __ _x0 _x1 _x2 _x3 _x4 __ l2' o2 r2' __ __
+ _res0 r0
+ (coq_R_map2_opt_rect f mapl mapr f0 f1 f2 f3 l1 l2' _res0 r0) _res r2
+ (coq_R_map2_opt_rect f mapl mapr f0 f1 f2 f3 r1 r2' _res r2)
+
+ (** 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 **)
+
+ let rec coq_R_map2_opt_rec f mapl mapr f0 f1 f2 f3 _ _ _ = function
+ | R_map2_opt_0 (m1, m2) -> f0 m1 m2 __
+ | R_map2_opt_1 (m1, m2, l1, x1, d1, r1, _x) ->
+ f1 m1 m2 l1 x1 d1 r1 _x __ __
+ | R_map2_opt_2 (m1, m2, l1, x1, d1, r1, _x, _x0, _x1, _x2, _x3, _x4, l2',
+ o2, r2', e, _res0, r0, _res, r2) ->
+ f2 m1 m2 l1 x1 d1 r1 _x __ _x0 _x1 _x2 _x3 _x4 __ l2' o2 r2' __ e __
+ _res0 r0 (coq_R_map2_opt_rec f mapl mapr f0 f1 f2 f3 l1 l2' _res0 r0)
+ _res r2 (coq_R_map2_opt_rec f mapl mapr f0 f1 f2 f3 r1 r2' _res r2)
+ | R_map2_opt_3 (m1, m2, l1, x1, d1, r1, _x, _x0, _x1, _x2, _x3, _x4, l2',
+ o2, r2', _res0, r0, _res, r2) ->
+ f3 m1 m2 l1 x1 d1 r1 _x __ _x0 _x1 _x2 _x3 _x4 __ l2' o2 r2' __ __
+ _res0 r0 (coq_R_map2_opt_rec f mapl mapr f0 f1 f2 f3 l1 l2' _res0 r0)
+ _res r2 (coq_R_map2_opt_rec f mapl mapr f0 f1 f2 f3 r1 r2' _res r2)
+
+ (** val fold' : (key -> 'a1 -> 'a2 -> 'a2) -> 'a1 tree -> 'a2 -> 'a2 **)
+
+ let fold' f s =
+ L.fold f (elements s)
+
+ (** val flatten_e : 'a1 enumeration -> (key * 'a1) list **)
+
+ let rec flatten_e = function
+ | End -> Nil
+ | More (x, e0, t0, r) -> Cons ((x, e0), (app (elements t0) (flatten_e r)))
+ end
+ end
+
+module IntMake =
+ functor (I:Int) ->
+ functor (X:OrderedType) ->
+ struct
+ module E = X
+
+ module Raw = Coq_Raw(I)(X)
+
+ type 'elt bst =
+ 'elt Raw.tree
+ (* singleton inductive, whose constructor was Bst *)
+
+ (** val this : 'a1 bst -> 'a1 Raw.tree **)
+
+ let this b =
+ b
+
+ type 'elt t = 'elt bst
+
+ type key = E.t
+
+ (** val empty : 'a1 t **)
+
+ let empty =
+ Raw.empty
+
+ (** val is_empty : 'a1 t -> bool **)
+
+ let is_empty m =
+ Raw.is_empty (this m)
+
+ (** val add : key -> 'a1 -> 'a1 t -> 'a1 t **)
+
+ let add x e m =
+ Raw.add x e (this m)
+
+ (** val remove : key -> 'a1 t -> 'a1 t **)
+
+ let remove x m =
+ Raw.remove x (this m)
+
+ (** val mem : key -> 'a1 t -> bool **)
+
+ let mem x m =
+ Raw.mem x (this m)
+
+ (** val find : key -> 'a1 t -> 'a1 option **)
+
+ let find x m =
+ Raw.find x (this m)
+
+ (** val map : ('a1 -> 'a2) -> 'a1 t -> 'a2 t **)
+
+ let map f m =
+ Raw.map f (this m)
+
+ (** val mapi : (key -> 'a1 -> 'a2) -> 'a1 t -> 'a2 t **)
+
+ let mapi f m =
+ Raw.mapi f (this m)
+
+ (** val map2 :
+ ('a1 option -> 'a2 option -> 'a3 option) -> 'a1 t -> 'a2 t -> 'a3 t **)
+
+ let map2 f m m' =
+ Raw.map2 f (this m) (this m')
+
+ (** val elements : 'a1 t -> (key * 'a1) list **)
+
+ let elements m =
+ Raw.elements (this m)
+
+ (** val cardinal : 'a1 t -> nat **)
+
+ let cardinal m =
+ Raw.cardinal (this m)
+
+ (** val fold : (key -> 'a1 -> 'a2 -> 'a2) -> 'a1 t -> 'a2 -> 'a2 **)
+
+ let fold f m i =
+ Raw.fold f (this m) i
+
+ (** val equal : ('a1 -> 'a1 -> bool) -> 'a1 t -> 'a1 t -> bool **)
+
+ let equal cmp m m' =
+ Raw.equal cmp (this m) (this m')
+ end
+
+module Make =
+ functor (X:OrderedType) ->
+ IntMake(Z_as_Int)(X)
+
+module IntOrderedType =
+ struct
+ type t = Uint63.t
+
+ (** val compare : Uint63.t -> Uint63.t -> Uint63.t compare1 **)
+
+ let compare x y =
+ if ltb0 x y then LT else if eqb0 x y then EQ else GT
+
+ (** val eq_dec : Uint63.t -> Uint63.t -> sumbool **)
+
+ let eq_dec x y =
+ if eqb0 x y then Left else Right
+ end
+
+module Map = Make(IntOrderedType)
+
+type 'a array = ('a Map.t * 'a) * Uint63.t
+
+(** val make : Uint63.t -> 'a1 -> 'a1 array **)
+
+let make l d =
+ ((Map.empty, d), l)
+
+module Coq__1 = struct
+ (** val get : 'a1 array -> Uint63.t -> 'a1 **)
+ let get t0 i =
+ let (td, l) = t0 in
+ let (t1, d) = td in
+ if ltb0 i l then (match Map.find i t1 with
+ | Some x -> x
+ | None -> d) else d
+end
+include Coq__1
+
+(** val set : 'a1 array -> Uint63.t -> 'a1 -> 'a1 array **)
+
+let set t0 i a =
+ let (td, l) = t0 in
+ if leb0 l i then t0 else let (t1, d) = td in (((Map.add i a t1), d), l)
+
+(** val length : 'a1 array -> Uint63.t **)
+
+let length = function
+| (_, l) -> l
+
+(** val iter_int63_aux : nat -> Uint63.t -> ('a1 -> 'a1) -> 'a1 -> 'a1 **)
+
+let rec iter_int63_aux n i f =
+ match n with
+ | O -> (fun x -> x)
+ | S n0 ->
+ if eqb0 i (Uint63.of_int (0))
+ then (fun x -> x)
+ else let g = iter_int63_aux n0 (lsr0 i (Uint63.of_int (1))) f in
+ (fun x -> if bit i (Uint63.of_int (0)) then f (g (g x)) else g (g x))
+
+(** val iter_int63 : Uint63.t -> ('a1 -> 'a1) -> 'a1 -> 'a1 **)
+
+let iter_int63 i f x =
+ iter_int63_aux size i f x
+
+(** val foldi :
+ (Uint63.t -> 'a1 -> 'a1) -> Uint63.t -> Uint63.t -> 'a1 -> 'a1 **)
+
+let foldi f from to0 a =
+ if leb0 to0 from
+ then a
+ else let (_, r) =
+ iter_int63 (sub0 to0 from) (fun jy ->
+ let (j, y) = jy in ((add0 j (Uint63.of_int (1))), (f j y))) (from,
+ a)
+ in
+ r
+
+(** val to_list : 'a1 array -> 'a1 list **)
+
+let to_list t0 =
+ rev
+ (foldi (fun i l -> Cons ((get t0 i), l)) (Uint63.of_int (0)) (length t0)
+ Nil)
+
+module Lit =
+ struct
+ (** val _true : Uint63.t **)
+
let _true =
- (ExtrNative.of_uint(0))
-
- (** val _false : int **)
-
- let _false =
- (ExtrNative.of_uint(2))
-
- (** val eqb : int -> int -> bool **)
-
- let eqb l l' =
- eqb l l'
-
- (** val interp : Valuation.t -> int -> bool **)
-
- let interp rho l =
- if is_pos l
- then Var.interp rho (blit l)
- else negb (Var.interp rho (blit l))
+ (Uint63.of_int (0))
end
-module C =
- struct
- type t = int list
-
- (** val interp : Valuation.t -> t -> bool **)
-
- let interp rho l =
- existsb (Lit.interp rho) l
-
+module C =
+ struct
+ type t = Uint63.t list
+
(** val _true : t **)
-
+
let _true =
Cons (Lit._true, Nil)
-
+
(** val is_false : t -> bool **)
-
+
let is_false = function
| Nil -> true
- | Cons (i, l) -> false
-
- (** val or_aux : (t -> t -> t) -> int -> t -> t -> int list **)
-
+ | Cons (_, _) -> false
+
+ (** val or_aux : (t -> t -> t) -> Uint63.t -> t -> t -> Uint63.t list **)
+
let rec or_aux or0 l1 c1 c2 = match c2 with
| Nil -> Cons (l1, c1)
| Cons (l2, c2') ->
- (match compare l1 l2 with
- | ExtrNative.Eq -> Cons (l1, (or0 c1 c2'))
- | ExtrNative.Lt -> Cons (l1, (or0 c1 c2))
- | ExtrNative.Gt -> Cons (l2, (or_aux or0 l1 c1 c2')))
-
+ (match compare0 l1 l2 with
+ | 0 -> Cons (l1, (or0 c1 c2'))
+ | (-1) -> Cons (l1, (or0 c1 c2))
+ | 1 -> Cons (l2, (or_aux or0 l1 c1 c2')))
+
(** val coq_or : t -> t -> t **)
-
+
let rec coq_or c1 c2 =
match c1 with
| Nil -> c2
@@ -249,29 +2409,29 @@ module C =
(match c2 with
| Nil -> c1
| Cons (l2, c2') ->
- (match compare l1 l2 with
- | ExtrNative.Eq -> Cons (l1, (coq_or c3 c2'))
- | ExtrNative.Lt -> Cons (l1, (coq_or c3 c2))
- | ExtrNative.Gt -> Cons (l2, (or_aux coq_or l1 c3 c2'))))
-
- (** val resolve_aux : (t -> t -> t) -> int -> t -> t -> t **)
-
+ (match compare0 l1 l2 with
+ | 0 -> Cons (l1, (coq_or c3 c2'))
+ | (-1) -> Cons (l1, (coq_or c3 c2))
+ | 1 -> Cons (l2, (or_aux coq_or l1 c3 c2'))))
+
+ (** val resolve_aux : (t -> t -> t) -> Uint63.t -> t -> t -> t **)
+
let rec resolve_aux resolve0 l1 c1 c2 = match c2 with
| Nil -> _true
| Cons (l2, c2') ->
- (match compare l1 l2 with
- | ExtrNative.Eq -> Cons (l1, (resolve0 c1 c2'))
- | ExtrNative.Lt ->
- if eqb (lxor0 l1 l2) (ExtrNative.of_uint(1))
+ (match compare0 l1 l2 with
+ | 0 -> Cons (l1, (resolve0 c1 c2'))
+ | (-1) ->
+ if eqb0 (lxor0 l1 l2) (Uint63.of_int (1))
then coq_or c1 c2'
else Cons (l1, (resolve0 c1 c2))
- | ExtrNative.Gt ->
- if eqb (lxor0 l1 l2) (ExtrNative.of_uint(1))
+ | 1 ->
+ if eqb0 (lxor0 l1 l2) (Uint63.of_int (1))
then coq_or c1 c2'
else Cons (l2, (resolve_aux resolve0 l1 c1 c2')))
-
+
(** val resolve : t -> t -> t **)
-
+
let rec resolve c1 c2 =
match c1 with
| Nil -> _true
@@ -279,165 +2439,107 @@ module C =
(match c2 with
| Nil -> _true
| Cons (l2, c2') ->
- (match compare l1 l2 with
- | ExtrNative.Eq -> Cons (l1, (resolve c3 c2'))
- | ExtrNative.Lt ->
- if eqb (lxor0 l1 l2) (ExtrNative.of_uint(1))
+ (match compare0 l1 l2 with
+ | 0 -> Cons (l1, (resolve c3 c2'))
+ | (-1) ->
+ if eqb0 (lxor0 l1 l2) (Uint63.of_int (1))
then coq_or c3 c2'
else Cons (l1, (resolve c3 c2))
- | ExtrNative.Gt ->
- if eqb (lxor0 l1 l2) (ExtrNative.of_uint(1))
+ | 1 ->
+ if eqb0 (lxor0 l1 l2) (Uint63.of_int (1))
then coq_or c3 c2'
else Cons (l2, (resolve_aux resolve l1 c3 c2'))))
end
-module S =
- struct
+module S =
+ struct
type t = C.t array
-
- (** val get : t -> int -> C.t **)
-
- let get s cid =
- get s cid
-
- (** val internal_set : t -> int -> C.t -> t **)
-
- let internal_set s cid c =
- set s cid c
-
- (** val make : int -> t **)
-
+
+ (** val get : t -> Uint63.t -> C.t **)
+
+ let get =
+ get
+
+ (** val internal_set : t -> Uint63.t -> C.t -> t **)
+
+ let internal_set =
+ set
+
+ (** val make : Uint63.t -> t **)
+
let make nclauses =
make nclauses C._true
-
- (** val insert : int -> int list -> int list **)
-
- let rec insert l1 c = match c with
+
+ (** val insert_no_simpl : Uint63.t -> Uint63.t list -> Uint63.t list **)
+
+ let rec insert_no_simpl l1 c = match c with
| Nil -> Cons (l1, Nil)
| Cons (l2, c') ->
- (match compare l1 l2 with
- | ExtrNative.Eq -> c
- | ExtrNative.Lt ->
- if eqb (lxor0 l1 l2) (ExtrNative.of_uint(1))
- then C._true
- else Cons (l1, c)
- | ExtrNative.Gt ->
- if eqb (lxor0 l1 l2) (ExtrNative.of_uint(1))
- then C._true
- else Cons (l2, (insert l1 c')))
-
- (** val sort_uniq : int list -> int list **)
-
- let rec sort_uniq = function
+ (match compare0 l1 l2 with
+ | 0 -> c
+ | (-1) -> Cons (l1, c)
+ | 1 -> Cons (l2, (insert_no_simpl l1 c')))
+
+ (** val sort : Uint63.t list -> Uint63.t list **)
+
+ let rec sort = function
| Nil -> Nil
- | Cons (l1, c0) -> insert l1 (sort_uniq c0)
-
- (** val set_clause : t -> int -> C.t -> t **)
-
+ | Cons (l1, c0) -> insert_no_simpl l1 (sort c0)
+
+ (** val set_clause : t -> Uint63.t -> C.t -> t **)
+
let set_clause s pos c =
- set s pos (sort_uniq c)
-
- (** val set_resolve : t -> int -> int array -> t **)
-
+ set s pos (sort c)
+
+ (** val set_resolve : t -> Uint63.t -> Uint63.t array -> t **)
+
let set_resolve s pos r =
let len = length r in
- if eqb len (ExtrNative.of_uint(0))
+ if eqb0 len (Uint63.of_int (0))
then s
else let c =
- foldi (fun i c -> C.resolve (get s (Coq__1.get r i)) c)
- (ExtrNative.of_uint(1)) (sub len (ExtrNative.of_uint(1)))
- (get s (Coq__1.get r (ExtrNative.of_uint(0))))
+ foldi (fun i c' -> C.resolve (get s (Coq__1.get r i)) c')
+ (Uint63.of_int (1)) len
+ (get s (Coq__1.get r (Uint63.of_int (0))))
in
internal_set s pos c
end
-(** val afold_left :
- 'a1 -> ('a1 -> 'a1 -> 'a1) -> ('a2 -> 'a1) -> 'a2 array -> 'a1 **)
-
-let afold_left default oP f v =
- let n = length v in
- if eqb n (ExtrNative.of_uint(0))
- then default
- else foldi (fun i a -> oP a (f (get v i))) (ExtrNative.of_uint(1))
- (sub n (ExtrNative.of_uint(1))) (f (get v (ExtrNative.of_uint(0))))
-
-type 'step _trace_ = 'step array array
+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 **)
let _checker_ check_step is_false0 s t0 confl =
- let s' = fold_left (fun s0 a -> fold_left check_step s0 a) s t0 in
- is_false0 (S.get s' confl)
+ let s' = fold_left check_step (fst t0) s in is_false0 (S.get s' confl)
-module Sat_Checker =
- struct
+module Sat_Checker =
+ struct
type step =
- | Res of int * int array
-
- (** val step_rect : (int -> int array -> 'a1) -> step -> 'a1 **)
-
- let step_rect f = function
- | Res (x, x0) -> f x x0
-
- (** val step_rec : (int -> int array -> 'a1) -> step -> 'a1 **)
-
- let step_rec f = function
- | Res (x, x0) -> f x x0
-
+ | Res of Uint63.t * Uint63.t array
+
(** val resolution_checker :
- (C.t -> bool) -> S.t -> step _trace_ -> int -> bool **)
-
+ (C.t -> bool) -> S.t -> step _trace_ -> Uint63.t -> bool **)
+
let resolution_checker s t0 =
_checker_ (fun s0 st -> let Res (pos, r) = st in S.set_resolve s0 pos r)
s t0
-
- type dimacs = int array array
-
- (** val coq_C_interp_or : Valuation.t -> int array -> bool **)
-
- let coq_C_interp_or rho c =
- afold_left false (fun b1 b2 -> if b1 then true else b2) (Lit.interp rho)
- c
-
- (** val valid : Valuation.t -> dimacs -> bool **)
-
- let valid rho d =
- afold_left true (fun b1 b2 -> if b1 then b2 else false)
- (coq_C_interp_or rho) d
-
+
+ type dimacs = Uint63.t array array
+
type certif =
- | Certif of int * step _trace_ * int
-
- (** val certif_rect :
- (int -> step _trace_ -> int -> 'a1) -> certif -> 'a1 **)
-
- let certif_rect f = function
- | Certif (x, x0, x1) -> f x x0 x1
-
- (** val certif_rec :
- (int -> step _trace_ -> int -> 'a1) -> certif -> 'a1 **)
-
- let certif_rec f = function
- | Certif (x, x0, x1) -> f x x0 x1
-
+ | Certif of Uint63.t * step _trace_ * Uint63.t
+
(** val add_roots : S.t -> dimacs -> S.t **)
-
+
let add_roots s d =
- foldi_right (fun i c s0 -> S.set_clause s0 i (to_list c)) d s
-
+ foldi (fun i s0 -> S.set_clause s0 i (to_list (get d i)))
+ (Uint63.of_int (0)) (length d) s
+
(** val checker : dimacs -> certif -> bool **)
-
+
let checker d = function
| Certif (nclauses, t0, confl_id) ->
resolution_checker C.is_false (add_roots (S.make nclauses) d) t0 confl_id
-
- (** val interp_var : (int -> bool) -> int -> bool **)
-
- let interp_var rho x =
- match compare x (ExtrNative.of_uint(1)) with
- | ExtrNative.Eq -> false
- | ExtrNative.Lt -> true
- | ExtrNative.Gt -> rho (sub x (ExtrNative.of_uint(1)))
end
-
diff --git a/src/extraction/sat_checker.mli b/src/extraction/sat_checker.mli
index 3ddb6e5..358c6e8 100644
--- a/src/extraction/sat_checker.mli
+++ b/src/extraction/sat_checker.mli
@@ -1,181 +1,4112 @@
-(**************************************************************************)
-(* *)
-(* 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
val negb : bool -> bool
+type nat =
+| O
+| S of nat
+
+type 'a option =
+| Some of 'a
+| None
+
+val fst : ('a1 * 'a2) -> 'a1
+
+val snd : ('a1 * 'a2) -> 'a2
+
type 'a list =
| Nil
| Cons of 'a * 'a list
-val existsb : ('a1 -> bool) -> 'a1 list -> bool
+val app : 'a1 list -> 'a1 list -> 'a1 list
+
+val compOpp : int -> int
+
+type sumbool =
+| Left
+| Right
+
+val add : nat -> nat -> nat
+
+type positive =
+| XI of positive
+| XO of positive
+| XH
+
+type z =
+| Z0
+| Zpos of positive
+| Zneg of positive
+
+module type EqLtLe =
+ sig
+ type t
+ end
+
+module MakeOrderTac :
+ functor (O:EqLtLe) ->
+ functor (P:sig
+ end) ->
+ sig
+ end
+
+module Pos :
+ sig
+ val succ : positive -> positive
+
+ val add : positive -> positive -> positive
+
+ val add_carry : positive -> positive -> positive
+
+ val pred_double : positive -> positive
+
+ val mul : positive -> positive -> positive
+
+ val compare_cont : int -> positive -> positive -> int
+
+ val compare : positive -> positive -> int
+
+ val eqb : positive -> positive -> bool
+
+ val eq_dec : positive -> positive -> sumbool
+ end
+
+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 sub : z -> z -> z
+
+ val mul : z -> z -> z
+
+ val compare : z -> z -> int
+
+ val leb : z -> z -> bool
+
+ val ltb : z -> z -> bool
+
+ val eqb : z -> z -> bool
+
+ val max : z -> z -> z
+
+ val eq_dec : z -> z -> sumbool
+ end
+
+val rev : 'a1 list -> 'a1 list
+
+val fold_left : ('a1 -> 'a2 -> 'a1) -> 'a2 list -> 'a1 -> 'a1
+
+val fold_right : ('a2 -> 'a1 -> 'a1) -> 'a1 -> 'a2 list -> 'a1
+
+val size : nat
+
+val lsl0 : Uint63.t -> Uint63.t -> Uint63.t
+
+val lsr0 : 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 bit : Uint63.t -> Uint63.t -> bool
+
+val compare0 : Uint63.t -> Uint63.t -> int
+
+type 'x compare1 =
+| LT
+| EQ
+| 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
-type int = ExtrNative.uint
+ val coq_R_fold_correct :
+ (key -> 'a1 -> 'a2 -> 'a2) -> 'a1 t -> 'a2 -> 'a2 -> ('a1, 'a2)
+ coq_R_fold
-val lsl0 : int -> int -> int
+ val equal : ('a1 -> 'a1 -> bool) -> 'a1 t -> 'a1 t -> bool
-val lsr0 : int -> int -> int
+ 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 land0 : int -> int -> int
+ 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 lxor0 : int -> int -> int
+ 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 sub : int -> int -> int
+ 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 eqb : int -> int -> bool
+ 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 foldi_cont :
- (int -> ('a1 -> 'a2) -> 'a1 -> 'a2) -> int -> int -> ('a1 -> 'a2) -> 'a1 ->
- 'a2
+ val coq_R_equal_correct :
+ ('a1 -> 'a1 -> bool) -> 'a1 t -> 'a1 t -> bool -> 'a1 coq_R_equal
-val foldi_down_cont :
- (int -> ('a1 -> 'a2) -> 'a1 -> 'a2) -> int -> int -> ('a1 -> 'a2) -> 'a1 ->
- 'a2
+ val map : ('a1 -> 'a2) -> 'a1 t -> 'a2 t
-val is_zero : int -> bool
+ val mapi : (key -> 'a1 -> 'a2) -> 'a1 t -> 'a2 t
-val is_even : int -> bool
+ val option_cons :
+ key -> 'a1 option -> (key * 'a1) list -> (key * 'a1) list
-val compare : int -> int -> ExtrNative.comparison
+ val map2_l :
+ ('a1 option -> 'a2 option -> 'a3 option) -> 'a1 t -> 'a3 t
-val foldi : (int -> 'a1 -> 'a1) -> int -> int -> 'a1 -> 'a1
+ val map2_r :
+ ('a1 option -> 'a2 option -> 'a3 option) -> 'a2 t -> 'a3 t
-val foldi_down : (int -> 'a1 -> 'a1) -> int -> int -> 'a1 -> 'a1
+ val map2 :
+ ('a1 option -> 'a2 option -> 'a3 option) -> 'a1 t -> 'a2 t -> 'a3 t
-type 'a array = 'a ExtrNative.parray
+ val combine : 'a1 t -> 'a2 t -> ('a1 option * 'a2 option) t
-val make : int -> 'a1 -> 'a1 array
+ val fold_right_pair :
+ ('a1 -> 'a2 -> 'a3 -> 'a3) -> ('a1 * 'a2) list -> 'a3 -> 'a3
-val get : 'a1 array -> int -> 'a1
+ val map2_alt :
+ ('a1 option -> 'a2 option -> 'a3 option) -> 'a1 t -> 'a2 t ->
+ (key * 'a3) list
-val set : 'a1 array -> int -> 'a1 -> 'a1 array
+ val at_least_one :
+ 'a1 option -> 'a2 option -> ('a1 option * 'a2 option) option
-val length : 'a1 array -> int
+ 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 set : 'a1 array -> Uint63.t -> 'a1 -> 'a1 array
+
+val length : '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 fold_left : ('a1 -> 'a2 -> 'a1) -> 'a1 -> 'a2 array -> 'a1
-
-val foldi_right : (int -> 'a1 -> 'a2 -> 'a2) -> 'a1 array -> 'a2 -> 'a2
-
-module Valuation :
- sig
- type t = int -> bool
- end
-
-module Var :
- sig
- val _true : int
-
- val _false : int
-
- val interp : Valuation.t -> int -> bool
- end
-
-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
-
-module C :
- sig
- type t = int list
-
- val interp : Valuation.t -> t -> bool
-
+module Lit :
+ sig
+ val _true : 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) -> int -> t -> t -> int list
-
+
+ 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) -> int -> t -> t -> t
-
+
+ val resolve_aux : (t -> t -> t) -> Uint63.t -> t -> t -> t
+
val resolve : t -> t -> t
end
-module S :
- sig
+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
- end
-
-val afold_left :
- 'a1 -> ('a1 -> 'a1 -> 'a1) -> ('a2 -> 'a1) -> 'a2 array -> 'a1
-
-type 'step _trace_ = 'step array 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 sort : Uint63.t list -> Uint63.t list
+
+ val set_clause : t -> Uint63.t -> C.t -> t
+
+ val set_resolve : t -> Uint63.t -> Uint63.t array -> t
+ end
+
+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 Sat_Checker :
- sig
+module Sat_Checker :
+ sig
type step =
- | Res of int * int array
-
- val step_rect : (int -> int array -> 'a1) -> step -> 'a1
-
- val step_rec : (int -> int array -> 'a1) -> step -> 'a1
-
+ | Res of Uint63.t * Uint63.t array
+
val resolution_checker :
- (C.t -> bool) -> S.t -> step _trace_ -> int -> bool
-
- type dimacs = int array array
-
- val coq_C_interp_or : Valuation.t -> int array -> bool
-
- val valid : Valuation.t -> dimacs -> bool
-
+ (C.t -> bool) -> S.t -> step _trace_ -> Uint63.t -> bool
+
+ type dimacs = Uint63.t array array
+
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
-
+ | Certif of Uint63.t * step _trace_ * Uint63.t
+
val add_roots : S.t -> dimacs -> S.t
-
+
val checker : dimacs -> certif -> bool
-
- val interp_var : (int -> bool) -> int -> bool
end
-
diff --git a/src/extraction/smt_checker.ml b/src/extraction/smt_checker.ml
index 96ba4a3..deb51fc 100644
--- a/src/extraction/smt_checker.ml
+++ b/src/extraction/smt_checker.ml
@@ -1,14 +1,3 @@
-(**************************************************************************)
-(* *)
-(* 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
let __ = let rec f _ = Obj.repr f in Obj.repr f
@@ -16,16 +5,6 @@ let __ = let rec f _ = Obj.repr f in Obj.repr f
type unit0 =
| Tt
-(** val implb : bool -> bool -> bool **)
-
-let implb b1 b2 =
- if b1 then b2 else true
-
-(** val xorb : bool -> bool -> bool **)
-
-let xorb b1 b2 =
- if b1 then if b2 then false else true else b2
-
(** val negb : bool -> bool **)
let negb = function
@@ -46,20 +25,26 @@ let option_map f = function
| Some a -> Some (f a)
| None -> None
-(** val fst : ('a1*'a2) -> 'a1 **)
+(** val fst : ('a1 * 'a2) -> 'a1 **)
let fst = function
-| x,y -> x
+| (x, _) -> x
-(** val snd : ('a1*'a2) -> 'a2 **)
+(** val snd : ('a1 * 'a2) -> 'a2 **)
let snd = function
-| x,y -> y
+| (_, y) -> y
type 'a list =
| Nil
| Cons of 'a * 'a list
+(** val length : 'a1 list -> nat **)
+
+let rec length = function
+| Nil -> O
+| Cons (_, l') -> S (length l')
+
(** val app : 'a1 list -> 'a1 list -> 'a1 list **)
let rec app l m =
@@ -67,58 +52,32 @@ let rec app l m =
| Nil -> m
| Cons (a, l1) -> Cons (a, (app l1 m))
-(** val compOpp : ExtrNative.comparison -> ExtrNative.comparison **)
+(** val compOpp : int -> int **)
let compOpp = function
-| ExtrNative.Eq -> ExtrNative.Eq
-| ExtrNative.Lt -> ExtrNative.Gt
-| ExtrNative.Gt -> ExtrNative.Lt
-
-type compareSpecT =
-| CompEqT
-| CompLtT
-| CompGtT
-
-(** val compareSpec2Type : ExtrNative.comparison -> compareSpecT **)
-
-let compareSpec2Type = function
-| ExtrNative.Eq -> CompEqT
-| ExtrNative.Lt -> CompLtT
-| ExtrNative.Gt -> CompGtT
-
-type 'a compSpecT = compareSpecT
-
-(** val compSpec2Type :
- 'a1 -> 'a1 -> ExtrNative.comparison -> 'a1 compSpecT **)
-
-let compSpec2Type x y c =
- compareSpec2Type c
-
-type 'a sig0 =
- 'a
- (* singleton inductive, whose constructor was exist *)
+| 0 -> 0
+| (-1) -> 1
+| 1 -> (-1)
type sumbool =
| Left
| Right
-type 'a sumor =
-| Inleft of 'a
-| Inright
-
-(** val plus : nat -> nat -> nat **)
-
-let rec plus n0 m =
- match n0 with
- | O -> m
- | S p -> S (plus p m)
+module Coq__1 = struct
+ (** val add : nat -> nat -> nat **)
+ let rec add n0 m =
+ match n0 with
+ | O -> m
+ | S p -> S (add p m)
+end
+include Coq__1
-(** val nat_iter : nat -> ('a1 -> 'a1) -> 'a1 -> 'a1 **)
+(** val mul : nat -> nat -> nat **)
-let rec nat_iter n0 f x =
+let rec mul n0 m =
match n0 with
- | O -> x
- | S n' -> f (nat_iter n' f x)
+ | O -> O
+ | S p -> add m (mul p m)
type positive =
| XI of positive
@@ -139,610 +98,51 @@ type z =
let eqb b1 b2 =
if b1 then b2 else if b2 then false else true
-type reflect =
-| ReflectT
-| ReflectF
-
-(** val iff_reflect : bool -> reflect **)
-
-let iff_reflect = function
-| true -> ReflectT
-| false -> ReflectF
-
-module type TotalOrder' =
- sig
- type t
+module type EqLtLe =
+ sig
+ type t
end
-module MakeOrderTac =
- functor (O:TotalOrder') ->
- struct
-
+module MakeOrderTac =
+ functor (O:EqLtLe) ->
+ functor (P:sig
+ end) ->
+ struct
end
-module MaxLogicalProperties =
- functor (O:TotalOrder') ->
- functor (M:sig
- val max : O.t -> O.t -> O.t
- end) ->
- struct
- module Private_Tac = MakeOrderTac(O)
+module Nat =
+ struct
+ (** val eqb : nat -> nat -> bool **)
+
+ let rec eqb n0 m =
+ match n0 with
+ | O -> (match m with
+ | O -> true
+ | S _ -> false)
+ | S n' -> (match m with
+ | O -> false
+ | S m' -> eqb n' m')
end
-module Pos =
- struct
- type t = positive
-
- (** val succ : positive -> positive **)
-
- let rec succ = function
- | XI p -> XO (succ p)
- | XO p -> XI p
- | XH -> XO XH
-
- (** val add : positive -> positive -> positive **)
-
- let rec add x y =
- match x with
- | XI p ->
- (match y with
- | XI q -> XO (add_carry p q)
- | XO q -> XI (add p q)
- | XH -> XO (succ p))
- | XO p ->
- (match y with
- | XI q -> XI (add p q)
- | XO q -> XO (add p q)
- | XH -> XI p)
- | XH ->
- (match y with
- | XI q -> XO (succ q)
- | XO q -> XI q
- | XH -> XO XH)
-
- (** val add_carry : positive -> positive -> positive **)
-
- and add_carry x y =
- match x with
- | XI p ->
- (match y with
- | XI q -> XI (add_carry p q)
- | XO q -> XO (add_carry p q)
- | XH -> XI (succ p))
- | XO p ->
- (match y with
- | XI q -> XO (add_carry p q)
- | XO q -> XI (add p q)
- | XH -> XO (succ p))
- | XH ->
- (match y with
- | XI q -> XI (succ q)
- | XO q -> XO (succ q)
- | XH -> XI XH)
-
- (** val pred_double : positive -> positive **)
-
- let rec pred_double = function
- | XI p -> XI (XO p)
- | XO p -> XI (pred_double p)
- | XH -> XH
-
- (** val pred : positive -> positive **)
-
- let pred = function
- | XI p -> XO p
- | XO p -> pred_double p
- | XH -> XH
-
- (** val pred_N : positive -> n **)
-
- let pred_N = function
- | XI p -> Npos (XO p)
- | XO p -> Npos (pred_double p)
- | XH -> N0
-
+module Pos =
+ struct
type mask =
| IsNul
| IsPos of positive
| IsNeg
-
- (** val mask_rect : 'a1 -> (positive -> 'a1) -> 'a1 -> mask -> 'a1 **)
-
- let mask_rect f f0 f1 = function
- | IsNul -> f
- | IsPos x -> f0 x
- | IsNeg -> f1
-
- (** val mask_rec : 'a1 -> (positive -> 'a1) -> 'a1 -> mask -> 'a1 **)
-
- let mask_rec f f0 f1 = function
- | IsNul -> f
- | IsPos x -> f0 x
- | IsNeg -> f1
-
- (** val succ_double_mask : mask -> mask **)
-
- let succ_double_mask = function
- | IsNul -> IsPos XH
- | IsPos p -> IsPos (XI p)
- | IsNeg -> IsNeg
-
- (** val double_mask : mask -> mask **)
-
- let double_mask = function
- | IsPos p -> IsPos (XO p)
- | x0 -> x0
-
- (** val double_pred_mask : positive -> mask **)
-
- let double_pred_mask = function
- | XI p -> IsPos (XO (XO p))
- | XO p -> IsPos (XO (pred_double p))
- | XH -> IsNul
-
- (** val pred_mask : mask -> mask **)
-
- let pred_mask = function
- | IsPos q ->
- (match q with
- | XH -> IsNul
- | _ -> IsPos (pred q))
- | _ -> IsNeg
-
- (** val sub_mask : positive -> positive -> mask **)
-
- let rec sub_mask x y =
- match x with
- | XI p ->
- (match y with
- | XI q -> double_mask (sub_mask p q)
- | XO q -> succ_double_mask (sub_mask p q)
- | XH -> IsPos (XO p))
- | XO p ->
- (match y with
- | XI q -> succ_double_mask (sub_mask_carry p q)
- | XO q -> double_mask (sub_mask p q)
- | XH -> IsPos (pred_double p))
- | XH ->
- (match y with
- | XH -> IsNul
- | _ -> IsNeg)
-
- (** val sub_mask_carry : positive -> positive -> mask **)
-
- and sub_mask_carry x y =
- match x with
- | XI p ->
- (match y with
- | XI q -> succ_double_mask (sub_mask_carry p q)
- | XO q -> double_mask (sub_mask p q)
- | XH -> IsPos (pred_double p))
- | XO p ->
- (match y with
- | XI q -> double_mask (sub_mask_carry p q)
- | XO q -> succ_double_mask (sub_mask_carry p q)
- | XH -> double_pred_mask p)
- | XH -> IsNeg
-
- (** val sub : positive -> positive -> positive **)
-
- let sub x y =
- match sub_mask x y with
- | IsPos z0 -> z0
- | _ -> XH
-
- (** val mul : positive -> positive -> positive **)
-
- let rec mul x y =
- match x with
- | XI p -> add y (XO (mul p y))
- | XO p -> XO (mul p y)
- | XH -> y
-
- (** val iter : positive -> ('a1 -> 'a1) -> 'a1 -> 'a1 **)
-
- let rec iter n0 f x =
- match n0 with
- | XI n' -> f (iter n' f (iter n' f x))
- | XO n' -> iter n' f (iter n' f x)
- | XH -> f x
-
- (** val pow : positive -> positive -> positive **)
-
- let pow x y =
- iter y (mul x) XH
-
- (** val square : positive -> positive **)
-
- let rec square = function
- | XI p2 -> XI (XO (add (square p2) p2))
- | XO p2 -> XO (XO (square p2))
- | XH -> XH
-
- (** val div2 : positive -> positive **)
-
- let div2 = function
- | XI p2 -> p2
- | XO p2 -> p2
- | XH -> XH
-
- (** val div2_up : positive -> positive **)
-
- let div2_up = function
- | XI p2 -> succ p2
- | XO p2 -> p2
- | XH -> XH
-
- (** val size_nat : positive -> nat **)
-
- let rec size_nat = function
- | XI p2 -> S (size_nat p2)
- | XO p2 -> S (size_nat p2)
- | XH -> S O
-
- (** val size : positive -> positive **)
-
- let rec size = function
- | XI p2 -> succ (size p2)
- | XO p2 -> succ (size p2)
- | XH -> XH
-
- (** val compare_cont :
- positive -> positive -> ExtrNative.comparison -> ExtrNative.comparison **)
-
- let rec compare_cont x y r =
- match x with
- | XI p ->
- (match y with
- | XI q -> compare_cont p q r
- | XO q -> compare_cont p q ExtrNative.Gt
- | XH -> ExtrNative.Gt)
- | XO p ->
- (match y with
- | XI q -> compare_cont p q ExtrNative.Lt
- | XO q -> compare_cont p q r
- | XH -> ExtrNative.Gt)
- | XH ->
- (match y with
- | XH -> r
- | _ -> ExtrNative.Lt)
-
- (** val compare : positive -> positive -> ExtrNative.comparison **)
-
- let compare x y =
- compare_cont x y ExtrNative.Eq
-
- (** val min : positive -> positive -> positive **)
-
- let min p p' =
- match compare p p' with
- | ExtrNative.Gt -> p'
- | _ -> p
-
- (** val max : positive -> positive -> positive **)
-
- let max p p' =
- match compare p p' with
- | ExtrNative.Gt -> p
- | _ -> p'
-
- (** val eqb : positive -> positive -> bool **)
-
- let rec eqb p q =
- match p with
- | XI p2 ->
- (match q with
- | XI q0 -> eqb p2 q0
- | _ -> false)
- | XO p2 ->
- (match q with
- | XO q0 -> eqb p2 q0
- | _ -> false)
- | XH ->
- (match q with
- | XH -> true
- | _ -> false)
-
- (** val leb : positive -> positive -> bool **)
-
- let leb x y =
- match compare x y with
- | ExtrNative.Gt -> false
- | _ -> true
-
- (** val ltb : positive -> positive -> bool **)
-
- let ltb x y =
- match compare x y with
- | ExtrNative.Lt -> true
- | _ -> false
-
- (** val sqrtrem_step :
- (positive -> positive) -> (positive -> positive) -> (positive*mask) ->
- positive*mask **)
-
- let sqrtrem_step f g = function
- | s,y ->
- (match y with
- | IsPos r ->
- let s' = XI (XO s) in
- let r' = g (f r) in
- if leb s' r' then (XI s),(sub_mask r' s') else (XO s),(IsPos r')
- | _ -> (XO s),(sub_mask (g (f XH)) (XO (XO XH))))
-
- (** val sqrtrem : positive -> positive*mask **)
-
- let rec sqrtrem = function
- | XI p2 ->
- (match p2 with
- | XI p3 -> sqrtrem_step (fun x -> XI x) (fun x -> XI x) (sqrtrem p3)
- | XO p3 -> sqrtrem_step (fun x -> XO x) (fun x -> XI x) (sqrtrem p3)
- | XH -> XH,(IsPos (XO XH)))
- | XO p2 ->
- (match p2 with
- | XI p3 -> sqrtrem_step (fun x -> XI x) (fun x -> XO x) (sqrtrem p3)
- | XO p3 -> sqrtrem_step (fun x -> XO x) (fun x -> XO x) (sqrtrem p3)
- | XH -> XH,(IsPos XH))
- | XH -> XH,IsNul
-
- (** val sqrt : positive -> positive **)
-
- let sqrt p =
- fst (sqrtrem p)
-
- (** val gcdn : nat -> positive -> positive -> positive **)
-
- let rec gcdn n0 a b =
- match n0 with
- | O -> XH
- | S n1 ->
- (match a with
- | XI a' ->
- (match b with
- | XI b' ->
- (match compare a' b' with
- | ExtrNative.Eq -> a
- | ExtrNative.Lt -> gcdn n1 (sub b' a') a
- | ExtrNative.Gt -> gcdn n1 (sub a' b') b)
- | XO b0 -> gcdn n1 a b0
- | XH -> XH)
- | XO a0 ->
- (match b with
- | XI p -> gcdn n1 a0 b
- | XO b0 -> XO (gcdn n1 a0 b0)
- | XH -> XH)
- | XH -> XH)
-
- (** val gcd : positive -> positive -> positive **)
-
- let gcd a b =
- gcdn (plus (size_nat a) (size_nat b)) a b
-
- (** val ggcdn :
- nat -> positive -> positive -> positive*(positive*positive) **)
-
- let rec ggcdn n0 a b =
- match n0 with
- | O -> XH,(a,b)
- | S n1 ->
- (match a with
- | XI a' ->
- (match b with
- | XI b' ->
- (match compare a' b' with
- | ExtrNative.Eq -> a,(XH,XH)
- | ExtrNative.Lt ->
- let g,p = ggcdn n1 (sub b' a') a in
- let ba,aa = p in g,(aa,(add aa (XO ba)))
- | ExtrNative.Gt ->
- let g,p = ggcdn n1 (sub a' b') b in
- let ab,bb = p in g,((add bb (XO ab)),bb))
- | XO b0 ->
- let g,p = ggcdn n1 a b0 in let aa,bb = p in g,(aa,(XO bb))
- | XH -> XH,(a,XH))
- | XO a0 ->
- (match b with
- | XI p ->
- let g,p2 = ggcdn n1 a0 b in let aa,bb = p2 in g,((XO aa),bb)
- | XO b0 -> let g,p = ggcdn n1 a0 b0 in (XO g),p
- | XH -> XH,(a,XH))
- | XH -> XH,(XH,b))
-
- (** val ggcd : positive -> positive -> positive*(positive*positive) **)
-
- let ggcd a b =
- ggcdn (plus (size_nat a) (size_nat b)) a b
-
- (** val coq_Nsucc_double : n -> n **)
-
- let coq_Nsucc_double = function
- | N0 -> Npos XH
- | Npos p -> Npos (XI p)
-
- (** val coq_Ndouble : n -> n **)
-
- let coq_Ndouble = function
- | N0 -> N0
- | Npos p -> Npos (XO p)
-
- (** val coq_lor : positive -> positive -> positive **)
-
- let rec coq_lor p q =
- match p with
- | XI p2 ->
- (match q with
- | XI q0 -> XI (coq_lor p2 q0)
- | XO q0 -> XI (coq_lor p2 q0)
- | XH -> p)
- | XO p2 ->
- (match q with
- | XI q0 -> XI (coq_lor p2 q0)
- | XO q0 -> XO (coq_lor p2 q0)
- | XH -> XI p2)
- | XH ->
- (match q with
- | XO q0 -> XI q0
- | _ -> q)
-
- (** val coq_land : positive -> positive -> n **)
-
- let rec coq_land p q =
- match p with
- | XI p2 ->
- (match q with
- | XI q0 -> coq_Nsucc_double (coq_land p2 q0)
- | XO q0 -> coq_Ndouble (coq_land p2 q0)
- | XH -> Npos XH)
- | XO p2 ->
- (match q with
- | XI q0 -> coq_Ndouble (coq_land p2 q0)
- | XO q0 -> coq_Ndouble (coq_land p2 q0)
- | XH -> N0)
- | XH ->
- (match q with
- | XO q0 -> N0
- | _ -> Npos XH)
-
- (** val ldiff : positive -> positive -> n **)
-
- let rec ldiff p q =
- match p with
- | XI p2 ->
- (match q with
- | XI q0 -> coq_Ndouble (ldiff p2 q0)
- | XO q0 -> coq_Nsucc_double (ldiff p2 q0)
- | XH -> Npos (XO p2))
- | XO p2 ->
- (match q with
- | XI q0 -> coq_Ndouble (ldiff p2 q0)
- | XO q0 -> coq_Ndouble (ldiff p2 q0)
- | XH -> Npos p)
- | XH ->
- (match q with
- | XO q0 -> Npos XH
- | _ -> N0)
-
- (** val coq_lxor : positive -> positive -> n **)
-
- let rec coq_lxor p q =
- match p with
- | XI p2 ->
- (match q with
- | XI q0 -> coq_Ndouble (coq_lxor p2 q0)
- | XO q0 -> coq_Nsucc_double (coq_lxor p2 q0)
- | XH -> Npos (XO p2))
- | XO p2 ->
- (match q with
- | XI q0 -> coq_Nsucc_double (coq_lxor p2 q0)
- | XO q0 -> coq_Ndouble (coq_lxor p2 q0)
- | XH -> Npos (XI p2))
- | XH ->
- (match q with
- | XI q0 -> Npos (XO q0)
- | XO q0 -> Npos (XI q0)
- | XH -> N0)
-
- (** val shiftl_nat : positive -> nat -> positive **)
-
- let shiftl_nat p n0 =
- nat_iter n0 (fun x -> XO x) p
-
- (** val shiftr_nat : positive -> nat -> positive **)
-
- let shiftr_nat p n0 =
- nat_iter n0 div2 p
-
- (** val shiftl : positive -> n -> positive **)
-
- let shiftl p = function
- | N0 -> p
- | Npos n1 -> iter n1 (fun x -> XO x) p
-
- (** val shiftr : positive -> n -> positive **)
-
- let shiftr p = function
- | N0 -> p
- | Npos n1 -> iter n1 div2 p
-
- (** val testbit_nat : positive -> nat -> bool **)
-
- let rec testbit_nat p n0 =
- match p with
- | XI p2 ->
- (match n0 with
- | O -> true
- | S n' -> testbit_nat p2 n')
- | XO p2 ->
- (match n0 with
- | O -> false
- | S n' -> testbit_nat p2 n')
- | XH ->
- (match n0 with
- | O -> true
- | S n1 -> false)
-
- (** val testbit : positive -> n -> bool **)
-
- let rec testbit p n0 =
- match p with
- | XI p2 ->
- (match n0 with
- | N0 -> true
- | Npos n1 -> testbit p2 (pred_N n1))
- | XO p2 ->
- (match n0 with
- | N0 -> false
- | Npos n1 -> testbit p2 (pred_N n1))
- | XH ->
- (match n0 with
- | N0 -> true
- | Npos p2 -> false)
-
- (** val iter_op : ('a1 -> 'a1 -> 'a1) -> positive -> 'a1 -> 'a1 **)
-
- let rec iter_op op p a =
- match p with
- | XI p2 -> op a (iter_op op p2 (op a a))
- | XO p2 -> iter_op op p2 (op a a)
- | XH -> a
-
- (** val to_nat : positive -> nat **)
-
- let to_nat x =
- iter_op plus x (S O)
-
- (** val of_nat : nat -> positive **)
-
- let rec of_nat = function
- | O -> XH
- | S x ->
- (match x with
- | O -> XH
- | S n1 -> succ (of_nat x))
-
- (** val of_succ_nat : nat -> positive **)
-
- let rec of_succ_nat = function
- | O -> XH
- | S x -> succ (of_succ_nat x)
end
-module Coq_Pos =
- struct
- module Coq__1 = struct
- type t = positive
- end
- type t = Coq__1.t
-
+module Coq_Pos =
+ struct
(** val succ : positive -> positive **)
-
+
let rec succ = function
| XI p -> XO (succ p)
| XO p -> XI p
| XH -> XO XH
-
+
(** val add : positive -> positive -> positive **)
-
+
let rec add x y =
match x with
| XI p ->
@@ -755,14 +155,13 @@ module Coq_Pos =
| XI q -> XI (add p q)
| XO q -> XO (add p q)
| XH -> XI p)
- | XH ->
- (match y with
- | XI q -> XO (succ q)
- | XO q -> XI q
- | XH -> XO XH)
-
+ | XH -> (match y with
+ | XI q -> XO (succ q)
+ | XO q -> XI q
+ | XH -> XO XH)
+
(** val add_carry : positive -> positive -> positive **)
-
+
and add_carry x y =
match x with
| XI p ->
@@ -780,78 +179,48 @@ module Coq_Pos =
| XI q -> XI (succ q)
| XO q -> XO (succ q)
| XH -> XI XH)
-
+
(** val pred_double : positive -> positive **)
-
+
let rec pred_double = function
| XI p -> XI (XO p)
| XO p -> XI (pred_double p)
| XH -> XH
-
+
(** val pred : positive -> positive **)
-
+
let pred = function
| XI p -> XO p
| XO p -> pred_double p
| XH -> XH
-
- (** val pred_N : positive -> n **)
-
- let pred_N = function
- | XI p -> Npos (XO p)
- | XO p -> Npos (pred_double p)
- | XH -> N0
-
+
type mask = Pos.mask =
| IsNul
| IsPos of positive
| IsNeg
-
- (** val mask_rect : 'a1 -> (positive -> 'a1) -> 'a1 -> mask -> 'a1 **)
-
- let mask_rect f f0 f1 = function
- | IsNul -> f
- | IsPos x -> f0 x
- | IsNeg -> f1
-
- (** val mask_rec : 'a1 -> (positive -> 'a1) -> 'a1 -> mask -> 'a1 **)
-
- let mask_rec f f0 f1 = function
- | IsNul -> f
- | IsPos x -> f0 x
- | IsNeg -> f1
-
+
(** val succ_double_mask : mask -> mask **)
-
+
let succ_double_mask = function
| IsNul -> IsPos XH
| IsPos p -> IsPos (XI p)
| IsNeg -> IsNeg
-
+
(** val double_mask : mask -> mask **)
-
+
let double_mask = function
| IsPos p -> IsPos (XO p)
| x0 -> x0
-
+
(** val double_pred_mask : positive -> mask **)
-
+
let double_pred_mask = function
| XI p -> IsPos (XO (XO p))
| XO p -> IsPos (XO (pred_double p))
| XH -> IsNul
-
- (** val pred_mask : mask -> mask **)
-
- let pred_mask = function
- | IsPos q ->
- (match q with
- | XH -> IsNul
- | _ -> IsPos (pred q))
- | _ -> IsNeg
-
+
(** val sub_mask : positive -> positive -> mask **)
-
+
let rec sub_mask x y =
match x with
| XI p ->
@@ -864,13 +233,12 @@ module Coq_Pos =
| XI q -> succ_double_mask (sub_mask_carry p q)
| XO q -> double_mask (sub_mask p q)
| XH -> IsPos (pred_double p))
- | XH ->
- (match y with
- | XH -> IsNul
- | _ -> IsNeg)
-
+ | XH -> (match y with
+ | XH -> IsNul
+ | _ -> IsNeg)
+
(** val sub_mask_carry : positive -> positive -> mask **)
-
+
and sub_mask_carry x y =
match x with
| XI p ->
@@ -884,175 +252,82 @@ module Coq_Pos =
| XO q -> succ_double_mask (sub_mask_carry p q)
| XH -> double_pred_mask p)
| XH -> IsNeg
-
+
(** val sub : positive -> positive -> positive **)
-
+
let sub x y =
match sub_mask x y with
| IsPos z0 -> z0
| _ -> XH
-
+
(** val mul : positive -> positive -> positive **)
-
+
let rec mul x y =
match x with
| XI p -> add y (XO (mul p y))
| XO p -> XO (mul p y)
| XH -> y
-
- (** val iter : positive -> ('a1 -> 'a1) -> 'a1 -> 'a1 **)
-
- let rec iter n0 f x =
- match n0 with
- | XI n' -> f (iter n' f (iter n' f x))
- | XO n' -> iter n' f (iter n' f x)
- | XH -> f x
-
- (** val pow : positive -> positive -> positive **)
-
- let pow x y =
- iter y (mul x) XH
-
- (** val square : positive -> positive **)
-
- let rec square = function
- | XI p2 -> XI (XO (add (square p2) p2))
- | XO p2 -> XO (XO (square p2))
- | XH -> XH
-
- (** val div2 : positive -> positive **)
-
- let div2 = function
- | XI p2 -> p2
- | XO p2 -> p2
- | XH -> XH
-
- (** val div2_up : positive -> positive **)
-
- let div2_up = function
- | XI p2 -> succ p2
- | XO p2 -> p2
- | XH -> XH
-
+
(** val size_nat : positive -> nat **)
-
+
let rec size_nat = function
| XI p2 -> S (size_nat p2)
| XO p2 -> S (size_nat p2)
| XH -> S O
-
- (** val size : positive -> positive **)
-
- let rec size = function
- | XI p2 -> succ (size p2)
- | XO p2 -> succ (size p2)
- | XH -> XH
-
- (** val compare_cont :
- positive -> positive -> ExtrNative.comparison -> ExtrNative.comparison **)
-
- let rec compare_cont x y r =
+
+ (** val compare_cont : int -> positive -> positive -> int **)
+
+ let rec compare_cont r x y =
match x with
| XI p ->
(match y with
- | XI q -> compare_cont p q r
- | XO q -> compare_cont p q ExtrNative.Gt
- | XH -> ExtrNative.Gt)
+ | XI q -> compare_cont r p q
+ | XO q -> compare_cont 1 p q
+ | XH -> 1)
| XO p ->
(match y with
- | XI q -> compare_cont p q ExtrNative.Lt
- | XO q -> compare_cont p q r
- | XH -> ExtrNative.Gt)
- | XH ->
- (match y with
- | XH -> r
- | _ -> ExtrNative.Lt)
-
- (** val compare : positive -> positive -> ExtrNative.comparison **)
-
- let compare x y =
- compare_cont x y ExtrNative.Eq
-
- (** val min : positive -> positive -> positive **)
-
- let min p p' =
- match compare p p' with
- | ExtrNative.Gt -> p'
- | _ -> p
-
+ | XI q -> compare_cont (-1) p q
+ | XO q -> compare_cont r p q
+ | XH -> 1)
+ | XH -> (match y with
+ | XH -> r
+ | _ -> (-1))
+
+ (** val compare : positive -> positive -> int **)
+
+ let compare =
+ compare_cont 0
+
(** val max : positive -> positive -> positive **)
-
+
let max p p' =
match compare p p' with
- | ExtrNative.Gt -> p
+ | 1 -> p
| _ -> p'
-
+
(** val eqb : positive -> positive -> bool **)
-
+
let rec eqb p q =
match p with
- | XI p2 ->
- (match q with
- | XI q0 -> eqb p2 q0
- | _ -> false)
- | XO p2 ->
- (match q with
- | XO q0 -> eqb p2 q0
- | _ -> false)
- | XH ->
- (match q with
- | XH -> true
- | _ -> false)
-
+ | XI p2 -> (match q with
+ | XI q0 -> eqb p2 q0
+ | _ -> false)
+ | XO p2 -> (match q with
+ | XO q0 -> eqb p2 q0
+ | _ -> false)
+ | XH -> (match q with
+ | XH -> true
+ | _ -> false)
+
(** val leb : positive -> positive -> bool **)
-
+
let leb x y =
match compare x y with
- | ExtrNative.Gt -> false
+ | 1 -> false
| _ -> true
-
- (** val ltb : positive -> positive -> bool **)
-
- let ltb x y =
- match compare x y with
- | ExtrNative.Lt -> true
- | _ -> false
-
- (** val sqrtrem_step :
- (positive -> positive) -> (positive -> positive) -> (positive*mask) ->
- positive*mask **)
-
- let sqrtrem_step f g = function
- | s,y ->
- (match y with
- | IsPos r ->
- let s' = XI (XO s) in
- let r' = g (f r) in
- if leb s' r' then (XI s),(sub_mask r' s') else (XO s),(IsPos r')
- | _ -> (XO s),(sub_mask (g (f XH)) (XO (XO XH))))
-
- (** val sqrtrem : positive -> positive*mask **)
-
- let rec sqrtrem = function
- | XI p2 ->
- (match p2 with
- | XI p3 -> sqrtrem_step (fun x -> XI x) (fun x -> XI x) (sqrtrem p3)
- | XO p3 -> sqrtrem_step (fun x -> XO x) (fun x -> XI x) (sqrtrem p3)
- | XH -> XH,(IsPos (XO XH)))
- | XO p2 ->
- (match p2 with
- | XI p3 -> sqrtrem_step (fun x -> XI x) (fun x -> XO x) (sqrtrem p3)
- | XO p3 -> sqrtrem_step (fun x -> XO x) (fun x -> XO x) (sqrtrem p3)
- | XH -> XH,(IsPos XH))
- | XH -> XH,IsNul
-
- (** val sqrt : positive -> positive **)
-
- let sqrt p =
- fst (sqrtrem p)
-
+
(** val gcdn : nat -> positive -> positive -> positive **)
-
+
let rec gcdn n0 a b =
match n0 with
| O -> XH
@@ -1062,500 +337,70 @@ module Coq_Pos =
(match b with
| XI b' ->
(match compare a' b' with
- | ExtrNative.Eq -> a
- | ExtrNative.Lt -> gcdn n1 (sub b' a') a
- | ExtrNative.Gt -> gcdn n1 (sub a' b') b)
+ | 0 -> a
+ | (-1) -> gcdn n1 (sub b' a') a
+ | 1 -> gcdn n1 (sub a' b') b)
| XO b0 -> gcdn n1 a b0
| XH -> XH)
| XO a0 ->
(match b with
- | XI p -> gcdn n1 a0 b
+ | XI _ -> gcdn n1 a0 b
| XO b0 -> XO (gcdn n1 a0 b0)
| XH -> XH)
| XH -> XH)
-
+
(** val gcd : positive -> positive -> positive **)
-
+
let gcd a b =
- gcdn (plus (size_nat a) (size_nat b)) a b
-
- (** val ggcdn :
- nat -> positive -> positive -> positive*(positive*positive) **)
-
- let rec ggcdn n0 a b =
- match n0 with
- | O -> XH,(a,b)
- | S n1 ->
- (match a with
- | XI a' ->
- (match b with
- | XI b' ->
- (match compare a' b' with
- | ExtrNative.Eq -> a,(XH,XH)
- | ExtrNative.Lt ->
- let g,p = ggcdn n1 (sub b' a') a in
- let ba,aa = p in g,(aa,(add aa (XO ba)))
- | ExtrNative.Gt ->
- let g,p = ggcdn n1 (sub a' b') b in
- let ab,bb = p in g,((add bb (XO ab)),bb))
- | XO b0 ->
- let g,p = ggcdn n1 a b0 in let aa,bb = p in g,(aa,(XO bb))
- | XH -> XH,(a,XH))
- | XO a0 ->
- (match b with
- | XI p ->
- let g,p2 = ggcdn n1 a0 b in let aa,bb = p2 in g,((XO aa),bb)
- | XO b0 -> let g,p = ggcdn n1 a0 b0 in (XO g),p
- | XH -> XH,(a,XH))
- | XH -> XH,(XH,b))
-
- (** val ggcd : positive -> positive -> positive*(positive*positive) **)
-
- let ggcd a b =
- ggcdn (plus (size_nat a) (size_nat b)) a b
-
- (** val coq_Nsucc_double : n -> n **)
-
- let coq_Nsucc_double = function
- | N0 -> Npos XH
- | Npos p -> Npos (XI p)
-
- (** val coq_Ndouble : n -> n **)
-
- let coq_Ndouble = function
- | N0 -> N0
- | Npos p -> Npos (XO p)
-
- (** val coq_lor : positive -> positive -> positive **)
-
- let rec coq_lor p q =
- match p with
- | XI p2 ->
- (match q with
- | XI q0 -> XI (coq_lor p2 q0)
- | XO q0 -> XI (coq_lor p2 q0)
- | XH -> p)
- | XO p2 ->
- (match q with
- | XI q0 -> XI (coq_lor p2 q0)
- | XO q0 -> XO (coq_lor p2 q0)
- | XH -> XI p2)
- | XH ->
- (match q with
- | XO q0 -> XI q0
- | _ -> q)
-
- (** val coq_land : positive -> positive -> n **)
-
- let rec coq_land p q =
- match p with
- | XI p2 ->
- (match q with
- | XI q0 -> coq_Nsucc_double (coq_land p2 q0)
- | XO q0 -> coq_Ndouble (coq_land p2 q0)
- | XH -> Npos XH)
- | XO p2 ->
- (match q with
- | XI q0 -> coq_Ndouble (coq_land p2 q0)
- | XO q0 -> coq_Ndouble (coq_land p2 q0)
- | XH -> N0)
- | XH ->
- (match q with
- | XO q0 -> N0
- | _ -> Npos XH)
-
- (** val ldiff : positive -> positive -> n **)
-
- let rec ldiff p q =
- match p with
- | XI p2 ->
- (match q with
- | XI q0 -> coq_Ndouble (ldiff p2 q0)
- | XO q0 -> coq_Nsucc_double (ldiff p2 q0)
- | XH -> Npos (XO p2))
- | XO p2 ->
- (match q with
- | XI q0 -> coq_Ndouble (ldiff p2 q0)
- | XO q0 -> coq_Ndouble (ldiff p2 q0)
- | XH -> Npos p)
- | XH ->
- (match q with
- | XO q0 -> Npos XH
- | _ -> N0)
-
- (** val coq_lxor : positive -> positive -> n **)
-
- let rec coq_lxor p q =
- match p with
- | XI p2 ->
- (match q with
- | XI q0 -> coq_Ndouble (coq_lxor p2 q0)
- | XO q0 -> coq_Nsucc_double (coq_lxor p2 q0)
- | XH -> Npos (XO p2))
- | XO p2 ->
- (match q with
- | XI q0 -> coq_Nsucc_double (coq_lxor p2 q0)
- | XO q0 -> coq_Ndouble (coq_lxor p2 q0)
- | XH -> Npos (XI p2))
- | XH ->
- (match q with
- | XI q0 -> Npos (XO q0)
- | XO q0 -> Npos (XI q0)
- | XH -> N0)
-
- (** val shiftl_nat : positive -> nat -> positive **)
-
- let shiftl_nat p n0 =
- nat_iter n0 (fun x -> XO x) p
-
- (** val shiftr_nat : positive -> nat -> positive **)
-
- let shiftr_nat p n0 =
- nat_iter n0 div2 p
-
- (** val shiftl : positive -> n -> positive **)
-
- let shiftl p = function
- | N0 -> p
- | Npos n1 -> iter n1 (fun x -> XO x) p
-
- (** val shiftr : positive -> n -> positive **)
-
- let shiftr p = function
- | N0 -> p
- | Npos n1 -> iter n1 div2 p
-
- (** val testbit_nat : positive -> nat -> bool **)
-
- let rec testbit_nat p n0 =
- match p with
- | XI p2 ->
- (match n0 with
- | O -> true
- | S n' -> testbit_nat p2 n')
- | XO p2 ->
- (match n0 with
- | O -> false
- | S n' -> testbit_nat p2 n')
- | XH ->
- (match n0 with
- | O -> true
- | S n1 -> false)
-
- (** val testbit : positive -> n -> bool **)
-
- let rec testbit p n0 =
- match p with
- | XI p2 ->
- (match n0 with
- | N0 -> true
- | Npos n1 -> testbit p2 (pred_N n1))
- | XO p2 ->
- (match n0 with
- | N0 -> false
- | Npos n1 -> testbit p2 (pred_N n1))
- | XH ->
- (match n0 with
- | N0 -> true
- | Npos p2 -> false)
-
+ gcdn (Coq__1.add (size_nat a) (size_nat b)) a b
+
(** val iter_op : ('a1 -> 'a1 -> 'a1) -> positive -> 'a1 -> 'a1 **)
-
+
let rec iter_op op p a =
match p with
| XI p2 -> op a (iter_op op p2 (op a a))
| XO p2 -> iter_op op p2 (op a a)
| XH -> a
-
+
(** val to_nat : positive -> nat **)
-
+
let to_nat x =
- iter_op plus x (S O)
-
- (** val of_nat : nat -> positive **)
-
- let rec of_nat = function
- | O -> XH
- | S x ->
- (match x with
- | O -> XH
- | S n1 -> succ (of_nat x))
-
+ iter_op Coq__1.add x (S O)
+
(** val of_succ_nat : nat -> positive **)
-
+
let rec of_succ_nat = function
| O -> XH
| S x -> succ (of_succ_nat x)
-
+
(** val eq_dec : positive -> positive -> sumbool **)
-
- let rec eq_dec p y0 =
+
+ let rec eq_dec p x0 =
match p with
- | XI p2 ->
- (match y0 with
- | XI p3 -> eq_dec p2 p3
- | _ -> Right)
- | XO p2 ->
- (match y0 with
- | XO p3 -> eq_dec p2 p3
- | _ -> Right)
- | XH ->
- (match y0 with
- | XH -> Left
- | _ -> Right)
-
- (** val peano_rect : 'a1 -> (positive -> 'a1 -> 'a1) -> positive -> 'a1 **)
-
- let rec peano_rect a f p =
- let f2 = peano_rect (f XH a) (fun p2 x -> f (succ (XO p2)) (f (XO p2) x))
- in
- (match p with
- | XI q -> f (XO q) (f2 q)
- | XO q -> f2 q
- | XH -> a)
-
- (** val peano_rec : 'a1 -> (positive -> 'a1 -> 'a1) -> positive -> 'a1 **)
-
- let peano_rec =
- peano_rect
-
- type coq_PeanoView =
- | PeanoOne
- | PeanoSucc of positive * coq_PeanoView
-
- (** val coq_PeanoView_rect :
- 'a1 -> (positive -> coq_PeanoView -> 'a1 -> 'a1) -> positive ->
- coq_PeanoView -> 'a1 **)
-
- let rec coq_PeanoView_rect f f0 p = function
- | PeanoOne -> f
- | PeanoSucc (p3, p4) -> f0 p3 p4 (coq_PeanoView_rect f f0 p3 p4)
-
- (** val coq_PeanoView_rec :
- 'a1 -> (positive -> coq_PeanoView -> 'a1 -> 'a1) -> positive ->
- coq_PeanoView -> 'a1 **)
-
- let rec coq_PeanoView_rec f f0 p = function
- | PeanoOne -> f
- | PeanoSucc (p3, p4) -> f0 p3 p4 (coq_PeanoView_rec f f0 p3 p4)
-
- (** val peanoView_xO : positive -> coq_PeanoView -> coq_PeanoView **)
-
- let rec peanoView_xO p = function
- | PeanoOne -> PeanoSucc (XH, PeanoOne)
- | PeanoSucc (p2, q0) ->
- PeanoSucc ((succ (XO p2)), (PeanoSucc ((XO p2), (peanoView_xO p2 q0))))
-
- (** val peanoView_xI : positive -> coq_PeanoView -> coq_PeanoView **)
-
- let rec peanoView_xI p = function
- | PeanoOne -> PeanoSucc ((succ XH), (PeanoSucc (XH, PeanoOne)))
- | PeanoSucc (p2, q0) ->
- PeanoSucc ((succ (XI p2)), (PeanoSucc ((XI p2), (peanoView_xI p2 q0))))
-
- (** val peanoView : positive -> coq_PeanoView **)
-
- let rec peanoView = function
- | XI p2 -> peanoView_xI p2 (peanoView p2)
- | XO p2 -> peanoView_xO p2 (peanoView p2)
- | XH -> PeanoOne
-
- (** val coq_PeanoView_iter :
- 'a1 -> (positive -> 'a1 -> 'a1) -> positive -> coq_PeanoView -> 'a1 **)
-
- let rec coq_PeanoView_iter a f p = function
- | PeanoOne -> a
- | PeanoSucc (p2, q0) -> f p2 (coq_PeanoView_iter a f p2 q0)
-
- (** val eqb_spec : positive -> positive -> reflect **)
-
- let eqb_spec x y =
- iff_reflect (eqb x y)
-
- (** val switch_Eq :
- ExtrNative.comparison -> ExtrNative.comparison -> ExtrNative.comparison **)
-
- let switch_Eq c = function
- | ExtrNative.Eq -> c
- | x -> x
-
- (** val mask2cmp : mask -> ExtrNative.comparison **)
-
- let mask2cmp = function
- | IsNul -> ExtrNative.Eq
- | IsPos p2 -> ExtrNative.Gt
- | IsNeg -> ExtrNative.Lt
-
- (** val leb_spec0 : positive -> positive -> reflect **)
-
- let leb_spec0 x y =
- iff_reflect (leb x y)
-
- (** val ltb_spec0 : positive -> positive -> reflect **)
-
- let ltb_spec0 x y =
- iff_reflect (ltb x y)
-
- module Private_Tac =
- struct
-
- end
-
- module Private_Rev =
- struct
- module ORev =
- struct
- type t = Coq__1.t
- end
-
- module MRev =
- struct
- (** val max : t -> t -> t **)
-
- let max x y =
- min y x
- end
-
- module MPRev = MaxLogicalProperties(ORev)(MRev)
- end
-
- module Private_Dec =
- struct
- (** val max_case_strong :
- t -> t -> (t -> t -> __ -> 'a1 -> 'a1) -> (__ -> 'a1) -> (__ -> 'a1)
- -> 'a1 **)
-
- let max_case_strong n0 m compat hl hr =
- let c = compSpec2Type n0 m (compare n0 m) in
- (match c with
- | CompGtT -> compat n0 (max n0 m) __ (hl __)
- | _ -> compat m (max n0 m) __ (hr __))
-
- (** val max_case :
- t -> t -> (t -> t -> __ -> 'a1 -> 'a1) -> 'a1 -> 'a1 -> 'a1 **)
-
- let max_case n0 m x x0 x1 =
- max_case_strong n0 m x (fun _ -> x0) (fun _ -> x1)
-
- (** val max_dec : t -> t -> sumbool **)
-
- let max_dec n0 m =
- max_case n0 m (fun x y _ h0 -> h0) Left Right
-
- (** val min_case_strong :
- t -> t -> (t -> t -> __ -> 'a1 -> 'a1) -> (__ -> 'a1) -> (__ -> 'a1)
- -> 'a1 **)
-
- let min_case_strong n0 m compat hl hr =
- let c = compSpec2Type n0 m (compare n0 m) in
- (match c with
- | CompGtT -> compat m (min n0 m) __ (hr __)
- | _ -> compat n0 (min n0 m) __ (hl __))
-
- (** val min_case :
- t -> t -> (t -> t -> __ -> 'a1 -> 'a1) -> 'a1 -> 'a1 -> 'a1 **)
-
- let min_case n0 m x x0 x1 =
- min_case_strong n0 m x (fun _ -> x0) (fun _ -> x1)
-
- (** val min_dec : t -> t -> sumbool **)
-
- let min_dec n0 m =
- min_case n0 m (fun x y _ h0 -> h0) Left Right
- end
-
- (** val max_case_strong : t -> t -> (__ -> 'a1) -> (__ -> 'a1) -> 'a1 **)
-
- let max_case_strong n0 m x x0 =
- Private_Dec.max_case_strong n0 m (fun x1 y _ x2 -> x2) x x0
-
- (** val max_case : t -> t -> 'a1 -> 'a1 -> 'a1 **)
-
- let max_case n0 m x x0 =
- max_case_strong n0 m (fun _ -> x) (fun _ -> x0)
-
- (** val max_dec : t -> t -> sumbool **)
-
- let max_dec =
- Private_Dec.max_dec
-
- (** val min_case_strong : t -> t -> (__ -> 'a1) -> (__ -> 'a1) -> 'a1 **)
-
- let min_case_strong n0 m x x0 =
- Private_Dec.min_case_strong n0 m (fun x1 y _ x2 -> x2) x x0
-
- (** val min_case : t -> t -> 'a1 -> 'a1 -> 'a1 **)
-
- let min_case n0 m x x0 =
- min_case_strong n0 m (fun _ -> x) (fun _ -> x0)
-
- (** val min_dec : t -> t -> sumbool **)
-
- let min_dec =
- Private_Dec.min_dec
+ | XI p2 -> (match x0 with
+ | XI p3 -> eq_dec p2 p3
+ | _ -> Right)
+ | XO p2 -> (match x0 with
+ | XO p3 -> eq_dec p2 p3
+ | _ -> Right)
+ | XH -> (match x0 with
+ | XH -> Left
+ | _ -> Right)
end
-module N =
- struct
- type t = n
-
- (** val zero : n **)
-
- let zero =
- N0
-
- (** val one : n **)
-
- let one =
- Npos XH
-
- (** val two : n **)
-
- let two =
- Npos (XO XH)
-
- (** val succ_double : n -> n **)
-
- let succ_double = function
- | N0 -> Npos XH
- | Npos p -> Npos (XI p)
-
- (** val double : n -> n **)
-
- let double = function
- | N0 -> N0
- | Npos p -> Npos (XO p)
-
- (** val succ : n -> n **)
-
- let succ = function
- | N0 -> Npos XH
- | Npos p -> Npos (Coq_Pos.succ p)
-
- (** val pred : n -> n **)
-
- let pred = function
- | N0 -> N0
- | Npos p -> Coq_Pos.pred_N p
-
- (** val succ_pos : n -> positive **)
-
- let succ_pos = function
- | N0 -> XH
- | Npos p -> Coq_Pos.succ p
-
+module N =
+ struct
(** val add : n -> n -> n **)
-
+
let add n0 m =
match n0 with
| N0 -> m
- | Npos p ->
- (match m with
- | N0 -> n0
- | Npos q -> Npos (Coq_Pos.add p q))
-
+ | Npos p -> (match m with
+ | N0 -> n0
+ | Npos q -> Npos (Coq_Pos.add p q))
+
(** val sub : n -> n -> n **)
-
+
let sub n0 m =
match n0 with
| N0 -> N0
@@ -1566,594 +411,81 @@ module N =
(match Coq_Pos.sub_mask n' m' with
| Coq_Pos.IsPos p -> Npos p
| _ -> N0))
-
- (** val mul : n -> n -> n **)
-
- let mul n0 m =
- match n0 with
- | N0 -> N0
- | Npos p ->
- (match m with
- | N0 -> N0
- | Npos q -> Npos (Coq_Pos.mul p q))
-
- (** val compare : n -> n -> ExtrNative.comparison **)
-
+
+ (** val compare : n -> n -> int **)
+
let compare n0 m =
match n0 with
- | N0 ->
- (match m with
- | N0 -> ExtrNative.Eq
- | Npos m' -> ExtrNative.Lt)
- | Npos n' ->
- (match m with
- | N0 -> ExtrNative.Gt
- | Npos m' -> Coq_Pos.compare n' m')
-
+ | N0 -> (match m with
+ | N0 -> 0
+ | Npos _ -> (-1))
+ | Npos n' -> (match m with
+ | N0 -> 1
+ | Npos m' -> Coq_Pos.compare n' m')
+
(** val eqb : n -> n -> bool **)
-
- let rec eqb n0 m =
+
+ let eqb n0 m =
match n0 with
- | N0 ->
- (match m with
- | N0 -> true
- | Npos p -> false)
- | Npos p ->
- (match m with
- | N0 -> false
- | Npos q -> Coq_Pos.eqb p q)
-
+ | N0 -> (match m with
+ | N0 -> true
+ | Npos _ -> false)
+ | Npos p -> (match m with
+ | N0 -> false
+ | Npos q -> Coq_Pos.eqb p q)
+
(** val leb : n -> n -> bool **)
-
+
let leb x y =
match compare x y with
- | ExtrNative.Gt -> false
+ | 1 -> false
| _ -> true
-
+
(** val ltb : n -> n -> bool **)
-
+
let ltb x y =
match compare x y with
- | ExtrNative.Lt -> true
+ | (-1) -> true
| _ -> false
-
- (** val min : n -> n -> n **)
-
- let min n0 n' =
- match compare n0 n' with
- | ExtrNative.Gt -> n'
- | _ -> n0
-
- (** val max : n -> n -> n **)
-
- let max n0 n' =
- match compare n0 n' with
- | ExtrNative.Gt -> n0
- | _ -> n'
-
- (** val div2 : n -> n **)
-
- let div2 = function
- | N0 -> N0
- | Npos p2 ->
- (match p2 with
- | XI p -> Npos p
- | XO p -> Npos p
- | XH -> N0)
-
- (** val even : n -> bool **)
-
- let even = function
- | N0 -> true
- | Npos p ->
- (match p with
- | XO p2 -> true
- | _ -> false)
-
- (** val odd : n -> bool **)
-
- let odd n0 =
- negb (even n0)
-
- (** val pow : n -> n -> n **)
-
- let pow n0 = function
- | N0 -> Npos XH
- | Npos p2 ->
- (match n0 with
- | N0 -> N0
- | Npos q -> Npos (Coq_Pos.pow q p2))
-
- (** val square : n -> n **)
-
- let square = function
- | N0 -> N0
- | Npos p -> Npos (Coq_Pos.square p)
-
- (** val log2 : n -> n **)
-
- let log2 = function
- | N0 -> N0
- | Npos p2 ->
- (match p2 with
- | XI p -> Npos (Coq_Pos.size p)
- | XO p -> Npos (Coq_Pos.size p)
- | XH -> N0)
-
- (** val size : n -> n **)
-
- let size = function
- | N0 -> N0
- | Npos p -> Npos (Coq_Pos.size p)
-
- (** val size_nat : n -> nat **)
-
- let size_nat = function
- | N0 -> O
- | Npos p -> Coq_Pos.size_nat p
-
- (** val pos_div_eucl : positive -> n -> n*n **)
-
- let rec pos_div_eucl a b =
- match a with
- | XI a' ->
- let q,r = pos_div_eucl a' b in
- let r' = succ_double r in
- if leb b r' then (succ_double q),(sub r' b) else (double q),r'
- | XO a' ->
- let q,r = pos_div_eucl a' b in
- let r' = double r in
- if leb b r' then (succ_double q),(sub r' b) else (double q),r'
- | XH ->
- (match b with
- | N0 -> N0,(Npos XH)
- | Npos p ->
- (match p with
- | XH -> (Npos XH),N0
- | _ -> N0,(Npos XH)))
-
- (** val div_eucl : n -> n -> n*n **)
-
- let div_eucl a b =
- match a with
- | N0 -> N0,N0
- | Npos na ->
- (match b with
- | N0 -> N0,a
- | Npos p -> pos_div_eucl na b)
-
- (** val div : n -> n -> n **)
-
- let div a b =
- fst (div_eucl a b)
-
- (** val modulo : n -> n -> n **)
-
- let modulo a b =
- snd (div_eucl a b)
-
- (** val gcd : n -> n -> n **)
-
- let gcd a b =
- match a with
- | N0 -> b
- | Npos p ->
- (match b with
- | N0 -> a
- | Npos q -> Npos (Coq_Pos.gcd p q))
-
- (** val ggcd : n -> n -> n*(n*n) **)
-
- let ggcd a b =
- match a with
- | N0 -> b,(N0,(Npos XH))
- | Npos p ->
- (match b with
- | N0 -> a,((Npos XH),N0)
- | Npos q ->
- let g,p2 = Coq_Pos.ggcd p q in
- let aa,bb = p2 in (Npos g),((Npos aa),(Npos bb)))
-
- (** val sqrtrem : n -> n*n **)
-
- let sqrtrem = function
- | N0 -> N0,N0
- | Npos p ->
- let s,m = Coq_Pos.sqrtrem p in
- (match m with
- | Coq_Pos.IsPos r -> (Npos s),(Npos r)
- | _ -> (Npos s),N0)
-
- (** val sqrt : n -> n **)
-
- let sqrt = function
- | N0 -> N0
- | Npos p -> Npos (Coq_Pos.sqrt p)
-
- (** val coq_lor : n -> n -> n **)
-
- let coq_lor n0 m =
- match n0 with
- | N0 -> m
- | Npos p ->
- (match m with
- | N0 -> n0
- | Npos q -> Npos (Coq_Pos.coq_lor p q))
-
- (** val coq_land : n -> n -> n **)
-
- let coq_land n0 m =
- match n0 with
- | N0 -> N0
- | Npos p ->
- (match m with
- | N0 -> N0
- | Npos q -> Coq_Pos.coq_land p q)
-
- (** val ldiff : n -> n -> n **)
-
- let rec ldiff n0 m =
- match n0 with
- | N0 -> N0
- | Npos p ->
- (match m with
- | N0 -> n0
- | Npos q -> Coq_Pos.ldiff p q)
-
- (** val coq_lxor : n -> n -> n **)
-
- let coq_lxor n0 m =
- match n0 with
- | N0 -> m
- | Npos p ->
- (match m with
- | N0 -> n0
- | Npos q -> Coq_Pos.coq_lxor p q)
-
- (** val shiftl_nat : n -> nat -> n **)
-
- let shiftl_nat a n0 =
- nat_iter n0 double a
-
- (** val shiftr_nat : n -> nat -> n **)
-
- let shiftr_nat a n0 =
- nat_iter n0 div2 a
-
- (** val shiftl : n -> n -> n **)
-
- let shiftl a n0 =
- match a with
- | N0 -> N0
- | Npos a0 -> Npos (Coq_Pos.shiftl a0 n0)
-
- (** val shiftr : n -> n -> n **)
-
- let shiftr a = function
- | N0 -> a
- | Npos p -> Coq_Pos.iter p div2 a
-
- (** val testbit_nat : n -> nat -> bool **)
-
- let testbit_nat = function
- | N0 -> (fun x -> false)
- | Npos p -> Coq_Pos.testbit_nat p
-
- (** val testbit : n -> n -> bool **)
-
- let testbit a n0 =
- match a with
- | N0 -> false
- | Npos p -> Coq_Pos.testbit p n0
-
+
(** val to_nat : n -> nat **)
-
+
let to_nat = function
| N0 -> O
| Npos p -> Coq_Pos.to_nat p
-
+
(** val of_nat : nat -> n **)
-
+
let of_nat = function
| O -> N0
| S n' -> Npos (Coq_Pos.of_succ_nat n')
-
- (** val iter : n -> ('a1 -> 'a1) -> 'a1 -> 'a1 **)
-
- let iter n0 f x =
- match n0 with
- | N0 -> x
- | Npos p -> Coq_Pos.iter p f x
-
- (** val eq_dec : n -> n -> sumbool **)
-
- let eq_dec n0 m =
- match n0 with
- | N0 ->
- (match m with
- | N0 -> Left
- | Npos p -> Right)
- | Npos x ->
- (match m with
- | N0 -> Right
- | Npos p2 -> Coq_Pos.eq_dec x p2)
-
- (** val discr : n -> positive sumor **)
-
- let discr = function
- | N0 -> Inright
- | Npos p -> Inleft p
-
- (** val binary_rect :
- 'a1 -> (n -> 'a1 -> 'a1) -> (n -> 'a1 -> 'a1) -> n -> 'a1 **)
-
- let binary_rect f0 f2 fS2 n0 =
- let f2' = fun p -> f2 (Npos p) in
- let fS2' = fun p -> fS2 (Npos p) in
- (match n0 with
- | N0 -> f0
- | Npos p ->
- let rec f = function
- | XI p3 -> fS2' p3 (f p3)
- | XO p3 -> f2' p3 (f p3)
- | XH -> fS2 N0 f0
- in f p)
-
- (** val binary_rec :
- 'a1 -> (n -> 'a1 -> 'a1) -> (n -> 'a1 -> 'a1) -> n -> 'a1 **)
-
- let binary_rec =
- binary_rect
-
- (** val peano_rect : 'a1 -> (n -> 'a1 -> 'a1) -> n -> 'a1 **)
-
- let peano_rect f0 f n0 =
- let f' = fun p -> f (Npos p) in
- (match n0 with
- | N0 -> f0
- | Npos p -> Coq_Pos.peano_rect (f N0 f0) f' p)
-
- (** val peano_rec : 'a1 -> (n -> 'a1 -> 'a1) -> n -> 'a1 **)
-
- let peano_rec =
- peano_rect
-
- (** val leb_spec0 : n -> n -> reflect **)
-
- let leb_spec0 x y =
- iff_reflect (leb x y)
-
- (** val ltb_spec0 : n -> n -> reflect **)
-
- let ltb_spec0 x y =
- iff_reflect (ltb x y)
-
- module Private_BootStrap =
- struct
-
- end
-
- (** val recursion : 'a1 -> (n -> 'a1 -> 'a1) -> n -> 'a1 **)
-
- let recursion x =
- peano_rect x
-
- module Private_OrderTac =
- struct
- module Elts =
- struct
- type t = n
- end
-
- module Tac = MakeOrderTac(Elts)
- end
-
- module Private_NZPow =
- struct
-
- end
-
- module Private_NZSqrt =
- struct
-
- end
-
- (** val sqrt_up : n -> n **)
-
- let sqrt_up a =
- match compare N0 a with
- | ExtrNative.Lt -> succ (sqrt (pred a))
- | _ -> N0
-
- (** val log2_up : n -> n **)
-
- let log2_up a =
- match compare (Npos XH) a with
- | ExtrNative.Lt -> succ (log2 (pred a))
- | _ -> N0
-
- module Private_NZDiv =
- struct
-
- end
-
- (** val lcm : n -> n -> n **)
-
- let lcm a b =
- mul a (div b (gcd a b))
-
- (** val eqb_spec : n -> n -> reflect **)
-
- let eqb_spec x y =
- iff_reflect (eqb x y)
-
- (** val b2n : bool -> n **)
-
- let b2n = function
- | true -> Npos XH
- | false -> N0
-
- (** val setbit : n -> n -> n **)
-
- let setbit a n0 =
- coq_lor a (shiftl (Npos XH) n0)
-
- (** val clearbit : n -> n -> n **)
-
- let clearbit a n0 =
- ldiff a (shiftl (Npos XH) n0)
-
- (** val ones : n -> n **)
-
- let ones n0 =
- pred (shiftl (Npos XH) n0)
-
- (** val lnot : n -> n -> n **)
-
- let lnot a n0 =
- coq_lxor a (ones n0)
-
- module Private_Tac =
- struct
-
- end
-
- module Private_Rev =
- struct
- module ORev =
- struct
- type t = n
- end
-
- module MRev =
- struct
- (** val max : n -> n -> n **)
-
- let max x y =
- min y x
- end
-
- module MPRev = MaxLogicalProperties(ORev)(MRev)
- end
-
- module Private_Dec =
- struct
- (** val max_case_strong :
- n -> n -> (n -> n -> __ -> 'a1 -> 'a1) -> (__ -> 'a1) -> (__ -> 'a1)
- -> 'a1 **)
-
- let max_case_strong n0 m compat hl hr =
- let c = compSpec2Type n0 m (compare n0 m) in
- (match c with
- | CompGtT -> compat n0 (max n0 m) __ (hl __)
- | _ -> compat m (max n0 m) __ (hr __))
-
- (** val max_case :
- n -> n -> (n -> n -> __ -> 'a1 -> 'a1) -> 'a1 -> 'a1 -> 'a1 **)
-
- let max_case n0 m x x0 x1 =
- max_case_strong n0 m x (fun _ -> x0) (fun _ -> x1)
-
- (** val max_dec : n -> n -> sumbool **)
-
- let max_dec n0 m =
- max_case n0 m (fun x y _ h0 -> h0) Left Right
-
- (** val min_case_strong :
- n -> n -> (n -> n -> __ -> 'a1 -> 'a1) -> (__ -> 'a1) -> (__ -> 'a1)
- -> 'a1 **)
-
- let min_case_strong n0 m compat hl hr =
- let c = compSpec2Type n0 m (compare n0 m) in
- (match c with
- | CompGtT -> compat m (min n0 m) __ (hr __)
- | _ -> compat n0 (min n0 m) __ (hl __))
-
- (** val min_case :
- n -> n -> (n -> n -> __ -> 'a1 -> 'a1) -> 'a1 -> 'a1 -> 'a1 **)
-
- let min_case n0 m x x0 x1 =
- min_case_strong n0 m x (fun _ -> x0) (fun _ -> x1)
-
- (** val min_dec : n -> n -> sumbool **)
-
- let min_dec n0 m =
- min_case n0 m (fun x y _ h0 -> h0) Left Right
- end
-
- (** val max_case_strong : n -> n -> (__ -> 'a1) -> (__ -> 'a1) -> 'a1 **)
-
- let max_case_strong n0 m x x0 =
- Private_Dec.max_case_strong n0 m (fun x1 y _ x2 -> x2) x x0
-
- (** val max_case : n -> n -> 'a1 -> 'a1 -> 'a1 **)
-
- let max_case n0 m x x0 =
- max_case_strong n0 m (fun _ -> x) (fun _ -> x0)
-
- (** val max_dec : n -> n -> sumbool **)
-
- let max_dec =
- Private_Dec.max_dec
-
- (** val min_case_strong : n -> n -> (__ -> 'a1) -> (__ -> 'a1) -> 'a1 **)
-
- let min_case_strong n0 m x x0 =
- Private_Dec.min_case_strong n0 m (fun x1 y _ x2 -> x2) x x0
-
- (** val min_case : n -> n -> 'a1 -> 'a1 -> 'a1 **)
-
- let min_case n0 m x x0 =
- min_case_strong n0 m (fun _ -> x) (fun _ -> x0)
-
- (** val min_dec : n -> n -> sumbool **)
-
- let min_dec =
- Private_Dec.min_dec
end
-module Z =
- struct
- type t = z
-
- (** val zero : z **)
-
- let zero =
- Z0
-
- (** val one : z **)
-
- let one =
- Zpos XH
-
- (** val two : z **)
-
- let two =
- Zpos (XO XH)
-
+module Z =
+ struct
(** val double : z -> z **)
-
+
let double = function
| Z0 -> Z0
| Zpos p -> Zpos (XO p)
| Zneg p -> Zneg (XO p)
-
+
(** val succ_double : z -> z **)
-
+
let succ_double = function
| Z0 -> Zpos XH
| Zpos p -> Zpos (XI p)
| Zneg p -> Zneg (Coq_Pos.pred_double p)
-
+
(** val pred_double : z -> z **)
-
+
let pred_double = function
| Z0 -> Zneg XH
| Zpos p -> Zpos (Coq_Pos.pred_double p)
| Zneg p -> Zneg (XI p)
-
+
(** val pos_sub : positive -> positive -> z **)
-
+
let rec pos_sub x y =
match x with
| XI p ->
@@ -2171,9 +503,9 @@ module Z =
| XI q -> Zneg (XO q)
| XO q -> Zneg (Coq_Pos.pred_double q)
| XH -> Z0)
-
+
(** val add : z -> z -> z **)
-
+
let add x y =
match x with
| Z0 -> y
@@ -2187,31 +519,21 @@ module Z =
| Z0 -> x
| Zpos y' -> pos_sub y' x'
| Zneg y' -> Zneg (Coq_Pos.add x' y'))
-
+
(** val opp : z -> z **)
-
+
let opp = function
| Z0 -> Z0
| Zpos x0 -> Zneg x0
| Zneg x0 -> Zpos x0
-
- (** val succ : z -> z **)
-
- let succ x =
- add x (Zpos XH)
-
- (** val pred : z -> z **)
-
- let pred x =
- add x (Zneg XH)
-
+
(** val sub : z -> z -> z **)
-
+
let sub m n0 =
add m (opp n0)
-
+
(** val mul : z -> z -> z **)
-
+
let mul x y =
match x with
| Z0 -> Z0
@@ -2225,321 +547,126 @@ module Z =
| Z0 -> Z0
| Zpos y' -> Zneg (Coq_Pos.mul x' y')
| Zneg y' -> Zpos (Coq_Pos.mul x' y'))
-
- (** val pow_pos : z -> positive -> z **)
-
- let pow_pos z0 n0 =
- Coq_Pos.iter n0 (mul z0) (Zpos XH)
-
- (** val pow : z -> z -> z **)
-
- let pow x = function
- | Z0 -> Zpos XH
- | Zpos p -> pow_pos x p
- | Zneg p -> Z0
-
- (** val square : z -> z **)
-
- let square = function
- | Z0 -> Z0
- | Zpos p -> Zpos (Coq_Pos.square p)
- | Zneg p -> Zpos (Coq_Pos.square p)
-
- (** val compare : z -> z -> ExtrNative.comparison **)
-
+
+ (** val compare : z -> z -> int **)
+
let compare x y =
match x with
- | Z0 ->
- (match y with
- | Z0 -> ExtrNative.Eq
- | Zpos y' -> ExtrNative.Lt
- | Zneg y' -> ExtrNative.Gt)
- | Zpos x' ->
- (match y with
- | Zpos y' -> Coq_Pos.compare x' y'
- | _ -> ExtrNative.Gt)
+ | Z0 -> (match y with
+ | Z0 -> 0
+ | Zpos _ -> (-1)
+ | Zneg _ -> 1)
+ | Zpos x' -> (match y with
+ | Zpos y' -> Coq_Pos.compare x' y'
+ | _ -> 1)
| Zneg x' ->
(match y with
| Zneg y' -> compOpp (Coq_Pos.compare x' y')
- | _ -> ExtrNative.Lt)
-
- (** val sgn : z -> z **)
-
- let sgn = function
- | Z0 -> Z0
- | Zpos p -> Zpos XH
- | Zneg p -> Zneg XH
-
+ | _ -> (-1))
+
(** val leb : z -> z -> bool **)
-
+
let leb x y =
match compare x y with
- | ExtrNative.Gt -> false
+ | 1 -> false
| _ -> true
-
+
(** val ltb : z -> z -> bool **)
-
+
let ltb x y =
match compare x y with
- | ExtrNative.Lt -> true
+ | (-1) -> true
| _ -> false
-
- (** val geb : z -> z -> bool **)
-
- let geb x y =
- match compare x y with
- | ExtrNative.Lt -> false
- | _ -> true
-
+
(** val gtb : z -> z -> bool **)
-
+
let gtb x y =
match compare x y with
- | ExtrNative.Gt -> true
+ | 1 -> true
| _ -> false
-
+
(** val eqb : z -> z -> bool **)
-
- let rec eqb x y =
+
+ let eqb x y =
match x with
- | Z0 ->
- (match y with
- | Z0 -> true
- | _ -> false)
- | Zpos p ->
- (match y with
- | Zpos q -> Coq_Pos.eqb p q
- | _ -> false)
- | Zneg p ->
- (match y with
- | Zneg q -> Coq_Pos.eqb p q
- | _ -> false)
-
+ | Z0 -> (match y with
+ | Z0 -> true
+ | _ -> false)
+ | Zpos p -> (match y with
+ | Zpos q -> Coq_Pos.eqb p q
+ | _ -> false)
+ | Zneg p -> (match y with
+ | Zneg q -> Coq_Pos.eqb p q
+ | _ -> false)
+
(** val max : z -> z -> z **)
-
+
let max n0 m =
match compare n0 m with
- | ExtrNative.Lt -> m
- | _ -> n0
-
- (** val min : z -> z -> z **)
-
- let min n0 m =
- match compare n0 m with
- | ExtrNative.Gt -> m
+ | (-1) -> m
| _ -> n0
-
+
(** val abs : z -> z **)
-
+
let abs = function
| Zneg p -> Zpos p
| x -> x
-
- (** val abs_nat : z -> nat **)
-
- let abs_nat = function
- | Z0 -> O
- | Zpos p -> Coq_Pos.to_nat p
- | Zneg p -> Coq_Pos.to_nat p
-
- (** val abs_N : z -> n **)
-
- let abs_N = function
- | Z0 -> N0
- | Zpos p -> Npos p
- | Zneg p -> Npos p
-
- (** val to_nat : z -> nat **)
-
- let to_nat = function
- | Zpos p -> Coq_Pos.to_nat p
- | _ -> O
-
- (** val to_N : z -> n **)
-
- let to_N = function
- | Zpos p -> Npos p
- | _ -> N0
-
+
(** val of_nat : nat -> z **)
-
+
let of_nat = function
| O -> Z0
| S n1 -> Zpos (Coq_Pos.of_succ_nat n1)
-
- (** val of_N : n -> z **)
-
- let of_N = function
- | N0 -> Z0
- | Npos p -> Zpos p
-
- (** val iter : z -> ('a1 -> 'a1) -> 'a1 -> 'a1 **)
-
- let iter n0 f x =
- match n0 with
- | Zpos p -> Coq_Pos.iter p f x
- | _ -> x
-
- (** val pos_div_eucl : positive -> z -> z*z **)
-
+
+ (** val pos_div_eucl : positive -> z -> z * z **)
+
let rec pos_div_eucl a b =
match a with
| XI a' ->
- let q,r = pos_div_eucl a' b in
+ let (q, r) = pos_div_eucl a' b in
let r' = add (mul (Zpos (XO XH)) r) (Zpos XH) in
if ltb r' b
- then (mul (Zpos (XO XH)) q),r'
- else (add (mul (Zpos (XO XH)) q) (Zpos XH)),(sub r' b)
+ then ((mul (Zpos (XO XH)) q), r')
+ else ((add (mul (Zpos (XO XH)) q) (Zpos XH)), (sub r' b))
| XO a' ->
- let q,r = pos_div_eucl a' b in
+ let (q, r) = pos_div_eucl a' b in
let r' = mul (Zpos (XO XH)) r in
if ltb r' b
- then (mul (Zpos (XO XH)) q),r'
- else (add (mul (Zpos (XO XH)) q) (Zpos XH)),(sub r' b)
- | XH -> if leb (Zpos (XO XH)) b then Z0,(Zpos XH) else (Zpos XH),Z0
-
- (** val div_eucl : z -> z -> z*z **)
-
+ then ((mul (Zpos (XO XH)) q), r')
+ else ((add (mul (Zpos (XO XH)) q) (Zpos XH)), (sub r' b))
+ | XH -> if leb (Zpos (XO XH)) b then (Z0, (Zpos XH)) else ((Zpos XH), Z0)
+
+ (** val div_eucl : z -> z -> z * z **)
+
let div_eucl a b =
match a with
- | Z0 -> Z0,Z0
+ | Z0 -> (Z0, Z0)
| Zpos a' ->
(match b with
- | Z0 -> Z0,Z0
- | Zpos p -> pos_div_eucl a' b
+ | Z0 -> (Z0, Z0)
+ | Zpos _ -> pos_div_eucl a' b
| Zneg b' ->
- let q,r = pos_div_eucl a' (Zpos b') in
+ let (q, r) = pos_div_eucl a' (Zpos b') in
(match r with
- | Z0 -> (opp q),Z0
- | _ -> (opp (add q (Zpos XH))),(add b r)))
+ | Z0 -> ((opp q), Z0)
+ | _ -> ((opp (add q (Zpos XH))), (add b r))))
| Zneg a' ->
(match b with
- | Z0 -> Z0,Z0
- | Zpos p ->
- let q,r = pos_div_eucl a' b in
+ | Z0 -> (Z0, Z0)
+ | Zpos _ ->
+ let (q, r) = pos_div_eucl a' b in
(match r with
- | Z0 -> (opp q),Z0
- | _ -> (opp (add q (Zpos XH))),(sub b r))
- | Zneg b' -> let q,r = pos_div_eucl a' (Zpos b') in q,(opp r))
-
+ | Z0 -> ((opp q), Z0)
+ | _ -> ((opp (add q (Zpos XH))), (sub b r)))
+ | Zneg b' -> let (q, r) = pos_div_eucl a' (Zpos b') in (q, (opp r)))
+
(** val div : z -> z -> z **)
-
+
let div a b =
- let q,x = div_eucl a b in q
-
- (** val modulo : z -> z -> z **)
-
- let modulo a b =
- let x,r = div_eucl a b in r
-
- (** val quotrem : z -> z -> z*z **)
-
- let quotrem a b =
- match a with
- | Z0 -> Z0,Z0
- | Zpos a0 ->
- (match b with
- | Z0 -> Z0,a
- | Zpos b0 ->
- let q,r = N.pos_div_eucl a0 (Npos b0) in (of_N q),(of_N r)
- | Zneg b0 ->
- let q,r = N.pos_div_eucl a0 (Npos b0) in (opp (of_N q)),(of_N r))
- | Zneg a0 ->
- (match b with
- | Z0 -> Z0,a
- | Zpos b0 ->
- let q,r = N.pos_div_eucl a0 (Npos b0) in
- (opp (of_N q)),(opp (of_N r))
- | Zneg b0 ->
- let q,r = N.pos_div_eucl a0 (Npos b0) in (of_N q),(opp (of_N r)))
-
- (** val quot : z -> z -> z **)
-
- let quot a b =
- fst (quotrem a b)
-
- (** val rem : z -> z -> z **)
-
- let rem a b =
- snd (quotrem a b)
-
- (** val even : z -> bool **)
-
- let even = function
- | Z0 -> true
- | Zpos p ->
- (match p with
- | XO p2 -> true
- | _ -> false)
- | Zneg p ->
- (match p with
- | XO p2 -> true
- | _ -> false)
-
- (** val odd : z -> bool **)
-
- let odd = function
- | Z0 -> false
- | Zpos p ->
- (match p with
- | XO p2 -> false
- | _ -> true)
- | Zneg p ->
- (match p with
- | XO p2 -> false
- | _ -> true)
-
- (** val div2 : z -> z **)
-
- let div2 = function
- | Z0 -> Z0
- | Zpos p ->
- (match p with
- | XH -> Z0
- | _ -> Zpos (Coq_Pos.div2 p))
- | Zneg p -> Zneg (Coq_Pos.div2_up p)
-
- (** val quot2 : z -> z **)
-
- let quot2 = function
- | Z0 -> Z0
- | Zpos p ->
- (match p with
- | XH -> Z0
- | _ -> Zpos (Coq_Pos.div2 p))
- | Zneg p ->
- (match p with
- | XH -> Z0
- | _ -> Zneg (Coq_Pos.div2 p))
-
- (** val log2 : z -> z **)
-
- let log2 = function
- | Zpos p2 ->
- (match p2 with
- | XI p -> Zpos (Coq_Pos.size p)
- | XO p -> Zpos (Coq_Pos.size p)
- | XH -> Z0)
- | _ -> Z0
-
- (** val sqrtrem : z -> z*z **)
-
- let sqrtrem = function
- | Zpos p ->
- let s,m = Coq_Pos.sqrtrem p in
- (match m with
- | Coq_Pos.IsPos r -> (Zpos s),(Zpos r)
- | _ -> (Zpos s),Z0)
- | _ -> Z0,Z0
-
- (** val sqrt : z -> z **)
-
- let sqrt = function
- | Zpos p -> Zpos (Coq_Pos.sqrt p)
- | _ -> Z0
-
+ let (q, _) = div_eucl a b in q
+
(** val gcd : z -> z -> z **)
-
+
let gcd a b =
match a with
| Z0 -> abs b
@@ -2553,361 +680,54 @@ module Z =
| Z0 -> abs a
| Zpos b0 -> Zpos (Coq_Pos.gcd a0 b0)
| Zneg b0 -> Zpos (Coq_Pos.gcd a0 b0))
-
- (** val ggcd : z -> z -> z*(z*z) **)
-
- let ggcd a b =
- match a with
- | Z0 -> (abs b),(Z0,(sgn b))
- | Zpos a0 ->
- (match b with
- | Z0 -> (abs a),((sgn a),Z0)
- | Zpos b0 ->
- let g,p = Coq_Pos.ggcd a0 b0 in
- let aa,bb = p in (Zpos g),((Zpos aa),(Zpos bb))
- | Zneg b0 ->
- let g,p = Coq_Pos.ggcd a0 b0 in
- let aa,bb = p in (Zpos g),((Zpos aa),(Zneg bb)))
- | Zneg a0 ->
- (match b with
- | Z0 -> (abs a),((sgn a),Z0)
- | Zpos b0 ->
- let g,p = Coq_Pos.ggcd a0 b0 in
- let aa,bb = p in (Zpos g),((Zneg aa),(Zpos bb))
- | Zneg b0 ->
- let g,p = Coq_Pos.ggcd a0 b0 in
- let aa,bb = p in (Zpos g),((Zneg aa),(Zneg bb)))
-
- (** val testbit : z -> z -> bool **)
-
- let testbit a = function
- | Z0 -> odd a
- | Zpos p ->
- (match a with
- | Z0 -> false
- | Zpos a0 -> Coq_Pos.testbit a0 (Npos p)
- | Zneg a0 -> negb (N.testbit (Coq_Pos.pred_N a0) (Npos p)))
- | Zneg p -> false
-
- (** val shiftl : z -> z -> z **)
-
- let shiftl a = function
- | Z0 -> a
- | Zpos p -> Coq_Pos.iter p (mul (Zpos (XO XH))) a
- | Zneg p -> Coq_Pos.iter p div2 a
-
- (** val shiftr : z -> z -> z **)
-
- let shiftr a n0 =
- shiftl a (opp n0)
-
- (** val coq_lor : z -> z -> z **)
-
- let coq_lor a b =
- match a with
- | Z0 -> b
- | Zpos a0 ->
- (match b with
- | Z0 -> a
- | Zpos b0 -> Zpos (Coq_Pos.coq_lor a0 b0)
- | Zneg b0 -> Zneg (N.succ_pos (N.ldiff (Coq_Pos.pred_N b0) (Npos a0))))
- | Zneg a0 ->
- (match b with
- | Z0 -> a
- | Zpos b0 -> Zneg (N.succ_pos (N.ldiff (Coq_Pos.pred_N a0) (Npos b0)))
- | Zneg b0 ->
- Zneg
- (N.succ_pos (N.coq_land (Coq_Pos.pred_N a0) (Coq_Pos.pred_N b0))))
-
- (** val coq_land : z -> z -> z **)
-
- let coq_land a b =
- match a with
- | Z0 -> Z0
- | Zpos a0 ->
- (match b with
- | Z0 -> Z0
- | Zpos b0 -> of_N (Coq_Pos.coq_land a0 b0)
- | Zneg b0 -> of_N (N.ldiff (Npos a0) (Coq_Pos.pred_N b0)))
- | Zneg a0 ->
- (match b with
- | Z0 -> Z0
- | Zpos b0 -> of_N (N.ldiff (Npos b0) (Coq_Pos.pred_N a0))
- | Zneg b0 ->
- Zneg
- (N.succ_pos (N.coq_lor (Coq_Pos.pred_N a0) (Coq_Pos.pred_N b0))))
-
- (** val ldiff : z -> z -> z **)
-
- let ldiff a b =
- match a with
- | Z0 -> Z0
- | Zpos a0 ->
- (match b with
- | Z0 -> a
- | Zpos b0 -> of_N (Coq_Pos.ldiff a0 b0)
- | Zneg b0 -> of_N (N.coq_land (Npos a0) (Coq_Pos.pred_N b0)))
- | Zneg a0 ->
- (match b with
- | Z0 -> a
- | Zpos b0 ->
- Zneg (N.succ_pos (N.coq_lor (Coq_Pos.pred_N a0) (Npos b0)))
- | Zneg b0 -> of_N (N.ldiff (Coq_Pos.pred_N b0) (Coq_Pos.pred_N a0)))
-
- (** val coq_lxor : z -> z -> z **)
-
- let coq_lxor a b =
- match a with
- | Z0 -> b
- | Zpos a0 ->
- (match b with
- | Z0 -> a
- | Zpos b0 -> of_N (Coq_Pos.coq_lxor a0 b0)
- | Zneg b0 ->
- Zneg (N.succ_pos (N.coq_lxor (Npos a0) (Coq_Pos.pred_N b0))))
- | Zneg a0 ->
- (match b with
- | Z0 -> a
- | Zpos b0 ->
- Zneg (N.succ_pos (N.coq_lxor (Coq_Pos.pred_N a0) (Npos b0)))
- | Zneg b0 -> of_N (N.coq_lxor (Coq_Pos.pred_N a0) (Coq_Pos.pred_N b0)))
-
+
(** val eq_dec : z -> z -> sumbool **)
-
+
let eq_dec x y =
match x with
- | Z0 ->
- (match y with
- | Z0 -> Left
- | _ -> Right)
- | Zpos x0 ->
- (match y with
- | Zpos p2 -> Coq_Pos.eq_dec x0 p2
- | _ -> Right)
- | Zneg x0 ->
- (match y with
- | Zneg p2 -> Coq_Pos.eq_dec x0 p2
- | _ -> Right)
-
- module Private_BootStrap =
- struct
-
- end
-
- (** val leb_spec0 : z -> z -> reflect **)
-
- let leb_spec0 x y =
- iff_reflect (leb x y)
-
- (** val ltb_spec0 : z -> z -> reflect **)
-
- let ltb_spec0 x y =
- iff_reflect (ltb x y)
-
- module Private_OrderTac =
- struct
- module Elts =
- struct
- type t = z
- end
-
- module Tac = MakeOrderTac(Elts)
- end
-
- (** val sqrt_up : z -> z **)
-
- let sqrt_up a =
- match compare Z0 a with
- | ExtrNative.Lt -> succ (sqrt (pred a))
- | _ -> Z0
-
- (** val log2_up : z -> z **)
-
- let log2_up a =
- match compare (Zpos XH) a with
- | ExtrNative.Lt -> succ (log2 (pred a))
- | _ -> Z0
-
- module Private_NZDiv =
- struct
-
- end
-
- module Private_Div =
- struct
- module Quot2Div =
- struct
- (** val div : z -> z -> z **)
-
- let div =
- quot
-
- (** val modulo : z -> z -> z **)
-
- let modulo =
- rem
- end
-
- module NZQuot =
- struct
-
- end
- end
-
- (** val lcm : z -> z -> z **)
-
- let lcm a b =
- abs (mul a (div b (gcd a b)))
-
- (** val eqb_spec : z -> z -> reflect **)
-
- let eqb_spec x y =
- iff_reflect (eqb x y)
-
- (** val b2z : bool -> z **)
-
- let b2z = function
- | true -> Zpos XH
- | false -> Z0
-
- (** val setbit : z -> z -> z **)
-
- let setbit a n0 =
- coq_lor a (shiftl (Zpos XH) n0)
-
- (** val clearbit : z -> z -> z **)
-
- let clearbit a n0 =
- ldiff a (shiftl (Zpos XH) n0)
-
- (** val lnot : z -> z **)
-
- let lnot a =
- pred (opp a)
-
- (** val ones : z -> z **)
-
- let ones n0 =
- pred (shiftl (Zpos XH) n0)
-
- module Private_Tac =
- struct
-
- end
-
- module Private_Rev =
- struct
- module ORev =
- struct
- type t = z
- end
-
- module MRev =
- struct
- (** val max : z -> z -> z **)
-
- let max x y =
- min y x
- end
-
- module MPRev = MaxLogicalProperties(ORev)(MRev)
- end
-
- module Private_Dec =
- struct
- (** val max_case_strong :
- z -> z -> (z -> z -> __ -> 'a1 -> 'a1) -> (__ -> 'a1) -> (__ -> 'a1)
- -> 'a1 **)
-
- let max_case_strong n0 m compat hl hr =
- let c = compSpec2Type n0 m (compare n0 m) in
- (match c with
- | CompGtT -> compat n0 (max n0 m) __ (hl __)
- | _ -> compat m (max n0 m) __ (hr __))
-
- (** val max_case :
- z -> z -> (z -> z -> __ -> 'a1 -> 'a1) -> 'a1 -> 'a1 -> 'a1 **)
-
- let max_case n0 m x x0 x1 =
- max_case_strong n0 m x (fun _ -> x0) (fun _ -> x1)
-
- (** val max_dec : z -> z -> sumbool **)
-
- let max_dec n0 m =
- max_case n0 m (fun x y _ h0 -> h0) Left Right
-
- (** val min_case_strong :
- z -> z -> (z -> z -> __ -> 'a1 -> 'a1) -> (__ -> 'a1) -> (__ -> 'a1)
- -> 'a1 **)
-
- let min_case_strong n0 m compat hl hr =
- let c = compSpec2Type n0 m (compare n0 m) in
- (match c with
- | CompGtT -> compat m (min n0 m) __ (hr __)
- | _ -> compat n0 (min n0 m) __ (hl __))
-
- (** val min_case :
- z -> z -> (z -> z -> __ -> 'a1 -> 'a1) -> 'a1 -> 'a1 -> 'a1 **)
-
- let min_case n0 m x x0 x1 =
- min_case_strong n0 m x (fun _ -> x0) (fun _ -> x1)
-
- (** val min_dec : z -> z -> sumbool **)
-
- let min_dec n0 m =
- min_case n0 m (fun x y _ h0 -> h0) Left Right
- end
-
- (** val max_case_strong : z -> z -> (__ -> 'a1) -> (__ -> 'a1) -> 'a1 **)
-
- let max_case_strong n0 m x x0 =
- Private_Dec.max_case_strong n0 m (fun x1 y _ x2 -> x2) x x0
-
- (** val max_case : z -> z -> 'a1 -> 'a1 -> 'a1 **)
-
- let max_case n0 m x x0 =
- max_case_strong n0 m (fun _ -> x) (fun _ -> x0)
-
- (** val max_dec : z -> z -> sumbool **)
-
- let max_dec =
- Private_Dec.max_dec
-
- (** val min_case_strong : z -> z -> (__ -> 'a1) -> (__ -> 'a1) -> 'a1 **)
-
- let min_case_strong n0 m x x0 =
- Private_Dec.min_case_strong n0 m (fun x1 y _ x2 -> x2) x x0
-
- (** val min_case : z -> z -> 'a1 -> 'a1 -> 'a1 **)
-
- let min_case n0 m x x0 =
- min_case_strong n0 m (fun _ -> x) (fun _ -> x0)
-
- (** val min_dec : z -> z -> sumbool **)
-
- let min_dec =
- Private_Dec.min_dec
+ | Z0 -> (match y with
+ | Z0 -> Left
+ | _ -> Right)
+ | Zpos x0 -> (match y with
+ | Zpos p2 -> Coq_Pos.eq_dec x0 p2
+ | _ -> Right)
+ | Zneg x0 -> (match y with
+ | Zneg p2 -> Coq_Pos.eq_dec x0 p2
+ | _ -> Right)
end
-(** val zeq_bool : z -> z -> bool **)
-
-let zeq_bool x y =
- match Z.compare x y with
- | ExtrNative.Eq -> true
- | _ -> false
-
(** val nth : nat -> 'a1 list -> 'a1 -> 'a1 **)
let rec nth n0 l default0 =
match n0 with
- | O ->
- (match l with
- | Nil -> default0
- | Cons (x, l') -> x)
- | S m ->
- (match l with
- | Nil -> default0
- | Cons (x, t0) -> nth m t0 default0)
+ | O -> (match l with
+ | Nil -> default0
+ | Cons (x, _) -> x)
+ | S m -> (match l with
+ | Nil -> default0
+ | Cons (_, t0) -> nth m t0 default0)
+
+(** val removelast : 'a1 list -> 'a1 list **)
+
+let rec removelast = function
+| Nil -> Nil
+| Cons (a, l0) ->
+ (match l0 with
+ | Nil -> Nil
+ | Cons (_, _) -> Cons (a, (removelast l0)))
+
+(** val rev : 'a1 list -> 'a1 list **)
+
+let rec rev = function
+| Nil -> Nil
+| Cons (x, l') -> app (rev l') (Cons (x, Nil))
+
+(** val rev_append : 'a1 list -> 'a1 list -> 'a1 list **)
+
+let rec rev_append l l' =
+ match l with
+ | Nil -> l'
+ | Cons (a, l0) -> rev_append l0 (Cons (a, l'))
(** val map : ('a1 -> 'a2) -> 'a1 list -> 'a2 list **)
@@ -2915,6 +735,13 @@ let rec map f = function
| Nil -> Nil
| Cons (a, t0) -> Cons ((f a), (map f t0))
+(** val fold_left : ('a1 -> 'a2 -> 'a1) -> 'a2 list -> 'a1 -> 'a1 **)
+
+let rec fold_left f l a0 =
+ match l with
+ | Nil -> a0
+ | Cons (b, t0) -> fold_left f t0 (f a0 b)
+
(** val fold_right : ('a2 -> 'a1 -> 'a1) -> 'a1 -> 'a2 list -> 'a1 **)
let rec fold_right f a0 = function
@@ -2933,1831 +760,31 @@ let rec forallb f = function
| Nil -> true
| Cons (a, l0) -> if f a then forallb f l0 else false
-type int = ExtrNative.uint
-
-(** val lsl0 : int -> int -> int **)
-
-let lsl0 = ExtrNative.l_sl
-
-(** val lsr0 : int -> int -> int **)
-
-let lsr0 = ExtrNative.l_sr
-
-(** val land0 : int -> int -> int **)
-
-let land0 = ExtrNative.l_and
-
-(** val lxor0 : int -> int -> int **)
-
-let lxor0 = ExtrNative.l_xor
-
-(** val sub0 : int -> int -> int **)
-
-let sub0 = ExtrNative.sub
-
-(** val eqb0 : int -> int -> bool **)
-
-let eqb0 = fun i j -> ExtrNative.compare i j = ExtrNative.Eq
-
-(** val ltb0 : int -> int -> bool **)
-
-let ltb0 = ExtrNative.lt
-
-(** val leb0 : int -> int -> bool **)
-
-let leb0 = ExtrNative.le
-
-(** val foldi_cont :
- (int -> ('a1 -> 'a2) -> 'a1 -> 'a2) -> int -> int -> ('a1 -> 'a2) -> 'a1
- -> 'a2 **)
-
-let foldi_cont = ExtrNative.foldi_cont
-
-(** val foldi_down_cont :
- (int -> ('a1 -> 'a2) -> 'a1 -> 'a2) -> int -> int -> ('a1 -> 'a2) -> 'a1
- -> 'a2 **)
-
-let foldi_down_cont = ExtrNative.foldi_down_cont
-
-(** val is_zero : int -> bool **)
-
-let is_zero i =
- eqb0 i (ExtrNative.of_uint(0))
-
-(** val is_even : int -> bool **)
-
-let is_even i =
- is_zero (land0 i (ExtrNative.of_uint(1)))
-
-(** val compare0 : int -> int -> ExtrNative.comparison **)
-
-let compare0 = ExtrNative.compare
-
-(** val foldi : (int -> 'a1 -> 'a1) -> int -> int -> 'a1 -> 'a1 **)
-
-let foldi f from to0 =
- foldi_cont (fun i cont a -> cont (f i a)) from to0 (fun a -> a)
-
-(** val fold : ('a1 -> 'a1) -> int -> int -> 'a1 -> 'a1 **)
-
-let fold f from to0 =
- foldi_cont (fun i cont a -> cont (f a)) from to0 (fun a -> a)
-
-(** val foldi_down : (int -> 'a1 -> 'a1) -> int -> int -> 'a1 -> 'a1 **)
-
-let foldi_down f from downto0 =
- foldi_down_cont (fun i cont a -> cont (f i a)) from downto0 (fun a -> a)
-
-(** val forallb0 : (int -> bool) -> int -> int -> bool **)
-
-let forallb0 f from to0 =
- foldi_cont (fun i cont x -> if f i then cont Tt else false) from to0
- (fun x -> true) Tt
-
-(** val existsb0 : (int -> bool) -> int -> int -> bool **)
-
-let existsb0 f from to0 =
- foldi_cont (fun i cont x -> if f i then true else cont Tt) from to0
- (fun x -> false) Tt
-
-(** val cast : int -> int -> (__ -> __ -> __) option **)
-
-let cast i j =
- if eqb0 i j then Some (fun _ hi -> hi) else None
-
-(** val reflect_eqb : int -> int -> reflect **)
-
-let reflect_eqb i j =
- iff_reflect (eqb0 i j)
-
-type 'a array = 'a ExtrNative.parray
-
-(** val make : int -> 'a1 -> 'a1 array **)
-
-let make = ExtrNative.parray_make
-
-module Coq__2 = struct
- (** val get : 'a1 array -> int -> 'a1 **)
-
- let get = ExtrNative.parray_get
-end
-let get = Coq__2.get
-
-(** val default : 'a1 array -> 'a1 **)
-
-let default = ExtrNative.parray_default
-
-(** val set : 'a1 array -> int -> 'a1 -> 'a1 array **)
-
-let set = ExtrNative.parray_set
-
-(** val length : 'a1 array -> int **)
-
-let length = ExtrNative.parray_length
-
-(** val to_list : 'a1 array -> 'a1 list **)
-
-let to_list t0 =
- let len = length t0 in
- if eqb0 (ExtrNative.of_uint(0)) len
- then Nil
- else foldi_down (fun i l -> Cons ((get t0 i), l))
- (sub0 len (ExtrNative.of_uint(1))) (ExtrNative.of_uint(0)) Nil
-
-(** val forallbi : (int -> 'a1 -> bool) -> 'a1 array -> bool **)
-
-let forallbi f t0 =
- let len = length t0 in
- if eqb0 (ExtrNative.of_uint(0)) len
- then true
- else forallb0 (fun i -> f i (get t0 i)) (ExtrNative.of_uint(0))
- (sub0 len (ExtrNative.of_uint(1)))
-
-(** val forallb1 : ('a1 -> bool) -> 'a1 array -> bool **)
-
-let forallb1 f t0 =
- let len = length t0 in
- if eqb0 (ExtrNative.of_uint(0)) len
- then true
- else forallb0 (fun i -> f (get t0 i)) (ExtrNative.of_uint(0))
- (sub0 len (ExtrNative.of_uint(1)))
-
-(** val existsb1 : ('a1 -> bool) -> 'a1 array -> bool **)
-
-let existsb1 f t0 =
- let len = length t0 in
- if eqb0 (ExtrNative.of_uint(0)) len
- then false
- else existsb0 (fun i -> f (get t0 i)) (ExtrNative.of_uint(0))
- (sub0 len (ExtrNative.of_uint(1)))
-
-(** val mapi : (int -> 'a1 -> 'a2) -> 'a1 array -> 'a2 array **)
-
-let mapi f t0 =
- let size0 = length t0 in
- let def = f size0 (default t0) in
- let tb = make size0 def in
- if eqb0 size0 (ExtrNative.of_uint(0))
- then tb
- else foldi (fun i tb0 -> set tb0 i (f i (get t0 i)))
- (ExtrNative.of_uint(0)) (sub0 size0 (ExtrNative.of_uint(1))) tb
-
-(** val foldi_left :
- (int -> 'a1 -> 'a2 -> 'a1) -> 'a1 -> 'a2 array -> 'a1 **)
-
-let foldi_left f a t0 =
- let len = length t0 in
- if eqb0 (ExtrNative.of_uint(0)) len
- then a
- else foldi (fun i a0 -> f i a0 (get t0 i)) (ExtrNative.of_uint(0))
- (sub0 len (ExtrNative.of_uint(1))) a
-
-(** val fold_left : ('a1 -> 'a2 -> 'a1) -> 'a1 -> 'a2 array -> 'a1 **)
-
-let fold_left f a t0 =
- let len = length t0 in
- if eqb0 (ExtrNative.of_uint(0)) len
- then a
- else foldi (fun i a0 -> f a0 (get t0 i)) (ExtrNative.of_uint(0))
- (sub0 (length t0) (ExtrNative.of_uint(1))) a
-
-(** val foldi_right :
- (int -> 'a1 -> 'a2 -> 'a2) -> 'a1 array -> 'a2 -> 'a2 **)
-
-let foldi_right f t0 b =
- let len = length t0 in
- if eqb0 (ExtrNative.of_uint(0)) len
- then b
- else foldi_down (fun i b0 -> f i (get t0 i) b0)
- (sub0 len (ExtrNative.of_uint(1))) (ExtrNative.of_uint(0)) b
-
-module Valuation =
- struct
- type t = int -> bool
- end
-
-module Var =
- struct
- (** val _true : int **)
-
- let _true =
- (ExtrNative.of_uint(0))
-
- (** val _false : int **)
-
- let _false =
- (ExtrNative.of_uint(1))
-
- (** val interp : Valuation.t -> int -> bool **)
-
- let interp rho x =
- rho x
- end
-
-module Lit =
- struct
- (** val is_pos : int -> bool **)
-
- let is_pos l =
- is_even l
-
- (** val blit : int -> int **)
-
- let blit l =
- lsr0 l (ExtrNative.of_uint(1))
-
- (** val lit : int -> int **)
-
- let lit x =
- lsl0 x (ExtrNative.of_uint(1))
-
- (** val neg : int -> int **)
-
- let neg l =
- lxor0 l (ExtrNative.of_uint(1))
-
- (** val nlit : int -> int **)
-
- let nlit x =
- neg (lit x)
-
- (** val _true : int **)
-
- let _true =
- (ExtrNative.of_uint(0))
-
- (** val _false : int **)
-
- let _false =
- (ExtrNative.of_uint(2))
-
- (** val eqb : int -> int -> bool **)
-
- let eqb l l' =
- eqb0 l l'
-
- (** val interp : Valuation.t -> int -> bool **)
-
- let interp rho l =
- if is_pos l
- then Var.interp rho (blit l)
- else negb (Var.interp rho (blit l))
- end
-
-module C =
- struct
- type t = int list
-
- (** val interp : Valuation.t -> t -> bool **)
-
- let interp rho l =
- existsb (Lit.interp rho) l
-
- (** val _true : t **)
-
- let _true =
- Cons (Lit._true, Nil)
-
- (** val is_false : t -> bool **)
-
- let is_false = function
- | Nil -> true
- | Cons (i, l) -> false
-
- (** val or_aux : (t -> t -> t) -> int -> t -> t -> int list **)
-
- let rec or_aux or0 l1 c1 c2 = match c2 with
- | Nil -> Cons (l1, c1)
- | Cons (l2, c2') ->
- (match compare0 l1 l2 with
- | ExtrNative.Eq -> Cons (l1, (or0 c1 c2'))
- | ExtrNative.Lt -> Cons (l1, (or0 c1 c2))
- | ExtrNative.Gt -> Cons (l2, (or_aux or0 l1 c1 c2')))
-
- (** val coq_or : t -> t -> t **)
-
- let rec coq_or c1 c2 =
- match c1 with
- | Nil -> c2
- | Cons (l1, c3) ->
- (match c2 with
- | Nil -> c1
- | Cons (l2, c2') ->
- (match compare0 l1 l2 with
- | ExtrNative.Eq -> Cons (l1, (coq_or c3 c2'))
- | ExtrNative.Lt -> Cons (l1, (coq_or c3 c2))
- | ExtrNative.Gt -> Cons (l2, (or_aux coq_or l1 c3 c2'))))
-
- (** val resolve_aux : (t -> t -> t) -> int -> t -> t -> t **)
-
- let rec resolve_aux resolve0 l1 c1 c2 = match c2 with
- | Nil -> _true
- | Cons (l2, c2') ->
- (match compare0 l1 l2 with
- | ExtrNative.Eq -> Cons (l1, (resolve0 c1 c2'))
- | ExtrNative.Lt ->
- if eqb0 (lxor0 l1 l2) (ExtrNative.of_uint(1))
- then coq_or c1 c2'
- else Cons (l1, (resolve0 c1 c2))
- | ExtrNative.Gt ->
- if eqb0 (lxor0 l1 l2) (ExtrNative.of_uint(1))
- then coq_or c1 c2'
- else Cons (l2, (resolve_aux resolve0 l1 c1 c2')))
-
- (** val resolve : t -> t -> t **)
-
- let rec resolve c1 c2 =
- match c1 with
- | Nil -> _true
- | Cons (l1, c3) ->
- (match c2 with
- | Nil -> _true
- | Cons (l2, c2') ->
- (match compare0 l1 l2 with
- | ExtrNative.Eq -> Cons (l1, (resolve c3 c2'))
- | ExtrNative.Lt ->
- if eqb0 (lxor0 l1 l2) (ExtrNative.of_uint(1))
- then coq_or c3 c2'
- else Cons (l1, (resolve c3 c2))
- | ExtrNative.Gt ->
- if eqb0 (lxor0 l1 l2) (ExtrNative.of_uint(1))
- then coq_or c3 c2'
- else Cons (l2, (resolve_aux resolve l1 c3 c2'))))
- end
-
-module S =
- struct
- type t = C.t array
-
- (** val get : t -> int -> C.t **)
-
- let get s cid =
- get s cid
-
- (** val internal_set : t -> int -> C.t -> t **)
-
- let internal_set s cid c =
- set s cid c
-
- (** val make : int -> t **)
-
- let make nclauses =
- make nclauses C._true
-
- (** val insert : int -> int list -> int list **)
-
- let rec insert l1 c = match c with
- | Nil -> Cons (l1, Nil)
- | Cons (l2, c') ->
- (match compare0 l1 l2 with
- | ExtrNative.Eq -> c
- | ExtrNative.Lt ->
- if eqb0 (lxor0 l1 l2) (ExtrNative.of_uint(1))
- then C._true
- else Cons (l1, c)
- | ExtrNative.Gt ->
- if eqb0 (lxor0 l1 l2) (ExtrNative.of_uint(1))
- then C._true
- else Cons (l2, (insert l1 c')))
-
- (** val sort_uniq : int list -> int list **)
-
- let rec sort_uniq = function
- | Nil -> Nil
- | Cons (l1, c0) -> insert l1 (sort_uniq c0)
-
- (** val set_clause : t -> int -> C.t -> t **)
-
- let set_clause s pos c =
- set s pos (sort_uniq c)
-
- (** val set_resolve : t -> int -> int array -> t **)
-
- let set_resolve s pos r =
- let len = length r in
- if eqb0 len (ExtrNative.of_uint(0))
- then s
- else let c =
- foldi (fun i c -> C.resolve (get s (Coq__2.get r i)) c)
- (ExtrNative.of_uint(1)) (sub0 len (ExtrNative.of_uint(1)))
- (get s (Coq__2.get r (ExtrNative.of_uint(0))))
- in
- internal_set s pos c
- end
-
-(** val afold_left :
- 'a1 -> ('a1 -> 'a1 -> 'a1) -> ('a2 -> 'a1) -> 'a2 array -> 'a1 **)
-
-let afold_left default0 oP f v =
- let n0 = length v in
- if eqb0 n0 (ExtrNative.of_uint(0))
- then default0
- else foldi (fun i a -> oP a (f (get v i))) (ExtrNative.of_uint(1))
- (sub0 n0 (ExtrNative.of_uint(1)))
- (f (get v (ExtrNative.of_uint(0))))
-
-(** val afold_right :
- 'a1 -> ('a1 -> 'a1 -> 'a1) -> ('a2 -> 'a1) -> 'a2 array -> 'a1 **)
-
-let afold_right default0 oP f v =
- let n0 = length v in
- if eqb0 n0 (ExtrNative.of_uint(0))
- then default0
- else if leb0 n0 (ExtrNative.of_uint(1))
- then f (get v (ExtrNative.of_uint(0)))
- else foldi_down (fun i b -> oP (f (get v i)) b)
- (sub0 n0 (ExtrNative.of_uint(2))) (ExtrNative.of_uint(0))
- (f (get v (sub0 n0 (ExtrNative.of_uint(1)))))
-
-(** val rev_aux : 'a1 list -> 'a1 list -> 'a1 list **)
-
-let rec rev_aux acc = function
-| Nil -> acc
-| Cons (t0, q) -> rev_aux (Cons (t0, acc)) q
-
-(** val rev : 'a1 list -> 'a1 list **)
-
-let rev l =
- rev_aux Nil l
-
-(** val distinct_aux2 :
- ('a1 -> 'a1 -> bool) -> bool -> 'a1 -> 'a1 list -> bool **)
-
-let rec distinct_aux2 eq acc ref = function
-| Nil -> acc
-| Cons (t0, q) ->
- distinct_aux2 eq (if acc then negb (eq ref t0) else false) ref q
-
-(** val distinct_aux : ('a1 -> 'a1 -> bool) -> bool -> 'a1 list -> bool **)
-
-let rec distinct_aux eq acc = function
-| Nil -> acc
-| Cons (t0, q) ->
- let acc' = distinct_aux2 eq acc t0 q in distinct_aux eq acc' q
-
-(** val distinct : ('a1 -> 'a1 -> bool) -> 'a1 list -> bool **)
-
-let distinct eq =
- distinct_aux eq true
-
-(** val forallb2 : ('a1 -> 'a2 -> bool) -> 'a1 list -> 'a2 list -> bool **)
-
-let rec forallb2 f l1 l2 =
- match l1 with
- | Nil ->
- (match l2 with
- | Nil -> true
- | Cons (y, l) -> false)
- | Cons (a, l3) ->
- (match l2 with
- | Nil -> false
- | Cons (b, l4) -> if f a b then forallb2 f l3 l4 else false)
-
-module Form =
- struct
- 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 **)
-
- let form_rect f f0 f1 f2 f3 f4 f5 f6 f7 f8 = function
- | Fatom x -> f x
- | Ftrue -> f0
- | Ffalse -> f1
- | Fnot2 (x, x0) -> f2 x x0
- | Fand x -> f3 x
- | For x -> f4 x
- | Fimp x -> f5 x
- | Fxor (x, x0) -> f6 x x0
- | Fiff (x, x0) -> f7 x x0
- | Fite (x, x0, x1) -> f8 x x0 x1
-
- (** 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 **)
-
- let form_rec f f0 f1 f2 f3 f4 f5 f6 f7 f8 = function
- | Fatom x -> f x
- | Ftrue -> f0
- | Ffalse -> f1
- | Fnot2 (x, x0) -> f2 x x0
- | Fand x -> f3 x
- | For x -> f4 x
- | Fimp x -> f5 x
- | Fxor (x, x0) -> f6 x x0
- | Fiff (x, x0) -> f7 x x0
- | Fite (x, x0, x1) -> f8 x x0 x1
-
- (** val is_Ftrue : form -> bool **)
-
- let is_Ftrue = function
- | Ftrue -> true
- | _ -> false
-
- (** val is_Ffalse : form -> bool **)
-
- let is_Ffalse = function
- | Ffalse -> true
- | _ -> false
-
- (** val interp_aux : (int -> bool) -> (int -> bool) -> form -> bool **)
-
- let interp_aux interp_atom interp_var = function
- | Fatom a -> interp_atom a
- | Ftrue -> true
- | Ffalse -> false
- | Fnot2 (i, l) ->
- fold (fun b -> negb (negb b)) (ExtrNative.of_uint(1)) i
- (Lit.interp interp_var l)
- | Fand args ->
- afold_left true (fun b1 b2 -> if b1 then b2 else false)
- (Lit.interp interp_var) args
- | For args ->
- afold_left false (fun b1 b2 -> if b1 then true else b2)
- (Lit.interp interp_var) args
- | Fimp args -> afold_right true implb (Lit.interp interp_var) args
- | Fxor (a, b) -> xorb (Lit.interp interp_var a) (Lit.interp interp_var b)
- | Fiff (a, b) -> eqb (Lit.interp interp_var a) (Lit.interp interp_var b)
- | Fite (a, b, c) ->
- if Lit.interp interp_var a
- then Lit.interp interp_var b
- else Lit.interp interp_var c
-
- (** val t_interp : (int -> bool) -> form array -> bool array **)
-
- let t_interp interp_atom t_form =
- foldi_left (fun i t_b hf ->
- set t_b i (interp_aux interp_atom (get t_b) hf))
- (make (length t_form) true) t_form
-
- (** val lt_form : int -> form -> bool **)
-
- let rec lt_form i = function
- | Fnot2 (i0, l) -> ltb0 (Lit.blit l) i
- | Fand args -> forallb1 (fun l -> ltb0 (Lit.blit l) i) args
- | For args -> forallb1 (fun l -> ltb0 (Lit.blit l) i) args
- | Fimp args -> forallb1 (fun l -> ltb0 (Lit.blit l) i) args
- | Fxor (a, b) -> if ltb0 (Lit.blit a) i then ltb0 (Lit.blit b) i else false
- | Fiff (a, b) -> if ltb0 (Lit.blit a) i then ltb0 (Lit.blit b) i else false
- | Fite (a, b, c) ->
- if if ltb0 (Lit.blit a) i then ltb0 (Lit.blit b) i else false
- then ltb0 (Lit.blit c) i
- else false
- | _ -> true
-
- (** val wf : form array -> bool **)
-
- let wf t_form =
- forallbi lt_form t_form
-
- (** val interp_state_var : (int -> bool) -> form array -> int -> bool **)
-
- let interp_state_var interp_atom t_form =
- let t_interp0 = t_interp interp_atom t_form in get t_interp0
-
- (** val interp : (int -> bool) -> form array -> form -> bool **)
-
- let interp interp_atom t_form =
- interp_aux interp_atom (interp_state_var interp_atom t_form)
-
- (** val check_form : form array -> bool **)
-
- let check_form t_form =
- if if if is_Ftrue (default t_form)
- then is_Ftrue (get t_form (ExtrNative.of_uint(0)))
- else false
- then is_Ffalse (get t_form (ExtrNative.of_uint(1)))
- else false
- then wf t_form
- else false
- end
-
-type typ_eqb = { te_eqb : (__ -> __ -> bool);
- te_reflect : (__ -> __ -> reflect) }
-
-type te_carrier = __
-
-(** val te_eqb : typ_eqb -> te_carrier -> te_carrier -> bool **)
-
-let te_eqb x = x.te_eqb
-
-module Typ =
- struct
- type coq_type =
- | Tindex of int
- | TZ
- | Tbool
- | Tpositive
-
- (** val type_rect :
- (int -> 'a1) -> 'a1 -> 'a1 -> 'a1 -> coq_type -> 'a1 **)
-
- let type_rect f f0 f1 f2 = function
- | Tindex x -> f x
- | TZ -> f0
- | Tbool -> f1
- | Tpositive -> f2
-
- (** val type_rec : (int -> 'a1) -> 'a1 -> 'a1 -> 'a1 -> coq_type -> 'a1 **)
-
- let type_rec f f0 f1 f2 = function
- | Tindex x -> f x
- | TZ -> f0
- | Tbool -> f1
- | Tpositive -> f2
-
- type ftype = coq_type list*coq_type
-
- type interp = __
-
- type interp_ftype = __
-
- (** val i_eqb : typ_eqb array -> coq_type -> interp -> interp -> bool **)
-
- let i_eqb t_i = function
- | Tindex i -> (get t_i i).te_eqb
- | TZ -> Obj.magic zeq_bool
- | Tbool -> Obj.magic eqb
- | Tpositive -> Obj.magic Coq_Pos.eqb
-
- (** val reflect_i_eqb :
- typ_eqb array -> coq_type -> interp -> interp -> reflect **)
-
- let reflect_i_eqb t_i t0 x y =
- iff_reflect (i_eqb t_i t0 x y)
-
- type cast_result =
- | Cast of (__ -> __ -> __)
- | NoCast
-
- (** val cast_result_rect :
- coq_type -> coq_type -> ((__ -> __ -> __) -> 'a1) -> 'a1 -> cast_result
- -> 'a1 **)
-
- let cast_result_rect a b f f0 = function
- | Cast x -> f x
- | NoCast -> f0
-
- (** val cast_result_rec :
- coq_type -> coq_type -> ((__ -> __ -> __) -> 'a1) -> 'a1 -> cast_result
- -> 'a1 **)
-
- let cast_result_rec a b f f0 = function
- | Cast x -> f x
- | NoCast -> f0
-
- (** val cast : coq_type -> coq_type -> cast_result **)
-
- let cast a b =
- match a with
- | Tindex i ->
- (match b with
- | Tindex j ->
- (match cast i j with
- | Some k -> Cast (fun _ -> k __)
- | None -> NoCast)
- | _ -> NoCast)
- | TZ ->
- (match b with
- | TZ -> Cast (fun _ x -> x)
- | _ -> NoCast)
- | Tbool ->
- (match b with
- | Tbool -> Cast (fun _ x -> x)
- | _ -> NoCast)
- | Tpositive ->
- (match b with
- | Tpositive -> Cast (fun _ x -> x)
- | _ -> NoCast)
-
- (** val eqb : coq_type -> coq_type -> bool **)
-
- let eqb a b =
- match a with
- | Tindex i ->
- (match b with
- | Tindex j -> eqb0 i j
- | _ -> false)
- | TZ ->
- (match b with
- | TZ -> true
- | _ -> false)
- | Tbool ->
- (match b with
- | Tbool -> true
- | _ -> false)
- | Tpositive ->
- (match b with
- | Tpositive -> true
- | _ -> false)
-
- (** val reflect_eqb : coq_type -> coq_type -> reflect **)
-
- let reflect_eqb x y =
- match x with
- | Tindex i ->
- (match y with
- | Tindex i0 -> iff_reflect (eqb0 i i0)
- | _ -> ReflectF)
- | TZ ->
- (match y with
- | TZ -> ReflectT
- | _ -> ReflectF)
- | Tbool ->
- (match y with
- | Tbool -> ReflectT
- | _ -> ReflectF)
- | Tpositive ->
- (match y with
- | Tpositive -> ReflectT
- | _ -> ReflectF)
- end
-
-(** val list_beq : ('a1 -> 'a1 -> bool) -> 'a1 list -> 'a1 list -> bool **)
-
-let rec list_beq eq_A x y =
- match x with
- | Nil ->
- (match y with
- | Nil -> true
- | Cons (a, l) -> false)
- | Cons (x0, x1) ->
- (match y with
- | Nil -> false
- | Cons (x2, x3) -> if eq_A x0 x2 then list_beq eq_A x1 x3 else false)
-
-(** val reflect_list_beq :
- ('a1 -> 'a1 -> bool) -> ('a1 -> 'a1 -> reflect) -> 'a1 list -> 'a1 list
- -> reflect **)
+(** val firstn : nat -> 'a1 list -> 'a1 list **)
-let rec reflect_list_beq beq hbeq x y =
- match x with
- | Nil ->
- (match y with
- | Nil -> ReflectT
- | Cons (a, y0) -> ReflectF)
- | Cons (y0, l) ->
- (match y with
- | Nil -> ReflectF
- | Cons (a0, y1) ->
- let r = hbeq y0 a0 in
- (match r with
- | ReflectT -> reflect_list_beq beq hbeq l y1
- | ReflectF -> ReflectF))
-
-module Atom =
- struct
- type cop =
- | CO_xH
- | CO_Z0
-
- (** val cop_rect : 'a1 -> 'a1 -> cop -> 'a1 **)
-
- let cop_rect f f0 = function
- | CO_xH -> f
- | CO_Z0 -> f0
-
- (** val cop_rec : 'a1 -> 'a1 -> cop -> 'a1 **)
-
- let cop_rec f f0 = function
- | CO_xH -> f
- | CO_Z0 -> f0
-
- type unop =
- | UO_xO
- | UO_xI
- | UO_Zpos
- | UO_Zneg
- | UO_Zopp
-
- (** val unop_rect : 'a1 -> 'a1 -> 'a1 -> 'a1 -> 'a1 -> unop -> 'a1 **)
-
- let unop_rect f f0 f1 f2 f3 = function
- | UO_xO -> f
- | UO_xI -> f0
- | UO_Zpos -> f1
- | UO_Zneg -> f2
- | UO_Zopp -> f3
-
- (** val unop_rec : 'a1 -> 'a1 -> 'a1 -> 'a1 -> 'a1 -> unop -> 'a1 **)
-
- let unop_rec f f0 f1 f2 f3 = function
- | UO_xO -> f
- | UO_xI -> f0
- | UO_Zpos -> f1
- | UO_Zneg -> f2
- | UO_Zopp -> f3
-
- 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 **)
-
- let binop_rect f f0 f1 f2 f3 f4 f5 f6 = function
- | BO_Zplus -> f
- | BO_Zminus -> f0
- | BO_Zmult -> f1
- | BO_Zlt -> f2
- | BO_Zle -> f3
- | BO_Zge -> f4
- | BO_Zgt -> f5
- | BO_eq x -> f6 x
-
- (** val binop_rec :
- 'a1 -> 'a1 -> 'a1 -> 'a1 -> 'a1 -> 'a1 -> 'a1 -> (Typ.coq_type -> 'a1)
- -> binop -> 'a1 **)
-
- let binop_rec f f0 f1 f2 f3 f4 f5 f6 = function
- | BO_Zplus -> f
- | BO_Zminus -> f0
- | BO_Zmult -> f1
- | BO_Zlt -> f2
- | BO_Zle -> f3
- | BO_Zge -> f4
- | BO_Zgt -> f5
- | BO_eq x -> f6 x
-
- type nop =
- Typ.coq_type
- (* singleton inductive, whose constructor was NO_distinct *)
-
- (** val nop_rect : (Typ.coq_type -> 'a1) -> nop -> 'a1 **)
-
- let nop_rect f n0 =
- f n0
-
- (** val nop_rec : (Typ.coq_type -> 'a1) -> nop -> 'a1 **)
-
- let nop_rec f n0 =
- f n0
-
- 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 **)
-
- let atom_rect f f0 f1 f2 f3 = function
- | Acop x -> f x
- | Auop (x, x0) -> f0 x x0
- | Abop (x, x0, x1) -> f1 x x0 x1
- | Anop (x, x0) -> f2 x x0
- | Aapp (x, x0) -> f3 x x0
-
- (** val atom_rec :
- (cop -> 'a1) -> (unop -> int -> 'a1) -> (binop -> int -> int -> 'a1) ->
- (nop -> int list -> 'a1) -> (int -> int list -> 'a1) -> atom -> 'a1 **)
-
- let atom_rec f f0 f1 f2 f3 = function
- | Acop x -> f x
- | Auop (x, x0) -> f0 x x0
- | Abop (x, x0, x1) -> f1 x x0 x1
- | Anop (x, x0) -> f2 x x0
- | Aapp (x, x0) -> f3 x x0
-
- (** val cop_eqb : cop -> cop -> bool **)
-
- let cop_eqb o o' =
- match o with
- | CO_xH ->
- (match o' with
- | CO_xH -> true
- | CO_Z0 -> false)
- | CO_Z0 ->
- (match o' with
- | CO_xH -> false
- | CO_Z0 -> true)
-
- (** val uop_eqb : unop -> unop -> bool **)
-
- let uop_eqb o o' =
- match o with
- | UO_xO ->
- (match o' with
- | UO_xO -> true
- | _ -> false)
- | UO_xI ->
- (match o' with
- | UO_xI -> true
- | _ -> false)
- | UO_Zpos ->
- (match o' with
- | UO_Zpos -> true
- | _ -> false)
- | UO_Zneg ->
- (match o' with
- | UO_Zneg -> true
- | _ -> false)
- | UO_Zopp ->
- (match o' with
- | UO_Zopp -> true
- | _ -> false)
-
- (** val bop_eqb : binop -> binop -> bool **)
-
- let bop_eqb o o' =
- match o with
- | BO_Zplus ->
- (match o' with
- | BO_Zplus -> true
- | _ -> false)
- | BO_Zminus ->
- (match o' with
- | BO_Zminus -> true
- | _ -> false)
- | BO_Zmult ->
- (match o' with
- | BO_Zmult -> true
- | _ -> false)
- | BO_Zlt ->
- (match o' with
- | BO_Zlt -> true
- | _ -> false)
- | BO_Zle ->
- (match o' with
- | BO_Zle -> true
- | _ -> false)
- | BO_Zge ->
- (match o' with
- | BO_Zge -> true
- | _ -> false)
- | BO_Zgt ->
- (match o' with
- | BO_Zgt -> true
- | _ -> false)
- | BO_eq t0 ->
- (match o' with
- | BO_eq t' -> Typ.eqb t0 t'
- | _ -> false)
-
- (** val nop_eqb : nop -> nop -> bool **)
-
- let nop_eqb o o' =
- Typ.eqb o o'
-
- (** val eqb : atom -> atom -> bool **)
-
- let eqb t0 t' =
- match t0 with
- | Acop o ->
- (match t' with
- | Acop o' -> cop_eqb o o'
- | _ -> false)
- | Auop (o, t1) ->
- (match t' with
- | Auop (o', t'0) -> if uop_eqb o o' then eqb0 t1 t'0 else false
- | _ -> false)
- | Abop (o, t1, t2) ->
- (match t' with
- | Abop (o', t1', t2') ->
- if if bop_eqb o o' then eqb0 t1 t1' else false
- then eqb0 t2 t2'
- else false
- | _ -> false)
- | Anop (o, t1) ->
- (match t' with
- | Anop (o', t'0) ->
- if nop_eqb o o' then list_beq eqb0 t1 t'0 else false
- | _ -> false)
- | Aapp (a, la) ->
- (match t' with
- | Aapp (b, lb) -> if eqb0 a b then list_beq eqb0 la lb else false
- | _ -> false)
-
- (** val reflect_cop_eqb : cop -> cop -> reflect **)
-
- let reflect_cop_eqb o1 o2 =
- match o1 with
- | CO_xH ->
- (match o2 with
- | CO_xH -> ReflectT
- | CO_Z0 -> ReflectF)
- | CO_Z0 ->
- (match o2 with
- | CO_xH -> ReflectF
- | CO_Z0 -> ReflectT)
-
- (** val reflect_uop_eqb : unop -> unop -> reflect **)
-
- let reflect_uop_eqb o1 o2 =
- match o1 with
- | UO_xO ->
- (match o2 with
- | UO_xO -> ReflectT
- | _ -> ReflectF)
- | UO_xI ->
- (match o2 with
- | UO_xI -> ReflectT
- | _ -> ReflectF)
- | UO_Zpos ->
- (match o2 with
- | UO_Zpos -> ReflectT
- | _ -> ReflectF)
- | UO_Zneg ->
- (match o2 with
- | UO_Zneg -> ReflectT
- | _ -> ReflectF)
- | UO_Zopp ->
- (match o2 with
- | UO_Zopp -> ReflectT
- | _ -> ReflectF)
-
- (** val reflect_bop_eqb : binop -> binop -> reflect **)
-
- let reflect_bop_eqb o1 o2 =
- match o1 with
- | BO_Zplus ->
- (match o2 with
- | BO_Zplus -> ReflectT
- | _ -> ReflectF)
- | BO_Zminus ->
- (match o2 with
- | BO_Zminus -> ReflectT
- | _ -> ReflectF)
- | BO_Zmult ->
- (match o2 with
- | BO_Zmult -> ReflectT
- | _ -> ReflectF)
- | BO_Zlt ->
- (match o2 with
- | BO_Zlt -> ReflectT
- | _ -> ReflectF)
- | BO_Zle ->
- (match o2 with
- | BO_Zle -> ReflectT
- | _ -> ReflectF)
- | BO_Zge ->
- (match o2 with
- | BO_Zge -> ReflectT
- | _ -> ReflectF)
- | BO_Zgt ->
- (match o2 with
- | BO_Zgt -> ReflectT
- | _ -> ReflectF)
- | BO_eq t0 ->
- (match o2 with
- | BO_eq t1 -> Typ.reflect_eqb t0 t1
- | _ -> ReflectF)
-
- (** val reflect_nop_eqb : nop -> nop -> reflect **)
-
- let reflect_nop_eqb o1 o2 =
- Typ.reflect_eqb o1 o2
-
- (** val reflect_eqb : atom -> atom -> reflect **)
-
- let reflect_eqb t1 t2 =
- match t1 with
- | Acop c ->
- (match t2 with
- | Acop c0 -> reflect_cop_eqb c c0
- | _ -> ReflectF)
- | Auop (u, i) ->
- (match t2 with
- | Auop (u0, i0) ->
- let r = reflect_uop_eqb u u0 in
- (match r with
- | ReflectT -> reflect_eqb i i0
- | ReflectF -> ReflectF)
- | _ -> ReflectF)
- | Abop (b, i, i0) ->
- (match t2 with
- | Abop (b0, i1, i2) ->
- let r = reflect_bop_eqb b b0 in
- (match r with
- | ReflectT ->
- let r0 = reflect_eqb i i1 in
- (match r0 with
- | ReflectT -> reflect_eqb i0 i2
- | ReflectF -> ReflectF)
- | ReflectF -> ReflectF)
- | _ -> ReflectF)
- | Anop (n0, l) ->
- (match t2 with
- | Anop (n1, l0) ->
- let r = reflect_nop_eqb n0 n1 in
- (match r with
- | ReflectT -> reflect_list_beq eqb0 reflect_eqb l l0
- | ReflectF -> ReflectF)
- | _ -> ReflectF)
- | Aapp (i, l) ->
- (match t2 with
- | Aapp (i0, l0) ->
- let r = reflect_eqb i i0 in
- (match r with
- | ReflectT -> reflect_list_beq eqb0 reflect_eqb l l0
- | ReflectF -> ReflectF)
- | _ -> ReflectF)
-
- type ('t, 'i) coq_val = { v_type : 't; v_val : 'i }
-
- (** val val_rect : ('a1 -> 'a2 -> 'a3) -> ('a1, 'a2) coq_val -> 'a3 **)
-
- let val_rect f v =
- let { v_type = x; v_val = x0 } = v in f x x0
-
- (** val val_rec : ('a1 -> 'a2 -> 'a3) -> ('a1, 'a2) coq_val -> 'a3 **)
-
- let val_rec f v =
- let { v_type = x; v_val = x0 } = v in f x x0
-
- (** val v_type : ('a1, 'a2) coq_val -> 'a1 **)
-
- let v_type x = x.v_type
-
- (** val v_val : ('a1, 'a2) coq_val -> 'a2 **)
-
- let v_val x = x.v_val
-
- 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 **)
-
- let coq_Bval t_i x x0 =
- { v_type = x; v_val = x0 }
-
- 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 **)
-
- let coq_Tval t_i x x0 =
- { v_type = x; v_val = x0 }
-
- (** val bvtrue : typ_eqb array -> bval **)
-
- let bvtrue t_i =
- coq_Bval t_i Typ.Tbool (Obj.magic true)
-
- (** val bvfalse : typ_eqb array -> bval **)
-
- let bvfalse t_i =
- coq_Bval t_i Typ.Tbool (Obj.magic false)
-
- (** val typ_cop : cop -> Typ.coq_type **)
-
- let typ_cop = function
- | CO_xH -> Typ.Tpositive
- | CO_Z0 -> Typ.TZ
-
- (** val typ_uop : unop -> Typ.coq_type*Typ.coq_type **)
-
- let typ_uop = function
- | UO_xO -> Typ.Tpositive,Typ.Tpositive
- | UO_xI -> Typ.Tpositive,Typ.Tpositive
- | UO_Zopp -> Typ.TZ,Typ.TZ
- | _ -> Typ.Tpositive,Typ.TZ
-
- (** val typ_bop : binop -> (Typ.coq_type*Typ.coq_type)*Typ.coq_type **)
-
- let typ_bop = function
- | BO_Zplus -> (Typ.TZ,Typ.TZ),Typ.TZ
- | BO_Zminus -> (Typ.TZ,Typ.TZ),Typ.TZ
- | BO_Zmult -> (Typ.TZ,Typ.TZ),Typ.TZ
- | BO_eq t0 -> (t0,t0),Typ.Tbool
- | _ -> (Typ.TZ,Typ.TZ),Typ.Tbool
-
- (** val typ_nop : nop -> Typ.coq_type*Typ.coq_type **)
-
- let typ_nop o =
- o,Typ.Tbool
-
- (** val check_args :
- (int -> Typ.coq_type) -> int list -> Typ.coq_type list -> bool **)
-
- let rec check_args get_type0 args targs =
- match args with
- | Nil ->
- (match targs with
- | Nil -> true
- | Cons (t0, l) -> false)
- | Cons (a, args0) ->
- (match targs with
- | Nil -> false
- | Cons (t0, targs0) ->
- if Typ.eqb (get_type0 a) t0
- then check_args get_type0 args0 targs0
- else false)
-
- (** val check_aux :
- typ_eqb array -> tval array -> (int -> Typ.coq_type) -> atom ->
- Typ.coq_type -> bool **)
-
- let check_aux t_i t_func get_type0 a t0 =
- match a with
- | Acop o -> Typ.eqb (typ_cop o) t0
- | Auop (o, a0) ->
- let ta,t' = typ_uop o in
- if Typ.eqb t' t0 then Typ.eqb (get_type0 a0) ta else false
- | Abop (o, a1, a2) ->
- let ta,t' = typ_bop o in
- let ta1,ta2 = ta in
- if if Typ.eqb t' t0 then Typ.eqb (get_type0 a1) ta1 else false
- then Typ.eqb (get_type0 a2) ta2
- else false
- | Anop (o, a0) ->
- let ta,t' = typ_nop o in
- if Typ.eqb t' t0
- then forallb (fun t1 -> Typ.eqb (get_type0 t1) ta) a0
- else false
- | Aapp (f, args) ->
- let targs,tr = (get t_func f).v_type in
- if check_args get_type0 args targs then Typ.eqb tr t0 else false
-
- (** val check_args_dec :
- (int -> Typ.coq_type) -> Typ.coq_type -> int list -> Typ.coq_type list
- -> sumbool **)
-
- let rec check_args_dec get_type0 a args targs =
- match args with
- | Nil ->
- (match targs with
- | Nil -> Left
- | Cons (t0, l) -> Right)
- | Cons (y, l) ->
- (match targs with
- | Nil -> Right
- | Cons (b, targs0) ->
- if Typ.eqb (get_type0 y) b
- then check_args_dec get_type0 a l targs0
- else Right)
-
- (** val check_aux_dec :
- typ_eqb array -> tval array -> (int -> Typ.coq_type) -> atom -> sumbool **)
-
- let check_aux_dec t_i t_func get_type0 = function
- | Acop op -> Left
- | Auop (op, h) ->
- (match op with
- | UO_Zopp -> if Typ.eqb (get_type0 h) Typ.TZ then Left else Right
- | _ -> if Typ.eqb (get_type0 h) Typ.Tpositive then Left else Right)
- | Abop (op, h1, h2) ->
- (match op with
- | BO_eq t0 ->
- if Typ.eqb (get_type0 h1) t0
- then if Typ.eqb (get_type0 h2) t0 then Left else Right
- else Right
- | _ ->
- if Typ.eqb (get_type0 h1) Typ.TZ
- then if Typ.eqb (get_type0 h2) Typ.TZ then Left else Right
- else Right)
- | Anop (op, ha) ->
- if forallb (fun t1 -> Typ.eqb (get_type0 t1) op) ha then Left else Right
- | Aapp (f, args) ->
- let l,t0 = (get t_func f).v_type in check_args_dec get_type0 t0 args l
-
- (** val apply_unop :
- typ_eqb array -> Typ.coq_type -> Typ.coq_type -> (Typ.interp ->
- Typ.interp) -> bval -> (Typ.coq_type, Typ.interp) coq_val **)
-
- let apply_unop t_i t0 r op tv =
- let { v_type = t'; v_val = v } = tv in
- (match Typ.cast t' t0 with
- | Typ.Cast k -> coq_Bval t_i r (op (k __ v))
- | Typ.NoCast -> bvtrue t_i)
-
- (** 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 **)
-
- let apply_binop t_i t1 t2 r op tv1 tv2 =
- let { v_type = t1'; v_val = v1 } = tv1 in
- let { v_type = t2'; v_val = v2 } = tv2 in
- (match Typ.cast t1' t1 with
- | Typ.Cast k1 ->
- (match Typ.cast t2' t2 with
- | Typ.Cast k2 -> coq_Bval t_i r (op (k1 __ v1) (k2 __ v2))
- | Typ.NoCast -> bvtrue t_i)
- | Typ.NoCast -> bvtrue t_i)
-
- (** val apply_func :
- typ_eqb array -> Typ.coq_type list -> Typ.coq_type -> Typ.interp_ftype
- -> bval list -> bval **)
-
- let rec apply_func t_i targs tr f lv =
- match targs with
- | Nil ->
- (match lv with
- | Nil -> coq_Bval t_i tr f
- | Cons (b, l) -> bvtrue t_i)
- | Cons (t0, targs0) ->
- (match lv with
- | Nil -> bvtrue t_i
- | Cons (v, lv0) ->
- let { v_type = tv; v_val = v0 } = v in
- (match Typ.cast tv t0 with
- | Typ.Cast k ->
- let f0 = Obj.magic f (k __ v0) in apply_func t_i targs0 tr f0 lv0
- | Typ.NoCast -> bvtrue t_i))
-
- (** val interp_cop :
- typ_eqb array -> cop -> (Typ.coq_type, Typ.interp) coq_val **)
-
- let interp_cop t_i = function
- | CO_xH -> coq_Bval t_i Typ.Tpositive (Obj.magic XH)
- | CO_Z0 -> coq_Bval t_i Typ.TZ (Obj.magic Z0)
-
- (** val interp_uop :
- typ_eqb array -> unop -> bval -> (Typ.coq_type, Typ.interp) coq_val **)
-
- let interp_uop t_i = function
- | UO_xO ->
- apply_unop t_i Typ.Tpositive Typ.Tpositive (Obj.magic (fun x -> XO x))
- | UO_xI ->
- apply_unop t_i Typ.Tpositive Typ.Tpositive (Obj.magic (fun x -> XI x))
- | UO_Zpos ->
- apply_unop t_i Typ.Tpositive Typ.TZ (Obj.magic (fun x -> Zpos x))
- | UO_Zneg ->
- apply_unop t_i Typ.Tpositive Typ.TZ (Obj.magic (fun x -> Zneg x))
- | UO_Zopp -> apply_unop t_i Typ.TZ Typ.TZ (Obj.magic Z.opp)
-
- (** val interp_bop :
- typ_eqb array -> binop -> bval -> bval -> (Typ.coq_type, Typ.interp)
- coq_val **)
-
- let interp_bop t_i = function
- | BO_Zplus -> apply_binop t_i Typ.TZ Typ.TZ Typ.TZ (Obj.magic Z.add)
- | BO_Zminus -> apply_binop t_i Typ.TZ Typ.TZ Typ.TZ (Obj.magic Z.sub)
- | BO_Zmult -> apply_binop t_i Typ.TZ Typ.TZ Typ.TZ (Obj.magic Z.mul)
- | BO_Zlt -> apply_binop t_i Typ.TZ Typ.TZ Typ.Tbool (Obj.magic Z.ltb)
- | BO_Zle -> apply_binop t_i Typ.TZ Typ.TZ Typ.Tbool (Obj.magic Z.leb)
- | BO_Zge -> apply_binop t_i Typ.TZ Typ.TZ Typ.Tbool (Obj.magic Z.geb)
- | BO_Zgt -> apply_binop t_i Typ.TZ Typ.TZ Typ.Tbool (Obj.magic Z.gtb)
- | BO_eq t0 ->
- apply_binop t_i t0 t0 Typ.Tbool (Obj.magic (Typ.i_eqb t_i t0))
-
- (** val compute_interp :
- typ_eqb array -> (int -> bval) -> Typ.coq_type -> Typ.interp list ->
- int list -> Typ.interp list option **)
-
- let rec compute_interp t_i interp_hatom0 ty acc = function
- | Nil -> Some acc
- | Cons (a, q) ->
- let { v_type = ta; v_val = va } = interp_hatom0 a in
- (match Typ.cast ta ty with
- | Typ.Cast ka ->
- compute_interp t_i interp_hatom0 ty (Cons ((ka __ va), acc)) q
- | Typ.NoCast -> None)
-
- (** val interp_aux :
- typ_eqb array -> tval array -> (int -> bval) -> atom -> bval **)
-
- let interp_aux t_i t_func interp_hatom0 = function
- | Acop o -> interp_cop t_i o
- | Auop (o, a0) -> interp_uop t_i o (interp_hatom0 a0)
- | Abop (o, a1, a2) ->
- interp_bop t_i o (interp_hatom0 a1) (interp_hatom0 a2)
- | Anop (n0, a0) ->
- (match compute_interp t_i interp_hatom0 n0 Nil a0 with
- | Some l ->
- coq_Bval t_i Typ.Tbool
- (Obj.magic (distinct (Typ.i_eqb t_i n0) (rev l)))
- | None -> bvtrue t_i)
- | Aapp (f, args) ->
- let { v_type = tf; v_val = f0 } = get t_func f in
- let lv = map interp_hatom0 args in apply_func t_i (fst tf) (snd tf) f0 lv
-
- (** val interp_bool : typ_eqb array -> bval -> bool **)
-
- let interp_bool t_i v =
- let { v_type = t0; v_val = v0 } = v in
- (match Typ.cast t0 Typ.Tbool with
- | Typ.Cast k -> Obj.magic k __ v0
- | Typ.NoCast -> true)
-
- (** val t_interp :
- typ_eqb array -> tval array -> atom array -> bval array **)
-
- let t_interp t_i t_func t_atom =
- foldi_left (fun i t_a a -> set t_a i (interp_aux t_i t_func (get t_a) a))
- (make (length t_atom) (interp_cop t_i CO_xH)) t_atom
-
- (** val lt_atom : int -> atom -> bool **)
-
- let lt_atom i = function
- | Acop c -> true
- | Auop (u, h) -> ltb0 h i
- | Abop (b, h1, h2) -> if ltb0 h1 i then ltb0 h2 i else false
- | Anop (n0, ha) -> forallb (fun h -> ltb0 h i) ha
- | Aapp (f, args) -> forallb (fun h -> ltb0 h i) args
-
- (** val wf : atom array -> bool **)
-
- let wf t_atom =
- forallbi lt_atom t_atom
-
- (** val get_type' : typ_eqb array -> bval array -> int -> Typ.coq_type **)
-
- let get_type' t_i t_interp' i =
- (get t_interp' i).v_type
-
- (** val get_type :
- typ_eqb array -> tval array -> atom array -> int -> Typ.coq_type **)
-
- let get_type t_i t_func t_atom =
- get_type' t_i (t_interp t_i t_func t_atom)
-
- (** val wt : typ_eqb array -> tval array -> atom array -> bool **)
-
- let wt t_i t_func t_atom =
- let t_interp0 = t_interp t_i t_func t_atom in
- let get_type0 = get_type' t_i t_interp0 in
- forallbi (fun i h -> check_aux t_i t_func get_type0 h (get_type0 i))
- t_atom
-
- (** val interp_hatom :
- typ_eqb array -> tval array -> atom array -> int -> bval **)
-
- let interp_hatom t_i t_func t_atom =
- let t_a = t_interp t_i t_func t_atom in get t_a
-
- (** val interp :
- typ_eqb array -> tval array -> atom array -> atom -> bval **)
-
- let interp t_i t_func t_atom =
- interp_aux t_i t_func (interp_hatom t_i t_func t_atom)
-
- (** val interp_form_hatom :
- typ_eqb array -> tval array -> atom array -> int -> bool **)
-
- let interp_form_hatom t_i t_func t_atom =
- let interp0 = interp_hatom t_i t_func t_atom in
- (fun a -> interp_bool t_i (interp0 a))
-
- (** val check_atom : atom array -> bool **)
-
- let check_atom t_atom =
- match default t_atom with
- | Acop c ->
- (match c with
- | CO_xH -> wf t_atom
- | CO_Z0 -> false)
- | _ -> false
- end
-
-(** val or_of_imp : int array -> int array **)
-
-let or_of_imp args =
- let last = sub0 (length args) (ExtrNative.of_uint(1)) in
- mapi (fun i l -> if eqb0 i last then l else Lit.neg l) args
-
-(** val check_True : C.t **)
-
-let check_True =
- C._true
-
-(** val check_False : int list **)
-
-let check_False =
- Cons ((Lit.neg Lit._false), Nil)
-
-(** val check_BuildDef : Form.form array -> int -> C.t **)
-
-let check_BuildDef t_form l =
- match get t_form (Lit.blit l) with
- | Form.Fand args ->
- if Lit.is_pos l then Cons (l, (map Lit.neg (to_list args))) else C._true
- | Form.For args ->
- if Lit.is_pos l then C._true else Cons (l, (to_list args))
- | Form.Fimp args ->
- if Lit.is_pos l
- then C._true
- else let args0 = or_of_imp args in Cons (l, (to_list args0))
- | Form.Fxor (a, b) ->
- if Lit.is_pos l
- then Cons (l, (Cons (a, (Cons ((Lit.neg b), Nil)))))
- else Cons (l, (Cons (a, (Cons (b, Nil)))))
- | Form.Fiff (a, b) ->
- if Lit.is_pos l
- then Cons (l, (Cons ((Lit.neg a), (Cons ((Lit.neg b), Nil)))))
- else Cons (l, (Cons (a, (Cons ((Lit.neg b), Nil)))))
- | Form.Fite (a, b, c) ->
- if Lit.is_pos l
- then Cons (l, (Cons (a, (Cons ((Lit.neg c), Nil)))))
- else Cons (l, (Cons (a, (Cons (c, Nil)))))
- | _ -> C._true
-
-(** val check_ImmBuildDef : Form.form array -> S.t -> int -> C.t **)
-
-let check_ImmBuildDef t_form s pos =
- match S.get s pos with
- | Nil -> C._true
- | Cons (l, l0) ->
- (match l0 with
- | Nil ->
- (match get t_form (Lit.blit l) with
- | Form.Fand args ->
- if Lit.is_pos l then C._true else map Lit.neg (to_list args)
- | Form.For args -> if Lit.is_pos l then to_list args else C._true
- | Form.Fimp args ->
- if Lit.is_pos l
- then let args0 = or_of_imp args in to_list args0
- else C._true
- | Form.Fxor (a, b) ->
- if Lit.is_pos l
- then Cons (a, (Cons (b, Nil)))
- else Cons (a, (Cons ((Lit.neg b), Nil)))
- | Form.Fiff (a, b) ->
- if Lit.is_pos l
- then Cons (a, (Cons ((Lit.neg b), Nil)))
- else Cons ((Lit.neg a), (Cons ((Lit.neg b), Nil)))
- | Form.Fite (a, b, c) ->
- if Lit.is_pos l
- then Cons (a, (Cons (c, Nil)))
- else Cons (a, (Cons ((Lit.neg c), Nil)))
- | _ -> C._true)
- | Cons (i, l1) -> C._true)
-
-(** val check_BuildDef2 : Form.form array -> int -> C.t **)
-
-let check_BuildDef2 t_form l =
- match get t_form (Lit.blit l) with
- | Form.Fxor (a, b) ->
- if Lit.is_pos l
- then Cons (l, (Cons ((Lit.neg a), (Cons (b, Nil)))))
- else Cons (l, (Cons ((Lit.neg a), (Cons ((Lit.neg b), Nil)))))
- | Form.Fiff (a, b) ->
- if Lit.is_pos l
- then Cons (l, (Cons (a, (Cons (b, Nil)))))
- else Cons (l, (Cons ((Lit.neg a), (Cons (b, Nil)))))
- | Form.Fite (a, b, c) ->
- if Lit.is_pos l
- then Cons (l, (Cons ((Lit.neg a), (Cons ((Lit.neg b), Nil)))))
- else Cons (l, (Cons ((Lit.neg a), (Cons (b, Nil)))))
- | _ -> C._true
-
-(** val check_ImmBuildDef2 : Form.form array -> S.t -> int -> C.t **)
-
-let check_ImmBuildDef2 t_form s pos =
- match S.get s pos with
- | Nil -> C._true
- | Cons (l, l0) ->
- (match l0 with
- | Nil ->
- (match get t_form (Lit.blit l) with
- | Form.Fxor (a, b) ->
- if Lit.is_pos l
- then Cons ((Lit.neg a), (Cons ((Lit.neg b), Nil)))
- else Cons ((Lit.neg a), (Cons (b, Nil)))
- | Form.Fiff (a, b) ->
- if Lit.is_pos l
- then Cons ((Lit.neg a), (Cons (b, Nil)))
- else Cons (a, (Cons (b, Nil)))
- | Form.Fite (a, b, c) ->
- if Lit.is_pos l
- then Cons ((Lit.neg a), (Cons (b, Nil)))
- else Cons ((Lit.neg a), (Cons ((Lit.neg b), Nil)))
- | _ -> C._true)
- | Cons (i, l1) -> C._true)
-
-(** val check_BuildProj : Form.form array -> int -> int -> C.t **)
-
-let check_BuildProj t_form l i =
- let x = Lit.blit l in
- (match get t_form x with
- | Form.Fand args ->
- if ltb0 i (length args)
- then Cons ((Lit.nlit x), (Cons ((get args i), Nil)))
- else C._true
- | Form.For args ->
- if ltb0 i (length args)
- then Cons ((Lit.lit x), (Cons ((Lit.neg (get args i)), Nil)))
- else C._true
- | Form.Fimp args ->
- let len = length args in
- if ltb0 i len
- then if eqb0 i (sub0 len (ExtrNative.of_uint(1)))
- then Cons ((Lit.lit x), (Cons ((Lit.neg (get args i)), Nil)))
- else Cons ((Lit.lit x), (Cons ((get args i), Nil)))
- else C._true
- | _ -> C._true)
-
-(** val check_ImmBuildProj : Form.form array -> S.t -> int -> int -> C.t **)
-
-let check_ImmBuildProj t_form s pos i =
- match S.get s pos with
- | Nil -> C._true
- | Cons (l, l0) ->
- (match l0 with
- | Nil ->
- let x = Lit.blit l in
- (match get t_form x with
- | Form.Fand args ->
- if if ltb0 i (length args) then Lit.is_pos l else false
- then Cons ((get args i), Nil)
- else C._true
- | Form.For args ->
- if if ltb0 i (length args) then negb (Lit.is_pos l) else false
- then Cons ((Lit.neg (get args i)), Nil)
- else C._true
- | Form.Fimp args ->
- let len = length args in
- if if ltb0 i len then negb (Lit.is_pos l) else false
- then if eqb0 i (sub0 len (ExtrNative.of_uint(1)))
- then Cons ((Lit.neg (get args i)), Nil)
- else Cons ((get args i), Nil)
- else C._true
- | _ -> C._true)
- | Cons (i0, l1) -> C._true)
-
-(** val get_eq :
- Form.form array -> Atom.atom array -> int -> (int -> int -> C.t) -> C.t **)
-
-let get_eq t_form t_atom x f =
- match get t_form x with
- | Form.Fatom xa ->
- (match get t_atom xa with
- | Atom.Abop (b0, a, b) ->
- (match b0 with
- | Atom.BO_eq t0 -> f a b
- | _ -> C._true)
- | _ -> C._true)
- | _ -> C._true
-
-(** val check_trans_aux :
- Form.form array -> Atom.atom array -> int -> int -> int list -> int ->
- C.t -> C.t **)
-
-let rec check_trans_aux t_form t_atom t1 t2 eqs res clause0 =
- match eqs with
- | Nil ->
- let xres = Lit.blit res in
- get_eq t_form t_atom xres (fun t1' t2' ->
- if if if eqb0 t1 t1' then eqb0 t2 t2' else false
- then true
- else if eqb0 t1 t2' then eqb0 t2 t1' else false
- then Cons ((Lit.lit xres), clause0)
- else C._true)
- | Cons (leq, eqs0) ->
- let xeq = Lit.blit leq in
- get_eq t_form t_atom xeq (fun t0 t' ->
- if eqb0 t2 t'
- then check_trans_aux t_form t_atom t1 t0 eqs0 res (Cons
- ((Lit.nlit xeq), clause0))
- else if eqb0 t2 t0
- then check_trans_aux t_form t_atom t1 t' eqs0 res (Cons
- ((Lit.nlit xeq), clause0))
- else if eqb0 t1 t'
- then check_trans_aux t_form t_atom t0 t2 eqs0 res (Cons
- ((Lit.nlit xeq), clause0))
- else if eqb0 t1 t0
- then check_trans_aux t_form t_atom t' t2 eqs0 res (Cons
- ((Lit.nlit xeq), clause0))
- else C._true)
-
-(** val check_trans :
- Form.form array -> Atom.atom array -> int -> int list -> C.t **)
-
-let check_trans t_form t_atom res = function
-| Nil ->
- let xres = Lit.blit res in
- get_eq t_form t_atom xres (fun t1 t2 ->
- if eqb0 t1 t2 then Cons ((Lit.lit xres), Nil) else C._true)
-| Cons (leq, eqs0) ->
- let xeq = Lit.blit leq in
- get_eq t_form t_atom xeq (fun t1 t2 ->
- check_trans_aux t_form t_atom t1 t2 eqs0 res (Cons ((Lit.nlit xeq), Nil)))
-
-(** val build_congr :
- Form.form array -> Atom.atom array -> int option list -> int list -> int
- list -> C.t -> C.t **)
-
-let rec build_congr t_form t_atom eqs l r c =
- match eqs with
- | Nil ->
- (match l with
- | Nil ->
- (match r with
- | Nil -> c
- | Cons (i, l0) -> C._true)
- | Cons (i, l0) -> C._true)
- | Cons (eq, eqs0) ->
+let rec firstn n0 l =
+ match n0 with
+ | O -> Nil
+ | S n1 ->
(match l with
- | Nil -> C._true
- | Cons (t1, l0) ->
- (match r with
- | Nil -> C._true
- | Cons (t2, r0) ->
- (match eq with
- | Some leq ->
- let xeq = Lit.blit leq in
- get_eq t_form t_atom xeq (fun t1' t2' ->
- if if if eqb0 t1 t1' then eqb0 t2 t2' else false
- then true
- else if eqb0 t1 t2' then eqb0 t2 t1' else false
- then build_congr t_form t_atom eqs0 l0 r0 (Cons
- ((Lit.nlit xeq), c))
- else C._true)
- | None ->
- if eqb0 t1 t2
- then build_congr t_form t_atom eqs0 l0 r0 c
- else C._true)))
-
-(** val check_congr :
- Form.form array -> Atom.atom array -> int -> int option list -> C.t **)
+ | Nil -> Nil
+ | Cons (a, l0) -> Cons (a, (firstn n1 l0)))
-let check_congr t_form t_atom leq eqs =
- let xeq = Lit.blit leq in
- get_eq t_form t_atom xeq (fun t1 t2 ->
- match get t_atom t1 with
- | Atom.Auop (o1, a) ->
- (match get t_atom t2 with
- | Atom.Auop (o2, b) ->
- if Atom.uop_eqb o1 o2
- then build_congr t_form t_atom eqs (Cons (a, Nil)) (Cons (b, Nil))
- (Cons ((Lit.lit xeq), Nil))
- else C._true
- | _ -> C._true)
- | Atom.Abop (o1, a1, a2) ->
- (match get t_atom t2 with
- | Atom.Abop (o2, b1, b2) ->
- if Atom.bop_eqb o1 o2
- then build_congr t_form t_atom eqs (Cons (a1, (Cons (a2, Nil))))
- (Cons (b1, (Cons (b2, Nil)))) (Cons ((Lit.lit xeq), Nil))
- else C._true
- | _ -> C._true)
- | Atom.Aapp (f1, args1) ->
- (match get t_atom t2 with
- | Atom.Aapp (f2, args2) ->
- if eqb0 f1 f2
- then build_congr t_form t_atom eqs args1 args2 (Cons ((Lit.lit xeq),
- Nil))
- else C._true
- | _ -> C._true)
- | _ -> C._true)
+(** val zeq_bool : z -> z -> bool **)
-(** val check_congr_pred :
- Form.form array -> Atom.atom array -> int -> int -> int option list ->
- C.t **)
+let zeq_bool x y =
+ match Z.compare x y with
+ | 0 -> true
+ | _ -> false
-let check_congr_pred t_form t_atom pA pB eqs =
- let xPA = Lit.blit pA in
- let xPB = Lit.blit pB in
- (match get t_form xPA with
- | Form.Fatom pa ->
- (match get t_form xPB with
- | Form.Fatom pb ->
- (match get t_atom pa with
- | Atom.Auop (o1, a) ->
- (match get t_atom pb with
- | Atom.Auop (o2, b) ->
- if Atom.uop_eqb o1 o2
- then build_congr t_form t_atom eqs (Cons (a, Nil)) (Cons (b,
- Nil)) (Cons ((Lit.nlit xPA), (Cons ((Lit.lit xPB),
- Nil))))
- else C._true
- | _ -> C._true)
- | Atom.Abop (o1, a1, a2) ->
- (match get t_atom pb with
- | Atom.Abop (o2, b1, b2) ->
- if Atom.bop_eqb o1 o2
- then build_congr t_form t_atom eqs (Cons (a1, (Cons (a2,
- Nil)))) (Cons (b1, (Cons (b2, Nil)))) (Cons
- ((Lit.nlit xPA), (Cons ((Lit.lit xPB), Nil))))
- else C._true
- | _ -> C._true)
- | Atom.Aapp (p, a) ->
- (match get t_atom pb with
- | Atom.Aapp (p', b) ->
- if eqb0 p p'
- then build_congr t_form t_atom eqs a b (Cons ((Lit.nlit xPA),
- (Cons ((Lit.lit xPB), Nil))))
- else C._true
- | _ -> C._true)
- | _ -> C._true)
- | _ -> C._true)
- | _ -> C._true)
+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
@@ -4778,31 +805,30 @@ let p1 cI =
let rec peq ceqb p p' =
match p with
- | Pc c ->
- (match p' with
- | Pc c' -> ceqb c c'
- | _ -> false)
+ | Pc c -> (match p' with
+ | Pc c' -> ceqb c c'
+ | _ -> false)
| Pinj (j, q) ->
(match p' with
| Pinj (j', q') ->
(match Coq_Pos.compare j j' with
- | ExtrNative.Eq -> peq ceqb q q'
+ | 0 -> peq ceqb q q'
| _ -> false)
| _ -> false)
| PX (p2, i, q) ->
(match p' with
| PX (p'0, i', q') ->
(match Coq_Pos.compare i i' with
- | ExtrNative.Eq -> if peq ceqb p2 p'0 then peq ceqb q q' else false
+ | 0 -> if peq ceqb p2 p'0 then peq ceqb q q' else false
| _ -> false)
| _ -> false)
(** val mkPinj : positive -> 'a1 pol -> 'a1 pol **)
let mkPinj j p = match p with
-| Pc c -> p
+| Pc _ -> p
| Pinj (j', q) -> Pinj ((Coq_Pos.add j j'), q)
-| PX (p2, p3, p4) -> Pinj (j, p)
+| PX (_, _, _) -> Pinj (j, p)
(** val mkPinj_pred : positive -> 'a1 pol -> 'a1 pol **)
@@ -4818,7 +844,7 @@ let mkPinj_pred j p =
let mkPX cO ceqb p i q =
match p with
| Pc c -> if ceqb c cO then mkPinj XH q else PX (p, i, q)
- | Pinj (p2, p3) -> PX (p, i, q)
+ | Pinj (_, _) -> PX (p, i, q)
| PX (p', i', q') ->
if peq ceqb q' (p0 cO)
then PX (p', (Coq_Pos.add i' i), q)
@@ -4896,7 +922,7 @@ let rec psubI cadd copp pop q j = function
-> positive -> 'a1 pol -> 'a1 pol **)
let rec paddX cO ceqb pop p' i' p = match p with
-| Pc c -> PX (p', i', p)
+| Pc _ -> PX (p', i', p)
| Pinj (j, q') ->
(match j with
| XI j0 -> PX (p', i', (Pinj ((XO j0), q')))
@@ -4913,7 +939,7 @@ let rec paddX cO ceqb pop p' i' p = match p with
pol) -> 'a1 pol -> positive -> 'a1 pol -> 'a1 pol **)
let rec psubX cO copp ceqb pop p' i' p = match p with
-| Pc c -> PX ((popp copp p'), i', p)
+| Pc _ -> PX ((popp copp p'), i', p)
| Pinj (j, q') ->
(match j with
| XI j0 -> PX ((popp copp p'), i', (Pinj ((XO j0), q')))
@@ -5071,15 +1097,6 @@ let rec psquare cO cI cadd cmul ceqb = function
let p3 = psquare cO cI cadd cmul ceqb p2 in
mkPX cO ceqb (padd cO cadd ceqb (mkPX cO ceqb p3 i (p0 cO)) twoPQ) i q2
-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 **)
let mk_X cO cI j =
@@ -5142,41 +1159,54 @@ let rec norm_aux cO cI cadd cmul csub copp ceqb = function
ppow_N cO cI cadd cmul ceqb (fun p -> p)
(norm_aux cO cI cadd cmul csub copp ceqb pe1) n0
-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 'term' clause = 'term' list
+type rtyp = __
-type 'term' cnf = 'term' clause list
+type eKind = __
-(** val tt : 'a1 cnf **)
+type 'a bFormula = ('a, eKind, unit0, unit0) gFormula
-let tt =
+type ('x, 'annot) clause = ('x * 'annot) list
+
+type ('x, 'annot) cnf = ('x, 'annot) clause list
+
+(** val cnf_tt : ('a1, 'a2) cnf **)
+
+let cnf_tt =
Nil
-(** val ff : 'a1 cnf **)
+(** val cnf_ff : ('a1, 'a2) cnf **)
-let ff =
+let cnf_ff =
Cons (Nil, Nil)
(** 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 **)
let rec add_term unsat deduce t0 = function
| Nil ->
- (match deduce t0 t0 with
+ (match deduce (fst t0) (fst t0) with
| Some u -> if unsat u then None else Some (Cons (t0, Nil))
| None -> Some (Cons (t0, Nil)))
| Cons (t', cl0) ->
- (match deduce t0 t' with
+ (match deduce (fst t0) (fst t') with
| Some u ->
if unsat u
then None
@@ -5189,8 +1219,8 @@ let rec add_term unsat deduce t0 = function
| None -> None))
(** 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 **)
let rec or_clause unsat deduce cl1 cl2 =
match cl1 with
@@ -5200,63 +1230,161 @@ let rec or_clause unsat deduce cl1 cl2 =
| Some cl' -> or_clause unsat deduce cl cl'
| None -> None)
-(** val or_clause_cnf :
- ('a1 -> bool) -> ('a1 -> 'a1 -> 'a1 option) -> 'a1 clause -> 'a1 cnf ->
- 'a1 cnf **)
+(** val xor_clause_cnf :
+ ('a1 -> bool) -> ('a1 -> 'a1 -> 'a1 option) -> ('a1, 'a2) clause -> ('a1,
+ 'a2) cnf -> ('a1, 'a2) cnf **)
-let or_clause_cnf unsat deduce t0 f =
- fold_right (fun e acc ->
+let xor_clause_cnf unsat deduce t0 f =
+ fold_left (fun acc e ->
match or_clause unsat deduce t0 e with
| Some cl -> Cons (cl, acc)
- | None -> acc) Nil f
+ | None -> acc) f Nil
+
+(** val or_clause_cnf :
+ ('a1 -> bool) -> ('a1 -> 'a1 -> 'a1 option) -> ('a1, 'a2) clause -> ('a1,
+ 'a2) cnf -> ('a1, 'a2) cnf **)
+
+let or_clause_cnf unsat deduce t0 f =
+ match t0 with
+ | Nil -> f
+ | Cons (_, _) -> xor_clause_cnf unsat deduce t0 f
(** 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 **)
let rec or_cnf unsat deduce f f' =
match f with
- | Nil -> tt
+ | Nil -> cnf_tt
| Cons (e, rst) ->
- app (or_cnf unsat deduce rst f') (or_clause_cnf unsat deduce e f')
+ rev_append (or_cnf unsat deduce rst f') (or_clause_cnf unsat deduce e f')
-(** val and_cnf : 'a1 cnf -> 'a1 cnf -> 'a1 cnf **)
+(** val and_cnf : ('a1, 'a2) cnf -> ('a1, 'a2) cnf -> ('a1, 'a2) cnf **)
-let and_cnf f1 f2 =
- app f1 f2
+let and_cnf =
+ rev_append
-(** val xcnf :
- ('a2 -> bool) -> ('a2 -> 'a2 -> 'a2 option) -> ('a1 -> 'a2 cnf) -> ('a1
- -> 'a2 cnf) -> bool -> 'a1 bFormula -> 'a2 cnf **)
-
-let rec xcnf unsat deduce normalise0 negate0 pol0 = function
-| TT -> if pol0 then tt else ff
-| FF -> if pol0 then ff else tt
-| X -> ff
-| A x -> if pol0 then normalise0 x else negate0 x
-| Cj (e1, e2) ->
+type ('term, 'annot, 'tX, 'aF) tFormula = ('term, 'tX, 'annot, 'aF) gFormula
+
+(** val is_cnf_tt : ('a1, 'a2) cnf -> bool **)
+
+let is_cnf_tt = function
+| Nil -> true
+| Cons (_, _) -> false
+
+(** val is_cnf_ff : ('a1, 'a2) cnf -> bool **)
+
+let is_cnf_ff = function
+| Nil -> false
+| Cons (c0, l) ->
+ (match c0 with
+ | Nil -> (match l with
+ | Nil -> true
+ | Cons (_, _) -> false)
+ | Cons (_, _) -> false)
+
+(** val and_cnf_opt : ('a1, 'a2) cnf -> ('a1, 'a2) cnf -> ('a1, 'a2) cnf **)
+
+let and_cnf_opt f1 f2 =
+ if if is_cnf_ff f1 then true else is_cnf_ff f2
+ then cnf_ff
+ else if is_cnf_tt f2 then f1 else and_cnf f1 f2
+
+(** val or_cnf_opt :
+ ('a1 -> bool) -> ('a1 -> 'a1 -> 'a1 option) -> ('a1, 'a2) cnf -> ('a1,
+ 'a2) cnf -> ('a1, 'a2) cnf **)
+
+let or_cnf_opt unsat deduce f1 f2 =
+ if if is_cnf_tt f1 then true else is_cnf_tt f2
+ then cnf_tt
+ else if is_cnf_ff f2 then f1 else or_cnf unsat deduce f1 f2
+
+(** 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 **)
+
+let mk_and unsat deduce rEC k pol0 f1 f2 =
if pol0
- then and_cnf (xcnf unsat deduce normalise0 negate0 pol0 e1)
- (xcnf unsat deduce normalise0 negate0 pol0 e2)
- else or_cnf unsat deduce (xcnf unsat deduce normalise0 negate0 pol0 e1)
- (xcnf unsat deduce normalise0 negate0 pol0 e2)
-| D (e1, e2) ->
+ then and_cnf_opt (rEC pol0 k f1) (rEC pol0 k f2)
+ else or_cnf_opt unsat deduce (rEC pol0 k f1) (rEC pol0 k f2)
+
+(** 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 **)
+
+let mk_or unsat deduce rEC k pol0 f1 f2 =
if pol0
- then or_cnf unsat deduce (xcnf unsat deduce normalise0 negate0 pol0 e1)
- (xcnf unsat deduce normalise0 negate0 pol0 e2)
- else and_cnf (xcnf unsat deduce normalise0 negate0 pol0 e1)
- (xcnf unsat deduce normalise0 negate0 pol0 e2)
-| N e -> xcnf unsat deduce normalise0 negate0 (negb pol0) e
-| I (e1, e2) ->
+ then or_cnf_opt unsat deduce (rEC pol0 k f1) (rEC pol0 k f2)
+ else and_cnf_opt (rEC pol0 k f1) (rEC pol0 k f2)
+
+(** 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 **)
+
+let mk_impl unsat deduce rEC k pol0 f1 f2 =
if pol0
- then or_cnf unsat deduce
- (xcnf unsat deduce normalise0 negate0 (negb pol0) e1)
- (xcnf unsat deduce normalise0 negate0 pol0 e2)
- else and_cnf (xcnf unsat deduce normalise0 negate0 (negb pol0) e1)
- (xcnf unsat deduce normalise0 negate0 pol0 e2)
+ then or_cnf_opt unsat deduce (rEC (negb pol0) k f1) (rEC pol0 k f2)
+ else and_cnf_opt (rEC (negb pol0) k f1) (rEC pol0 k f2)
+
+(** 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 **)
+
+let mk_iff unsat deduce rEC k pol0 f1 f2 =
+ or_cnf_opt unsat deduce
+ (and_cnf_opt (rEC (negb pol0) k f1) (rEC false k f2))
+ (and_cnf_opt (rEC pol0 k f1) (rEC true k f2))
+
+(** val is_bool : kind -> ('a1, 'a2, 'a3, 'a4) tFormula -> bool option **)
+
+let is_bool _ = function
+| TT _ -> Some true
+| FF _ -> Some false
+| _ -> None
+
+(** val xcnf :
+ ('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 **)
+
+let rec xcnf unsat deduce normalise0 negate0 pol0 _ = function
+| TT _ -> if pol0 then cnf_tt else cnf_ff
+| FF _ -> if pol0 then cnf_ff else cnf_tt
+| X (_, _) -> cnf_ff
+| A (_, x, t0) -> if pol0 then normalise0 x t0 else negate0 x t0
+| AND (k0, e1, e2) ->
+ mk_and unsat deduce (fun x x0 x1 ->
+ xcnf unsat deduce normalise0 negate0 x x0 x1) k0 pol0 e1 e2
+| OR (k0, e1, e2) ->
+ mk_or unsat deduce (fun x x0 x1 ->
+ xcnf unsat deduce normalise0 negate0 x x0 x1) k0 pol0 e1 e2
+| NOT (k0, e) -> xcnf unsat deduce normalise0 negate0 (negb pol0) k0 e
+| IMPL (k0, e1, _, e2) ->
+ mk_impl unsat deduce (fun x x0 x1 ->
+ xcnf unsat deduce normalise0 negate0 x x0 x1) k0 pol0 e1 e2
+| IFF (k0, e1, e2) ->
+ (match is_bool k0 e2 with
+ | Some isb ->
+ xcnf unsat deduce normalise0 negate0 (if isb then pol0 else negb pol0)
+ k0 e1
+ | None ->
+ mk_iff unsat deduce (fun x x0 x1 ->
+ xcnf unsat deduce normalise0 negate0 x x0 x1) k0 pol0 e1 e2)
+| EQ (e1, e2) ->
+ (match is_bool IsBool e2 with
+ | Some isb ->
+ xcnf unsat deduce normalise0 negate0 (if isb then pol0 else negb pol0)
+ IsBool e1
+ | None ->
+ mk_iff unsat deduce (fun x x0 x1 ->
+ xcnf unsat deduce normalise0 negate0 x x0 x1) IsBool pol0 e1 e2)
(** val cnf_checker :
- ('a1 list -> 'a2 -> bool) -> 'a1 cnf -> 'a2 list -> bool **)
+ (('a1 * 'a2) list -> 'a3 -> bool) -> ('a1, 'a2) cnf -> 'a3 list -> bool **)
let rec cnf_checker checker0 f l =
match f with
@@ -5268,12 +1396,12 @@ let rec cnf_checker checker0 f l =
if checker0 e c then cnf_checker checker0 f0 l0 else false)
(** 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 **)
let tauto_checker unsat deduce normalise0 negate0 checker0 f w =
- cnf_checker checker0 (xcnf unsat deduce normalise0 negate0 true f) w
+ cnf_checker checker0 (xcnf unsat deduce normalise0 negate0 true IsProp f) w
(** val cneqb : ('a1 -> 'a1 -> bool) -> 'a1 -> 'a1 -> bool **)
@@ -5294,7 +1422,7 @@ type op1 =
| Strict
| NonStrict
-type 'c nFormula = 'c polC*op1
+type 'c nFormula = 'c polC * op1
(** val opMult : op1 -> op1 -> op1 option **)
@@ -5303,32 +1431,29 @@ let opMult o o' =
| Equal -> Some Equal
| NonEqual ->
(match o' with
- | Strict -> None
- | NonStrict -> None
- | x -> Some x)
- | Strict ->
- (match o' with
- | NonEqual -> None
- | _ -> Some o')
+ | Equal -> Some Equal
+ | NonEqual -> Some NonEqual
+ | _ -> None)
+ | Strict -> (match o' with
+ | NonEqual -> None
+ | _ -> Some o')
| NonStrict ->
(match o' with
+ | Equal -> Some Equal
| NonEqual -> None
- | Strict -> Some NonStrict
- | x -> Some x)
+ | _ -> Some NonStrict)
(** val opAdd : op1 -> op1 -> op1 option **)
let opAdd o o' =
match o with
| Equal -> Some o'
- | NonEqual ->
- (match o' with
- | Equal -> Some NonEqual
- | _ -> None)
- | Strict ->
- (match o' with
- | NonEqual -> None
- | _ -> Some Strict)
+ | NonEqual -> (match o' with
+ | Equal -> Some NonEqual
+ | _ -> None)
+ | Strict -> (match o' with
+ | NonEqual -> None
+ | _ -> Some Strict)
| NonStrict ->
(match o' with
| Equal -> Some NonStrict
@@ -5355,10 +1480,9 @@ let map_option f = function
let map_option2 f o o' =
match o with
- | Some x ->
- (match o' with
- | Some x' -> f x x'
- | None -> None)
+ | Some x -> (match o' with
+ | Some x' -> f x x'
+ | None -> None)
| None -> None
(** val pexpr_times_nformula :
@@ -5366,9 +1490,9 @@ let map_option2 f o o' =
-> bool) -> 'a1 polC -> 'a1 nFormula -> 'a1 nFormula option **)
let pexpr_times_nformula cO cI cplus ctimes ceqb e = function
-| ef,o ->
+| (ef, o) ->
(match o with
- | Equal -> Some ((pmul cO cI cplus ctimes ceqb e ef),Equal)
+ | Equal -> Some ((pmul cO cI cplus ctimes ceqb e ef), Equal)
| _ -> None)
(** val nformula_times_nformula :
@@ -5376,9 +1500,9 @@ let pexpr_times_nformula cO cI cplus ctimes ceqb e = function
-> bool) -> 'a1 nFormula -> 'a1 nFormula -> 'a1 nFormula option **)
let nformula_times_nformula cO cI cplus ctimes ceqb f1 f2 =
- let e1,o1 = f1 in
- let e2,o2 = f2 in
- map_option (fun x -> Some ((pmul cO cI cplus ctimes ceqb e1 e2),x))
+ let (e1, o1) = f1 in
+ let (e2, o2) = f2 in
+ map_option (fun x -> Some ((pmul cO cI cplus ctimes ceqb e1 e2), x))
(opMult o1 o2)
(** val nformula_plus_nformula :
@@ -5386,9 +1510,9 @@ let nformula_times_nformula cO cI cplus ctimes ceqb f1 f2 =
nFormula -> 'a1 nFormula option **)
let nformula_plus_nformula cO cplus ceqb f1 f2 =
- let e1,o1 = f1 in
- let e2,o2 = f2 in
- map_option (fun x -> Some ((padd cO cplus ceqb e1 e2),x)) (opAdd o1 o2)
+ let (e1, o1) = f1 in
+ let (e2, o2) = f2 in
+ map_option (fun x -> Some ((padd cO cplus ceqb e1 e2), x)) (opAdd o1 o2)
(** val eval_Psatz :
'a1 -> 'a1 -> ('a1 -> 'a1 -> 'a1) -> ('a1 -> 'a1 -> 'a1) -> ('a1 -> 'a1
@@ -5396,8 +1520,8 @@ let nformula_plus_nformula cO cplus ceqb f1 f2 =
nFormula option **)
let rec eval_Psatz cO cI cplus ctimes ceqb cleb l = function
-| PsatzIn n0 -> Some (nth n0 l ((Pc cO),Equal))
-| PsatzSquare e0 -> Some ((psquare cO cI cplus ctimes ceqb e0),NonStrict)
+| PsatzIn n0 -> Some (nth n0 l ((Pc cO), Equal))
+| PsatzSquare e0 -> Some ((psquare cO cI cplus ctimes ceqb e0), NonStrict)
| PsatzMulC (re, e0) ->
map_option (pexpr_times_nformula cO cI cplus ctimes ceqb re)
(eval_Psatz cO cI cplus ctimes ceqb cleb l e0)
@@ -5409,15 +1533,15 @@ let rec eval_Psatz cO cI cplus ctimes ceqb cleb l = function
map_option2 (nformula_plus_nformula cO cplus ceqb)
(eval_Psatz cO cI cplus ctimes ceqb cleb l f1)
(eval_Psatz cO cI cplus ctimes ceqb cleb l f2)
-| PsatzC c -> if cltb ceqb cleb cO c then Some ((Pc c),Strict) else None
-| PsatzZ -> Some ((Pc cO),Equal)
+| PsatzC c -> if cltb ceqb cleb cO c then Some ((Pc c), Strict) else None
+| PsatzZ -> Some ((Pc cO), Equal)
(** val check_inconsistent :
'a1 -> ('a1 -> 'a1 -> bool) -> ('a1 -> 'a1 -> bool) -> 'a1 nFormula ->
bool **)
let check_inconsistent cO ceqb cleb = function
-| e,op ->
+| (e, op) ->
(match e with
| Pc c ->
(match op with
@@ -5441,22 +1565,22 @@ type 't formula = { flhs : 't pExpr; fop : op2; frhs : 't pExpr }
'a1 -> 'a1 -> ('a1 -> 'a1 -> 'a1) -> ('a1 -> 'a1 -> 'a1) -> ('a1 -> 'a1
-> 'a1) -> ('a1 -> 'a1) -> ('a1 -> 'a1 -> bool) -> 'a1 pExpr -> 'a1 pol **)
-let norm cO cI cplus ctimes cminus copp ceqb =
- norm_aux cO cI cplus ctimes cminus copp ceqb
+let norm =
+ norm_aux
(** val psub0 :
'a1 -> ('a1 -> 'a1 -> 'a1) -> ('a1 -> 'a1 -> 'a1) -> ('a1 -> 'a1) -> ('a1
-> 'a1 -> bool) -> 'a1 pol -> 'a1 pol -> 'a1 pol **)
-let psub0 cO cplus cminus copp ceqb =
- psub cO cplus cminus copp ceqb
+let psub0 =
+ psub
(** val padd0 :
'a1 -> ('a1 -> 'a1 -> 'a1) -> ('a1 -> 'a1 -> bool) -> 'a1 pol -> 'a1 pol
-> 'a1 pol **)
-let padd0 cO cplus ceqb =
- padd cO cplus ceqb
+let padd0 =
+ padd
type zWitness = z psatz
@@ -5470,67 +1594,81 @@ let psub1 =
let padd1 =
padd0 Z0 Z.add zeq_bool
-(** val norm0 : z pExpr -> z pol **)
+(** val normZ : z pExpr -> z pol **)
-let norm0 =
+let normZ =
norm Z0 (Zpos XH) Z.add Z.mul Z.sub Z.opp zeq_bool
-(** val xnormalise : z formula -> z nFormula list **)
+(** val zunsat : z nFormula -> bool **)
-let xnormalise t0 =
- let { flhs = lhs; fop = o; frhs = rhs } = t0 in
- let lhs0 = norm0 lhs in
- let rhs0 = norm0 rhs in
- (match o with
- | OpEq ->
- Cons (((psub1 lhs0 (padd1 rhs0 (Pc (Zpos XH)))),NonStrict), (Cons
- (((psub1 rhs0 (padd1 lhs0 (Pc (Zpos XH)))),NonStrict), Nil)))
- | OpNEq -> Cons (((psub1 lhs0 rhs0),Equal), Nil)
- | OpLe -> Cons (((psub1 lhs0 (padd1 rhs0 (Pc (Zpos XH)))),NonStrict), Nil)
- | OpGe -> Cons (((psub1 rhs0 (padd1 lhs0 (Pc (Zpos XH)))),NonStrict), Nil)
- | OpLt -> Cons (((psub1 lhs0 rhs0),NonStrict), Nil)
- | OpGt -> Cons (((psub1 rhs0 lhs0),NonStrict), Nil))
+let zunsat =
+ check_inconsistent Z0 zeq_bool Z.leb
-(** val normalise : z formula -> z nFormula cnf **)
+(** val zdeduce : z nFormula -> z nFormula -> z nFormula option **)
-let normalise t0 =
- map (fun x -> Cons (x, Nil)) (xnormalise t0)
+let zdeduce =
+ nformula_plus_nformula Z0 Z.add zeq_bool
-(** val xnegate : z formula -> z nFormula list **)
+(** val xnnormalise : z formula -> z nFormula **)
-let xnegate t0 =
+let xnnormalise t0 =
let { flhs = lhs; fop = o; frhs = rhs } = t0 in
- let lhs0 = norm0 lhs in
- let rhs0 = norm0 rhs in
+ let lhs0 = normZ lhs in
+ let rhs0 = normZ rhs in
(match o with
- | OpEq -> Cons (((psub1 lhs0 rhs0),Equal), Nil)
- | OpNEq ->
- Cons (((psub1 lhs0 (padd1 rhs0 (Pc (Zpos XH)))),NonStrict), (Cons
- (((psub1 rhs0 (padd1 lhs0 (Pc (Zpos XH)))),NonStrict), Nil)))
- | OpLe -> Cons (((psub1 rhs0 lhs0),NonStrict), Nil)
- | OpGe -> Cons (((psub1 lhs0 rhs0),NonStrict), Nil)
- | OpLt -> Cons (((psub1 rhs0 (padd1 lhs0 (Pc (Zpos XH)))),NonStrict), Nil)
- | OpGt -> Cons (((psub1 lhs0 (padd1 rhs0 (Pc (Zpos XH)))),NonStrict), Nil))
+ | OpEq -> ((psub1 rhs0 lhs0), Equal)
+ | OpNEq -> ((psub1 rhs0 lhs0), NonEqual)
+ | OpLe -> ((psub1 rhs0 lhs0), NonStrict)
+ | OpGe -> ((psub1 lhs0 rhs0), NonStrict)
+ | OpLt -> ((psub1 rhs0 lhs0), Strict)
+ | OpGt -> ((psub1 lhs0 rhs0), Strict))
-(** val negate : z formula -> z nFormula cnf **)
+(** val xnormalise : z nFormula -> z nFormula list **)
-let negate t0 =
- map (fun x -> Cons (x, Nil)) (xnegate t0)
+let xnormalise = function
+| (e, o) ->
+ (match o with
+ | Equal ->
+ Cons (((psub1 e (Pc (Zpos XH))), NonStrict), (Cons
+ (((psub1 (Pc (Zneg XH)) e), NonStrict), Nil)))
+ | NonEqual -> Cons ((e, Equal), Nil)
+ | Strict -> Cons (((psub1 (Pc Z0) e), NonStrict), Nil)
+ | NonStrict -> Cons (((psub1 (Pc (Zneg XH)) e), NonStrict), Nil))
-(** val zunsat : z nFormula -> bool **)
+(** val cnf_of_list :
+ 'a1 -> z nFormula list -> (z nFormula * 'a1) list list **)
-let zunsat =
- check_inconsistent Z0 zeq_bool Z.leb
+let cnf_of_list tg l =
+ fold_right (fun x acc ->
+ if zunsat x then acc else Cons ((Cons ((x, tg), Nil)), acc)) cnf_tt l
-(** val zdeduce : z nFormula -> z nFormula -> z nFormula option **)
+(** val normalise : z formula -> 'a1 -> (z nFormula, 'a1) cnf **)
-let zdeduce =
- nformula_plus_nformula Z0 Z.add zeq_bool
+let normalise t0 tg =
+ let f = xnnormalise t0 in
+ if zunsat f then cnf_ff else cnf_of_list tg (xnormalise f)
+
+(** val xnegate : z nFormula -> z nFormula list **)
+
+let xnegate = function
+| (e, o) ->
+ (match o with
+ | NonEqual ->
+ Cons (((psub1 e (Pc (Zpos XH))), NonStrict), (Cons
+ (((psub1 (Pc (Zneg XH)) e), NonStrict), Nil)))
+ | Strict -> Cons (((psub1 e (Pc (Zpos XH))), NonStrict), Nil)
+ | x -> Cons ((e, x), Nil))
+
+(** val negate : z formula -> 'a1 -> (z nFormula, 'a1) cnf **)
+
+let negate t0 tg =
+ let f = xnnormalise t0 in
+ if zunsat f then cnf_tt else cnf_of_list tg (xnegate f)
(** val ceiling : z -> z -> z **)
let ceiling a b =
- let q,r = Z.div_eucl a b in
+ let (q, r) = Z.div_eucl a b in
(match r with
| Z0 -> q
| _ -> Z.add q (Zpos XH))
@@ -5540,20 +1678,21 @@ 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 **)
let zgcdM x y =
Z.max (Z.gcd x y) (Zpos XH)
-(** val zgcd_pol : z polC -> z*z **)
+(** val zgcd_pol : z polC -> z * z **)
let rec zgcd_pol = function
-| Pc c -> Z0,c
-| Pinj (p2, p3) -> zgcd_pol p3
-| PX (p2, p3, q) ->
- let g1,c1 = zgcd_pol p2 in
- let g2,c2 = zgcd_pol q in (zgcdM (zgcdM g1 c1) g2),c2
+| Pc c -> (Z0, c)
+| Pinj (_, p2) -> zgcd_pol p2
+| PX (p2, _, q) ->
+ let (g1, c1) = zgcd_pol p2 in
+ let (g2, c2) = zgcd_pol q in ((zgcdM (zgcdM g1 c1) g2), c2)
(** val zdiv_pol : z polC -> z -> z polC **)
@@ -5563,44 +1702,43 @@ let rec zdiv_pol p x =
| Pinj (j, p2) -> Pinj (j, (zdiv_pol p2 x))
| PX (p2, j, q) -> PX ((zdiv_pol p2 x), j, (zdiv_pol q x))
-(** val makeCuttingPlane : z polC -> z polC*z **)
+(** val makeCuttingPlane : z polC -> z polC * z **)
let makeCuttingPlane p =
- let g,c = zgcd_pol p in
+ let (g, c) = zgcd_pol p in
if Z.gtb g Z0
- then (zdiv_pol (psubC Z.sub p c) g),(Z.opp (ceiling (Z.opp c) g))
- else p,Z0
+ then ((zdiv_pol (psubC Z.sub p c) g), (Z.opp (ceiling (Z.opp c) g)))
+ else (p, Z0)
-(** val genCuttingPlane : z nFormula -> ((z polC*z)*op1) option **)
+(** val genCuttingPlane : z nFormula -> ((z polC * z) * op1) option **)
let genCuttingPlane = function
-| e,op ->
+| (e, op) ->
(match op with
| Equal ->
- let g,c = zgcd_pol e in
+ let (g, c) = zgcd_pol e in
if if Z.gtb g Z0
then if negb (zeq_bool c Z0)
then negb (zeq_bool (Z.gcd g c) g)
else false
else false
then None
- else Some ((makeCuttingPlane e),Equal)
- | NonEqual -> Some ((e,Z0),op)
- | Strict -> Some ((makeCuttingPlane (psubC Z.sub e (Zpos XH))),NonStrict)
- | NonStrict -> Some ((makeCuttingPlane e),NonStrict))
+ else Some ((makeCuttingPlane e), Equal)
+ | NonEqual -> Some ((e, Z0), op)
+ | Strict -> Some ((makeCuttingPlane (psubC Z.sub e (Zpos XH))), NonStrict)
+ | NonStrict -> Some ((makeCuttingPlane e), NonStrict))
-(** val nformula_of_cutting_plane : ((z polC*z)*op1) -> z nFormula **)
+(** val nformula_of_cutting_plane : ((z polC * z) * op1) -> z nFormula **)
let nformula_of_cutting_plane = function
-| e_z,o -> let e,z0 = e_z in (padd1 e (Pc z0)),o
+| (e_z, o) -> let (e, z0) = e_z in ((padd1 e (Pc z0)), o)
(** val is_pol_Z0 : z polC -> bool **)
let is_pol_Z0 = function
-| Pc z0 ->
- (match z0 with
- | Z0 -> true
- | _ -> false)
+| Pc z0 -> (match z0 with
+ | Z0 -> true
+ | _ -> false)
| _ -> false
(** val eval_Psatz0 : z nFormula list -> zWitness -> z nFormula option **)
@@ -5615,6 +1753,28 @@ let valid_cut_sign = function
| NonStrict -> true
| _ -> false
+(** val bound_var : positive -> z formula **)
+
+let bound_var v =
+ { flhs = (PEX v); fop = OpGe; frhs = (PEc Z0) }
+
+(** val mk_eq_pos : positive -> positive -> positive -> z formula **)
+
+let mk_eq_pos x y t0 =
+ { flhs = (PEX x); fop = OpEq; frhs = (PEsub ((PEX y), (PEX t0))) }
+
+(** val max_var : positive -> z pol -> positive **)
+
+let rec max_var jmp = function
+| Pc _ -> jmp
+| Pinj (j, p2) -> max_var (Coq_Pos.add j jmp) p2
+| PX (p2, _, q) -> Coq_Pos.max (max_var jmp p2) (max_var (Coq_Pos.succ jmp) q)
+
+(** val max_var_nformulae : z nFormula list -> positive **)
+
+let max_var_nformulae l =
+ fold_left (fun acc f -> Coq_Pos.max acc (max_var XH (fst f))) l XH
+
(** val zChecker : z nFormula list -> zArithProof -> bool **)
let rec zChecker l = function
@@ -5637,12 +1797,12 @@ let rec zChecker l = function
| Some f2 ->
(match genCuttingPlane f1 with
| Some p ->
- let p2,op3 = p in
- let e1,z1 = p2 in
+ let (p2, op3) = p in
+ let (e1, z1) = p2 in
(match genCuttingPlane f2 with
| Some p3 ->
- let p4,op4 = p3 in
- let e2,z2 = p4 in
+ let (p4, op4) = p3 in
+ let (e2, z2) = p4 in
if if if valid_cut_sign op3 then valid_cut_sign op4 else false
then is_pol_Z0 (padd1 e1 e2)
else false
@@ -5650,7 +1810,7 @@ let rec zChecker l = function
match pfs with
| Nil -> Z.gtb lb ub
| Cons (pf1, rsr) ->
- if zChecker (Cons (((psub1 e1 (Pc lb)),Equal), l)) pf1
+ if zChecker (Cons (((psub1 e1 (Pc lb)), Equal), l)) pf1
then label rsr (Z.add lb (Zpos XH)) ub
else false
in label pf0 (Z.opp z1) z2
@@ -5659,20 +1819,2880 @@ let rec zChecker l = function
| None -> true)
| None -> false)
| None -> false)
+| ExProof (x, prf) ->
+ let fr = max_var_nformulae l in
+ if Coq_Pos.leb x fr
+ then let z0 = Coq_Pos.succ fr in
+ let t0 = Coq_Pos.succ z0 in
+ let nfx = xnnormalise (mk_eq_pos x z0 t0) in
+ let posz = xnnormalise (bound_var z0) in
+ let post = xnnormalise (bound_var t0) in
+ zChecker (Cons (nfx, (Cons (posz, (Cons (post, l)))))) prf
+ else false
(** val zTautoChecker : z formula bFormula -> zArithProof list -> bool **)
let zTautoChecker f w =
- tauto_checker zunsat zdeduce normalise negate zChecker f w
+ tauto_checker zunsat zdeduce normalise negate (fun cl ->
+ zChecker (map fst cl)) f w
+
+(** val size : nat **)
+
+let size =
+ S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S
+ (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S (S
+ (S (S (S (S (S (S (S (S (S (S (S (S (S (S
+ O))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
+
+(** val lsl0 : Uint63.t -> Uint63.t -> Uint63.t **)
+
+let lsl0 = Uint63.l_sl
+
+(** val lsr0 : Uint63.t -> Uint63.t -> Uint63.t **)
+
+let lsr0 = Uint63.l_sr
+
+(** val land0 : Uint63.t -> Uint63.t -> Uint63.t **)
+
+let land0 = Uint63.l_and
+
+(** val lxor0 : Uint63.t -> Uint63.t -> Uint63.t **)
+
+let lxor0 = Uint63.l_xor
+
+(** val add0 : Uint63.t -> Uint63.t -> Uint63.t **)
+
+let add0 = Uint63.add
+
+(** val sub0 : Uint63.t -> Uint63.t -> Uint63.t **)
+
+let sub0 = Uint63.sub
+
+(** val eqb0 : Uint63.t -> Uint63.t -> bool **)
+
+let eqb0 = Uint63.equal
+
+(** val ltb0 : Uint63.t -> Uint63.t -> bool **)
+
+let ltb0 = Uint63.lt
+
+(** val leb0 : Uint63.t -> Uint63.t -> bool **)
+
+let leb0 = Uint63.le
+
+(** val digits : Uint63.t **)
+
+let digits =
+ (Uint63.of_int (63))
+
+(** val is_zero : Uint63.t -> bool **)
+
+let is_zero i =
+ eqb0 i (Uint63.of_int (0))
+
+(** val is_even : Uint63.t -> bool **)
+
+let is_even i =
+ is_zero (land0 i (Uint63.of_int (1)))
+
+(** val bit : Uint63.t -> Uint63.t -> bool **)
+
+let bit i n0 =
+ negb (is_zero (lsl0 (lsr0 i n0) (sub0 digits (Uint63.of_int (1)))))
+
+(** val compare0 : Uint63.t -> Uint63.t -> int **)
+
+let compare0 = Uint63.compare
+
+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) ->
+ struct
+ module TO =
+ struct
+ type t = O.t
+ end
+
+ module IsTO =
+ struct
+ end
+
+ module OrderTac = MakeOrderTac(TO)(IsTO)
+
+ (** val eq_dec : O.t -> O.t -> sumbool **)
+
+ let eq_dec =
+ O.eq_dec
+
+ (** val lt_dec : O.t -> O.t -> sumbool **)
+
+ let lt_dec x y =
+ match O.compare x y with
+ | LT -> Left
+ | _ -> Right
+
+ (** val eqb : O.t -> O.t -> bool **)
+
+ let eqb x y =
+ match eq_dec x y with
+ | Left -> true
+ | Right -> false
+ end
+
+module KeyOrderedType =
+ functor (O:OrderedType) ->
+ struct
+ module MO = OrderedTypeFacts(O)
+ end
+
+module Raw =
+ functor (X:OrderedType) ->
+ struct
+ module MX = OrderedTypeFacts(X)
+
+ module PX = KeyOrderedType(X)
+
+ type key = X.t
+
+ type 'elt t = (X.t * 'elt) list
+
+ (** val empty : 'a1 t **)
+
+ let empty =
+ Nil
+
+ (** val is_empty : 'a1 t -> bool **)
+
+ let is_empty = function
+ | Nil -> true
+ | Cons (_, _) -> false
+
+ (** val mem : key -> 'a1 t -> bool **)
+
+ let rec mem k = function
+ | Nil -> false
+ | Cons (p, l) ->
+ let (k', _) = p in
+ (match X.compare k k' with
+ | LT -> false
+ | EQ0 -> true
+ | GT -> mem k l)
+
+ 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 **)
+
+ let rec coq_R_mem_rect k f f0 f1 f2 _ _ = function
+ | R_mem_0 s -> f s __
+ | R_mem_1 (s, k', _x, l) -> f0 s k' _x l __ __ __
+ | R_mem_2 (s, k', _x, l) -> f1 s k' _x l __ __ __
+ | R_mem_3 (s, k', _x, l, _res, r0) ->
+ f2 s k' _x l __ __ __ _res r0 (coq_R_mem_rect k f f0 f1 f2 l _res r0)
+
+ (** 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 **)
+
+ let rec coq_R_mem_rec k f f0 f1 f2 _ _ = function
+ | R_mem_0 s -> f s __
+ | R_mem_1 (s, k', _x, l) -> f0 s k' _x l __ __ __
+ | R_mem_2 (s, k', _x, l) -> f1 s k' _x l __ __ __
+ | R_mem_3 (s, k', _x, l, _res, r0) ->
+ f2 s k' _x l __ __ __ _res r0 (coq_R_mem_rec k f f0 f1 f2 l _res r0)
+
+ (** 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 **)
+
+ let rec mem_rect k f2 f1 f0 f s =
+ let f3 = f2 s in
+ let f4 = f1 s in
+ let f5 = f0 s in
+ let f6 = f s in
+ (match s with
+ | Nil -> f3 __
+ | Cons (p, l) ->
+ let (t0, e) = p in
+ let f7 = f6 t0 e l __ in
+ let f8 = fun _ _ -> let hrec = mem_rect k f2 f1 f0 f l in f7 __ __ hrec
+ in
+ let f9 = f5 t0 e l __ in
+ let f10 = f4 t0 e l __ in
+ (match X.compare k t0 with
+ | LT -> f10 __ __
+ | EQ0 -> f9 __ __
+ | GT -> f8 __ __))
+
+ (** 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 **)
+
+ let mem_rec =
+ mem_rect
+
+ (** val coq_R_mem_correct : key -> 'a1 t -> bool -> 'a1 coq_R_mem **)
+
+ let coq_R_mem_correct k s _res =
+ Obj.magic mem_rect k (fun y _ _ _ -> R_mem_0 y)
+ (fun y y0 y1 y2 _ _ _ _ _ -> R_mem_1 (y, y0, y1, y2))
+ (fun y y0 y1 y2 _ _ _ _ _ -> R_mem_2 (y, y0, y1, y2))
+ (fun y y0 y1 y2 _ _ _ y6 _ _ -> R_mem_3 (y, y0, y1, y2, (mem k y2),
+ (y6 (mem k y2) __))) s _res __
+
+ (** val find : key -> 'a1 t -> 'a1 option **)
+
+ let rec find k = function
+ | Nil -> None
+ | Cons (p, s') ->
+ let (k', x) = p in
+ (match X.compare k k' with
+ | LT -> None
+ | EQ0 -> Some x
+ | GT -> find k s')
+
+ 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 **)
+
+ let rec coq_R_find_rect k f f0 f1 f2 _ _ = function
+ | R_find_0 s -> f s __
+ | R_find_1 (s, k', x, s') -> f0 s k' x s' __ __ __
+ | R_find_2 (s, k', x, s') -> f1 s k' x s' __ __ __
+ | R_find_3 (s, k', x, s', _res, r0) ->
+ f2 s k' x s' __ __ __ _res r0 (coq_R_find_rect k f f0 f1 f2 s' _res r0)
+
+ (** 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 **)
+
+ let rec coq_R_find_rec k f f0 f1 f2 _ _ = function
+ | R_find_0 s -> f s __
+ | R_find_1 (s, k', x, s') -> f0 s k' x s' __ __ __
+ | R_find_2 (s, k', x, s') -> f1 s k' x s' __ __ __
+ | R_find_3 (s, k', x, s', _res, r0) ->
+ f2 s k' x s' __ __ __ _res r0 (coq_R_find_rec k f f0 f1 f2 s' _res r0)
+
+ (** 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 **)
+
+ let rec find_rect k f2 f1 f0 f s =
+ let f3 = f2 s in
+ let f4 = f1 s in
+ let f5 = f0 s in
+ let f6 = f s in
+ (match s with
+ | Nil -> f3 __
+ | Cons (p, l) ->
+ let (t0, e) = p in
+ let f7 = f6 t0 e l __ in
+ let f8 = fun _ _ ->
+ let hrec = find_rect k f2 f1 f0 f l in f7 __ __ hrec
+ in
+ let f9 = f5 t0 e l __ in
+ let f10 = f4 t0 e l __ in
+ (match X.compare k t0 with
+ | LT -> f10 __ __
+ | EQ0 -> f9 __ __
+ | GT -> f8 __ __))
+
+ (** 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 **)
+
+ let find_rec =
+ find_rect
+
+ (** val coq_R_find_correct :
+ key -> 'a1 t -> 'a1 option -> 'a1 coq_R_find **)
+
+ let coq_R_find_correct k s _res =
+ Obj.magic find_rect k (fun y _ _ _ -> R_find_0 y)
+ (fun y y0 y1 y2 _ _ _ _ _ -> R_find_1 (y, y0, y1, y2))
+ (fun y y0 y1 y2 _ _ _ _ _ -> R_find_2 (y, y0, y1, y2))
+ (fun y y0 y1 y2 _ _ _ y6 _ _ -> R_find_3 (y, y0, y1, y2, (find k y2),
+ (y6 (find k y2) __))) s _res __
+
+ (** val add : key -> 'a1 -> 'a1 t -> 'a1 t **)
+
+ let rec add k x s = match s with
+ | Nil -> Cons ((k, x), Nil)
+ | Cons (p, l) ->
+ let (k', y) = p in
+ (match X.compare k k' with
+ | LT -> Cons ((k, x), s)
+ | EQ0 -> Cons ((k, x), l)
+ | GT -> Cons ((k', y), (add k x l)))
+
+ 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 **)
+
+ let rec coq_R_add_rect k x f f0 f1 f2 _ _ = function
+ | R_add_0 s -> f s __
+ | R_add_1 (s, k', y, l) -> f0 s k' y l __ __ __
+ | R_add_2 (s, k', y, l) -> f1 s k' y l __ __ __
+ | R_add_3 (s, k', y, l, _res, r0) ->
+ f2 s k' y l __ __ __ _res r0 (coq_R_add_rect k x f f0 f1 f2 l _res r0)
+
+ (** 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 **)
+
+ let rec coq_R_add_rec k x f f0 f1 f2 _ _ = function
+ | R_add_0 s -> f s __
+ | R_add_1 (s, k', y, l) -> f0 s k' y l __ __ __
+ | R_add_2 (s, k', y, l) -> f1 s k' y l __ __ __
+ | R_add_3 (s, k', y, l, _res, r0) ->
+ f2 s k' y l __ __ __ _res r0 (coq_R_add_rec k x f f0 f1 f2 l _res r0)
+
+ (** 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 **)
+
+ let rec add_rect k x f2 f1 f0 f s =
+ let f3 = f2 s in
+ let f4 = f1 s in
+ let f5 = f0 s in
+ let f6 = f s in
+ (match s with
+ | Nil -> f3 __
+ | Cons (p, l) ->
+ let (t0, e) = p in
+ let f7 = f6 t0 e l __ in
+ let f8 = fun _ _ ->
+ let hrec = add_rect k x f2 f1 f0 f l in f7 __ __ hrec
+ in
+ let f9 = f5 t0 e l __ in
+ let f10 = f4 t0 e l __ in
+ (match X.compare k t0 with
+ | LT -> f10 __ __
+ | EQ0 -> f9 __ __
+ | GT -> f8 __ __))
+
+ (** 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 **)
+
+ let add_rec =
+ add_rect
+
+ (** val coq_R_add_correct :
+ key -> 'a1 -> 'a1 t -> 'a1 t -> 'a1 coq_R_add **)
+
+ let coq_R_add_correct k x s _res =
+ add_rect k x (fun y _ _ _ -> R_add_0 y) (fun y y0 y1 y2 _ _ _ _ _ ->
+ R_add_1 (y, y0, y1, y2)) (fun y y0 y1 y2 _ _ _ _ _ -> R_add_2 (y, y0,
+ y1, y2)) (fun y y0 y1 y2 _ _ _ y6 _ _ -> R_add_3 (y, y0, y1, y2,
+ (add k x y2), (y6 (add k x y2) __))) s _res __
+
+ (** val remove : key -> 'a1 t -> 'a1 t **)
+
+ let rec remove k s = match s with
+ | Nil -> Nil
+ | Cons (p, l) ->
+ let (k', x) = p in
+ (match X.compare k k' with
+ | LT -> s
+ | EQ0 -> l
+ | GT -> Cons ((k', x), (remove k l)))
+
+ 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 **)
+
+ let rec coq_R_remove_rect k f f0 f1 f2 _ _ = function
+ | R_remove_0 s -> f s __
+ | R_remove_1 (s, k', x, l) -> f0 s k' x l __ __ __
+ | R_remove_2 (s, k', x, l) -> f1 s k' x l __ __ __
+ | R_remove_3 (s, k', x, l, _res, r0) ->
+ f2 s k' x l __ __ __ _res r0 (coq_R_remove_rect k f f0 f1 f2 l _res r0)
+
+ (** 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 **)
+
+ let rec coq_R_remove_rec k f f0 f1 f2 _ _ = function
+ | R_remove_0 s -> f s __
+ | R_remove_1 (s, k', x, l) -> f0 s k' x l __ __ __
+ | R_remove_2 (s, k', x, l) -> f1 s k' x l __ __ __
+ | R_remove_3 (s, k', x, l, _res, r0) ->
+ f2 s k' x l __ __ __ _res r0 (coq_R_remove_rec k f f0 f1 f2 l _res r0)
+
+ (** 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 **)
+
+ let rec remove_rect k f2 f1 f0 f s =
+ let f3 = f2 s in
+ let f4 = f1 s in
+ let f5 = f0 s in
+ let f6 = f s in
+ (match s with
+ | Nil -> f3 __
+ | Cons (p, l) ->
+ let (t0, e) = p in
+ let f7 = f6 t0 e l __ in
+ let f8 = fun _ _ ->
+ let hrec = remove_rect k f2 f1 f0 f l in f7 __ __ hrec
+ in
+ let f9 = f5 t0 e l __ in
+ let f10 = f4 t0 e l __ in
+ (match X.compare k t0 with
+ | LT -> f10 __ __
+ | EQ0 -> f9 __ __
+ | GT -> f8 __ __))
+
+ (** 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 **)
+
+ let remove_rec =
+ remove_rect
+
+ (** val coq_R_remove_correct : key -> 'a1 t -> 'a1 t -> 'a1 coq_R_remove **)
+
+ let coq_R_remove_correct k s _res =
+ Obj.magic remove_rect k (fun y _ _ _ -> R_remove_0 y)
+ (fun y y0 y1 y2 _ _ _ _ _ -> R_remove_1 (y, y0, y1, y2))
+ (fun y y0 y1 y2 _ _ _ _ _ -> R_remove_2 (y, y0, y1, y2))
+ (fun y y0 y1 y2 _ _ _ y6 _ _ -> R_remove_3 (y, y0, y1, y2,
+ (remove k y2), (y6 (remove k y2) __))) s _res __
+
+ (** val elements : 'a1 t -> 'a1 t **)
+
+ let elements m =
+ m
+
+ (** val fold : (key -> 'a1 -> 'a2 -> 'a2) -> 'a1 t -> 'a2 -> 'a2 **)
+
+ let rec fold f m acc =
+ match m with
+ | Nil -> acc
+ | Cons (p, m') -> let (k, e) = p in fold f m' (f k e acc)
+
+ 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 **)
+
+ let rec coq_R_fold_rect f f0 f1 _ _ _ = function
+ | R_fold_0 (m, acc) -> f0 m acc __
+ | R_fold_1 (m, acc, k, e, m', _res, r0) ->
+ f1 m acc k e m' __ _res r0
+ (coq_R_fold_rect f f0 f1 m' (f k e acc) _res r0)
+
+ (** 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 **)
+
+ let rec coq_R_fold_rec f f0 f1 _ _ _ = function
+ | R_fold_0 (m, acc) -> f0 m acc __
+ | R_fold_1 (m, acc, k, e, m', _res, r0) ->
+ f1 m acc k e m' __ _res r0 (coq_R_fold_rec f f0 f1 m' (f k e acc) _res r0)
+
+ (** 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 **)
+
+ let rec fold_rect f1 f0 f m acc =
+ let f2 = f0 m acc in
+ let f3 = f m acc in
+ (match m with
+ | Nil -> f2 __
+ | Cons (p, l) ->
+ let (t0, e) = p in
+ let f4 = f3 t0 e l __ in
+ let hrec = fold_rect f1 f0 f l (f1 t0 e acc) in f4 hrec)
+
+ (** 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 **)
+
+ let fold_rec =
+ fold_rect
+
+ (** val coq_R_fold_correct :
+ (key -> 'a1 -> 'a2 -> 'a2) -> 'a1 t -> 'a2 -> 'a2 -> ('a1, 'a2)
+ coq_R_fold **)
+
+ let coq_R_fold_correct f m acc _res =
+ fold_rect f (fun y y0 _ _ _ -> R_fold_0 (y, y0))
+ (fun y y0 y1 y2 y3 _ y5 _ _ -> R_fold_1 (y, y0, y1, y2, y3,
+ (fold f y3 (f y1 y2 y0)), (y5 (fold f y3 (f y1 y2 y0)) __))) m acc _res
+ __
+
+ (** val equal : ('a1 -> 'a1 -> bool) -> 'a1 t -> 'a1 t -> bool **)
+
+ let rec equal cmp m m' =
+ match m with
+ | Nil -> (match m' with
+ | Nil -> true
+ | Cons (_, _) -> false)
+ | Cons (p, l) ->
+ let (x, e) = p in
+ (match m' with
+ | Nil -> false
+ | Cons (p2, l') ->
+ let (x', e') = p2 in
+ (match X.compare x x' with
+ | EQ0 -> if cmp e e' then equal cmp l l' else false
+ | _ -> false))
+
+ 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 **)
+
+ let rec coq_R_equal_rect cmp f f0 f1 f2 _ _ _ = function
+ | R_equal_0 (m, m') -> f m m' __ __
+ | R_equal_1 (m, m', x, e, l, x', e', l', _res, r0) ->
+ f0 m m' x e l __ x' e' l' __ __ __ _res r0
+ (coq_R_equal_rect cmp f f0 f1 f2 l l' _res r0)
+ | R_equal_2 (m, m', x, e, l, x', e', l', _x) ->
+ f1 m m' x e l __ x' e' l' __ _x __ __
+ | R_equal_3 (m, m', _x, _x0) -> f2 m m' _x __ _x0 __ __
+
+ (** 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 **)
+
+ let rec coq_R_equal_rec cmp f f0 f1 f2 _ _ _ = function
+ | R_equal_0 (m, m') -> f m m' __ __
+ | R_equal_1 (m, m', x, e, l, x', e', l', _res, r0) ->
+ f0 m m' x e l __ x' e' l' __ __ __ _res r0
+ (coq_R_equal_rec cmp f f0 f1 f2 l l' _res r0)
+ | R_equal_2 (m, m', x, e, l, x', e', l', _x) ->
+ f1 m m' x e l __ x' e' l' __ _x __ __
+ | R_equal_3 (m, m', _x, _x0) -> f2 m m' _x __ _x0 __ __
+
+ (** 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 **)
+
+ let rec equal_rect cmp f2 f1 f0 f m m' =
+ let f3 = f2 m m' in
+ let f4 = f1 m m' in
+ let f5 = f0 m m' in
+ let f6 = f m m' in
+ let f7 = f6 m __ in
+ let f8 = f7 m' __ in
+ (match m with
+ | Nil ->
+ let f9 = f3 __ in (match m' with
+ | Nil -> f9 __
+ | Cons (_, _) -> f8 __)
+ | Cons (p, l) ->
+ let (t0, e) = p in
+ let f9 = f5 t0 e l __ in
+ let f10 = f4 t0 e l __ in
+ (match m' with
+ | Nil -> f8 __
+ | Cons (p2, l0) ->
+ let (t1, e0) = p2 in
+ let f11 = f9 t1 e0 l0 __ in
+ let f12 = let _x = X.compare t0 t1 in f11 _x __ in
+ let f13 = f10 t1 e0 l0 __ in
+ let f14 = fun _ _ ->
+ let hrec = equal_rect cmp f2 f1 f0 f l l0 in f13 __ __ hrec
+ in
+ (match X.compare t0 t1 with
+ | EQ0 -> f14 __ __
+ | _ -> f12 __)))
+
+ (** 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 **)
+
+ let equal_rec =
+ equal_rect
+
+ (** val coq_R_equal_correct :
+ ('a1 -> 'a1 -> bool) -> 'a1 t -> 'a1 t -> bool -> 'a1 coq_R_equal **)
+
+ let coq_R_equal_correct cmp m m' _res =
+ equal_rect cmp (fun y y0 _ _ _ _ -> R_equal_0 (y, y0))
+ (fun y y0 y1 y2 y3 _ y5 y6 y7 _ _ _ y11 _ _ -> R_equal_1 (y, y0, y1,
+ y2, y3, y5, y6, y7, (equal cmp y3 y7), (y11 (equal cmp y3 y7) __)))
+ (fun y y0 y1 y2 y3 _ y5 y6 y7 _ y9 _ _ _ _ -> R_equal_2 (y, y0, y1, y2,
+ y3, y5, y6, y7, y9)) (fun y y0 y1 _ y3 _ _ _ _ -> R_equal_3 (y, y0, y1,
+ y3)) m m' _res __
+
+ (** val map : ('a1 -> 'a2) -> 'a1 t -> 'a2 t **)
+
+ let rec map f = function
+ | Nil -> Nil
+ | Cons (p, m') -> let (k, e) = p in Cons ((k, (f e)), (map f m'))
+
+ (** val mapi : (key -> 'a1 -> 'a2) -> 'a1 t -> 'a2 t **)
+
+ let rec mapi f = function
+ | Nil -> Nil
+ | Cons (p, m') -> let (k, e) = p in Cons ((k, (f k e)), (mapi f m'))
+
+ (** val option_cons :
+ key -> 'a1 option -> (key * 'a1) list -> (key * 'a1) list **)
+
+ let option_cons k o l =
+ match o with
+ | Some e -> Cons ((k, e), l)
+ | None -> l
+
+ (** val map2_l :
+ ('a1 option -> 'a2 option -> 'a3 option) -> 'a1 t -> 'a3 t **)
+
+ let rec map2_l f = function
+ | Nil -> Nil
+ | Cons (p, l) ->
+ let (k, e) = p in option_cons k (f (Some e) None) (map2_l f l)
+
+ (** val map2_r :
+ ('a1 option -> 'a2 option -> 'a3 option) -> 'a2 t -> 'a3 t **)
+
+ let rec map2_r f = function
+ | Nil -> Nil
+ | Cons (p, l') ->
+ let (k, e') = p in option_cons k (f None (Some e')) (map2_r f l')
+
+ (** val map2 :
+ ('a1 option -> 'a2 option -> 'a3 option) -> 'a1 t -> 'a2 t -> 'a3 t **)
+
+ let rec map2 f m = match m with
+ | Nil -> map2_r f
+ | Cons (p, l) ->
+ let (k, e) = p in
+ let rec map2_aux m' = match m' with
+ | Nil -> map2_l f m
+ | Cons (p2, l') ->
+ let (k', e') = p2 in
+ (match X.compare k k' with
+ | LT -> option_cons k (f (Some e) None) (map2 f l m')
+ | EQ0 -> option_cons k (f (Some e) (Some e')) (map2 f l l')
+ | GT -> option_cons k' (f None (Some e')) (map2_aux l'))
+ in map2_aux
+
+ (** val combine : 'a1 t -> 'a2 t -> ('a1 option * 'a2 option) t **)
+
+ let rec combine m = match m with
+ | Nil -> map (fun e' -> (None, (Some e')))
+ | Cons (p, l) ->
+ let (k, e) = p in
+ let rec combine_aux m' = match m' with
+ | Nil -> map (fun e0 -> ((Some e0), None)) m
+ | Cons (p2, l') ->
+ let (k', e') = p2 in
+ (match X.compare k k' with
+ | LT -> Cons ((k, ((Some e), None)), (combine l m'))
+ | EQ0 -> Cons ((k, ((Some e), (Some e'))), (combine l l'))
+ | GT -> Cons ((k', (None, (Some e'))), (combine_aux l')))
+ in combine_aux
+
+ (** val fold_right_pair :
+ ('a1 -> 'a2 -> 'a3 -> 'a3) -> ('a1 * 'a2) list -> 'a3 -> 'a3 **)
+
+ let fold_right_pair f l i =
+ fold_right (fun p -> f (fst p) (snd p)) i l
+
+ (** val map2_alt :
+ ('a1 option -> 'a2 option -> 'a3 option) -> 'a1 t -> 'a2 t ->
+ (key * 'a3) list **)
+
+ let map2_alt f m m' =
+ let m0 = combine m m' in
+ let m1 = map (fun p -> f (fst p) (snd p)) m0 in
+ fold_right_pair option_cons m1 Nil
+
+ (** val at_least_one :
+ 'a1 option -> 'a2 option -> ('a1 option * 'a2 option) option **)
+
+ let at_least_one o o' =
+ match o with
+ | Some _ -> Some (o, o')
+ | None -> (match o' with
+ | Some _ -> Some (o, o')
+ | None -> None)
+
+ (** val at_least_one_then_f :
+ ('a1 option -> 'a2 option -> 'a3 option) -> 'a1 option -> 'a2 option ->
+ 'a3 option **)
+
+ let at_least_one_then_f f o o' =
+ match o with
+ | Some _ -> f o o'
+ | None -> (match o' with
+ | Some _ -> f o o'
+ | None -> None)
+ 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 =
+ struct
+ type t = z
+
+ (** val _0 : z **)
+
+ let _0 =
+ Z0
+
+ (** val _1 : z **)
+
+ let _1 =
+ Zpos XH
+
+ (** val _2 : z **)
+
+ let _2 =
+ Zpos (XO XH)
+
+ (** val _3 : z **)
+
+ let _3 =
+ Zpos (XI XH)
+
+ (** val add : z -> z -> z **)
+
+ let add =
+ Z.add
+
+ (** val opp : z -> z **)
+
+ let opp =
+ Z.opp
+
+ (** val sub : z -> z -> z **)
+
+ let sub =
+ Z.sub
+
+ (** val mul : z -> z -> z **)
+
+ let mul =
+ Z.mul
+
+ (** val max : z -> z -> z **)
+
+ let max =
+ Z.max
+
+ (** val eqb : z -> z -> bool **)
+
+ let eqb =
+ Z.eqb
+
+ (** val ltb : z -> z -> bool **)
+
+ let ltb =
+ Z.ltb
+
+ (** val leb : z -> z -> bool **)
+
+ let leb =
+ Z.leb
+
+ (** val eq_dec : z -> z -> sumbool **)
+
+ let eq_dec =
+ Z.eq_dec
+
+ (** val gt_le_dec : z -> z -> sumbool **)
+
+ let gt_le_dec i j =
+ let b = Z.ltb j i in if b then Left else Right
+
+ (** val ge_lt_dec : z -> z -> sumbool **)
+
+ let ge_lt_dec i j =
+ let b = Z.ltb i j in if b then Right else Left
+
+ (** val i2z : t -> z **)
+
+ let i2z n0 =
+ n0
+ end
+
+module Coq_Raw =
+ functor (I:Int) ->
+ functor (X:OrderedType) ->
+ struct
+ 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 **)
+
+ let rec tree_rect f f0 = function
+ | Leaf -> f
+ | Node (t1, k, y, t2, t3) ->
+ f0 t1 (tree_rect f f0 t1) k y t2 (tree_rect f f0 t2) t3
+
+ (** val tree_rec :
+ 'a2 -> ('a1 tree -> 'a2 -> key -> 'a1 -> 'a1 tree -> 'a2 -> I.t -> 'a2)
+ -> 'a1 tree -> 'a2 **)
+
+ let rec tree_rec f f0 = function
+ | Leaf -> f
+ | Node (t1, k, y, t2, t3) ->
+ f0 t1 (tree_rec f f0 t1) k y t2 (tree_rec f f0 t2) t3
+
+ (** val height : 'a1 tree -> I.t **)
+
+ let height = function
+ | Leaf -> I._0
+ | Node (_, _, _, _, h) -> h
+
+ (** val cardinal : 'a1 tree -> nat **)
+
+ let rec cardinal = function
+ | Leaf -> O
+ | Node (l, _, _, r, _) -> S (add (cardinal l) (cardinal r))
+
+ (** val empty : 'a1 tree **)
+
+ let empty =
+ Leaf
+
+ (** val is_empty : 'a1 tree -> bool **)
+
+ let is_empty = function
+ | Leaf -> true
+ | Node (_, _, _, _, _) -> false
+
+ (** val mem : X.t -> 'a1 tree -> bool **)
+
+ let rec mem x = function
+ | Leaf -> false
+ | Node (l, y, _, r, _) ->
+ (match X.compare x y with
+ | LT -> mem x l
+ | EQ0 -> true
+ | GT -> mem x r)
+
+ (** val find : X.t -> 'a1 tree -> 'a1 option **)
+
+ let rec find x = function
+ | Leaf -> None
+ | Node (l, y, d, r, _) ->
+ (match X.compare x y with
+ | LT -> find x l
+ | EQ0 -> Some d
+ | GT -> find x r)
+
+ (** val create : 'a1 tree -> key -> 'a1 -> 'a1 tree -> 'a1 tree **)
+
+ let create l x e r =
+ Node (l, x, e, r, (I.add (I.max (height l) (height r)) I._1))
+
+ (** val assert_false : 'a1 tree -> key -> 'a1 -> 'a1 tree -> 'a1 tree **)
+
+ let assert_false =
+ create
+
+ (** val bal : 'a1 tree -> key -> 'a1 -> 'a1 tree -> 'a1 tree **)
+
+ let bal l x d r =
+ let hl = height l in
+ let hr = height r in
+ (match I.gt_le_dec hl (I.add hr I._2) with
+ | Left ->
+ (match l with
+ | Leaf -> assert_false l x d r
+ | Node (ll, lx, ld, lr, _) ->
+ (match I.ge_lt_dec (height ll) (height lr) with
+ | Left -> create ll lx ld (create lr x d r)
+ | Right ->
+ (match lr with
+ | Leaf -> assert_false l x d r
+ | Node (lrl, lrx, lrd, lrr, _) ->
+ create (create ll lx ld lrl) lrx lrd (create lrr x d r))))
+ | Right ->
+ (match I.gt_le_dec hr (I.add hl I._2) with
+ | Left ->
+ (match r with
+ | Leaf -> assert_false l x d r
+ | Node (rl, rx, rd, rr, _) ->
+ (match I.ge_lt_dec (height rr) (height rl) with
+ | Left -> create (create l x d rl) rx rd rr
+ | Right ->
+ (match rl with
+ | Leaf -> assert_false l x d r
+ | Node (rll, rlx, rld, rlr, _) ->
+ create (create l x d rll) rlx rld (create rlr rx rd rr))))
+ | Right -> create l x d r))
+
+ (** val add : key -> 'a1 -> 'a1 tree -> 'a1 tree **)
+
+ let rec add x d = function
+ | Leaf -> Node (Leaf, x, d, Leaf, I._1)
+ | Node (l, y, d', r, h) ->
+ (match X.compare x y with
+ | LT -> bal (add x d l) y d' r
+ | EQ0 -> Node (l, y, d, r, h)
+ | GT -> bal l y d' (add x d r))
+
+ (** val remove_min :
+ 'a1 tree -> key -> 'a1 -> 'a1 tree -> 'a1 tree * (key * 'a1) **)
+
+ let rec remove_min l x d r =
+ match l with
+ | Leaf -> (r, (x, d))
+ | Node (ll, lx, ld, lr, _) ->
+ let (l', m) = remove_min ll lx ld lr in ((bal l' x d r), m)
+
+ (** val merge : 'a1 tree -> 'a1 tree -> 'a1 tree **)
+
+ let merge s1 s2 =
+ match s1 with
+ | Leaf -> s2
+ | Node (_, _, _, _, _) ->
+ (match s2 with
+ | Leaf -> s1
+ | Node (l2, x2, d2, r2, _) ->
+ let (s2', p) = remove_min l2 x2 d2 r2 in
+ let (x, d) = p in bal s1 x d s2')
+
+ (** val remove : X.t -> 'a1 tree -> 'a1 tree **)
+
+ let rec remove x = function
+ | Leaf -> Leaf
+ | Node (l, y, d, r, _) ->
+ (match X.compare x y with
+ | LT -> bal (remove x l) y d r
+ | EQ0 -> merge l r
+ | GT -> bal l y d (remove x r))
+
+ (** val join : 'a1 tree -> key -> 'a1 -> 'a1 tree -> 'a1 tree **)
+
+ let rec join l = match l with
+ | Leaf -> add
+ | Node (ll, lx, ld, lr, lh) ->
+ (fun x d ->
+ let rec join_aux r = match r with
+ | Leaf -> add x d l
+ | Node (rl, rx, rd, rr, rh) ->
+ (match I.gt_le_dec lh (I.add rh I._2) with
+ | Left -> bal ll lx ld (join lr x d r)
+ | Right ->
+ (match I.gt_le_dec rh (I.add lh I._2) with
+ | Left -> bal (join_aux rl) rx rd rr
+ | Right -> create l x d r))
+ in join_aux)
+
+ type 'elt triple = { t_left : 'elt tree; t_opt : 'elt option;
+ t_right : 'elt tree }
+
+ (** val t_left : 'a1 triple -> 'a1 tree **)
+
+ let t_left t0 =
+ t0.t_left
+
+ (** val t_opt : 'a1 triple -> 'a1 option **)
+
+ let t_opt t0 =
+ t0.t_opt
+
+ (** val t_right : 'a1 triple -> 'a1 tree **)
+
+ let t_right t0 =
+ t0.t_right
+
+ (** val split : X.t -> 'a1 tree -> 'a1 triple **)
+
+ let rec split x = function
+ | Leaf -> { t_left = Leaf; t_opt = None; t_right = Leaf }
+ | Node (l, y, d, r, _) ->
+ (match X.compare x y with
+ | LT ->
+ let { t_left = ll; t_opt = o; t_right = rl } = split x l in
+ { t_left = ll; t_opt = o; t_right = (join rl y d r) }
+ | EQ0 -> { t_left = l; t_opt = (Some d); t_right = r }
+ | GT ->
+ let { t_left = rl; t_opt = o; t_right = rr } = split x r in
+ { t_left = (join l y d rl); t_opt = o; t_right = rr })
+
+ (** val concat : 'a1 tree -> 'a1 tree -> 'a1 tree **)
+
+ let concat m1 m2 =
+ match m1 with
+ | Leaf -> m2
+ | Node (_, _, _, _, _) ->
+ (match m2 with
+ | Leaf -> m1
+ | Node (l2, x2, d2, r2, _) ->
+ let (m2', xd) = remove_min l2 x2 d2 r2 in
+ join m1 (fst xd) (snd xd) m2')
+
+ (** val elements_aux : (key * 'a1) list -> 'a1 tree -> (key * 'a1) list **)
+
+ let rec elements_aux acc = function
+ | Leaf -> acc
+ | Node (l, x, d, r, _) ->
+ elements_aux (Cons ((x, d), (elements_aux acc r))) l
+
+ (** val elements : 'a1 tree -> (key * 'a1) list **)
+
+ let elements m =
+ elements_aux Nil m
+
+ (** val fold : (key -> 'a1 -> 'a2 -> 'a2) -> 'a1 tree -> 'a2 -> 'a2 **)
+
+ let rec fold f m a =
+ match m with
+ | Leaf -> a
+ | Node (l, x, d, r, _) -> fold f r (f x d (fold f l a))
+
+ 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 **)
+
+ let rec enumeration_rect f f0 = function
+ | End -> f
+ | More (k, e0, t0, e1) -> f0 k e0 t0 e1 (enumeration_rect f f0 e1)
+
+ (** val enumeration_rec :
+ 'a2 -> (key -> 'a1 -> 'a1 tree -> 'a1 enumeration -> 'a2 -> 'a2) -> 'a1
+ enumeration -> 'a2 **)
+
+ let rec enumeration_rec f f0 = function
+ | End -> f
+ | More (k, e0, t0, e1) -> f0 k e0 t0 e1 (enumeration_rec f f0 e1)
+
+ (** val cons : 'a1 tree -> 'a1 enumeration -> 'a1 enumeration **)
+
+ let rec cons m e =
+ match m with
+ | Leaf -> e
+ | Node (l, x, d, r, _) -> cons l (More (x, d, r, e))
+
+ (** val equal_more :
+ ('a1 -> 'a1 -> bool) -> X.t -> 'a1 -> ('a1 enumeration -> bool) -> 'a1
+ enumeration -> bool **)
+
+ let equal_more cmp x1 d1 cont = function
+ | End -> false
+ | More (x2, d2, r2, e3) ->
+ (match X.compare x1 x2 with
+ | EQ0 -> if cmp d1 d2 then cont (cons r2 e3) else false
+ | _ -> false)
+
+ (** val equal_cont :
+ ('a1 -> 'a1 -> bool) -> 'a1 tree -> ('a1 enumeration -> bool) -> 'a1
+ enumeration -> bool **)
+
+ let rec equal_cont cmp m1 cont e2 =
+ match m1 with
+ | Leaf -> cont e2
+ | Node (l1, x1, d1, r1, _) ->
+ equal_cont cmp l1 (equal_more cmp x1 d1 (equal_cont cmp r1 cont)) e2
+
+ (** val equal_end : 'a1 enumeration -> bool **)
+
+ let equal_end = function
+ | End -> true
+ | More (_, _, _, _) -> false
+
+ (** val equal : ('a1 -> 'a1 -> bool) -> 'a1 tree -> 'a1 tree -> bool **)
+
+ let equal cmp m1 m2 =
+ equal_cont cmp m1 equal_end (cons m2 End)
+
+ (** val map : ('a1 -> 'a2) -> 'a1 tree -> 'a2 tree **)
+
+ let rec map f = function
+ | Leaf -> Leaf
+ | Node (l, x, d, r, h) -> Node ((map f l), x, (f d), (map f r), h)
+
+ (** val mapi : (key -> 'a1 -> 'a2) -> 'a1 tree -> 'a2 tree **)
+
+ let rec mapi f = function
+ | Leaf -> Leaf
+ | Node (l, x, d, r, h) -> Node ((mapi f l), x, (f x d), (mapi f r), h)
+
+ (** val map_option : (key -> 'a1 -> 'a2 option) -> 'a1 tree -> 'a2 tree **)
+
+ let rec map_option f = function
+ | Leaf -> Leaf
+ | Node (l, x, d, r, _) ->
+ (match f x d with
+ | Some d' -> join (map_option f l) x d' (map_option f r)
+ | None -> concat (map_option f l) (map_option f r))
+
+ (** val map2_opt :
+ (key -> 'a1 -> 'a2 option -> 'a3 option) -> ('a1 tree -> 'a3 tree) ->
+ ('a2 tree -> 'a3 tree) -> 'a1 tree -> 'a2 tree -> 'a3 tree **)
+
+ let rec map2_opt f mapl mapr m1 m2 =
+ match m1 with
+ | Leaf -> mapr m2
+ | Node (l1, x1, d1, r1, _) ->
+ (match m2 with
+ | Leaf -> mapl m1
+ | Node (_, _, _, _, _) ->
+ let { t_left = l2'; t_opt = o2; t_right = r2' } = split x1 m2 in
+ (match f x1 d1 o2 with
+ | Some e ->
+ join (map2_opt f mapl mapr l1 l2') x1 e
+ (map2_opt f mapl mapr r1 r2')
+ | None ->
+ concat (map2_opt f mapl mapr l1 l2') (map2_opt f mapl mapr r1 r2')))
+
+ (** val map2 :
+ ('a1 option -> 'a2 option -> 'a3 option) -> 'a1 tree -> 'a2 tree -> 'a3
+ tree **)
+
+ let map2 f =
+ map2_opt (fun _ d o -> f (Some d) o)
+ (map_option (fun _ d -> f (Some d) None))
+ (map_option (fun _ d' -> f None (Some d')))
+
+ module Proofs =
+ struct
+ module MX = OrderedTypeFacts(X)
+
+ module PX = KeyOrderedType(X)
+
+ module L = Raw(X)
+
+ 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 **)
+
+ let rec coq_R_mem_rect x f f0 f1 f2 _ _ = function
+ | R_mem_0 m -> f m __
+ | R_mem_1 (m, l, y, _x, r0, _x0, _res, r1) ->
+ f0 m l y _x r0 _x0 __ __ __ _res r1
+ (coq_R_mem_rect x f f0 f1 f2 l _res r1)
+ | R_mem_2 (m, l, y, _x, r0, _x0) -> f1 m l y _x r0 _x0 __ __ __
+ | R_mem_3 (m, l, y, _x, r0, _x0, _res, r1) ->
+ f2 m l y _x r0 _x0 __ __ __ _res r1
+ (coq_R_mem_rect x f f0 f1 f2 r0 _res r1)
+
+ (** 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 **)
+
+ let rec coq_R_mem_rec x f f0 f1 f2 _ _ = function
+ | R_mem_0 m -> f m __
+ | R_mem_1 (m, l, y, _x, r0, _x0, _res, r1) ->
+ f0 m l y _x r0 _x0 __ __ __ _res r1
+ (coq_R_mem_rec x f f0 f1 f2 l _res r1)
+ | R_mem_2 (m, l, y, _x, r0, _x0) -> f1 m l y _x r0 _x0 __ __ __
+ | R_mem_3 (m, l, y, _x, r0, _x0, _res, r1) ->
+ f2 m l y _x r0 _x0 __ __ __ _res r1
+ (coq_R_mem_rec x f f0 f1 f2 r0 _res r1)
+
+ 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 **)
+
+ let rec coq_R_find_rect x f f0 f1 f2 _ _ = function
+ | R_find_0 m -> f m __
+ | R_find_1 (m, l, y, d, r0, _x, _res, r1) ->
+ f0 m l y d r0 _x __ __ __ _res r1
+ (coq_R_find_rect x f f0 f1 f2 l _res r1)
+ | R_find_2 (m, l, y, d, r0, _x) -> f1 m l y d r0 _x __ __ __
+ | R_find_3 (m, l, y, d, r0, _x, _res, r1) ->
+ f2 m l y d r0 _x __ __ __ _res r1
+ (coq_R_find_rect x f f0 f1 f2 r0 _res r1)
+
+ (** 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 **)
+
+ let rec coq_R_find_rec x f f0 f1 f2 _ _ = function
+ | R_find_0 m -> f m __
+ | R_find_1 (m, l, y, d, r0, _x, _res, r1) ->
+ f0 m l y d r0 _x __ __ __ _res r1
+ (coq_R_find_rec x f f0 f1 f2 l _res r1)
+ | R_find_2 (m, l, y, d, r0, _x) -> f1 m l y d r0 _x __ __ __
+ | R_find_3 (m, l, y, d, r0, _x, _res, r1) ->
+ f2 m l y d r0 _x __ __ __ _res r1
+ (coq_R_find_rec x f f0 f1 f2 r0 _res r1)
+
+ 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 **)
+
+ let coq_R_bal_rect f f0 f1 f2 f3 f4 f5 f6 f7 _ _ _ _ _ = function
+ | R_bal_0 (x, x0, x1, x2) -> f x x0 x1 x2 __ __ __
+ | R_bal_1 (x, x0, x1, x2, x3, x4, x5, x6, x7) ->
+ f0 x x0 x1 x2 __ __ x3 x4 x5 x6 x7 __ __ __
+ | R_bal_2 (x, x0, x1, x2, x3, x4, x5, x6, x7) ->
+ f1 x x0 x1 x2 __ __ x3 x4 x5 x6 x7 __ __ __ __
+ | R_bal_3 (x, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) ->
+ f2 x x0 x1 x2 __ __ x3 x4 x5 x6 x7 __ __ __ x8 x9 x10 x11 x12 __
+ | R_bal_4 (x, x0, x1, x2) -> f3 x x0 x1 x2 __ __ __ __ __
+ | R_bal_5 (x, x0, x1, x2, x3, x4, x5, x6, x7) ->
+ f4 x x0 x1 x2 __ __ __ __ x3 x4 x5 x6 x7 __ __ __
+ | R_bal_6 (x, x0, x1, x2, x3, x4, x5, x6, x7) ->
+ f5 x x0 x1 x2 __ __ __ __ x3 x4 x5 x6 x7 __ __ __ __
+ | R_bal_7 (x, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) ->
+ f6 x x0 x1 x2 __ __ __ __ x3 x4 x5 x6 x7 __ __ __ x8 x9 x10 x11 x12 __
+ | R_bal_8 (x, x0, x1, x2) -> f7 x x0 x1 x2 __ __ __ __
+
+ (** 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 **)
+
+ let coq_R_bal_rec f f0 f1 f2 f3 f4 f5 f6 f7 _ _ _ _ _ = function
+ | R_bal_0 (x, x0, x1, x2) -> f x x0 x1 x2 __ __ __
+ | R_bal_1 (x, x0, x1, x2, x3, x4, x5, x6, x7) ->
+ f0 x x0 x1 x2 __ __ x3 x4 x5 x6 x7 __ __ __
+ | R_bal_2 (x, x0, x1, x2, x3, x4, x5, x6, x7) ->
+ f1 x x0 x1 x2 __ __ x3 x4 x5 x6 x7 __ __ __ __
+ | R_bal_3 (x, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) ->
+ f2 x x0 x1 x2 __ __ x3 x4 x5 x6 x7 __ __ __ x8 x9 x10 x11 x12 __
+ | R_bal_4 (x, x0, x1, x2) -> f3 x x0 x1 x2 __ __ __ __ __
+ | R_bal_5 (x, x0, x1, x2, x3, x4, x5, x6, x7) ->
+ f4 x x0 x1 x2 __ __ __ __ x3 x4 x5 x6 x7 __ __ __
+ | R_bal_6 (x, x0, x1, x2, x3, x4, x5, x6, x7) ->
+ f5 x x0 x1 x2 __ __ __ __ x3 x4 x5 x6 x7 __ __ __ __
+ | R_bal_7 (x, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) ->
+ f6 x x0 x1 x2 __ __ __ __ x3 x4 x5 x6 x7 __ __ __ x8 x9 x10 x11 x12 __
+ | R_bal_8 (x, x0, x1, x2) -> f7 x x0 x1 x2 __ __ __ __
+
+ 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 **)
+
+ let rec coq_R_add_rect x d f f0 f1 f2 _ _ = function
+ | R_add_0 m -> f m __
+ | R_add_1 (m, l, y, d', r0, h, _res, r1) ->
+ f0 m l y d' r0 h __ __ __ _res r1
+ (coq_R_add_rect x d f f0 f1 f2 l _res r1)
+ | R_add_2 (m, l, y, d', r0, h) -> f1 m l y d' r0 h __ __ __
+ | R_add_3 (m, l, y, d', r0, h, _res, r1) ->
+ f2 m l y d' r0 h __ __ __ _res r1
+ (coq_R_add_rect x d f f0 f1 f2 r0 _res r1)
+
+ (** 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 **)
+
+ let rec coq_R_add_rec x d f f0 f1 f2 _ _ = function
+ | R_add_0 m -> f m __
+ | R_add_1 (m, l, y, d', r0, h, _res, r1) ->
+ f0 m l y d' r0 h __ __ __ _res r1
+ (coq_R_add_rec x d f f0 f1 f2 l _res r1)
+ | R_add_2 (m, l, y, d', r0, h) -> f1 m l y d' r0 h __ __ __
+ | R_add_3 (m, l, y, d', r0, h, _res, r1) ->
+ f2 m l y d' r0 h __ __ __ _res r1
+ (coq_R_add_rec x d f f0 f1 f2 r0 _res r1)
+
+ 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 **)
+
+ let rec coq_R_remove_min_rect f f0 _ _ _ _ _ = function
+ | R_remove_min_0 (l, x, d, r0) -> f l x d r0 __
+ | R_remove_min_1 (l, x, d, r0, ll, lx, ld, lr, _x, _res, r1, l', m) ->
+ f0 l x d r0 ll lx ld lr _x __ _res r1
+ (coq_R_remove_min_rect f f0 ll lx ld lr _res r1) l' m __
+
+ (** 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 **)
+
+ let rec coq_R_remove_min_rec f f0 _ _ _ _ _ = function
+ | R_remove_min_0 (l, x, d, r0) -> f l x d r0 __
+ | R_remove_min_1 (l, x, d, r0, ll, lx, ld, lr, _x, _res, r1, l', m) ->
+ f0 l x d r0 ll lx ld lr _x __ _res r1
+ (coq_R_remove_min_rec f f0 ll lx ld lr _res r1) l' m __
+
+ 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 **)
+
+ let coq_R_merge_rect f f0 f1 _ _ _ = function
+ | R_merge_0 (x, x0) -> f x x0 __
+ | R_merge_1 (x, x0, x1, x2, x3, x4, x5) -> f0 x x0 x1 x2 x3 x4 x5 __ __
+ | R_merge_2 (x, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12,
+ x13, x14) ->
+ f1 x x0 x1 x2 x3 x4 x5 __ x6 x7 x8 x9 x10 __ x11 x12 __ x13 x14 __
+
+ (** 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 **)
+
+ let coq_R_merge_rec f f0 f1 _ _ _ = function
+ | R_merge_0 (x, x0) -> f x x0 __
+ | R_merge_1 (x, x0, x1, x2, x3, x4, x5) -> f0 x x0 x1 x2 x3 x4 x5 __ __
+ | R_merge_2 (x, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12,
+ x13, x14) ->
+ f1 x x0 x1 x2 x3 x4 x5 __ x6 x7 x8 x9 x10 __ x11 x12 __ x13 x14 __
+
+ 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 **)
+
+ let rec coq_R_remove_rect x f f0 f1 f2 _ _ = function
+ | R_remove_0 m -> f m __
+ | R_remove_1 (m, l, y, d, r0, _x, _res, r1) ->
+ f0 m l y d r0 _x __ __ __ _res r1
+ (coq_R_remove_rect x f f0 f1 f2 l _res r1)
+ | R_remove_2 (m, l, y, d, r0, _x) -> f1 m l y d r0 _x __ __ __
+ | R_remove_3 (m, l, y, d, r0, _x, _res, r1) ->
+ f2 m l y d r0 _x __ __ __ _res r1
+ (coq_R_remove_rect x f f0 f1 f2 r0 _res r1)
+
+ (** 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 **)
+
+ let rec coq_R_remove_rec x f f0 f1 f2 _ _ = function
+ | R_remove_0 m -> f m __
+ | R_remove_1 (m, l, y, d, r0, _x, _res, r1) ->
+ f0 m l y d r0 _x __ __ __ _res r1
+ (coq_R_remove_rec x f f0 f1 f2 l _res r1)
+ | R_remove_2 (m, l, y, d, r0, _x) -> f1 m l y d r0 _x __ __ __
+ | R_remove_3 (m, l, y, d, r0, _x, _res, r1) ->
+ f2 m l y d r0 _x __ __ __ _res r1
+ (coq_R_remove_rec x f f0 f1 f2 r0 _res r1)
+
+ 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 **)
+
+ let coq_R_concat_rect f f0 f1 _ _ _ = function
+ | R_concat_0 (x, x0) -> f x x0 __
+ | R_concat_1 (x, x0, x1, x2, x3, x4, x5) -> f0 x x0 x1 x2 x3 x4 x5 __ __
+ | R_concat_2 (x, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) ->
+ f1 x x0 x1 x2 x3 x4 x5 __ x6 x7 x8 x9 x10 __ x11 x12 __
+
+ (** 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 **)
+
+ let coq_R_concat_rec f f0 f1 _ _ _ = function
+ | R_concat_0 (x, x0) -> f x x0 __
+ | R_concat_1 (x, x0, x1, x2, x3, x4, x5) -> f0 x x0 x1 x2 x3 x4 x5 __ __
+ | R_concat_2 (x, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) ->
+ f1 x x0 x1 x2 x3 x4 x5 __ x6 x7 x8 x9 x10 __ x11 x12 __
+
+ 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 **)
+
+ let rec coq_R_split_rect x f f0 f1 f2 _ _ = function
+ | R_split_0 m -> f m __
+ | R_split_1 (m, l, y, d, r0, _x, _res, r1, ll, o, rl) ->
+ f0 m l y d r0 _x __ __ __ _res r1
+ (coq_R_split_rect x f f0 f1 f2 l _res r1) ll o rl __
+ | R_split_2 (m, l, y, d, r0, _x) -> f1 m l y d r0 _x __ __ __
+ | R_split_3 (m, l, y, d, r0, _x, _res, r1, rl, o, rr) ->
+ f2 m l y d r0 _x __ __ __ _res r1
+ (coq_R_split_rect x f f0 f1 f2 r0 _res r1) rl o rr __
+
+ (** 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 **)
+
+ let rec coq_R_split_rec x f f0 f1 f2 _ _ = function
+ | R_split_0 m -> f m __
+ | R_split_1 (m, l, y, d, r0, _x, _res, r1, ll, o, rl) ->
+ f0 m l y d r0 _x __ __ __ _res r1
+ (coq_R_split_rec x f f0 f1 f2 l _res r1) ll o rl __
+ | R_split_2 (m, l, y, d, r0, _x) -> f1 m l y d r0 _x __ __ __
+ | R_split_3 (m, l, y, d, r0, _x, _res, r1, rl, o, rr) ->
+ f2 m l y d r0 _x __ __ __ _res r1
+ (coq_R_split_rec x f f0 f1 f2 r0 _res r1) rl o rr __
+
+ 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 **)
+
+ let rec coq_R_map_option_rect f f0 f1 f2 _ _ = function
+ | R_map_option_0 m -> f0 m __
+ | R_map_option_1 (m, l, x, d, r0, _x, d', _res0, r1, _res, r2) ->
+ f1 m l x d r0 _x __ d' __ _res0 r1
+ (coq_R_map_option_rect f f0 f1 f2 l _res0 r1) _res r2
+ (coq_R_map_option_rect f f0 f1 f2 r0 _res r2)
+ | R_map_option_2 (m, l, x, d, r0, _x, _res0, r1, _res, r2) ->
+ f2 m l x d r0 _x __ __ _res0 r1
+ (coq_R_map_option_rect f f0 f1 f2 l _res0 r1) _res r2
+ (coq_R_map_option_rect f f0 f1 f2 r0 _res r2)
+
+ (** 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 **)
+
+ let rec coq_R_map_option_rec f f0 f1 f2 _ _ = function
+ | R_map_option_0 m -> f0 m __
+ | R_map_option_1 (m, l, x, d, r0, _x, d', _res0, r1, _res, r2) ->
+ f1 m l x d r0 _x __ d' __ _res0 r1
+ (coq_R_map_option_rec f f0 f1 f2 l _res0 r1) _res r2
+ (coq_R_map_option_rec f f0 f1 f2 r0 _res r2)
+ | R_map_option_2 (m, l, x, d, r0, _x, _res0, r1, _res, r2) ->
+ f2 m l x d r0 _x __ __ _res0 r1
+ (coq_R_map_option_rec f f0 f1 f2 l _res0 r1) _res r2
+ (coq_R_map_option_rec f f0 f1 f2 r0 _res r2)
+
+ 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 **)
+
+ let rec coq_R_map2_opt_rect f mapl mapr f0 f1 f2 f3 _ _ _ = function
+ | R_map2_opt_0 (m1, m2) -> f0 m1 m2 __
+ | R_map2_opt_1 (m1, m2, l1, x1, d1, r1, _x) ->
+ f1 m1 m2 l1 x1 d1 r1 _x __ __
+ | R_map2_opt_2 (m1, m2, l1, x1, d1, r1, _x, _x0, _x1, _x2, _x3, _x4, l2',
+ o2, r2', e, _res0, r0, _res, r2) ->
+ f2 m1 m2 l1 x1 d1 r1 _x __ _x0 _x1 _x2 _x3 _x4 __ l2' o2 r2' __ e __
+ _res0 r0
+ (coq_R_map2_opt_rect f mapl mapr f0 f1 f2 f3 l1 l2' _res0 r0) _res r2
+ (coq_R_map2_opt_rect f mapl mapr f0 f1 f2 f3 r1 r2' _res r2)
+ | R_map2_opt_3 (m1, m2, l1, x1, d1, r1, _x, _x0, _x1, _x2, _x3, _x4, l2',
+ o2, r2', _res0, r0, _res, r2) ->
+ f3 m1 m2 l1 x1 d1 r1 _x __ _x0 _x1 _x2 _x3 _x4 __ l2' o2 r2' __ __
+ _res0 r0
+ (coq_R_map2_opt_rect f mapl mapr f0 f1 f2 f3 l1 l2' _res0 r0) _res r2
+ (coq_R_map2_opt_rect f mapl mapr f0 f1 f2 f3 r1 r2' _res r2)
+
+ (** 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 **)
+
+ let rec coq_R_map2_opt_rec f mapl mapr f0 f1 f2 f3 _ _ _ = function
+ | R_map2_opt_0 (m1, m2) -> f0 m1 m2 __
+ | R_map2_opt_1 (m1, m2, l1, x1, d1, r1, _x) ->
+ f1 m1 m2 l1 x1 d1 r1 _x __ __
+ | R_map2_opt_2 (m1, m2, l1, x1, d1, r1, _x, _x0, _x1, _x2, _x3, _x4, l2',
+ o2, r2', e, _res0, r0, _res, r2) ->
+ f2 m1 m2 l1 x1 d1 r1 _x __ _x0 _x1 _x2 _x3 _x4 __ l2' o2 r2' __ e __
+ _res0 r0 (coq_R_map2_opt_rec f mapl mapr f0 f1 f2 f3 l1 l2' _res0 r0)
+ _res r2 (coq_R_map2_opt_rec f mapl mapr f0 f1 f2 f3 r1 r2' _res r2)
+ | R_map2_opt_3 (m1, m2, l1, x1, d1, r1, _x, _x0, _x1, _x2, _x3, _x4, l2',
+ o2, r2', _res0, r0, _res, r2) ->
+ f3 m1 m2 l1 x1 d1 r1 _x __ _x0 _x1 _x2 _x3 _x4 __ l2' o2 r2' __ __
+ _res0 r0 (coq_R_map2_opt_rec f mapl mapr f0 f1 f2 f3 l1 l2' _res0 r0)
+ _res r2 (coq_R_map2_opt_rec f mapl mapr f0 f1 f2 f3 r1 r2' _res r2)
+
+ (** val fold' : (key -> 'a1 -> 'a2 -> 'a2) -> 'a1 tree -> 'a2 -> 'a2 **)
+
+ let fold' f s =
+ L.fold f (elements s)
+
+ (** val flatten_e : 'a1 enumeration -> (key * 'a1) list **)
+
+ let rec flatten_e = function
+ | End -> Nil
+ | More (x, e0, t0, r) -> Cons ((x, e0), (app (elements t0) (flatten_e r)))
+ end
+ end
+
+module IntMake =
+ functor (I:Int) ->
+ functor (X:OrderedType) ->
+ struct
+ module E = X
+
+ module Raw = Coq_Raw(I)(X)
+
+ type 'elt bst =
+ 'elt Raw.tree
+ (* singleton inductive, whose constructor was Bst *)
+
+ (** val this : 'a1 bst -> 'a1 Raw.tree **)
+
+ let this b =
+ b
+
+ type 'elt t = 'elt bst
+
+ type key = E.t
+
+ (** val empty : 'a1 t **)
+
+ let empty =
+ Raw.empty
+
+ (** val is_empty : 'a1 t -> bool **)
+
+ let is_empty m =
+ Raw.is_empty (this m)
+
+ (** val add : key -> 'a1 -> 'a1 t -> 'a1 t **)
+
+ let add x e m =
+ Raw.add x e (this m)
+
+ (** val remove : key -> 'a1 t -> 'a1 t **)
+
+ let remove x m =
+ Raw.remove x (this m)
+
+ (** val mem : key -> 'a1 t -> bool **)
+
+ let mem x m =
+ Raw.mem x (this m)
+
+ (** val find : key -> 'a1 t -> 'a1 option **)
+
+ let find x m =
+ Raw.find x (this m)
+
+ (** val map : ('a1 -> 'a2) -> 'a1 t -> 'a2 t **)
+
+ let map f m =
+ Raw.map f (this m)
+
+ (** val mapi : (key -> 'a1 -> 'a2) -> 'a1 t -> 'a2 t **)
+
+ let mapi f m =
+ Raw.mapi f (this m)
+
+ (** val map2 :
+ ('a1 option -> 'a2 option -> 'a3 option) -> 'a1 t -> 'a2 t -> 'a3 t **)
+
+ let map2 f m m' =
+ Raw.map2 f (this m) (this m')
+
+ (** val elements : 'a1 t -> (key * 'a1) list **)
+
+ let elements m =
+ Raw.elements (this m)
+
+ (** val cardinal : 'a1 t -> nat **)
+
+ let cardinal m =
+ Raw.cardinal (this m)
+
+ (** val fold : (key -> 'a1 -> 'a2 -> 'a2) -> 'a1 t -> 'a2 -> 'a2 **)
+
+ let fold f m i =
+ Raw.fold f (this m) i
+
+ (** val equal : ('a1 -> 'a1 -> bool) -> 'a1 t -> 'a1 t -> bool **)
+
+ let equal cmp m m' =
+ Raw.equal cmp (this m) (this m')
+ end
+
+module Make =
+ functor (X:OrderedType) ->
+ IntMake(Z_as_Int)(X)
+
+module IntOrderedType =
+ struct
+ type t = Uint63.t
+
+ (** val compare : Uint63.t -> Uint63.t -> Uint63.t compare1 **)
+
+ let compare x y =
+ if ltb0 x y then LT else if eqb0 x y then EQ0 else GT
+
+ (** val eq_dec : Uint63.t -> Uint63.t -> sumbool **)
+
+ let eq_dec x y =
+ if eqb0 x y then Left else Right
+ end
+
+module Map = Make(IntOrderedType)
+
+type 'a array = ('a Map.t * 'a) * Uint63.t
+
+(** val make : Uint63.t -> 'a1 -> 'a1 array **)
+
+let make l d =
+ ((Map.empty, d), l)
+
+module Coq__2 = struct
+ (** val get : 'a1 array -> Uint63.t -> 'a1 **)
+ let get t0 i =
+ let (td, l) = t0 in
+ let (t1, d) = td in
+ if ltb0 i l then (match Map.find i t1 with
+ | Some x -> x
+ | None -> d) else d
+end
+include Coq__2
+
+(** val default : 'a1 array -> 'a1 **)
+
+let default = function
+| (td, _) -> let (_, d) = td in d
+
+(** val set : 'a1 array -> Uint63.t -> 'a1 -> 'a1 array **)
+
+let set t0 i a =
+ let (td, l) = t0 in
+ if leb0 l i then t0 else let (t1, d) = td in (((Map.add i a t1), d), l)
+
+(** val length0 : 'a1 array -> Uint63.t **)
+
+let length0 = function
+| (_, l) -> l
+
+(** val iter_int63_aux : nat -> Uint63.t -> ('a1 -> 'a1) -> 'a1 -> 'a1 **)
+
+let rec iter_int63_aux n0 i f =
+ match n0 with
+ | O -> (fun x -> x)
+ | S n1 ->
+ if eqb0 i (Uint63.of_int (0))
+ then (fun x -> x)
+ else let g = iter_int63_aux n1 (lsr0 i (Uint63.of_int (1))) f in
+ (fun x -> if bit i (Uint63.of_int (0)) then f (g (g x)) else g (g x))
+
+(** val iter_int63 : Uint63.t -> ('a1 -> 'a1) -> 'a1 -> 'a1 **)
+
+let iter_int63 i f x =
+ iter_int63_aux size i f x
+
+(** val foldi :
+ (Uint63.t -> 'a1 -> 'a1) -> Uint63.t -> Uint63.t -> 'a1 -> 'a1 **)
+
+let foldi f from to0 a =
+ if leb0 to0 from
+ then a
+ else let (_, r) =
+ iter_int63 (sub0 to0 from) (fun jy ->
+ let (j, y) = jy in ((add0 j (Uint63.of_int (1))), (f j y))) (from,
+ a)
+ in
+ r
+
+(** val to_list : 'a1 array -> 'a1 list **)
+
+let to_list t0 =
+ rev
+ (foldi (fun i l -> Cons ((get t0 i), l)) (Uint63.of_int (0)) (length0 t0)
+ Nil)
+
+(** val amapi : (Uint63.t -> 'a1 -> 'a2) -> 'a1 array -> 'a2 array **)
+
+let amapi f t0 =
+ let l = length0 t0 in
+ foldi (fun i tb -> set tb i (f i (get t0 i))) (Uint63.of_int (0)) l
+ (make l (f l (default t0)))
+
+(** val amap : ('a1 -> 'a2) -> 'a1 array -> 'a2 array **)
+
+let amap f =
+ amapi (fun _ -> f)
+
+(** val afold_left : 'a1 -> ('a1 -> 'a1 -> 'a1) -> 'a1 array -> 'a1 **)
+
+let afold_left default0 oP v =
+ if eqb0 (length0 v) (Uint63.of_int (0))
+ then default0
+ else foldi (fun i a -> oP a (get v i)) (Uint63.of_int (1)) (length0 v)
+ (get v (Uint63.of_int (0)))
+
+(** val afold_right : 'a1 -> ('a1 -> 'a1 -> 'a1) -> 'a1 array -> 'a1 **)
+
+let afold_right default0 oP v =
+ if eqb0 (length0 v) (Uint63.of_int (0))
+ then default0
+ else foldi (fun i ->
+ oP (get v (sub0 (sub0 (length0 v) (Uint63.of_int (1))) i)))
+ (Uint63.of_int (1)) (length0 v)
+ (get v (sub0 (length0 v) (Uint63.of_int (1))))
+
+(** val aexistsbi : (Uint63.t -> 'a1 -> bool) -> 'a1 array -> bool **)
+
+let aexistsbi f t0 =
+ afold_left false (fun b1 b2 -> if b1 then true else b2) (amapi f t0)
+
+(** val aforallbi : (Uint63.t -> 'a1 -> bool) -> 'a1 array -> bool **)
+
+let aforallbi f t0 =
+ afold_left true (fun b1 b2 -> if b1 then b2 else false) (amapi f t0)
+
+(** val forallb2 : ('a1 -> 'a2 -> bool) -> 'a1 list -> 'a2 list -> bool **)
+
+let rec forallb2 f l1 l2 =
+ match l1 with
+ | Nil -> (match l2 with
+ | Nil -> true
+ | Cons (_, _) -> false)
+ | Cons (a, l3) ->
+ (match l2 with
+ | Nil -> false
+ | Cons (b, l4) -> if f a b then forallb2 f l3 l4 else false)
+
+module RAWBITVECTOR_LIST =
+ struct
+ (** val beq_list : bool list -> bool list -> bool **)
+
+ let rec beq_list l m =
+ match l with
+ | Nil -> (match m with
+ | Nil -> true
+ | Cons (_, _) -> false)
+ | Cons (x, l') ->
+ (match m with
+ | Nil -> false
+ | Cons (y, m') -> if eqb x y then beq_list l' m' else false)
+
+ (** val pow2 : nat -> nat **)
+
+ let rec pow2 = function
+ | O -> S O
+ | S n' -> mul (S (S O)) (pow2 n')
+
+ (** val _list2nat_be : bool list -> nat -> nat -> nat **)
+
+ let rec _list2nat_be a n0 i =
+ match a with
+ | Nil -> n0
+ | Cons (xa, xsa) ->
+ if xa
+ then _list2nat_be xsa (add n0 (pow2 i)) (add i (S O))
+ else _list2nat_be xsa n0 (add i (S O))
+
+ (** val list2nat_be : bool list -> nat **)
+
+ let list2nat_be a =
+ _list2nat_be a O O
+ end
+
+module Lit =
+ struct
+ (** val is_pos : Uint63.t -> bool **)
+
+ let is_pos =
+ is_even
+
+ (** val blit : Uint63.t -> Uint63.t **)
+
+ let blit l =
+ lsr0 l (Uint63.of_int (1))
+
+ (** val lit : Uint63.t -> Uint63.t **)
+
+ let lit x =
+ lsl0 x (Uint63.of_int (1))
+
+ (** val neg : Uint63.t -> Uint63.t **)
+
+ let neg l =
+ lxor0 l (Uint63.of_int (1))
+
+ (** val nlit : Uint63.t -> Uint63.t **)
+
+ let nlit x =
+ neg (lit x)
+
+ (** val _true : Uint63.t **)
+
+ let _true =
+ (Uint63.of_int (0))
+
+ (** val _false : Uint63.t **)
+
+ let _false =
+ (Uint63.of_int (2))
+ end
+
+module C =
+ struct
+ type t = Uint63.t list
+
+ (** val _true : t **)
+
+ let _true =
+ Cons (Lit._true, Nil)
+
+ (** val is_false : t -> bool **)
+
+ let is_false = function
+ | Nil -> true
+ | Cons (_, _) -> false
+
+ (** val or_aux : (t -> t -> t) -> Uint63.t -> t -> t -> Uint63.t list **)
+
+ let rec or_aux or0 l1 c1 c2 = match c2 with
+ | Nil -> Cons (l1, c1)
+ | Cons (l2, c2') ->
+ (match compare0 l1 l2 with
+ | 0 -> Cons (l1, (or0 c1 c2'))
+ | (-1) -> Cons (l1, (or0 c1 c2))
+ | 1 -> Cons (l2, (or_aux or0 l1 c1 c2')))
+
+ (** val coq_or : t -> t -> t **)
+
+ let rec coq_or c1 c2 =
+ match c1 with
+ | Nil -> c2
+ | Cons (l1, c3) ->
+ (match c2 with
+ | Nil -> c1
+ | Cons (l2, c2') ->
+ (match compare0 l1 l2 with
+ | 0 -> Cons (l1, (coq_or c3 c2'))
+ | (-1) -> Cons (l1, (coq_or c3 c2))
+ | 1 -> Cons (l2, (or_aux coq_or l1 c3 c2'))))
+
+ (** val resolve_aux : (t -> t -> t) -> Uint63.t -> t -> t -> t **)
+
+ let rec resolve_aux resolve0 l1 c1 c2 = match c2 with
+ | Nil -> _true
+ | Cons (l2, c2') ->
+ (match compare0 l1 l2 with
+ | 0 -> Cons (l1, (resolve0 c1 c2'))
+ | (-1) ->
+ if eqb0 (lxor0 l1 l2) (Uint63.of_int (1))
+ then coq_or c1 c2'
+ else Cons (l1, (resolve0 c1 c2))
+ | 1 ->
+ if eqb0 (lxor0 l1 l2) (Uint63.of_int (1))
+ then coq_or c1 c2'
+ else Cons (l2, (resolve_aux resolve0 l1 c1 c2')))
+
+ (** val resolve : t -> t -> t **)
+
+ let rec resolve c1 c2 =
+ match c1 with
+ | Nil -> _true
+ | Cons (l1, c3) ->
+ (match c2 with
+ | Nil -> _true
+ | Cons (l2, c2') ->
+ (match compare0 l1 l2 with
+ | 0 -> Cons (l1, (resolve c3 c2'))
+ | (-1) ->
+ if eqb0 (lxor0 l1 l2) (Uint63.of_int (1))
+ then coq_or c3 c2'
+ else Cons (l1, (resolve c3 c2))
+ | 1 ->
+ if eqb0 (lxor0 l1 l2) (Uint63.of_int (1))
+ then coq_or c3 c2'
+ else Cons (l2, (resolve_aux resolve l1 c3 c2'))))
+ end
+
+module S =
+ struct
+ type t = C.t array
+
+ (** val get : t -> Uint63.t -> C.t **)
+
+ let get =
+ get
+
+ (** val internal_set : t -> Uint63.t -> C.t -> t **)
+
+ let internal_set =
+ set
+
+ (** val make : Uint63.t -> t **)
+
+ let make nclauses =
+ make nclauses C._true
+
+ (** val insert_no_simpl : Uint63.t -> Uint63.t list -> Uint63.t list **)
+
+ let rec insert_no_simpl l1 c = match c with
+ | Nil -> Cons (l1, Nil)
+ | Cons (l2, c') ->
+ (match compare0 l1 l2 with
+ | 0 -> c
+ | (-1) -> Cons (l1, c)
+ | 1 -> Cons (l2, (insert_no_simpl l1 c')))
+
+ (** val insert_keep : Uint63.t -> Uint63.t list -> Uint63.t list **)
+
+ let rec insert_keep l1 c = match c with
+ | Nil -> Cons (l1, Nil)
+ | Cons (l2, c') ->
+ (match compare0 l1 l2 with
+ | 1 -> Cons (l2, (insert_keep l1 c'))
+ | _ -> Cons (l1, c))
+
+ (** val sort : Uint63.t list -> Uint63.t list **)
+
+ let rec sort = function
+ | Nil -> Nil
+ | Cons (l1, c0) -> insert_no_simpl l1 (sort c0)
+
+ (** val sort_keep : Uint63.t list -> Uint63.t list **)
+
+ let rec sort_keep = function
+ | Nil -> Nil
+ | Cons (l1, c0) -> insert_keep l1 (sort_keep c0)
+
+ (** val set_clause : t -> Uint63.t -> C.t -> t **)
+
+ let set_clause s pos c =
+ set s pos (sort c)
+
+ (** val set_clause_keep : t -> Uint63.t -> C.t -> t **)
+
+ let set_clause_keep s pos c =
+ set s pos (sort_keep c)
+
+ (** val set_resolve : t -> Uint63.t -> Uint63.t array -> t **)
+
+ let set_resolve s pos r =
+ let len = length0 r in
+ if eqb0 len (Uint63.of_int (0))
+ then s
+ else let c =
+ foldi (fun i c' -> C.resolve (get s (Coq__2.get r i)) c')
+ (Uint63.of_int (1)) len
+ (get s (Coq__2.get r (Uint63.of_int (0))))
+ in
+ internal_set s pos c
+
+ (** val subclause : Uint63.t list -> Uint63.t list -> bool **)
+
+ let subclause cl1 cl2 =
+ forallb (fun l1 ->
+ if if eqb0 l1 Lit._false then true else eqb0 l1 (Lit.neg Lit._true)
+ then true
+ else existsb (fun l2 -> eqb0 l1 l2) cl2) cl1
+
+ (** val check_weaken : t -> Uint63.t -> Uint63.t list -> C.t **)
+
+ let check_weaken s cid cl =
+ if subclause (get s cid) cl then cl else C._true
+
+ (** val set_weaken : t -> Uint63.t -> Uint63.t -> Uint63.t list -> t **)
+
+ let set_weaken s pos cid cl =
+ set_clause_keep s pos (check_weaken s cid cl)
+ end
+
+module Form =
+ struct
+ 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 **)
+
+ let is_Ftrue = function
+ | Ftrue -> true
+ | _ -> false
+
+ (** val is_Ffalse : form -> bool **)
+
+ let is_Ffalse = function
+ | Ffalse -> true
+ | _ -> false
+
+ (** val lt_form : Uint63.t -> form -> bool **)
+
+ let lt_form i = function
+ | Fnot2 (_, l) -> ltb0 (Lit.blit l) i
+ | Fand args -> aforallbi (fun _ l -> ltb0 (Lit.blit l) i) args
+ | For args -> aforallbi (fun _ l -> ltb0 (Lit.blit l) i) args
+ | Fimp args -> aforallbi (fun _ l -> ltb0 (Lit.blit l) i) args
+ | Fxor (a, b) -> if ltb0 (Lit.blit a) i then ltb0 (Lit.blit b) i else false
+ | Fiff (a, b) -> if ltb0 (Lit.blit a) i then ltb0 (Lit.blit b) i else false
+ | Fite (a, b, c) ->
+ if if ltb0 (Lit.blit a) i then ltb0 (Lit.blit b) i else false
+ then ltb0 (Lit.blit c) i
+ else false
+ | FbbT (_, ls) -> forallb (fun l -> ltb0 (Lit.blit l) i) ls
+ | _ -> true
+
+ (** val wf : form array -> bool **)
+
+ let wf t_form =
+ aforallbi lt_form t_form
+
+ (** val check_form : form array -> bool **)
+
+ let check_form t_form =
+ if if if is_Ftrue (default t_form)
+ then is_Ftrue (get t_form (Uint63.of_int (0)))
+ else false
+ then is_Ffalse (get t_form (Uint63.of_int (1)))
+ else false
+ then wf t_form
+ else false
+ end
+
+module Typ =
+ struct
+ 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 **)
+
+ let rec eqb a b =
+ match a with
+ | TFArray (k1, e1) ->
+ (match b with
+ | TFArray (k2, e2) -> if eqb k1 k2 then eqb e1 e2 else false
+ | _ -> false)
+ | Tindex i -> (match b with
+ | Tindex j -> N.eqb i j
+ | _ -> false)
+ | TZ -> (match b with
+ | TZ -> true
+ | _ -> false)
+ | Tbool -> (match b with
+ | Tbool -> true
+ | _ -> false)
+ | Tpositive -> (match b with
+ | Tpositive -> true
+ | _ -> false)
+ | TBV n0 -> (match b with
+ | TBV m -> N.eqb n0 m
+ | _ -> false)
+ end
+
+(** val list_beq : ('a1 -> 'a1 -> bool) -> 'a1 list -> 'a1 list -> bool **)
+
+let rec list_beq eq_A x y =
+ match x with
+ | Nil -> (match y with
+ | Nil -> true
+ | Cons (_, _) -> false)
+ | Cons (x0, x1) ->
+ (match y with
+ | Nil -> false
+ | Cons (x2, x3) -> if eq_A x0 x2 then list_beq eq_A x1 x3 else false)
+
+module Atom =
+ struct
+ 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 **)
+
+ let cop_eqb o o' =
+ match o with
+ | CO_xH -> (match o' with
+ | CO_xH -> true
+ | _ -> false)
+ | CO_Z0 -> (match o' with
+ | CO_Z0 -> true
+ | _ -> false)
+ | CO_BV (bv, s) ->
+ (match o' with
+ | CO_BV (bv', s') ->
+ if N.eqb s s' then RAWBITVECTOR_LIST.beq_list bv bv' else false
+ | _ -> false)
+
+ (** val uop_eqb : unop -> unop -> bool **)
+
+ let uop_eqb o o' =
+ match o with
+ | UO_xO -> (match o' with
+ | UO_xO -> true
+ | _ -> false)
+ | UO_xI -> (match o' with
+ | UO_xI -> true
+ | _ -> false)
+ | UO_Zpos -> (match o' with
+ | UO_Zpos -> true
+ | _ -> false)
+ | UO_Zneg -> (match o' with
+ | UO_Zneg -> true
+ | _ -> false)
+ | UO_Zopp -> (match o' with
+ | UO_Zopp -> true
+ | _ -> false)
+ | UO_BVbitOf (s1, n0) ->
+ (match o' with
+ | UO_BVbitOf (s2, m) -> if Nat.eqb n0 m then N.eqb s1 s2 else false
+ | _ -> false)
+ | UO_BVnot s1 -> (match o' with
+ | UO_BVnot s2 -> N.eqb s1 s2
+ | _ -> false)
+ | UO_BVneg s1 -> (match o' with
+ | UO_BVneg s2 -> N.eqb s1 s2
+ | _ -> false)
+ | UO_BVextr (i0, n00, n01) ->
+ (match o' with
+ | UO_BVextr (i1, n10, n11) ->
+ if if N.eqb i0 i1 then N.eqb n00 n10 else false
+ then N.eqb n01 n11
+ else false
+ | _ -> false)
+ | UO_BVzextn (s1, i1) ->
+ (match o' with
+ | UO_BVzextn (s2, i2) -> if N.eqb s1 s2 then N.eqb i1 i2 else false
+ | _ -> false)
+ | UO_BVsextn (s1, i1) ->
+ (match o' with
+ | UO_BVsextn (s2, i2) -> if N.eqb s1 s2 then N.eqb i1 i2 else false
+ | _ -> false)
+
+ (** val bop_eqb : binop -> binop -> bool **)
+
+ let bop_eqb o o' =
+ match o with
+ | BO_Zplus -> (match o' with
+ | BO_Zplus -> true
+ | _ -> false)
+ | BO_Zminus -> (match o' with
+ | BO_Zminus -> true
+ | _ -> false)
+ | BO_Zmult -> (match o' with
+ | BO_Zmult -> true
+ | _ -> false)
+ | BO_Zlt -> (match o' with
+ | BO_Zlt -> true
+ | _ -> false)
+ | BO_Zle -> (match o' with
+ | BO_Zle -> true
+ | _ -> false)
+ | BO_Zge -> (match o' with
+ | BO_Zge -> true
+ | _ -> false)
+ | BO_Zgt -> (match o' with
+ | BO_Zgt -> true
+ | _ -> false)
+ | BO_eq t0 -> (match o' with
+ | BO_eq t' -> Typ.eqb t0 t'
+ | _ -> false)
+ | BO_BVand s1 -> (match o' with
+ | BO_BVand s2 -> N.eqb s1 s2
+ | _ -> false)
+ | BO_BVor s1 -> (match o' with
+ | BO_BVor s2 -> N.eqb s1 s2
+ | _ -> false)
+ | BO_BVxor s1 -> (match o' with
+ | BO_BVxor s2 -> N.eqb s1 s2
+ | _ -> false)
+ | BO_BVadd s1 -> (match o' with
+ | BO_BVadd s2 -> N.eqb s1 s2
+ | _ -> false)
+ | BO_BVmult s1 -> (match o' with
+ | BO_BVmult s2 -> N.eqb s1 s2
+ | _ -> false)
+ | BO_BVult s1 -> (match o' with
+ | BO_BVult s2 -> N.eqb s1 s2
+ | _ -> false)
+ | BO_BVslt s1 -> (match o' with
+ | BO_BVslt s2 -> N.eqb s1 s2
+ | _ -> false)
+ | BO_BVconcat (s1, s2) ->
+ (match o' with
+ | BO_BVconcat (s3, s4) -> if N.eqb s1 s3 then N.eqb s2 s4 else false
+ | _ -> false)
+ | BO_BVshl s1 -> (match o' with
+ | BO_BVshl s2 -> N.eqb s1 s2
+ | _ -> false)
+ | BO_BVshr s1 -> (match o' with
+ | BO_BVshr s2 -> N.eqb s1 s2
+ | _ -> false)
+ | BO_select (ti, te) ->
+ (match o' with
+ | BO_select (ti', te') ->
+ if Typ.eqb ti ti' then Typ.eqb te te' else false
+ | _ -> false)
+ | BO_diffarray (ti, te) ->
+ (match o' with
+ | BO_diffarray (ti', te') ->
+ if Typ.eqb ti ti' then Typ.eqb te te' else false
+ | _ -> false)
+
+ (** val top_eqb : terop -> terop -> bool **)
+
+ let top_eqb o o' =
+ let TO_store (ti, te) = o in
+ let TO_store (ti', te') = o' in
+ if Typ.eqb ti ti' then Typ.eqb te te' else false
+
+ (** val nop_eqb : nop -> nop -> bool **)
+
+ let nop_eqb =
+ Typ.eqb
+
+ (** val eqb : atom -> atom -> bool **)
+
+ let eqb t0 t' =
+ match t0 with
+ | Acop o -> (match t' with
+ | Acop o' -> cop_eqb o o'
+ | _ -> false)
+ | Auop (o, t1) ->
+ (match t' with
+ | Auop (o', t'0) -> if uop_eqb o o' then eqb0 t1 t'0 else false
+ | _ -> false)
+ | Abop (o, t1, t2) ->
+ (match t' with
+ | Abop (o', t1', t2') ->
+ if if bop_eqb o o' then eqb0 t1 t1' else false
+ then eqb0 t2 t2'
+ else false
+ | _ -> false)
+ | Atop (o, t1, t2, t3) ->
+ (match t' with
+ | Atop (o', t1', t2', t3') ->
+ if if if top_eqb o o' then eqb0 t1 t1' else false
+ then eqb0 t2 t2'
+ else false
+ then eqb0 t3 t3'
+ else false
+ | _ -> false)
+ | Anop (o, t1) ->
+ (match t' with
+ | Anop (o', t'0) ->
+ if nop_eqb o o' then list_beq eqb0 t1 t'0 else false
+ | _ -> false)
+ | Aapp (a, la) ->
+ (match t' with
+ | Aapp (b, lb) -> if eqb0 a b then list_beq eqb0 la lb else false
+ | _ -> false)
+
+ (** val lt_atom : Uint63.t -> atom -> bool **)
+
+ let lt_atom i = function
+ | Acop _ -> true
+ | Auop (_, h) -> ltb0 h i
+ | Abop (_, h1, h2) -> if ltb0 h1 i then ltb0 h2 i else false
+ | Atop (_, h1, h2, h3) ->
+ if if ltb0 h1 i then ltb0 h2 i else false then ltb0 h3 i else false
+ | Anop (_, ha) -> forallb (fun h -> ltb0 h i) ha
+ | Aapp (_, args) -> forallb (fun h -> ltb0 h i) args
+
+ (** val wf : atom array -> bool **)
+
+ let wf t_atom =
+ aforallbi lt_atom t_atom
+
+ (** val check_atom : atom array -> bool **)
+
+ let check_atom t_atom =
+ match default t_atom with
+ | Acop c -> (match c with
+ | CO_xH -> wf t_atom
+ | _ -> false)
+ | _ -> false
+ end
+
+(** val get_eq :
+ Form.form array -> Atom.atom array -> Uint63.t -> (Uint63.t -> Uint63.t
+ -> C.t) -> C.t **)
+
+let get_eq t_form t_atom x f =
+ match get t_form x with
+ | Form.Fatom xa ->
+ (match get t_atom xa with
+ | Atom.Abop (b0, a, b) ->
+ (match b0 with
+ | Atom.BO_eq _ -> f a b
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true
+
+(** val check_trans_aux :
+ Form.form array -> Atom.atom array -> Uint63.t -> Uint63.t -> Uint63.t
+ list -> Uint63.t -> C.t -> C.t **)
+
+let rec check_trans_aux t_form t_atom t1 t2 eqs res clause0 =
+ match eqs with
+ | Nil ->
+ let xres = Lit.blit res in
+ get_eq t_form t_atom xres (fun t1' t2' ->
+ if if if eqb0 t1 t1' then eqb0 t2 t2' else false
+ then true
+ else if eqb0 t1 t2' then eqb0 t2 t1' else false
+ then Cons ((Lit.lit xres), clause0)
+ else C._true)
+ | Cons (leq, eqs0) ->
+ let xeq = Lit.blit leq in
+ get_eq t_form t_atom xeq (fun t0 t' ->
+ if eqb0 t2 t'
+ then check_trans_aux t_form t_atom t1 t0 eqs0 res (Cons
+ ((Lit.nlit xeq), clause0))
+ else if eqb0 t2 t0
+ then check_trans_aux t_form t_atom t1 t' eqs0 res (Cons
+ ((Lit.nlit xeq), clause0))
+ else if eqb0 t1 t'
+ then check_trans_aux t_form t_atom t0 t2 eqs0 res (Cons
+ ((Lit.nlit xeq), clause0))
+ else if eqb0 t1 t0
+ then check_trans_aux t_form t_atom t' t2 eqs0 res (Cons
+ ((Lit.nlit xeq), clause0))
+ else C._true)
+
+(** val check_trans :
+ Form.form array -> Atom.atom array -> Uint63.t -> Uint63.t list -> C.t **)
+
+let check_trans t_form t_atom res = function
+| Nil ->
+ let xres = Lit.blit res in
+ get_eq t_form t_atom xres (fun t1 t2 ->
+ if eqb0 t1 t2 then Cons ((Lit.lit xres), Nil) else C._true)
+| Cons (leq, eqs0) ->
+ let xeq = Lit.blit leq in
+ get_eq t_form t_atom xeq (fun t1 t2 ->
+ check_trans_aux t_form t_atom t1 t2 eqs0 res (Cons ((Lit.nlit xeq), Nil)))
+
+(** val build_congr :
+ Form.form array -> Atom.atom array -> Uint63.t option list -> Uint63.t
+ list -> Uint63.t list -> C.t -> C.t **)
+
+let rec build_congr t_form t_atom eqs l r c =
+ match eqs with
+ | Nil ->
+ (match l with
+ | Nil -> (match r with
+ | Nil -> c
+ | Cons (_, _) -> C._true)
+ | Cons (_, _) -> C._true)
+ | Cons (eq, eqs0) ->
+ (match l with
+ | Nil -> C._true
+ | Cons (t1, l0) ->
+ (match r with
+ | Nil -> C._true
+ | Cons (t2, r0) ->
+ (match eq with
+ | Some leq ->
+ let xeq = Lit.blit leq in
+ get_eq t_form t_atom xeq (fun t1' t2' ->
+ if if if eqb0 t1 t1' then eqb0 t2 t2' else false
+ then true
+ else if eqb0 t1 t2' then eqb0 t2 t1' else false
+ then build_congr t_form t_atom eqs0 l0 r0 (Cons
+ ((Lit.nlit xeq), c))
+ else C._true)
+ | None ->
+ if eqb0 t1 t2
+ then build_congr t_form t_atom eqs0 l0 r0 c
+ else C._true)))
+
+(** val check_congr :
+ Form.form array -> Atom.atom array -> Uint63.t -> Uint63.t option list ->
+ C.t **)
+
+let check_congr t_form t_atom leq eqs =
+ let xeq = Lit.blit leq in
+ get_eq t_form t_atom xeq (fun t1 t2 ->
+ match get t_atom t1 with
+ | Atom.Auop (o1, a) ->
+ (match get t_atom t2 with
+ | Atom.Auop (o2, b) ->
+ if Atom.uop_eqb o1 o2
+ then build_congr t_form t_atom eqs (Cons (a, Nil)) (Cons (b, Nil))
+ (Cons ((Lit.lit xeq), Nil))
+ else C._true
+ | _ -> C._true)
+ | Atom.Abop (o1, a1, a2) ->
+ (match get t_atom t2 with
+ | Atom.Abop (o2, b1, b2) ->
+ if Atom.bop_eqb o1 o2
+ then build_congr t_form t_atom eqs (Cons (a1, (Cons (a2, Nil))))
+ (Cons (b1, (Cons (b2, Nil)))) (Cons ((Lit.lit xeq), Nil))
+ else C._true
+ | _ -> C._true)
+ | Atom.Aapp (f1, args1) ->
+ (match get t_atom t2 with
+ | Atom.Aapp (f2, args2) ->
+ if eqb0 f1 f2
+ then build_congr t_form t_atom eqs args1 args2 (Cons ((Lit.lit xeq),
+ Nil))
+ else C._true
+ | _ -> C._true)
+ | _ -> C._true)
+
+(** val check_congr_pred :
+ Form.form array -> Atom.atom array -> Uint63.t -> Uint63.t -> Uint63.t
+ option list -> C.t **)
+
+let check_congr_pred t_form t_atom pA pB eqs =
+ let xPA = Lit.blit pA in
+ let xPB = Lit.blit pB in
+ (match get t_form xPA with
+ | Form.Fatom pa ->
+ (match get t_form xPB with
+ | Form.Fatom pb ->
+ (match get t_atom pa with
+ | Atom.Auop (o1, a) ->
+ (match get t_atom pb with
+ | Atom.Auop (o2, b) ->
+ if Atom.uop_eqb o1 o2
+ then build_congr t_form t_atom eqs (Cons (a, Nil)) (Cons (b,
+ Nil)) (Cons ((Lit.nlit xPA), (Cons ((Lit.lit xPB),
+ Nil))))
+ else C._true
+ | _ -> C._true)
+ | Atom.Abop (o1, a1, a2) ->
+ (match get t_atom pb with
+ | Atom.Abop (o2, b1, b2) ->
+ if Atom.bop_eqb o1 o2
+ then build_congr t_form t_atom eqs (Cons (a1, (Cons (a2,
+ Nil)))) (Cons (b1, (Cons (b2, Nil)))) (Cons
+ ((Lit.nlit xPA), (Cons ((Lit.lit xPB), Nil))))
+ else C._true
+ | _ -> C._true)
+ | Atom.Aapp (p, a) ->
+ (match get t_atom pb with
+ | Atom.Aapp (p', b) ->
+ if eqb0 p p'
+ then build_congr t_form t_atom eqs a b (Cons ((Lit.nlit xPA),
+ (Cons ((Lit.lit xPB), Nil))))
+ else C._true
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
(** val build_positive_atom_aux :
- (int -> positive option) -> Atom.atom -> positive option **)
+ (Uint63.t -> positive option) -> Atom.atom -> positive option **)
let build_positive_atom_aux build_positive0 = function
-| Atom.Acop c ->
- (match c with
- | Atom.CO_xH -> Some XH
- | Atom.CO_Z0 -> None)
+| Atom.Acop c -> (match c with
+ | Atom.CO_xH -> Some XH
+ | _ -> None)
| Atom.Auop (u, a0) ->
(match u with
| Atom.UO_xO -> option_map (fun x -> XO x) (build_positive0 a0)
@@ -5680,20 +4700,18 @@ let build_positive_atom_aux build_positive0 = function
| _ -> None)
| _ -> None
-(** val build_positive : Atom.atom array -> int -> positive option **)
+(** val build_positive : Atom.atom array -> Uint63.t -> positive option **)
let build_positive t_atom =
- foldi_down_cont (fun i cont h ->
- build_positive_atom_aux cont (get t_atom h)) (length t_atom)
- (ExtrNative.of_uint(0)) (fun x -> None)
+ foldi (fun _ cont h -> build_positive_atom_aux cont (get t_atom h))
+ (Uint63.of_int (0)) (length0 t_atom) (fun _ -> None)
(** val build_z_atom_aux : Atom.atom array -> Atom.atom -> z option **)
let build_z_atom_aux t_atom = function
-| Atom.Acop c ->
- (match c with
- | Atom.CO_xH -> None
- | Atom.CO_Z0 -> Some Z0)
+| Atom.Acop c -> (match c with
+ | Atom.CO_Z0 -> Some Z0
+ | _ -> None)
| Atom.Auop (u, a0) ->
(match u with
| Atom.UO_Zpos -> option_map (fun x -> Zpos x) (build_positive t_atom a0)
@@ -5703,10 +4721,10 @@ let build_z_atom_aux t_atom = function
(** val build_z_atom : Atom.atom array -> Atom.atom -> z option **)
-let build_z_atom t_atom =
- build_z_atom_aux t_atom
+let build_z_atom =
+ build_z_atom_aux
-type vmap = positive*Atom.atom list
+type vmap = positive * Atom.atom list
(** val find_var_aux :
Atom.atom -> positive -> Atom.atom list -> positive option **)
@@ -5717,57 +4735,58 @@ let rec find_var_aux h p = function
let p2 = Coq_Pos.pred p in
if Atom.eqb h h' then Some p2 else find_var_aux h p2 l0
-(** val find_var : vmap -> Atom.atom -> vmap*positive **)
+(** val find_var : vmap -> Atom.atom -> vmap * positive **)
let find_var vm h =
- let count,map0 = vm in
+ let (count, map0) = vm in
(match find_var_aux h count map0 with
- | Some p -> vm,p
- | None -> ((Coq_Pos.succ count),(Cons (h, map0))),count)
+ | Some p -> (vm, p)
+ | None -> (((Coq_Pos.succ count), (Cons (h, map0))), count))
(** val empty_vmap : vmap **)
let empty_vmap =
- XH,Nil
+ (XH, Nil)
(** 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 **)
let build_pexpr_atom_aux t_atom build_pexpr0 vm h = match h with
| Atom.Auop (u, a) ->
(match u with
- | Atom.UO_Zopp -> let vm0,pe = build_pexpr0 vm a in vm0,(PEopp pe)
+ | Atom.UO_Zopp -> let (vm0, pe) = build_pexpr0 vm a in (vm0, (PEopp pe))
| _ ->
(match build_z_atom t_atom h with
- | Some z0 -> vm,(PEc z0)
- | None -> let vm0,p = find_var vm h in vm0,(PEX p)))
+ | Some z0 -> (vm, (PEc z0))
+ | None -> let (vm0, p) = find_var vm h in (vm0, (PEX p))))
| Atom.Abop (b, a1, a2) ->
(match b with
| Atom.BO_Zplus ->
- let vm0,pe1 = build_pexpr0 vm a1 in
- let vm1,pe2 = build_pexpr0 vm0 a2 in vm1,(PEadd (pe1, pe2))
+ let (vm0, pe1) = build_pexpr0 vm a1 in
+ let (vm1, pe2) = build_pexpr0 vm0 a2 in (vm1, (PEadd (pe1, pe2)))
| Atom.BO_Zminus ->
- let vm0,pe1 = build_pexpr0 vm a1 in
- let vm1,pe2 = build_pexpr0 vm0 a2 in vm1,(PEsub (pe1, pe2))
+ let (vm0, pe1) = build_pexpr0 vm a1 in
+ let (vm1, pe2) = build_pexpr0 vm0 a2 in (vm1, (PEsub (pe1, pe2)))
| Atom.BO_Zmult ->
- let vm0,pe1 = build_pexpr0 vm a1 in
- let vm1,pe2 = build_pexpr0 vm0 a2 in vm1,(PEmul (pe1, pe2))
+ let (vm0, pe1) = build_pexpr0 vm a1 in
+ let (vm1, pe2) = build_pexpr0 vm0 a2 in (vm1, (PEmul (pe1, pe2)))
| _ ->
(match build_z_atom t_atom h with
- | Some z0 -> vm,(PEc z0)
- | None -> let vm0,p = find_var vm h in vm0,(PEX p)))
+ | Some z0 -> (vm, (PEc z0))
+ | None -> let (vm0, p) = find_var vm h in (vm0, (PEX p))))
| _ ->
(match build_z_atom t_atom h with
- | Some z0 -> vm,(PEc z0)
- | None -> let vm0,p = find_var vm h in vm0,(PEX p))
+ | Some z0 -> (vm, (PEc z0))
+ | None -> let (vm0, p) = find_var vm h in (vm0, (PEX p)))
-(** val build_pexpr : Atom.atom array -> vmap -> int -> vmap*z pExpr **)
+(** val build_pexpr :
+ Atom.atom array -> vmap -> Uint63.t -> vmap * z pExpr **)
let build_pexpr t_atom =
- foldi_down_cont (fun i cont vm h ->
- build_pexpr_atom_aux t_atom cont vm (get t_atom h)) (length t_atom)
- (ExtrNative.of_uint(0)) (fun vm x -> vm,(PEc Z0))
+ foldi (fun _ cont vm h ->
+ build_pexpr_atom_aux t_atom cont vm (get t_atom h)) (Uint63.of_int (0))
+ (length0 t_atom) (fun vm _ -> (vm, (PEc Z0)))
(** val build_op2 : Atom.binop -> op2 option **)
@@ -5776,229 +4795,205 @@ let build_op2 = function
| Atom.BO_Zle -> Some OpLe
| Atom.BO_Zge -> Some OpGe
| Atom.BO_Zgt -> Some OpGt
-| Atom.BO_eq t0 ->
- (match t0 with
- | Typ.TZ -> Some OpEq
- | _ -> None)
+| Atom.BO_eq t0 -> (match t0 with
+ | Typ.TZ -> Some OpEq
+ | _ -> None)
| _ -> None
(** val build_formula_atom :
- Atom.atom array -> vmap -> Atom.atom -> (vmap*z formula) option **)
+ Atom.atom array -> vmap -> Atom.atom -> (vmap * z formula) option **)
let build_formula_atom t_atom vm = function
| Atom.Abop (op, a1, a2) ->
(match build_op2 op with
| Some o ->
- let vm0,pe1 = build_pexpr t_atom vm a1 in
- let vm1,pe2 = build_pexpr t_atom vm0 a2 in
- Some (vm1,{ flhs = pe1; fop = o; frhs = pe2 })
+ let (vm0, pe1) = build_pexpr t_atom vm a1 in
+ let (vm1, pe2) = build_pexpr t_atom vm0 a2 in
+ Some (vm1, { flhs = pe1; fop = o; frhs = pe2 })
| None -> None)
| _ -> None
(** val build_formula :
- Atom.atom array -> vmap -> int -> (vmap*z formula) option **)
+ Atom.atom array -> vmap -> Uint63.t -> (vmap * z formula) option **)
let build_formula t_atom vm h =
build_formula_atom t_atom vm (get t_atom h)
-(** val build_not2 : int -> z formula bFormula -> z formula bFormula **)
+(** val build_not2 : Uint63.t -> z formula bFormula -> z formula bFormula **)
let build_not2 i f =
- fold (fun f' -> N (N f')) (ExtrNative.of_uint(1)) i f
+ foldi (fun _ f' -> NOT (IsProp, (NOT (IsProp, f')))) (Uint63.of_int (0)) i f
(** 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 **)
let build_hform t_atom build_var0 vm = function
| Form.Fatom h ->
(match build_formula t_atom vm h with
- | Some p -> let vm0,f0 = p in Some (vm0,(A f0))
+ | Some p -> let (vm0, f0) = p in Some (vm0, (A (IsProp, f0, Tt)))
| None -> None)
-| Form.Ftrue -> Some (vm,TT)
-| Form.Ffalse -> Some (vm,FF)
+| Form.Ftrue -> Some (vm, (TT IsProp))
+| Form.Ffalse -> Some (vm, (FF IsProp))
| Form.Fnot2 (i, l) ->
(match build_var0 vm (Lit.blit l) with
| Some p ->
- let vm0,f0 = p in
+ let (vm0, f0) = p in
let f' = build_not2 i f0 in
- let f'' = if Lit.is_pos l then f' else N f' in Some (vm0,f'')
+ let f'' = if Lit.is_pos l then f' else NOT (IsProp, f') in
+ Some (vm0, f'')
| None -> None)
| Form.Fand args ->
- let n0 = length args in
- if eqb0 n0 (ExtrNative.of_uint(0))
- then Some (vm,TT)
- else foldi (fun i f1 ->
- match f1 with
- | Some y ->
- let vm',f1' = y in
- let l = get args i in
- (match build_var0 vm' (Lit.blit l) with
- | Some p ->
- let vm2,f2 = p in
- let f2' = if Lit.is_pos l then f2 else N f2 in
- Some (vm2,(Cj (f1', f2')))
- | None -> None)
- | None -> None) (ExtrNative.of_uint(1))
- (sub0 n0 (ExtrNative.of_uint(1)))
- (let l = get args (ExtrNative.of_uint(0)) in
- match build_var0 vm (Lit.blit l) with
- | Some p ->
- let vm',f0 = p in
- if Lit.is_pos l then Some (vm',f0) else Some (vm',(N f0))
- | None -> None)
+ afold_left (fun vm0 -> Some (vm0, (TT IsProp))) (fun a b vm0 ->
+ match a vm0 with
+ | Some p ->
+ let (vm1, f1) = p in
+ (match b vm1 with
+ | Some p2 -> let (vm2, f2) = p2 in Some (vm2, (AND (IsProp, f1, f2)))
+ | None -> None)
+ | None -> None)
+ (amap (fun l vm0 ->
+ match build_var0 vm0 (Lit.blit l) with
+ | Some p ->
+ let (vm', f0) = p in
+ Some (vm', (if Lit.is_pos l then f0 else NOT (IsProp, f0)))
+ | None -> None) args) vm
| Form.For args ->
- let n0 = length args in
- if eqb0 n0 (ExtrNative.of_uint(0))
- then Some (vm,FF)
- else foldi (fun i f1 ->
- match f1 with
- | Some y ->
- let vm',f1' = y in
- let l = get args i in
- (match build_var0 vm' (Lit.blit l) with
- | Some p ->
- let vm2,f2 = p in
- let f2' = if Lit.is_pos l then f2 else N f2 in
- Some (vm2,(D (f1', f2')))
- | None -> None)
- | None -> None) (ExtrNative.of_uint(1))
- (sub0 n0 (ExtrNative.of_uint(1)))
- (let l = get args (ExtrNative.of_uint(0)) in
- match build_var0 vm (Lit.blit l) with
- | Some p ->
- let vm',f0 = p in
- if Lit.is_pos l then Some (vm',f0) else Some (vm',(N f0))
- | None -> None)
+ afold_left (fun vm0 -> Some (vm0, (FF IsProp))) (fun a b vm0 ->
+ match a vm0 with
+ | Some p ->
+ let (vm1, f1) = p in
+ (match b vm1 with
+ | Some p2 -> let (vm2, f2) = p2 in Some (vm2, (OR (IsProp, f1, f2)))
+ | None -> None)
+ | None -> None)
+ (amap (fun l vm0 ->
+ match build_var0 vm0 (Lit.blit l) with
+ | Some p ->
+ let (vm', f0) = p in
+ Some (vm', (if Lit.is_pos l then f0 else NOT (IsProp, f0)))
+ | None -> None) args) vm
| Form.Fimp args ->
- let n0 = length args in
- if eqb0 n0 (ExtrNative.of_uint(0))
- then Some (vm,TT)
- else if leb0 n0 (ExtrNative.of_uint(1))
- then let l = get args (ExtrNative.of_uint(0)) in
- (match build_var0 vm (Lit.blit l) with
- | Some p ->
- let vm',f0 = p in
- if Lit.is_pos l then Some (vm',f0) else Some (vm',(N f0))
- | None -> None)
- else foldi_down (fun i f1 ->
- match f1 with
- | Some y ->
- let vm',f1' = y in
- let l = get args i in
- (match build_var0 vm' (Lit.blit l) with
- | Some p ->
- let vm2,f2 = p in
- let f2' = if Lit.is_pos l then f2 else N f2 in
- Some (vm2,(I (f2', f1')))
- | None -> None)
- | None -> None) (sub0 n0 (ExtrNative.of_uint(2)))
- (ExtrNative.of_uint(0))
- (let l = get args (sub0 n0 (ExtrNative.of_uint(1))) in
- match build_var0 vm (Lit.blit l) with
- | Some p ->
- let vm',f0 = p in
- if Lit.is_pos l then Some (vm',f0) else Some (vm',(N f0))
- | None -> None)
+ afold_right (fun vm0 -> Some (vm0, (TT IsProp))) (fun a b vm0 ->
+ match b vm0 with
+ | Some p ->
+ let (vm2, f2) = p in
+ (match a vm2 with
+ | Some p2 ->
+ let (vm1, f1) = p2 in Some (vm1, (IMPL (IsProp, f1, None, f2)))
+ | None -> None)
+ | None -> None)
+ (amap (fun l vm0 ->
+ match build_var0 vm0 (Lit.blit l) with
+ | Some p ->
+ let (vm', f0) = p in
+ Some (vm', (if Lit.is_pos l then f0 else NOT (IsProp, f0)))
+ | None -> None) args) vm
| Form.Fxor (a, b) ->
(match build_var0 vm (Lit.blit a) with
| Some p ->
- let vm1,f1 = p in
+ let (vm1, f1) = p in
(match build_var0 vm1 (Lit.blit b) with
| Some p2 ->
- let vm2,f2 = p2 in
- let f1' = if Lit.is_pos a then f1 else N f1 in
- let f2' = if Lit.is_pos b then f2 else N f2 in
- Some (vm2,(Cj ((D (f1', f2')), (D ((N f1'), (N f2'))))))
+ let (vm2, f2) = p2 in
+ let f1' = if Lit.is_pos a then f1 else NOT (IsProp, f1) in
+ let f2' = if Lit.is_pos b then f2 else NOT (IsProp, f2) in
+ Some (vm2, (AND (IsProp, (OR (IsProp, f1', f2')), (OR (IsProp, (NOT
+ (IsProp, f1')), (NOT (IsProp, f2')))))))
| None -> None)
| None -> None)
| Form.Fiff (a, b) ->
(match build_var0 vm (Lit.blit a) with
| Some p ->
- let vm1,f1 = p in
+ let (vm1, f1) = p in
(match build_var0 vm1 (Lit.blit b) with
| Some p2 ->
- let vm2,f2 = p2 in
- let f1' = if Lit.is_pos a then f1 else N f1 in
- let f2' = if Lit.is_pos b then f2 else N f2 in
- Some (vm2,(Cj ((D (f1', (N f2'))), (D ((N f1'), f2')))))
+ let (vm2, f2) = p2 in
+ let f1' = if Lit.is_pos a then f1 else NOT (IsProp, f1) in
+ let f2' = if Lit.is_pos b then f2 else NOT (IsProp, f2) in
+ Some (vm2, (AND (IsProp, (OR (IsProp, f1', (NOT (IsProp, f2')))), (OR
+ (IsProp, (NOT (IsProp, f1')), f2')))))
| None -> None)
| None -> None)
| Form.Fite (a, b, c) ->
(match build_var0 vm (Lit.blit a) with
| Some p ->
- let vm1,f1 = p in
+ let (vm1, f1) = p in
(match build_var0 vm1 (Lit.blit b) with
| Some p2 ->
- let vm2,f2 = p2 in
+ let (vm2, f2) = p2 in
(match build_var0 vm2 (Lit.blit c) with
| Some p3 ->
- let vm3,f3 = p3 in
- let f1' = if Lit.is_pos a then f1 else N f1 in
- let f2' = if Lit.is_pos b then f2 else N f2 in
- let f3' = if Lit.is_pos c then f3 else N f3 in
- Some (vm3,(D ((Cj (f1', f2')), (Cj ((N f1'), f3')))))
+ let (vm3, f3) = p3 in
+ let f1' = if Lit.is_pos a then f1 else NOT (IsProp, f1) in
+ let f2' = if Lit.is_pos b then f2 else NOT (IsProp, f2) in
+ let f3' = if Lit.is_pos c then f3 else NOT (IsProp, f3) in
+ Some (vm3, (OR (IsProp, (AND (IsProp, f1', f2')), (AND (IsProp,
+ (NOT (IsProp, f1')), f3')))))
| None -> None)
| None -> None)
| None -> None)
+| Form.FbbT (_, _) -> None
(** val build_var :
- Form.form array -> Atom.atom array -> vmap -> int -> (vmap*z formula
- bFormula) option **)
+ Form.form array -> Atom.atom array -> vmap -> Uint63.t -> (vmap * z
+ formula bFormula) option **)
let build_var t_form t_atom =
- foldi_down_cont (fun i cont vm h ->
- build_hform t_atom cont vm (get t_form h)) (length t_form)
- (ExtrNative.of_uint(0)) (fun x x0 -> None)
+ foldi (fun _ cont vm h -> build_hform t_atom cont vm (get t_form h))
+ (Uint63.of_int (0)) (length0 t_form) (fun _ _ -> None)
(** val build_form :
- Form.form array -> Atom.atom array -> vmap -> Form.form -> (vmap*z
+ Form.form array -> Atom.atom array -> vmap -> Form.form -> (vmap * z
formula bFormula) option **)
let build_form t_form t_atom =
build_hform t_atom (build_var t_form t_atom)
(** val build_nlit :
- Form.form array -> Atom.atom array -> vmap -> int -> (vmap*z formula
- bFormula) option **)
+ Form.form array -> Atom.atom array -> vmap -> Uint63.t -> (vmap * z
+ formula bFormula) option **)
let build_nlit t_form t_atom vm l =
let l0 = Lit.neg l in
(match build_form t_form t_atom vm (get t_form (Lit.blit l0)) with
| Some p ->
- let vm0,f = p in
- let f0 = if Lit.is_pos l0 then f else N f in Some (vm0,f0)
+ let (vm0, f) = p in
+ let f0 = if Lit.is_pos l0 then f else NOT (IsProp, f) in Some (vm0, f0)
| None -> None)
(** 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 **)
let rec build_clause_aux t_form t_atom vm = function
| Nil -> None
| Cons (l, cl0) ->
(match cl0 with
| Nil -> build_nlit t_form t_atom vm l
- | Cons (i, l0) ->
+ | Cons (_, _) ->
(match build_nlit t_form t_atom vm l with
| Some p ->
- let vm0,bf1 = p in
+ let (vm0, bf1) = p in
(match build_clause_aux t_form t_atom vm0 cl0 with
- | Some p2 -> let vm1,bf2 = p2 in Some (vm1,(Cj (bf1, bf2)))
+ | Some p2 ->
+ let (vm1, bf2) = p2 in Some (vm1, (AND (IsProp, bf1, bf2)))
| None -> None)
| None -> None))
(** 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 **)
let build_clause t_form t_atom vm cl =
match build_clause_aux t_form t_atom vm cl with
- | Some p -> let vm0,bf = p in Some (vm0,(I (bf, FF)))
+ | Some p ->
+ let (vm0, bf) = p in Some (vm0, (IMPL (IsProp, bf, None, (FF IsProp))))
| None -> None
(** 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 **)
let get_eq0 t_form t_atom l f =
if Lit.is_pos l
@@ -6007,14 +5002,15 @@ let get_eq0 t_form t_atom l f =
(match get t_atom xa with
| Atom.Abop (b0, a, b) ->
(match b0 with
- | Atom.BO_eq t0 -> f a b
+ | Atom.BO_eq _ -> f a b
| _ -> C._true)
| _ -> C._true)
| _ -> C._true)
else C._true
(** 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 **)
let get_not_le t_form t_atom l f =
if negb (Lit.is_pos l)
@@ -6030,22 +5026,24 @@ let get_not_le t_form t_atom l f =
else C._true
(** 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 **)
let check_micromega t_form t_atom cl c =
match build_clause t_form t_atom empty_vmap cl with
- | Some p -> let v,bf = p in if zTautoChecker bf c then cl else C._true
+ | Some p -> let (_, bf) = p in if zTautoChecker bf c then cl else C._true
| None -> C._true
-(** 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 **)
let check_diseq t_form t_atom l =
match get t_form (Lit.blit l) with
| Form.For a ->
- if eqb0 (length a) (ExtrNative.of_uint(3))
- then let a_eq_b = get a (ExtrNative.of_uint(0)) in
- let not_a_le_b = get a (ExtrNative.of_uint(1)) in
- let not_b_le_a = get a (ExtrNative.of_uint(2)) in
+ if eqb0 (length0 a) (Uint63.of_int (3))
+ then let a_eq_b = get a (Uint63.of_int (0)) in
+ let not_a_le_b = get a (Uint63.of_int (1)) in
+ let not_b_le_a = get a (Uint63.of_int (2)) in
get_eq0 t_form t_atom a_eq_b (fun a0 b ->
get_not_le t_form t_atom not_a_le_b (fun a' b' ->
get_not_le t_form t_atom not_b_le_a (fun b'' a'' ->
@@ -6066,7 +5064,8 @@ let check_diseq t_form t_atom l =
| _ -> C._true
(** 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 **)
let check_atom_aux t_atom check_hatom0 a b =
match a with
@@ -6168,8 +5167,24 @@ let check_atom_aux t_atom check_hatom0 a b =
then check_hatom0 a2 b1
else false
else false
- | _ -> false))
+ | _ -> false)
+ | Atom.BO_BVand s1 ->
+ (match o2 with
+ | Atom.BO_BVand s2 ->
+ if if N.eqb s1 s2 then check_hatom0 a1 b1 else false
+ then check_hatom0 a2 b2
+ else false
+ | _ -> false)
+ | Atom.BO_BVor s1 ->
+ (match o2 with
+ | Atom.BO_BVor s2 ->
+ if if N.eqb s1 s2 then check_hatom0 a1 b1 else false
+ then check_hatom0 a2 b2
+ else false
+ | _ -> false)
+ | _ -> false)
| _ -> false)
+ | Atom.Atop (_, _, _, _) -> false
| Atom.Anop (o1, l1) ->
(match b with
| Atom.Anop (o2, l2) ->
@@ -6181,16 +5196,16 @@ let check_atom_aux t_atom check_hatom0 a b =
if eqb0 f1 f2 then list_beq check_hatom0 aargs bargs else false
| _ -> false)
-(** val check_hatom : Atom.atom array -> int -> int -> bool **)
+(** val check_hatom : Atom.atom array -> Uint63.t -> Uint63.t -> bool **)
let check_hatom t_atom h1 h2 =
- foldi_down_cont (fun x cont h3 h4 ->
+ foldi (fun _ cont h3 h4 ->
if eqb0 h3 h4
then true
else check_atom_aux t_atom cont (get t_atom h3) (get t_atom h4))
- (length t_atom) (ExtrNative.of_uint(0)) (fun h3 h4 -> false) h1 h2
+ (Uint63.of_int (0)) (length0 t_atom) (fun _ _ -> false) h1 h2
-(** val check_neg_hatom : Atom.atom array -> int -> int -> bool **)
+(** val check_neg_hatom : Atom.atom array -> Uint63.t -> Uint63.t -> bool **)
let check_neg_hatom t_atom h1 h2 =
match get t_atom h1 with
@@ -6246,14 +5261,14 @@ let check_neg_hatom t_atom h1 h2 =
| _ -> false)
| _ -> false
-(** val remove_not : Form.form array -> int -> int **)
+(** val remove_not : Form.form array -> Uint63.t -> Uint63.t **)
let remove_not t_form l =
match get t_form (Lit.blit l) with
- | Form.Fnot2 (i, l') -> if Lit.is_pos l then l' else Lit.neg l'
+ | Form.Fnot2 (_, l') -> if Lit.is_pos l then l' else Lit.neg l'
| _ -> l
-(** val get_and : Form.form array -> int -> int array option **)
+(** val get_and : Form.form array -> Uint63.t -> Uint63.t array option **)
let get_and t_form l =
let l0 = remove_not t_form l in
@@ -6263,7 +5278,7 @@ let get_and t_form l =
| _ -> None)
else None
-(** val get_or : Form.form array -> int -> int array option **)
+(** val get_or : Form.form array -> Uint63.t -> Uint63.t array option **)
let get_or t_form l =
let l0 = remove_not t_form l in
@@ -6274,42 +5289,48 @@ let get_or t_form l =
else None
(** 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 **)
let flatten_op_body get_op frec largs l =
match get_op l with
- | Some a -> fold_left frec largs a
+ | Some a ->
+ foldi (fun i x -> frec x (get a i)) (Uint63.of_int (0)) (length0 a) largs
| None -> Cons (l, largs)
(** 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 **)
let flatten_op_lit get_op max0 =
- foldi_cont (fun x -> flatten_op_body get_op) (ExtrNative.of_uint(0)) max0
+ foldi (fun _ -> flatten_op_body get_op) (Uint63.of_int (0)) max0
(fun largs l -> Cons (l, largs))
-(** val flatten_and : Form.form array -> int array -> int list **)
+(** val flatten_and : Form.form array -> Uint63.t array -> Uint63.t list **)
let flatten_and t_form t0 =
- fold_left (flatten_op_lit (get_and t_form) (length t_form)) Nil t0
+ foldi (fun i x ->
+ flatten_op_lit (get_and t_form) (length0 t_form) x (get t0 i))
+ (Uint63.of_int (0)) (length0 t0) Nil
-(** val flatten_or : Form.form array -> int array -> int list **)
+(** val flatten_or : Form.form array -> Uint63.t array -> Uint63.t list **)
let flatten_or t_form t0 =
- fold_left (flatten_op_lit (get_or t_form) (length t_form)) Nil t0
+ foldi (fun i x ->
+ flatten_op_lit (get_or t_form) (length0 t_form) x (get t0 i))
+ (Uint63.of_int (0)) (length0 t0) Nil
(** 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 **)
let check_flatten_body t_form check_atom0 check_neg_atom frec l lf =
let l0 = remove_not t_form l in
let lf0 = remove_not t_form lf in
if eqb0 l0 lf0
then true
- else if eqb0 (land0 (ExtrNative.of_uint(1)) (lxor0 l0 lf0))
- (ExtrNative.of_uint(0))
+ else if eqb0 (land0 (Uint63.of_int (1)) (lxor0 l0 lf0)) (Uint63.of_int (0))
then (match get t_form (Lit.blit l0) with
| Form.Fatom a1 ->
(match get t_form (Lit.blit lf0) with
@@ -6323,7 +5344,6 @@ let check_flatten_body t_form check_atom0 check_neg_atom frec l lf =
(match get t_form (Lit.blit lf0) with
| Form.Ffalse -> true
| _ -> false)
- | Form.Fnot2 (i, i0) -> false
| Form.Fand args1 ->
(match get t_form (Lit.blit lf0) with
| Form.Fand args2 ->
@@ -6341,8 +5361,8 @@ let check_flatten_body t_form check_atom0 check_neg_atom frec l lf =
| Form.Fimp args1 ->
(match get t_form (Lit.blit lf0) with
| Form.Fimp args2 ->
- if eqb0 (length args1) (length args2)
- then forallbi (fun i l1 -> frec l1 (get args2 i)) args1
+ if eqb0 (length0 args1) (length0 args2)
+ then aforallbi (fun i l1 -> frec l1 (get args2 i)) args1
else false
| _ -> false)
| Form.Fxor (l1, l2) ->
@@ -6361,7 +5381,8 @@ let check_flatten_body t_form check_atom0 check_neg_atom frec l lf =
if if frec l1 lf1 then frec l2 lf2 else false
then frec l3 lf3
else false
- | _ -> false))
+ | _ -> false)
+ | _ -> false)
else (match get t_form (Lit.blit l0) with
| Form.Fatom a1 ->
(match get t_form (Lit.blit lf0) with
@@ -6370,16 +5391,16 @@ let check_flatten_body t_form check_atom0 check_neg_atom frec l lf =
| _ -> false)
(** 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 **)
let check_flatten_aux t_form check_atom0 check_neg_atom l lf =
- foldi_cont (fun x -> check_flatten_body t_form check_atom0 check_neg_atom)
- (ExtrNative.of_uint(0)) (length t_form) (fun x x0 -> false) l lf
+ foldi (fun _ -> check_flatten_body t_form check_atom0 check_neg_atom)
+ (Uint63.of_int (0)) (length0 t_form) (fun _ _ -> false) l lf
(** 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 **)
let check_flatten t_form check_atom0 check_neg_atom s cid lf =
match S.get s cid with
@@ -6390,11 +5411,11 @@ let check_flatten t_form check_atom0 check_neg_atom s cid lf =
if check_flatten_aux t_form check_atom0 check_neg_atom l lf
then Cons (lf, Nil)
else C._true
- | Cons (i, l1) -> C._true)
+ | Cons (_, _) -> C._true)
(** 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 **)
let check_spl_arith t_form t_atom orig res l =
match orig with
@@ -6405,28 +5426,28 @@ let check_spl_arith t_form t_atom orig res l =
let cl = Cons ((Lit.neg li), (Cons (res, Nil))) in
(match build_clause t_form t_atom empty_vmap cl with
| Some p ->
- let v,bf = p in
+ let (_, bf) = p in
if zTautoChecker bf l then Cons (res, Nil) else C._true
| None -> C._true)
- | Cons (y, l1) -> C._true)
+ | Cons (_, _) -> C._true)
-(** val check_in : int -> int list -> bool **)
+(** val check_in : Uint63.t -> Uint63.t list -> bool **)
let rec check_in x = function
| Nil -> false
| Cons (t0, q) -> if eqb0 x t0 then true else check_in x q
(** 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 **)
let rec check_diseqs_complete_aux a dist t0 =
match dist with
| Nil -> true
| Cons (b, q) ->
- if existsb1 (fun x ->
+ if aexistsbi (fun _ x ->
match x with
| Some p ->
- let a',b' = p in
+ let (a', b') = p in
if if eqb0 a a' then eqb0 b b' else false
then true
else if eqb0 a b' then eqb0 b a' else false
@@ -6435,7 +5456,7 @@ let rec check_diseqs_complete_aux a dist t0 =
else false
(** val check_diseqs_complete :
- int list -> (int*int) option array -> bool **)
+ Uint63.t list -> (Uint63.t * Uint63.t) option array -> bool **)
let rec check_diseqs_complete dist t0 =
match dist with
@@ -6446,19 +5467,19 @@ let rec check_diseqs_complete dist t0 =
else false
(** 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 **)
let check_diseqs t_form t_atom ty dist diseq =
let t0 =
- mapi (fun x t0 ->
+ amap (fun t0 ->
if Lit.is_pos t0
then None
else (match get t_form (Lit.blit t0) with
| Form.Fatom a ->
(match get t_atom a with
- | Atom.Acop c -> None
- | Atom.Auop (u, i) -> None
+ | Atom.Acop _ -> None
+ | Atom.Auop (_, _) -> None
| Atom.Abop (b, h1, h2) ->
(match b with
| Atom.BO_Zplus -> None
@@ -6476,20 +5497,20 @@ let check_diseqs t_form t_atom ty dist diseq =
else false
then check_in h2 dist
else false
- then Some (h1,h2)
- else None)
+ then Some (h1, h2)
+ else None
+ | _ -> None)
| _ -> None)
| _ -> None)) diseq
in
- if forallb1 (fun x ->
- match x with
- | Some y -> true
- | None -> false) t0
+ if aforallbi (fun _ x -> match x with
+ | Some _ -> true
+ | None -> false) t0
then check_diseqs_complete dist t0
else false
(** 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 **)
let check_distinct t_form t_atom ha diseq =
match get t_atom ha with
@@ -6497,7 +5518,7 @@ let check_distinct t_form t_atom ha diseq =
| _ -> false
(** 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 **)
let check_distinct_two_args t_form t_atom f1 f2 =
match get t_form f1 with
@@ -6525,14 +5546,14 @@ let check_distinct_two_args t_form t_atom f1 f2 =
else false
| _ -> false)
| _ -> false)
- | Cons (i, l2) -> false)))
+ | Cons (_, _) -> false)))
| _ -> false)
| _ -> false)
| _ -> false
(** 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 **)
let check_lit t_form t_atom check_var l1 l2 =
if if eqb0 l1 l2
@@ -6546,8 +5567,8 @@ let check_lit t_form t_atom check_var l1 l2 =
else false
(** 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 **)
let check_form_aux t_form t_atom check_var a b =
match a with
@@ -6556,14 +5577,12 @@ let check_form_aux t_form t_atom check_var a b =
| Form.Fatom b0 -> eqb0 a0 b0
| Form.Fand diseq -> check_distinct t_form t_atom a0 diseq
| _ -> false)
- | Form.Ftrue ->
- (match b with
- | Form.Ftrue -> true
- | _ -> false)
- | Form.Ffalse ->
- (match b with
- | Form.Ffalse -> true
- | _ -> false)
+ | Form.Ftrue -> (match b with
+ | Form.Ftrue -> true
+ | _ -> false)
+ | Form.Ffalse -> (match b with
+ | Form.Ffalse -> true
+ | _ -> false)
| Form.Fnot2 (i1, l1) ->
(match b with
| Form.Fnot2 (i2, l2) ->
@@ -6572,24 +5591,24 @@ let check_form_aux t_form t_atom check_var a b =
| Form.Fand a1 ->
(match b with
| Form.Fand a2 ->
- if eqb0 (length a1) (length a2)
- then forallbi (fun i l ->
+ if eqb0 (length0 a1) (length0 a2)
+ then aforallbi (fun i l ->
check_lit t_form t_atom check_var l (get a2 i)) a1
else false
| _ -> false)
| Form.For a1 ->
(match b with
| Form.For a2 ->
- if eqb0 (length a1) (length a2)
- then forallbi (fun i l ->
+ if eqb0 (length0 a1) (length0 a2)
+ then aforallbi (fun i l ->
check_lit t_form t_atom check_var l (get a2 i)) a1
else false
| _ -> false)
| Form.Fimp a1 ->
(match b with
| Form.Fimp a2 ->
- if eqb0 (length a1) (length a2)
- then forallbi (fun i l ->
+ if eqb0 (length0 a1) (length0 a2)
+ then aforallbi (fun i l ->
check_lit t_form t_atom check_var l (get a2 i)) a1
else false
| _ -> false)
@@ -6616,25 +5635,27 @@ let check_form_aux t_form t_atom check_var a b =
then check_lit t_form t_atom check_var l3 j3
else false
| _ -> false)
+ | Form.FbbT (_, _) -> false
(** val check_hform :
- Form.form array -> Atom.atom array -> int -> int -> bool **)
+ Form.form array -> Atom.atom array -> Uint63.t -> Uint63.t -> bool **)
let check_hform t_form t_atom h1 h2 =
- foldi_down_cont (fun x cont h3 h4 ->
+ foldi (fun _ cont h3 h4 ->
if eqb0 h3 h4
then true
else check_form_aux t_form t_atom cont (get t_form h3) (get t_form h4))
- (length t_form) (ExtrNative.of_uint(0)) (fun h3 h4 -> false) h1 h2
+ (Uint63.of_int (0)) (length0 t_form) (fun _ _ -> false) h1 h2
(** val check_lit' :
- Form.form array -> Atom.atom array -> int -> int -> bool **)
+ Form.form array -> Atom.atom array -> Uint63.t -> Uint63.t -> bool **)
let check_lit' t_form t_atom =
check_lit t_form t_atom (check_hform t_form t_atom)
(** 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 **)
let rec check_distinct_elim t_form t_atom input res =
match input with
@@ -6644,99 +5665,1889 @@ let rec check_distinct_elim t_form t_atom input res =
then Cons (res, q)
else Cons (l, (check_distinct_elim t_form t_atom q res))
-type 'step _trace_ = 'step array array
+(** val or_of_imp : Uint63.t array -> Uint63.t array **)
+
+let or_of_imp args =
+ let last = sub0 (length0 args) (Uint63.of_int (1)) in
+ amapi (fun i l -> if eqb0 i last then l else Lit.neg l) args
+
+(** val check_True : C.t **)
+
+let check_True =
+ C._true
+
+(** val check_False : Uint63.t list **)
+
+let check_False =
+ Cons ((Lit.neg Lit._false), Nil)
+
+(** val check_BuildDef : Form.form array -> Uint63.t -> C.t **)
+
+let check_BuildDef t_form l =
+ match get t_form (Lit.blit l) with
+ | Form.Fand args ->
+ if Lit.is_pos l then Cons (l, (map Lit.neg (to_list args))) else C._true
+ | Form.For args ->
+ if Lit.is_pos l then C._true else Cons (l, (to_list args))
+ | Form.Fimp args ->
+ if Lit.is_pos l
+ then C._true
+ else if eqb0 (length0 args) (Uint63.of_int (0))
+ then C._true
+ else let args0 = or_of_imp args in Cons (l, (to_list args0))
+ | Form.Fxor (a, b) ->
+ if Lit.is_pos l
+ then Cons (l, (Cons (a, (Cons ((Lit.neg b), Nil)))))
+ else Cons (l, (Cons (a, (Cons (b, Nil)))))
+ | Form.Fiff (a, b) ->
+ if Lit.is_pos l
+ then Cons (l, (Cons ((Lit.neg a), (Cons ((Lit.neg b), Nil)))))
+ else Cons (l, (Cons (a, (Cons ((Lit.neg b), Nil)))))
+ | Form.Fite (a, _, c) ->
+ if Lit.is_pos l
+ then Cons (l, (Cons (a, (Cons ((Lit.neg c), Nil)))))
+ else Cons (l, (Cons (a, (Cons (c, Nil)))))
+ | _ -> C._true
+
+(** val check_ImmBuildDef : Form.form array -> S.t -> Uint63.t -> C.t **)
+
+let check_ImmBuildDef t_form s pos =
+ match S.get s pos with
+ | Nil -> C._true
+ | Cons (l, l0) ->
+ (match l0 with
+ | Nil ->
+ (match get t_form (Lit.blit l) with
+ | Form.Fand args ->
+ if Lit.is_pos l then C._true else map Lit.neg (to_list args)
+ | Form.For args -> if Lit.is_pos l then to_list args else C._true
+ | Form.Fimp args ->
+ if eqb0 (length0 args) (Uint63.of_int (0))
+ then C._true
+ else if Lit.is_pos l
+ then let args0 = or_of_imp args in to_list args0
+ else C._true
+ | Form.Fxor (a, b) ->
+ if Lit.is_pos l
+ then Cons (a, (Cons (b, Nil)))
+ else Cons (a, (Cons ((Lit.neg b), Nil)))
+ | Form.Fiff (a, b) ->
+ if Lit.is_pos l
+ then Cons (a, (Cons ((Lit.neg b), Nil)))
+ else Cons ((Lit.neg a), (Cons ((Lit.neg b), Nil)))
+ | Form.Fite (a, _, c) ->
+ if Lit.is_pos l
+ then Cons (a, (Cons (c, Nil)))
+ else Cons (a, (Cons ((Lit.neg c), Nil)))
+ | _ -> C._true)
+ | Cons (_, _) -> C._true)
+
+(** val check_BuildDef2 : Form.form array -> Uint63.t -> C.t **)
+
+let check_BuildDef2 t_form l =
+ match get t_form (Lit.blit l) with
+ | Form.Fxor (a, b) ->
+ if Lit.is_pos l
+ then Cons (l, (Cons ((Lit.neg a), (Cons (b, Nil)))))
+ else Cons (l, (Cons ((Lit.neg a), (Cons ((Lit.neg b), Nil)))))
+ | Form.Fiff (a, b) ->
+ if Lit.is_pos l
+ then Cons (l, (Cons (a, (Cons (b, Nil)))))
+ else Cons (l, (Cons ((Lit.neg a), (Cons (b, Nil)))))
+ | Form.Fite (a, b, _) ->
+ if Lit.is_pos l
+ then Cons (l, (Cons ((Lit.neg a), (Cons ((Lit.neg b), Nil)))))
+ else Cons (l, (Cons ((Lit.neg a), (Cons (b, Nil)))))
+ | _ -> C._true
+
+(** val check_ImmBuildDef2 : Form.form array -> S.t -> Uint63.t -> C.t **)
+
+let check_ImmBuildDef2 t_form s pos =
+ match S.get s pos with
+ | Nil -> C._true
+ | Cons (l, l0) ->
+ (match l0 with
+ | Nil ->
+ (match get t_form (Lit.blit l) with
+ | Form.Fxor (a, b) ->
+ if Lit.is_pos l
+ then Cons ((Lit.neg a), (Cons ((Lit.neg b), Nil)))
+ else Cons ((Lit.neg a), (Cons (b, Nil)))
+ | Form.Fiff (a, b) ->
+ if Lit.is_pos l
+ then Cons ((Lit.neg a), (Cons (b, Nil)))
+ else Cons (a, (Cons (b, Nil)))
+ | Form.Fite (a, b, _) ->
+ if Lit.is_pos l
+ then Cons ((Lit.neg a), (Cons (b, Nil)))
+ else Cons ((Lit.neg a), (Cons ((Lit.neg b), Nil)))
+ | _ -> C._true)
+ | Cons (_, _) -> C._true)
+
+(** val check_BuildProj : Form.form array -> Uint63.t -> Uint63.t -> C.t **)
+
+let check_BuildProj t_form l i =
+ let x = Lit.blit l in
+ (match get t_form x with
+ | Form.Fand args ->
+ if ltb0 i (length0 args)
+ then Cons ((Lit.nlit x), (Cons ((get args i), Nil)))
+ else C._true
+ | Form.For args ->
+ if ltb0 i (length0 args)
+ then Cons ((Lit.lit x), (Cons ((Lit.neg (get args i)), Nil)))
+ else C._true
+ | Form.Fimp args ->
+ let len = length0 args in
+ if ltb0 i len
+ then if eqb0 i (sub0 len (Uint63.of_int (1)))
+ then Cons ((Lit.lit x), (Cons ((Lit.neg (get args i)), Nil)))
+ else Cons ((Lit.lit x), (Cons ((get args i), Nil)))
+ else C._true
+ | _ -> C._true)
+
+(** val check_ImmBuildProj :
+ Form.form array -> S.t -> Uint63.t -> Uint63.t -> C.t **)
+
+let check_ImmBuildProj t_form s pos i =
+ match S.get s pos with
+ | Nil -> C._true
+ | Cons (l, l0) ->
+ (match l0 with
+ | Nil ->
+ let x = Lit.blit l in
+ (match get t_form x with
+ | Form.Fand args ->
+ if if ltb0 i (length0 args) then Lit.is_pos l else false
+ then Cons ((get args i), Nil)
+ else C._true
+ | Form.For args ->
+ if if ltb0 i (length0 args) then negb (Lit.is_pos l) else false
+ then Cons ((Lit.neg (get args i)), Nil)
+ else C._true
+ | Form.Fimp args ->
+ let len = length0 args in
+ if if ltb0 i len then negb (Lit.is_pos l) else false
+ then if eqb0 i (sub0 len (Uint63.of_int (1)))
+ then Cons ((Lit.neg (get args i)), Nil)
+ else Cons ((get args i), Nil)
+ else C._true
+ | _ -> C._true)
+ | Cons (_, _) -> C._true)
+
+(** val check_bbc : Form.form array -> bool list -> Uint63.t list -> bool **)
+
+let rec check_bbc t_form a_bv bs =
+ match a_bv with
+ | Nil -> (match bs with
+ | Nil -> true
+ | Cons (_, _) -> false)
+ | Cons (v, a_bv0) ->
+ (match bs with
+ | Nil -> false
+ | Cons (b, bs0) ->
+ if Lit.is_pos b
+ then (match get t_form (Lit.blit b) with
+ | Form.Ftrue -> if v then check_bbc t_form a_bv0 bs0 else false
+ | Form.Ffalse -> if v then false else check_bbc t_form a_bv0 bs0
+ | _ -> false)
+ else false)
+
+(** val check_bbConst :
+ Atom.atom array -> Form.form array -> Uint63.t -> C.t **)
+
+let check_bbConst t_atom t_form lres =
+ if Lit.is_pos lres
+ then (match get t_form (Lit.blit lres) with
+ | Form.FbbT (a, bs) ->
+ (match get t_atom a with
+ | Atom.Acop c ->
+ (match c with
+ | Atom.CO_BV (bv, n0) ->
+ if if check_bbc t_form bv bs
+ then N.eqb (N.of_nat (length bv)) n0
+ else false
+ then Cons (lres, Nil)
+ else C._true
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ else C._true
+
+(** val check_bb :
+ Atom.atom array -> Form.form array -> Uint63.t -> Uint63.t list -> nat ->
+ nat -> bool **)
+
+let rec check_bb t_atom t_form a bs i n0 =
+ match bs with
+ | Nil -> Nat.eqb i n0
+ | Cons (b, bs0) ->
+ if Lit.is_pos b
+ then (match get t_form (Lit.blit b) with
+ | Form.Fatom a' ->
+ (match get t_atom a' with
+ | Atom.Auop (u, a'0) ->
+ (match u with
+ | Atom.UO_BVbitOf (n1, p) ->
+ if if if eqb0 a a'0 then Nat.eqb i p else false
+ then Nat.eqb n0 (N.to_nat n1)
+ else false
+ then check_bb t_atom t_form a bs0 (S i) n0
+ else false
+ | _ -> false)
+ | _ -> false)
+ | _ -> false)
+ else false
+
+(** val check_bbVar :
+ Atom.atom array -> Form.form array -> Uint63.t -> C.t **)
+
+let check_bbVar t_atom t_form lres =
+ if Lit.is_pos lres
+ then (match get t_form (Lit.blit lres) with
+ | Form.FbbT (a, bs) ->
+ if check_bb t_atom t_form a bs O (length bs)
+ then Cons (lres, Nil)
+ else C._true
+ | _ -> C._true)
+ else C._true
+
+(** val check_not : Uint63.t list -> Uint63.t list -> bool **)
+
+let rec check_not bs br =
+ match bs with
+ | Nil -> (match br with
+ | Nil -> true
+ | Cons (_, _) -> false)
+ | Cons (b, bs0) ->
+ (match br with
+ | Nil -> false
+ | Cons (r, br0) ->
+ if eqb0 r (Lit.neg b) then check_not bs0 br0 else false)
+
+(** val check_bbNot :
+ Atom.atom array -> Form.form array -> S.t -> Uint63.t -> Uint63.t -> C.t **)
+
+let check_bbNot t_atom t_form s pos lres =
+ match S.get s pos with
+ | Nil -> C._true
+ | Cons (l, l0) ->
+ (match l0 with
+ | Nil ->
+ if if Lit.is_pos l then Lit.is_pos lres else false
+ then (match get t_form (Lit.blit l) with
+ | Form.FbbT (a, bs) ->
+ (match get t_form (Lit.blit lres) with
+ | Form.FbbT (r, br) ->
+ (match get t_atom r with
+ | Atom.Auop (u, a') ->
+ (match u with
+ | Atom.UO_BVnot n0 ->
+ if if if eqb0 a a' then check_not bs br else false
+ then N.eqb (N.of_nat (length bs)) n0
+ else false
+ then Cons (lres, Nil)
+ else C._true
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ else C._true
+ | Cons (_, _) -> C._true)
+
+(** val check_symopp :
+ Form.form array -> Uint63.t list -> Uint63.t list -> Uint63.t list ->
+ Atom.binop -> bool **)
+
+let rec check_symopp t_form bs1 bs2 bsres bvop =
+ match bs1 with
+ | Nil ->
+ (match bs2 with
+ | Nil -> (match bsres with
+ | Nil -> true
+ | Cons (_, _) -> false)
+ | Cons (_, _) -> false)
+ | Cons (b1, bs3) ->
+ (match bs2 with
+ | Nil -> false
+ | Cons (b2, bs4) ->
+ (match bsres with
+ | Nil -> false
+ | Cons (bres, bsres0) ->
+ if Lit.is_pos bres
+ then (match get t_form (Lit.blit bres) with
+ | Form.Fand args ->
+ (match bvop with
+ | Atom.BO_BVand n0 ->
+ let ires =
+ if eqb0 (length0 args) (Uint63.of_int (2))
+ then let a1 = get args (Uint63.of_int (0)) in
+ let a2 = get args (Uint63.of_int (1)) in
+ if if eqb0 a1 b1 then eqb0 a2 b2 else false
+ then true
+ else if eqb0 a1 b2 then eqb0 a2 b1 else false
+ else false
+ in
+ let bvop0 = Atom.BO_BVand (N.sub n0 (Npos XH)) in
+ if ires
+ then check_symopp t_form bs3 bs4 bsres0 bvop0
+ else false
+ | _ ->
+ let ires = false in
+ if ires
+ then check_symopp t_form bs3 bs4 bsres0 bvop
+ else false)
+ | Form.For args ->
+ (match bvop with
+ | Atom.BO_BVor n0 ->
+ let ires =
+ if eqb0 (length0 args) (Uint63.of_int (2))
+ then let a1 = get args (Uint63.of_int (0)) in
+ let a2 = get args (Uint63.of_int (1)) in
+ if if eqb0 a1 b1 then eqb0 a2 b2 else false
+ then true
+ else if eqb0 a1 b2 then eqb0 a2 b1 else false
+ else false
+ in
+ let bvop0 = Atom.BO_BVor (N.sub n0 (Npos XH)) in
+ if ires
+ then check_symopp t_form bs3 bs4 bsres0 bvop0
+ else false
+ | _ ->
+ let ires = false in
+ if ires
+ then check_symopp t_form bs3 bs4 bsres0 bvop
+ else false)
+ | Form.Fxor (a1, a2) ->
+ (match bvop with
+ | Atom.BO_BVxor n0 ->
+ let ires =
+ if if eqb0 a1 b1 then eqb0 a2 b2 else false
+ then true
+ else if eqb0 a1 b2 then eqb0 a2 b1 else false
+ in
+ let bvop0 = Atom.BO_BVxor (N.sub n0 (Npos XH)) in
+ if ires
+ then check_symopp t_form bs3 bs4 bsres0 bvop0
+ else false
+ | _ ->
+ let ires = false in
+ if ires
+ then check_symopp t_form bs3 bs4 bsres0 bvop
+ else false)
+ | Form.Fiff (a1, a2) ->
+ (match bvop with
+ | Atom.BO_eq t0 ->
+ (match t0 with
+ | Typ.TBV n0 ->
+ let ires =
+ if if eqb0 a1 b1 then eqb0 a2 b2 else false
+ then true
+ else if eqb0 a1 b2 then eqb0 a2 b1 else false
+ in
+ let bvop0 = Atom.BO_eq (Typ.TBV n0) in
+ if ires
+ then check_symopp t_form bs3 bs4 bsres0 bvop0
+ else false
+ | _ ->
+ let ires = false in
+ if ires
+ then check_symopp t_form bs3 bs4 bsres0 bvop
+ else false)
+ | _ ->
+ let ires = false in
+ if ires
+ then check_symopp t_form bs3 bs4 bsres0 bvop
+ else false)
+ | _ ->
+ let ires = false in
+ if ires
+ then check_symopp t_form bs3 bs4 bsres0 bvop
+ else false)
+ else false))
+
+(** val check_bbOp :
+ Atom.atom array -> Form.form array -> S.t -> Uint63.t -> Uint63.t ->
+ Uint63.t -> C.t **)
+
+let check_bbOp t_atom t_form s pos1 pos2 lres =
+ match S.get s pos1 with
+ | Nil -> C._true
+ | Cons (l1, l) ->
+ (match l with
+ | Nil ->
+ (match S.get s pos2 with
+ | Nil -> C._true
+ | Cons (l2, l0) ->
+ (match l0 with
+ | Nil ->
+ if if if Lit.is_pos l1 then Lit.is_pos l2 else false
+ then Lit.is_pos lres
+ else false
+ then (match get t_form (Lit.blit l1) with
+ | Form.FbbT (a1, bs1) ->
+ (match get t_form (Lit.blit l2) with
+ | Form.FbbT (a2, bs2) ->
+ (match get t_form (Lit.blit lres) with
+ | Form.FbbT (a, bsres) ->
+ (match get t_atom a with
+ | Atom.Abop (b, a1', a2') ->
+ (match b with
+ | Atom.BO_BVand n0 ->
+ if if if if if eqb0 a1 a1'
+ then eqb0 a2 a2'
+ else false
+ then true
+ else if eqb0 a1 a2'
+ then eqb0 a2 a1'
+ else false
+ then check_symopp t_form bs1 bs2 bsres
+ (Atom.BO_BVand n0)
+ else false
+ then N.eqb (N.of_nat (length bs1)) n0
+ else false
+ then Cons (lres, Nil)
+ else C._true
+ | Atom.BO_BVor n0 ->
+ if if if if if eqb0 a1 a1'
+ then eqb0 a2 a2'
+ else false
+ then true
+ else if eqb0 a1 a2'
+ then eqb0 a2 a1'
+ else false
+ then check_symopp t_form bs1 bs2 bsres
+ (Atom.BO_BVor n0)
+ else false
+ then N.eqb (N.of_nat (length bs1)) n0
+ else false
+ then Cons (lres, Nil)
+ else C._true
+ | Atom.BO_BVxor n0 ->
+ if if if if if eqb0 a1 a1'
+ then eqb0 a2 a2'
+ else false
+ then true
+ else if eqb0 a1 a2'
+ then eqb0 a2 a1'
+ else false
+ then check_symopp t_form bs1 bs2 bsres
+ (Atom.BO_BVxor n0)
+ else false
+ then N.eqb (N.of_nat (length bs1)) n0
+ else false
+ then Cons (lres, Nil)
+ else C._true
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ else C._true
+ | Cons (_, _) -> C._true))
+ | Cons (_, _) -> C._true)
+
+(** val check_eq :
+ Form.form array -> Uint63.t list -> Uint63.t list -> Uint63.t list -> bool **)
+
+let rec check_eq t_form bs1 bs2 bsres =
+ match bs1 with
+ | Nil ->
+ (match bs2 with
+ | Nil -> (match bsres with
+ | Nil -> true
+ | Cons (_, _) -> false)
+ | Cons (_, _) -> false)
+ | Cons (b1, bs3) ->
+ (match bs2 with
+ | Nil -> false
+ | Cons (b2, bs4) ->
+ (match bsres with
+ | Nil -> false
+ | Cons (bres, bsres0) ->
+ (match bs3 with
+ | Nil ->
+ if Lit.is_pos bres
+ then let ires =
+ match get t_form (Lit.blit bres) with
+ | Form.Fiff (a1, a2) ->
+ if if eqb0 a1 b1 then eqb0 a2 b2 else false
+ then true
+ else if eqb0 a1 b2 then eqb0 a2 b1 else false
+ | _ -> false
+ in
+ if ires then check_eq t_form bs3 bs4 bsres0 else false
+ else false
+ | Cons (_, _) ->
+ (match bs4 with
+ | Nil ->
+ if Lit.is_pos bres
+ then let ires =
+ match get t_form (Lit.blit bres) with
+ | Form.Fiff (a1, a2) ->
+ if if eqb0 a1 b1 then eqb0 a2 b2 else false
+ then true
+ else if eqb0 a1 b2 then eqb0 a2 b1 else false
+ | _ -> false
+ in
+ if ires then check_eq t_form bs3 bs4 bsres0 else false
+ else false
+ | Cons (_, _) ->
+ (match bsres0 with
+ | Nil ->
+ if Lit.is_pos bres
+ then (match get t_form (Lit.blit bres) with
+ | Form.Fand args ->
+ (match to_list args with
+ | Nil -> false
+ | Cons (bres0, bsres1) ->
+ if Lit.is_pos bres0
+ then let ires =
+ match get t_form (Lit.blit bres0) with
+ | Form.Fiff (a1, a2) ->
+ if if eqb0 a1 b1
+ then eqb0 a2 b2
+ else false
+ then true
+ else if eqb0 a1 b2
+ then eqb0 a2 b1
+ else false
+ | _ -> false
+ in
+ if ires
+ then check_eq t_form bs3 bs4 bsres1
+ else false
+ else false)
+ | _ -> false)
+ else false
+ | Cons (_, _) ->
+ if Lit.is_pos bres
+ then let ires =
+ match get t_form (Lit.blit bres) with
+ | Form.Fiff (a1, a2) ->
+ if if eqb0 a1 b1 then eqb0 a2 b2 else false
+ then true
+ else if eqb0 a1 b2 then eqb0 a2 b1 else false
+ | _ -> false
+ in
+ if ires then check_eq t_form bs3 bs4 bsres0 else false
+ else false)))))
+
+(** val check_bbEq :
+ Atom.atom array -> Form.form array -> S.t -> Uint63.t -> Uint63.t ->
+ Uint63.t -> C.t **)
+
+let check_bbEq t_atom t_form s pos1 pos2 lres =
+ match S.get s pos1 with
+ | Nil -> C._true
+ | Cons (l1, l) ->
+ (match l with
+ | Nil ->
+ (match S.get s pos2 with
+ | Nil -> C._true
+ | Cons (l2, l0) ->
+ (match l0 with
+ | Nil ->
+ if if if Lit.is_pos l1 then Lit.is_pos l2 else false
+ then Lit.is_pos lres
+ else false
+ then (match get t_form (Lit.blit l1) with
+ | Form.FbbT (a1, bs1) ->
+ (match get t_form (Lit.blit l2) with
+ | Form.FbbT (a2, bs2) ->
+ (match get t_form (Lit.blit lres) with
+ | Form.Fiff (leq, lbb) ->
+ if eqb (Lit.is_pos leq) (Lit.is_pos lbb)
+ then (match get t_form (Lit.blit leq) with
+ | Form.Fatom a ->
+ (match get t_atom a with
+ | Atom.Abop (b, a1', a2') ->
+ (match b with
+ | Atom.BO_eq t0 ->
+ (match t0 with
+ | Typ.TBV n0 ->
+ if if if if if eqb0 a1 a1'
+ then eqb0 a2 a2'
+ else false
+ then true
+ else if eqb0 a1 a2'
+ then eqb0 a2 a1'
+ else false
+ then check_eq t_form bs1
+ bs2 (Cons (lbb, Nil))
+ else false
+ then N.eqb
+ (N.of_nat (length bs1))
+ n0
+ else false
+ then Cons (lres, Nil)
+ else C._true
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ else C._true
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ else C._true
+ | Cons (_, _) -> C._true))
+ | Cons (_, _) -> C._true)
+
+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 **)
+
+let rec eq_carry_lit t_form carry0 c =
+ if Lit.is_pos c
+ then (match carry0 with
+ | Clit l -> eqb0 l c
+ | Cand (c1, c2) ->
+ (match get t_form (Lit.blit c) with
+ | Form.Fand args ->
+ if eqb0 (length0 args) (Uint63.of_int (2))
+ then if eq_carry_lit t_form c1 (get args (Uint63.of_int (0)))
+ then eq_carry_lit t_form c2 (get args (Uint63.of_int (1)))
+ else false
+ else false
+ | _ -> false)
+ | Cxor (c1, c2) ->
+ (match get t_form (Lit.blit c) with
+ | Form.Fxor (a1, a2) ->
+ if eq_carry_lit t_form c1 a1
+ then eq_carry_lit t_form c2 a2
+ else false
+ | _ -> false)
+ | Cor (c1, c2) ->
+ (match get t_form (Lit.blit c) with
+ | Form.For args ->
+ if eqb0 (length0 args) (Uint63.of_int (2))
+ then if eq_carry_lit t_form c1 (get args (Uint63.of_int (0)))
+ then eq_carry_lit t_form c2 (get args (Uint63.of_int (1)))
+ else false
+ else false
+ | _ -> false)
+ | Ciff (c1, c2) ->
+ (match get t_form (Lit.blit c) with
+ | Form.Fiff (a1, a2) ->
+ if eq_carry_lit t_form c1 a1
+ then eq_carry_lit t_form c2 a2
+ else false
+ | _ -> false))
+ else (match carry0 with
+ | Clit l -> eqb0 l c
+ | _ -> false)
+
+(** val check_add :
+ Form.form array -> Uint63.t list -> Uint63.t list -> Uint63.t list ->
+ carry -> bool **)
+
+let rec check_add t_form bs1 bs2 bsres carry0 =
+ match bs1 with
+ | Nil ->
+ (match bs2 with
+ | Nil -> (match bsres with
+ | Nil -> true
+ | Cons (_, _) -> false)
+ | Cons (_, _) -> false)
+ | Cons (b1, bs3) ->
+ (match bs2 with
+ | Nil -> false
+ | Cons (b2, bs4) ->
+ (match bsres with
+ | Nil -> false
+ | Cons (bres, bsres0) ->
+ if Lit.is_pos bres
+ then (match get t_form (Lit.blit bres) with
+ | Form.Fxor (xab, c) ->
+ if Lit.is_pos xab
+ then (match get t_form (Lit.blit xab) with
+ | Form.Fxor (a1, a2) ->
+ let carry' = Cor ((Cand ((Clit b1), (Clit b2))),
+ (Cand ((Cxor ((Clit b1), (Clit b2))), carry0)))
+ in
+ if if if if eqb0 a1 b1 then eqb0 a2 b2 else false
+ then true
+ else if eqb0 a1 b2 then eqb0 a2 b1 else false
+ then eq_carry_lit t_form carry0 c
+ else false
+ then check_add t_form bs3 bs4 bsres0 carry'
+ else false
+ | _ -> false)
+ else false
+ | _ -> false)
+ else false))
+
+(** val check_bbAdd :
+ Atom.atom array -> Form.form array -> S.t -> Uint63.t -> Uint63.t ->
+ Uint63.t -> C.t **)
+
+let check_bbAdd t_atom t_form s pos1 pos2 lres =
+ match S.get s pos1 with
+ | Nil -> C._true
+ | Cons (l1, l) ->
+ (match l with
+ | Nil ->
+ (match S.get s pos2 with
+ | Nil -> C._true
+ | Cons (l2, l0) ->
+ (match l0 with
+ | Nil ->
+ if if if Lit.is_pos l1 then Lit.is_pos l2 else false
+ then Lit.is_pos lres
+ else false
+ then (match get t_form (Lit.blit l1) with
+ | Form.FbbT (a1, bs1) ->
+ (match get t_form (Lit.blit l2) with
+ | Form.FbbT (a2, bs2) ->
+ (match get t_form (Lit.blit lres) with
+ | Form.FbbT (a, bsres) ->
+ (match get t_atom a with
+ | Atom.Abop (b, a1', a2') ->
+ (match b with
+ | Atom.BO_BVadd n0 ->
+ if if if if if eqb0 a1 a1'
+ then eqb0 a2 a2'
+ else false
+ then true
+ else if eqb0 a1 a2'
+ then eqb0 a2 a1'
+ else false
+ then check_add t_form bs1 bs2 bsres
+ (Clit Lit._false)
+ else false
+ then N.eqb (N.of_nat (length bs1)) n0
+ else false
+ then Cons (lres, Nil)
+ else C._true
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ else C._true
+ | Cons (_, _) -> C._true))
+ | Cons (_, _) -> C._true)
+
+(** val check_neg :
+ Form.form array -> Uint63.t list -> Uint63.t list -> bool **)
+
+let check_neg t_form bs br =
+ let z0 = map (fun _ -> Lit._false) bs in
+ let nbs = map Lit.neg bs in check_add t_form nbs z0 br (Clit Lit._true)
+
+(** val check_bbNeg :
+ Atom.atom array -> Form.form array -> S.t -> Uint63.t -> Uint63.t -> C.t **)
+
+let check_bbNeg t_atom t_form s pos lres =
+ match S.get s pos with
+ | Nil -> C._true
+ | Cons (l, l0) ->
+ (match l0 with
+ | Nil ->
+ if if Lit.is_pos l then Lit.is_pos lres else false
+ then (match get t_form (Lit.blit l) with
+ | Form.FbbT (a, bs) ->
+ (match get t_form (Lit.blit lres) with
+ | Form.FbbT (r, br) ->
+ (match get t_atom r with
+ | Atom.Auop (u, a') ->
+ (match u with
+ | Atom.UO_BVneg n0 ->
+ if if if eqb0 a a'
+ then check_neg t_form bs br
+ else false
+ then N.eqb (N.of_nat (length bs)) n0
+ else false
+ then Cons (lres, Nil)
+ else C._true
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ else C._true
+ | Cons (_, _) -> C._true)
+
+(** val and_with_bit : Uint63.t list -> Uint63.t -> carry list **)
+
+let rec and_with_bit a bt =
+ match a with
+ | Nil -> Nil
+ | Cons (ai, a') ->
+ Cons ((Cand ((Clit bt), (Clit ai))), (and_with_bit a' bt))
+
+(** val mult_step_k_h :
+ carry list -> carry list -> carry -> z -> carry list **)
+
+let rec mult_step_k_h a b c k =
+ match a with
+ | Nil -> Nil
+ | Cons (ai, a') ->
+ (match b with
+ | Nil -> Cons (ai, (mult_step_k_h a' b c k))
+ | Cons (bi, b') ->
+ if Z.ltb (Z.sub k (Zpos XH)) Z0
+ then let carry_out = Cor ((Cand (ai, bi)), (Cand ((Cxor (ai, bi)), c)))
+ in
+ let curr = Cxor ((Cxor (ai, bi)), c) in
+ Cons (curr, (mult_step_k_h a' b' carry_out (Z.sub k (Zpos XH))))
+ else Cons (ai, (mult_step_k_h a' b c (Z.sub k (Zpos XH)))))
+
+(** val mult_step :
+ Uint63.t list -> Uint63.t list -> carry list -> nat -> nat -> carry list **)
+
+let rec mult_step a b res k k' =
+ let ak = firstn (S k') a in
+ let b' = and_with_bit ak (nth k b Lit._false) in
+ let res' = mult_step_k_h res b' (Clit Lit._false) (Z.of_nat k) in
+ (match k' with
+ | O -> res'
+ | S pk' -> mult_step a b res' (S k) pk')
+
+(** val bblast_bvmult :
+ Uint63.t list -> Uint63.t list -> nat -> carry list **)
+
+let bblast_bvmult a b n0 =
+ let res = and_with_bit a (nth O b Lit._false) in
+ (match n0 with
+ | O -> res
+ | S n1 -> (match n1 with
+ | O -> res
+ | S k -> mult_step a b res (S O) k))
+
+(** val check_mult :
+ Form.form array -> Uint63.t list -> Uint63.t list -> Uint63.t list -> bool **)
+
+let check_mult t_form bs1 bs2 bsres =
+ if Nat.eqb (length bs1) (length bs2)
+ then let bvm12 = bblast_bvmult bs1 bs2 (length bs1) in
+ forallb2 (eq_carry_lit t_form) bvm12 bsres
+ else false
+
+(** val check_bbMult :
+ Atom.atom array -> Form.form array -> S.t -> Uint63.t -> Uint63.t ->
+ Uint63.t -> C.t **)
+
+let check_bbMult t_atom t_form s pos1 pos2 lres =
+ match S.get s pos1 with
+ | Nil -> C._true
+ | Cons (l1, l) ->
+ (match l with
+ | Nil ->
+ (match S.get s pos2 with
+ | Nil -> C._true
+ | Cons (l2, l0) ->
+ (match l0 with
+ | Nil ->
+ if if if Lit.is_pos l1 then Lit.is_pos l2 else false
+ then Lit.is_pos lres
+ else false
+ then (match get t_form (Lit.blit l1) with
+ | Form.FbbT (a1, bs1) ->
+ (match get t_form (Lit.blit l2) with
+ | Form.FbbT (a2, bs2) ->
+ (match get t_form (Lit.blit lres) with
+ | Form.FbbT (a, bsres) ->
+ (match get t_atom a with
+ | Atom.Abop (b, a1', a2') ->
+ (match b with
+ | Atom.BO_BVmult n0 ->
+ if if if if eqb0 a1 a1'
+ then eqb0 a2 a2'
+ else false
+ then check_mult t_form bs1 bs2 bsres
+ else false
+ then N.eqb (N.of_nat (length bs1)) n0
+ else false
+ then Cons (lres, Nil)
+ else C._true
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ else C._true
+ | Cons (_, _) -> C._true))
+ | Cons (_, _) -> C._true)
+
+(** val ult_big_endian_lit_list : Uint63.t list -> Uint63.t list -> carry **)
+
+let rec ult_big_endian_lit_list bs1 bs2 =
+ match bs1 with
+ | Nil -> Clit Lit._false
+ | Cons (xi, x') ->
+ (match x' with
+ | Nil ->
+ (match bs2 with
+ | Nil -> Clit Lit._false
+ | Cons (yi, y') ->
+ (match y' with
+ | Nil -> Cand ((Clit (Lit.neg xi)), (Clit yi))
+ | Cons (_, _) ->
+ Cor ((Cand ((Ciff ((Clit xi), (Clit yi))),
+ (ult_big_endian_lit_list x' y'))), (Cand ((Clit (Lit.neg xi)),
+ (Clit yi))))))
+ | Cons (_, _) ->
+ (match bs2 with
+ | Nil -> Clit Lit._false
+ | Cons (yi, y') ->
+ Cor ((Cand ((Ciff ((Clit xi), (Clit yi))),
+ (ult_big_endian_lit_list x' y'))), (Cand ((Clit (Lit.neg xi)),
+ (Clit yi))))))
+
+(** val ult_lit_list : Uint63.t list -> Uint63.t list -> carry **)
+
+let ult_lit_list x y =
+ ult_big_endian_lit_list (rev x) (rev y)
+
+(** val check_ult :
+ Form.form array -> Uint63.t list -> Uint63.t list -> Uint63.t -> bool **)
+
+let check_ult t_form bs1 bs2 bsres =
+ if Lit.is_pos bsres
+ then eq_carry_lit t_form (ult_lit_list bs1 bs2) bsres
+ else false
+
+(** val check_bbUlt :
+ Atom.atom array -> Form.form array -> S.t -> Uint63.t -> Uint63.t ->
+ Uint63.t -> C.t **)
+
+let check_bbUlt t_atom t_form s pos1 pos2 lres =
+ match S.get s pos1 with
+ | Nil -> C._true
+ | Cons (l1, l) ->
+ (match l with
+ | Nil ->
+ (match S.get s pos2 with
+ | Nil -> C._true
+ | Cons (l2, l0) ->
+ (match l0 with
+ | Nil ->
+ if if if Lit.is_pos l1 then Lit.is_pos l2 else false
+ then Lit.is_pos lres
+ else false
+ then (match get t_form (Lit.blit l1) with
+ | Form.FbbT (a1, bs1) ->
+ (match get t_form (Lit.blit l2) with
+ | Form.FbbT (a2, bs2) ->
+ (match get t_form (Lit.blit lres) with
+ | Form.Fiff (llt, lbb) ->
+ if eqb (Lit.is_pos llt) (Lit.is_pos lbb)
+ then (match get t_form (Lit.blit llt) with
+ | Form.Fatom a ->
+ (match get t_atom a with
+ | Atom.Abop (b, a1', a2') ->
+ (match b with
+ | Atom.BO_BVult n0 ->
+ if if if if if eqb0 a1 a1'
+ then eqb0 a2 a2'
+ else false
+ then check_ult t_form bs1
+ bs2 lbb
+ else false
+ then N.eqb
+ (N.of_nat (length bs1))
+ n0
+ else false
+ then N.eqb
+ (N.of_nat (length bs2)) n0
+ else false
+ then Cons (lres, Nil)
+ else C._true
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ else C._true
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ else C._true
+ | Cons (_, _) -> C._true))
+ | Cons (_, _) -> C._true)
+
+(** val slt_big_endian_lit_list : Uint63.t list -> Uint63.t list -> carry **)
+
+let slt_big_endian_lit_list x y =
+ match x with
+ | Nil -> Clit Lit._false
+ | Cons (xi, x') ->
+ (match x' with
+ | Nil ->
+ (match y with
+ | Nil -> Clit Lit._false
+ | Cons (yi, y') ->
+ (match y' with
+ | Nil -> Cand ((Clit xi), (Clit (Lit.neg yi)))
+ | Cons (_, _) ->
+ Cor ((Cand ((Ciff ((Clit xi), (Clit yi))),
+ (ult_big_endian_lit_list x' y'))), (Cand ((Clit xi), (Clit
+ (Lit.neg yi)))))))
+ | Cons (_, _) ->
+ (match y with
+ | Nil -> Clit Lit._false
+ | Cons (yi, y') ->
+ Cor ((Cand ((Ciff ((Clit xi), (Clit yi))),
+ (ult_big_endian_lit_list x' y'))), (Cand ((Clit xi), (Clit
+ (Lit.neg yi)))))))
+
+(** val slt_lit_list : Uint63.t list -> Uint63.t list -> carry **)
+
+let slt_lit_list x y =
+ slt_big_endian_lit_list (rev x) (rev y)
+
+(** val check_slt :
+ Form.form array -> Uint63.t list -> Uint63.t list -> Uint63.t -> bool **)
+
+let check_slt t_form bs1 bs2 bsres =
+ if Lit.is_pos bsres
+ then eq_carry_lit t_form (slt_lit_list bs1 bs2) bsres
+ else false
+
+(** val check_bbSlt :
+ Atom.atom array -> Form.form array -> S.t -> Uint63.t -> Uint63.t ->
+ Uint63.t -> C.t **)
+
+let check_bbSlt t_atom t_form s pos1 pos2 lres =
+ match S.get s pos1 with
+ | Nil -> C._true
+ | Cons (l1, l) ->
+ (match l with
+ | Nil ->
+ (match S.get s pos2 with
+ | Nil -> C._true
+ | Cons (l2, l0) ->
+ (match l0 with
+ | Nil ->
+ if if if Lit.is_pos l1 then Lit.is_pos l2 else false
+ then Lit.is_pos lres
+ else false
+ then (match get t_form (Lit.blit l1) with
+ | Form.FbbT (a1, bs1) ->
+ (match get t_form (Lit.blit l2) with
+ | Form.FbbT (a2, bs2) ->
+ (match get t_form (Lit.blit lres) with
+ | Form.Fiff (llt, lbb) ->
+ if eqb (Lit.is_pos llt) (Lit.is_pos lbb)
+ then (match get t_form (Lit.blit llt) with
+ | Form.Fatom a ->
+ (match get t_atom a with
+ | Atom.Abop (b, a1', a2') ->
+ (match b with
+ | Atom.BO_BVslt n0 ->
+ if if if if if eqb0 a1 a1'
+ then eqb0 a2 a2'
+ else false
+ then check_slt t_form bs1
+ bs2 lbb
+ else false
+ then N.eqb
+ (N.of_nat (length bs1))
+ n0
+ else false
+ then N.eqb
+ (N.of_nat (length bs2)) n0
+ else false
+ then Cons (lres, Nil)
+ else C._true
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ else C._true
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ else C._true
+ | Cons (_, _) -> C._true))
+ | Cons (_, _) -> C._true)
+
+(** val lit_to_carry : Uint63.t list -> carry list **)
+
+let rec lit_to_carry = function
+| Nil -> Nil
+| Cons (xbs, xsbs) -> Cons ((Clit xbs), (lit_to_carry xsbs))
+
+(** val check_concat :
+ Form.form array -> Uint63.t list -> Uint63.t list -> Uint63.t list -> bool **)
+
+let check_concat t_form bs1 bs2 bsres =
+ forallb2 (eq_carry_lit t_form) (lit_to_carry (app bs2 bs1)) bsres
+
+(** val check_bbConcat :
+ Atom.atom array -> Form.form array -> S.t -> Uint63.t -> Uint63.t ->
+ Uint63.t -> C.t **)
+
+let check_bbConcat t_atom t_form s pos1 pos2 lres =
+ match S.get s pos1 with
+ | Nil -> C._true
+ | Cons (l1, l) ->
+ (match l with
+ | Nil ->
+ (match S.get s pos2 with
+ | Nil -> C._true
+ | Cons (l2, l0) ->
+ (match l0 with
+ | Nil ->
+ if if if Lit.is_pos l1 then Lit.is_pos l2 else false
+ then Lit.is_pos lres
+ else false
+ then (match get t_form (Lit.blit l1) with
+ | Form.FbbT (a1, bs1) ->
+ (match get t_form (Lit.blit l2) with
+ | Form.FbbT (a2, bs2) ->
+ (match get t_form (Lit.blit lres) with
+ | Form.FbbT (a, bsres) ->
+ (match get t_atom a with
+ | Atom.Abop (b, a1', a2') ->
+ (match b with
+ | Atom.BO_BVconcat (n0, m) ->
+ if if if if if eqb0 a1 a1'
+ then eqb0 a2 a2'
+ else false
+ then check_concat t_form bs1 bs2
+ bsres
+ else false
+ then N.eqb (N.of_nat (length bs1)) n0
+ else false
+ then N.eqb (N.of_nat (length bs2)) m
+ else false
+ then Cons (lres, Nil)
+ else C._true
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ else C._true
+ | Cons (_, _) -> C._true))
+ | Cons (_, _) -> C._true)
+
+(** val list_diseqb : bool list -> bool list -> bool **)
+
+let rec list_diseqb a b =
+ match a with
+ | Nil -> (match b with
+ | Nil -> false
+ | Cons (_, _) -> true)
+ | Cons (xa, xsa) ->
+ (match b with
+ | Nil -> true
+ | Cons (xb, xsb) ->
+ if eqb xa false
+ then if eqb xb false then list_diseqb xsa xsb else true
+ else if eqb xb true then list_diseqb xsa xsb else true)
+
+(** val check_bbDiseq :
+ Atom.atom array -> Form.form array -> Uint63.t -> C.t **)
+
+let check_bbDiseq t_atom t_form lres =
+ if negb (Lit.is_pos lres)
+ then (match get t_form (Lit.blit lres) with
+ | Form.Fatom f ->
+ (match get t_atom f with
+ | Atom.Abop (b0, a, b) ->
+ (match b0 with
+ | Atom.BO_eq t0 ->
+ (match t0 with
+ | Typ.TBV n0 ->
+ (match get t_atom a with
+ | Atom.Acop c ->
+ (match c with
+ | Atom.CO_BV (bv1, n1) ->
+ (match get t_atom b with
+ | Atom.Acop c0 ->
+ (match c0 with
+ | Atom.CO_BV (bv2, n2) ->
+ if if if if if list_diseqb bv1 bv2
+ then N.eqb (N.of_nat (length bv1))
+ n0
+ else false
+ then N.eqb (N.of_nat (length bv2)) n0
+ else false
+ then N.eqb n1 n0
+ else false
+ then N.eqb n2 n0
+ else false
+ then Cons (lres, Nil)
+ else C._true
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ else C._true
+
+(** val extract_lit : Uint63.t list -> nat -> nat -> Uint63.t list **)
+
+let rec extract_lit x i j =
+ match x with
+ | Nil -> Nil
+ | Cons (bx, x') ->
+ (match i with
+ | O -> (match j with
+ | O -> Nil
+ | S j' -> Cons (bx, (extract_lit x' i j')))
+ | S i' -> (match j with
+ | O -> Nil
+ | S j' -> extract_lit x' i' j'))
+
+(** val check_extract :
+ Form.form array -> Uint63.t list -> Uint63.t list -> n -> n -> bool **)
+
+let check_extract t_form bs bsres i j =
+ if N.ltb (N.of_nat (length bs)) j
+ then false
+ else forallb2 (eq_carry_lit t_form)
+ (lit_to_carry (extract_lit bs (N.to_nat i) (N.to_nat j))) bsres
+
+(** val check_bbExtract :
+ Atom.atom array -> Form.form array -> S.t -> Uint63.t -> Uint63.t -> C.t **)
+
+let check_bbExtract t_atom t_form s pos lres =
+ match S.get s pos with
+ | Nil -> C._true
+ | Cons (l1, l) ->
+ (match l with
+ | Nil ->
+ if if Lit.is_pos l1 then Lit.is_pos lres else false
+ then (match get t_form (Lit.blit l1) with
+ | Form.FbbT (a1, bs) ->
+ (match get t_form (Lit.blit lres) with
+ | Form.FbbT (a, bsres) ->
+ (match get t_atom a with
+ | Atom.Auop (u, a1') ->
+ (match u with
+ | Atom.UO_BVextr (i, n0, n1) ->
+ if if if if eqb0 a1 a1'
+ then check_extract t_form bs bsres i
+ (N.add n0 i)
+ else false
+ then N.eqb (N.of_nat (length bs)) n1
+ else false
+ then N.leb (N.add n0 i) n1
+ else false
+ then Cons (lres, Nil)
+ else C._true
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ else C._true
+ | Cons (_, _) -> C._true)
+
+(** val extend_lit : Uint63.t list -> nat -> Uint63.t -> Uint63.t list **)
+
+let rec extend_lit x i b =
+ match i with
+ | O -> x
+ | S i' -> Cons (b, (extend_lit x i' b))
+
+(** val zextend_lit : Uint63.t list -> nat -> Uint63.t list **)
+
+let zextend_lit x i =
+ extend_lit x i Lit._false
+
+(** val check_zextend :
+ Form.form array -> Uint63.t list -> Uint63.t list -> n -> bool **)
+
+let check_zextend t_form bs bsres i =
+ forallb2 (eq_carry_lit t_form) (lit_to_carry (zextend_lit bs (N.to_nat i)))
+ bsres
+
+(** val check_bbZextend :
+ Atom.atom array -> Form.form array -> S.t -> Uint63.t -> Uint63.t -> C.t **)
+
+let check_bbZextend t_atom t_form s pos lres =
+ match S.get s pos with
+ | Nil -> C._true
+ | Cons (l1, l) ->
+ (match l with
+ | Nil ->
+ if if Lit.is_pos l1 then Lit.is_pos lres else false
+ then (match get t_form (Lit.blit l1) with
+ | Form.FbbT (a1, bs) ->
+ (match get t_form (Lit.blit lres) with
+ | Form.FbbT (a, bsres) ->
+ (match get t_atom a with
+ | Atom.Auop (u, a1') ->
+ (match u with
+ | Atom.UO_BVzextn (n0, i) ->
+ if if if eqb0 a1 a1'
+ then check_zextend t_form bs bsres i
+ else false
+ then N.eqb (N.of_nat (length bs)) n0
+ else false
+ then Cons (lres, Nil)
+ else C._true
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ else C._true
+ | Cons (_, _) -> C._true)
+
+(** val mk_list_lit_false : nat -> Uint63.t list **)
+
+let rec mk_list_lit_false = function
+| O -> Nil
+| S t' -> Cons (Lit._false, (mk_list_lit_false t'))
+
+(** val sextend_lit : Uint63.t list -> nat -> Uint63.t list **)
+
+let sextend_lit x i =
+ match x with
+ | Nil -> mk_list_lit_false i
+ | Cons (xb, _) -> extend_lit x i xb
+
+(** val check_sextend :
+ Form.form array -> Uint63.t list -> Uint63.t list -> n -> bool **)
+
+let check_sextend t_form bs bsres i =
+ forallb2 (eq_carry_lit t_form) (lit_to_carry (sextend_lit bs (N.to_nat i)))
+ bsres
+
+(** val check_bbSextend :
+ Atom.atom array -> Form.form array -> S.t -> Uint63.t -> Uint63.t -> C.t **)
+
+let check_bbSextend t_atom t_form s pos lres =
+ match S.get s pos with
+ | Nil -> C._true
+ | Cons (l1, l) ->
+ (match l with
+ | Nil ->
+ if if Lit.is_pos l1 then Lit.is_pos lres else false
+ then (match get t_form (Lit.blit l1) with
+ | Form.FbbT (a1, bs) ->
+ (match get t_form (Lit.blit lres) with
+ | Form.FbbT (a, bsres) ->
+ (match get t_atom a with
+ | Atom.Auop (u, a1') ->
+ (match u with
+ | Atom.UO_BVsextn (n0, i) ->
+ if if if eqb0 a1 a1'
+ then check_sextend t_form bs bsres i
+ else false
+ then N.eqb (N.of_nat (length bs)) n0
+ else false
+ then Cons (lres, Nil)
+ else C._true
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ else C._true
+ | Cons (_, _) -> C._true)
+
+(** val _shl_lit_be : Uint63.t list -> Uint63.t list **)
+
+let _shl_lit_be a = match a with
+| Nil -> Nil
+| Cons (_, _) -> Cons (Lit._false, (removelast a))
+
+(** val nshl_lit_be : Uint63.t list -> nat -> Uint63.t list **)
+
+let rec nshl_lit_be a = function
+| O -> a
+| S n' -> nshl_lit_be (_shl_lit_be a) n'
+
+(** val shl_lit_be : Uint63.t list -> bool list -> Uint63.t list **)
+
+let shl_lit_be a b =
+ nshl_lit_be a (RAWBITVECTOR_LIST.list2nat_be b)
+
+(** val check_shl :
+ Form.form array -> Uint63.t list -> bool list -> Uint63.t list -> bool **)
+
+let check_shl t_form bs1 bs2 bsres =
+ if Nat.eqb (length bs1) (length bs2)
+ then forallb2 (eq_carry_lit t_form) (lit_to_carry (shl_lit_be bs1 bs2))
+ bsres
+ else false
+
+(** val check_bbShl :
+ Atom.atom array -> Form.form array -> S.t -> Uint63.t -> Uint63.t ->
+ Uint63.t -> C.t **)
+
+let check_bbShl t_atom t_form s pos1 pos2 lres =
+ match S.get s pos1 with
+ | Nil -> C._true
+ | Cons (l1, l) ->
+ (match l with
+ | Nil ->
+ (match S.get s pos2 with
+ | Nil -> C._true
+ | Cons (l2, l0) ->
+ (match l0 with
+ | Nil ->
+ if if if Lit.is_pos l1 then Lit.is_pos l2 else false
+ then Lit.is_pos lres
+ else false
+ then (match get t_form (Lit.blit l1) with
+ | Form.FbbT (a1, bs1) ->
+ (match get t_form (Lit.blit l2) with
+ | Form.Fatom a2 ->
+ (match get t_form (Lit.blit lres) with
+ | Form.FbbT (a, bsres) ->
+ (match get t_atom a with
+ | Atom.Abop (b, a1', a2') ->
+ (match b with
+ | Atom.BO_BVshl n0 ->
+ (match get t_atom a2 with
+ | Atom.Acop c ->
+ (match c with
+ | Atom.CO_BV (bv2, n2) ->
+ if if if if if if eqb0 a1 a1'
+ then eqb0 a2 a2'
+ else false
+ then check_shl t_form bs1
+ bv2 bsres
+ else false
+ then N.eqb
+ (N.of_nat (length bs1))
+ n0
+ else false
+ then N.eqb
+ (N.of_nat (length bv2)) n0
+ else false
+ then N.eqb n2 n0
+ else false
+ then Cons (lres, Nil)
+ else C._true
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ else C._true
+ | Cons (_, _) -> C._true))
+ | Cons (_, _) -> C._true)
+
+(** val _shr_lit_be : Uint63.t list -> Uint63.t list **)
+
+let _shr_lit_be = function
+| Nil -> Nil
+| Cons (_, xsa) -> app xsa (Cons (Lit._false, Nil))
+
+(** val nshr_lit_be : Uint63.t list -> nat -> Uint63.t list **)
+
+let rec nshr_lit_be a = function
+| O -> a
+| S n' -> nshr_lit_be (_shr_lit_be a) n'
+
+(** val shr_lit_be : Uint63.t list -> bool list -> Uint63.t list **)
+
+let shr_lit_be a b =
+ nshr_lit_be a (RAWBITVECTOR_LIST.list2nat_be b)
+
+(** val check_shr :
+ Form.form array -> Uint63.t list -> bool list -> Uint63.t list -> bool **)
+
+let check_shr t_form bs1 bs2 bsres =
+ if Nat.eqb (length bs1) (length bs2)
+ then forallb2 (eq_carry_lit t_form) (lit_to_carry (shr_lit_be bs1 bs2))
+ bsres
+ else false
+
+(** val check_bbShr :
+ Atom.atom array -> Form.form array -> S.t -> Uint63.t -> Uint63.t ->
+ Uint63.t -> C.t **)
+
+let check_bbShr t_atom t_form s pos1 pos2 lres =
+ match S.get s pos1 with
+ | Nil -> C._true
+ | Cons (l1, l) ->
+ (match l with
+ | Nil ->
+ (match S.get s pos2 with
+ | Nil -> C._true
+ | Cons (l2, l0) ->
+ (match l0 with
+ | Nil ->
+ if if if Lit.is_pos l1 then Lit.is_pos l2 else false
+ then Lit.is_pos lres
+ else false
+ then (match get t_form (Lit.blit l1) with
+ | Form.FbbT (a1, bs1) ->
+ (match get t_form (Lit.blit l2) with
+ | Form.Fatom a2 ->
+ (match get t_form (Lit.blit lres) with
+ | Form.FbbT (a, bsres) ->
+ (match get t_atom a with
+ | Atom.Abop (b, a1', a2') ->
+ (match b with
+ | Atom.BO_BVshr n0 ->
+ (match get t_atom a2 with
+ | Atom.Acop c ->
+ (match c with
+ | Atom.CO_BV (bv2, n2) ->
+ if if if if if if eqb0 a1 a1'
+ then eqb0 a2 a2'
+ else false
+ then check_shr t_form bs1
+ bv2 bsres
+ else false
+ then N.eqb
+ (N.of_nat (length bs1))
+ n0
+ else false
+ then N.eqb
+ (N.of_nat (length bv2)) n0
+ else false
+ then N.eqb n2 n0
+ else false
+ then Cons (lres, Nil)
+ else C._true
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ else C._true
+ | Cons (_, _) -> C._true))
+ | Cons (_, _) -> C._true)
+
+(** val check_roweq :
+ Form.form array -> Atom.atom array -> Uint63.t -> C.t **)
+
+let check_roweq t_form t_atom lres =
+ if Lit.is_pos lres
+ then (match get t_form (Lit.blit lres) with
+ | Form.Fatom a ->
+ (match get t_atom a with
+ | Atom.Abop (b, xa, v) ->
+ (match b with
+ | Atom.BO_eq te ->
+ (match get t_atom xa with
+ | Atom.Abop (b0, sa, i) ->
+ (match b0 with
+ | Atom.BO_select (ti1, te1) ->
+ (match get t_atom sa with
+ | Atom.Atop (t0, _, j, v2) ->
+ let Atom.TO_store (ti2, te2) = t0 in
+ if if if if if Typ.eqb ti1 ti2
+ then Typ.eqb te te1
+ else false
+ then Typ.eqb te te2
+ else false
+ then eqb0 i j
+ else false
+ then eqb0 v v2
+ else false
+ then Cons (lres, Nil)
+ else C._true
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ else C._true
+
+(** val store_of_me :
+ Atom.atom array -> Uint63.t -> Uint63.t ->
+ ((Typ.coq_type * Typ.coq_type) * Uint63.t) option **)
+
+let store_of_me t_atom a b =
+ match get t_atom b with
+ | Atom.Atop (t0, a', i, _) ->
+ let Atom.TO_store (ti, te) = t0 in
+ if eqb0 a' a then Some ((ti, te), i) else None
+ | _ -> None
+
+(** val check_rowneq :
+ Form.form array -> Atom.atom array -> Uint63.t list -> C.t **)
+
+let check_rowneq t_form t_atom cl = match cl with
+| Nil -> C._true
+| Cons (leqij, l) ->
+ (match l with
+ | Nil -> C._true
+ | Cons (leqrow, l0) ->
+ (match l0 with
+ | Nil ->
+ if if Lit.is_pos leqij then Lit.is_pos leqrow else false
+ then (match get t_form (Lit.blit leqij) with
+ | Form.Fatom eqij ->
+ (match get t_form (Lit.blit leqrow) with
+ | Form.Fatom eqrow ->
+ (match get t_atom eqij with
+ | Atom.Abop (b, i, j) ->
+ (match b with
+ | Atom.BO_eq ti ->
+ (match get t_atom eqrow with
+ | Atom.Abop (b0, xa, x) ->
+ (match b0 with
+ | Atom.BO_eq te ->
+ (match get t_atom xa with
+ | Atom.Abop (b1, sa, j1) ->
+ (match b1 with
+ | Atom.BO_select (ti1, te1) ->
+ (match get t_atom x with
+ | Atom.Abop (b2, sa2, j2) ->
+ (match b2 with
+ | Atom.BO_select (ti2, te2) ->
+ if if if if Typ.eqb ti ti1
+ then Typ.eqb ti ti2
+ else false
+ then Typ.eqb te te1
+ else false
+ then Typ.eqb te te2
+ else false
+ then (match store_of_me t_atom sa
+ sa2 with
+ | Some p ->
+ let (p2, i1) = p in
+ let (ti3, te3) = p2 in
+ (match store_of_me t_atom
+ sa2 sa with
+ | Some _ -> C._true
+ | None ->
+ if if if Typ.eqb ti ti3
+ then Typ.eqb te
+ te3
+ else false
+ then if if if
+ eqb0 i1 i
+ then
+ eqb0 j1 j
+ else false
+ then
+ eqb0 j2 j
+ else false
+ then true
+ else if
+ if
+ eqb0 i1 j
+ then
+ eqb0 j1 i
+ else false
+ then
+ eqb0 j2 i
+ else false
+ else false
+ then cl
+ else C._true)
+ | None ->
+ (match store_of_me t_atom
+ sa2 sa with
+ | Some p ->
+ let (p2, i1) = p in
+ let (ti3, te3) = p2 in
+ if if if Typ.eqb ti ti3
+ then Typ.eqb te
+ te3
+ else false
+ then if if if
+ eqb0 i1 i
+ then
+ eqb0 j1 j
+ else false
+ then
+ eqb0 j2 j
+ else false
+ then true
+ else if
+ if
+ eqb0 i1 j
+ then
+ eqb0 j1 i
+ else false
+ then
+ eqb0 j2 i
+ else false
+ else false
+ then cl
+ else C._true
+ | None -> C._true))
+ else C._true
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ else C._true
+ | Cons (_, _) -> C._true))
+
+(** val eq_sel_sym :
+ Atom.atom array -> Typ.coq_type -> Typ.coq_type -> Uint63.t -> Uint63.t
+ -> Uint63.t -> Uint63.t -> bool **)
+
+let eq_sel_sym t_atom ti te a b sela selb =
+ match get t_atom sela with
+ | Atom.Abop (b0, a', d1) ->
+ (match b0 with
+ | Atom.BO_select (ti1, te1) ->
+ (match get t_atom selb with
+ | Atom.Abop (b1, b', d2) ->
+ (match b1 with
+ | Atom.BO_select (ti2, te2) ->
+ if if if if if if if Typ.eqb ti ti1
+ then Typ.eqb ti ti2
+ else false
+ then Typ.eqb te te1
+ else false
+ then Typ.eqb te te2
+ else false
+ then eqb0 a a'
+ else false
+ then eqb0 b b'
+ else false
+ then eqb0 d1 d2
+ else false
+ then (match get t_atom d1 with
+ | Atom.Abop (b2, a3, b3) ->
+ (match b2 with
+ | Atom.BO_diffarray (ti3, te3) ->
+ if if if Typ.eqb ti ti3 then Typ.eqb te te3 else false
+ then eqb0 a3 a
+ else false
+ then eqb0 b3 b
+ else false
+ | _ -> false)
+ | _ -> false)
+ else false
+ | _ -> false)
+ | _ -> false)
+ | _ -> false)
+ | _ -> false
+
+(** val check_ext : Form.form array -> Atom.atom array -> Uint63.t -> C.t **)
+
+let check_ext t_form t_atom lres =
+ if Lit.is_pos lres
+ then (match get t_form (Lit.blit lres) with
+ | Form.For args ->
+ if eqb0 (length0 args) (Uint63.of_int (2))
+ then let l1 = get args (Uint63.of_int (0)) in
+ let l2 = get args (Uint63.of_int (1)) in
+ if if Lit.is_pos l1 then negb (Lit.is_pos l2) else false
+ then (match get t_form (Lit.blit l1) with
+ | Form.Fatom eqa ->
+ (match get t_form (Lit.blit l2) with
+ | Form.Fatom eqsel ->
+ (match get t_atom eqa with
+ | Atom.Abop (b0, a, b) ->
+ (match b0 with
+ | Atom.BO_eq t0 ->
+ (match t0 with
+ | Typ.TFArray (ti, te) ->
+ (match get t_atom eqsel with
+ | Atom.Abop (b1, sela, selb) ->
+ (match b1 with
+ | Atom.BO_eq te' ->
+ if if Typ.eqb te te'
+ then if eq_sel_sym t_atom ti te a
+ b sela selb
+ then true
+ else eq_sel_sym t_atom ti te
+ b a sela selb
+ else false
+ then Cons (lres, Nil)
+ else C._true
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ | _ -> C._true)
+ else C._true
+ else C._true
+ | _ -> C._true)
+ else C._true
+
+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 **)
let _checker_ check_step is_false0 s t0 confl =
- let s' = fold_left (fun s0 a -> fold_left check_step s0 a) s t0 in
- is_false0 (S.get s' confl)
+ let s' = fold_left check_step (fst t0) s in is_false0 (S.get s' confl)
+
+module Euf_Checker =
+ struct
+ (** val add_roots :
+ S.t -> Uint63.t array -> Uint63.t array option -> S.t **)
-module Euf_Checker =
- struct
+ let add_roots s d = function
+ | Some ur ->
+ foldi (fun i s0 ->
+ let c =
+ if ltb0 (get ur i) (length0 d)
+ then Cons ((get d (get ur i)), Nil)
+ else C._true
+ in
+ S.set_clause s0 i c) (Uint63.of_int (0)) (length0 ur) s
+ | None ->
+ foldi (fun i s0 -> S.set_clause s0 i (Cons ((get d i), Nil)))
+ (Uint63.of_int (0)) (length0 d) s
+ end
+
+module Checker_Ext =
+ struct
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 **)
-
- let step_rect f f0 f1 f2 f3 f4 f5 f6 f7 f8 f9 f10 f11 f12 f13 f14 f15 = function
- | Res (x, x0) -> f x x0
- | ImmFlatten (x, x0, x1) -> f0 x x0 x1
- | CTrue x -> f1 x
- | CFalse x -> f2 x
- | BuildDef (x, x0) -> f3 x x0
- | BuildDef2 (x, x0) -> f4 x x0
- | BuildProj (x, x0, x1) -> f5 x x0 x1
- | ImmBuildDef (x, x0) -> f6 x x0
- | ImmBuildDef2 (x, x0) -> f7 x x0
- | ImmBuildProj (x, x0, x1) -> f8 x x0 x1
- | EqTr (x, x0, x1) -> f9 x x0 x1
- | EqCgr (x, x0, x1) -> f10 x x0 x1
- | EqCgrP (x, x0, x1, x2) -> f11 x x0 x1 x2
- | LiaMicromega (x, x0, x1) -> f12 x x0 x1
- | LiaDiseq (x, x0) -> f13 x x0
- | SplArith (x, x0, x1, x2) -> f14 x x0 x1 x2
- | SplDistinctElim (x, x0, x1) -> f15 x x0 x1
-
- (** 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 **)
-
- let step_rec f f0 f1 f2 f3 f4 f5 f6 f7 f8 f9 f10 f11 f12 f13 f14 f15 = function
- | Res (x, x0) -> f x x0
- | ImmFlatten (x, x0, x1) -> f0 x x0 x1
- | CTrue x -> f1 x
- | CFalse x -> f2 x
- | BuildDef (x, x0) -> f3 x x0
- | BuildDef2 (x, x0) -> f4 x x0
- | BuildProj (x, x0, x1) -> f5 x x0 x1
- | ImmBuildDef (x, x0) -> f6 x x0
- | ImmBuildDef2 (x, x0) -> f7 x x0
- | ImmBuildProj (x, x0, x1) -> f8 x x0 x1
- | EqTr (x, x0, x1) -> f9 x x0 x1
- | EqCgr (x, x0, x1) -> f10 x x0 x1
- | EqCgrP (x, x0, x1, x2) -> f11 x x0 x1 x2
- | LiaMicromega (x, x0, x1) -> f12 x x0 x1
- | LiaDiseq (x, x0) -> f13 x x0
- | SplArith (x, x0, x1, x2) -> f14 x x0 x1 x2
- | SplDistinctElim (x, x0, x1) -> f15 x x0 x1
-
+ | 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 **)
-
+
let step_checker t_atom t_form s = function
| Res (pos, res) -> S.set_resolve s pos res
+ | Weaken (pos, cid, cl) -> S.set_weaken s pos cid cl
| ImmFlatten (pos, cid, lf) ->
S.set_clause s pos
(check_flatten t_form (check_hatom t_atom) (check_neg_hatom t_atom) s
@@ -6763,99 +7574,59 @@ module Euf_Checker =
S.set_clause s pos (check_spl_arith t_form t_atom (S.get s orig) res l)
| SplDistinctElim (pos, orig, res) ->
S.set_clause s pos (check_distinct_elim t_form t_atom (S.get s orig) res)
-
- (** val euf_checker :
+ | BBVar (pos, res) -> S.set_clause s pos (check_bbVar t_atom t_form res)
+ | BBConst (pos, res) -> S.set_clause s pos (check_bbConst t_atom t_form res)
+ | BBOp (pos, orig1, orig2, res) ->
+ S.set_clause s pos (check_bbOp t_atom t_form s orig1 orig2 res)
+ | BBNot (pos, orig, res) ->
+ S.set_clause s pos (check_bbNot t_atom t_form s orig res)
+ | BBNeg (pos, orig, res) ->
+ S.set_clause s pos (check_bbNeg t_atom t_form s orig res)
+ | BBAdd (pos, orig1, orig2, res) ->
+ S.set_clause s pos (check_bbAdd t_atom t_form s orig1 orig2 res)
+ | BBConcat (pos, orig1, orig2, res) ->
+ S.set_clause s pos (check_bbConcat t_atom t_form s orig1 orig2 res)
+ | BBMul (pos, orig1, orig2, res) ->
+ S.set_clause s pos (check_bbMult t_atom t_form s orig1 orig2 res)
+ | BBUlt (pos, orig1, orig2, res) ->
+ S.set_clause s pos (check_bbUlt t_atom t_form s orig1 orig2 res)
+ | BBSlt (pos, orig1, orig2, res) ->
+ S.set_clause s pos (check_bbSlt t_atom t_form s orig1 orig2 res)
+ | BBEq (pos, orig1, orig2, res) ->
+ S.set_clause s pos (check_bbEq t_atom t_form s orig1 orig2 res)
+ | BBDiseq (pos, res) -> S.set_clause s pos (check_bbDiseq t_atom t_form res)
+ | BBExtract (pos, orig, res) ->
+ S.set_clause s pos (check_bbExtract t_atom t_form s orig res)
+ | BBZextend (pos, orig, res) ->
+ S.set_clause s pos (check_bbZextend t_atom t_form s orig res)
+ | BBSextend (pos, orig, res) ->
+ S.set_clause s pos (check_bbSextend t_atom t_form s orig res)
+ | BBShl (pos, orig1, orig2, res) ->
+ S.set_clause s pos (check_bbShl t_atom t_form s orig1 orig2 res)
+ | BBShr (pos, orig1, orig2, res) ->
+ S.set_clause s pos (check_bbShr t_atom t_form s orig1 orig2 res)
+ | RowEq (pos, res) -> S.set_clause s pos (check_roweq t_form t_atom res)
+ | RowNeq (pos, cl) -> S.set_clause s pos (check_rowneq t_form t_atom cl)
+ | Ext (pos, res) -> S.set_clause s pos (check_ext t_form t_atom res)
+
+ (** val checker :
Atom.atom array -> Form.form array -> (C.t -> bool) -> S.t -> step
- _trace_ -> int -> bool **)
-
- let euf_checker t_atom t_form s t0 =
+ _trace_ -> Uint63.t -> bool **)
+
+ let checker t_atom t_form s t0 =
_checker_ (step_checker t_atom t_form) s t0
-
+
type certif =
- | Certif of int * step _trace_ * int
-
- (** val certif_rect :
- (int -> step _trace_ -> int -> 'a1) -> certif -> 'a1 **)
-
- let certif_rect f = function
- | Certif (x, x0, x1) -> f x x0 x1
-
- (** val certif_rec :
- (int -> step _trace_ -> int -> 'a1) -> certif -> 'a1 **)
-
- let certif_rec f = function
- | Certif (x, x0, x1) -> f x x0 x1
-
- (** val add_roots : S.t -> int array -> int array option -> S.t **)
-
- let add_roots s d = function
- | Some ur ->
- foldi_right (fun i c_index s0 ->
- let c =
- if ltb0 c_index (length d)
- then Cons ((get d c_index), Nil)
- else C._true
- in
- S.set_clause s0 i c) ur s
- | None -> foldi_right (fun i c s0 -> S.set_clause s0 i (Cons (c, Nil))) d s
-
- (** val valid :
- typ_eqb array -> Atom.tval array -> Atom.atom array -> Form.form array
- -> int array -> bool **)
-
- let valid t_i t_func t_atom t_form d =
- let rho =
- Form.interp_state_var (Atom.interp_form_hatom t_i t_func t_atom) t_form
- in
- afold_left true (fun b1 b2 -> if b1 then b2 else false) (Lit.interp rho)
- d
-
- (** val checker :
- typ_eqb array -> Atom.tval array -> Atom.atom array -> Form.form array
- -> int array -> int array option -> certif -> bool **)
-
- let checker t_i t_func t_atom t_form d used_roots = function
- | Certif (nclauses, t0, confl) ->
- if if if Form.check_form t_form then Atom.check_atom t_atom else false
- then Atom.wt t_i t_func t_atom
- else false
- then euf_checker t_atom t_form C.is_false
- (add_roots (S.make nclauses) d used_roots) t0 confl
- else false
-
- (** val checker_b :
- typ_eqb array -> Atom.tval array -> Atom.atom array -> Form.form array
- -> int -> bool -> certif -> bool **)
-
- let checker_b t_i t_func t_atom t_form l b c =
- let l0 = if b then Lit.neg l else l in
- let Certif (nclauses, x, x0) = c in
- checker t_i t_func t_atom t_form (make nclauses l0) None c
-
- (** val checker_eq :
- typ_eqb array -> Atom.tval array -> Atom.atom array -> Form.form array
- -> int -> int -> int -> certif -> bool **)
-
- let checker_eq t_i t_func t_atom t_form l1 l2 l c =
- if if negb (Lit.is_pos l)
- then (match get t_form (Lit.blit l) with
- | Form.Fiff (l1', l2') ->
- if eqb0 l1 l1' then eqb0 l2 l2' else false
- | _ -> false)
- else false
- then let Certif (nclauses, x, x0) = c in
- checker t_i t_func t_atom t_form (make nclauses l) None c
- else false
-
+ | 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 **)
+
let checker_ext t_atom t_form d used_roots = function
| Certif (nclauses, t0, confl) ->
if if Form.check_form t_form then Atom.check_atom t_atom else false
- then euf_checker t_atom t_form C.is_false
- (add_roots (S.make nclauses) d used_roots) t0 confl
+ then checker t_atom t_form C.is_false
+ (Euf_Checker.add_roots (S.make nclauses) d used_roots) t0 confl
else false
end
-
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
-
diff --git a/src/extraction/smtcoq.ml b/src/extraction/smtcoq.ml
index 5ba8ce0..f393822 100644
--- a/src/extraction/smtcoq.ml
+++ b/src/extraction/smtcoq.ml
@@ -10,17 +10,10 @@
(**************************************************************************)
-type solver = Zchaff | Verit
-
+open Smtcoq_extr
-let usage =
-"
-Usage: smtcoq [solver] problem trace
-Solver:
- -zchaff Uses the verifier for ZChaff (default); the problem must be a dimacs file, and the trace, ZChaff unsatisfiability trace
- -verit Uses the verifier for ZChaff; the problem must be a SMTLIB2 file, and the trace, veriT unsatisfiability trace
-"
+type solver = Zchaff | Verit
let string_of_solver = function
@@ -47,14 +40,32 @@ let run s pb trace =
with | _ -> Printf.printf "The verifier failed to check the trace :-(\n"
-
let _ =
- let (s,pb,trace) =
+ let usage_msg = "Usage: smtcoq [-verit|-zchaff] <problem> <trace>" in
+
+ let verit = ref true in
+ let input_files = ref [] in
+
+ let anon_fun filename =
+ input_files := filename::!input_files
+ in
+
+ let usage_verit = "Uses the verifier for veriT (default); the problem must be a SMTLIB2 file, and the trace, veriT unsatisfiability trace" in
+ let usage_zchaff = "Uses the verifier for ZChaff; the problem must be a dimacs file, and the trace, ZChaff unsatisfiability trace" in
+ let speclist =
+ [("-verit", Arg.Set verit, usage_verit);
+ ("-zchaff", Arg.Clear verit, usage_zchaff)]
+ in
+
+ Arg.parse speclist anon_fun usage_msg;
+
+ let s = if !verit then Verit else Zchaff in
+ let (pb, trace) =
try
- let s = if Sys.argv.(1) = "-verit" then Verit else Zchaff in
- let pb = Sys.argv.((Array.length Sys.argv)-2) in
- let trace = Sys.argv.((Array.length Sys.argv)-1) in
- (s,pb,trace)
+ match !input_files with
+ | [trace; pb] -> (pb, trace)
+ | _ -> assert false
with
- | _ -> Printf.printf "%s" usage; exit 0 in
+ | _ -> Arg.usage speclist usage_msg; exit 0
+ in
run s pb trace
diff --git a/src/extraction/smtcoq.mli b/src/extraction/smtcoq.mli
deleted file mode 100644
index bf62ec3..0000000
--- a/src/extraction/smtcoq.mli
+++ /dev/null
@@ -1,17 +0,0 @@
-(**************************************************************************)
-(* *)
-(* 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 solver = Zchaff | Verit
-val usage : string
-val string_of_solver : solver -> string
-val verifier_of_solver : solver -> string -> string -> bool
-val run : solver -> string -> string -> unit
diff --git a/src/extraction/test.ml b/src/extraction/test.ml
index 2444a23..459ca8f 100644
--- a/src/extraction/test.ml
+++ b/src/extraction/test.ml
@@ -10,45 +10,50 @@
(**************************************************************************)
-let _ = Printf.printf "Zchaff_checker.checker \"tests/sat1.cnf\" \"tests/sat1.zlog\" = %b\n" (Zchaff_checker.checker "tests/sat1.cnf" "tests/sat1.zlog")
-let _ = Printf.printf "Zchaff_checker.checker \"tests/sat2.cnf\" \"tests/sat2.zlog\" = %b\n" (Zchaff_checker.checker "tests/sat2.cnf" "tests/sat2.zlog")
-let _ = Printf.printf "Zchaff_checker.checker \"tests/sat3.cnf\" \"tests/sat3.zlog\" = %b\n" (Zchaff_checker.checker "tests/sat3.cnf" "tests/sat3.zlog")
-let _ = Printf.printf "Zchaff_checker.checker \"tests/sat5.cnf\" \"tests/sat5.zlog\" = %b\n" (Zchaff_checker.checker "tests/sat5.cnf" "tests/sat5.zlog")
-let _ = Printf.printf "Zchaff_checker.checker \"tests/sat6.cnf\" \"tests/sat6.zlog\" = %b\n" (Zchaff_checker.checker "tests/sat6.cnf" "tests/sat6.zlog")
-let _ = Printf.printf "Zchaff_checker.checker \"tests/sat7.cnf\" \"tests/sat7.zlog\" = %b\n" (Zchaff_checker.checker "tests/sat7.cnf" "tests/sat7.zlog")
-let _ = Printf.printf "Zchaff_checker.checker \"tests/hole4.cnf\" \"tests/hole4.zlog\" = %b\n" (Zchaff_checker.checker "tests/hole4.cnf" "tests/hole4.zlog")
-let _ = Printf.printf "Zchaff_checker.checker \"tests/cmu-bmc-barrel6.cnf\" \"tests/cmu-bmc-barrel6.zlog\" = %b\n" (Zchaff_checker.checker "tests/cmu-bmc-barrel6.cnf" "tests/cmu-bmc-barrel6.zlog")
-let _ = Printf.printf "Zchaff_checker.checker \"tests/velev-sss-1.0-05.cnf\" \"tests/velev-sss-1.0-05.zlog\" = %b\n" (Zchaff_checker.checker "tests/velev-sss-1.0-05.cnf" "tests/velev-sss-1.0-05.zlog")
-
-
-
-
-let _ = Printf.printf "Verit_checker.checker \"tests/sat1.smt2\" \"tests/sat1.vtlog\" = %b\n" (Verit_checker.checker "tests/sat1.smt2" "tests/sat1.vtlog")
-let _ = Printf.printf "Verit_checker.checker \"tests/sat2.smt2\" \"tests/sat2.vtlog\" = %b\n" (Verit_checker.checker "tests/sat2.smt2" "tests/sat2.vtlog")
-let _ = Printf.printf "Verit_checker.checker \"tests/sat3.smt2\" \"tests/sat3.vtlog\" = %b\n" (Verit_checker.checker "tests/sat3.smt2" "tests/sat3.vtlog")
-let _ = Printf.printf "Verit_checker.checker \"tests/sat4.smt2\" \"tests/sat4.vtlog\" = %b\n" (Verit_checker.checker "tests/sat4.smt2" "tests/sat4.vtlog")
-let _ = Printf.printf "Verit_checker.checker \"tests/sat5.smt2\" \"tests/sat5.vtlog\" = %b\n" (Verit_checker.checker "tests/sat5.smt2" "tests/sat5.vtlog")
-let _ = Printf.printf "Verit_checker.checker \"tests/sat6.smt2\" \"tests/sat6.vtlog\" = %b\n" (Verit_checker.checker "tests/sat6.smt2" "tests/sat6.vtlog")
-let _ = Printf.printf "Verit_checker.checker \"tests/sat7.smt2\" \"tests/sat7.vtlog\" = %b\n" (Verit_checker.checker "tests/sat7.smt2" "tests/sat7.vtlog")
-let _ = Printf.printf "Verit_checker.checker \"tests/sat8.smt2\" \"tests/sat8.vtlog\" = %b\n" (Verit_checker.checker "tests/sat8.smt2" "tests/sat8.vtlog")
-let _ = Printf.printf "Verit_checker.checker \"tests/sat9.smt2\" \"tests/sat9.vtlog\" = %b\n" (Verit_checker.checker "tests/sat9.smt2" "tests/sat9.vtlog")
-let _ = Printf.printf "Verit_checker.checker \"tests/sat11.smt2\" \"tests/sat11.vtlog\" = %b\n" (Verit_checker.checker "tests/sat11.smt2" "tests/sat11.vtlog")
-let _ = Printf.printf "Verit_checker.checker \"tests/sat12.smt2\" \"tests/sat12.vtlog\" = %b\n" (Verit_checker.checker "tests/sat12.smt2" "tests/sat12.vtlog")
-let _ = Printf.printf "Verit_checker.checker \"tests/sat13.smt2\" \"tests/sat13.vtlog\" = %b\n" (Verit_checker.checker "tests/sat13.smt2" "tests/sat13.vtlog")
-let _ = Printf.printf "Verit_checker.checker \"tests/hole4.smt2\" \"tests/hole4.vtlog\" = %b\n" (Verit_checker.checker "tests/hole4.smt2" "tests/hole4.vtlog")
-let _ = Printf.printf "Verit_checker.checker \"tests/uf1.smt2\" \"tests/uf1.vtlog\" = %b\n" (Verit_checker.checker "tests/uf1.smt2" "tests/uf1.vtlog")
-let _ = Printf.printf "Verit_checker.checker \"tests/uf2.smt2\" \"tests/uf2.vtlog\" = %b\n" (Verit_checker.checker "tests/uf2.smt2" "tests/uf2.vtlog")
-let _ = Printf.printf "Verit_checker.checker \"tests/uf3.smt2\" \"tests/uf3.vtlog\" = %b\n" (Verit_checker.checker "tests/uf3.smt2" "tests/uf3.vtlog")
-let _ = Printf.printf "Verit_checker.checker \"tests/uf4.smt2\" \"tests/uf4.vtlog\" = %b\n" (Verit_checker.checker "tests/uf4.smt2" "tests/uf4.vtlog")
-let _ = Printf.printf "Verit_checker.checker \"tests/uf5.smt2\" \"tests/uf5.vtlog\" = %b\n" (Verit_checker.checker "tests/uf5.smt2" "tests/uf5.vtlog")
-let _ = Printf.printf "Verit_checker.checker \"tests/uf6.smt2\" \"tests/uf6.vtlog\" = %b\n" (Verit_checker.checker "tests/uf6.smt2" "tests/uf6.vtlog")
-let _ = Printf.printf "Verit_checker.checker \"tests/uf7.smt2\" \"tests/uf7.vtlog\" = %b\n" (Verit_checker.checker "tests/uf7.smt2" "tests/uf7.vtlog")
-let _ = Printf.printf "Verit_checker.checker \"tests/lia1.smt2\" \"tests/lia1.vtlog\" = %b\n" (Verit_checker.checker "tests/lia1.smt2" "tests/lia1.vtlog")
-let _ = Printf.printf "Verit_checker.checker \"tests/lia2.smt2\" \"tests/lia2.vtlog\" = %b\n" (Verit_checker.checker "tests/lia2.smt2" "tests/lia2.vtlog")
-let _ = Printf.printf "Verit_checker.checker \"tests/lia3.smt2\" \"tests/lia3.vtlog\" = %b\n" (Verit_checker.checker "tests/lia3.smt2" "tests/lia3.vtlog")
-let _ = Printf.printf "Verit_checker.checker \"tests/lia4.smt2\" \"tests/lia4.vtlog\" = %b\n" (Verit_checker.checker "tests/lia4.smt2" "tests/lia4.vtlog")
-let _ = Printf.printf "Verit_checker.checker \"tests/lia5.smt2\" \"tests/lia5.vtlog\" = %b\n" (Verit_checker.checker "tests/lia5.smt2" "tests/lia5.vtlog")
-let _ = Printf.printf "Verit_checker.checker \"tests/lia6.smt2\" \"tests/lia6.vtlog\" = %b\n" (Verit_checker.checker "tests/lia6.smt2" "tests/lia6.vtlog")
-let _ = Printf.printf "Verit_checker.checker \"tests/lia7.smt2\" \"tests/lia7.vtlog\" = %b\n" (Verit_checker.checker "tests/lia7.smt2" "tests/lia7.vtlog")
-let _ = Printf.printf "Verit_checker.checker \"tests/let1.smt2\" \"tests/let1.vtlog\" = %b\n" (Verit_checker.checker "tests/let1.smt2" "tests/let1.vtlog")
-let _ = Printf.printf "Verit_checker.checker \"tests/let2.smt2\" \"tests/let2.vtlog\" = %b\n" (Verit_checker.checker "tests/let2.smt2" "tests/let2.vtlog")
+open Smtcoq_extr
+
+
+let _ = Printf.printf "Zchaff_checker.checker \"../../unit-tests/sat1.cnf\" \"../../unit-tests/sat1.zlog\" = %b\n" (Zchaff_checker.checker "../../unit-tests/sat1.cnf" "../../unit-tests/sat1.zlog")
+let _ = Printf.printf "Zchaff_checker.checker \"../../unit-tests/sat2.cnf\" \"../../unit-tests/sat2.zlog\" = %b\n" (Zchaff_checker.checker "../../unit-tests/sat2.cnf" "../../unit-tests/sat2.zlog")
+let _ = Printf.printf "Zchaff_checker.checker \"../../unit-tests/sat3.cnf\" \"../../unit-tests/sat3.zlog\" = %b\n" (Zchaff_checker.checker "../../unit-tests/sat3.cnf" "../../unit-tests/sat3.zlog")
+let _ = Printf.printf "Zchaff_checker.checker \"../../unit-tests/sat5.cnf\" \"../../unit-tests/sat5.zlog\" = %b\n" (Zchaff_checker.checker "../../unit-tests/sat5.cnf" "../../unit-tests/sat5.zlog")
+let _ = Printf.printf "Zchaff_checker.checker \"../../unit-tests/sat6.cnf\" \"../../unit-tests/sat6.zlog\" = %b\n" (Zchaff_checker.checker "../../unit-tests/sat6.cnf" "../../unit-tests/sat6.zlog")
+let _ = Printf.printf "Zchaff_checker.checker \"../../unit-tests/sat7.cnf\" \"../../unit-tests/sat7.zlog\" = %b\n" (Zchaff_checker.checker "../../unit-tests/sat7.cnf" "../../unit-tests/sat7.zlog")
+let _ = Printf.printf "Zchaff_checker.checker \"../../unit-tests/hole4.cnf\" \"../../unit-tests/hole4.zlog\" = %b\n" (Zchaff_checker.checker "../../unit-tests/hole4.cnf" "../../unit-tests/hole4.zlog")
+let _ = Printf.printf "Zchaff_checker.checker \"../../unit-tests/cmu-bmc-barrel6.cnf\" \"../../unit-tests/cmu-bmc-barrel6.zlog\" = %b\n" (Zchaff_checker.checker "../../unit-tests/cmu-bmc-barrel6.cnf" "../../unit-tests/cmu-bmc-barrel6.zlog")
+let _ = Printf.printf "Zchaff_checker.checker \"../../unit-tests/velev-sss-1.0-05.cnf\" \"../../unit-tests/velev-sss-1.0-05.zlog\" = %b\n" (Zchaff_checker.checker "../../unit-tests/velev-sss-1.0-05.cnf" "../../unit-tests/velev-sss-1.0-05.zlog")
+
+
+
+
+let _ = Printf.printf "Verit_checker.checker \"../../unit-tests/sat0.smt2\" \"../../unit-tests/sat0.vtlog\" = %b\n" (Verit_checker.checker "../../unit-tests/sat0.smt2" "../../unit-tests/sat0.vtlog")
+let _ = Printf.printf "Verit_checker.checker \"../../unit-tests/sat1.smt2\" \"../../unit-tests/sat1.vtlog\" = %b\n" (Verit_checker.checker "../../unit-tests/sat1.smt2" "../../unit-tests/sat1.vtlog")
+let _ = Printf.printf "Verit_checker.checker \"../../unit-tests/sat2.smt2\" \"../../unit-tests/sat2.vtlog\" = %b\n" (Verit_checker.checker "../../unit-tests/sat2.smt2" "../../unit-tests/sat2.vtlog")
+let _ = Printf.printf "Verit_checker.checker \"../../unit-tests/sat3.smt2\" \"../../unit-tests/sat3.vtlog\" = %b\n" (Verit_checker.checker "../../unit-tests/sat3.smt2" "../../unit-tests/sat3.vtlog")
+let _ = Printf.printf "Verit_checker.checker \"../../unit-tests/sat4.smt2\" \"../../unit-tests/sat4.vtlog\" = %b\n" (Verit_checker.checker "../../unit-tests/sat4.smt2" "../../unit-tests/sat4.vtlog")
+let _ = Printf.printf "Verit_checker.checker \"../../unit-tests/sat5.smt2\" \"../../unit-tests/sat5.vtlog\" = %b\n" (Verit_checker.checker "../../unit-tests/sat5.smt2" "../../unit-tests/sat5.vtlog")
+let _ = Printf.printf "Verit_checker.checker \"../../unit-tests/sat6.smt2\" \"../../unit-tests/sat6.vtlog\" = %b\n" (Verit_checker.checker "../../unit-tests/sat6.smt2" "../../unit-tests/sat6.vtlog")
+let _ = Printf.printf "Verit_checker.checker \"../../unit-tests/sat7.smt2\" \"../../unit-tests/sat7.vtlog\" = %b\n" (Verit_checker.checker "../../unit-tests/sat7.smt2" "../../unit-tests/sat7.vtlog")
+let _ = Printf.printf "Verit_checker.checker \"../../unit-tests/sat8.smt2\" \"../../unit-tests/sat8.vtlog\" = %b\n" (Verit_checker.checker "../../unit-tests/sat8.smt2" "../../unit-tests/sat8.vtlog")
+let _ = Printf.printf "Verit_checker.checker \"../../unit-tests/sat9.smt2\" \"../../unit-tests/sat9.vtlog\" = %b\n" (Verit_checker.checker "../../unit-tests/sat9.smt2" "../../unit-tests/sat9.vtlog")
+let _ = Printf.printf "Verit_checker.checker \"../../unit-tests/sat11.smt2\" \"../../unit-tests/sat11.vtlog\" = %b\n" (Verit_checker.checker "../../unit-tests/sat11.smt2" "../../unit-tests/sat11.vtlog")
+let _ = Printf.printf "Verit_checker.checker \"../../unit-tests/sat12.smt2\" \"../../unit-tests/sat12.vtlog\" = %b\n" (Verit_checker.checker "../../unit-tests/sat12.smt2" "../../unit-tests/sat12.vtlog")
+let _ = Printf.printf "Verit_checker.checker \"../../unit-tests/sat13.smt2\" \"../../unit-tests/sat13.vtlog\" = %b\n" (Verit_checker.checker "../../unit-tests/sat13.smt2" "../../unit-tests/sat13.vtlog")
+let _ = Printf.printf "Verit_checker.checker \"../../unit-tests/sat14.smt2\" \"../../unit-tests/sat14.vtlog\" = %b\n" (Verit_checker.checker "../../unit-tests/sat14.smt2" "../../unit-tests/sat14.vtlog")
+let _ = Printf.printf "Verit_checker.checker \"../../unit-tests/hole4.smt2\" \"../../unit-tests/hole4.vtlog\" = %b\n" (Verit_checker.checker "../../unit-tests/hole4.smt2" "../../unit-tests/hole4.vtlog")
+let _ = Printf.printf "Verit_checker.checker \"../../unit-tests/uf1.smt2\" \"../../unit-tests/uf1.vtlog\" = %b\n" (Verit_checker.checker "../../unit-tests/uf1.smt2" "../../unit-tests/uf1.vtlog")
+let _ = Printf.printf "Verit_checker.checker \"../../unit-tests/uf2.smt2\" \"../../unit-tests/uf2.vtlog\" = %b\n" (Verit_checker.checker "../../unit-tests/uf2.smt2" "../../unit-tests/uf2.vtlog")
+let _ = Printf.printf "Verit_checker.checker \"../../unit-tests/uf3.smt2\" \"../../unit-tests/uf3.vtlog\" = %b\n" (Verit_checker.checker "../../unit-tests/uf3.smt2" "../../unit-tests/uf3.vtlog")
+let _ = Printf.printf "Verit_checker.checker \"../../unit-tests/uf4.smt2\" \"../../unit-tests/uf4.vtlog\" = %b\n" (Verit_checker.checker "../../unit-tests/uf4.smt2" "../../unit-tests/uf4.vtlog")
+let _ = Printf.printf "Verit_checker.checker \"../../unit-tests/uf5.smt2\" \"../../unit-tests/uf5.vtlog\" = %b\n" (Verit_checker.checker "../../unit-tests/uf5.smt2" "../../unit-tests/uf5.vtlog")
+let _ = Printf.printf "Verit_checker.checker \"../../unit-tests/uf6.smt2\" \"../../unit-tests/uf6.vtlog\" = %b\n" (Verit_checker.checker "../../unit-tests/uf6.smt2" "../../unit-tests/uf6.vtlog")
+let _ = Printf.printf "Verit_checker.checker \"../../unit-tests/uf7.smt2\" \"../../unit-tests/uf7.vtlog\" = %b\n" (Verit_checker.checker "../../unit-tests/uf7.smt2" "../../unit-tests/uf7.vtlog")
+let _ = Printf.printf "Verit_checker.checker \"../../unit-tests/lia1.smt2\" \"../../unit-tests/lia1.vtlog\" = %b\n" (Verit_checker.checker "../../unit-tests/lia1.smt2" "../../unit-tests/lia1.vtlog")
+let _ = Printf.printf "Verit_checker.checker \"../../unit-tests/lia2.smt2\" \"../../unit-tests/lia2.vtlog\" = %b\n" (Verit_checker.checker "../../unit-tests/lia2.smt2" "../../unit-tests/lia2.vtlog")
+let _ = Printf.printf "Verit_checker.checker \"../../unit-tests/lia3.smt2\" \"../../unit-tests/lia3.vtlog\" = %b\n" (Verit_checker.checker "../../unit-tests/lia3.smt2" "../../unit-tests/lia3.vtlog")
+let _ = Printf.printf "Verit_checker.checker \"../../unit-tests/lia4.smt2\" \"../../unit-tests/lia4.vtlog\" = %b\n" (Verit_checker.checker "../../unit-tests/lia4.smt2" "../../unit-tests/lia4.vtlog")
+let _ = Printf.printf "Verit_checker.checker \"../../unit-tests/lia5.smt2\" \"../../unit-tests/lia5.vtlog\" = %b\n" (Verit_checker.checker "../../unit-tests/lia5.smt2" "../../unit-tests/lia5.vtlog")
+let _ = Printf.printf "Verit_checker.checker \"../../unit-tests/lia6.smt2\" \"../../unit-tests/lia6.vtlog\" = %b\n" (Verit_checker.checker "../../unit-tests/lia6.smt2" "../../unit-tests/lia6.vtlog")
+let _ = Printf.printf "Verit_checker.checker \"../../unit-tests/lia7.smt2\" \"../../unit-tests/lia7.vtlog\" = %b\n" (Verit_checker.checker "../../unit-tests/lia7.smt2" "../../unit-tests/lia7.vtlog")
+let _ = Printf.printf "Verit_checker.checker \"../../unit-tests/let1.smt2\" \"../../unit-tests/let1.vtlog\" = %b\n" (Verit_checker.checker "../../unit-tests/let1.smt2" "../../unit-tests/let1.vtlog")
+let _ = Printf.printf "Verit_checker.checker \"../../unit-tests/let2.smt2\" \"../../unit-tests/let2.vtlog\" = %b\n" (Verit_checker.checker "../../unit-tests/let2.smt2" "../../unit-tests/let2.vtlog")
diff --git a/src/extraction/verit_checker.ml b/src/extraction/verit_checker.ml
index 796ae54..c8b2a2f 100644
--- a/src/extraction/verit_checker.ml
+++ b/src/extraction/verit_checker.ml
@@ -10,25 +10,40 @@
(**************************************************************************)
-open SmtMisc
-open SmtCertif
-open SmtCommands
-open SmtForm
-open SmtAtom
-open SmtTrace
-open Verit
-open Smtlib2_ast
-open Smtlib2_genConstr
-(* open Smt_checker *)
+open Smtcoq_plugin
-module Mc = Structures.Micromega_plugin_Certificate.Mc
+let error_hole = "The proof contains a hole, which is not supported by the current version of the extracted checker; in a future version, a warning will be output but the remaining of the proof will be checked"
+let error_quant = "The current version of the extracted checker does not support quantifiers"
-let mkInt = ExtrNative.of_int
-let mkArray = ExtrNative.of_array
+module Mc = CoqInterface.Micromega_plugin_Certificate.Mc
+let mkInt = Uint63.of_int
+
+(* From trace/coqTerms.ml *)
+let mkArray a =
+ let l = (Array.length a) - 1 in
+ snd (Array.fold_left (fun (i,acc) c ->
+ let acc' =
+ if i = l then
+ acc
+ else
+ Smt_checker.set acc (mkInt i) c in
+ (i+1,acc')
+ ) (0, Smt_checker.make (mkInt l) a.(l)) a)
+
+
+(* Generate a list *)
+let rec dump_list dump_elt l =
+ match l with
+ | [] -> Smt_checker.Nil
+ | e :: l -> Smt_checker.Cons (dump_elt e, dump_list dump_elt l)
+
+
+(* Correspondance between the Micromega representation of objects and
+ the one that has been extracted *)
let rec dump_nat x =
match x with
| Mc.O -> Smt_checker.O
@@ -71,222 +86,321 @@ let dump_psatz e =
dump_cone e
-let rec dump_list dump_elt l =
- match l with
- | [] -> Smt_checker.Nil
- | e :: l -> Smt_checker.Cons (dump_elt e, dump_list dump_elt l)
-
-
let rec dump_proof_term = function
- | Micromega.DoneProof -> Smt_checker.DoneProof
- | Micromega.RatProof(cone,rst) ->
+ | CoqInterface.Micromega_plugin_Micromega.DoneProof -> Smt_checker.DoneProof
+ | CoqInterface.Micromega_plugin_Micromega.RatProof(cone,rst) ->
Smt_checker.RatProof (dump_psatz cone, dump_proof_term rst)
- | Micromega.CutProof(cone,prf) ->
+ | CoqInterface.Micromega_plugin_Micromega.CutProof(cone,prf) ->
Smt_checker.CutProof (dump_psatz cone, dump_proof_term prf)
- | Micromega.EnumProof(c1,c2,prfs) ->
+ | CoqInterface.Micromega_plugin_Micromega.EnumProof(c1,c2,prfs) ->
Smt_checker.EnumProof (dump_psatz c1, dump_psatz c2, dump_list dump_proof_term prfs)
+ | CoqInterface.Micromega_plugin_Micromega.ExProof(p,prf) ->
+ Smt_checker.ExProof (dump_positive p, dump_proof_term prf)
+(* From trace/coqInterface.ml *)
+(* WARNING: side effect on r! *)
+let mkTrace step_to_coq next size def_step r =
+ let rec mkTrace s =
+ if s = size then
+ Smt_checker.Nil
+ else (
+ r := next !r;
+ let st = step_to_coq !r in
+ Smt_checker.Cons (st, mkTrace (s+1))
+ ) in
+ (mkTrace 0, def_step)
+
+
+(* From trace/smtTrace.ml *)
+let to_coq to_lit
+ (cRes, cWeaken, cImmFlatten,
+ cTrue, cFalse, cBuildDef, cBuildDef2, cBuildProj,
+ cImmBuildProj,cImmBuildDef,cImmBuildDef2,
+ cEqTr, cEqCgr, cEqCgrP,
+ cLiaMicromega, cLiaDiseq, cSplArith, cSplDistinctElim,
+ cBBVar, cBBConst, cBBOp, cBBNot, cBBEq, cBBDiseq,
+ cBBNeg, cBBAdd, cBBMul, cBBUlt, cBBSlt, cBBConc,
+ cBBExtr, cBBZextn, cBBSextn,
+ cBBShl, cBBShr,
+ cRowEq, cRowNeq, cExt,
+ cHole, cForallInst) confl =
-let to_coq to_lit confl =
let out_f f = to_lit f in
- let out_c c = mkInt (get_pos c) in
+ let out_c c = mkInt (SmtTrace.get_pos c) in
+ let out_cl cl = List.fold_right (fun f l -> Smt_checker.Cons (out_f f, l)) cl Smt_checker.Nil in
let step_to_coq c =
- match c.kind with
+ match c.SmtCertif.kind with
| Res res ->
let size = List.length res.rtail + 3 in
let args = Array.make size (mkInt 0) in
- args.(0) <- mkInt (get_pos res.rc1);
- args.(1) <- mkInt (get_pos res.rc2);
+ args.(0) <- mkInt (SmtTrace.get_pos res.rc1);
+ args.(1) <- mkInt (SmtTrace.get_pos res.rc2);
let l = ref res.rtail in
for i = 2 to size - 2 do
match !l with
| c::tl ->
- args.(i) <- mkInt (get_pos c);
+ args.(i) <- mkInt (SmtTrace.get_pos c);
l := tl
| _ -> assert false
done;
- Smt_checker.Euf_Checker.Res (mkInt (get_pos c), mkArray args)
+ cRes (mkInt (SmtTrace.get_pos c), mkArray args)
| Other other ->
begin match other with
- | ImmFlatten (c',f) -> Smt_checker.Euf_Checker.ImmFlatten (out_c c, out_c c', out_f f)
- | True -> Smt_checker.Euf_Checker.CTrue (out_c c)
- | False -> Smt_checker.Euf_Checker.CFalse (out_c c)
- | BuildDef f -> Smt_checker.Euf_Checker.BuildDef (out_c c, out_f f)
- | BuildDef2 f -> Smt_checker.Euf_Checker.BuildDef2 (out_c c, out_f f)
- | BuildProj (f, i) -> Smt_checker.Euf_Checker.BuildProj (out_c c, out_f f, mkInt i)
- | ImmBuildDef c' -> Smt_checker.Euf_Checker.ImmBuildDef (out_c c, out_c c')
- | ImmBuildDef2 c' -> Smt_checker.Euf_Checker.ImmBuildDef2 (out_c c, out_c c')
- | ImmBuildProj(c', i) -> Smt_checker.Euf_Checker.ImmBuildProj (out_c c, out_c c',mkInt i)
+ | Weaken (c',l') -> cWeaken (out_c c, out_c c', out_cl l')
+ | ImmFlatten (c',f) -> cImmFlatten (out_c c, out_c c', out_f f)
+ | True -> cTrue (out_c c)
+ | False -> cFalse (out_c c)
+ | BuildDef f -> cBuildDef (out_c c, out_f f)
+ | BuildDef2 f -> cBuildDef2 (out_c c, out_f f)
+ | BuildProj (f, i) -> cBuildProj (out_c c, out_f f, mkInt i)
+ | ImmBuildDef c' -> cImmBuildDef (out_c c, out_c c')
+ | ImmBuildDef2 c' -> cImmBuildDef2 (out_c c, out_c c')
+ | ImmBuildProj(c', i) -> cImmBuildProj (out_c c, out_c c', mkInt i)
| EqTr (f, fl) ->
let res = List.fold_right (fun f l -> Smt_checker.Cons (out_f f, l)) fl Smt_checker.Nil in
- Smt_checker.Euf_Checker.EqTr (out_c c, out_f f, res)
+ cEqTr (out_c c, out_f f, res)
| EqCgr (f, fl) ->
let res = List.fold_right (fun f l -> Smt_checker.Cons ((match f with | Some f -> Smt_checker.Some (out_f f) | None -> Smt_checker.None), l)) fl Smt_checker.Nil in
- Smt_checker.Euf_Checker.EqCgr (out_c c, out_f f, res)
+ cEqCgr (out_c c, out_f f, res)
| EqCgrP (f1, f2, fl) ->
let res = List.fold_right (fun f l -> Smt_checker.Cons ((match f with | Some f -> Smt_checker.Some (out_f f) | None -> Smt_checker.None), l)) fl Smt_checker.Nil in
- Smt_checker.Euf_Checker.EqCgrP (out_c c, out_f f1, out_f f2, res)
+ cEqCgrP (out_c c, out_f f1, out_f f2, res)
| LiaMicromega (cl,d) ->
let cl' = List.fold_right (fun f l -> Smt_checker.Cons (out_f f, l)) cl Smt_checker.Nil in
let c' = List.fold_right (fun f l -> Smt_checker.Cons (dump_proof_term f, l)) d Smt_checker.Nil in
- Smt_checker.Euf_Checker.LiaMicromega (out_c c, cl', c')
- | LiaDiseq l -> Smt_checker.Euf_Checker.LiaDiseq (out_c c, out_f l)
+ cLiaMicromega (out_c c, cl', c')
+ | LiaDiseq l -> cLiaDiseq (out_c c, out_f l)
| SplArith (orig,res,l) ->
let res' = out_f res in
let l' = List.fold_right (fun f l -> Smt_checker.Cons (dump_proof_term f, l)) l Smt_checker.Nil in
- Smt_checker.Euf_Checker.SplArith (out_c c, out_c orig, res', l')
- | SplDistinctElim (c',f) -> Smt_checker.Euf_Checker.SplDistinctElim (out_c c, out_c c', out_f f)
+ cSplArith (out_c c, out_c orig, res', l')
+ | SplDistinctElim (c',f) -> cSplDistinctElim (out_c c, out_c c', out_f f)
+ | BBVar res -> cBBVar (out_c c, out_f res)
+ | BBConst res -> cBBConst (out_c c, out_f res)
+ | BBOp (c1,c2,res) ->
+ cBBOp (out_c c, out_c c1, out_c c2, out_f res)
+ | BBNot (c1,res) ->
+ cBBNot (out_c c, out_c c1, out_f res)
+ | BBNeg (c1,res) ->
+ cBBNeg (out_c c, out_c c1, out_f res)
+ | BBAdd (c1,c2,res) ->
+ cBBAdd (out_c c, out_c c1, out_c c2, out_f res)
+ | BBMul (c1,c2,res) ->
+ cBBMul (out_c c, out_c c1, out_c c2, out_f res)
+ | BBUlt (c1,c2,res) ->
+ cBBUlt (out_c c, out_c c1, out_c c2, out_f res)
+ | BBSlt (c1,c2,res) ->
+ cBBSlt (out_c c, out_c c1, out_c c2, out_f res)
+ | BBConc (c1,c2,res) ->
+ cBBConc (out_c c, out_c c1, out_c c2, out_f res)
+ | BBExtr (c1,res) ->
+ cBBExtr (out_c c, out_c c1, out_f res)
+ | BBZextn (c1,res) ->
+ cBBZextn (out_c c, out_c c1, out_f res)
+ | BBSextn (c1,res) ->
+ cBBSextn (out_c c, out_c c1, out_f res)
+ | BBShl (c1,c2,res) ->
+ cBBShl (out_c c, out_c c1, out_c c2, out_f res)
+ | BBShr (c1,c2,res) ->
+ cBBShr (out_c c, out_c c1, out_c c2, out_f res)
+ | BBEq (c1,c2,res) ->
+ cBBEq (out_c c, out_c c1, out_c c2, out_f res)
+ | BBDiseq (res) -> cBBDiseq (out_c c, out_f res)
+ | RowEq (res) -> cRowEq (out_c c, out_f res)
+ | RowNeq (cl) ->
+ let out_cl cl =
+ List.fold_right (fun f l -> Smt_checker.Cons (out_f f, l)) cl Smt_checker.Nil
+ in
+ cRowNeq (out_c c, out_cl cl)
+ | Ext (res) -> cExt (out_c c, out_f res)
+ | Hole (prem_id, concl) -> failwith error_hole
+ | Forall_inst (cl, concl) | Qf_lemma (cl, concl) -> failwith error_quant
end
| _ -> assert false in
let def_step =
- Smt_checker.Euf_Checker.Res (mkInt 0, mkArray [|mkInt 0|]) in
+ cRes (mkInt 0, mkArray [|mkInt 0|]) in
let r = ref confl in
let nc = ref 0 in
- while not (isRoot !r.kind) do r := prev !r; incr nc done;
+ while not (SmtTrace.isRoot !r.SmtCertif.kind) do r := SmtTrace.prev !r; incr nc done;
let last_root = !r in
- let size = !nc in
- let max = (Parray.trunc_size (Uint63.of_int 4194303)) - 1 in
- let q,r1 = size / max, size mod max in
-
- let trace =
- let len = if r1 = 0 then q + 1 else q + 2 in
- Array.make len (mkArray [|def_step|]) in
- for j = 0 to q - 1 do
- let tracej = Array.make (Parray.trunc_size (Uint63.of_int 4194303)) def_step in
- for i = 0 to max - 1 do
- r := next !r;
- tracej.(i) <- step_to_coq !r;
- done;
- trace.(j) <- mkArray tracej
- done;
- if r1 <> 0 then begin
- let traceq = Array.make (r1 + 1) def_step in
- for i = 0 to r1-1 do
- r := next !r;
- traceq.(i) <- step_to_coq !r;
- done;
- trace.(q) <- mkArray traceq
- end;
-
- (mkArray trace, last_root)
-
-
-let btype_to_coq = function
- | TZ -> Smt_checker.Typ.TZ
- | Tbool -> Smt_checker.Typ.Tbool
- | Tpositive -> Smt_checker.Typ.Tpositive
- | Tindex i -> Smt_checker.Typ.Tindex (mkInt (SmtAtom.indexed_type_index i))
+ (* Be careful, step_to_coq makes a side effect on cuts so it needs to be called first *)
+ let res = mkTrace step_to_coq SmtTrace.next !nc def_step r in
+ (res, last_root)
+
+
+(* Map OCaml integers to the extracted version of N *)
+(* From trace/coqTerms.ml *)
+let rec mkNat = function
+ | 0 -> Smt_checker.O
+ | i -> Smt_checker.S (mkNat (i-1))
+
+let rec mkPositive = function
+ | 1 -> Smt_checker.XH
+ | i ->
+ let c =
+ if (i mod 2) = 0 then
+ fun c -> Smt_checker.XO c
+ else
+ fun c -> Smt_checker.XI c
+ in
+ c (mkPositive (i / 2))
+
+let mkN = function
+ | 0 -> Smt_checker.N0
+ | i -> Smt_checker.Npos (mkPositive i)
+
+
+(* Correspondance between the SMTCoq representation of objects and the
+ one that has been extracted *)
+let rec btype_to_coq = function
+ | SmtBtype.TZ -> Smt_checker.Typ.TZ
+ | SmtBtype.Tbool -> Smt_checker.Typ.Tbool
+ | SmtBtype.Tpositive -> Smt_checker.Typ.Tpositive
+ | SmtBtype.TBV i -> Smt_checker.Typ.TBV (mkN i)
+ | SmtBtype.TFArray (k, v) -> Smt_checker.Typ.TFArray (btype_to_coq k, btype_to_coq v)
+ | SmtBtype.Tindex i -> Smt_checker.Typ.Tindex (mkN (SmtBtype.indexed_type_index i))
let c_to_coq = function
- | CO_xH -> Smt_checker.Atom.CO_xH
- | CO_Z0 -> Smt_checker.Atom.CO_Z0
+ | SmtAtom.CO_xH -> Smt_checker.Atom.CO_xH
+ | SmtAtom.CO_Z0 -> Smt_checker.Atom.CO_Z0
+ | SmtAtom.CO_BV bv ->
+ Smt_checker.Atom.CO_BV (dump_list (fun x -> x) bv, mkN (List.length bv))
let u_to_coq = function
- | UO_xO -> Smt_checker.Atom.UO_xO
- | UO_xI -> Smt_checker.Atom.UO_xI
- | UO_Zpos -> Smt_checker.Atom.UO_Zpos
- | UO_Zneg -> Smt_checker.Atom.UO_Zneg
- | UO_Zopp -> Smt_checker.Atom.UO_Zopp
+ | SmtAtom.UO_xO -> Smt_checker.Atom.UO_xO
+ | SmtAtom.UO_xI -> Smt_checker.Atom.UO_xI
+ | SmtAtom.UO_Zpos -> Smt_checker.Atom.UO_Zpos
+ | SmtAtom.UO_Zneg -> Smt_checker.Atom.UO_Zneg
+ | SmtAtom.UO_Zopp -> Smt_checker.Atom.UO_Zopp
+ | SmtAtom.UO_BVbitOf (s, i) -> Smt_checker.Atom.UO_BVbitOf (mkN s, mkNat i)
+ | SmtAtom.UO_BVnot s -> Smt_checker.Atom.UO_BVnot (mkN s)
+ | SmtAtom.UO_BVneg s -> Smt_checker.Atom.UO_BVneg (mkN s)
+ | SmtAtom.UO_BVextr (s1, s2, s3) -> Smt_checker.Atom.UO_BVextr (mkN s1, mkN s2, mkN s3)
+ | SmtAtom.UO_BVzextn (s1, s2) -> Smt_checker.Atom.UO_BVzextn (mkN s1, mkN s2)
+ | SmtAtom.UO_BVsextn (s1, s2) -> Smt_checker.Atom.UO_BVsextn (mkN s1, mkN s2)
let b_to_coq = function
- | BO_Zplus -> Smt_checker.Atom.BO_Zplus
- | BO_Zminus -> Smt_checker.Atom.BO_Zminus
- | BO_Zmult -> Smt_checker.Atom.BO_Zmult
- | BO_Zlt -> Smt_checker.Atom.BO_Zlt
- | BO_Zle -> Smt_checker.Atom.BO_Zle
- | BO_Zge -> Smt_checker.Atom.BO_Zge
- | BO_Zgt -> Smt_checker.Atom.BO_Zgt
- | BO_eq t -> Smt_checker.Atom.BO_eq (btype_to_coq t)
+ | SmtAtom.BO_Zplus -> Smt_checker.Atom.BO_Zplus
+ | SmtAtom.BO_Zminus -> Smt_checker.Atom.BO_Zminus
+ | SmtAtom.BO_Zmult -> Smt_checker.Atom.BO_Zmult
+ | SmtAtom.BO_Zlt -> Smt_checker.Atom.BO_Zlt
+ | SmtAtom.BO_Zle -> Smt_checker.Atom.BO_Zle
+ | SmtAtom.BO_Zge -> Smt_checker.Atom.BO_Zge
+ | SmtAtom.BO_Zgt -> Smt_checker.Atom.BO_Zgt
+ | SmtAtom.BO_eq t -> Smt_checker.Atom.BO_eq (btype_to_coq t)
+ | SmtAtom.BO_BVand s -> Smt_checker.Atom.BO_BVand (mkN s)
+ | SmtAtom.BO_BVor s -> Smt_checker.Atom.BO_BVor (mkN s)
+ | SmtAtom.BO_BVxor s -> Smt_checker.Atom.BO_BVxor (mkN s)
+ | SmtAtom.BO_BVadd s -> Smt_checker.Atom.BO_BVadd (mkN s)
+ | SmtAtom.BO_BVmult s -> Smt_checker.Atom.BO_BVmult (mkN s)
+ | SmtAtom.BO_BVult s -> Smt_checker.Atom.BO_BVult (mkN s)
+ | SmtAtom.BO_BVslt s -> Smt_checker.Atom.BO_BVslt (mkN s)
+ | SmtAtom.BO_BVconcat (s1, s2) -> Smt_checker.Atom.BO_BVconcat (mkN s1, mkN s2)
+ | SmtAtom.BO_BVshl s -> Smt_checker.Atom.BO_BVshl (mkN s)
+ | SmtAtom.BO_BVshr s -> Smt_checker.Atom.BO_BVshr (mkN s)
+ | SmtAtom.BO_select (k ,v) -> Smt_checker.Atom.BO_select (btype_to_coq k, btype_to_coq v)
+ | SmtAtom.BO_diffarray (k ,v) -> Smt_checker.Atom.BO_diffarray (btype_to_coq k, btype_to_coq v)
+
+
+let t_to_coq = function
+ | SmtAtom.TO_store (k ,v) -> Smt_checker.Atom.TO_store (btype_to_coq k, btype_to_coq v)
let n_to_coq = function
- | NO_distinct t -> btype_to_coq t
+ | SmtAtom.NO_distinct t -> btype_to_coq t
let i_to_coq i = mkInt (SmtAtom.indexed_op_index i)
+let hatom_to_coq h = mkInt (SmtAtom.Atom.index h)
+
let a_to_coq a =
- let to_coq h = mkInt (Atom.index h) in
match a with
- | Acop op -> Smt_checker.Atom.Acop (c_to_coq op)
- | Auop (op,h) -> Smt_checker.Atom.Auop (u_to_coq op, to_coq h)
- | Abop (op,h1,h2) ->
- Smt_checker.Atom.Abop (b_to_coq op, to_coq h1, to_coq h2)
- | Anop (op,ha) ->
+ | SmtAtom.Acop op -> Smt_checker.Atom.Acop (c_to_coq op)
+ | SmtAtom.Auop (op,h) -> Smt_checker.Atom.Auop (u_to_coq op, hatom_to_coq h)
+ | SmtAtom.Abop (op,h1,h2) ->
+ Smt_checker.Atom.Abop (b_to_coq op, hatom_to_coq h1, hatom_to_coq h2)
+ | SmtAtom.Atop (op,h1,h2,h3) ->
+ Smt_checker.Atom.Atop (t_to_coq op, hatom_to_coq h1, hatom_to_coq h2, hatom_to_coq h3)
+ | SmtAtom.Anop (op,ha) ->
let cop = n_to_coq op in
- let cargs = Array.fold_right (fun h l -> Smt_checker.Cons (to_coq h, l)) ha Smt_checker.Nil in
+ let cargs = Array.fold_right (fun h l -> Smt_checker.Cons (hatom_to_coq h, l)) ha Smt_checker.Nil in
Smt_checker.Atom.Anop (cop, cargs)
- | Aapp (op,args) ->
+ | SmtAtom.Aapp (op,args) ->
let cop = i_to_coq op in
- let cargs = Array.fold_right (fun h l -> Smt_checker.Cons (to_coq h, l)) args Smt_checker.Nil in
+ let cargs = Array.fold_right (fun h l -> Smt_checker.Cons (hatom_to_coq h, l)) args Smt_checker.Nil in
Smt_checker.Atom.Aapp (cop, cargs)
let atom_interp_tbl reify =
- let t = Atom.to_array reify (Smt_checker.Atom.Acop Smt_checker.Atom.CO_xH) a_to_coq in
+ let t = SmtAtom.Atom.to_array reify (Smt_checker.Atom.Acop Smt_checker.Atom.CO_xH) a_to_coq in
mkArray t
-let form_to_coq hf = mkInt (Form.to_lit hf)
+let form_to_coq hf = mkInt (SmtAtom.Form.to_lit hf)
let args_to_coq args =
let cargs = Array.make (Array.length args + 1) (mkInt 0) in
Array.iteri (fun i hf -> cargs.(i) <- form_to_coq hf) args;
mkArray cargs
-let pf_to_coq = function
- | Fatom a -> Smt_checker.Form.Fatom (mkInt (Atom.index a))
- | Fapp(op,args) ->
- match op with
- | Ftrue -> Smt_checker.Form.Ftrue
- | Ffalse -> Smt_checker.Form.Ffalse
- | Fand -> Smt_checker.Form.Fand (args_to_coq args)
- | For -> Smt_checker.Form.For (args_to_coq args)
- | Fimp -> Smt_checker.Form.Fimp (args_to_coq args)
- | Fxor -> if Array.length args = 2 then Smt_checker.Form.Fxor (form_to_coq args.(0), form_to_coq args.(1)) else assert false
- | Fiff -> if Array.length args = 2 then Smt_checker.Form.Fiff (form_to_coq args.(0), form_to_coq args.(1)) else assert false
- | Fite -> if Array.length args = 3 then Smt_checker.Form.Fite (form_to_coq args.(0), form_to_coq args.(1), form_to_coq args.(2)) else assert false
- | Fnot2 i -> Smt_checker.Form.Fnot2 (mkInt i, form_to_coq args.(0))
+let pf_to_coq pf =
+ match pf with
+ | SmtForm.Fatom a -> Smt_checker.Form.Fatom (hatom_to_coq a)
+ | SmtForm.Fapp(op,args) ->
+ (match op with
+ | SmtForm.Ftrue -> Smt_checker.Form.Ftrue
+ | SmtForm.Ffalse -> Smt_checker.Form.Ffalse
+ | SmtForm.Fand -> Smt_checker.Form.Fand (args_to_coq args)
+ | SmtForm.For -> Smt_checker.Form.For (args_to_coq args)
+ | SmtForm.Fxor -> if Array.length args = 2 then Smt_checker.Form.Fxor (form_to_coq args.(0), form_to_coq args.(1)) else assert false
+ | SmtForm.Fimp -> Smt_checker.Form.Fimp (args_to_coq args)
+ | SmtForm.Fiff -> if Array.length args = 2 then Smt_checker.Form.Fiff (form_to_coq args.(0), form_to_coq args.(1)) else assert false
+ | SmtForm.Fite -> if Array.length args = 3 then Smt_checker.Form.Fite (form_to_coq args.(0), form_to_coq args.(1), form_to_coq args.(2)) else assert false
+ | SmtForm.Fnot2 i -> Smt_checker.Form.Fnot2 (mkInt i, form_to_coq args.(0))
+ | SmtForm.Fforall _ -> failwith error_quant
+ )
+ | SmtForm.FbbT (a, args) -> Smt_checker.Form.FbbT (hatom_to_coq a, dump_list form_to_coq args)
let form_interp_tbl reify =
- let (_,t) = Form.to_array reify Smt_checker.Form.Ftrue pf_to_coq in
+ let (_,t) = SmtAtom.Form.to_array reify Smt_checker.Form.Ftrue pf_to_coq in
mkArray t
(* Importing from SMT-LIB v.2 without generating section variables *)
-
+(* From smtlib2/smtlib2_genConstr.ml *)
let count_btype = ref 0
let count_op = ref 0
let declare_sort sym =
- let s = string_of_symbol sym in
- let res = Tindex (dummy_indexed_type !count_btype) in
+ let s = Smtlib2_genConstr.string_of_symbol sym in
+ let res = SmtBtype.Tindex (SmtBtype.dummy_indexed_type !count_btype) in
incr count_btype;
- VeritSyntax.add_btype s res;
+ SmtMaps.add_btype s res;
res
let declare_fun sym arg cod =
- let s = string_of_symbol sym in
- let tyl = List.map sort_of_sort arg in
- let ty = sort_of_sort cod in
- let op = dummy_indexed_op !count_op (Array.of_list (List.map fst tyl)) (fst ty) in
+ let s = Smtlib2_genConstr.string_of_symbol sym in
+ let tyl = List.map Smtlib2_genConstr.sort_of_sort arg in
+ let ty = Smtlib2_genConstr.sort_of_sort cod in
+ let op = SmtAtom.dummy_indexed_op (SmtAtom.Index !count_op) (Array.of_list tyl) ty in
incr count_op;
- VeritSyntax.add_fun s op;
+ SmtMaps.add_fun s op;
op
let declare_commands ra rf acc = function
- | CDeclareSort (_,sym,_) -> let _ = declare_sort sym in acc
- | CDeclareFun (_,sym, (_, arg), cod) -> let _ = declare_fun sym arg cod in acc
- | CAssert (_, t) -> (make_root ra rf t)::acc
+ | Smtlib2_ast.CDeclareSort (_,sym,_) -> let _ = declare_sort sym in acc
+ | Smtlib2_ast.CDeclareFun (_,sym, (_, arg), cod) -> let _ = declare_fun sym arg cod in acc
+ | Smtlib2_ast.CAssert (_, t) -> (Smtlib2_genConstr.make_root ra rf t)::acc
| _ -> acc
@@ -309,29 +423,79 @@ let this_clear_all () =
count_op := 0
+let certif_ops =
+ ((fun (a, b) -> Smt_checker.Checker_Ext.Res (a, b)),
+ (fun (a, b, c) -> Smt_checker.Checker_Ext.Weaken (a, b, c)),
+ (fun (a, b, c) -> Smt_checker.Checker_Ext.ImmFlatten (a, b, c)),
+ (fun a -> Smt_checker.Checker_Ext.CTrue a),
+ (fun a -> Smt_checker.Checker_Ext.CFalse a),
+ (fun (a, b) -> Smt_checker.Checker_Ext.BuildDef (a, b)),
+ (fun (a, b) -> Smt_checker.Checker_Ext.BuildDef2 (a, b)),
+ (fun (a, b, c) -> Smt_checker.Checker_Ext.BuildProj (a, b, c)),
+ (fun (a, b, c) -> Smt_checker.Checker_Ext.ImmBuildProj (a, b, c)),
+ (fun (a, b) -> Smt_checker.Checker_Ext.ImmBuildDef (a, b)),
+ (fun (a, b) -> Smt_checker.Checker_Ext.ImmBuildDef2 (a, b)),
+ (fun (a, b, c) -> Smt_checker.Checker_Ext.EqTr (a, b, c)),
+ (fun (a, b, c) -> Smt_checker.Checker_Ext.EqCgr (a, b, c)),
+ (fun (a, b, c, d) -> Smt_checker.Checker_Ext.EqCgrP (a, b, c, d)),
+ (fun (a, b, c) -> Smt_checker.Checker_Ext.LiaMicromega (a, b, c)),
+ (fun (a, b) -> Smt_checker.Checker_Ext.LiaDiseq (a, b)),
+ (fun (a, b, c, d) -> Smt_checker.Checker_Ext.SplArith (a, b, c, d)),
+ (fun (a, b, c) -> Smt_checker.Checker_Ext.SplDistinctElim (a, b, c)),
+ (fun (a, b) -> Smt_checker.Checker_Ext.BBVar (a, b)),
+ (fun (a, b) -> Smt_checker.Checker_Ext.BBConst (a, b)),
+ (fun (a, b, c, d) -> Smt_checker.Checker_Ext.BBOp (a, b, c, d)),
+ (fun (a, b, c) -> Smt_checker.Checker_Ext.BBNot (a, b, c)),
+ (fun (a, b, c, d) -> Smt_checker.Checker_Ext.BBEq (a, b, c, d)),
+ (fun (a, b) -> Smt_checker.Checker_Ext.BBDiseq (a, b)),
+ (fun (a, b, c) -> Smt_checker.Checker_Ext.BBNeg (a, b, c)),
+ (fun (a, b, c, d) -> Smt_checker.Checker_Ext.BBAdd (a, b, c, d)),
+ (fun (a, b, c, d) -> Smt_checker.Checker_Ext.BBMul (a, b, c, d)),
+ (fun (a, b, c, d) -> Smt_checker.Checker_Ext.BBUlt (a, b, c, d)),
+ (fun (a, b, c, d) -> Smt_checker.Checker_Ext.BBSlt (a, b, c, d)),
+ (fun (a, b, c, d) -> Smt_checker.Checker_Ext.BBConcat (a, b, c, d)),
+ (fun (a, b, c) -> Smt_checker.Checker_Ext.BBExtract (a, b, c)),
+ (fun (a, b, c) -> Smt_checker.Checker_Ext.BBZextend (a, b, c)),
+ (fun (a, b, c) -> Smt_checker.Checker_Ext.BBSextend (a, b, c)),
+ (fun (a, b, c, d) -> Smt_checker.Checker_Ext.BBShl (a, b, c, d)),
+ (fun (a, b, c, d) -> Smt_checker.Checker_Ext.BBShr (a, b, c, d)),
+ (fun (a, b) -> Smt_checker.Checker_Ext.RowEq (a, b)),
+ (fun (a, b) -> Smt_checker.Checker_Ext.RowNeq (a, b)),
+ (fun (a, b) -> Smt_checker.Checker_Ext.Ext (a, b)),
+ (fun () -> failwith error_hole),
+ (fun () -> failwith error_quant))
+
+
+(* From verit/verit.ml and trace/smtCommands.ml *)
let checker fsmt fproof =
this_clear_all ();
let ra = VeritSyntax.ra in
let rf = VeritSyntax.rf in
+ let ra_quant = VeritSyntax.ra_quant in
+ let rf_quant = VeritSyntax.rf_quant in
let roots = import_smtlib2 ra rf fsmt in
- let (max_id, confl) = import_trace fproof None in
- let (tres,last_root) = to_coq (fun i -> mkInt (SmtAtom.Form.to_lit i)) confl in
+ let (max_id, confl) = Verit.import_trace ra_quant rf_quant fproof None [] in
+
+ let (tres,last_root) = to_coq (fun i -> mkInt (SmtAtom.Form.to_lit i)) certif_ops confl in
let certif =
- Smt_checker.Euf_Checker.Certif (mkInt (max_id + 1), tres, mkInt (get_pos confl)) in
- let used_roots = compute_roots roots last_root in
+ Smt_checker.Checker_Ext.Certif (mkInt (max_id + 1), tres, mkInt (SmtTrace.get_pos confl))
+ in
+ let used_roots = SmtCommands.compute_roots roots last_root in
let used_rootsCstr =
let l = List.length used_roots in
let res = Array.make (l + 1) (mkInt 0) in
let i = ref (l-1) in
List.iter (fun j -> res.(!i) <- mkInt j; decr i) used_roots;
- Smt_checker.Some (mkArray res) in
+ Smt_checker.Some (mkArray res)
+ in
let rootsCstr =
let res = Array.make (List.length roots + 1) (mkInt 0) in
let i = ref 0 in
List.iter (fun j -> res.(!i) <- mkInt (SmtAtom.Form.to_lit j); incr i) roots;
- mkArray res in
+ mkArray res
+ in
let t_atom = atom_interp_tbl ra in
let t_form = form_interp_tbl rf in
- Smt_checker.Euf_Checker.checker_ext t_atom t_form rootsCstr used_rootsCstr certif
+ Smt_checker.Checker_Ext.checker_ext t_atom t_form rootsCstr used_rootsCstr certif
diff --git a/src/extraction/verit_checker.mli b/src/extraction/verit_checker.mli
index 6247001..f916eb2 100644
--- a/src/extraction/verit_checker.mli
+++ b/src/extraction/verit_checker.mli
@@ -10,48 +10,4 @@
(**************************************************************************)
-module Mc = CoqInterface.Micromega_plugin_Certificate.Mc
-val mkInt : int -> ExtrNative.uint
-val mkArray : 'a array -> 'a ExtrNative.parray
-val dump_nat : Mc.nat -> Smt_checker.nat
-val dump_positive : Mc.positive -> Smt_checker.positive
-val dump_z : Mc.z -> Smt_checker.z
-val dump_pol : Mc.z Mc.pol -> Smt_checker.z Smt_checker.pol
-val dump_psatz : Mc.z Mc.psatz -> Smt_checker.z Smt_checker.psatz
-val dump_list : ('a -> 'b) -> 'a list -> 'b Smt_checker.list
-val dump_proof_term : Micromega.zArithProof -> Smt_checker.zArithProof
-val to_coq :
- ('a -> Smt_checker.int) ->
- 'a SmtCertif.clause ->
- Smt_checker.Euf_Checker.step ExtrNative.parray ExtrNative.parray *
- 'a SmtCertif.clause
-val btype_to_coq : SmtBtype.btype -> Smt_checker.Typ.coq_type
-val c_to_coq : SmtAtom.cop -> Smt_checker.Atom.cop
-val u_to_coq : SmtAtom.uop -> Smt_checker.Atom.unop
-val b_to_coq : SmtAtom.bop -> Smt_checker.Atom.binop
-val n_to_coq : SmtAtom.nop -> Smt_checker.Typ.coq_type
-val i_to_coq : SmtAtom.indexed_op -> ExtrNative.uint
-val a_to_coq : SmtAtom.atom -> Smt_checker.Atom.atom
-val atom_interp_tbl :
- SmtAtom.Atom.reify_tbl -> Smt_checker.Atom.atom ExtrNative.parray
-val form_to_coq : SmtAtom.Form.t -> ExtrNative.uint
-val args_to_coq : SmtAtom.Form.t array -> ExtrNative.uint ExtrNative.parray
-val pf_to_coq :
- (SmtAtom.hatom, SmtAtom.Form.t) SmtForm.gen_pform -> Smt_checker.Form.form
-val form_interp_tbl :
- SmtAtom.Form.reify -> Smt_checker.Form.form ExtrNative.parray
-val count_btype : int ref
-val count_op : int ref
-val declare_sort : Smtlib2_ast.symbol -> SmtBtype.btype
-val declare_fun :
- Smtlib2_ast.symbol ->
- Smtlib2_ast.sort list -> Smtlib2_ast.sort -> SmtAtom.indexed_op
-val declare_commands :
- SmtAtom.Atom.reify_tbl ->
- SmtAtom.Form.reify ->
- SmtAtom.Form.t list -> Smtlib2_ast.command -> SmtAtom.Form.t list
-val import_smtlib2 :
- SmtAtom.Atom.reify_tbl ->
- SmtAtom.Form.reify -> string -> SmtAtom.Form.t list
-val this_clear_all : unit -> unit
val checker : string -> string -> bool
diff --git a/src/extraction/zchaff_checker.ml b/src/extraction/zchaff_checker.ml
index a53526b..77e6ca1 100644
--- a/src/extraction/zchaff_checker.ml
+++ b/src/extraction/zchaff_checker.ml
@@ -10,34 +10,41 @@
(**************************************************************************)
-open SmtCertif
-open SmtForm
-open SatAtom
-open SmtTrace
-open Zchaff
-open Sat_checker
+open Smtcoq_plugin
-let mkInt = ExtrNative.of_int
-let mkArray = ExtrNative.of_array
+let mkInt = Uint63.of_int
+(* From trace/coqTerms.ml *)
+let mkArray a =
+ let l = (Array.length a) - 1 in
+ snd (Array.fold_left (fun (i,acc) c ->
+ let acc' =
+ if i = l then
+ acc
+ else
+ Sat_checker.set acc (mkInt i) c in
+ (i+1,acc')
+ ) (0, Sat_checker.make (mkInt l) a.(l)) a)
+
+(* From zchaff/zchaff.ml *)
let make_roots first last =
- let roots = Array.make (last.id + 2) (mkArray (Array.make 1 (mkInt 0))) in
+ let roots = Array.make (last.SmtCertif.id + 2) (mkArray (Array.make 1 (mkInt 0))) in
let mk_elem l =
- let x = match Form.pform l with
+ let x = match SatAtom.Form.pform l with
| Fatom x -> x + 2
| _ -> assert false in
- mkInt (if Form.is_pos l then x lsl 1 else (x lsl 1) lxor 1) in
+ mkInt (if SatAtom.Form.is_pos l then x lsl 1 else (x lsl 1) lxor 1) in
let r = ref first in
- while !r.id < last.id do
- let root = Array.of_list (get_val !r) in
+ while !r.SmtCertif.id < last.SmtCertif.id do
+ let root = Array.of_list (SmtTrace.get_val !r) in
let croot = Array.make (Array.length root + 1) (mkInt 0) in
Array.iteri (fun i l -> croot.(i) <- mk_elem l) root;
roots.(!r.id) <- mkArray croot;
- r := next !r
+ r := SmtTrace.next !r
done;
- let root = Array.of_list (get_val !r) in
+ let root = Array.of_list (SmtTrace.get_val !r) in
let croot = Array.make (Array.length root + 1) (mkInt 0) in
Array.iteri (fun i l -> croot.(i) <- mk_elem l) root;
roots.(!r.id) <- mkArray croot;
@@ -45,71 +52,65 @@ let make_roots first last =
mkArray roots
-let to_coq to_lit (cstep,
- cRes, cImmFlatten,
- cTrue, cFalse, cBuildDef, cBuildDef2, cBuildProj,
- cImmBuildProj,cImmBuildDef,cImmBuildDef2,
- cEqTr, cEqCgr, cEqCgrP,
- cLiaMicromega, cLiaDiseq, cSplArith, cSplDistinctElim, cHole) confl =
+(* From trace/coqInterface.ml *)
+(* WARNING: side effect on r! *)
+let mkTrace step_to_coq next size def_step r =
+ let rec mkTrace s =
+ if s = size then
+ Sat_checker.Nil
+ else (
+ r := next !r;
+ let st = step_to_coq !r in
+ Sat_checker.Cons (st, mkTrace (s+1))
+ ) in
+ (mkTrace 0, def_step)
+
+
+(* From trace/smtTrace.ml *)
+let to_coq cRes confl =
+
let step_to_coq c =
- match c.kind with
- | Res res ->
+ match c.SmtCertif.kind with
+ | Res res ->
let size = List.length res.rtail + 3 in
let args = Array.make size (mkInt 0) in
- args.(0) <- mkInt (get_pos res.rc1);
- args.(1) <- mkInt (get_pos res.rc2);
+ args.(0) <- mkInt (SmtTrace.get_pos res.rc1);
+ args.(1) <- mkInt (SmtTrace.get_pos res.rc2);
let l = ref res.rtail in
for i = 2 to size - 2 do
match !l with
- | c::tl ->
- args.(i) <- mkInt (get_pos c);
+ | c::tl ->
+ args.(i) <- mkInt (SmtTrace.get_pos c);
l := tl
- | _ -> assert false
+ | _ -> assert false
done;
- Sat_Checker.Res (mkInt (get_pos c), mkArray args)
- | _ -> assert false in
- let def_step =
- Sat_Checker.Res (mkInt 0, mkArray [|mkInt 0|]) in
+ cRes (mkInt (SmtTrace.get_pos c), mkArray args)
+ | Other other -> assert false
+ | _ -> assert false
+ in
+
+ let def_step = cRes (mkInt 0, mkArray [|mkInt 0|]) in
let r = ref confl in
let nc = ref 0 in
- while not (isRoot !r.kind) do r := prev !r; incr nc done;
+ while not (SmtTrace.isRoot !r.SmtCertif.kind) do r := SmtTrace.prev !r; incr nc done;
let last_root = !r in
- let size = !nc in
- let max = (Parray.trunc_size (Uint63.of_int 4194303)) - 1 in
- let q,r1 = size / max, size mod max in
-
- let trace =
- let len = if r1 = 0 then q + 1 else q + 2 in
- Array.make len (mkArray [|def_step|]) in
- for j = 0 to q - 1 do
- let tracej = Array.make (Parray.trunc_size (Uint63.of_int 4194303)) def_step in
- for i = 0 to max - 1 do
- r := next !r;
- tracej.(i) <- step_to_coq !r;
- done;
- trace.(j) <- mkArray tracej
- done;
- if r1 <> 0 then begin
- let traceq = Array.make (r1 + 1) def_step in
- for i = 0 to r1-1 do
- r := next !r;
- traceq.(i) <- step_to_coq !r;
- done;
- trace.(q) <- mkArray traceq
- end;
-
- (mkArray trace, last_root)
+ let res =
+ mkTrace step_to_coq SmtTrace.next !nc def_step r
+ in
+ (res, last_root)
let checker fdimacs ftrace =
SmtTrace.clear ();
- let _,first,last,reloc = import_cnf fdimacs in
+ let _,first,last,reloc = Zchaff.import_cnf fdimacs in
let d = make_roots first last in
- let max_id, confl = import_cnf_trace reloc ftrace first last in
+ let max_id, confl = Zchaff.import_cnf_trace reloc ftrace first last in
let (tres,_) =
- to_coq (fun _ -> assert false) certif_ops confl in
+ to_coq (fun (pos, args) -> Sat_checker.Sat_Checker.Res (pos, args)) confl
+ in
let certif =
- Sat_Checker.Certif (mkInt (max_id + 1), tres, mkInt (get_pos confl)) in
+ Sat_checker.Sat_Checker.Certif (mkInt (max_id + 1), tres, mkInt (SmtTrace.get_pos confl))
+ in
- Sat_Checker.checker d certif
+ Sat_checker.Sat_Checker.checker d certif
diff --git a/src/extraction/zchaff_checker.mli b/src/extraction/zchaff_checker.mli
index 511fd97..f916eb2 100644
--- a/src/extraction/zchaff_checker.mli
+++ b/src/extraction/zchaff_checker.mli
@@ -10,16 +10,4 @@
(**************************************************************************)
-val mkInt : int -> ExtrNative.uint
-val mkArray : 'a array -> 'a ExtrNative.parray
-val make_roots :
- SatAtom.Form.t SmtCertif.clause ->
- 'a SmtCertif.clause -> ExtrNative.uint ExtrNative.parray ExtrNative.parray
-val to_coq :
- 'a ->
- 'b * 'c * 'd * 'e * 'f * 'g * 'h * 'i * 'j * 'k * 'l * 'm * 'n * 'o * 'p *
- 'q * 'r * 's * 't ->
- 'u SmtCertif.clause ->
- Sat_checker.Sat_Checker.step ExtrNative.parray ExtrNative.parray *
- 'u SmtCertif.clause
val checker : string -> string -> bool
diff --git a/src/smtlib2/smtlib2_genConstr.mli b/src/smtlib2/smtlib2_genConstr.mli
index 65f47b5..1299da5 100644
--- a/src/smtlib2/smtlib2_genConstr.mli
+++ b/src/smtlib2/smtlib2_genConstr.mli
@@ -14,6 +14,12 @@ val pp_symbol : Smtlib2_ast.symbol -> string
val parse_smt2bv : string -> bool list
val bigint_bv : Big_int.big_int -> int -> string
+(* For extraction *)
+val string_of_symbol : Smtlib2_ast.symbol -> string
+val sort_of_sort : Smtlib2_ast.sort -> SmtBtype.btype
+val make_root :
+ SmtAtom.Atom.reify_tbl -> SmtAtom.Form.reify -> Smtlib2_ast.term -> SmtAtom.Form.t
+
(* Import from an SMTLIB2 file *)
val import_smtlib2 :
SmtBtype.reify_tbl ->
diff --git a/src/trace/smtCommands.mli b/src/trace/smtCommands.mli
index d0ebb61..ed50a05 100644
--- a/src/trace/smtCommands.mli
+++ b/src/trace/smtCommands.mli
@@ -61,3 +61,6 @@ val tactic :
CoqInterface.constr_expr list -> CoqInterface.tactic
val model_string : Environ.env -> SmtBtype.reify_tbl -> 'a -> 'b -> 'c -> SExpr.t -> string
+
+(* For extraction *)
+val compute_roots : SmtAtom.Form.t list -> SmtAtom.Form.t SmtCertif.clause -> int list
diff --git a/src/verit/verit.mli b/src/verit/verit.mli
index d67051f..a041ce3 100644
--- a/src/verit/verit.mli
+++ b/src/verit/verit.mli
@@ -21,3 +21,12 @@ val checker_debug : string -> string -> unit
val theorem : CoqInterface.id -> string -> string -> unit
val tactic : int option -> EConstr.t -> CoqInterface.constr_expr list -> CoqInterface.tactic
val tactic_no_check : int option -> EConstr.t -> CoqInterface.constr_expr list -> CoqInterface.tactic
+
+(* For extraction *)
+val clear_all : unit -> unit
+val import_trace :
+ SmtAtom.Atom.reify_tbl ->
+ SmtAtom.Form.reify ->
+ string ->
+ (SmtAtom.Form.t SmtCertif.clause * SmtAtom.Form.t) option ->
+ SmtAtom.Form.t list -> int * SmtAtom.Form.t SmtCertif.clause
diff --git a/src/zchaff/zchaff.mli b/src/zchaff/zchaff.mli
index 5e67177..201a4c0 100644
--- a/src/zchaff/zchaff.mli
+++ b/src/zchaff/zchaff.mli
@@ -17,3 +17,11 @@ val theorem : CoqInterface.id -> string -> string -> unit
val theorem_abs : CoqInterface.id -> string -> string -> unit
val tactic : unit -> CoqInterface.tactic
val tactic_no_check : unit -> CoqInterface.tactic
+val import_cnf : string ->
+ int * SatAtom.Form.t SmtCertif.clause *
+ SatAtom.Form.t SmtCertif.clause *
+ (int, SatAtom.Form.t SmtCertif.clause) Hashtbl.t
+val import_cnf_trace : (int, 'a SmtCertif.clause) Hashtbl.t ->
+ string ->
+ SatAtom.Form.t SmtCertif.clause ->
+ 'a SmtCertif.clause -> int * 'a SmtCertif.clause
generated by cgit (git 2.34.1) at 2024-04-27 10:41:33 +0000