Some work on BigQ :

  * keep only one implementation of BigQ
  * QMake (ex-Q0Make) becomes functorial 
  * proofs in it have been reworked, some new functions (e.g. red, power)
  * BigQ.t is declared to be a setoid and a field



git-svn-id: svn+ssh://scm.gforge.inria.fr/svn/coq/trunk@11178 85f007b7-540e-0410-9357-904b9bb8a0f7

10 files changed, 1255 insertions, 5563 deletions

diff --git a/theories/Numbers/BigNumPrelude.v b/theories/Numbers/BigNumPrelude.v
index 10e208ead..c8eb5658b 100644
--- a/theories/Numbers/BigNumPrelude.v
+++ b/theories/Numbers/BigNumPrelude.v
@@ -329,7 +329,7 @@ Theorem Zmod_le_first: forall a b, 0 <= a -> 0 < b -> 0 <= a mod b <= a.
  Qed.
 
  Theorem Zgcd_div_pos a b:
-   (0 < b)%Z -> (0 < Zgcd a b)%Z -> (0 < b / Zgcd a b)%Z.
+   0 < b -> 0 < Zgcd a b -> 0 < b / Zgcd a b.
  Proof.
  intros a b Ha Hg.
  case (Zle_lt_or_eq 0 (b/Zgcd a b)); auto.
@@ -340,6 +340,58 @@ Theorem Zmod_le_first: forall a b, 0 <= a -> 0 < b -> 0 <= a mod b <= a.
  assert (F := (Zgcd_is_gcd a b)); inversion F; auto.
  Qed.
 
+ Theorem Zdiv_neg a b:
+   a < 0 -> 0 < b -> a / b < 0.
+ Proof.
+ intros a b Ha Hb.
+ assert (b > 0) by omega.
+ generalize (Z_mult_div_ge a _ H); intros.
+ assert (b * (a / b) < 0)%Z.
+  apply Zle_lt_trans with a; auto with zarith.
+ destruct b; try (compute in Hb; discriminate).
+ destruct (a/Zpos p)%Z.
+ compute in H1; discriminate.
+ compute in H1; discriminate.
+ compute; auto.
+ Qed.
+ 
+ Lemma Zgcd_Zabs : forall z z', Zgcd (Zabs z) z' = Zgcd z z'.
+ Proof.
+ destruct z; simpl; auto.
+ Qed.
+
+ Lemma Zgcd_sym : forall p q, Zgcd p q = Zgcd q p.
+ Proof.
+ intros.
+ apply Zis_gcd_gcd.
+ apply Zgcd_is_pos.
+ apply Zis_gcd_sym.
+ apply Zgcd_is_gcd.
+ Qed.
+
+ Lemma Zdiv_gcd_zero : forall a b, b / Zgcd a b = 0 -> b <> 0 -> 
+  Zgcd a b = 0.
+ Proof.
+ intros.
+ generalize (Zgcd_is_gcd a b); destruct 1.
+ destruct H2 as (k,Hk).
+ generalize H; rewrite Hk at 1.
+ destruct (Z_eq_dec (Zgcd a b) 0) as [H'|H']; auto.
+ rewrite Z_div_mult_full; auto.
+ intros; subst k; simpl in *; subst b; elim H0; auto.
+ Qed.
+
+ Lemma Zcompare_gt : forall (A:Type)(a a':A)(p q:Z),
+  match (p?=q)%Z with Gt => a | _ => a' end = 
+  if Z_le_gt_dec p q then a' else a.
+ Proof.
+ intros.
+ destruct Z_le_gt_dec as [H|H].
+ red in H.
+ destruct (p?=q)%Z; auto; elim H; auto.
+ rewrite H; auto.
+ Qed.
+
 Theorem Zbounded_induction :
   (forall Q : Z -> Prop, forall b : Z,
     Q 0 ->
diff --git a/theories/Numbers/Rational/BigQ/BigQ.v b/theories/Numbers/Rational/BigQ/BigQ.v
index 8323d7884..11c945f4e 100644
--- a/theories/Numbers/Rational/BigQ/BigQ.v
+++ b/theories/Numbers/Rational/BigQ/BigQ.v
@@ -10,17 +10,33 @@
 
 (*i $Id$ i*)
 
-Require Export QMake_base.
-Require Import QpMake.
-Require Import QvMake.
-Require Import Q0Make.
-Require Import QifMake.
-Require Import QbiMake.
+Require Import Field Qfield BigN BigZ QSig QMake.
 
-(* We choose for Q the implemention with
-   multiple representation of 0: 0, 1/0, 2/0 etc *)
+(** We choose for BigQ an implemention with
+    multiple representation of 0: 0, 1/0, 2/0 etc.
+    See [QMake.v] *)
 
-Module BigQ <: QSig.QType := Q0.
+(** First, we provide translations functions between [BigN] and [BigZ] *)
+
+Module BigN_BigZ <: NType_ZType BigN.BigN BigZ.
+ Definition Z_of_N := BigZ.Pos.
+ Lemma spec_Z_of_N : forall n, BigZ.to_Z (Z_of_N n) = BigN.to_Z n.
+ Proof.
+ reflexivity.
+ Qed.
+ Definition Zabs_N := BigZ.to_N.
+ Lemma spec_Zabs_N : forall z, BigN.to_Z (Zabs_N z) = Zabs (BigZ.to_Z z).
+ Proof.
+ unfold Zabs_N; intros.
+ rewrite BigZ.spec_to_Z, Zmult_comm; apply Zsgn_Zabs.
+ Qed.
+End BigN_BigZ.
+
+(** This allows to build [BigQ] out of [BigN] and [BigQ] via [QMake] *)
+
+Module BigQ <: QSig.QType := QMake.Make BigN BigZ BigN_BigZ.
+
+(** Notations about [BigQ] *)
 
 Notation bigQ := BigQ.t.
 
@@ -28,8 +44,148 @@ Delimit Scope bigQ_scope with bigQ.
 Bind Scope bigQ_scope with bigQ.
 Bind Scope bigQ_scope with BigQ.t.
 
-Notation " i + j " := (BigQ.add i j) : bigQ_scope.
-Notation " i - j " := (BigQ.sub i j) : bigQ_scope.
-Notation " i * j " := (BigQ.mul i j) : bigQ_scope.
-Notation " i / j " := (BigQ.div i j) : bigQ_scope.
-Notation " i ?= j " := (BigQ.compare i j) : bigQ_scope.
+Infix "+" := BigQ.add : bigQ_scope.
+Infix "-" := BigQ.sub : bigQ_scope.
+Notation "- x" := (BigQ.opp x) : bigQ_scope.
+Infix "*" := BigQ.mul : bigQ_scope.
+Infix "/" := BigQ.div : bigQ_scope.
+Infix "^" := BigQ.power : bigQ_scope.
+Infix "?=" := BigQ.compare : bigQ_scope.
+Infix "==" := BigQ.eq : bigQ_scope.
+Infix "<" := BigQ.lt : bigQ_scope.
+Infix "<=" := BigQ.le : bigQ_scope.
+Notation "[ q ]" := (BigQ.to_Q q) : bigQ_scope. 
+
+Open Scope bigQ_scope.
+
+(** [BigQ] is a setoid *)
+
+Add Relation BigQ.t BigQ.eq
+ reflexivity proved by (fun x => Qeq_refl [x])
+ symmetry proved by (fun x y => Qeq_sym [x] [y])
+ transitivity proved by (fun x y z => Qeq_trans [x] [y] [z])
+as BigQeq_rel.
+
+Add Morphism BigQ.add with signature BigQ.eq ==> BigQ.eq ==> BigQ.eq as BigQadd_wd.
+Proof.
+ unfold BigQ.eq; intros; rewrite !BigQ.spec_add; rewrite H, H0; apply Qeq_refl.
+Qed.
+
+Add Morphism BigQ.opp with signature BigQ.eq ==> BigQ.eq as BigQopp_wd.
+Proof.
+ unfold BigQ.eq; intros; rewrite !BigQ.spec_opp; rewrite H; apply Qeq_refl.
+Qed.
+
+Add Morphism BigQ.sub with signature BigQ.eq ==> BigQ.eq ==> BigQ.eq as BigQsub_wd.
+Proof.
+ unfold BigQ.eq; intros; rewrite !BigQ.spec_sub; rewrite H, H0; apply Qeq_refl.
+Qed.
+
+Add Morphism BigQ.mul with signature BigQ.eq ==> BigQ.eq ==> BigQ.eq as BigQmul_wd.
+Proof.
+ unfold BigQ.eq; intros; rewrite !BigQ.spec_mul; rewrite H, H0; apply Qeq_refl.
+Qed.
+
+Add Morphism BigQ.inv with signature BigQ.eq ==> BigQ.eq as BigQinv_wd.
+Proof.
+ unfold BigQ.eq; intros; rewrite !BigQ.spec_inv; rewrite H; apply Qeq_refl.
+Qed.
+
+Add Morphism BigQ.div with signature BigQ.eq ==> BigQ.eq ==> BigQ.eq as BigQdiv_wd.
+Proof.
+ unfold BigQ.eq; intros; rewrite !BigQ.spec_div; rewrite H, H0; apply Qeq_refl.
+Qed.
+
+(* TODO : fix this. For the moment it's useless (horribly slow)
+Hint Rewrite 
+ BigQ.spec_0 BigQ.spec_1 BigQ.spec_m1 BigQ.spec_compare
+ BigQ.spec_red BigQ.spec_add BigQ.spec_sub BigQ.spec_opp 
+ BigQ.spec_mul BigQ.spec_inv BigQ.spec_div BigQ.spec_power_pos
+ BigQ.spec_square : bigq. *)
+
+
+(** [BigQ] is a field *)
+
+Lemma BigQfieldth : 
+ field_theory BigQ.zero BigQ.one BigQ.add BigQ.mul BigQ.sub BigQ.opp BigQ.div BigQ.inv BigQ.eq.
+Proof.
+constructor.
+constructor; intros; red.
+rewrite BigQ.spec_add, BigQ.spec_0; ring.
+rewrite ! BigQ.spec_add; ring.
+rewrite ! BigQ.spec_add; ring.
+rewrite BigQ.spec_mul, BigQ.spec_1; ring.
+rewrite ! BigQ.spec_mul; ring.
+rewrite ! BigQ.spec_mul; ring.
+rewrite BigQ.spec_add, ! BigQ.spec_mul, BigQ.spec_add; ring.
+unfold BigQ.sub; apply Qeq_refl.
+rewrite BigQ.spec_add, BigQ.spec_0, BigQ.spec_opp; ring.
+compute; discriminate.
+intros; red.
+unfold BigQ.div; apply Qeq_refl.
+intros; red.
+rewrite BigQ.spec_mul, BigQ.spec_inv, BigQ.spec_1; field.
+rewrite <- BigQ.spec_0; auto.
+Qed.
+
+Lemma BigQpowerth : 
+ power_theory BigQ.one BigQ.mul BigQ.eq Z_of_N BigQ.power.
+Proof.
+constructor.
+intros; red.
+rewrite BigQ.spec_power.
+replace ([r] ^ Z_of_N n)%Q with (pow_N 1 Qmult [r] n)%Q.
+destruct n.
+simpl; compute; auto.
+induction p; simpl; auto; try rewrite !BigQ.spec_mul, !IHp; apply Qeq_refl.
+destruct n; reflexivity.
+Qed.
+
+Lemma BigQ_eq_bool_correct : 
+ forall x y, BigQ.eq_bool x y = true -> x==y.
+Proof.
+intros; generalize (BigQ.spec_eq_bool x y); rewrite H; auto.
+Qed.
+
+Lemma BigQ_eq_bool_complete : 
+ forall x y, x==y -> BigQ.eq_bool x y = true.
+Proof.
+intros; generalize (BigQ.spec_eq_bool x y).
+destruct BigQ.eq_bool; auto.
+Qed.
+
+(* TODO : improve later the detection of constants ... *)
+
+Ltac BigQcst t := 
+ match t with 
+   | BigQ.zero => BigQ.zero
+   | BigQ.one => BigQ.one
+   | BigQ.minus_one => BigQ.minus_one
+   | _ => NotConstant 
+ end.
+
+Add Field BigQfield : BigQfieldth 
+ (decidable BigQ_eq_bool_correct, 
+  completeness BigQ_eq_bool_complete,
+  constants [BigQcst],
+  power_tac BigQpowerth [Qpow_tac]).
+
+Section Examples.
+
+Let ex1 : forall x y z, (x+y)*z ==  (x*z)+(y*z).
+  intros.
+  ring.
+Qed.
+
+Let ex8 : forall x, x ^ 1 == x.
+  intro.
+  ring.
+Qed.
+
+Let ex10 : forall x y, ~(y==BigQ.zero) -> (x/y)*y == x.
+intros.
+field.
+auto.
+Qed.
+
+End Examples.
\ No newline at end of file
diff --git a/theories/Numbers/Rational/BigQ/Q0Make.v b/theories/Numbers/Rational/BigQ/Q0Make.v
deleted file mode 100644
index ba49f59e6..000000000
--- a/theories/Numbers/Rational/BigQ/Q0Make.v
+++ /dev/null
@@ -1,1412 +0,0 @@
-(************************************************************************)
-(*  v      *   The Coq Proof Assistant  /  The Coq Development Team     *)
-(* <O___,, * CNRS-Ecole Polytechnique-INRIA Futurs-Universite Paris Sud *)
-(*   \VV/  **************************************************************)
-(*    //   *      This file is distributed under the terms of the       *)
-(*         *       GNU Lesser General Public License Version 2.1        *)
-(************************************************************************)
-(*            Benjamin Gregoire, Laurent Thery, INRIA, 2007             *)
-(************************************************************************)
-
-(*i $Id$ i*)
-
-Require Import Bool.
-Require Import ZArith.
-Require Import Znumtheory.
-Require Import BigNumPrelude.
-Require Import Arith.
-Require Export BigN.
-Require Export BigZ.
-Require Import QArith.
-Require Import Qcanon.
-Require Import Qpower.
-Require Import QSig.
-Require Import QMake_base.
-
-Module Q0 <: QType.
-
- Import BinInt Zorder.
-
- (** The notation of a rational number is either an integer x,
-     interpreted as itself or a pair (x,y) of an integer x and a natural
-     number y interpreted as x/y. The pairs (x,0) and (0,y) are all
-     interpreted as 0. *)
-
- Definition t := q_type.
-
- (** Specification with respect to [QArith] *) 
-
- Open Local Scope Q_scope.
-
- Definition of_Z x: t := Qz (BigZ.of_Z x).
-
- Definition of_Q q: t := 
- match q with x # y =>
-  Qq (BigZ.of_Z x) (BigN.of_N (Npos y))
- end.
-
- Definition to_Q (q: t) := 
- match q with 
-  Qz x => BigZ.to_Z x # 1
- |Qq x y => if BigN.eq_bool y BigN.zero then 0
-            else BigZ.to_Z x # Z2P (BigN.to_Z y)
- end.
-
- Notation "[ x ]" := (to_Q x).
-
- Theorem strong_spec_of_Q: forall q: Q, [of_Q q] = q.
- Proof.
- intros (x,y); simpl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-  generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto; rewrite BigN.spec_0.
-   rewrite BigN.spec_of_pos; intros HH; discriminate HH.
- rewrite BigZ.spec_of_Z; simpl.
- rewrite (BigN.spec_of_pos); auto.
- Qed.
-
- Theorem spec_of_Q: forall q: Q, [of_Q q] == q.
- Proof.
- intros; rewrite strong_spec_of_Q; red; auto.
- Qed.
-
- Definition eq x y := [x] == [y].
-
- Definition zero: t := Qz BigZ.zero.
- Definition one: t := Qz BigZ.one.
- Definition minus_one: t := Qz BigZ.minus_one.
-
- Lemma spec_0: [zero] == 0.
- Proof.
- reflexivity.
- Qed.
-
- Lemma spec_1: [one] == 1.
- Proof.
- reflexivity.
- Qed.
-
- Lemma spec_m1: [minus_one] == -(1).
- Proof.
- reflexivity.
- Qed.
-
- Definition opp (x: t): t :=
-  match x with
-  | Qz zx => Qz (BigZ.opp zx)
-  | Qq nx dx => Qq (BigZ.opp nx) dx
-  end.
-
- Theorem strong_spec_opp: forall q, [opp q] = -[q].
- Proof.
- intros [z | x y]; simpl.
- rewrite BigZ.spec_opp; auto.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-  generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto; rewrite BigN.spec_0.
- rewrite BigZ.spec_opp; auto.
- Qed.
-
- Theorem spec_opp : forall q, [opp q] == -[q].
- Proof.
- intros; rewrite strong_spec_opp; red; auto.
- Qed.
-
- Definition compare (x y: t) :=
-  match x, y with
-  | Qz zx, Qz zy => BigZ.compare zx zy
-  | Qz zx, Qq ny dy => 
-    if BigN.eq_bool dy BigN.zero then BigZ.compare zx BigZ.zero
-    else BigZ.compare (BigZ.mul zx (BigZ.Pos dy)) ny
-  | Qq nx dx, Qz zy => 
-    if BigN.eq_bool dx BigN.zero then BigZ.compare BigZ.zero zy 
-    else BigZ.compare nx (BigZ.mul zy (BigZ.Pos dx))
-  | Qq nx dx, Qq ny dy =>
-    match BigN.eq_bool dx BigN.zero, BigN.eq_bool dy BigN.zero with
-    | true, true => Eq
-    | true, false => BigZ.compare BigZ.zero ny
-    | false, true => BigZ.compare nx BigZ.zero
-    | false, false => BigZ.compare (BigZ.mul nx (BigZ.Pos dy)) (BigZ.mul ny (BigZ.Pos dx))
-    end
-  end.
-
- Theorem spec_compare: forall q1 q2, (compare q1 q2) = ([q1] ?= [q2]).
- Proof.
- intros [z1 | x1 y1] [z2 | x2 y2]; 
-   unfold Qcompare, compare, to_Q, Qnum, Qden.
- repeat rewrite Zmult_1_r.
- generalize (BigZ.spec_compare z1 z2); case BigZ.compare; intros H; auto.
- rewrite H; rewrite Zcompare_refl; auto.
- rewrite Zmult_1_r.
- generalize (BigN.spec_eq_bool y2 BigN.zero);
-   case BigN.eq_bool; rewrite BigN.spec_0; intros HH.
- rewrite Zmult_1_r; generalize (BigZ.spec_compare z1 BigZ.zero);
-  case BigZ.compare; auto.
- rewrite BigZ.spec_0; intros HH1; rewrite HH1; rewrite Zcompare_refl; auto.
- rewrite Z2P_correct; auto with zarith.
-  2: generalize (BigN.spec_pos y2); auto with zarith.
- generalize (BigZ.spec_compare (z1 * BigZ.Pos y2) x2)%bigZ; case BigZ.compare;
-   rewrite BigZ.spec_mul; simpl; intros H; apply sym_equal; auto.
- rewrite H; rewrite Zcompare_refl; auto.
- generalize (BigN.spec_eq_bool y1 BigN.zero);
-   case BigN.eq_bool; rewrite BigN.spec_0; intros HH.
- rewrite Zmult_0_l; rewrite Zmult_1_r.
- generalize (BigZ.spec_compare BigZ.zero z2);
-  case BigZ.compare; auto.
- rewrite BigZ.spec_0; intros HH1; rewrite <- HH1; rewrite Zcompare_refl; auto.
- rewrite Z2P_correct; auto with zarith.
-  2: generalize (BigN.spec_pos y1); auto with zarith.
- rewrite Zmult_1_r.
- generalize (BigZ.spec_compare x1 (z2 * BigZ.Pos y1))%bigZ; case BigZ.compare;
-   rewrite BigZ.spec_mul; simpl; intros H; apply sym_equal; auto.
- rewrite H; rewrite Zcompare_refl; auto.
- generalize (BigN.spec_eq_bool y1 BigN.zero);
-   case BigN.eq_bool; rewrite BigN.spec_0; intros HH.
- generalize (BigN.spec_eq_bool y2 BigN.zero);
-   case BigN.eq_bool; rewrite BigN.spec_0; intros HH1.
- rewrite Zcompare_refl; auto.
- rewrite Zmult_0_l; rewrite Zmult_1_r.
- generalize (BigZ.spec_compare BigZ.zero x2);
-  case BigZ.compare; auto.
- rewrite BigZ.spec_0; intros HH2; rewrite <- HH2; rewrite Zcompare_refl; auto.
- generalize (BigN.spec_eq_bool y2 BigN.zero);
-   case BigN.eq_bool; rewrite BigN.spec_0; intros HH1.
- rewrite Zmult_0_l; rewrite Zmult_1_r.
- generalize (BigZ.spec_compare x1 BigZ.zero)%bigZ; case BigZ.compare;
-   auto; rewrite BigZ.spec_0.
- intros HH2; rewrite <- HH2; rewrite Zcompare_refl; auto.
- repeat rewrite Z2P_correct.
-  2: generalize (BigN.spec_pos y1); auto with zarith.
-  2: generalize (BigN.spec_pos y2); auto with zarith.
- generalize (BigZ.spec_compare (x1 * BigZ.Pos y2) 
-                               (x2 * BigZ.Pos y1))%bigZ; case BigZ.compare;
-   repeat rewrite BigZ.spec_mul; simpl; intros H; apply sym_equal; auto.
- rewrite H; rewrite Zcompare_refl; auto.
- Qed.
-
- Definition lt n m := compare n m = Lt.
- Definition le n m := compare n m <> Gt.
- Definition min n m := match compare n m with Gt => m | _ => n end.
- Definition max n m := match compare n m with Lt => m | _ => n end.
-
-(* Je pense que cette fonction normalise bien ... *)
- Definition norm n d: t :=
-  let gcd := BigN.gcd (BigZ.to_N n) d in 
-  match BigN.compare BigN.one gcd with
-  | Lt => 
-    let n := BigZ.div n (BigZ.Pos gcd) in
-    let d := BigN.div d gcd in
-    match BigN.compare d BigN.one with
-    | Gt => Qq n d
-    | Eq => Qz n
-    | Lt => zero
-    end
-  | Eq => Qq n d
-  | Gt => zero (* gcd = 0 => both numbers are 0 *)
-  end.
-
- Theorem spec_norm: forall n q, [norm n q] == [Qq n q].
- Proof.
- intros p q; unfold norm.
- assert (Hp := BigN.spec_pos (BigZ.to_N p)).
- match goal with  |- context[BigN.compare ?X ?Y] => 
-   generalize (BigN.spec_compare X Y); case BigN.compare
- end; auto; rewrite BigN.spec_1; rewrite BigN.spec_gcd; intros H1.
-   apply Qeq_refl.
- generalize (BigN.spec_pos (q / BigN.gcd (BigZ.to_N p) q)%bigN).
- match goal with  |- context[BigN.compare ?X ?Y] => 
-   generalize (BigN.spec_compare X Y); case BigN.compare
- end; auto; rewrite BigN.spec_1; rewrite BigN.spec_div; 
-   rewrite BigN.spec_gcd; auto with zarith; intros H2 HH.
- red; simpl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto; rewrite BigN.spec_0; intros H3; simpl;
-  rewrite BigZ.spec_div; simpl; rewrite BigN.spec_gcd;
-  auto with zarith.
- generalize H2; rewrite H3; 
-   rewrite Zdiv_0_l; auto with zarith.
- generalize H1 H2 H3 (BigN.spec_pos q); clear H1 H2 H3.
- rewrite spec_to_N.
- set (a := (BigN.to_Z (BigZ.to_N p))).
- set (b := (BigN.to_Z q)).
- intros H1 H2 H3 H4; rewrite Z2P_correct; auto with zarith.
- rewrite Zgcd_div_swap; auto with zarith.
- rewrite H2; ring.
- red; simpl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto; rewrite BigN.spec_0; intros H3; simpl.
- case H3.
- generalize H1 H2 H3 HH; clear H1 H2 H3 HH.
- set (a := (BigN.to_Z (BigZ.to_N p))).
- set (b := (BigN.to_Z q)).
- intros H1 H2 H3 HH.
-  rewrite (Zdivide_Zdiv_eq (Zgcd a b) b); auto with zarith.
- case (Zle_lt_or_eq _ _ HH); auto with zarith.
- intros HH1; rewrite <- HH1; ring.
- generalize (Zgcd_is_gcd a b); intros HH1; inversion HH1; auto.
- red; simpl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto; rewrite BigN.spec_0; rewrite BigN.spec_div;
-   rewrite BigN.spec_gcd; auto with zarith; intros H3.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto; rewrite BigN.spec_0; intros H4.
- case H3; rewrite H4;  rewrite Zdiv_0_l; auto with zarith.
- simpl.
- assert (FF := BigN.spec_pos q).
- rewrite Z2P_correct; auto with zarith.
- rewrite <- BigN.spec_gcd; rewrite <- BigN.spec_div; auto with zarith.
- rewrite Z2P_correct; auto with zarith.
- rewrite BigN.spec_div; rewrite BigN.spec_gcd; auto with zarith.
- simpl; rewrite BigZ.spec_div; simpl.
- rewrite BigN.spec_gcd; auto with zarith.
- generalize H1 H2 H3 H4 HH FF; clear H1 H2 H3 H4 HH FF.
- set (a := (BigN.to_Z (BigZ.to_N p))).
- set (b := (BigN.to_Z q)).
- intros H1 H2 H3 H4 HH FF.
- rewrite spec_to_N; fold a.
- rewrite Zgcd_div_swap; auto with zarith.
- rewrite BigN.spec_gcd; auto with zarith.
- rewrite BigN.spec_div; 
-   rewrite BigN.spec_gcd; auto with zarith.
- rewrite BigN.spec_gcd; auto with zarith.
- case (Zle_lt_or_eq _ _ 
-   (BigN.spec_pos (BigN.gcd (BigZ.to_N p) q)));
-  rewrite BigN.spec_gcd; auto with zarith.
- intros; apply False_ind; auto with zarith.
- intros HH2; assert (FF1 := Zgcd_inv_0_l _ _ (sym_equal HH2)).
- assert (FF2 := Zgcd_inv_0_l _ _ (sym_equal HH2)).
- red; simpl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto; rewrite BigN.spec_0; intros H2; simpl.
- rewrite spec_to_N.
- rewrite FF2; ring.
- Qed.
-
-   
- Definition add (x y: t): t :=
-  match x with
-  | Qz zx =>
-    match y with
-    | Qz zy => Qz (BigZ.add zx zy)
-    | Qq ny dy => 
-      if BigN.eq_bool dy BigN.zero then x 
-      else Qq (BigZ.add (BigZ.mul zx (BigZ.Pos dy)) ny) dy
-    end
-  | Qq nx dx =>
-    if BigN.eq_bool dx BigN.zero then y 
-    else match y with
-    | Qz zy => Qq (BigZ.add nx (BigZ.mul zy (BigZ.Pos dx))) dx
-    | Qq ny dy =>
-      if BigN.eq_bool dy BigN.zero then x
-      else
-       let n := BigZ.add (BigZ.mul nx (BigZ.Pos dy)) (BigZ.mul ny (BigZ.Pos dx)) in
-       let d := BigN.mul dx dy in
-       Qq n d
-    end
-  end.
-
- Theorem spec_add : forall x y, [add x y] == [x] + [y].
- Proof.
- intros [x | nx dx] [y | ny dy]; unfold Qplus; simpl.
- rewrite BigZ.spec_add; repeat rewrite Zmult_1_r; auto.
-  intros; apply Qeq_refl; auto.
- assert (F1:= BigN.spec_pos dy).
- rewrite Zmult_1_r; red; simpl.
- generalize (BigN.spec_eq_bool dy BigN.zero);
-   case BigN.eq_bool;
-   rewrite BigN.spec_0; intros HH; simpl; try ring.
- generalize (BigN.spec_eq_bool dy BigN.zero);
-   case BigN.eq_bool;
-   rewrite BigN.spec_0; intros HH1; simpl; try ring.
- case HH; auto.
- rewrite Z2P_correct; auto with zarith.
- rewrite BigZ.spec_add; rewrite BigZ.spec_mul; simpl; auto.
- generalize (BigN.spec_eq_bool dx BigN.zero);
-   case BigN.eq_bool;
-   rewrite BigN.spec_0; intros HH; simpl; try ring.
- rewrite Zmult_1_r; apply Qeq_refl.
- generalize (BigN.spec_eq_bool dx BigN.zero);
-   case BigN.eq_bool;
-   rewrite BigN.spec_0; intros HH1; simpl; try ring.
- case HH; auto.
- rewrite Z2P_correct; auto with zarith.
- rewrite BigZ.spec_add; rewrite BigZ.spec_mul; simpl; auto.
- rewrite Zmult_1_r; rewrite Pmult_1_r.
- apply Qeq_refl.
- assert (F1:= BigN.spec_pos dx); auto with zarith.
- generalize (BigN.spec_eq_bool dx BigN.zero);
-   case BigN.eq_bool; rewrite BigN.spec_0; intros HH.
- generalize (BigN.spec_eq_bool dy BigN.zero);
-   case BigN.eq_bool; rewrite BigN.spec_0; intros HH1.
- simpl.
- generalize (BigN.spec_eq_bool dy BigN.zero);
-   case BigN.eq_bool; rewrite BigN.spec_0; intros HH2.
- apply Qeq_refl.
- case HH2; auto.
- simpl.
- generalize (BigN.spec_eq_bool dy BigN.zero);
-   case BigN.eq_bool; rewrite BigN.spec_0; intros HH2.
- case HH2; auto.
- case HH1; auto.
- rewrite Zmult_1_r; apply Qeq_refl.
- generalize (BigN.spec_eq_bool dy BigN.zero);
-   case BigN.eq_bool; rewrite BigN.spec_0; intros HH1.
- simpl.
- generalize (BigN.spec_eq_bool dx BigN.zero);
-   case BigN.eq_bool; rewrite BigN.spec_0; intros HH2.
- case HH; auto.
- rewrite Zmult_1_r; rewrite Zplus_0_r; rewrite Pmult_1_r.
- apply Qeq_refl.
- simpl.
- generalize (BigN.spec_eq_bool (dx * dy)%bigN BigN.zero);
-   case BigN.eq_bool; rewrite BigN.spec_mul;
-   rewrite BigN.spec_0; intros HH2.
- (case (Zmult_integral _ _ HH2); intros HH3);
-  [case HH| case HH1]; auto.
- rewrite BigZ.spec_add; repeat rewrite BigZ.spec_mul; simpl.
- assert (Fx: (0 < BigN.to_Z dx)%Z).
-   generalize (BigN.spec_pos dx); auto with zarith.
- assert (Fy: (0 < BigN.to_Z dy)%Z).
-   generalize (BigN.spec_pos dy); auto with zarith.
- red; simpl; rewrite Zpos_mult_morphism.
- repeat rewrite Z2P_correct; auto with zarith.
- apply Zmult_lt_0_compat; auto.
- Qed.
-
- Definition add_norm (x y: t): t :=
-  match x with
-  | Qz zx =>
-    match y with
-    | Qz zy => Qz (BigZ.add zx zy)
-    | Qq ny dy =>  
-      if BigN.eq_bool dy BigN.zero then x 
-      else norm (BigZ.add (BigZ.mul zx (BigZ.Pos dy)) ny) dy
-    end
-  | Qq nx dx =>
-    if BigN.eq_bool dx BigN.zero then y 
-    else match y with
-    | Qz zy => norm (BigZ.add nx (BigZ.mul zy (BigZ.Pos dx))) dx
-    | Qq ny dy =>
-      if BigN.eq_bool dy BigN.zero then x
-      else
-       let n := BigZ.add (BigZ.mul nx (BigZ.Pos dy)) (BigZ.mul ny (BigZ.Pos dx)) in
-       let d := BigN.mul dx dy in
-       norm n d
-    end
-  end.
-
- Theorem spec_add_norm : forall x y, [add_norm x y] == [x] + [y].
- Proof.
- intros x y; rewrite <- spec_add; auto.
- case x; case y; clear x y; unfold add_norm, add.
-  intros; apply Qeq_refl.
- intros p1 n p2.
- generalize (BigN.spec_eq_bool n BigN.zero);
-   case BigN.eq_bool; rewrite BigN.spec_0; intros HH.
- apply Qeq_refl.
- match goal with |- [norm ?X ?Y] == _ =>
-  apply Qeq_trans with ([Qq X Y]);
-  [apply spec_norm | idtac]
- end.
- simpl.
- generalize (BigN.spec_eq_bool n BigN.zero);
-   case BigN.eq_bool; rewrite BigN.spec_0; intros HH1.
- apply Qeq_refl.
- apply Qeq_refl.
- intros p1 p2 n.
- generalize (BigN.spec_eq_bool n BigN.zero);
-   case BigN.eq_bool; rewrite BigN.spec_0; intros HH.
- apply Qeq_refl.
- match goal with |- [norm ?X ?Y] == _ =>
-  apply Qeq_trans with ([Qq X Y]);
-  [apply spec_norm | idtac]
- end.
- apply Qeq_refl.
- intros p1 q1 p2 q2.
- generalize (BigN.spec_eq_bool q2 BigN.zero);
-   case BigN.eq_bool; rewrite BigN.spec_0; intros HH1.
- apply Qeq_refl.
- generalize (BigN.spec_eq_bool q1 BigN.zero);
-   case BigN.eq_bool; rewrite BigN.spec_0; intros HH2.
- apply Qeq_refl.
- match goal with |- [norm ?X ?Y] == _ =>
-  apply Qeq_trans with ([Qq X Y]);
-  [apply spec_norm | idtac]
- end.
- apply Qeq_refl.
- Qed.
-
- Definition sub x y := add x (opp y).
-
- Theorem spec_sub : forall x y, [sub x y] == [x] - [y].
- Proof.
- intros x y; unfold sub; rewrite spec_add; auto.
- rewrite spec_opp; ring.
- Qed.
-
- Definition sub_norm x y := add_norm x (opp y).
-
- Theorem spec_sub_norm : forall x y, [sub_norm x y] == [x] - [y].
- Proof.
- intros x y; unfold sub_norm; rewrite spec_add_norm; auto.
- rewrite spec_opp; ring.
- Qed.
-
- Definition mul (x y: t): t :=
-  match x, y with
-  | Qz zx, Qz zy => Qz (BigZ.mul zx zy)
-  | Qz zx, Qq ny dy => Qq (BigZ.mul zx ny) dy
-  | Qq nx dx, Qz zy => Qq (BigZ.mul nx zy) dx
-  | Qq nx dx, Qq ny dy => Qq (BigZ.mul nx ny) (BigN.mul dx dy)
-  end.
-
- Theorem spec_mul : forall x y, [mul x y] == [x] * [y].
- Proof.
- intros [x | nx dx] [y | ny dy]; unfold Qmult; simpl.
- rewrite BigZ.spec_mul; repeat rewrite Zmult_1_r; auto.
-  intros; apply Qeq_refl; auto.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end;  rewrite BigN.spec_0; intros HH1.
- red; simpl; ring.
- rewrite BigZ.spec_mul; apply Qeq_refl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros HH1.
- red; simpl; ring.
- rewrite BigZ.spec_mul; rewrite Pmult_1_r.
- apply Qeq_refl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0;  rewrite BigN.spec_mul;
-      intros HH1.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros HH2.
- red; simpl; auto.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros HH3.
- red; simpl; ring.
- case (Zmult_integral _ _ HH1); intros HH.
-   case HH2; auto.
-   case HH3; auto.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros HH2.
- case HH1; rewrite HH2; ring.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros HH3.
- case HH1; rewrite HH3; ring.
- rewrite BigZ.spec_mul.
- assert (tmp: 
-  (forall a b, 0 < a -> 0 < b -> Z2P (a * b) = (Z2P a * Z2P b)%positive)%Z).
-  intros [|a|a] [|b|b]; simpl; auto; intros; apply False_ind; auto with zarith.
- rewrite tmp; auto.
- apply Qeq_refl.
-  generalize (BigN.spec_pos dx); auto with zarith.
-  generalize (BigN.spec_pos dy); auto with zarith.
- Qed.
-
-Definition mul_norm (x y: t): t := 
- match x, y with
- | Qz zx, Qz zy => Qz (BigZ.mul zx zy)
- | Qz zx, Qq ny dy =>
-   if BigZ.eq_bool zx BigZ.zero then zero
-   else	
-     let gcd := BigN.gcd (BigZ.to_N zx) dy in
-     match BigN.compare gcd BigN.one with
-       Gt => 
-       let zx := BigZ.div zx (BigZ.Pos gcd) in
-       let d := BigN.div dy gcd in
-       if BigN.eq_bool d BigN.one then Qz (BigZ.mul zx ny)
-       else Qq (BigZ.mul zx ny) d
-      | _  => Qq (BigZ.mul zx ny) dy
-     end
- | Qq nx dx, Qz zy =>   
-   if BigZ.eq_bool zy BigZ.zero then zero
-   else	
-     let gcd := BigN.gcd (BigZ.to_N zy) dx in
-     match BigN.compare gcd BigN.one with
-       Gt => 
-       let zy := BigZ.div zy (BigZ.Pos gcd) in
-       let d := BigN.div dx gcd in
-       if BigN.eq_bool d BigN.one then Qz (BigZ.mul zy nx)
-       else Qq (BigZ.mul zy nx) d
-     | _ =>  Qq (BigZ.mul zy nx) dx
-     end
- | Qq nx dx, Qq ny dy => 
-     let (nx, dy) := 
-       let gcd := BigN.gcd (BigZ.to_N nx) dy in
-       match BigN.compare gcd BigN.one with 
-        Gt => (BigZ.div nx (BigZ.Pos gcd), BigN.div dy gcd)
-       | _ => (nx, dy)
-       end in
-     let (ny, dx) := 
-       let gcd := BigN.gcd (BigZ.to_N ny) dx in
-       match BigN.compare gcd BigN.one with 
-        Gt =>  (BigZ.div ny (BigZ.Pos gcd), BigN.div dx gcd) 
-       | _ =>  (ny, dx)
-       end in 
-     let d := (BigN.mul dx dy) in
-     if BigN.eq_bool d BigN.one then Qz (BigZ.mul ny nx) 
-     else Qq (BigZ.mul ny nx) d
- end.
-
- Theorem spec_mul_norm : forall x y, [mul_norm x y] == [x] * [y].
- Proof.
- intros x y; rewrite <- spec_mul; auto.
- unfold mul_norm, mul; case x; case y; clear x y.
-  intros; apply Qeq_refl.
- intros p1 n p2.
- set (a := BigN.to_Z (BigZ.to_N p2)).
- set (b := BigN.to_Z n).
- match goal with  |- context[BigZ.eq_bool ?X ?Y] => 
-   generalize (BigZ.spec_eq_bool X Y); case BigZ.eq_bool
- end; unfold zero, to_Q; repeat rewrite BigZ.spec_0; intros H.
- case BigN.eq_bool; try apply Qeq_refl.
- rewrite BigZ.spec_mul; rewrite H.
- red; simpl; ring.
- assert (F: (0 < a)%Z).
-  case (Zle_lt_or_eq _ _ (BigN.spec_pos (BigZ.to_N p2))); auto.
-  intros H1; case H; rewrite spec_to_N; rewrite <- H1; ring.
- match goal with  |- context[BigN.compare ?X ?Y] => 
-   generalize (BigN.spec_compare X Y); case BigN.compare
- end; rewrite BigN.spec_1; rewrite BigN.spec_gcd;
-      fold a b; intros H1.
- apply Qeq_refl.
- apply Qeq_refl.
- assert (F0 : (0 < (Zgcd a b))%Z).
-   apply Zlt_trans with 1%Z.
-   red; auto.
-   apply Zgt_lt; auto.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_1; rewrite BigN.spec_div;
- rewrite BigN.spec_gcd; auto with zarith; 
- fold a b; intros H2.
- assert (F1: b = Zgcd a b).
-   pattern b at 1; rewrite (Zdivide_Zdiv_eq (Zgcd a b) b);
-   auto with zarith.
-   rewrite H2; ring.
-   assert (FF := Zgcd_is_gcd a b); inversion FF; auto.
- assert (F2: (0 < b)%Z).
-   rewrite F1; auto.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; fold b; intros H3.
- rewrite H3 in F2; discriminate F2.
- rewrite BigZ.spec_mul.
- rewrite BigZ.spec_div; simpl; rewrite BigN.spec_gcd; 
-  fold a b; auto with zarith.
- rewrite BigZ.spec_mul.
- red; simpl; rewrite Z2P_correct; auto.
- rewrite Zmult_1_r; rewrite spec_to_N; fold a b.
- repeat rewrite <- Zmult_assoc.
- rewrite (Zmult_comm (BigZ.to_Z p1)).
- repeat rewrite Zmult_assoc.
- rewrite Zgcd_div_swap; auto with zarith.
- rewrite H2; ring.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; rewrite BigN.spec_div;
- rewrite BigN.spec_gcd; fold a b; auto; intros H3.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H4.
- apply Qeq_refl.
- case H4; fold b.
- rewrite (Zdivide_Zdiv_eq (Zgcd a b) b); auto.
- rewrite H3; ring.
- assert (FF := Zgcd_is_gcd a b); inversion FF; auto.
- simpl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; fold b; intros H4.
- case H3; rewrite H4; rewrite Zdiv_0_l; auto.
- rewrite BigZ.spec_mul; rewrite BigZ.spec_div; simpl;
-  rewrite BigN.spec_gcd; fold a b; auto with zarith.
- assert (F1: (0 < b)%Z).
-   case (Zle_lt_or_eq _ _ (BigN.spec_pos n)); fold b; auto with zarith.
- red; simpl.
- rewrite BigZ.spec_mul.
- repeat rewrite Z2P_correct; auto.
- rewrite spec_to_N; fold a.
- repeat rewrite <- Zmult_assoc.
- rewrite (Zmult_comm (BigZ.to_Z p1)).
- repeat rewrite Zmult_assoc.
- rewrite Zgcd_div_swap; auto with zarith.
- ring.
- apply Zgcd_div_pos; auto.
- intros p1 p2 n.
- set (a := BigN.to_Z (BigZ.to_N p1)).
- set (b := BigN.to_Z n).
- match goal with  |- context[BigZ.eq_bool ?X ?Y] => 
-   generalize (BigZ.spec_eq_bool X Y); case BigZ.eq_bool
- end; unfold zero, to_Q; repeat rewrite BigZ.spec_0; intros H.
- case BigN.eq_bool; try apply Qeq_refl.
- rewrite BigZ.spec_mul; rewrite H.
- red; simpl; ring.
- assert (F: (0 < a)%Z).
-  case (Zle_lt_or_eq _ _ (BigN.spec_pos (BigZ.to_N p1))); auto.
-  intros H1; case H; rewrite spec_to_N; rewrite <- H1; ring.
- match goal with  |- context[BigN.compare ?X ?Y] => 
-   generalize (BigN.spec_compare X Y); case BigN.compare
- end; rewrite BigN.spec_1; rewrite BigN.spec_gcd;
-      fold a b; intros H1.
- repeat rewrite BigZ.spec_mul; rewrite Zmult_comm.
- apply Qeq_refl.
- repeat rewrite BigZ.spec_mul; rewrite Zmult_comm.
- apply Qeq_refl.
- assert (F0 : (0 < (Zgcd a b))%Z).
-   apply Zlt_trans with 1%Z.
-   red; auto.
-   apply Zgt_lt; auto.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_1; rewrite BigN.spec_div;
- rewrite BigN.spec_gcd; auto with zarith; 
- fold a b; intros H2.
- assert (F1: b = Zgcd a b).
-   pattern b at 1; rewrite (Zdivide_Zdiv_eq (Zgcd a b) b);
-   auto with zarith.
-   rewrite H2; ring.
-   assert (FF := Zgcd_is_gcd a b); inversion FF; auto.
- assert (F2: (0 < b)%Z).
-   rewrite F1; auto.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; fold b; intros H3.
- rewrite H3 in F2; discriminate F2.
- rewrite BigZ.spec_mul.
- rewrite BigZ.spec_div; simpl; rewrite BigN.spec_gcd; 
-  fold a b; auto with zarith.
- rewrite BigZ.spec_mul.
- red; simpl; rewrite Z2P_correct; auto.
- rewrite Zmult_1_r; rewrite spec_to_N; fold a b.
- repeat rewrite <- Zmult_assoc.
- rewrite (Zmult_comm (BigZ.to_Z p2)).
- repeat rewrite Zmult_assoc.
- rewrite Zgcd_div_swap; auto with zarith.
- rewrite H2; ring.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; rewrite BigN.spec_div;
- rewrite BigN.spec_gcd; fold a b; auto; intros H3.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H4.
- apply Qeq_refl.
- case H4; fold b.
- rewrite (Zdivide_Zdiv_eq (Zgcd a b) b); auto.
- rewrite H3; ring.
- assert (FF := Zgcd_is_gcd a b); inversion FF; auto.
- simpl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; fold b; intros H4.
- case H3; rewrite H4; rewrite Zdiv_0_l; auto.
- rewrite BigZ.spec_mul; rewrite BigZ.spec_div; simpl;
-  rewrite BigN.spec_gcd; fold a b; auto with zarith.
- assert (F1: (0 < b)%Z).
-   case (Zle_lt_or_eq _ _ (BigN.spec_pos n)); fold b; auto with zarith.
- red; simpl.
- rewrite BigZ.spec_mul.
- repeat rewrite Z2P_correct; auto.
- rewrite spec_to_N; fold a.
- repeat rewrite <- Zmult_assoc.
- rewrite (Zmult_comm (BigZ.to_Z p2)).
- repeat rewrite Zmult_assoc.
- rewrite Zgcd_div_swap; auto with zarith.
- ring.
- apply Zgcd_div_pos; auto.
- set (f := fun p t =>
-        match (BigN.gcd (BigZ.to_N p) t ?= BigN.one)%bigN with
-       | Eq => (p, t)
-       | Lt => (p, t)
-       | Gt =>
-         ((p / BigZ.Pos (BigN.gcd (BigZ.to_N p) t))%bigZ,
-           (t / BigN.gcd (BigZ.to_N p) t)%bigN)
-       end).
- assert (F: forall p t,
-   let (n, d) := f p t in [Qq p t] == [Qq n d]).
- intros p t1; unfold f.
- match goal with  |- context[BigN.compare ?X ?Y] => 
-   generalize (BigN.spec_compare X Y); case BigN.compare
- end; rewrite BigN.spec_1; rewrite BigN.spec_gcd; intros H1.
- apply Qeq_refl.
- apply Qeq_refl.
- set (a := BigN.to_Z (BigZ.to_N p)).
- set (b := BigN.to_Z t1).
- fold a b in H1.
- assert (F0 : (0 < (Zgcd a b))%Z).
-   apply Zlt_trans with 1%Z.
-   red; auto.
-   apply Zgt_lt; auto.
- red; simpl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; fold b; intros HH1.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; fold b; intros HH2.
- simpl; ring.
- case HH2.
- rewrite BigN.spec_div; rewrite BigN.spec_gcd; fold a b; auto.
- rewrite HH1; rewrite Zdiv_0_l; auto.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0;
-   rewrite BigN.spec_div; rewrite BigN.spec_gcd; fold a b; auto;
-   intros HH2.
- case HH1.
- rewrite (Zdivide_Zdiv_eq (Zgcd a b) b); auto.
- rewrite HH2; ring.
- assert (FF := Zgcd_is_gcd a b); inversion FF; auto.
- simpl.
- rewrite BigZ.spec_div; simpl; rewrite BigN.spec_gcd; fold a b; auto with zarith.
- assert (F1: (0 < b)%Z).
-    case (Zle_lt_or_eq _ _ (BigN.spec_pos t1)); fold b; auto with zarith.
-    intros HH; case HH1; auto.
- repeat rewrite Z2P_correct; auto.
- rewrite spec_to_N; fold a.
- rewrite Zgcd_div_swap; auto.
- apply Zgcd_div_pos; auto.
- intros HH; rewrite HH in F0; discriminate F0.
- intros p1 n1 p2 n2.
- change ([let (nx , dy) := f p2 n1 in
-         let (ny, dx) := f p1 n2 in
-  if BigN.eq_bool (dx * dy)%bigN BigN.one
-   then Qz (ny * nx)
-  else Qq (ny * nx) (dx * dy)] == [Qq (p2 * p1) (n2 * n1)]).
-  generalize (F p2 n1) (F p1 n2).
- case f; case f.
- intros u1 u2 v1 v2 Hu1 Hv1.
- apply Qeq_trans with [mul (Qq p2 n1) (Qq p1 n2)].
- rewrite spec_mul; rewrite Hu1; rewrite Hv1.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_1; rewrite BigN.spec_mul; intros HH1.
- assert (F1: BigN.to_Z u2 = 1%Z).
-  case (Zmult_1_inversion_l _ _ HH1); auto.
-  generalize (BigN.spec_pos u2); auto with zarith.
- assert (F2: BigN.to_Z v2 = 1%Z).
-  rewrite Zmult_comm in HH1.
-  case (Zmult_1_inversion_l _ _ HH1); auto.
-  generalize (BigN.spec_pos v2); auto with zarith.
- red; simpl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H1.
- rewrite H1 in F2; discriminate F2.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H2.
- rewrite H2 in F1; discriminate F1.
- simpl; rewrite BigZ.spec_mul.
- rewrite F1; rewrite F2; simpl; ring.
- rewrite Qmult_comm; rewrite <- spec_mul.
- apply Qeq_refl.
- red; simpl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; rewrite BigN.spec_mul;
- rewrite Zmult_comm; intros H1.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; rewrite BigN.spec_mul; intros H2; auto.
- case H2; auto.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; rewrite BigN.spec_mul; intros H2; auto.
- case H1; auto.
- Qed.
-
-
-Definition inv (x: t): t := 
- match x with
- | Qz (BigZ.Pos n) => Qq BigZ.one n
- | Qz (BigZ.Neg n) => Qq BigZ.minus_one n
- | Qq (BigZ.Pos n) d => Qq (BigZ.Pos d) n
- | Qq (BigZ.Neg n) d => Qq (BigZ.Neg d) n
- end.
-
- Theorem spec_inv : forall x, [inv x] == /[x].
- Proof.
- intros [ [x | x] | [nx | nx] dx]; unfold inv, Qinv; simpl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H1; auto.
- rewrite H1; apply Qeq_refl.
- generalize H1 (BigN.spec_pos x); case (BigN.to_Z x); auto.
- intros HH; case HH; auto.
- intros; red; simpl; auto.
- intros p _ HH; case HH; auto.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H1; auto.
- rewrite H1; apply Qeq_refl.
- generalize H1 (BigN.spec_pos x); case (BigN.to_Z x); simpl;
-   auto.
- intros HH; case HH; auto.
- intros; red; simpl; auto.
- intros p _ HH; case HH; auto.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H1; auto.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H2; simpl; auto.
- apply Qeq_refl.
- rewrite H1; apply Qeq_refl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H2; simpl; auto.
- rewrite H2; red; simpl; auto.
- generalize H1 (BigN.spec_pos nx); case (BigN.to_Z nx); simpl;
-   auto.
- intros HH; case HH; auto.
- intros; red; simpl.
- rewrite Zpos_mult_morphism.
- rewrite Z2P_correct; auto.
- generalize (BigN.spec_pos dx); auto with zarith.
- intros p _ HH; case HH; auto.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H1; auto.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H2; simpl; auto.
- apply Qeq_refl.
- rewrite H1; apply Qeq_refl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H2; simpl; auto.
- rewrite H2; red; simpl; auto.
- generalize H1 (BigN.spec_pos nx); case (BigN.to_Z nx); simpl;
-   auto.
- intros HH; case HH; auto.
- intros; red; simpl.
- assert (tmp: forall x, Zneg x = Zopp (Zpos x)); auto.
- rewrite tmp.
- rewrite Zpos_mult_morphism.
- rewrite Z2P_correct; auto.
- ring.
- generalize (BigN.spec_pos dx); auto with zarith.
- intros p _ HH; case HH; auto.
- Qed.
-
-Definition inv_norm (x: t): t := 
- match x with
- | Qz (BigZ.Pos n) => 
-   match BigN.compare n BigN.one with
-     Gt => Qq BigZ.one n
-   | _ =>  x
-   end
- | Qz (BigZ.Neg n) => 
-   match BigN.compare n BigN.one with
-     Gt => Qq BigZ.minus_one n
-   | _ =>  x
-   end
- | Qq (BigZ.Pos n) d =>
-   match BigN.compare n BigN.one with
-     Gt => Qq (BigZ.Pos d) n
-   | Eq =>  Qz (BigZ.Pos d) 
-   | Lt => Qz (BigZ.zero)
-   end
- | Qq (BigZ.Neg n) d => 
-   match BigN.compare n BigN.one with
-     Gt => Qq (BigZ.Neg d) n
-   | Eq =>  Qz (BigZ.Neg d) 
-   | Lt => Qz (BigZ.zero)
-   end
- end.
-
- Theorem spec_inv_norm : forall x, [inv_norm x] == /[x].
- Proof.
- intros [ [x | x] | [nx | nx] dx]; unfold inv_norm, Qinv.
- match goal with  |- context[BigN.compare ?X ?Y] => 
-   generalize (BigN.spec_compare X Y); case BigN.compare
- end; rewrite BigN.spec_1; intros H.
- simpl; rewrite H; apply Qeq_refl.
- case (Zle_lt_or_eq _ _ (BigN.spec_pos x)); simpl.
- generalize H; case BigN.to_Z.
- intros _ HH; discriminate HH.
- intros p; case p; auto.
-   intros p1 HH; discriminate HH.
-   intros p1 HH; discriminate HH.
- intros HH; discriminate HH.
- intros p _ HH; discriminate HH.
- intros HH; rewrite <- HH.
-   apply Qeq_refl.
- generalize H; simpl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H1.
- rewrite H1; intros HH; discriminate.
- generalize H; case BigN.to_Z.
- intros HH; discriminate HH.
- intros; red; simpl; auto.
- intros p HH; discriminate HH.
- match goal with  |- context[BigN.compare ?X ?Y] => 
-   generalize (BigN.spec_compare X Y); case BigN.compare
- end; rewrite BigN.spec_1; intros H.
- simpl; rewrite H; apply Qeq_refl.
- case (Zle_lt_or_eq _ _ (BigN.spec_pos x)); simpl.
- generalize H; case BigN.to_Z.
- intros _ HH; discriminate HH.
- intros p; case p; auto.
-   intros p1 HH; discriminate HH.
-   intros p1 HH; discriminate HH.
- intros HH; discriminate HH.
- intros p _ HH; discriminate HH.
- intros HH; rewrite <- HH.
-   apply Qeq_refl.
- generalize H; simpl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H1.
- rewrite H1; intros HH; discriminate.
- generalize H; case BigN.to_Z.
- intros HH; discriminate HH.
- intros; red; simpl; auto.
- intros p HH; discriminate HH.
- simpl Qnum.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H1; simpl.
- case BigN.compare; red; simpl; auto.
- rewrite H1; auto.
- case BigN.eq_bool; auto.
- simpl; rewrite H1; auto.
- match goal with  |- context[BigN.compare ?X ?Y] => 
-   generalize (BigN.spec_compare X Y); case BigN.compare
- end; rewrite BigN.spec_1; intros H2.
- rewrite H2.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H3.
- case H1; auto.
- red; simpl.
- rewrite Zmult_1_r; rewrite Pmult_1_r; rewrite Z2P_correct; auto.
- generalize (BigN.spec_pos dx); auto with zarith.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H3.
- case H1; auto.
- generalize H2 (BigN.spec_pos nx); case (BigN.to_Z nx).
- intros; apply Qeq_refl.
- intros p; case p; clear p.
- intros p HH; discriminate HH.
- intros p HH; discriminate HH.
- intros HH; discriminate HH.
- intros p _ HH; case HH; auto.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H3.
- case H1; auto.
- simpl; generalize H2; case (BigN.to_Z nx).
- intros HH; discriminate HH.
- intros p Hp.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H4.
- rewrite H4 in H2; discriminate H2.
- red; simpl.
- rewrite Zpos_mult_morphism.
- rewrite Z2P_correct; auto.
- generalize (BigN.spec_pos dx); auto with zarith.
- intros p HH; discriminate HH.
- simpl Qnum.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H1; simpl.
- case BigN.compare; red; simpl; auto.
- rewrite H1; auto.
- case BigN.eq_bool; auto.
- simpl; rewrite H1; auto.
- match goal with  |- context[BigN.compare ?X ?Y] => 
-   generalize (BigN.spec_compare X Y); case BigN.compare
- end; rewrite BigN.spec_1; intros H2.
- rewrite H2.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H3.
- case H1; auto.
- red; simpl.
- assert (tmp: forall x, Zneg x = Zopp (Zpos x)); auto.
- rewrite tmp.
- rewrite Zmult_1_r; rewrite Pmult_1_r; rewrite Z2P_correct; auto.
- generalize (BigN.spec_pos dx); auto with zarith.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H3.
- case H1; auto.
- generalize H2 (BigN.spec_pos nx); case (BigN.to_Z nx).
- intros; apply Qeq_refl.
- intros p; case p; clear p.
- intros p HH; discriminate HH.
- intros p HH; discriminate HH.
- intros HH; discriminate HH.
- intros p _ HH; case HH; auto.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H3.
- case H1; auto.
- simpl; generalize H2; case (BigN.to_Z nx).
- intros HH; discriminate HH.
- intros p Hp.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H4.
- rewrite H4 in H2; discriminate H2.
- red; simpl.
- assert (tmp: forall x, Zneg x = Zopp (Zpos x)); auto.
- rewrite tmp.
- rewrite Zpos_mult_morphism.
- rewrite Z2P_correct; auto.
- ring.
- generalize (BigN.spec_pos dx); auto with zarith.
- intros p HH; discriminate HH.
- Qed.
-
- Definition div x y := mul x (inv y).
-
- Theorem spec_div x y: [div x y] == [x] / [y].
- Proof.
- intros x y; unfold div; rewrite spec_mul; auto.
- unfold Qdiv; apply Qmult_comp.
- apply Qeq_refl.
- apply spec_inv; auto.
- Qed.
-
- Definition div_norm x y := mul_norm x (inv y).
-
- Theorem spec_div_norm x y: [div_norm x y] == [x] / [y].
- Proof.
- intros x y; unfold div_norm; rewrite spec_mul_norm; auto.
- unfold Qdiv; apply Qmult_comp.
- apply Qeq_refl.
- apply spec_inv; auto.
- Qed.
-
- Definition square (x: t): t :=
-  match x with
-  | Qz zx => Qz (BigZ.square zx)
-  | Qq nx dx => Qq (BigZ.square nx) (BigN.square dx)
-  end.
-
- Theorem spec_square : forall x, [square x] == [x] ^ 2.
- Proof.
- intros [ x | nx dx]; unfold square.
- red; simpl; rewrite BigZ.spec_square; auto with zarith.
- simpl Qpower.
- repeat match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto; rewrite BigN.spec_0; intros H.
- red; simpl.
- repeat match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto; rewrite BigN.spec_0; rewrite BigN.spec_square;
-   intros H1.
- case H1; rewrite H; auto.
- red; simpl.
- repeat match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto; rewrite BigN.spec_0; rewrite BigN.spec_square;
-   intros H1.
- case H; case (Zmult_integral _ _ H1); auto.
- simpl.
- rewrite BigZ.spec_square.
- rewrite Zpos_mult_morphism.
- assert (tmp: 
-  (forall a b, 0 < a -> 0 < b -> Z2P (a * b) = (Z2P a * Z2P b)%positive)%Z).
-  intros [|a|a] [|b|b]; simpl; auto; intros; apply False_ind; auto with zarith.
- rewrite tmp; auto.
- generalize (BigN.spec_pos dx); auto with zarith.
- generalize (BigN.spec_pos dx); auto with zarith.
- Qed.
-
- Definition power_pos (x: t) p: t :=
-  match x with
-  | Qz zx => Qz (BigZ.power_pos zx p)
-  | Qq nx dx => Qq (BigZ.power_pos nx p) (BigN.power_pos dx p)
-  end.
-
- Theorem spec_power_pos : forall x p, [power_pos x p] == [x] ^ Zpos p.
- Proof.
- intros [x | nx dx] p; unfold power_pos.
-   unfold power_pos; red; simpl.
-   generalize (Qpower_decomp p (BigZ.to_Z x) 1).
-   unfold Qeq; simpl.
-   rewrite Zpower_pos_1_l; simpl Z2P.
-   rewrite Zmult_1_r.
-   intros H; rewrite H.
-   rewrite BigZ.spec_power_pos; simpl; ring.
- simpl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto; rewrite BigN.spec_0; rewrite BigN.spec_power_pos; intros H1.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto; rewrite BigN.spec_0; intros H2.
- elim p; simpl.
- intros; red; simpl; auto.
- intros p1 Hp1; rewrite <- Hp1; red; simpl; auto.
- apply Qeq_refl.
- case H2; generalize H1.
- elim p; simpl.
- intros p1 Hrec.
- change (xI p1) with (1 + (xO p1))%positive.
- rewrite Zpower_pos_is_exp; rewrite Zpower_pos_1_r.
- intros HH; case (Zmult_integral _ _ HH); auto.
- rewrite <- Pplus_diag.
- rewrite Zpower_pos_is_exp.
- intros HH1; case (Zmult_integral _ _ HH1); auto.
- intros p1 Hrec.
- rewrite <- Pplus_diag.
- rewrite Zpower_pos_is_exp.
- intros HH1; case (Zmult_integral _ _ HH1); auto.
- rewrite Zpower_pos_1_r; auto.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto; rewrite BigN.spec_0; intros H2.
- case H1; rewrite H2; auto.
- simpl; rewrite Zpower_pos_0_l; auto.
- assert (F1: (0 < BigN.to_Z dx)%Z).
-     generalize (BigN.spec_pos dx); auto with zarith.
- assert (F2: (0 < BigN.to_Z dx  ^ ' p)%Z).
-  unfold Zpower; apply Zpower_pos_pos; auto.
- unfold power_pos; red; simpl.
- generalize (Qpower_decomp p (BigZ.to_Z nx) 
-               (Z2P (BigN.to_Z dx))).
- unfold Qeq; simpl.
- repeat rewrite Z2P_correct; auto.
- unfold Qeq; simpl; intros HH.
- rewrite HH.
- rewrite BigZ.spec_power_pos; simpl; ring.
- Qed.
-
- (** Interaction with [Qcanon.Qc] *)
- 
- Open Scope Qc_scope.
-
- Definition of_Qc q := of_Q (this q).
-
- Definition to_Qc q := !!(to_Q q).
-
- Notation "[[ x ]]" := (to_Qc x).
-
- Theorem spec_of_Qc: forall q, [[of_Qc q]] = q.
- Proof.
- intros (x, Hx); unfold of_Qc, to_Qc; simpl.
- apply Qc_decomp; simpl.
- intros.
- rewrite <- H0 at 2; apply Qred_complete.
- apply spec_of_Q.
- Qed.
-
- Theorem spec_oppc: forall q, [[opp q]] = -[[q]].
- Proof.
- intros q; unfold Qcopp, to_Qc, Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete.
- rewrite spec_opp.
- rewrite <- Qred_opp.
- rewrite Qred_correct; red; auto.
- Qed.
-
- Theorem spec_comparec: forall q1 q2,
-  compare q1 q2 = ([[q1]] ?= [[q2]]).
- Proof.
- unfold Qccompare, to_Qc. 
- intros q1 q2; rewrite spec_compare; simpl; auto.
- apply Qcompare_comp; apply Qeq_sym; apply Qred_correct.
- Qed.
-
- Theorem spec_addc x y:
-  [[add x y]] = [[x]] + [[y]].
- Proof.
- intros x y; unfold to_Qc.
- apply trans_equal with (!! ([x] + [y])).
- unfold Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete; apply spec_add; auto.
- unfold Qcplus, Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete.
- apply Qplus_comp; apply Qeq_sym; apply Qred_correct.
- Qed.
-
- Theorem spec_add_normc x y:
-  [[add_norm x y]] = [[x]] + [[y]].
- Proof.
- intros x y; unfold to_Qc.
- apply trans_equal with (!! ([x] + [y])).
- unfold Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete; apply spec_add_norm; auto.
- unfold Qcplus, Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete.
- apply Qplus_comp; apply Qeq_sym; apply Qred_correct.
- Qed.
-
- Theorem spec_subc x y:  [[sub x y]] = [[x]] - [[y]].
- Proof.
- intros x y; unfold sub; rewrite spec_addc; auto.
- rewrite spec_oppc; ring.
- Qed.
-
- Theorem spec_sub_normc x y:
-   [[sub_norm x y]] = [[x]] - [[y]].
- intros x y; unfold sub_norm; rewrite spec_add_normc; auto.
- rewrite spec_oppc; ring.
- Qed.
-
- Theorem spec_mulc x y:
-  [[mul x y]] = [[x]] * [[y]].
- Proof.
- intros x y; unfold to_Qc.
- apply trans_equal with (!! ([x] * [y])).
- unfold Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete; apply spec_mul; auto.
- unfold Qcmult, Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete.
- apply Qmult_comp; apply Qeq_sym; apply Qred_correct.
- Qed.
-
- Theorem spec_mul_normc x y:
-   [[mul_norm x y]] = [[x]] * [[y]].
- Proof.
- intros x y; unfold to_Qc.
- apply trans_equal with (!! ([x] * [y])).
- unfold Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete; apply spec_mul_norm; auto.
- unfold Qcmult, Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete.
- apply Qmult_comp; apply Qeq_sym; apply Qred_correct.
- Qed.
-
- Theorem spec_invc x:
-   [[inv x]] =  /[[x]].
- Proof.
- intros x; unfold to_Qc.
- apply trans_equal with (!! (/[x])).
- unfold Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete; apply spec_inv; auto.
- unfold Qcinv, Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete.
- apply Qinv_comp; apply Qeq_sym; apply Qred_correct.
- Qed.
-
- Theorem spec_inv_normc x:
-   [[inv_norm x]] =  /[[x]].
- Proof.
- intros x; unfold to_Qc.
- apply trans_equal with (!! (/[x])).
- unfold Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete; apply spec_inv_norm; auto.
- unfold Qcinv, Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete.
- apply Qinv_comp; apply Qeq_sym; apply Qred_correct.
- Qed.
-
- Theorem spec_divc x y: [[div x y]] = [[x]] / [[y]].
- Proof.
- intros x y; unfold div; rewrite spec_mulc; auto.
- unfold Qcdiv; apply f_equal2 with (f := Qcmult); auto.
- apply spec_invc; auto. 
- Qed.
-
- Theorem spec_div_normc x y: [[div_norm x y]] = [[x]] / [[y]].
- Proof.
- intros x y; unfold div_norm; rewrite spec_mul_normc; auto.
- unfold Qcdiv; apply f_equal2 with (f := Qcmult); auto.
- apply spec_invc; auto.
- Qed.
-
- Theorem spec_squarec x: [[square x]] =  [[x]]^2.
- Proof.
- intros x; unfold to_Qc.
- apply trans_equal with (!! ([x]^2)).
- unfold Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete; apply spec_square; auto.
- simpl Qcpower.
- replace (!! [x] * 1) with (!![x]); try ring.
- simpl.
- unfold Qcmult, Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete.
- apply Qmult_comp; apply Qeq_sym; apply Qred_correct.
- Qed.
-
- Theorem spec_power_posc x p:
-   [[power_pos x p]] = [[x]] ^ nat_of_P p.
- Proof.
- intros x p; unfold to_Qc.
- apply trans_equal with (!! ([x]^Zpos p)).
- unfold Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete; apply spec_power_pos; auto.
- pattern p; apply Pind; clear p.
- simpl; ring.
- intros p Hrec.
- rewrite nat_of_P_succ_morphism; simpl Qcpower.
- rewrite <- Hrec.
- unfold Qcmult, Q2Qc.
- apply Qc_decomp; intros _ _;
- unfold this.
- apply Qred_complete.
- assert (F: [x] ^ ' Psucc p == [x] *   [x] ^ ' p).
-  simpl; case x; simpl; clear x Hrec.
-  intros x; simpl; repeat rewrite Qpower_decomp; simpl.
-  red; simpl; repeat rewrite Zpower_pos_1_l; simpl Z2P.
-  rewrite Pplus_one_succ_l.
-  rewrite Zpower_pos_is_exp.
-  rewrite Zpower_pos_1_r; auto.
-  intros nx dx.
-  match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
-  end; auto; rewrite BigN.spec_0.
-  unfold Qpower_positive.
-  assert (tmp: forall p, pow_pos Qmult 0%Q p = 0%Q).
-    intros p1; elim p1; simpl; auto; clear p1.
-    intros p1 Hp1; rewrite Hp1; auto.
-    intros p1 Hp1; rewrite Hp1; auto.
-  repeat rewrite tmp; intros; red; simpl; auto.
-  intros H1.
-  assert (F1: (0 < BigN.to_Z dx)%Z).
-     generalize (BigN.spec_pos dx); auto with zarith.
-  simpl; repeat rewrite Qpower_decomp; simpl.
-  red; simpl; repeat rewrite Zpower_pos_1_l; simpl Z2P.
-  rewrite Pplus_one_succ_l.
-  rewrite Zpower_pos_is_exp.
-  rewrite Zpower_pos_1_r; auto.
-  repeat rewrite Zpos_mult_morphism.
-  repeat rewrite Z2P_correct; auto.
-  2: apply Zpower_pos_pos; auto.
-  2: apply Zpower_pos_pos; auto.
-  rewrite Zpower_pos_is_exp.
-  rewrite Zpower_pos_1_r; auto.
- rewrite F.
- apply Qmult_comp; apply Qeq_sym; apply Qred_correct.
- Qed.
-
-
-End Q0.
diff --git a/theories/Numbers/Rational/BigQ/QMake.v b/theories/Numbers/Rational/BigQ/QMake.v
new file mode 100644
index 000000000..b526b6e24
--- /dev/null
+++ b/theories/Numbers/Rational/BigQ/QMake.v
@@ -0,0 +1,1014 @@
+(************************************************************************)
+(*  v      *   The Coq Proof Assistant  /  The Coq Development Team     *)
+(* <O___,, * CNRS-Ecole Polytechnique-INRIA Futurs-Universite Paris Sud *)
+(*   \VV/  **************************************************************)
+(*    //   *      This file is distributed under the terms of the       *)
+(*         *       GNU Lesser General Public License Version 2.1        *)
+(************************************************************************)
+(*            Benjamin Gregoire, Laurent Thery, INRIA, 2007             *)
+(************************************************************************)
+
+(*i $Id$ i*)
+
+Require Import BigNumPrelude ROmega.
+Require Import QArith Qcanon Qpower.
+Require Import NSig ZSig QSig.
+
+(* TODO : prove more precise results concerning add_norm and other
+   ..._norm functions, namely that they return reduced results. *)
+
+Module Type NType_ZType (N:NType)(Z:ZType).
+ Parameter Z_of_N : N.t -> Z.t.
+ Parameter spec_Z_of_N : forall n, Z.to_Z (Z_of_N n) = N.to_Z n.
+ Parameter Zabs_N : Z.t -> N.t.
+ Parameter spec_Zabs_N : forall z, N.to_Z (Zabs_N z) = Zabs (Z.to_Z z).
+End NType_ZType.
+
+Module Make (N:NType)(Z:ZType)(Import NZ:NType_ZType N Z) <: QType.
+
+ (** The notation of a rational number is either an integer x,
+     interpreted as itself or a pair (x,y) of an integer x and a natural
+     number y interpreted as x/y. The pairs (x,0) and (0,y) are all
+     interpreted as 0. *)
+
+ Inductive t_ := 
+  | Qz : Z.t -> t_
+  | Qq : Z.t -> N.t -> t_.
+
+ Definition t := t_.
+
+ (** Specification with respect to [QArith] *) 
+
+ Open Local Scope Q_scope.
+
+ Definition of_Z x: t := Qz (Z.of_Z x).
+
+ Definition of_Q q: t := 
+ match q with x # y =>
+  Qq (Z.of_Z x) (N.of_N (Npos y))
+ end.
+
+ Definition to_Q (q: t) := 
+ match q with 
+  Qz x => Z.to_Z x # 1
+ |Qq x y => if N.eq_bool y N.zero then 0
+            else Z.to_Z x # Z2P (N.to_Z y)
+ end.
+
+ Notation "[ x ]" := (to_Q x).
+
+ Theorem strong_spec_of_Q: forall q: Q, [of_Q q] = q.
+ Proof.
+ intros (x,y); simpl.
+ match goal with  |- context[N.eq_bool ?X ?Y] => 
+  generalize (N.spec_eq_bool X Y); case N.eq_bool
+ end; auto; rewrite N.spec_0.
+   rewrite N.spec_of_N; intros HH; discriminate HH.
+ rewrite Z.spec_of_Z; simpl.
+ rewrite N.spec_of_N; auto.
+ Qed.
+
+ Theorem spec_of_Q: forall q: Q, [of_Q q] == q.
+ Proof.
+ intros; rewrite strong_spec_of_Q; red; auto.
+ Qed.
+
+ Definition eq x y := [x] == [y].
+
+ Definition zero: t := Qz Z.zero.
+ Definition one: t := Qz Z.one.
+ Definition minus_one: t := Qz Z.minus_one.
+
+ Lemma spec_0: [zero] == 0.
+ Proof.
+ simpl; rewrite Z.spec_0; reflexivity.
+ Qed.
+
+ Lemma spec_1: [one] == 1.
+ Proof.
+ simpl; rewrite Z.spec_1; reflexivity.
+ Qed.
+
+ Lemma spec_m1: [minus_one] == -(1).
+ Proof.
+ simpl; rewrite Z.spec_m1; reflexivity.
+ Qed.
+
+ Definition opp (x: t): t :=
+  match x with
+  | Qz zx => Qz (Z.opp zx)
+  | Qq nx dx => Qq (Z.opp nx) dx
+  end.
+
+ Theorem strong_spec_opp: forall q, [opp q] = -[q].
+ Proof.
+ intros [z | x y]; simpl.
+ rewrite Z.spec_opp; auto.
+ match goal with  |- context[N.eq_bool ?X ?Y] => 
+  generalize (N.spec_eq_bool X Y); case N.eq_bool
+ end; auto; rewrite N.spec_0.
+ rewrite Z.spec_opp; auto.
+ Qed.
+
+ Theorem spec_opp : forall q, [opp q] == -[q].
+ Proof.
+ intros; rewrite strong_spec_opp; red; auto.
+ Qed.
+
+ Definition compare (x y: t) :=
+  match x, y with
+  | Qz zx, Qz zy => Z.compare zx zy
+  | Qz zx, Qq ny dy => 
+    if N.eq_bool dy N.zero then Z.compare zx Z.zero
+    else Z.compare (Z.mul zx (Z_of_N dy)) ny
+  | Qq nx dx, Qz zy => 
+    if N.eq_bool dx N.zero then Z.compare Z.zero zy 
+    else Z.compare nx (Z.mul zy (Z_of_N dx))
+  | Qq nx dx, Qq ny dy =>
+    match N.eq_bool dx N.zero, N.eq_bool dy N.zero with
+    | true, true => Eq
+    | true, false => Z.compare Z.zero ny
+    | false, true => Z.compare nx Z.zero
+    | false, false => Z.compare (Z.mul nx (Z_of_N dy)) 
+                                (Z.mul ny (Z_of_N dx))
+    end
+  end.
+
+ Lemma Zcompare_spec_alt : 
+  forall z z', Z.compare z z' = (Z.to_Z z ?= Z.to_Z z')%Z.
+ Proof.
+ intros; generalize (Z.spec_compare z z'); destruct Z.compare; auto.
+ intro H; rewrite H; symmetry; apply Zcompare_refl.
+ Qed.
+ 
+ Lemma Ncompare_spec_alt : 
+  forall n n', N.compare n n' = (N.to_Z n ?= N.to_Z n')%Z.
+ Proof.
+ intros; generalize (N.spec_compare n n'); destruct N.compare; auto.
+ intro H; rewrite H; symmetry; apply Zcompare_refl.
+ Qed.
+
+ Lemma N_to_Z2P : forall n, N.to_Z n <> 0%Z -> 
+  Zpos (Z2P (N.to_Z n)) = N.to_Z n.
+ Proof.
+ intros; apply Z2P_correct.
+ generalize (N.spec_pos n); romega.
+ Qed.
+
+ Hint Rewrite 
+  Zplus_0_r Zplus_0_l Zmult_0_r Zmult_0_l Zmult_1_r Zmult_1_l 
+  Z.spec_0 N.spec_0 Z.spec_1 N.spec_1 Z.spec_m1 Z.spec_opp
+  Zcompare_spec_alt Ncompare_spec_alt
+  Z.spec_add N.spec_add Z.spec_mul N.spec_mul 
+  Z.spec_gcd N.spec_gcd Zgcd_Zabs
+  spec_Z_of_N spec_Zabs_N
+ : nz.
+ Ltac nzsimpl := autorewrite with nz in *.
+
+ Ltac destr_neq_bool := repeat
+ (match goal with |- context [N.eq_bool ?x ?y] => 
+   generalize (N.spec_eq_bool x y); case N.eq_bool
+  end).
+ 
+ Ltac destr_zeq_bool := repeat
+ (match goal with |- context [Z.eq_bool ?x ?y] => 
+   generalize (Z.spec_eq_bool x y); case Z.eq_bool
+  end).
+
+ Ltac destr_zcompare := 
+ match goal with |- context [Zcompare ?x ?y] => 
+  let H := fresh "H" in 
+  case_eq (Zcompare x y); intro H;
+   [generalize (Zcompare_Eq_eq _ _ H); clear H; intro H |
+    change (x<y)%Z in H | 
+    change (x>y)%Z in H ]
+ end.
+
+ Ltac simpl_ndiv := rewrite N.spec_div by (nzsimpl; romega).
+ Tactic Notation "simpl_ndiv" "in" "*" := 
+   rewrite N.spec_div in * by (nzsimpl; romega).
+
+ Ltac simpl_zdiv := rewrite Z.spec_div by (nzsimpl; romega).
+ Tactic Notation "simpl_zdiv" "in" "*" := 
+   rewrite Z.spec_div in * by (nzsimpl; romega).
+
+ Ltac qsimpl := try red; unfold to_Q; simpl; intros; 
+  destr_neq_bool; destr_zeq_bool; simpl; nzsimpl; auto; intros.
+
+ Theorem spec_compare: forall q1 q2, (compare q1 q2) = ([q1] ?= [q2]).
+ Proof.
+ intros [z1 | x1 y1] [z2 | x2 y2]; 
+   unfold Qcompare, compare; qsimpl; rewrite ! N_to_Z2P; auto.
+ Qed.
+
+ Definition lt n m := compare n m = Lt.
+ Definition le n m := compare n m <> Gt.
+ Definition min n m := match compare n m with Gt => m | _ => n end.
+ Definition max n m := match compare n m with Lt => m | _ => n end.
+
+ Definition eq_bool n m := 
+  match compare n m with Eq => true | _ => false end.
+
+ Theorem spec_eq_bool: forall x y,
+  if eq_bool x y then [x] == [y] else ~([x] == [y]).
+ Proof.
+ intros.
+ unfold eq_bool.
+ rewrite spec_compare.
+ generalize (Qeq_alt [x] [y]).
+ destruct Qcompare.
+ intros H; rewrite H; auto.
+ intros H H'; rewrite H in H'; discriminate.
+ intros H H'; rewrite H in H'; discriminate.
+ Qed.
+
+ Definition norm n d : t :=
+  let gcd := N.gcd (Zabs_N n) d in 
+  match N.compare N.one gcd with
+  | Lt => 
+    let n := Z.div n (Z_of_N gcd) in
+    let d := N.div d gcd in
+    match N.compare d N.one with
+    | Gt => Qq n d
+    | Eq => Qz n
+    | Lt => zero
+    end
+  | Eq => Qq n d
+  | Gt => zero (* gcd = 0 => both numbers are 0 *)
+  end.
+
+ Theorem spec_norm: forall n q, [norm n q] == [Qq n q].
+ Proof.
+ intros p q; unfold norm.
+ assert (Hp := N.spec_pos (Zabs_N p)).
+ assert (Hq := N.spec_pos q).
+ nzsimpl.
+ destr_zcompare.
+ qsimpl.
+
+ simpl_ndiv.
+ destr_zcompare.
+ qsimpl.
+ rewrite H1 in *; rewrite Zdiv_0_l in H0; discriminate.
+ rewrite N_to_Z2P; auto.
+ simpl_zdiv; nzsimpl.
+ rewrite Zgcd_div_swap0, H0; romega.
+
+ qsimpl.
+ assert (0 < N.to_Z q / Zgcd (Z.to_Z p) (N.to_Z q))%Z.
+  apply Zgcd_div_pos; romega.
+ romega.
+
+ qsimpl.
+ simpl_ndiv in *; nzsimpl; romega.
+ simpl_ndiv in *.
+ rewrite H1, Zdiv_0_l in H2; elim H2; auto.
+ rewrite 2 N_to_Z2P; auto.
+ simpl_ndiv; simpl_zdiv; nzsimpl.
+ apply Zgcd_div_swap0; romega.
+
+ qsimpl.
+ assert (H' : Zgcd (Z.to_Z p) (N.to_Z q) = 0%Z).
+  generalize (Zgcd_is_pos (Z.to_Z p) (N.to_Z q)); romega.
+ symmetry; apply (Zgcd_inv_0_l _ _ H'); auto.
+ Qed.
+
+ Theorem strong_spec_norm : forall p q, [norm p q] = Qred [Qq p q].
+ Proof.
+ intros.
+ replace (Qred [Qq p q]) with (Qred [norm p q]) by 
+  (apply Qred_complete; apply spec_norm).
+ symmetry; apply Qred_identity.
+ unfold norm.
+ assert (Hp := N.spec_pos (Zabs_N p)).
+ assert (Hq := N.spec_pos q).
+ nzsimpl.
+ destr_zcompare.
+ (* Eq *)
+ simpl.
+ destr_neq_bool; nzsimpl; simpl; auto.
+ intros.
+ rewrite N_to_Z2P; auto.
+ (* Lt *)
+ simpl_ndiv.
+ destr_zcompare.
+ qsimpl.
+ apply Zis_gcd_gcd; auto with zarith; apply Zis_gcd_1.
+ qsimpl.
+ qsimpl.
+ simpl_zdiv; nzsimpl.
+ rewrite N_to_Z2P; auto.
+ clear H1.
+ simpl_ndiv; nzsimpl.
+ rewrite Zgcd_1_rel_prime.
+ destruct (Z_lt_le_dec 0 (N.to_Z q)).
+ apply Zis_gcd_rel_prime; auto with zarith.
+ apply Zgcd_is_gcd.
+ replace (N.to_Z q) with 0%Z in * by romega.
+ rewrite Zdiv_0_l in H0; discriminate.
+ (* Gt *) 
+ simpl.
+ apply Zis_gcd_gcd; auto with zarith; apply Zis_gcd_1.
+ Qed.
+
+ Definition red (x : t) : t := 
+  match x with 
+   | Qz z => x
+   | Qq n d => norm n d
+  end.
+
+ Theorem spec_red : forall x, [red x] == [x].
+ Proof.
+ intros [ z | n d ].
+ apply Qeq_refl.
+ unfold red.
+ apply spec_norm.
+ Qed.
+
+ Theorem strong_spec_red : forall x, [red x] = Qred [x].
+ Proof.
+ intros [ z | n d ].
+ unfold red.
+ symmetry; apply Qred_identity; simpl.
+ apply Zis_gcd_gcd; auto with zarith; apply Zis_gcd_1.
+ unfold red.
+ apply strong_spec_norm.
+ Qed.
+   
+ Definition add (x y: t): t :=
+  match x with
+  | Qz zx =>
+    match y with
+    | Qz zy => Qz (Z.add zx zy)
+    | Qq ny dy => 
+      if N.eq_bool dy N.zero then x 
+      else Qq (Z.add (Z.mul zx (Z_of_N dy)) ny) dy
+    end
+  | Qq nx dx =>
+    if N.eq_bool dx N.zero then y 
+    else match y with
+    | Qz zy => Qq (Z.add nx (Z.mul zy (Z_of_N dx))) dx
+    | Qq ny dy =>
+      if N.eq_bool dy N.zero then x
+      else
+       let n := Z.add (Z.mul nx (Z_of_N dy)) (Z.mul ny (Z_of_N dx)) in
+       let d := N.mul dx dy in
+       Qq n d
+    end
+  end.
+
+ Theorem spec_add : forall x y, [add x y] == [x] + [y].
+ Proof.
+ intros [x | nx dx] [y | ny dy]; unfold Qplus; qsimpl.
+ intuition.
+ rewrite N_to_Z2P; auto.
+ intuition.
+ rewrite Pmult_1_r, N_to_Z2P; auto.
+ intuition.
+ rewrite Pmult_1_r, N_to_Z2P; auto.
+ destruct (Zmult_integral _ _ H); intuition.
+ rewrite Zpos_mult_morphism, 2 N_to_Z2P; auto.
+ rewrite (Z2P_correct (N.to_Z dx * N.to_Z dy)); auto.
+ apply Zmult_lt_0_compat.
+  generalize (N.spec_pos dx); romega.
+  generalize (N.spec_pos dy); romega.
+ Qed.
+
+ Definition add_norm (x y: t): t :=
+  match x with
+  | Qz zx =>
+    match y with
+    | Qz zy => Qz (Z.add zx zy)
+    | Qq ny dy =>  
+      if N.eq_bool dy N.zero then x 
+      else norm (Z.add (Z.mul zx (Z_of_N dy)) ny) dy
+    end
+  | Qq nx dx =>
+    if N.eq_bool dx N.zero then y 
+    else match y with
+    | Qz zy => norm (Z.add nx (Z.mul zy (Z_of_N dx))) dx
+    | Qq ny dy =>
+      if N.eq_bool dy N.zero then x
+      else
+       let n := Z.add (Z.mul nx (Z_of_N dy)) (Z.mul ny (Z_of_N dx)) in
+       let d := N.mul dx dy in
+       norm n d
+    end
+  end.
+
+ Theorem spec_add_norm : forall x y, [add_norm x y] == [x] + [y].
+ Proof.
+ intros x y; rewrite <- spec_add.
+ destruct x; destruct y; unfold add_norm, add; 
+ destr_neq_bool; auto using Qeq_refl, spec_norm.
+ Qed.
+
+ Definition sub x y := add x (opp y).
+
+ Theorem spec_sub : forall x y, [sub x y] == [x] - [y].
+ Proof.
+ intros x y; unfold sub; rewrite spec_add; auto.
+ rewrite spec_opp; ring.
+ Qed.
+
+ Definition sub_norm x y := add_norm x (opp y).
+
+ Theorem spec_sub_norm : forall x y, [sub_norm x y] == [x] - [y].
+ Proof.
+ intros x y; unfold sub_norm; rewrite spec_add_norm; auto.
+ rewrite spec_opp; ring.
+ Qed.
+
+ Definition mul (x y: t): t :=
+  match x, y with
+  | Qz zx, Qz zy => Qz (Z.mul zx zy)
+  | Qz zx, Qq ny dy => Qq (Z.mul zx ny) dy
+  | Qq nx dx, Qz zy => Qq (Z.mul nx zy) dx
+  | Qq nx dx, Qq ny dy => Qq (Z.mul nx ny) (N.mul dx dy)
+  end.
+
+ Theorem spec_mul : forall x y, [mul x y] == [x] * [y].
+ Proof.
+ intros [x | nx dx] [y | ny dy]; unfold Qmult; simpl; qsimpl.
+ rewrite Pmult_1_r, N_to_Z2P; auto.
+ destruct (Zmult_integral _ _ H1); intuition.
+ rewrite H0 in H1; elim H1; auto.
+ rewrite H0 in H1; elim H1; auto.
+ rewrite H in H1; nzsimpl; elim H1; auto.
+ rewrite Zpos_mult_morphism, 2 N_to_Z2P; auto.
+ rewrite (Z2P_correct (N.to_Z dx * N.to_Z dy)); auto.
+ apply Zmult_lt_0_compat.
+  generalize (N.spec_pos dx); omega.
+  generalize (N.spec_pos dy); omega.
+ Qed.
+
+ Lemma norm_denum : forall n d, 
+  [if N.eq_bool d N.one then Qz n else Qq n d] == [Qq n d].
+ Proof.
+ intros; simpl; qsimpl.
+ rewrite H0 in H; discriminate.
+ rewrite N_to_Z2P, H0; auto with zarith.
+ Qed.
+
+ Definition irred n d :=        
+   let gcd := N.gcd (Zabs_N n) d in
+   match N.compare gcd N.one with 
+     | Gt => (Z.div n (Z_of_N gcd), N.div d gcd)
+     | _ => (n, d)
+   end.
+
+ Lemma spec_irred : forall n d, 
+   let (n',d') := irred n d in 
+   (Z.to_Z n * N.to_Z d' = Z.to_Z n' * N.to_Z d)%Z. 
+ Proof.
+ intros.
+ unfold irred.
+ nzsimpl.
+ destr_zcompare; auto.
+ simpl_ndiv; simpl_zdiv; nzsimpl.
+ destruct (Z_eq_dec (N.to_Z d) 0).
+ rewrite e; simpl; rewrite Zdiv_0_l; nzsimpl; auto.
+ rewrite Zgcd_div_swap0; auto.
+ auto with zarith.
+ generalize (N.spec_pos d); romega.
+ Qed.
+
+ Lemma spec_irred_zero : forall n d, 
+   (N.to_Z d = 0)%Z <-> (N.to_Z (snd (irred n d)) = 0)%Z.
+ Proof.
+ intros.
+ unfold irred.
+ split.
+ nzsimpl; intros.
+ destr_zcompare; auto.
+ simpl.
+ simpl_ndiv; nzsimpl.
+ rewrite H, Zdiv_0_l; auto.
+ nzsimpl; destr_zcompare; simpl; auto.
+ simpl_ndiv; nzsimpl.
+ intros.
+ generalize (N.spec_pos d); intros.
+ destruct (N.to_Z d); auto.
+ assert (0 < 0)%Z.
+  rewrite <- H0 at 2.
+  apply Zgcd_div_pos; auto with zarith.
+  compute; auto.
+ discriminate.
+ compute in H1; elim H1; auto.
+ Qed.
+
+ Definition mul_norm_Qz_Qq z n d := 
+   if Z.eq_bool z Z.zero then zero 
+   else
+    let gcd := N.gcd (Zabs_N z) d in
+    match N.compare gcd N.one with
+      | Gt => 
+        let z := Z.div z (Z_of_N gcd) in
+        let d := N.div d gcd in
+        if N.eq_bool d N.one then Qz (Z.mul z n) else Qq (Z.mul z n) d
+      | _  => Qq (Z.mul z n) d
+    end.
+
+ Definition mul_norm (x y: t): t := 
+ match x, y with
+ | Qz zx, Qz zy => Qz (Z.mul zx zy)
+ | Qz zx, Qq ny dy => mul_norm_Qz_Qq zx ny dy
+ | Qq nx dx, Qz zy => mul_norm_Qz_Qq zy nx dx
+ | Qq nx dx, Qq ny dy => 
+    let (nx, dy) := irred nx dy in 
+    let (ny, dx) := irred ny dx in 
+    let d := N.mul dx dy in
+    if N.eq_bool d N.one then Qz (Z.mul ny nx) else Qq (Z.mul ny nx) d
+ end.
+
+ Lemma spec_mul_norm_Qz_Qq : forall z n d, 
+   [mul_norm_Qz_Qq z n d] == [Qq (Z.mul z n) d].
+ Proof.
+ intros z n d; unfold mul_norm_Qz_Qq; nzsimpl; rewrite Zcompare_gt.
+ destr_zeq_bool; intros Hz; nzsimpl.
+ qsimpl; rewrite Hz; auto.
+ assert (Hd := N.spec_pos d).
+ destruct Z_le_gt_dec.
+ qsimpl.
+ rewrite norm_denum.
+ qsimpl.
+ simpl_ndiv in *; nzsimpl.
+ rewrite (Zdiv_gcd_zero _ _ H0 H) in z0; discriminate.
+ simpl_ndiv in *; nzsimpl.
+ rewrite H, Zdiv_0_l in H0; elim H0; auto.
+ rewrite 2 N_to_Z2P; auto.
+ simpl_ndiv; simpl_zdiv; nzsimpl.
+ rewrite (Zmult_comm (Z.to_Z z)), <- 2 Zmult_assoc.
+ rewrite <- Zgcd_div_swap0; auto with zarith; ring.
+ Qed.
+
+ Theorem spec_mul_norm : forall x y, [mul_norm x y] == [x] * [y].
+ Proof.
+ intros x y; rewrite <- spec_mul; auto.
+ unfold mul_norm, mul; destruct x; destruct y.
+ apply Qeq_refl.
+ apply spec_mul_norm_Qz_Qq.
+ rewrite spec_mul_norm_Qz_Qq; qsimpl; ring.
+
+ rename t0 into nx, t3 into dy, t2 into ny, t1 into dx.
+ generalize (spec_irred nx dy) (spec_irred ny dx)
+   (spec_irred_zero nx dy) (spec_irred_zero ny dx).
+ destruct irred as (n1,d1); destruct irred as (n2,d2). 
+ simpl fst; simpl snd; intros.
+ rewrite norm_denum.
+ qsimpl.
+
+ elim H3; destruct (Zmult_integral _ _ H4) as [Eq|Eq].
+ rewrite <- H2 in Eq; rewrite Eq; simpl; auto.
+ rewrite <- H1 in Eq; rewrite Eq; nzsimpl; auto.
+
+ elim H4; destruct (Zmult_integral _ _ H3) as [Eq|Eq].
+ rewrite H2 in Eq; rewrite Eq; simpl; auto.
+ rewrite H1 in Eq; rewrite Eq; nzsimpl; auto.
+
+ rewrite 2 Z2P_correct.
+ rewrite Zmult_permute, <- Zmult_assoc, <- H.
+ rewrite Zmult_permute, Zmult_assoc, <- H0.
+ ring.
+
+ assert (0 <= N.to_Z d2 * N.to_Z d1)%Z 
+  by (apply Zmult_le_0_compat; apply N.spec_pos).
+ romega.
+ assert (0 <= N.to_Z dx * N.to_Z dy)%Z 
+  by (apply Zmult_le_0_compat; apply N.spec_pos).
+ romega.
+ Qed.
+
+ Definition inv (x: t): t := 
+ match x with
+ | Qz z => 
+   match Z.compare Z.zero z with 
+     | Eq => zero
+     | Lt => Qq Z.one (Zabs_N z)
+     | Gt => Qq Z.minus_one (Zabs_N z)
+   end
+ | Qq n d => 
+   match Z.compare Z.zero n with
+     | Eq => zero
+     | Lt => Qq (Z_of_N d) (Zabs_N n)
+     | Gt => Qq (Z.opp (Z_of_N d)) (Zabs_N n)
+   end
+ end.
+
+ Theorem spec_inv : forall x, [inv x] == /[x].
+ Proof.
+ destruct x as [ z | n d ].
+ (* Qz z *)
+ simpl.
+ rewrite Zcompare_spec_alt; destr_zcompare.
+ (* 0 = z *)
+ rewrite <- H.
+ simpl; nzsimpl; compute; auto.
+ (* 0 < z *)
+ simpl.
+ destr_neq_bool; nzsimpl; [ intros; rewrite Zabs_eq in *; romega | intros _ ].
+ set (z':=Z.to_Z z) in *; clearbody z'.
+ red; simpl.
+ rewrite Zabs_eq by romega.
+ rewrite Z2P_correct by auto.
+ unfold Qinv; simpl; destruct z'; simpl; auto; discriminate.
+ (* 0 > z *)
+ simpl.
+ destr_neq_bool; nzsimpl; [ intros; rewrite Zabs_non_eq in *; romega | intros _ ].
+ set (z':=Z.to_Z z) in *; clearbody z'.
+ red; simpl.
+ rewrite Zabs_non_eq by romega.
+ rewrite Z2P_correct by romega.
+ unfold Qinv; simpl; destruct z'; simpl; auto; discriminate.
+ (* Qq n d *)
+ simpl.
+ rewrite Zcompare_spec_alt; destr_zcompare.
+ (* 0 = n *)
+ rewrite <- H.
+ simpl; nzsimpl.
+ destr_neq_bool; intros; compute; auto.
+ (* 0 < n *)
+ simpl.
+ destr_neq_bool; nzsimpl; intros.
+ intros; rewrite Zabs_eq in *; romega.
+ intros; rewrite Zabs_eq in *; romega.
+ clear H1.
+ rewrite H0.
+ compute; auto.
+ clear H1.
+ set (n':=Z.to_Z n) in *; clearbody n'.
+ rewrite Zabs_eq by romega.
+ red; simpl.
+ rewrite Z2P_correct by auto.
+ unfold Qinv; simpl; destruct n'; simpl; auto; try discriminate.
+ rewrite Zpos_mult_morphism, N_to_Z2P; auto.
+ (* 0 > n *)
+ simpl.
+ destr_neq_bool; nzsimpl; intros.
+ intros; rewrite Zabs_non_eq in *; romega.
+ intros; rewrite Zabs_non_eq in *; romega.
+ clear H1.
+ red; nzsimpl; rewrite H0; compute; auto.
+ clear H1.
+ set (n':=Z.to_Z n) in *; clearbody n'.
+ red; simpl; nzsimpl.
+ rewrite Zabs_non_eq by romega.
+ rewrite Z2P_correct by romega.
+ unfold Qinv; simpl; destruct n'; simpl; auto; try discriminate.
+ assert (T : forall x, Zneg x = Zopp (Zpos x)) by auto.
+ rewrite T, Zpos_mult_morphism, N_to_Z2P; auto; ring.
+ Qed.
+
+ Definition inv_norm (x: t): t := 
+   match x with
+     | Qz z => 
+       match Z.compare Z.zero z with 
+         | Eq => zero
+         | Lt => 
+           match Z.compare z Z.one with 
+             | Gt => Qq Z.one (Zabs_N z)
+             | _ => x
+           end
+         | Gt => 
+           match Z.compare z Z.minus_one with 
+             | Lt => Qq Z.minus_one (Zabs_N z)
+             | _ => x
+           end
+       end
+     | Qq n d => 
+       match Z.compare Z.zero n with 
+         | Eq => zero
+         | Lt => 
+           match Z.compare n Z.one with 
+             | Gt => Qq (Z_of_N d) (Zabs_N n)
+             | _ => Qz (Z_of_N d)
+           end
+         | Gt => 
+           match Z.compare n Z.minus_one with 
+             | Lt => Qq (Z.opp (Z_of_N d)) (Zabs_N n)
+             | _ => Qz (Z.opp (Z_of_N d))
+           end
+       end
+   end.
+
+ Theorem spec_inv_norm : forall x, [inv_norm x] == /[x].
+ Proof.
+ intros.
+ rewrite <- spec_inv.
+ destruct x as [ z | n d ].
+ (* Qz z *)
+ simpl.
+ rewrite Zcompare_spec_alt; destr_zcompare; try apply Qeq_refl.
+ (* 0 < z *)
+ rewrite Zcompare_spec_alt; destr_zcompare; try apply Qeq_refl.
+ red; simpl; nzsimpl.
+ rewrite H0; simpl.
+ destr_neq_bool; nzsimpl; [ intros; rewrite Zabs_eq in *; romega | intros _ ].
+ simpl; auto.
+ nzsimpl; romega.
+ (* 0 > z *)
+ rewrite Zcompare_spec_alt; destr_zcompare; try apply Qeq_refl.
+ red; simpl; nzsimpl.
+ rewrite H0; simpl.
+ destr_neq_bool; nzsimpl; [ intros; rewrite Zabs_non_eq in *; romega | intros _ ].
+ simpl; auto.
+ nzsimpl; romega.
+ (* Qq n d *)
+ simpl.
+ rewrite Zcompare_spec_alt; destr_zcompare; try apply Qeq_refl.
+ (* 0 < n *)
+ rewrite Zcompare_spec_alt; destr_zcompare; try apply Qeq_refl.
+ red; simpl; nzsimpl.
+ rewrite H0; simpl.
+ destr_neq_bool; nzsimpl; [ intros; rewrite Zabs_eq in *; romega | intros _ ].
+ simpl; auto.
+ nzsimpl; romega.
+ (* 0 > n *)
+ rewrite Zcompare_spec_alt; destr_zcompare; try apply Qeq_refl.
+ red; simpl; nzsimpl.
+ rewrite H0; simpl.
+ destr_neq_bool; nzsimpl; [ intros; rewrite Zabs_non_eq in *; romega | intros _ ].
+ simpl; auto.
+ nzsimpl; romega.
+ Qed.
+
+ Definition div x y := mul x (inv y).
+
+ Theorem spec_div x y: [div x y] == [x] / [y].
+ Proof.
+ intros x y; unfold div; rewrite spec_mul; auto.
+ unfold Qdiv; apply Qmult_comp.
+ apply Qeq_refl.
+ apply spec_inv; auto.
+ Qed.
+
+ Definition div_norm x y := mul_norm x (inv y).
+
+ Theorem spec_div_norm x y: [div_norm x y] == [x] / [y].
+ Proof.
+ intros x y; unfold div_norm; rewrite spec_mul_norm; auto.
+ unfold Qdiv; apply Qmult_comp.
+ apply Qeq_refl.
+ apply spec_inv; auto.
+ Qed.
+
+ Definition square (x: t): t :=
+  match x with
+  | Qz zx => Qz (Z.square zx)
+  | Qq nx dx => Qq (Z.square nx) (N.square dx)
+  end.
+
+ Theorem spec_square : forall x, [square x] == [x] ^ 2.
+ Proof.
+ destruct x as [ z | n d ].
+ simpl; rewrite Z.spec_square; red; auto.
+ simpl.
+ destr_neq_bool; nzsimpl; intros.
+ apply Qeq_refl.
+ rewrite N.spec_square in *; nzsimpl.
+ contradict H; elim (Zmult_integral _ _ H0); auto.
+ rewrite N.spec_square in *; nzsimpl.
+ rewrite H in H0; simpl in H0; elim H0; auto.
+ assert (0 < N.to_Z d)%Z by (generalize (N.spec_pos d); romega).
+ clear H H0.
+ rewrite Z.spec_square, N.spec_square.  
+ red; simpl.
+ rewrite Zpos_mult_morphism; rewrite !Z2P_correct; auto.
+ apply Zmult_lt_0_compat; auto.
+ Qed.
+
+ Definition power_pos (x : t) p : t :=
+  match x with
+  | Qz zx => Qz (Z.power_pos zx p)
+  | Qq nx dx => Qq (Z.power_pos nx p) (N.power_pos dx p)
+  end.
+ 
+ Theorem spec_power_pos : forall x p, [power_pos x p] == [x] ^ Zpos p.
+ Proof.
+ intros [ z | n d ] p; unfold power_pos.
+ (* Qz *)
+ simpl.
+ rewrite Z.spec_power_pos.
+ rewrite Qpower_decomp.
+ red; simpl; f_equal.
+ rewrite Zpower_pos_1_l; auto.
+ (* Qq *)
+ simpl.
+ rewrite Z.spec_power_pos.
+ destr_neq_bool; nzsimpl; intros.
+ apply Qeq_sym; apply Qpower_positive_0.
+ rewrite N.spec_power_pos in *.
+ assert (0 < N.to_Z d ^ ' p)%Z.
+  apply Zpower_gt_0; auto with zarith.
+  generalize (N.spec_pos d); romega.
+ romega.
+ rewrite N.spec_power_pos, H in *.
+ rewrite Zpower_0_l in H0; [ elim H0; auto | discriminate ].
+ rewrite Qpower_decomp.
+ red; simpl; do 3 f_equal.
+ rewrite Z2P_correct by (generalize (N.spec_pos d); romega).
+ rewrite N.spec_power_pos. auto.
+ Qed.
+
+ Definition power (x : t) (z : Z) : t := 
+   match z with 
+     | Z0 => one
+     | Zpos p => power_pos x p
+     | Zneg p => inv (power_pos x p)
+   end.
+
+ Theorem spec_power : forall x z, [power x z] == [x]^z.
+ Proof.
+ destruct z.
+ simpl; nzsimpl; red; auto.
+ apply spec_power_pos.
+ simpl.
+ rewrite spec_inv, spec_power_pos; apply Qeq_refl.
+ Qed.
+
+ (** Interaction with [Qcanon.Qc] *)
+ 
+ Open Scope Qc_scope.
+
+ Definition of_Qc q := of_Q (this q).
+
+ Definition to_Qc q := !!(to_Q q).
+
+ Notation "[[ x ]]" := (to_Qc x).
+
+ Theorem spec_of_Qc: forall q, [[of_Qc q]] = q.
+ Proof.
+ intros (x, Hx); unfold of_Qc, to_Qc; simpl.
+ apply Qc_decomp; simpl.
+ intros.
+ rewrite <- H0 at 2; apply Qred_complete.
+ apply spec_of_Q.
+ Qed.
+
+ Theorem spec_oppc: forall q, [[opp q]] = -[[q]].
+ Proof.
+ intros q; unfold Qcopp, to_Qc, Q2Qc.
+ apply Qc_decomp; intros _ _; unfold this.
+ apply Qred_complete.
+ rewrite spec_opp, <- Qred_opp, Qred_correct.
+ apply Qeq_refl.
+ Qed.
+
+ Theorem spec_comparec: forall q1 q2,
+  compare q1 q2 = ([[q1]] ?= [[q2]]).
+ Proof.
+ unfold Qccompare, to_Qc.
+ intros q1 q2; rewrite spec_compare; simpl; auto.
+ apply Qcompare_comp; apply Qeq_sym; apply Qred_correct.
+ Qed.
+
+ Theorem spec_addc x y:
+  [[add x y]] = [[x]] + [[y]].
+ Proof.
+ intros x y; unfold to_Qc.
+ apply trans_equal with (!! ([x] + [y])).
+ unfold Q2Qc.
+ apply Qc_decomp; intros _ _; unfold this.
+ apply Qred_complete; apply spec_add; auto.
+ unfold Qcplus, Q2Qc.
+ apply Qc_decomp; intros _ _; unfold this.
+ apply Qred_complete.
+ apply Qplus_comp; apply Qeq_sym; apply Qred_correct.
+ Qed.
+
+ Theorem spec_add_normc x y:
+  [[add_norm x y]] = [[x]] + [[y]].
+ Proof.
+ intros x y; unfold to_Qc.
+ apply trans_equal with (!! ([x] + [y])).
+ unfold Q2Qc.
+ apply Qc_decomp; intros _ _; unfold this.
+ apply Qred_complete; apply spec_add_norm; auto.
+ unfold Qcplus, Q2Qc.
+ apply Qc_decomp; intros _ _; unfold this.
+ apply Qred_complete.
+ apply Qplus_comp; apply Qeq_sym; apply Qred_correct.
+ Qed.
+
+ Theorem spec_subc x y:  [[sub x y]] = [[x]] - [[y]].
+ Proof.
+ intros x y; unfold sub; rewrite spec_addc; auto.
+ rewrite spec_oppc; ring.
+ Qed.
+
+ Theorem spec_sub_normc x y:
+   [[sub_norm x y]] = [[x]] - [[y]].
+ intros x y; unfold sub_norm; rewrite spec_add_normc; auto.
+ rewrite spec_oppc; ring.
+ Qed.
+
+ Theorem spec_mulc x y:
+  [[mul x y]] = [[x]] * [[y]].
+ Proof.
+ intros x y; unfold to_Qc.
+ apply trans_equal with (!! ([x] * [y])).
+ unfold Q2Qc.
+ apply Qc_decomp; intros _ _; unfold this.
+ apply Qred_complete; apply spec_mul; auto.
+ unfold Qcmult, Q2Qc.
+ apply Qc_decomp; intros _ _; unfold this.
+ apply Qred_complete.
+ apply Qmult_comp; apply Qeq_sym; apply Qred_correct.
+ Qed.
+
+ Theorem spec_mul_normc x y:
+   [[mul_norm x y]] = [[x]] * [[y]].
+ Proof.
+ intros x y; unfold to_Qc.
+ apply trans_equal with (!! ([x] * [y])).
+ unfold Q2Qc.
+ apply Qc_decomp; intros _ _; unfold this.
+ apply Qred_complete; apply spec_mul_norm; auto.
+ unfold Qcmult, Q2Qc.
+ apply Qc_decomp; intros _ _; unfold this.
+ apply Qred_complete.
+ apply Qmult_comp; apply Qeq_sym; apply Qred_correct.
+ Qed.
+
+ Theorem spec_invc x:
+   [[inv x]] =  /[[x]].
+ Proof.
+ intros x; unfold to_Qc.
+ apply trans_equal with (!! (/[x])).
+ unfold Q2Qc.
+ apply Qc_decomp; intros _ _; unfold this.
+ apply Qred_complete; apply spec_inv; auto.
+ unfold Qcinv, Q2Qc.
+ apply Qc_decomp; intros _ _; unfold this.
+ apply Qred_complete.
+ apply Qinv_comp; apply Qeq_sym; apply Qred_correct.
+ Qed.
+
+ Theorem spec_inv_normc x:
+   [[inv_norm x]] =  /[[x]].
+ Proof.
+ intros x; unfold to_Qc.
+ apply trans_equal with (!! (/[x])).
+ unfold Q2Qc.
+ apply Qc_decomp; intros _ _; unfold this.
+ apply Qred_complete; apply spec_inv_norm; auto.
+ unfold Qcinv, Q2Qc.
+ apply Qc_decomp; intros _ _; unfold this.
+ apply Qred_complete.
+ apply Qinv_comp; apply Qeq_sym; apply Qred_correct.
+ Qed.
+
+ Theorem spec_divc x y: [[div x y]] = [[x]] / [[y]].
+ Proof.
+ intros x y; unfold div; rewrite spec_mulc; auto.
+ unfold Qcdiv; apply f_equal2 with (f := Qcmult); auto.
+ apply spec_invc; auto. 
+ Qed.
+
+ Theorem spec_div_normc x y: [[div_norm x y]] = [[x]] / [[y]].
+ Proof.
+ intros x y; unfold div_norm; rewrite spec_mul_normc; auto.
+ unfold Qcdiv; apply f_equal2 with (f := Qcmult); auto.
+ apply spec_invc; auto.
+ Qed.
+
+ Theorem spec_squarec x: [[square x]] =  [[x]]^2.
+ Proof.
+ intros x; unfold to_Qc.
+ apply trans_equal with (!! ([x]^2)).
+ unfold Q2Qc.
+ apply Qc_decomp; intros _ _; unfold this.
+ apply Qred_complete; apply spec_square; auto.
+ simpl Qcpower.
+ replace (!! [x] * 1) with (!![x]); try ring.
+ simpl.
+ unfold Qcmult, Q2Qc.
+ apply Qc_decomp; intros _ _; unfold this.
+ apply Qred_complete.
+ apply Qmult_comp; apply Qeq_sym; apply Qred_correct.
+ Qed.
+
+ Theorem spec_power_posc x p:
+   [[power_pos x p]] = [[x]] ^ nat_of_P p.
+ Proof.
+ intros x p; unfold to_Qc.
+ apply trans_equal with (!! ([x]^Zpos p)).
+ unfold Q2Qc.
+ apply Qc_decomp; intros _ _; unfold this.
+ apply Qred_complete; apply spec_power_pos; auto.
+ induction p using Pind.
+ simpl; ring.
+ rewrite nat_of_P_succ_morphism; simpl Qcpower.
+ rewrite <- IHp; clear IHp.
+ unfold Qcmult, Q2Qc.
+ apply Qc_decomp; intros _ _; unfold this.
+ apply Qred_complete.
+ setoid_replace ([x] ^ ' Psucc p)%Q with ([x] * [x] ^ ' p)%Q.
+ apply Qmult_comp; apply Qeq_sym; apply Qred_correct.
+ simpl.
+ rewrite Pplus_one_succ_l.
+ rewrite Qpower_plus_positive; simpl; apply Qeq_refl.
+ Qed.
+
+End Make.
+
diff --git a/theories/Numbers/Rational/BigQ/QMake_base.v b/theories/Numbers/Rational/BigQ/QMake_base.v
deleted file mode 100644
index da74ee392..000000000
--- a/theories/Numbers/Rational/BigQ/QMake_base.v
+++ /dev/null
@@ -1,34 +0,0 @@
-(************************************************************************)
-(*  v      *   The Coq Proof Assistant  /  The Coq Development Team     *)
-(* <O___,, * CNRS-Ecole Polytechnique-INRIA Futurs-Universite Paris Sud *)
-(*   \VV/  **************************************************************)
-(*    //   *      This file is distributed under the terms of the       *)
-(*         *       GNU Lesser General Public License Version 2.1        *)
-(************************************************************************)
-(*            Benjamin Gregoire, Laurent Thery, INRIA, 2007             *)
-(************************************************************************)
-
-(* $Id$ *)
-
-(** * An implementation of rational numbers based on big integers *)
-
-Require Export BigN.
-Require Export BigZ.
-
-(* Basic type for Q: a Z or a pair of a Z and an N *)
-
-Inductive q_type := 
- | Qz : BigZ.t -> q_type
- | Qq : BigZ.t -> BigN.t -> q_type.
-
-Definition print_type x := 
- match x with
- | Qz _ => Z
- | _ => (Z*Z)%type
- end.
-
-Definition print x :=
- match x return print_type x with
- | Qz zx => BigZ.to_Z zx
- | Qq nx dx => (BigZ.to_Z nx, BigN.to_Z dx)
- end.
diff --git a/theories/Numbers/Rational/BigQ/QbiMake.v b/theories/Numbers/Rational/BigQ/QbiMake.v
deleted file mode 100644
index e105b36fc..000000000
--- a/theories/Numbers/Rational/BigQ/QbiMake.v
+++ /dev/null
@@ -1,1066 +0,0 @@
-(************************************************************************)
-(*  v      *   The Coq Proof Assistant  /  The Coq Development Team     *)
-(* <O___,, * CNRS-Ecole Polytechnique-INRIA Futurs-Universite Paris Sud *)
-(*   \VV/  **************************************************************)
-(*    //   *      This file is distributed under the terms of the       *)
-(*         *       GNU Lesser General Public License Version 2.1        *)
-(************************************************************************)
-(*            Benjamin Gregoire, Laurent Thery, INRIA, 2007             *)
-(************************************************************************)
-
-(*i $Id$ i*)
-
-Require Import Bool.
-Require Import ZArith.
-Require Import Znumtheory.
-Require Import BigNumPrelude.
-Require Import Arith.
-Require Export BigN.
-Require Export BigZ.
-Require Import QArith.
-Require Import Qcanon.
-Require Import Qpower.
-Require Import QMake_base.	
-
-Module Qbi.
-
- Import BinInt Zorder.
- Open Local Scope Q_scope.
- Open Local Scope Qc_scope.
-
- (** The notation of a rational number is either an integer x,
-     interpreted as itself or a pair (x,y) of an integer x and a naturel
-     number y interpreted as x/y. The pairs (x,0) and (0,y) are all
-     interpreted as 0. *)
-
- Definition t := q_type.
-
- Definition zero: t := Qz BigZ.zero.
- Definition one: t  := Qz BigZ.one.
- Definition minus_one: t := Qz BigZ.minus_one.
-
- Definition of_Z x: t := Qz (BigZ.of_Z x).
-
-
- Definition of_Q q: t := 
- match q with x # y =>
-  Qq (BigZ.of_Z x) (BigN.of_N (Npos y))
- end.
-
- Definition of_Qc q := of_Q (this q).
-
- Definition to_Q (q: t) := 
- match q with 
-  Qz x => BigZ.to_Z x # 1
- |Qq x y => if BigN.eq_bool y BigN.zero then 0%Q
-            else BigZ.to_Z x # Z2P (BigN.to_Z y)
- end.
-
- Definition to_Qc q := !!(to_Q q).
-
- Notation "[[ x ]]" := (to_Qc x).
-
- Notation "[ x ]" := (to_Q x).
-
- Theorem spec_to_Q: forall q: Q, [of_Q q] = q.
- intros (x,y); simpl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-  generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto; rewrite BigN.spec_0.
-   rewrite BigN.spec_of_pos; intros HH; discriminate HH.
- rewrite BigZ.spec_of_Z; simpl.
- rewrite (BigN.spec_of_pos); auto.
- Qed.
-
- Theorem spec_to_Qc: forall q, [[of_Qc q]] = q.
- intros (x, Hx); unfold of_Qc, to_Qc; simpl.
- apply Qc_decomp; simpl.
- intros; rewrite spec_to_Q; auto.
- Qed.
-
- Definition opp (x: t): t :=
-  match x with
-  | Qz zx => Qz (BigZ.opp zx)
-  | Qq nx dx => Qq (BigZ.opp nx) dx
-  end.
-
- Theorem spec_opp: forall q, ([opp q] = -[q])%Q.
- intros [z | x y]; simpl.
- rewrite BigZ.spec_opp; auto.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-  generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto; rewrite BigN.spec_0.
- rewrite BigZ.spec_opp; auto.
- Qed.
-
- Theorem spec_oppc: forall q, [[opp q]] = -[[q]].
- intros q; unfold Qcopp, to_Qc, Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- rewrite spec_opp.
- rewrite <- Qred_opp.
- rewrite Qred_involutive; auto.
- Qed.
-
-
- Definition compare (x y: t) :=
-  match x, y with
-  | Qz zx, Qz zy => BigZ.compare zx zy
-  | Qz zx, Qq ny dy => 
-    if BigN.eq_bool dy BigN.zero then BigZ.compare zx BigZ.zero
-    else
-      match BigZ.cmp_sign zx ny with
-      | Lt => Lt 
-      | Gt => Gt
-      | Eq => BigZ.compare (BigZ.mul zx (BigZ.Pos dy)) ny
-      end
-  | Qq nx dx, Qz zy =>
-    if BigN.eq_bool dx BigN.zero then BigZ.compare BigZ.zero zy     
-    else
-      match BigZ.cmp_sign nx zy with
-      | Lt => Lt
-      | Gt => Gt
-      | Eq => BigZ.compare nx (BigZ.mul zy (BigZ.Pos dx))
-      end
-  | Qq nx dx, Qq ny dy =>
-    match BigN.eq_bool dx BigN.zero, BigN.eq_bool dy BigN.zero with
-    | true, true => Eq
-    | true, false => BigZ.compare BigZ.zero ny
-    | false, true => BigZ.compare nx BigZ.zero
-    | false, false =>
-      match BigZ.cmp_sign nx ny with
-      | Lt => Lt
-      | Gt => Gt
-      | Eq => BigZ.compare (BigZ.mul nx (BigZ.Pos dy)) (BigZ.mul ny (BigZ.Pos dx))
-      end
-    end
-  end.
-
- Theorem spec_compare: forall q1 q2, 
-  compare q1 q2 = ([q1] ?= [q2])%Q.
- intros [z1 | x1 y1] [z2 | x2 y2]; 
-   unfold Qcompare, compare, to_Q, Qnum, Qden.
- repeat rewrite Zmult_1_r.
- generalize (BigZ.spec_compare z1 z2); case BigZ.compare; intros H; auto.
- rewrite H; rewrite Zcompare_refl; auto.
- rewrite Zmult_1_r.
- generalize (BigN.spec_eq_bool y2 BigN.zero);
-   case BigN.eq_bool; rewrite BigN.spec_0; intros HH.
- rewrite Zmult_1_r; generalize (BigZ.spec_compare z1 BigZ.zero);
-  case BigZ.compare; auto.
- rewrite BigZ.spec_0; intros HH1; rewrite HH1; rewrite Zcompare_refl; auto.
- set (a := BigZ.to_Z z1); set (b := BigZ.to_Z x2);
-   set (c := BigN.to_Z y2); fold c in HH.
- assert (F: (0 < c)%Z).
-   case (Zle_lt_or_eq _ _ (BigN.spec_pos  y2)); fold c; auto.
-   intros H1; case HH; rewrite <- H1; auto.
- rewrite Z2P_correct; auto with zarith.
- generalize (BigZ.spec_cmp_sign z1 x2); case BigZ.cmp_sign; fold a b c.
- intros _; generalize (BigZ.spec_compare (z1 * BigZ.Pos y2)%bigZ x2); 
-   case BigZ.compare; rewrite BigZ.spec_mul; simpl; fold a b c; auto.
- intros H1; rewrite H1; rewrite Zcompare_refl; auto.
- intros (H1, H2); apply sym_equal; change (a * c < b)%Z.
- apply Zlt_le_trans with (2 := H2).
- change 0%Z with (0 * c)%Z.
- apply Zmult_lt_compat_r; auto with zarith.
- intros (H1, H2); apply sym_equal; change (a * c > b)%Z.
- apply Zlt_gt.
- apply Zlt_le_trans with (1 := H2).
- change 0%Z with (0 * c)%Z.
- apply Zmult_le_compat_r; auto with zarith.
- generalize (BigN.spec_eq_bool y1 BigN.zero);
-   case BigN.eq_bool; rewrite BigN.spec_0; intros HH.
- rewrite Zmult_0_l; rewrite Zmult_1_r.
- generalize (BigZ.spec_compare BigZ.zero z2);
-  case BigZ.compare; auto.
- rewrite BigZ.spec_0; intros HH1; rewrite <- HH1; rewrite Zcompare_refl; auto.
- set (a := BigZ.to_Z z2); set (b := BigZ.to_Z x1);
-   set (c := BigN.to_Z y1); fold c in HH.
- assert (F: (0 < c)%Z).
-   case (Zle_lt_or_eq _ _ (BigN.spec_pos  y1)); fold c; auto.
-   intros H1; case HH; rewrite <- H1; auto.
- rewrite Zmult_1_r; rewrite Z2P_correct; auto with zarith.
- generalize (BigZ.spec_cmp_sign x1 z2); case BigZ.cmp_sign; fold a b c.
- intros _; generalize (BigZ.spec_compare x1 (z2 * BigZ.Pos y1)%bigZ); 
-   case BigZ.compare; rewrite BigZ.spec_mul; simpl; fold a b c; auto.
- intros H1; rewrite H1; rewrite Zcompare_refl; auto.
- intros (H1, H2); apply sym_equal; change (b < a * c)%Z.
- apply Zlt_le_trans with (1 := H1).
- change 0%Z with (0 * c)%Z.
- apply Zmult_le_compat_r; auto with zarith.
- intros (H1, H2); apply sym_equal; change (b > a * c)%Z.
- apply Zlt_gt.
- apply Zlt_le_trans with (2 := H1).
- change 0%Z with (0 * c)%Z.
- apply Zmult_lt_compat_r; auto with zarith.
- generalize (BigN.spec_eq_bool y1 BigN.zero);
-   case BigN.eq_bool; rewrite BigN.spec_0; intros HH.
- generalize (BigN.spec_eq_bool y2 BigN.zero);
-   case BigN.eq_bool; rewrite BigN.spec_0; intros HH1.
- rewrite Zcompare_refl; auto.
- rewrite Zmult_0_l; rewrite Zmult_1_r.
- generalize (BigZ.spec_compare BigZ.zero x2);
-  case BigZ.compare; auto.
- rewrite BigZ.spec_0; intros HH2; rewrite <- HH2; rewrite Zcompare_refl; auto.
- generalize (BigN.spec_eq_bool y2 BigN.zero);
-   case BigN.eq_bool; rewrite BigN.spec_0; intros HH1.
- rewrite Zmult_0_l; rewrite Zmult_1_r.
- generalize (BigZ.spec_compare x1 BigZ.zero)%bigZ; case BigZ.compare;
-   auto; rewrite BigZ.spec_0.
- intros HH2; rewrite <- HH2; rewrite Zcompare_refl; auto.
- set (a := BigZ.to_Z x1); set (b := BigZ.to_Z x2);
-   set (c1 := BigN.to_Z y1); set (c2 := BigN.to_Z y2).
- fold c1 in HH; fold c2 in HH1.
- assert (F1: (0 < c1)%Z).
-   case (Zle_lt_or_eq _ _ (BigN.spec_pos  y1)); fold c1; auto.
-   intros H1; case HH; rewrite <- H1; auto.
- assert (F2: (0 < c2)%Z).
-   case (Zle_lt_or_eq _ _ (BigN.spec_pos  y2)); fold c2; auto.
-   intros H1; case HH1; rewrite <- H1; auto.
- repeat rewrite Z2P_correct; auto.
- generalize (BigZ.spec_cmp_sign x1 x2); case BigZ.cmp_sign.
- intros _; generalize (BigZ.spec_compare (x1 * BigZ.Pos y2)%bigZ
-                          (x2 * BigZ.Pos y1)%bigZ); 
-   case BigZ.compare; rewrite BigZ.spec_mul; simpl; fold a b c1 c2; auto.
- rewrite BigZ.spec_mul; simpl; fold a b c1; intros HH2; rewrite HH2;
-  rewrite Zcompare_refl; auto.
- rewrite BigZ.spec_mul; simpl; auto.
- rewrite BigZ.spec_mul; simpl; auto.
- fold a b; intros (H1, H2); apply sym_equal; change (a * c2 < b * c1)%Z.
- apply Zlt_le_trans with 0%Z.
-   change 0%Z with (0 * c2)%Z.
- apply Zmult_lt_compat_r; auto with zarith.
- apply Zmult_le_0_compat; auto with zarith.
- fold a b; intros (H1, H2); apply sym_equal; change (a * c2 > b * c1)%Z.
- apply Zlt_gt; apply Zlt_le_trans with 0%Z.
- change 0%Z with (0 * c1)%Z.
- apply Zmult_lt_compat_r; auto with zarith.
- apply Zmult_le_0_compat; auto with zarith.
- Qed.
-
-
- Definition do_norm_n n := 
-  match n with
-  | BigN.N0 _ => false
-  | BigN.N1 _ => false
-  | BigN.N2 _ => false
-  | BigN.N3 _ => false
-  | BigN.N4 _ => false
-  | BigN.N5 _ => false
-  | BigN.N6 _ => false
-  | _         => true 
-  end.
- 
- Definition do_norm_z z :=
-  match z with
-  | BigZ.Pos n => do_norm_n n
-  | BigZ.Neg n => do_norm_n n
-  end.
-
-(* Je pense que cette fonction normalise bien ... *)
- Definition norm n d: t :=
-  if andb (do_norm_z n) (do_norm_n d) then
-  let gcd := BigN.gcd (BigZ.to_N n) d in 
-  match BigN.compare BigN.one gcd with
-  | Lt => 
-    let n := BigZ.div n (BigZ.Pos gcd) in
-    let d := BigN.div d gcd in
-    match BigN.compare d BigN.one with
-    | Gt => Qq n d
-    | Eq => Qz n
-    | Lt => zero
-    end
-  | Eq => Qq n d
-  | Gt => zero (* gcd = 0 => both numbers are 0 *)
-  end
- else Qq n d.
-
- Theorem spec_norm: forall n q, 
-     ([norm n q] == [Qq n q])%Q.
- intros p q; unfold norm.
- case do_norm_z; simpl andb.
- 2: apply Qeq_refl.
- case do_norm_n.
- 2: apply Qeq_refl.
- assert (Hp := BigN.spec_pos (BigZ.to_N p)).
- match goal with  |- context[BigN.compare ?X ?Y] => 
-   generalize (BigN.spec_compare X Y); case BigN.compare
- end; auto; rewrite BigN.spec_1; rewrite BigN.spec_gcd; intros H1.
-   apply Qeq_refl.
- generalize (BigN.spec_pos (q / BigN.gcd (BigZ.to_N p) q)%bigN).
- match goal with  |- context[BigN.compare ?X ?Y] => 
-   generalize (BigN.spec_compare X Y); case BigN.compare
- end; auto; rewrite BigN.spec_1; rewrite BigN.spec_div; 
-   rewrite BigN.spec_gcd; auto with zarith; intros H2 HH.
- red; simpl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto; rewrite BigN.spec_0; intros H3; simpl;
-  rewrite BigZ.spec_div; simpl; rewrite BigN.spec_gcd;
-  auto with zarith.
- generalize H2; rewrite H3; 
-   rewrite Zdiv_0_l; auto with zarith.
- generalize H1 H2 H3 (BigN.spec_pos q); clear H1 H2 H3.
- rewrite spec_to_N.
- set (a := (BigN.to_Z (BigZ.to_N p))).
- set (b := (BigN.to_Z q)).
- intros H1 H2 H3 H4; rewrite Z2P_correct; auto with zarith.
- rewrite Zgcd_div_swap; auto with zarith.
- rewrite H2; ring.
- red; simpl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto; rewrite BigN.spec_0; intros H3; simpl.
- case H3.
- generalize H1 H2 H3 HH; clear H1 H2 H3 HH.
- set (a := (BigN.to_Z (BigZ.to_N p))).
- set (b := (BigN.to_Z q)).
- intros H1 H2 H3 HH.
-  rewrite (Zdivide_Zdiv_eq (Zgcd a b) b); auto with zarith.
- case (Zle_lt_or_eq _ _ HH); auto with zarith.
- intros HH1; rewrite <- HH1; ring.
- generalize (Zgcd_is_gcd a b); intros HH1; inversion HH1; auto.
- red; simpl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto; rewrite BigN.spec_0; rewrite BigN.spec_div;
-   rewrite BigN.spec_gcd; auto with zarith; intros H3.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto; rewrite BigN.spec_0; intros H4.
- case H3; rewrite H4;  rewrite Zdiv_0_l; auto with zarith.
- simpl.
- assert (FF := BigN.spec_pos q).
- rewrite Z2P_correct; auto with zarith.
- rewrite <- BigN.spec_gcd; rewrite <- BigN.spec_div; auto with zarith.
- rewrite Z2P_correct; auto with zarith.
- rewrite BigN.spec_div; rewrite BigN.spec_gcd; auto with zarith.
- simpl; rewrite BigZ.spec_div; simpl.
- rewrite BigN.spec_gcd; auto with zarith.
- generalize H1 H2 H3 H4 HH FF; clear H1 H2 H3 H4 HH FF.
- set (a := (BigN.to_Z (BigZ.to_N p))).
- set (b := (BigN.to_Z q)).
- intros H1 H2 H3 H4 HH FF.
- rewrite spec_to_N; fold a.
- rewrite Zgcd_div_swap; auto with zarith.
- rewrite BigN.spec_gcd; auto with zarith.
- rewrite BigN.spec_div; 
-   rewrite BigN.spec_gcd; auto with zarith.
- rewrite BigN.spec_gcd; auto with zarith.
- case (Zle_lt_or_eq _ _ 
-   (BigN.spec_pos (BigN.gcd (BigZ.to_N p) q)));
-  rewrite BigN.spec_gcd; auto with zarith.
- intros; apply False_ind; auto with zarith.
- intros HH2; assert (FF1 := Zgcd_inv_0_l _ _ (sym_equal HH2)).
- assert (FF2 := Zgcd_inv_0_l _ _ (sym_equal HH2)).
- red; simpl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto; rewrite BigN.spec_0; intros H2; simpl.
- rewrite spec_to_N.
- rewrite FF2; ring.
- Qed.
-   
- Definition add (x y: t): t :=
-  match x with
-  | Qz zx =>
-    match y with
-    | Qz zy => Qz (BigZ.add zx zy)
-    | Qq ny dy => 
-      if BigN.eq_bool dy BigN.zero then x 
-      else Qq (BigZ.add (BigZ.mul zx (BigZ.Pos dy)) ny) dy
-    end
-  | Qq nx dx =>
-    if BigN.eq_bool dx BigN.zero then y 
-    else match y with
-    | Qz zy => Qq (BigZ.add nx (BigZ.mul zy (BigZ.Pos dx))) dx
-    | Qq ny dy =>
-      if BigN.eq_bool dy BigN.zero then x
-      else
-       if BigN.eq_bool dx dy then
-         let n := BigZ.add nx ny in
-         Qq n dx
-       else
-         let n := BigZ.add (BigZ.mul nx (BigZ.Pos dy)) (BigZ.mul ny (BigZ.Pos dx)) in
-         let d := BigN.mul dx dy in
-         Qq n d
-    end
-  end.
-
-
-
- Theorem spec_add x y: 
-  ([add x y] == [x] + [y])%Q.
- intros [x | nx dx] [y | ny dy]; unfold Qplus; simpl.
- rewrite BigZ.spec_add; repeat rewrite Zmult_1_r; auto.
-  intros; apply Qeq_refl; auto.
- assert (F1:= BigN.spec_pos dy).
- rewrite Zmult_1_r; red; simpl.
- generalize (BigN.spec_eq_bool dy BigN.zero);
-   case BigN.eq_bool;
-   rewrite BigN.spec_0; intros HH; simpl; try ring.
- generalize (BigN.spec_eq_bool dy BigN.zero);
-   case BigN.eq_bool;
-   rewrite BigN.spec_0; intros HH1; simpl; try ring.
- case HH; auto.
- rewrite Z2P_correct; auto with zarith.
- rewrite BigZ.spec_add; rewrite BigZ.spec_mul; simpl; auto.
- generalize (BigN.spec_eq_bool dx BigN.zero);
-   case BigN.eq_bool;
-   rewrite BigN.spec_0; intros HH; simpl; try ring.
- rewrite Zmult_1_r; apply Qeq_refl.
- generalize (BigN.spec_eq_bool dx BigN.zero);
-   case BigN.eq_bool;
-   rewrite BigN.spec_0; intros HH1; simpl; try ring.
- case HH; auto.
- rewrite Z2P_correct; auto with zarith.
- rewrite BigZ.spec_add; rewrite BigZ.spec_mul; simpl; auto.
- rewrite Zmult_1_r; rewrite Pmult_1_r.
- apply Qeq_refl.
- assert (F1:= BigN.spec_pos dx); auto with zarith.
- generalize (BigN.spec_eq_bool dx BigN.zero);
-   case BigN.eq_bool; rewrite BigN.spec_0; intros HH.
- generalize (BigN.spec_eq_bool dy BigN.zero);
-   case BigN.eq_bool; rewrite BigN.spec_0; intros HH1.
- simpl.
- generalize (BigN.spec_eq_bool dy BigN.zero);
-   case BigN.eq_bool; rewrite BigN.spec_0; intros HH2.
- apply Qeq_refl.
- case HH2; auto.
- simpl.
- generalize (BigN.spec_eq_bool dy BigN.zero);
-   case BigN.eq_bool; rewrite BigN.spec_0; intros HH2.
- case HH2; auto.
- case HH1; auto.
- rewrite Zmult_1_r; apply Qeq_refl.
- generalize (BigN.spec_eq_bool dy BigN.zero);
-   case BigN.eq_bool; rewrite BigN.spec_0; intros HH1.
- simpl.
- generalize (BigN.spec_eq_bool dx BigN.zero);
-   case BigN.eq_bool; rewrite BigN.spec_0; intros HH2.
- case HH; auto.
- rewrite Zmult_1_r; rewrite Zplus_0_r; rewrite Pmult_1_r.
- apply Qeq_refl.
- simpl.
- generalize (BigN.spec_eq_bool (dx * dy)%bigN BigN.zero);
-   case BigN.eq_bool; rewrite BigN.spec_mul;
-   rewrite BigN.spec_0; intros HH2.
- (case (Zmult_integral _ _ HH2); intros HH3);
-  [case HH| case HH1]; auto.
- generalize (BigN.spec_eq_bool dx dy);
-   case BigN.eq_bool; intros HH3.
- rewrite <- HH3.
- assert (Fx: (0 < BigN.to_Z dx)%Z).
-   generalize (BigN.spec_pos dx); auto with zarith.
- red; simpl.
- generalize (BigN.spec_eq_bool dx BigN.zero);
-   case BigN.eq_bool; rewrite BigN.spec_0; intros HH4.
- case HH; auto.
- simpl; rewrite Zpos_mult_morphism.
- repeat rewrite Z2P_correct; auto with zarith.
- rewrite BigZ.spec_add; repeat rewrite BigZ.spec_mul; simpl.
- ring.
- assert (Fx: (0 < BigN.to_Z dx)%Z).
-   generalize (BigN.spec_pos dx); auto with zarith.
- assert (Fy: (0 < BigN.to_Z dy)%Z).
-   generalize (BigN.spec_pos dy); auto with zarith.
- red; simpl; rewrite Zpos_mult_morphism.
- repeat rewrite Z2P_correct; auto with zarith.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto; rewrite BigN.spec_mul;
-    rewrite BigN.spec_0; intros H3; simpl.
- absurd (0 < 0)%Z; auto with zarith.
- rewrite BigZ.spec_add; repeat rewrite BigZ.spec_mul; simpl.
- repeat rewrite Z2P_correct; auto with zarith.
- apply Zmult_lt_0_compat; auto.
- Qed.
-
- Theorem spec_addc x y:
-  [[add x y]] = [[x]] + [[y]].
- intros x y; unfold to_Qc.
- apply trans_equal with (!! ([x] + [y])).
- unfold Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete; apply spec_add; auto.
- unfold Qcplus, Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete.
- apply Qplus_comp; apply Qeq_sym; apply Qred_correct.
- Qed.
-
- Definition add_norm (x y: t): t :=
-  match x with
-  | Qz zx =>
-    match y with
-    | Qz zy => Qz (BigZ.add zx zy)
-    | Qq ny dy =>  
-      if BigN.eq_bool dy BigN.zero then x 
-      else 
-        norm (BigZ.add (BigZ.mul zx (BigZ.Pos dy)) ny) dy
-    end
-  | Qq nx dx =>
-    if BigN.eq_bool dx BigN.zero then y 
-    else match y with
-    | Qz zy => norm (BigZ.add nx (BigZ.mul zy (BigZ.Pos dx))) dx
-    | Qq ny dy =>
-      if BigN.eq_bool dy BigN.zero then x
-      else
-       if BigN.eq_bool dx dy then
-         let n := BigZ.add nx ny in
-         norm n dx
-       else
-         let n := BigZ.add (BigZ.mul nx (BigZ.Pos dy)) (BigZ.mul ny (BigZ.Pos dx)) in
-         let d := BigN.mul dx dy in
-         norm n d
-    end
-  end.
-
- Theorem spec_add_norm x y:
-  ([add_norm x y] == [x] + [y])%Q.
- intros x y; rewrite <- spec_add; auto.
- case x; case y; clear x y; unfold add_norm, add.
-  intros; apply Qeq_refl.
- intros p1 n p2.
- generalize (BigN.spec_eq_bool n BigN.zero);
-   case BigN.eq_bool; rewrite BigN.spec_0; intros HH.
- apply Qeq_refl.
- match goal with |- [norm ?X ?Y] == _ =>
-  apply Qeq_trans with ([Qq X Y]);
-  [apply spec_norm | idtac]
- end.
- simpl.
- generalize (BigN.spec_eq_bool n BigN.zero);
-   case BigN.eq_bool; rewrite BigN.spec_0; intros HH1.
- apply Qeq_refl.
- apply Qeq_refl.
- intros p1 p2 n.
- generalize (BigN.spec_eq_bool n BigN.zero);
-   case BigN.eq_bool; rewrite BigN.spec_0; intros HH.
- apply Qeq_refl.
- match goal with |- [norm ?X ?Y] == _ =>
-  apply Qeq_trans with ([Qq X Y]);
-  [apply spec_norm | idtac]
- end.
- apply Qeq_refl.
- intros p1 q1 p2 q2.
- generalize (BigN.spec_eq_bool q2 BigN.zero);
-   case BigN.eq_bool; rewrite BigN.spec_0; intros HH1.
- apply Qeq_refl.
- generalize (BigN.spec_eq_bool q1 BigN.zero);
-   case BigN.eq_bool; rewrite BigN.spec_0; intros HH2.
- apply Qeq_refl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; intros HH3;
- match goal with |- [norm ?X ?Y] == _ =>
-  apply Qeq_trans with ([Qq X Y]);
-  [apply spec_norm | idtac]
- end; apply Qeq_refl.
- Qed.
-
- Theorem spec_add_normc x y:
-  [[add_norm x y]] = [[x]] + [[y]].
- intros x y; unfold to_Qc.
- apply trans_equal with (!! ([x] + [y])).
- unfold Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete; apply spec_add_norm; auto.
- unfold Qcplus, Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete.
- apply Qplus_comp; apply Qeq_sym; apply Qred_correct.
- Qed.
- 
- Definition sub x y := add x (opp y).
-
- Theorem spec_sub x y:
-  ([sub x y] == [x] - [y])%Q.
- intros x y; unfold sub; rewrite spec_add; auto.
- rewrite spec_opp; ring.
- Qed.
-
- Theorem spec_subc x y:  [[sub x y]] = [[x]] - [[y]].
- intros x y; unfold sub; rewrite spec_addc; auto.
- rewrite spec_oppc; ring.
- Qed.
-
- Definition sub_norm x y := add_norm x (opp y).
-
- Theorem spec_sub_norm x y: 
-  ([sub_norm x y] == [x] - [y])%Q.
- intros x y; unfold sub_norm; rewrite spec_add_norm; auto.
- rewrite spec_opp; ring.
- Qed.
-
- Theorem spec_sub_normc x y:
-   [[sub_norm x y]] = [[x]] - [[y]].
- intros x y; unfold sub_norm; rewrite spec_add_normc; auto.
- rewrite spec_oppc; ring.
- Qed.
-
- Definition mul (x y: t): t :=
-  match x, y with
-  | Qz zx, Qz zy => Qz (BigZ.mul zx zy)
-  | Qz zx, Qq ny dy => Qq (BigZ.mul zx ny) dy
-  | Qq nx dx, Qz zy => Qq (BigZ.mul nx zy) dx
-  | Qq nx dx, Qq ny dy => Qq (BigZ.mul nx ny) (BigN.mul dx dy)
-  end.
-
- Theorem spec_mul x y: ([mul x y] == [x] * [y])%Q.
- intros [x | nx dx] [y | ny dy]; unfold Qmult; simpl.
- rewrite BigZ.spec_mul; repeat rewrite Zmult_1_r; auto.
-  intros; apply Qeq_refl; auto.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end;  rewrite BigN.spec_0; intros HH1.
- red; simpl; ring.
- rewrite BigZ.spec_mul; apply Qeq_refl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros HH1.
- red; simpl; ring.
- rewrite BigZ.spec_mul; rewrite Pmult_1_r.
- apply Qeq_refl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0;  rewrite BigN.spec_mul;
-      intros HH1.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros HH2.
- red; simpl; auto.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros HH3.
- red; simpl; ring.
- case (Zmult_integral _ _ HH1); intros HH.
-   case HH2; auto.
-   case HH3; auto.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros HH2.
- case HH1; rewrite HH2; ring.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros HH3.
- case HH1; rewrite HH3; ring.
- rewrite BigZ.spec_mul.
- assert (tmp: 
-  (forall a b, 0 < a -> 0 < b -> Z2P (a * b) = (Z2P a * Z2P b)%positive)%Z).
-  intros [|a|a] [|b|b]; simpl; auto; intros; apply False_ind; auto with zarith.
- rewrite tmp; auto.
- apply Qeq_refl.
-  generalize (BigN.spec_pos dx); auto with zarith.
-  generalize (BigN.spec_pos dy); auto with zarith.
- Qed.
-
- Theorem spec_mulc x y:
-  [[mul x y]] = [[x]] * [[y]].
- intros x y; unfold to_Qc.
- apply trans_equal with (!! ([x] * [y])).
- unfold Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete; apply spec_mul; auto.
- unfold Qcmult, Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete.
- apply Qmult_comp; apply Qeq_sym; apply Qred_correct.
- Qed.
-
- Definition mul_norm (x y: t): t := 
-  match x, y with
-  | Qz zx, Qz zy => Qz (BigZ.mul zx zy)
-  | Qz zx, Qq ny dy => mul (Qz ny) (norm zx dy)
-  | Qq nx dx, Qz zy => mul (Qz nx) (norm zy dx)
-  | Qq nx dx, Qq ny dy => mul (norm nx dy) (norm ny dx)
-  end.
-
- Theorem spec_mul_norm x y:
-  ([mul_norm x y] == [x] * [y])%Q.
- intros x y; rewrite <- spec_mul; auto.
- unfold mul_norm; case x; case y; clear x y.
-  intros; apply Qeq_refl.
- intros p1 n p2.
- repeat rewrite spec_mul.
- match goal with |- ?Z == _ =>
-   match Z with context id [norm ?X ?Y] =>
-   let y := context id [Qq X Y] in
-   apply Qeq_trans with y; [repeat apply Qmult_comp;
-   repeat apply Qplus_comp; repeat apply Qeq_refl;
-   apply spec_norm | idtac]
-   end
- end.
- red; simpl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros HH; simpl; ring.
- intros p1 p2 n.
- repeat rewrite spec_mul.
- match goal with |- ?Z == _ =>
-   match Z with context id [norm ?X ?Y] =>
-   let y := context id [Qq X Y] in
-   apply Qeq_trans with y; [repeat apply Qmult_comp;
-   repeat apply Qplus_comp; repeat apply Qeq_refl;
-   apply spec_norm | idtac]
-   end
- end.
- red; simpl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros HH; simpl; try ring.
- rewrite Pmult_1_r; auto.
- intros p1 n1 p2 n2.
- repeat rewrite spec_mul.
- repeat match goal with |- ?Z == _ =>
-   match Z with context id [norm ?X ?Y] =>
-   let y := context id [Qq X Y] in
-   apply Qeq_trans with y; [repeat apply Qmult_comp;
-   repeat apply Qplus_comp; repeat apply Qeq_refl;
-   apply spec_norm | idtac]
-   end
- end.
- red; simpl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H1;
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H2; simpl; try ring.
- repeat rewrite Zpos_mult_morphism; ring.
- Qed.
-
- Theorem spec_mul_normc x y:
-   [[mul_norm x y]] = [[x]] * [[y]].
- intros x y; unfold to_Qc.
- apply trans_equal with (!! ([x] * [y])).
- unfold Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete; apply spec_mul_norm; auto.
- unfold Qcmult, Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete.
- apply Qmult_comp; apply Qeq_sym; apply Qred_correct.
- Qed.
-
- Definition inv (x: t): t := 
-  match x with
-  | Qz (BigZ.Pos n) => Qq BigZ.one n
-  | Qz (BigZ.Neg n) => Qq BigZ.minus_one n
-  | Qq (BigZ.Pos n) d => Qq (BigZ.Pos d) n
-  | Qq (BigZ.Neg n) d => Qq (BigZ.Neg d) n
-  end.
-
-
- Theorem spec_inv x:
-   ([inv x] == /[x])%Q.
- intros [ [x | x] | [nx | nx] dx]; unfold inv, Qinv; simpl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H1; auto.
- rewrite H1; apply Qeq_refl.
- generalize H1 (BigN.spec_pos x); case (BigN.to_Z x); auto.
- intros HH; case HH; auto.
- intros; red; simpl; auto.
- intros p _ HH; case HH; auto.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H1; auto.
- rewrite H1; apply Qeq_refl.
- generalize H1 (BigN.spec_pos x); case (BigN.to_Z x); simpl;
-   auto.
- intros HH; case HH; auto.
- intros; red; simpl; auto.
- intros p _ HH; case HH; auto.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H1; auto.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H2; simpl; auto.
- apply Qeq_refl.
- rewrite H1; apply Qeq_refl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H2; simpl; auto.
- rewrite H2; red; simpl; auto.
- generalize H1 (BigN.spec_pos nx); case (BigN.to_Z nx); simpl;
-   auto.
- intros HH; case HH; auto.
- intros; red; simpl.
- rewrite Zpos_mult_morphism.
- rewrite Z2P_correct; auto.
- generalize (BigN.spec_pos dx); auto with zarith.
- intros p _ HH; case HH; auto.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H1; auto.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H2; simpl; auto.
- apply Qeq_refl.
- rewrite H1; apply Qeq_refl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H2; simpl; auto.
- rewrite H2; red; simpl; auto.
- generalize H1 (BigN.spec_pos nx); case (BigN.to_Z nx); simpl;
-   auto.
- intros HH; case HH; auto.
- intros; red; simpl.
- assert (tmp: forall x, Zneg x = Zopp (Zpos x)); auto.
- rewrite tmp.
- rewrite Zpos_mult_morphism.
- rewrite Z2P_correct; auto.
- ring.
- generalize (BigN.spec_pos dx); auto with zarith.
- intros p _ HH; case HH; auto.
- Qed.
-
- Theorem spec_invc x:
-   [[inv x]] =  /[[x]].
- intros x; unfold to_Qc.
- apply trans_equal with (!! (/[x])).
- unfold Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete; apply spec_inv; auto.
- unfold Qcinv, Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete.
- apply Qinv_comp; apply Qeq_sym; apply Qred_correct.
- Qed.
-
- Definition inv_norm (x: t): t := 
-  match x with
-  | Qz (BigZ.Pos n) => 
-    if BigN.eq_bool n BigN.zero then zero else Qq BigZ.one n
-  | Qz (BigZ.Neg n) => 
-    if BigN.eq_bool n BigN.zero then zero else Qq BigZ.minus_one n
-  | Qq (BigZ.Pos n) d => 
-    if BigN.eq_bool n BigN.zero then zero else Qq (BigZ.Pos d) n
-  | Qq (BigZ.Neg n) d => 
-    if BigN.eq_bool n BigN.zero then zero else Qq (BigZ.Neg d) n
-  end.
-
- Theorem spec_inv_norm x: ([inv_norm x] == /[x])%Q.
- intros x; rewrite <- spec_inv; generalize x; clear x.
- intros [ [x | x] | [nx | nx] dx]; unfold inv_norm, inv;
-   match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-     generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
-   end; rewrite BigN.spec_0; intros H1; try apply Qeq_refl;
-   red; simpl;
-   match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-     generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
-   end; rewrite BigN.spec_0; intros H2; auto;
-   case H2; auto.
- Qed.
-
- Theorem spec_inv_normc x:
-   [[inv_norm x]] =  /[[x]].
- intros x; unfold to_Qc.
- apply trans_equal with (!! (/[x])).
- unfold Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete; apply spec_inv_norm; auto.
- unfold Qcinv, Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete.
- apply Qinv_comp; apply Qeq_sym; apply Qred_correct.
- Qed.
-
-
- Definition div x y := mul x (inv y).
-
- Theorem spec_div x y: ([div x y] == [x] / [y])%Q.
- intros x y; unfold div; rewrite spec_mul; auto.
- unfold Qdiv; apply Qmult_comp.
- apply Qeq_refl.
- apply spec_inv; auto.
- Qed.
-
- Theorem spec_divc x y: [[div x y]] = [[x]] / [[y]].
- intros x y; unfold div; rewrite spec_mulc; auto.
- unfold Qcdiv; apply f_equal2 with (f := Qcmult); auto.
- apply spec_invc; auto. 
- Qed.
-
- Definition div_norm x y := mul_norm x (inv y).
-
- Theorem spec_div_norm x y: ([div_norm x y] == [x] / [y])%Q.
- intros x y; unfold div_norm; rewrite spec_mul_norm; auto.
- unfold Qdiv; apply Qmult_comp.
- apply Qeq_refl.
- apply spec_inv; auto.
- Qed.
-
- Theorem spec_div_normc x y: [[div_norm x y]] = [[x]] / [[y]].
- intros x y; unfold div_norm; rewrite spec_mul_normc; auto.
- unfold Qcdiv; apply f_equal2 with (f := Qcmult); auto.
- apply spec_invc; auto.
- Qed.
-
-
- Definition square (x: t): t :=
-  match x with
-  | Qz zx => Qz (BigZ.square zx)
-  | Qq nx dx => Qq (BigZ.square nx) (BigN.square dx)
-  end.
-
-
- Theorem spec_square x: ([square x] == [x] ^ 2)%Q.
- intros [ x | nx dx]; unfold square.
- red; simpl; rewrite BigZ.spec_square; auto with zarith.
- simpl Qpower.
- repeat match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto; rewrite BigN.spec_0; intros H.
- red; simpl.
- repeat match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto; rewrite BigN.spec_0; rewrite BigN.spec_square;
-   intros H1.
- case H1; rewrite H; auto.
- red; simpl.
- repeat match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto; rewrite BigN.spec_0; rewrite BigN.spec_square;
-   intros H1.
- case H; case (Zmult_integral _ _ H1); auto.
- simpl.
- rewrite BigZ.spec_square.
- rewrite Zpos_mult_morphism.
- assert (tmp: 
-  (forall a b, 0 < a -> 0 < b -> Z2P (a * b) = (Z2P a * Z2P b)%positive)%Z).
-  intros [|a|a] [|b|b]; simpl; auto; intros; apply False_ind; auto with zarith.
- rewrite tmp; auto.
- generalize (BigN.spec_pos dx); auto with zarith.
- generalize (BigN.spec_pos dx); auto with zarith.
- Qed.
-
- Theorem spec_squarec x: [[square x]] =  [[x]]^2.
- intros x; unfold to_Qc.
- apply trans_equal with (!! ([x]^2)).
- unfold Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete; apply spec_square; auto.
- simpl Qcpower.
- replace (!! [x] * 1) with (!![x]); try ring.
- simpl.
- unfold Qcmult, Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete.
- apply Qmult_comp; apply Qeq_sym; apply Qred_correct.
- Qed.
-
- Definition power_pos (x: t) p: t :=
-  match x with
-  | Qz zx => Qz (BigZ.power_pos zx p)
-  | Qq nx dx => Qq (BigZ.power_pos nx p) (BigN.power_pos dx p)
-  end.
-
- Theorem spec_power_pos x p: ([power_pos x p] == [x] ^ Zpos p)%Q.
- Proof.
- intros [x | nx dx] p; unfold power_pos.
-   unfold power_pos; red; simpl.
-   generalize (Qpower_decomp p (BigZ.to_Z x) 1).
-   unfold Qeq; simpl.
-   rewrite Zpower_pos_1_l; simpl Z2P.
-   rewrite Zmult_1_r.
-   intros H; rewrite H.
-   rewrite BigZ.spec_power_pos; simpl; ring.
- simpl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto; rewrite BigN.spec_0; rewrite BigN.spec_power_pos; intros H1.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto; rewrite BigN.spec_0; intros H2.
- elim p; simpl.
- intros; red; simpl; auto.
- intros p1 Hp1; rewrite <- Hp1; red; simpl; auto.
- apply Qeq_refl.
- case H2; generalize H1.
- elim p; simpl.
- intros p1 Hrec.
- change (xI p1) with (1 + (xO p1))%positive.
- rewrite Zpower_pos_is_exp; rewrite Zpower_pos_1_r.
- intros HH; case (Zmult_integral _ _ HH); auto.
- rewrite <- Pplus_diag.
- rewrite Zpower_pos_is_exp.
- intros HH1; case (Zmult_integral _ _ HH1); auto.
- intros p1 Hrec.
- rewrite <- Pplus_diag.
- rewrite Zpower_pos_is_exp.
- intros HH1; case (Zmult_integral _ _ HH1); auto.
- rewrite Zpower_pos_1_r; auto.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto; rewrite BigN.spec_0; intros H2.
- case H1; rewrite H2; auto.
- simpl; rewrite Zpower_pos_0_l; auto.
- assert (F1: (0 < BigN.to_Z dx)%Z).
-     generalize (BigN.spec_pos dx); auto with zarith.
- assert (F2: (0 < BigN.to_Z dx  ^ ' p)%Z).
-  unfold Zpower; apply Zpower_pos_pos; auto.
- unfold power_pos; red; simpl.
- generalize (Qpower_decomp p (BigZ.to_Z nx) 
-               (Z2P (BigN.to_Z dx))).
- unfold Qeq; simpl.
- repeat rewrite Z2P_correct; auto.
- unfold Qeq; simpl; intros HH.
- rewrite HH.
- rewrite BigZ.spec_power_pos; simpl; ring.
- Qed.
-
- Theorem spec_power_posc x p:
-   [[power_pos x p]] = [[x]] ^ nat_of_P p.
- intros x p; unfold to_Qc.
- apply trans_equal with (!! ([x]^Zpos p)).
- unfold Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete; apply spec_power_pos; auto.
- pattern p; apply Pind; clear p.
- simpl; ring.
- intros p Hrec.
- rewrite nat_of_P_succ_morphism; simpl Qcpower.
- rewrite <- Hrec.
- unfold Qcmult, Q2Qc.
- apply Qc_decomp; intros _ _;
- unfold this.
- apply Qred_complete.
- assert (F: [x] ^ ' Psucc p == [x] *   [x] ^ ' p).
-  simpl; case x; simpl; clear x Hrec.
-  intros x; simpl; repeat rewrite Qpower_decomp; simpl.
-  red; simpl; repeat rewrite Zpower_pos_1_l; simpl Z2P.
-  rewrite Pplus_one_succ_l.
-  rewrite Zpower_pos_is_exp.
-  rewrite Zpower_pos_1_r; auto.
-  intros nx dx.
-  match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
-  end; auto; rewrite BigN.spec_0.
-  unfold Qpower_positive.
-  assert (tmp: forall p, pow_pos Qmult 0%Q p = 0%Q).
-    intros p1; elim p1; simpl; auto; clear p1.
-    intros p1 Hp1; rewrite Hp1; auto.
-    intros p1 Hp1; rewrite Hp1; auto.
-  repeat rewrite tmp; intros; red; simpl; auto.
-  intros H1.
-  assert (F1: (0 < BigN.to_Z dx)%Z).
-     generalize (BigN.spec_pos dx); auto with zarith.
-  simpl; repeat rewrite Qpower_decomp; simpl.
-  red; simpl; repeat rewrite Zpower_pos_1_l; simpl Z2P.
-  rewrite Pplus_one_succ_l.
-  rewrite Zpower_pos_is_exp.
-  rewrite Zpower_pos_1_r; auto.
-  repeat rewrite Zpos_mult_morphism.
-  repeat rewrite Z2P_correct; auto.
-  2: apply Zpower_pos_pos; auto.
-  2: apply Zpower_pos_pos; auto.
-  rewrite Zpower_pos_is_exp.
-  rewrite Zpower_pos_1_r; auto.
- rewrite F.
- apply Qmult_comp; apply Qeq_sym; apply Qred_correct.
- Qed.
-
-
-End Qbi.
diff --git a/theories/Numbers/Rational/BigQ/QifMake.v b/theories/Numbers/Rational/BigQ/QifMake.v
deleted file mode 100644
index 1c8caa657..000000000
--- a/theories/Numbers/Rational/BigQ/QifMake.v
+++ /dev/null
@@ -1,979 +0,0 @@
-(************************************************************************)
-(*  v      *   The Coq Proof Assistant  /  The Coq Development Team     *)
-(* <O___,, * CNRS-Ecole Polytechnique-INRIA Futurs-Universite Paris Sud *)
-(*   \VV/  **************************************************************)
-(*    //   *      This file is distributed under the terms of the       *)
-(*         *       GNU Lesser General Public License Version 2.1        *)
-(************************************************************************)
-(*            Benjamin Gregoire, Laurent Thery, INRIA, 2007             *)
-(************************************************************************)
-
-(*i $Id$ i*)
-
-Require Import Bool.
-Require Import ZArith.
-Require Import Znumtheory.
-Require Import BigNumPrelude.
-Require Import Arith.
-Require Export BigN.
-Require Export BigZ.
-Require Import QArith.
-Require Import Qcanon.
-Require Import Qpower.
-Require Import QMake_base.
-
-Module Qif.
-
- Import BinInt.
- Open Local Scope Q_scope.
- Open Local Scope Qc_scope.
-
- (** The notation of a rational number is either an integer x,
-     interpreted as itself or a pair (x,y) of an integer x and a naturel
-     number y interpreted as x/y. The pairs (x,0) and (0,y) are all
-     interpreted as 0. *)
-
- Definition t := q_type.
-
- Definition zero: t := Qz BigZ.zero.
- Definition one: t := Qz BigZ.one.
- Definition minus_one: t := Qz BigZ.minus_one.
-
- Definition of_Z x: t := Qz (BigZ.of_Z x).
-
- Definition of_Q q: t := 
- match q with x # y =>
-  Qq (BigZ.of_Z x) (BigN.of_N (Npos y))
- end.
-
- Definition of_Qc q := of_Q (this q).
-
- Definition to_Q (q: t) := 
- match q with 
-  Qz x => BigZ.to_Z x # 1
- |Qq x y => if BigN.eq_bool y BigN.zero then 0%Q
-            else BigZ.to_Z x # Z2P (BigN.to_Z y)
- end.
-
- Definition to_Qc q := !!(to_Q q).
-
- Notation "[[ x ]]" := (to_Qc x).
-
- Notation "[ x ]" := (to_Q x).
-
- Theorem spec_to_Q: forall q: Q, [of_Q q] = q.
- intros (x,y); simpl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-  generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto; rewrite BigN.spec_0.
-   rewrite BigN.spec_of_pos; intros HH; discriminate HH.
- rewrite BigZ.spec_of_Z; simpl.
- rewrite (BigN.spec_of_pos); auto.
- Qed.
-
- Theorem spec_to_Qc: forall q, [[of_Qc q]] = q.
- intros (x, Hx); unfold of_Qc, to_Qc; simpl.
- apply Qc_decomp; simpl.
- intros; rewrite spec_to_Q; auto.
- Qed.
-
- Definition opp (x: t): t :=
-  match x with
-  | Qz zx => Qz (BigZ.opp zx)
-  | Qq nx dx => Qq (BigZ.opp nx) dx
-  end.
-
- Theorem spec_opp: forall q, ([opp q] = -[q])%Q.
- intros [z | x y]; simpl.
- rewrite BigZ.spec_opp; auto.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-  generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto; rewrite BigN.spec_0.
- rewrite BigZ.spec_opp; auto.
- Qed.
-
- Theorem spec_oppc: forall q, [[opp q]] = -[[q]].
- intros q; unfold Qcopp, to_Qc, Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- rewrite spec_opp.
- rewrite <- Qred_opp.
- rewrite Qred_involutive; auto.
- Qed.
-
- Definition compare (x y: t) :=
-  match x, y with
-  | Qz zx, Qz zy => BigZ.compare zx zy
-  | Qz zx, Qq ny dy => 
-    if BigN.eq_bool dy BigN.zero then BigZ.compare zx BigZ.zero
-    else BigZ.compare (BigZ.mul zx (BigZ.Pos dy)) ny
-  | Qq nx dx, Qz zy => 
-    if BigN.eq_bool dx BigN.zero then BigZ.compare BigZ.zero zy 
-    else BigZ.compare nx (BigZ.mul zy (BigZ.Pos dx))
-  | Qq nx dx, Qq ny dy =>
-    match BigN.eq_bool dx BigN.zero, BigN.eq_bool dy BigN.zero with
-    | true, true => Eq
-    | true, false => BigZ.compare BigZ.zero ny
-    | false, true => BigZ.compare nx BigZ.zero
-    | false, false => BigZ.compare (BigZ.mul nx (BigZ.Pos dy)) (BigZ.mul ny (BigZ.Pos dx))
-    end
-  end.
-
- Theorem spec_compare: forall q1 q2, 
-  compare q1 q2 = ([q1] ?= [q2])%Q.
- intros [z1 | x1 y1] [z2 | x2 y2]; 
-   unfold Qcompare, compare, to_Q, Qnum, Qden.
- repeat rewrite Zmult_1_r.
- generalize (BigZ.spec_compare z1 z2); case BigZ.compare; intros H; auto.
- rewrite H; rewrite Zcompare_refl; auto.
- rewrite Zmult_1_r.
- generalize (BigN.spec_eq_bool y2 BigN.zero);
-   case BigN.eq_bool; rewrite BigN.spec_0; intros HH.
- rewrite Zmult_1_r; generalize (BigZ.spec_compare z1 BigZ.zero);
-  case BigZ.compare; auto.
- rewrite BigZ.spec_0; intros HH1; rewrite HH1; rewrite Zcompare_refl; auto.
- rewrite Z2P_correct; auto with zarith.
-  2: generalize (BigN.spec_pos y2); auto with zarith.
- generalize (BigZ.spec_compare (z1 * BigZ.Pos y2) x2)%bigZ; case BigZ.compare;
-   rewrite BigZ.spec_mul; simpl; intros H; apply sym_equal; auto.
- rewrite H; rewrite Zcompare_refl; auto.
- generalize (BigN.spec_eq_bool y1 BigN.zero);
-   case BigN.eq_bool; rewrite BigN.spec_0; intros HH.
- rewrite Zmult_0_l; rewrite Zmult_1_r.
- generalize (BigZ.spec_compare BigZ.zero z2);
-  case BigZ.compare; auto.
- rewrite BigZ.spec_0; intros HH1; rewrite <- HH1; rewrite Zcompare_refl; auto.
- rewrite Z2P_correct; auto with zarith.
-  2: generalize (BigN.spec_pos y1); auto with zarith.
- rewrite Zmult_1_r.
- generalize (BigZ.spec_compare x1 (z2 * BigZ.Pos y1))%bigZ; case BigZ.compare;
-   rewrite BigZ.spec_mul; simpl; intros H; apply sym_equal; auto.
- rewrite H; rewrite Zcompare_refl; auto.
- generalize (BigN.spec_eq_bool y1 BigN.zero);
-   case BigN.eq_bool; rewrite BigN.spec_0; intros HH.
- generalize (BigN.spec_eq_bool y2 BigN.zero);
-   case BigN.eq_bool; rewrite BigN.spec_0; intros HH1.
- rewrite Zcompare_refl; auto.
- rewrite Zmult_0_l; rewrite Zmult_1_r.
- generalize (BigZ.spec_compare BigZ.zero x2);
-  case BigZ.compare; auto.
- rewrite BigZ.spec_0; intros HH2; rewrite <- HH2; rewrite Zcompare_refl; auto.
- generalize (BigN.spec_eq_bool y2 BigN.zero);
-   case BigN.eq_bool; rewrite BigN.spec_0; intros HH1.
- rewrite Zmult_0_l; rewrite Zmult_1_r.
- generalize (BigZ.spec_compare x1 BigZ.zero)%bigZ; case BigZ.compare;
-   auto; rewrite BigZ.spec_0.
- intros HH2; rewrite <- HH2; rewrite Zcompare_refl; auto.
- repeat rewrite Z2P_correct.
-  2: generalize (BigN.spec_pos y1); auto with zarith.
-  2: generalize (BigN.spec_pos y2); auto with zarith.
- generalize (BigZ.spec_compare (x1 * BigZ.Pos y2) 
-                               (x2 * BigZ.Pos y1))%bigZ; case BigZ.compare;
-   repeat rewrite BigZ.spec_mul; simpl; intros H; apply sym_equal; auto.
- rewrite H; rewrite Zcompare_refl; auto.
- Qed.
-
- Definition do_norm_n n := 
-  match n with
-  | BigN.N0 _ => false
-  | BigN.N1 _ => false
-  | BigN.N2 _ => false
-  | BigN.N3 _ => false
-  | BigN.N4 _ => false
-  | BigN.N5 _ => false
-  | BigN.N6 _ => false
-  | _         => true 
-  end.
-
- Definition do_norm_z z :=
-  match z with
-  | BigZ.Pos n => do_norm_n n
-  | BigZ.Neg n => do_norm_n n
-  end.
-
-(* Je pense que cette fonction normalise bien ... *)
- Definition norm n d: t :=
-  if andb (do_norm_z n) (do_norm_n d) then
-  let gcd := BigN.gcd (BigZ.to_N n) d in 
-  match BigN.compare BigN.one gcd with
-  | Lt => 
-    let n := BigZ.div n (BigZ.Pos gcd) in
-    let d := BigN.div d gcd in
-    match BigN.compare d BigN.one with
-    | Gt => Qq n d
-    | Eq => Qz n
-    | Lt => zero
-    end
-  | Eq => Qq n d
-  | Gt => zero (* gcd = 0 => both numbers are 0 *)
-  end
- else Qq n d.
-
- Theorem spec_norm: forall n q, 
-     ([norm n q] == [Qq n q])%Q.
- intros p q; unfold norm.
- case do_norm_z; simpl andb.
- 2: apply Qeq_refl.
- case do_norm_n.
- 2: apply Qeq_refl.
- assert (Hp := BigN.spec_pos (BigZ.to_N p)).
- match goal with  |- context[BigN.compare ?X ?Y] => 
-   generalize (BigN.spec_compare X Y); case BigN.compare
- end; auto; rewrite BigN.spec_1; rewrite BigN.spec_gcd; intros H1.
-   apply Qeq_refl.
- generalize (BigN.spec_pos (q / BigN.gcd (BigZ.to_N p) q)%bigN).
- match goal with  |- context[BigN.compare ?X ?Y] => 
-   generalize (BigN.spec_compare X Y); case BigN.compare
- end; auto; rewrite BigN.spec_1; rewrite BigN.spec_div; 
-   rewrite BigN.spec_gcd; auto with zarith; intros H2 HH.
- red; simpl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto; rewrite BigN.spec_0; intros H3; simpl;
-  rewrite BigZ.spec_div; simpl; rewrite BigN.spec_gcd;
-  auto with zarith.
- generalize H2; rewrite H3; 
-   rewrite Zdiv_0_l; auto with zarith.
- generalize H1 H2 H3 (BigN.spec_pos q); clear H1 H2 H3.
- rewrite spec_to_N.
- set (a := (BigN.to_Z (BigZ.to_N p))).
- set (b := (BigN.to_Z q)).
- intros H1 H2 H3 H4; rewrite Z2P_correct; auto with zarith.
- rewrite Zgcd_div_swap; auto with zarith.
- rewrite H2; ring.
- red; simpl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto; rewrite BigN.spec_0; intros H3; simpl.
- case H3.
- generalize H1 H2 H3 HH; clear H1 H2 H3 HH.
- set (a := (BigN.to_Z (BigZ.to_N p))).
- set (b := (BigN.to_Z q)).
- intros H1 H2 H3 HH.
-  rewrite (Zdivide_Zdiv_eq (Zgcd a b) b); auto with zarith.
- case (Zle_lt_or_eq _ _ HH); auto with zarith.
- intros HH1; rewrite <- HH1; ring.
- generalize (Zgcd_is_gcd a b); intros HH1; inversion HH1; auto.
- red; simpl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto; rewrite BigN.spec_0; rewrite BigN.spec_div;
-   rewrite BigN.spec_gcd; auto with zarith; intros H3.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto; rewrite BigN.spec_0; intros H4.
- case H3; rewrite H4;  rewrite Zdiv_0_l; auto with zarith.
- simpl.
- assert (FF := BigN.spec_pos q).
- rewrite Z2P_correct; auto with zarith.
- rewrite <- BigN.spec_gcd; rewrite <- BigN.spec_div; auto with zarith.
- rewrite Z2P_correct; auto with zarith.
- rewrite BigN.spec_div; rewrite BigN.spec_gcd; auto with zarith.
- simpl; rewrite BigZ.spec_div; simpl.
- rewrite BigN.spec_gcd; auto with zarith.
- generalize H1 H2 H3 H4 HH FF; clear H1 H2 H3 H4 HH FF.
- set (a := (BigN.to_Z (BigZ.to_N p))).
- set (b := (BigN.to_Z q)).
- intros H1 H2 H3 H4 HH FF.
- rewrite spec_to_N; fold a.
- rewrite Zgcd_div_swap; auto with zarith.
- rewrite BigN.spec_gcd; auto with zarith.
- rewrite BigN.spec_div; 
-   rewrite BigN.spec_gcd; auto with zarith.
- rewrite BigN.spec_gcd; auto with zarith.
- case (Zle_lt_or_eq _ _ 
-   (BigN.spec_pos (BigN.gcd (BigZ.to_N p) q)));
-  rewrite BigN.spec_gcd; auto with zarith.
- intros; apply False_ind; auto with zarith.
- intros HH2; assert (FF1 := Zgcd_inv_0_l _ _ (sym_equal HH2)).
- assert (FF2 := Zgcd_inv_0_l _ _ (sym_equal HH2)).
- red; simpl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto; rewrite BigN.spec_0; intros H2; simpl.
- rewrite spec_to_N.
- rewrite FF2; ring.
- Qed.
-
-   
- Definition add (x y: t): t :=
-  match x with
-  | Qz zx =>
-    match y with
-    | Qz zy => Qz (BigZ.add zx zy)
-    | Qq ny dy => 
-      if BigN.eq_bool dy BigN.zero then x 
-      else Qq (BigZ.add (BigZ.mul zx (BigZ.Pos dy)) ny) dy
-    end
-  | Qq nx dx =>
-    if BigN.eq_bool dx BigN.zero then y 
-    else match y with
-    | Qz zy => Qq (BigZ.add nx (BigZ.mul zy (BigZ.Pos dx))) dx
-    | Qq ny dy =>
-      if BigN.eq_bool dy BigN.zero then x
-      else
-       let n := BigZ.add (BigZ.mul nx (BigZ.Pos dy)) (BigZ.mul ny (BigZ.Pos dx)) in
-       let d := BigN.mul dx dy in
-       Qq n d
-    end
-  end.
-
-
- Theorem spec_add x y: 
-  ([add x y] == [x] + [y])%Q.
- intros [x | nx dx] [y | ny dy]; unfold Qplus; simpl.
- rewrite BigZ.spec_add; repeat rewrite Zmult_1_r; auto.
-  intros; apply Qeq_refl; auto.
- assert (F1:= BigN.spec_pos dy).
- rewrite Zmult_1_r; red; simpl.
- generalize (BigN.spec_eq_bool dy BigN.zero);
-   case BigN.eq_bool;
-   rewrite BigN.spec_0; intros HH; simpl; try ring.
- generalize (BigN.spec_eq_bool dy BigN.zero);
-   case BigN.eq_bool;
-   rewrite BigN.spec_0; intros HH1; simpl; try ring.
- case HH; auto.
- rewrite Z2P_correct; auto with zarith.
- rewrite BigZ.spec_add; rewrite BigZ.spec_mul; simpl; auto.
- generalize (BigN.spec_eq_bool dx BigN.zero);
-   case BigN.eq_bool;
-   rewrite BigN.spec_0; intros HH; simpl; try ring.
- rewrite Zmult_1_r; apply Qeq_refl.
- generalize (BigN.spec_eq_bool dx BigN.zero);
-   case BigN.eq_bool;
-   rewrite BigN.spec_0; intros HH1; simpl; try ring.
- case HH; auto.
- rewrite Z2P_correct; auto with zarith.
- rewrite BigZ.spec_add; rewrite BigZ.spec_mul; simpl; auto.
- rewrite Zmult_1_r; rewrite Pmult_1_r.
- apply Qeq_refl.
- assert (F1:= BigN.spec_pos dx); auto with zarith.
- generalize (BigN.spec_eq_bool dx BigN.zero);
-   case BigN.eq_bool; rewrite BigN.spec_0; intros HH.
- generalize (BigN.spec_eq_bool dy BigN.zero);
-   case BigN.eq_bool; rewrite BigN.spec_0; intros HH1.
- simpl.
- generalize (BigN.spec_eq_bool dy BigN.zero);
-   case BigN.eq_bool; rewrite BigN.spec_0; intros HH2.
- apply Qeq_refl.
- case HH2; auto.
- simpl.
- generalize (BigN.spec_eq_bool dy BigN.zero);
-   case BigN.eq_bool; rewrite BigN.spec_0; intros HH2.
- case HH2; auto.
- case HH1; auto.
- rewrite Zmult_1_r; apply Qeq_refl.
- generalize (BigN.spec_eq_bool dy BigN.zero);
-   case BigN.eq_bool; rewrite BigN.spec_0; intros HH1.
- simpl.
- generalize (BigN.spec_eq_bool dx BigN.zero);
-   case BigN.eq_bool; rewrite BigN.spec_0; intros HH2.
- case HH; auto.
- rewrite Zmult_1_r; rewrite Zplus_0_r; rewrite Pmult_1_r.
- apply Qeq_refl.
- simpl.
- generalize (BigN.spec_eq_bool (dx * dy)%bigN BigN.zero);
-   case BigN.eq_bool; rewrite BigN.spec_mul;
-   rewrite BigN.spec_0; intros HH2.
- (case (Zmult_integral _ _ HH2); intros HH3);
-  [case HH| case HH1]; auto.
- rewrite BigZ.spec_add; repeat rewrite BigZ.spec_mul; simpl.
- assert (Fx: (0 < BigN.to_Z dx)%Z).
-   generalize (BigN.spec_pos dx); auto with zarith.
- assert (Fy: (0 < BigN.to_Z dy)%Z).
-   generalize (BigN.spec_pos dy); auto with zarith.
- red; simpl; rewrite Zpos_mult_morphism.
- repeat rewrite Z2P_correct; auto with zarith.
- apply Zmult_lt_0_compat; auto.
- Qed.
-
- Theorem spec_addc x y:
-  [[add x y]] = [[x]] + [[y]].
- intros x y; unfold to_Qc.
- apply trans_equal with (!! ([x] + [y])).
- unfold Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete; apply spec_add; auto.
- unfold Qcplus, Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete.
- apply Qplus_comp; apply Qeq_sym; apply Qred_correct.
- Qed.
-
- Definition add_norm (x y: t): t :=
-  match x with
-  | Qz zx =>
-    match y with
-    | Qz zy => Qz (BigZ.add zx zy)
-    | Qq ny dy =>  
-      if BigN.eq_bool dy BigN.zero then x 
-      else norm (BigZ.add (BigZ.mul zx (BigZ.Pos dy)) ny) dy
-    end
-  | Qq nx dx =>
-    if BigN.eq_bool dx BigN.zero then y 
-    else match y with
-    | Qz zy => norm (BigZ.add nx (BigZ.mul zy (BigZ.Pos dx))) dx
-    | Qq ny dy =>
-      if BigN.eq_bool dy BigN.zero then x
-      else
-       let n := BigZ.add (BigZ.mul nx (BigZ.Pos dy)) (BigZ.mul ny (BigZ.Pos dx)) in
-       let d := BigN.mul dx dy in
-       norm n d
-    end
-  end.
-
- Theorem spec_add_norm x y:
-  ([add_norm x y] == [x] + [y])%Q.
- intros x y; rewrite <- spec_add; auto.
- case x; case y; clear x y; unfold add_norm, add.
-  intros; apply Qeq_refl.
- intros p1 n p2.
- generalize (BigN.spec_eq_bool n BigN.zero);
-   case BigN.eq_bool; rewrite BigN.spec_0; intros HH.
- apply Qeq_refl.
- match goal with |- [norm ?X ?Y] == _ =>
-  apply Qeq_trans with ([Qq X Y]);
-  [apply spec_norm | idtac]
- end.
- simpl.
- generalize (BigN.spec_eq_bool n BigN.zero);
-   case BigN.eq_bool; rewrite BigN.spec_0; intros HH1.
- apply Qeq_refl.
- apply Qeq_refl.
- intros p1 p2 n.
- generalize (BigN.spec_eq_bool n BigN.zero);
-   case BigN.eq_bool; rewrite BigN.spec_0; intros HH.
- apply Qeq_refl.
- match goal with |- [norm ?X ?Y] == _ =>
-  apply Qeq_trans with ([Qq X Y]);
-  [apply spec_norm | idtac]
- end.
- apply Qeq_refl.
- intros p1 q1 p2 q2.
- generalize (BigN.spec_eq_bool q2 BigN.zero);
-   case BigN.eq_bool; rewrite BigN.spec_0; intros HH1.
- apply Qeq_refl.
- generalize (BigN.spec_eq_bool q1 BigN.zero);
-   case BigN.eq_bool; rewrite BigN.spec_0; intros HH2.
- apply Qeq_refl.
- match goal with |- [norm ?X ?Y] == _ =>
-  apply Qeq_trans with ([Qq X Y]);
-  [apply spec_norm | idtac]
- end.
- apply Qeq_refl.
- Qed.
-
- Theorem spec_add_normc x y:
-  [[add_norm x y]] = [[x]] + [[y]].
- intros x y; unfold to_Qc.
- apply trans_equal with (!! ([x] + [y])).
- unfold Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete; apply spec_add_norm; auto.
- unfold Qcplus, Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete.
- apply Qplus_comp; apply Qeq_sym; apply Qred_correct.
- Qed.
-
- Definition sub x y := add x (opp y).
-
-
- Theorem spec_sub x y:
-  ([sub x y] == [x] - [y])%Q.
- intros x y; unfold sub; rewrite spec_add; auto.
- rewrite spec_opp; ring.
- Qed.
-
- Theorem spec_subc x y:  [[sub x y]] = [[x]] - [[y]].
- intros x y; unfold sub; rewrite spec_addc; auto.
- rewrite spec_oppc; ring.
- Qed.
-
- Definition sub_norm x y := add_norm x (opp y).
-
- Theorem spec_sub_norm x y: 
-  ([sub_norm x y] == [x] - [y])%Q.
- intros x y; unfold sub_norm; rewrite spec_add_norm; auto.
- rewrite spec_opp; ring.
- Qed.
-
- Theorem spec_sub_normc x y:
-   [[sub_norm x y]] = [[x]] - [[y]].
- intros x y; unfold sub_norm; rewrite spec_add_normc; auto.
- rewrite spec_oppc; ring.
- Qed.
-
- Definition mul (x y: t): t :=
-  match x, y with
-  | Qz zx, Qz zy => Qz (BigZ.mul zx zy)
-  | Qz zx, Qq ny dy => Qq (BigZ.mul zx ny) dy
-  | Qq nx dx, Qz zy => Qq (BigZ.mul nx zy) dx
-  | Qq nx dx, Qq ny dy => Qq (BigZ.mul nx ny) (BigN.mul dx dy)
-  end.
-
-
- Theorem spec_mul x y: ([mul x y] == [x] * [y])%Q.
- intros [x | nx dx] [y | ny dy]; unfold Qmult; simpl.
- rewrite BigZ.spec_mul; repeat rewrite Zmult_1_r; auto.
-  intros; apply Qeq_refl; auto.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end;  rewrite BigN.spec_0; intros HH1.
- red; simpl; ring.
- rewrite BigZ.spec_mul; apply Qeq_refl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros HH1.
- red; simpl; ring.
- rewrite BigZ.spec_mul; rewrite Pmult_1_r.
- apply Qeq_refl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0;  rewrite BigN.spec_mul;
-      intros HH1.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros HH2.
- red; simpl; auto.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros HH3.
- red; simpl; ring.
- case (Zmult_integral _ _ HH1); intros HH.
-   case HH2; auto.
-   case HH3; auto.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros HH2.
- case HH1; rewrite HH2; ring.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros HH3.
- case HH1; rewrite HH3; ring.
- rewrite BigZ.spec_mul.
- assert (tmp: 
-  (forall a b, 0 < a -> 0 < b -> Z2P (a * b) = (Z2P a * Z2P b)%positive)%Z).
-  intros [|a|a] [|b|b]; simpl; auto; intros; apply False_ind; auto with zarith.
- rewrite tmp; auto.
- apply Qeq_refl.
-  generalize (BigN.spec_pos dx); auto with zarith.
-  generalize (BigN.spec_pos dy); auto with zarith.
- Qed.
-
- Theorem spec_mulc x y:
-  [[mul x y]] = [[x]] * [[y]].
- intros x y; unfold to_Qc.
- apply trans_equal with (!! ([x] * [y])).
- unfold Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete; apply spec_mul; auto.
- unfold Qcmult, Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete.
- apply Qmult_comp; apply Qeq_sym; apply Qred_correct.
- Qed.
-
-
- Definition mul_norm (x y: t): t := 
-  match x, y with
-  | Qz zx, Qz zy => Qz (BigZ.mul zx zy)
-  | Qz zx, Qq ny dy => norm (BigZ.mul zx ny) dy
-  | Qq nx dx, Qz zy => norm (BigZ.mul nx zy) dx
-  | Qq nx dx, Qq ny dy => norm (BigZ.mul nx ny) (BigN.mul dx dy)
-  end.
-
- Theorem spec_mul_norm x y:
-  ([mul_norm x y] == [x] * [y])%Q.
- intros x y; rewrite <- spec_mul; auto.
- unfold mul_norm, mul; case x; case y; clear x y.
-  intros; apply Qeq_refl.
- intros p1 n p2.
- match goal with |- [norm ?X ?Y] == _ =>
-  apply Qeq_trans with ([Qq X Y]);
-  [apply spec_norm | idtac]
- end; apply Qeq_refl.
- intros p1 p2 n.
- match goal with |- [norm ?X ?Y] == _ =>
-  apply Qeq_trans with ([Qq X Y]);
-  [apply spec_norm | idtac]
- end; apply Qeq_refl.
- intros p1 n1 p2 n2.
- match goal with |- [norm ?X ?Y] == _ =>
-  apply Qeq_trans with ([Qq X Y]);
-  [apply spec_norm | idtac]
- end; apply Qeq_refl.
- Qed.
-
- Theorem spec_mul_normc x y:
-   [[mul_norm x y]] = [[x]] * [[y]].
- intros x y; unfold to_Qc.
- apply trans_equal with (!! ([x] * [y])).
- unfold Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete; apply spec_mul_norm; auto.
- unfold Qcmult, Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete.
- apply Qmult_comp; apply Qeq_sym; apply Qred_correct.
- Qed.
-
-
-
- Definition inv (x: t): t := 
-  match x with
-  | Qz (BigZ.Pos n) => Qq BigZ.one n
-  | Qz (BigZ.Neg n) => Qq BigZ.minus_one n
-  | Qq (BigZ.Pos n) d => Qq (BigZ.Pos d) n
-  | Qq (BigZ.Neg n) d => Qq (BigZ.Neg d) n
-  end.
-
- Theorem spec_inv x:
-   ([inv x] == /[x])%Q.
- intros [ [x | x] | [nx | nx] dx]; unfold inv, Qinv; simpl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H1; auto.
- rewrite H1; apply Qeq_refl.
- generalize H1 (BigN.spec_pos x); case (BigN.to_Z x); auto.
- intros HH; case HH; auto.
- intros; red; simpl; auto.
- intros p _ HH; case HH; auto.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H1; auto.
- rewrite H1; apply Qeq_refl.
- generalize H1 (BigN.spec_pos x); case (BigN.to_Z x); simpl;
-   auto.
- intros HH; case HH; auto.
- intros; red; simpl; auto.
- intros p _ HH; case HH; auto.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H1; auto.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H2; simpl; auto.
- apply Qeq_refl.
- rewrite H1; apply Qeq_refl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H2; simpl; auto.
- rewrite H2; red; simpl; auto.
- generalize H1 (BigN.spec_pos nx); case (BigN.to_Z nx); simpl;
-   auto.
- intros HH; case HH; auto.
- intros; red; simpl.
- rewrite Zpos_mult_morphism.
- rewrite Z2P_correct; auto.
- generalize (BigN.spec_pos dx); auto with zarith.
- intros p _ HH; case HH; auto.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H1; auto.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H2; simpl; auto.
- apply Qeq_refl.
- rewrite H1; apply Qeq_refl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H2; simpl; auto.
- rewrite H2; red; simpl; auto.
- generalize H1 (BigN.spec_pos nx); case (BigN.to_Z nx); simpl;
-   auto.
- intros HH; case HH; auto.
- intros; red; simpl.
- assert (tmp: forall x, Zneg x = Zopp (Zpos x)); auto.
- rewrite tmp.
- rewrite Zpos_mult_morphism.
- rewrite Z2P_correct; auto.
- ring.
- generalize (BigN.spec_pos dx); auto with zarith.
- intros p _ HH; case HH; auto.
- Qed.
-
- Theorem spec_invc x:
-   [[inv x]] =  /[[x]].
- intros x; unfold to_Qc.
- apply trans_equal with (!! (/[x])).
- unfold Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete; apply spec_inv; auto.
- unfold Qcinv, Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete.
- apply Qinv_comp; apply Qeq_sym; apply Qred_correct.
- Qed.
-
-
-Definition inv_norm (x: t): t := 
- match x with
- | Qz (BigZ.Pos n) => 
-   match BigN.compare n BigN.one with
-     Gt => Qq BigZ.one n
-   | _ =>  x
-   end
- | Qz (BigZ.Neg n) => 
-   match BigN.compare n BigN.one with
-     Gt => Qq BigZ.minus_one n
-   | _ =>  x
-   end
- | Qq (BigZ.Pos n) d =>
-   match BigN.compare n BigN.one with
-     Gt => Qq (BigZ.Pos d) n
-   | Eq =>  Qz (BigZ.Pos d) 
-   | Lt => Qz (BigZ.zero)
-   end
- | Qq (BigZ.Neg n) d => 
-   match BigN.compare n BigN.one with
-     Gt => Qq (BigZ.Neg d) n
-   | Eq =>  Qz (BigZ.Neg d) 
-   | Lt => Qz (BigZ.zero)
-   end
- end.
-
- Theorem spec_inv_norm x: ([inv_norm x] == /[x])%Q.
- intros [ [x | x] | [nx | nx] dx]; unfold inv_norm, Qinv.
- match goal with  |- context[BigN.compare ?X ?Y] => 
-   generalize (BigN.spec_compare X Y); case BigN.compare
- end; rewrite BigN.spec_1; intros H.
- simpl; rewrite H; apply Qeq_refl.
- case (Zle_lt_or_eq _ _ (BigN.spec_pos x)); simpl.
- generalize H; case BigN.to_Z.
- intros _ HH; discriminate HH.
- intros p; case p; auto.
-   intros p1 HH; discriminate HH.
-   intros p1 HH; discriminate HH.
- intros HH; discriminate HH.
- intros p _ HH; discriminate HH.
- intros HH; rewrite <- HH.
-   apply Qeq_refl.
- generalize H; simpl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H1.
- rewrite H1; intros HH; discriminate.
- generalize H; case BigN.to_Z.
- intros HH; discriminate HH.
- intros; red; simpl; auto.
- intros p HH; discriminate HH.
- match goal with  |- context[BigN.compare ?X ?Y] => 
-   generalize (BigN.spec_compare X Y); case BigN.compare
- end; rewrite BigN.spec_1; intros H.
- simpl; rewrite H; apply Qeq_refl.
- case (Zle_lt_or_eq _ _ (BigN.spec_pos x)); simpl.
- generalize H; case BigN.to_Z.
- intros _ HH; discriminate HH.
- intros p; case p; auto.
-   intros p1 HH; discriminate HH.
-   intros p1 HH; discriminate HH.
- intros HH; discriminate HH.
- intros p _ HH; discriminate HH.
- intros HH; rewrite <- HH.
-   apply Qeq_refl.
- generalize H; simpl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H1.
- rewrite H1; intros HH; discriminate.
- generalize H; case BigN.to_Z.
- intros HH; discriminate HH.
- intros; red; simpl; auto.
- intros p HH; discriminate HH.
- simpl Qnum.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H1; simpl.
- case BigN.compare; red; simpl; auto.
- rewrite H1; auto.
- case BigN.eq_bool; auto.
- simpl; rewrite H1; auto.
- match goal with  |- context[BigN.compare ?X ?Y] => 
-   generalize (BigN.spec_compare X Y); case BigN.compare
- end; rewrite BigN.spec_1; intros H2.
- rewrite H2.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H3.
- case H1; auto.
- red; simpl.
- rewrite Zmult_1_r; rewrite Pmult_1_r; rewrite Z2P_correct; auto.
- generalize (BigN.spec_pos dx); auto with zarith.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H3.
- case H1; auto.
- generalize H2 (BigN.spec_pos nx); case (BigN.to_Z nx).
- intros; apply Qeq_refl.
- intros p; case p; clear p.
- intros p HH; discriminate HH.
- intros p HH; discriminate HH.
- intros HH; discriminate HH.
- intros p _ HH; case HH; auto.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H3.
- case H1; auto.
- simpl; generalize H2; case (BigN.to_Z nx).
- intros HH; discriminate HH.
- intros p Hp.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H4.
- rewrite H4 in H2; discriminate H2.
- red; simpl.
- rewrite Zpos_mult_morphism.
- rewrite Z2P_correct; auto.
- generalize (BigN.spec_pos dx); auto with zarith.
- intros p HH; discriminate HH.
- simpl Qnum.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H1; simpl.
- case BigN.compare; red; simpl; auto.
- rewrite H1; auto.
- case BigN.eq_bool; auto.
- simpl; rewrite H1; auto.
- match goal with  |- context[BigN.compare ?X ?Y] => 
-   generalize (BigN.spec_compare X Y); case BigN.compare
- end; rewrite BigN.spec_1; intros H2.
- rewrite H2.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H3.
- case H1; auto.
- red; simpl.
- assert (tmp: forall x, Zneg x = Zopp (Zpos x)); auto.
- rewrite tmp.
- rewrite Zmult_1_r; rewrite Pmult_1_r; rewrite Z2P_correct; auto.
- generalize (BigN.spec_pos dx); auto with zarith.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H3.
- case H1; auto.
- generalize H2 (BigN.spec_pos nx); case (BigN.to_Z nx).
- intros; apply Qeq_refl.
- intros p; case p; clear p.
- intros p HH; discriminate HH.
- intros p HH; discriminate HH.
- intros HH; discriminate HH.
- intros p _ HH; case HH; auto.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H3.
- case H1; auto.
- simpl; generalize H2; case (BigN.to_Z nx).
- intros HH; discriminate HH.
- intros p Hp.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H4.
- rewrite H4 in H2; discriminate H2.
- red; simpl.
- assert (tmp: forall x, Zneg x = Zopp (Zpos x)); auto.
- rewrite tmp.
- rewrite Zpos_mult_morphism.
- rewrite Z2P_correct; auto.
- ring.
- generalize (BigN.spec_pos dx); auto with zarith.
- intros p HH; discriminate HH.
- Qed.
-
- Theorem spec_inv_normc x:
-   [[inv_norm x]] =  /[[x]].
- intros x; unfold to_Qc.
- apply trans_equal with (!! (/[x])).
- unfold Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete; apply spec_inv_norm; auto.
- unfold Qcinv, Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete.
- apply Qinv_comp; apply Qeq_sym; apply Qred_correct.
- Qed.
-
-
- Definition div x y := mul x (inv y).
-
- Theorem spec_div x y: ([div x y] == [x] / [y])%Q.
- intros x y; unfold div; rewrite spec_mul; auto.
- unfold Qdiv; apply Qmult_comp.
- apply Qeq_refl.
- apply spec_inv; auto.
- Qed.
-
- Theorem spec_divc x y: [[div x y]] = [[x]] / [[y]].
- intros x y; unfold div; rewrite spec_mulc; auto.
- unfold Qcdiv; apply f_equal2 with (f := Qcmult); auto.
- apply spec_invc; auto. 
- Qed.
-
- Definition div_norm x y := mul_norm x (inv y).
-
- Theorem spec_div_norm x y: ([div_norm x y] == [x] / [y])%Q.
- intros x y; unfold div_norm; rewrite spec_mul_norm; auto.
- unfold Qdiv; apply Qmult_comp.
- apply Qeq_refl.
- apply spec_inv; auto.
- Qed.
-
- Theorem spec_div_normc x y: [[div_norm x y]] = [[x]] / [[y]].
- intros x y; unfold div_norm; rewrite spec_mul_normc; auto.
- unfold Qcdiv; apply f_equal2 with (f := Qcmult); auto.
- apply spec_invc; auto.
- Qed.
-
-
- Definition square (x: t): t :=
-  match x with
-  | Qz zx => Qz (BigZ.square zx)
-  | Qq nx dx => Qq (BigZ.square nx) (BigN.square dx)
-  end.
-
- Theorem spec_square x: ([square x] == [x] ^ 2)%Q.
- intros [ x | nx dx]; unfold square.
- red; simpl; rewrite BigZ.spec_square; auto with zarith.
- simpl Qpower.
- repeat match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto; rewrite BigN.spec_0; intros H.
- red; simpl.
- repeat match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto; rewrite BigN.spec_0; rewrite BigN.spec_square;
-   intros H1.
- case H1; rewrite H; auto.
- red; simpl.
- repeat match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto; rewrite BigN.spec_0; rewrite BigN.spec_square;
-   intros H1.
- case H; case (Zmult_integral _ _ H1); auto.
- simpl.
- rewrite BigZ.spec_square.
- rewrite Zpos_mult_morphism.
- assert (tmp: 
-  (forall a b, 0 < a -> 0 < b -> Z2P (a * b) = (Z2P a * Z2P b)%positive)%Z).
-  intros [|a|a] [|b|b]; simpl; auto; intros; apply False_ind; auto with zarith.
- rewrite tmp; auto.
- generalize (BigN.spec_pos dx); auto with zarith.
- generalize (BigN.spec_pos dx); auto with zarith.
- Qed.
-
- Theorem spec_squarec x: [[square x]] =  [[x]]^2.
- intros x; unfold to_Qc.
- apply trans_equal with (!! ([x]^2)).
- unfold Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete; apply spec_square; auto.
- simpl Qcpower.
- replace (!! [x] * 1) with (!![x]); try ring.
- simpl.
- unfold Qcmult, Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete.
- apply Qmult_comp; apply Qeq_sym; apply Qred_correct.
- Qed.
-
-
-End Qif.
diff --git a/theories/Numbers/Rational/BigQ/QpMake.v b/theories/Numbers/Rational/BigQ/QpMake.v
deleted file mode 100644
index b9199357e..000000000
--- a/theories/Numbers/Rational/BigQ/QpMake.v
+++ /dev/null
@@ -1,901 +0,0 @@
-(************************************************************************)
-(*  v      *   The Coq Proof Assistant  /  The Coq Development Team     *)
-(* <O___,, * CNRS-Ecole Polytechnique-INRIA Futurs-Universite Paris Sud *)
-(*   \VV/  **************************************************************)
-(*    //   *      This file is distributed under the terms of the       *)
-(*         *       GNU Lesser General Public License Version 2.1        *)
-(************************************************************************)
-(*            Benjamin Gregoire, Laurent Thery, INRIA, 2007             *)
-(************************************************************************)
-
-(*i $Id$ i*)
-
-Require Import Bool.
-Require Import ZArith.
-Require Import Znumtheory.
-Require Import BigNumPrelude.
-Require Import Arith.
-Require Export BigN.
-Require Export BigZ.
-Require Import QArith.
-Require Import Qcanon.
-Require Import Qpower.
-Require Import QMake_base.
-
-Notation Nspec_lt := BigNAxiomsMod.NZOrdAxiomsMod.spec_lt.
-Notation Nspec_le := BigNAxiomsMod.NZOrdAxiomsMod.spec_le.
-
-Module Qp.
-
- (** The notation of a rational number is either an integer x,
-     interpreted as itself or a pair (x,y) of an integer x and a naturel
-     number y interpreted as x/(y+1). *)
-
- Definition t := q_type.
-
- Definition zero: t := Qz BigZ.zero.
- Definition one: t := Qz BigZ.one.
- Definition minus_one: t := Qz BigZ.minus_one.
-
- Definition of_Z x: t := Qz (BigZ.of_Z x).
-
- Definition d_to_Z d := BigZ.Pos (BigN.succ d).
-
- Definition of_Q q: t := 
- match q with x # y =>
-  Qq (BigZ.of_Z x) (BigN.pred (BigN.of_N (Npos y)))
- end.
-
- Definition of_Qc q := of_Q (this q).
-
- Definition to_Q (q: t) := 
- match q with 
-  Qz x => BigZ.to_Z x # 1
- |Qq x y => BigZ.to_Z x # Z2P (BigN.to_Z (BigN.succ y))
- end.
-
- Definition to_Qc q := !!(to_Q q).
-
- Notation "[[ x ]]" := (to_Qc x).
-
- Notation "[ x ]" := (to_Q x).
-
- Theorem spec_to_Q: forall q: Q, [of_Q q] = q.
- intros (x,y); simpl.
- rewrite BigZ.spec_of_Z; auto.
- rewrite BigN.spec_succ; simpl. simpl.
- rewrite BigN.spec_pred; rewrite (BigN.spec_of_pos).
- replace (Zpos y - 1 + 1)%Z with (Zpos y); auto; ring.
- red; auto.
- Qed.
-
- Theorem spec_to_Qc: forall q, [[of_Qc q]] = q.
- intros (x, Hx); unfold of_Qc, to_Qc; simpl.
- apply Qc_decomp; simpl.
- intros; rewrite spec_to_Q; auto.
- Qed.
-
- Definition opp (x: t): t :=
-  match x with
-  | Qz zx => Qz (BigZ.opp zx)
-  | Qq nx dx => Qq (BigZ.opp nx) dx
-  end.
-
-
- Theorem spec_opp: forall q, ([opp q] = -[q])%Q.
- intros [z | x y]; simpl.
- rewrite BigZ.spec_opp; auto.
- rewrite BigZ.spec_opp; auto.
- Qed.
-
-
- Theorem spec_oppc: forall q, [[opp q]] = -[[q]].
- intros q; unfold Qcopp, to_Qc, Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- rewrite spec_opp.
- rewrite <- Qred_opp.
- rewrite Qred_involutive; auto.
- Qed.
-
- Definition compare (x y: t) :=
-  match x, y with
-  | Qz zx, Qz zy => BigZ.compare zx zy
-  | Qz zx, Qq ny dy => BigZ.compare (BigZ.mul zx (d_to_Z dy)) ny
-  | Qq nx dy, Qz zy => BigZ.compare nx (BigZ.mul zy (d_to_Z dy))
-  | Qq nx dx, Qq ny dy =>
-    BigZ.compare (BigZ.mul nx (d_to_Z dy)) (BigZ.mul ny (d_to_Z dx))
-  end.
-
- Theorem spec_compare: forall q1 q2,
-  compare q1 q2 = ([q1] ?= [q2])%Q.
- intros [z1 | x1 y1] [z2 | x2 y2]; unfold Qcompare; simpl.
- repeat rewrite Zmult_1_r.
- generalize (BigZ.spec_compare z1 z2); case BigZ.compare; intros H; auto.
- rewrite H; rewrite Zcompare_refl; auto.
- rewrite Zmult_1_r.
- rewrite BigN.spec_succ.
- rewrite Z2P_correct; auto with zarith.
-  2: generalize (BigN.spec_pos y2); auto with zarith.
- generalize (BigZ.spec_compare (z1 * d_to_Z y2) x2)%bigZ; case BigZ.compare; 
-   intros H; rewrite <- H.
- rewrite BigZ.spec_mul; unfold d_to_Z; simpl.
- rewrite BigN.spec_succ.
- rewrite Zcompare_refl; auto.
- rewrite BigZ.spec_mul; unfold d_to_Z; simpl.
- rewrite BigN.spec_succ; auto.
- rewrite BigZ.spec_mul; unfold d_to_Z; simpl.
- rewrite BigN.spec_succ; auto.
- rewrite Zmult_1_r.
- rewrite BigN.spec_succ.
- rewrite Z2P_correct; auto with zarith.
-  2: generalize (BigN.spec_pos y1); auto with zarith.
- generalize (BigZ.spec_compare x1 (z2 * d_to_Z y1))%bigZ; case BigZ.compare;
-    rewrite BigZ.spec_mul; unfold d_to_Z; simpl;  
-    rewrite BigN.spec_succ; intros H; auto.
- rewrite H; rewrite Zcompare_refl; auto.
- repeat rewrite BigN.spec_succ; auto.
- repeat rewrite Z2P_correct; auto with zarith.
-  2: generalize (BigN.spec_pos y1); auto with zarith.
-  2: generalize (BigN.spec_pos y2); auto with zarith.
- generalize (BigZ.spec_compare (x1 * d_to_Z  y2)
-                  (x2 * d_to_Z y1))%bigZ; case BigZ.compare;
-    repeat rewrite BigZ.spec_mul; unfold d_to_Z; simpl;  
-    repeat rewrite BigN.spec_succ; intros H; auto.
- rewrite H; auto.
- rewrite Zcompare_refl; auto.
- Qed.
-
-
- Theorem spec_comparec: forall q1 q2,
-  compare q1 q2 = ([[q1]] ?= [[q2]]).
- unfold Qccompare, to_Qc. 
- intros q1 q2; rewrite spec_compare; simpl.
- apply Qcompare_comp; apply Qeq_sym; apply Qred_correct.
- Qed.
-
-(* Inv d > 0, Pour la forme normal unique on veut d > 1 *)
- Definition norm n d: t :=
-  if BigZ.eq_bool n BigZ.zero then zero
-  else
-    let gcd := BigN.gcd (BigZ.to_N n) d in
-    if BigN.eq_bool gcd BigN.one then Qq n (BigN.pred d)
-    else	
-      let n := BigZ.div n (BigZ.Pos gcd) in
-      let d := BigN.div d gcd in
-      if BigN.eq_bool d BigN.one then Qz n
-      else Qq n (BigN.pred d).
-
- Theorem spec_norm: forall n q, 
-    ((0 < BigN.to_Z q)%Z -> [norm n q] == [Qq n (BigN.pred q)])%Q.
- intros p q; unfold norm; intros Hq.
- assert (Hp := BigN.spec_pos (BigZ.to_N p)).
- match goal with  |- context[BigZ.eq_bool ?X ?Y] => 
-   generalize (BigZ.spec_eq_bool X Y); case BigZ.eq_bool
- end; auto; rewrite BigZ.spec_0; intros H1.
-   red; simpl; rewrite H1; ring.
- case (Zle_lt_or_eq _ _ Hp); clear Hp; intros Hp.
- case (Zle_lt_or_eq _ _ 
-      (Zgcd_is_pos (BigN.to_Z (BigZ.to_N p)) (BigN.to_Z q))); intros H4.
- 2: generalize Hq; rewrite (Zgcd_inv_0_r _ _ (sym_equal H4)); auto with zarith.
- 2: red; simpl; auto with zarith.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto; rewrite BigN.spec_1; intros H2.
-   apply Qeq_refl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto; rewrite BigN.spec_1.
- red; simpl.
- rewrite BigZ.spec_div; simpl; rewrite BigN.spec_gcd; auto with zarith.
- rewrite BigN.spec_div; simpl; rewrite BigN.spec_gcd; auto with zarith.
- rewrite Zmult_1_r.
- rewrite BigN.succ_pred by (rewrite Nspec_lt, BigN.spec_0; auto).
- rewrite Z2P_correct; auto with zarith.
- rewrite spec_to_N; intros; rewrite Zgcd_div_swap; auto.
- rewrite H; ring.
- intros H3.
- red; simpl.
- rewrite BigZ.spec_div; simpl; rewrite BigN.spec_gcd; auto with zarith.
- rewrite BigN.succ_pred by (rewrite Nspec_lt, BigN.spec_0; auto).
- assert (F: (0 < BigN.to_Z (q / BigN.gcd (BigZ.to_N p) q)%bigN)%Z).
-   rewrite BigN.spec_div; auto with zarith.
-   rewrite BigN.spec_gcd.
-   apply Zgcd_div_pos; auto.
-   rewrite BigN.spec_gcd; auto.
- rewrite BigN.succ_pred by (rewrite Nspec_lt, BigN.spec_0; auto).
- rewrite Z2P_correct; auto.
- rewrite Z2P_correct; auto.
- rewrite BigN.spec_div; simpl; rewrite BigN.spec_gcd; auto with zarith.
- rewrite spec_to_N; apply Zgcd_div_swap; auto.
- case H1; rewrite spec_to_N; rewrite <- Hp; ring.
- Qed.
-
- Theorem spec_normc: forall n q, 
-    (0 < BigN.to_Z q)%Z -> [[norm n q]] = [[Qq n (BigN.pred q)]].
- intros n q H; unfold to_Qc, Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete; apply spec_norm; auto.
- Qed.
-   
- Definition add (x y: t): t :=
-  match x, y with
-  | Qz zx, Qz zy => Qz (BigZ.add zx zy)
-  | Qz zx, Qq ny dy => Qq (BigZ.add (BigZ.mul zx (d_to_Z dy)) ny) dy
-  | Qq nx dx, Qz zy => Qq (BigZ.add nx (BigZ.mul zy (d_to_Z dx))) dx
-  | Qq nx dx, Qq ny dy => 
-    let dx' := BigN.succ dx in
-    let dy' := BigN.succ dy in
-    let n := BigZ.add (BigZ.mul nx (BigZ.Pos dy')) (BigZ.mul ny (BigZ.Pos dx')) in
-    let d := BigN.pred (BigN.mul dx' dy') in
-    Qq n d
-  end. 
-
- Theorem spec_d_to_Z: forall dy,
-     (BigZ.to_Z (d_to_Z dy) = BigN.to_Z dy + 1)%Z.
- intros dy; unfold d_to_Z; simpl.
- rewrite BigN.spec_succ; auto.
- Qed.
-
- Theorem spec_succ_pos: forall p,
-  (0 < BigN.to_Z (BigN.succ p))%Z.
- intros p; rewrite BigN.spec_succ;
-   generalize (BigN.spec_pos p); auto with zarith.
- Qed.
-
- Theorem spec_add x y: ([add x y] == [x] + [y])%Q.
- intros [x | nx dx] [y | ny dy]; unfold Qplus; simpl.
- rewrite BigZ.spec_add; repeat rewrite Zmult_1_r; auto.
-  apply Qeq_refl; auto.
- assert (F1:= BigN.spec_pos dy).
- rewrite Zmult_1_r.
- simpl; rewrite Z2P_correct; rewrite BigN.spec_succ; auto with zarith.
- rewrite BigZ.spec_add; rewrite BigZ.spec_mul.
- rewrite spec_d_to_Z; apply Qeq_refl.
- assert (F1:= BigN.spec_pos dx).
- rewrite Zmult_1_r; rewrite Pmult_1_r.
- simpl; rewrite Z2P_correct; rewrite BigN.spec_succ; auto with zarith.
- rewrite BigZ.spec_add; rewrite BigZ.spec_mul.
- rewrite spec_d_to_Z; apply Qeq_refl.
- repeat rewrite BigN.spec_succ.
- assert (Fx: (0 < BigN.to_Z dx + 1)%Z).
-   generalize (BigN.spec_pos dx); auto with zarith.
- assert (Fy: (0 < BigN.to_Z dy + 1)%Z).
-   generalize (BigN.spec_pos dy); auto with zarith.
- repeat rewrite BigN.spec_pred.
- rewrite BigZ.spec_add; repeat rewrite BigN.spec_mul;
-   repeat rewrite BigN.spec_succ.
- assert (tmp: forall x, (x-1+1 = x)%Z); [intros; ring | rewrite tmp; clear tmp].
- repeat rewrite Z2P_correct; auto.
- repeat rewrite BigZ.spec_mul; simpl.
- repeat rewrite BigN.spec_succ.
- assert (tmp: 
-  (forall a b, 0 < a -> 0 < b -> Z2P (a * b) = (Z2P a * Z2P b)%positive)%Z).
-  intros [|a|a] [|b|b]; simpl; auto; intros; apply False_ind; auto with zarith.
- rewrite tmp; auto; apply Qeq_refl.
- rewrite BigN.spec_mul; repeat rewrite BigN.spec_succ; auto with zarith.
- apply Zmult_lt_0_compat; auto.
- Qed.
-
- Theorem spec_addc x y: [[add x y]] = [[x]] + [[y]].
- intros x y; unfold to_Qc.
- apply trans_equal with (!! ([x] + [y])).
- unfold Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete; apply spec_add.
- unfold Qcplus, Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete.
- apply Qplus_comp; apply Qeq_sym; apply Qred_correct.
- Qed.
-
- Definition add_norm (x y: t): t := 
-  match x, y with
-  | Qz zx, Qz zy => Qz (BigZ.add zx zy)
-  | Qz zx, Qq ny dy => 
-    let d := BigN.succ dy in
-    norm (BigZ.add (BigZ.mul zx (BigZ.Pos d)) ny) d 
-  | Qq nx dx, Qz zy =>
-    let d := BigN.succ dx in
-    norm (BigZ.add (BigZ.mul zy (BigZ.Pos d)) nx) d
-  | Qq nx dx, Qq ny dy =>
-    let dx' := BigN.succ dx in
-    let dy' := BigN.succ dy in
-    let n := BigZ.add (BigZ.mul nx (BigZ.Pos dy')) (BigZ.mul ny (BigZ.Pos dx')) in
-    let d := BigN.mul dx' dy' in
-    norm n d 
-  end.
-
- Theorem spec_add_norm x y: ([add_norm x y] == [x] + [y])%Q.
- intros x y; rewrite <- spec_add.
- unfold add_norm, add; case x; case y.
-  intros; apply Qeq_refl.
- intros p1 n p2.
- match goal with |- [norm ?X ?Y] == _ =>
-  apply Qeq_trans with ([Qq X (BigN.pred Y)]);
-  [apply spec_norm | idtac]
- end.
- rewrite BigN.spec_succ; generalize (BigN.spec_pos n); auto with zarith.
- simpl.
- repeat rewrite BigZ.spec_add.
- repeat rewrite BigZ.spec_mul; simpl.
- rewrite BigN.succ_pred; try apply Qeq_refl; apply lt_0_succ.
- intros p1 n p2.
- match goal with |- [norm ?X ?Y] == _ =>
-  apply Qeq_trans with ([Qq X (BigN.pred Y)]);
-  [apply spec_norm | idtac]
- end.
- rewrite BigN.spec_succ; generalize (BigN.spec_pos p2); auto with zarith.
- simpl.
- repeat rewrite BigZ.spec_add.
- repeat rewrite BigZ.spec_mul; simpl.
- rewrite BinInt.Zplus_comm.
- rewrite BigN.succ_pred; try apply Qeq_refl; apply lt_0_succ.
- intros p1 q1 p2 q2.
- match goal with |- [norm ?X ?Y] == _ =>
-  apply Qeq_trans with ([Qq X (BigN.pred Y)]);
-  [apply spec_norm | idtac]
- end; try apply Qeq_refl.
- rewrite BigN.spec_mul.
- apply Zmult_lt_0_compat; apply spec_succ_pos.
- Qed.
-
- Theorem spec_add_normc x y: [[add_norm x y]] = [[x]] + [[y]].
- intros x y; unfold to_Qc.
- apply trans_equal with (!! ([x] + [y])).
- unfold Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete; apply spec_add_norm.
- unfold Qcplus, Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete.
- apply Qplus_comp; apply Qeq_sym; apply Qred_correct.
- Qed.
- 
- Definition sub (x y: t): t := add x (opp y).
-
- Theorem spec_sub x y: ([sub x y] == [x] - [y])%Q.
- intros x y; unfold sub; rewrite spec_add.
- rewrite spec_opp; ring.
- Qed.
-
- Theorem spec_subc x y: [[sub x y]] = [[x]] - [[y]].
- intros x y; unfold sub; rewrite spec_addc.
- rewrite spec_oppc; ring.
- Qed.
-
- Definition sub_norm x y := add_norm x (opp y).
-
- Theorem spec_sub_norm x y: ([sub_norm x y] == [x] - [y])%Q.
- intros x y; unfold sub_norm; rewrite spec_add_norm.
- rewrite spec_opp; ring.
- Qed.
-
- Theorem spec_sub_normc x y: [[sub_norm x y]] = [[x]] - [[y]].
- intros x y; unfold sub_norm; rewrite spec_add_normc.
- rewrite spec_oppc; ring.
- Qed.
-
-
- Definition mul (x y: t): t :=
-  match x, y with
-  | Qz zx, Qz zy => Qz (BigZ.mul zx zy)
-  | Qz zx, Qq ny dy => Qq (BigZ.mul zx ny) dy
-  | Qq nx dx, Qz zy => Qq (BigZ.mul nx zy) dx
-  | Qq nx dx, Qq ny dy => 
-    Qq (BigZ.mul nx ny) (BigN.pred (BigN.mul (BigN.succ dx) (BigN.succ dy)))
-  end.
-
- Theorem spec_mul x y: ([mul x y] == [x] * [y])%Q.
- intros [x | nx dx] [y | ny dy]; unfold Qmult; simpl.
- rewrite BigZ.spec_mul; repeat rewrite Zmult_1_r; auto.
-  apply Qeq_refl; auto.
- rewrite BigZ.spec_mul; apply Qeq_refl.
- rewrite BigZ.spec_mul; rewrite Pmult_1_r; auto.
-  apply Qeq_refl; auto.
- assert (F1:= spec_succ_pos dx).
- assert (F2:= spec_succ_pos dy).
- rewrite BigN.succ_pred.
- rewrite BigN.spec_mul; rewrite BigZ.spec_mul.
- assert (tmp: 
-  (forall a b, 0 < a -> 0 < b -> Z2P (a * b) = (Z2P a * Z2P b)%positive)%Z).
-  intros [|a|a] [|b|b]; simpl; auto; intros; apply False_ind; auto with zarith.
- rewrite tmp; auto; apply Qeq_refl.
- rewrite Nspec_lt, BigN.spec_0, BigN.spec_mul; auto.
- apply Zmult_lt_0_compat; apply spec_succ_pos.
- Qed.
-
- Theorem spec_mulc x y: [[mul x y]] = [[x]] * [[y]].
- intros x y; unfold to_Qc.
- apply trans_equal with (!! ([x] * [y])).
- unfold Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete; apply spec_mul.
- unfold Qcmult, Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete.
- apply Qmult_comp; apply Qeq_sym; apply Qred_correct.
- Qed.
-
- Definition mul_norm (x y: t): t := 
-  match x, y with
-  | Qz zx, Qz zy => Qz (BigZ.mul zx zy)
-  | Qz zx, Qq ny dy =>
-    if BigZ.eq_bool zx BigZ.zero then zero
-    else	
-      let d := BigN.succ dy in
-      let gcd := BigN.gcd (BigZ.to_N zx) d in
-      if BigN.eq_bool gcd BigN.one then Qq (BigZ.mul zx ny) dy
-      else 
-        let zx := BigZ.div zx (BigZ.Pos gcd) in
-        let d := BigN.div d gcd in
-        if BigN.eq_bool d BigN.one then Qz (BigZ.mul zx ny)
-        else Qq (BigZ.mul zx ny) (BigN.pred d)
-  | Qq nx dx, Qz zy =>   
-    if BigZ.eq_bool zy BigZ.zero then zero
-    else	
-      let d := BigN.succ dx in
-      let gcd := BigN.gcd (BigZ.to_N zy) d in
-      if BigN.eq_bool gcd BigN.one then Qq (BigZ.mul zy nx) dx
-      else 
-        let zy := BigZ.div zy (BigZ.Pos gcd) in
-        let d := BigN.div d gcd in
-        if BigN.eq_bool d BigN.one then Qz (BigZ.mul zy nx)
-        else Qq (BigZ.mul zy nx) (BigN.pred d)
-  | Qq nx dx, Qq ny dy => 
-    norm (BigZ.mul nx ny) (BigN.mul (BigN.succ dx) (BigN.succ dy))
-  end.
-
- Theorem spec_mul_norm x y: ([mul_norm x y] == [x] * [y])%Q.
- intros x y; rewrite <- spec_mul.
- unfold mul_norm, mul; case x; case y.
-  intros; apply Qeq_refl.
- intros p1 n p2.
- match goal with  |- context[BigZ.eq_bool ?X ?Y] => 
-   generalize (BigZ.spec_eq_bool X Y); case BigZ.eq_bool
- end; unfold zero, to_Q; repeat rewrite BigZ.spec_0; intros H.
- rewrite BigZ.spec_mul; rewrite H; red; auto.
- assert (F: (0 < BigN.to_Z (BigZ.to_N p2))%Z).
-  case (Zle_lt_or_eq _ _ (BigN.spec_pos (BigZ.to_N p2))); auto.
-  intros H1; case H; rewrite spec_to_N; rewrite <- H1; ring.
- assert (F1: (0 < BigN.to_Z (BigN.succ n))%Z).
-  rewrite BigN.spec_succ; generalize (BigN.spec_pos n); auto with zarith.
- assert (F2: (0 < Zgcd (BigN.to_Z (BigZ.to_N p2)) (BigN.to_Z (BigN.succ n)))%Z).
-   case (Zle_lt_or_eq _ _ (Zgcd_is_pos (BigN.to_Z (BigZ.to_N p2))
-                                       (BigN.to_Z (BigN.succ n)))); intros H3; auto.
-   generalize F; rewrite (Zgcd_inv_0_l _ _ (sym_equal H3)); auto with zarith.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_1; intros H1.
-  intros; apply Qeq_refl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_1.
- rewrite BigN.spec_div; rewrite BigN.spec_gcd;
-   auto with zarith.
- intros H2.
- red; simpl.
- repeat rewrite BigZ.spec_mul.
- rewrite BigZ.spec_div; simpl; rewrite BigN.spec_gcd; auto with zarith.
- rewrite Z2P_correct; auto with zarith.
- rewrite spec_to_N.
- rewrite Zmult_1_r; repeat rewrite <- Zmult_assoc.
- rewrite (Zmult_comm (BigZ.to_Z p1)).
- repeat rewrite Zmult_assoc.
- rewrite Zgcd_div_swap; auto with zarith.
- rewrite H2; ring.
- intros H2.
- red; simpl.
- repeat rewrite BigZ.spec_mul.
- rewrite BigZ.spec_div; simpl; rewrite BigN.spec_gcd; auto with zarith.
- rewrite Z2P_correct; auto with zarith.
- rewrite (spec_to_N p2).
- case (Zle_lt_or_eq _ _
-       (BigN.spec_pos  (BigN.succ n / 
-                         BigN.gcd (BigZ.to_N p2) 
-                                  (BigN.succ n)))%bigN); intros F3.
- rewrite BigN.succ_pred; auto with zarith.
- rewrite Z2P_correct; auto with zarith.
- rewrite BigN.spec_div; simpl; rewrite BigN.spec_gcd; auto with zarith.
- repeat rewrite <- Zmult_assoc.
- rewrite (Zmult_comm (BigZ.to_Z p1)).
- repeat rewrite Zmult_assoc.
- rewrite Zgcd_div_swap; auto; try ring.
- rewrite Nspec_lt, BigN.spec_0; auto.
- apply False_ind; generalize F1.
- rewrite (Zdivide_Zdiv_eq
-          (Zgcd (BigN.to_Z (BigZ.to_N p2)) (BigN.to_Z (BigN.succ n)))
-           (BigN.to_Z (BigN.succ n))); auto.
- generalize F3; rewrite BigN.spec_div; rewrite BigN.spec_gcd;
-   auto with zarith.
- intros HH; rewrite <- HH; auto with zarith.
- assert (FF:= Zgcd_is_gcd (BigN.to_Z (BigZ.to_N p2))
-           (BigN.to_Z (BigN.succ n))); inversion FF; auto.
- intros p1 p2 n.
- match goal with  |- context[BigZ.eq_bool ?X ?Y] => 
-   generalize (BigZ.spec_eq_bool X Y); case BigZ.eq_bool
- end; unfold zero, to_Q; repeat rewrite BigZ.spec_0; intros H.
- rewrite BigZ.spec_mul; rewrite H; red; simpl; ring.
- assert (F: (0 < BigN.to_Z (BigZ.to_N p1))%Z).
-  case (Zle_lt_or_eq _ _ (BigN.spec_pos (BigZ.to_N p1))); auto.
-  intros H1; case H; rewrite spec_to_N; rewrite <- H1; ring.
- assert (F1: (0 < BigN.to_Z (BigN.succ n))%Z).
-  rewrite BigN.spec_succ; generalize (BigN.spec_pos n); auto with zarith.
- assert (F2: (0 < Zgcd (BigN.to_Z (BigZ.to_N p1)) (BigN.to_Z (BigN.succ n)))%Z).
-   case (Zle_lt_or_eq _ _ (Zgcd_is_pos (BigN.to_Z (BigZ.to_N p1))
-                                       (BigN.to_Z (BigN.succ n)))); intros H3; auto.
-   generalize F; rewrite (Zgcd_inv_0_l _ _ (sym_equal H3)); auto with zarith.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_1; intros H1.
-  intros; repeat rewrite BigZ.spec_mul; rewrite Zmult_comm; apply Qeq_refl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_1.
- rewrite BigN.spec_div; rewrite BigN.spec_gcd;
-   auto with zarith.
- intros H2.
- red; simpl.
- repeat rewrite BigZ.spec_mul.
- rewrite BigZ.spec_div; simpl; rewrite BigN.spec_gcd; auto with zarith.
- rewrite Z2P_correct; auto with zarith.
- rewrite spec_to_N.
- rewrite Zmult_1_r; repeat rewrite <- Zmult_assoc.
- rewrite (Zmult_comm (BigZ.to_Z p2)).
- repeat rewrite Zmult_assoc.
- rewrite Zgcd_div_swap; auto with zarith.
- rewrite H2; ring.
- intros H2.
- red; simpl.
- repeat rewrite BigZ.spec_mul.
- rewrite BigZ.spec_div; simpl; rewrite BigN.spec_gcd; auto with zarith.
- rewrite Z2P_correct; auto with zarith.
- rewrite (spec_to_N p1).
- case (Zle_lt_or_eq _ _
-       (BigN.spec_pos  (BigN.succ n / 
-                         BigN.gcd (BigZ.to_N p1) 
-                                  (BigN.succ n)))%bigN); intros F3.
- rewrite BigN.succ_pred; auto with zarith.
- rewrite Z2P_correct; auto with zarith.
- rewrite BigN.spec_div; simpl; rewrite BigN.spec_gcd; auto with zarith.
- repeat rewrite <- Zmult_assoc.
- rewrite (Zmult_comm (BigZ.to_Z p2)).
- repeat rewrite Zmult_assoc.
- rewrite Zgcd_div_swap; auto; try ring.
- rewrite Nspec_lt, BigN.spec_0; auto.
- apply False_ind; generalize F1.
- rewrite (Zdivide_Zdiv_eq
-          (Zgcd (BigN.to_Z (BigZ.to_N p1)) (BigN.to_Z (BigN.succ n)))
-           (BigN.to_Z (BigN.succ n))); auto.
- generalize F3; rewrite BigN.spec_div; rewrite BigN.spec_gcd;
-   auto with zarith.
- intros HH; rewrite <- HH; auto with zarith.
- assert (FF:= Zgcd_is_gcd (BigN.to_Z (BigZ.to_N p1))
-           (BigN.to_Z (BigN.succ n))); inversion FF; auto.
- intros p1 n1 p2 n2.
- match goal with |- [norm ?X ?Y] == _ =>
-  apply Qeq_trans with ([Qq X (BigN.pred Y)]);
-  [apply spec_norm | idtac]
- end; try  apply Qeq_refl.
- rewrite BigN.spec_mul.
- apply Zmult_lt_0_compat; rewrite BigN.spec_succ;
-    generalize (BigN.spec_pos n1) (BigN.spec_pos n2); auto with zarith.
- Qed.
-
- Theorem spec_mul_normc x y: [[mul_norm x y]] = [[x]] * [[y]].
- intros x y; unfold to_Qc.
- apply trans_equal with (!! ([x] * [y])).
- unfold Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete; apply spec_mul_norm.
- unfold Qcmult, Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete.
- apply Qmult_comp; apply Qeq_sym; apply Qred_correct.
- Qed.
-
- Definition inv (x: t): t := 
-  match x with
-  | Qz (BigZ.Pos n) => 
-    if BigN.eq_bool n BigN.zero then zero else Qq BigZ.one (BigN.pred n)
-  | Qz (BigZ.Neg n) => 
-    if BigN.eq_bool n BigN.zero then zero else Qq BigZ.minus_one (BigN.pred n)
-  | Qq (BigZ.Pos n) d => 
-    if BigN.eq_bool n BigN.zero then zero else Qq (BigZ.Pos (BigN.succ d)) (BigN.pred n)
-  | Qq (BigZ.Neg n) d => 
-    if BigN.eq_bool n BigN.zero then zero else Qq (BigZ.Neg (BigN.succ d)) (BigN.pred n)
-  end.
-
- Theorem spec_inv x: ([inv x] == /[x])%Q.
- intros [ [x | x] | [nx | nx] dx]; unfold inv.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H.
-  unfold zero, to_Q; rewrite BigZ.spec_0.
- unfold BigZ.to_Z; rewrite H; apply Qeq_refl.
- assert (F: (0 < BigN.to_Z x)%Z).
-   case (Zle_lt_or_eq _ _ (BigN.spec_pos x)); auto with zarith.
- unfold to_Q; rewrite BigZ.spec_1.
- rewrite BigN.succ_pred by (rewrite Nspec_lt, BigN.spec_0; auto).
- red; unfold Qinv; simpl.
- generalize F; case BigN.to_Z; auto with zarith.
- intros p Hp; discriminate Hp.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H.
-  unfold zero, to_Q; rewrite BigZ.spec_0.
- unfold BigZ.to_Z; rewrite H; apply Qeq_refl.
- assert (F: (0 < BigN.to_Z x)%Z).
-   case (Zle_lt_or_eq _ _ (BigN.spec_pos x)); auto with zarith.
- red; unfold Qinv; simpl.
- rewrite BigN.succ_pred by (rewrite Nspec_lt, BigN.spec_0; auto).
- generalize F; case BigN.to_Z; simpl; auto with zarith.
- intros p Hp; discriminate Hp.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H.
-  unfold zero, to_Q; rewrite BigZ.spec_0.
- unfold BigZ.to_Z; rewrite H; apply Qeq_refl.
- assert (F: (0 < BigN.to_Z nx)%Z).
-   case (Zle_lt_or_eq _ _ (BigN.spec_pos nx)); auto with zarith.
- red; unfold Qinv; simpl.
- rewrite BigN.succ_pred by (rewrite Nspec_lt, BigN.spec_0; auto).
- rewrite BigN.spec_succ; rewrite Z2P_correct; auto with zarith.
- generalize F; case BigN.to_Z; auto with zarith.
- intros p Hp; discriminate Hp.
- generalize (BigN.spec_pos dx); auto with zarith.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H.
-  unfold zero, to_Q; rewrite BigZ.spec_0.
- unfold BigZ.to_Z; rewrite H; apply Qeq_refl.
- assert (F: (0 < BigN.to_Z nx)%Z).
-   case (Zle_lt_or_eq _ _ (BigN.spec_pos nx)); auto with zarith.
- red; unfold Qinv; simpl.
- rewrite BigN.succ_pred by (rewrite Nspec_lt, BigN.spec_0; auto).
- rewrite BigN.spec_succ; rewrite Z2P_correct; auto with zarith.
- generalize F; case BigN.to_Z; auto with zarith.
- simpl; intros.
- match goal with  |- (?X = Zneg ?Y)%Z => 
-   replace (Zneg Y) with (-(Zpos Y))%Z;
-   try rewrite Z2P_correct; auto with zarith
- end.
- rewrite Zpos_mult_morphism; 
-   rewrite Z2P_correct; auto with zarith; try ring.
- generalize (BigN.spec_pos dx); auto with zarith.
- intros p Hp; discriminate Hp.
- generalize (BigN.spec_pos dx); auto with zarith.
- Qed.
-
- Theorem spec_invc x: [[inv x]] =  /[[x]].
- intros x; unfold to_Qc.
- apply trans_equal with (!! (/[x])).
- unfold Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete; apply spec_inv.
- unfold Qcinv, Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete.
- apply Qinv_comp; apply Qeq_sym; apply Qred_correct.
- Qed.
-
-Definition inv_norm x := 
- match x with
- | Qz (BigZ.Pos n) => 
-      if BigN.eq_bool n BigN.zero then zero else
-      if BigN.eq_bool n BigN.one then x else Qq BigZ.one (BigN.pred n)
- | Qz (BigZ.Neg n) => 
-      if BigN.eq_bool n BigN.zero then zero  else
-      if BigN.eq_bool n BigN.one then x else Qq BigZ.minus_one (BigN.pred n)
- | Qq (BigZ.Pos n) d => let d := BigN.succ d in 
-                  if BigN.eq_bool n BigN.zero then zero else
-                  if BigN.eq_bool n BigN.one then Qz (BigZ.Pos d) 
-                     else Qq (BigZ.Pos d) (BigN.pred n)
- | Qq (BigZ.Neg n) d => let d := BigN.succ d in 
-                  if BigN.eq_bool n BigN.zero then zero else
-                  if BigN.eq_bool n BigN.one then Qz (BigZ.Neg d) 
-                     else Qq (BigZ.Neg d) (BigN.pred n)
- end.
-
- Theorem spec_inv_norm x: ([inv_norm x] == /[x])%Q.
- intros x; rewrite <- spec_inv.
- (case x; clear x); [intros [x | x] | intros nx dx];
-  unfold inv_norm, inv.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H.
-  apply Qeq_refl.
- assert (F: (0 < BigN.to_Z x)%Z).
-   case (Zle_lt_or_eq _ _ (BigN.spec_pos x)); auto with zarith.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_1; intros H1.
- red; simpl.
- rewrite BigN.succ_pred by (rewrite Nspec_lt, BigN.spec_0; auto).
- rewrite Z2P_correct; try rewrite H1; auto with zarith.
-  apply Qeq_refl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H.
-  apply Qeq_refl.
- assert (F: (0 < BigN.to_Z x)%Z).
-   case (Zle_lt_or_eq _ _ (BigN.spec_pos x)); auto with zarith.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_1; intros H1.
- red; simpl.
- rewrite BigN.succ_pred by (rewrite Nspec_lt, BigN.spec_0; auto).
- rewrite Z2P_correct; try rewrite H1; auto with zarith.
-  apply Qeq_refl.
- case nx; clear nx; intros nx.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H.
-  apply Qeq_refl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_1; intros H1.
- red; simpl.
- rewrite BigN.succ_pred; try rewrite H1; auto with zarith.
- rewrite Nspec_lt, BigN.spec_0, H1; auto with zarith.
- apply Qeq_refl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H.
-  apply Qeq_refl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_1; intros H1.
- red; simpl.
- rewrite BigN.succ_pred; try rewrite H1; auto with zarith.
- rewrite Nspec_lt, BigN.spec_0, H1; auto with zarith.
- apply Qeq_refl.
- Qed.
-
-
- Definition div x y := mul x (inv y).
-
- Theorem spec_div x y: ([div x y] == [x] / [y])%Q.
- intros x y; unfold div; rewrite spec_mul; auto.
- unfold Qdiv; apply Qmult_comp.
- apply Qeq_refl.
- apply spec_inv; auto.
- Qed.
-
- Theorem spec_divc x y: [[div x y]] = [[x]] / [[y]].
- intros x y; unfold div; rewrite spec_mulc; auto.
- unfold Qcdiv; apply f_equal2 with (f := Qcmult); auto.
- apply spec_invc; auto. 
- Qed.
-
- Definition div_norm x y := mul_norm x (inv y).
-
- Theorem spec_div_norm x y: ([div_norm x y] == [x] / [y])%Q.
- intros x y; unfold div_norm; rewrite spec_mul_norm; auto.
- unfold Qdiv; apply Qmult_comp.
- apply Qeq_refl.
- apply spec_inv; auto.
- Qed.
-
- Theorem spec_div_normc x y: [[div_norm x y]] = [[x]] / [[y]].
- intros x y; unfold div_norm; rewrite spec_mul_normc; auto.
- unfold Qcdiv; apply f_equal2 with (f := Qcmult); auto.
- apply spec_invc; auto.
- Qed.
-
-
- Definition square (x: t): t :=
-  match x with
-  | Qz zx => Qz (BigZ.square zx)
-  | Qq nx dx => Qq (BigZ.square nx) (BigN.pred (BigN.square (BigN.succ dx)))
-  end.
-
- Theorem spec_square x: ([square x] == [x] ^ 2)%Q.
- intros [ x | nx dx]; unfold square.
- red; simpl; rewrite BigZ.spec_square; auto with zarith.
- red; simpl; rewrite BigZ.spec_square; auto with zarith.
- assert (F: (0 < BigN.to_Z (BigN.succ dx))%Z).
-   rewrite BigN.spec_succ;
-   case (Zle_lt_or_eq _ _ (BigN.spec_pos dx)); auto with zarith.
- assert (F1 : (0 < BigN.to_Z (BigN.square (BigN.succ dx)))%Z).
-   rewrite BigN.spec_square; apply Zmult_lt_0_compat;
-     auto with zarith.
- rewrite BigN.succ_pred by (rewrite Nspec_lt, BigN.spec_0; auto).
- rewrite Zpos_mult_morphism.
- repeat rewrite Z2P_correct; auto with zarith.
- repeat rewrite BigN.spec_succ; auto with zarith.
- rewrite BigN.spec_square; auto with zarith.
- repeat rewrite BigN.spec_succ; auto with zarith.
- Qed.
-
- Theorem spec_squarec x: [[square x]] =  [[x]]^2.
- intros x; unfold to_Qc.
- apply trans_equal with (!! ([x]^2)).
- unfold Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete; apply spec_square.
- simpl Qcpower.
- replace (!! [x] * 1) with (!![x]); try ring.
- simpl.
- unfold Qcmult, Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete.
- apply Qmult_comp; apply Qeq_sym; apply Qred_correct.
- Qed.
-
- Definition power_pos (x: t) p: t :=
-  match x with
-  | Qz zx => Qz (BigZ.power_pos zx p)
-  | Qq nx dx => Qq (BigZ.power_pos nx p) (BigN.pred (BigN.power_pos (BigN.succ dx) p))
-  end.
-
-
- Theorem spec_power_pos x p: ([power_pos x p] == [x] ^ Zpos p)%Q.
- Proof.
- intros [x | nx dx] p; unfold power_pos.
-   unfold power_pos; red; simpl.
-   generalize (Qpower_decomp p (BigZ.to_Z x) 1).
-   unfold Qeq; simpl.
-   rewrite Zpower_pos_1_l; simpl Z2P.
-   rewrite Zmult_1_r.
-   intros H; rewrite H.
-   rewrite BigZ.spec_power_pos; simpl; ring.
- assert (F1: (0 < BigN.to_Z (BigN.succ dx))%Z).
-     rewrite BigN.spec_succ;
-     generalize (BigN.spec_pos dx); auto with zarith.
- assert (F2: (0 < BigN.to_Z (BigN.succ dx) ^ ' p)%Z).
-  unfold Zpower; apply Zpower_pos_pos; auto.
- unfold power_pos; red; simpl.
- rewrite BigN.succ_pred, BigN.spec_power_pos.
- rewrite Z2P_correct; auto.
- generalize (Qpower_decomp p (BigZ.to_Z nx) 
-               (Z2P (BigN.to_Z (BigN.succ dx)))).
- unfold Qeq; simpl.
- repeat rewrite Z2P_correct; auto.
- unfold Qeq; simpl; intros HH.
- rewrite HH.
- rewrite BigZ.spec_power_pos; simpl; ring.
- rewrite Nspec_lt, BigN.spec_0, BigN.spec_power_pos; auto.
- Qed.
-
- Theorem spec_power_posc x p: [[power_pos x p]] = [[x]] ^ nat_of_P p.
- intros x p; unfold to_Qc.
- apply trans_equal with (!! ([x]^Zpos p)).
- unfold Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete; apply spec_power_pos.
- pattern p; apply Pind; clear p.
- simpl; ring.
- intros p Hrec.
- rewrite nat_of_P_succ_morphism; simpl Qcpower.
- rewrite <- Hrec.
- unfold Qcmult, Q2Qc.
- apply Qc_decomp; intros _ _;
- unfold this.
- apply Qred_complete.
- assert (F: [x] ^ ' Psucc p == [x] *   [x] ^ ' p).
-  simpl; case x; simpl; clear x Hrec.
-  intros x; simpl; repeat rewrite Qpower_decomp; simpl.
-  red; simpl; repeat rewrite Zpower_pos_1_l; simpl Z2P.
-  rewrite Pplus_one_succ_l.
-  rewrite Zpower_pos_is_exp.
-  rewrite Zpower_pos_1_r; auto.
-  intros nx dx; simpl; repeat rewrite Qpower_decomp; simpl.
-  red; simpl; repeat rewrite Zpower_pos_1_l; simpl Z2P.
-  rewrite Pplus_one_succ_l.
-  rewrite Zpower_pos_is_exp.
-  rewrite Zpower_pos_1_r; auto.
-  assert (F1: (0 < BigN.to_Z (BigN.succ dx))%Z).
-    rewrite BigN.spec_succ; generalize (BigN.spec_pos dx); 
-      auto with zarith.
-  repeat rewrite Zpos_mult_morphism.
-  repeat rewrite Z2P_correct; auto.
-  2: apply Zpower_pos_pos; auto.
-  2: apply Zpower_pos_pos; auto.
-  rewrite Zpower_pos_is_exp.
-  rewrite Zpower_pos_1_r; auto.
- rewrite F.
- apply Qmult_comp; apply Qeq_sym; apply Qred_correct.
- Qed.
-
-
-End Qp.
diff --git a/theories/Numbers/Rational/BigQ/QvMake.v b/theories/Numbers/Rational/BigQ/QvMake.v
deleted file mode 100644
index 3f51e7063..000000000
--- a/theories/Numbers/Rational/BigQ/QvMake.v
+++ /dev/null
@@ -1,1151 +0,0 @@
-(************************************************************************)
-(*  v      *   The Coq Proof Assistant  /  The Coq Development Team     *)
-(* <O___,, * CNRS-Ecole Polytechnique-INRIA Futurs-Universite Paris Sud *)
-(*   \VV/  **************************************************************)
-(*    //   *      This file is distributed under the terms of the       *)
-(*         *       GNU Lesser General Public License Version 2.1        *)
-(************************************************************************)
-(*            Benjamin Gregoire, Laurent Thery, INRIA, 2007             *)
-(************************************************************************)
-
-(*i $Id$ i*)
-
-Require Import Bool.
-Require Import ZArith.
-Require Import Znumtheory.
-Require Import BigNumPrelude.
-Require Import Arith.
-Require Export BigN.
-Require Export BigZ.
-Require Import QArith.
-Require Import Qcanon.
-Require Import Qpower.
-Require Import QMake_base.
-
-Module Qv.
-
- Import BinInt Zorder.
- Open Local Scope Q_scope.
- Open Local Scope Qc_scope.
-
- (** The notation of a rational number is either an integer x,
-     interpreted as itself or a pair (x,y) of an integer x and a naturel
-     number y interpreted as x/y. All functions maintain the invariant
-     that y is never zero. *)
-
- Definition t := q_type.
-
- Definition zero: t := Qz BigZ.zero.
- Definition one: t := Qz BigZ.one.
- Definition minus_one: t := Qz BigZ.minus_one.
-
- Definition of_Z x: t := Qz (BigZ.of_Z x).
-
- Definition wf x := 
-  match x with
-  | Qz _ => True
-  | Qq n d => if BigN.eq_bool d BigN.zero then False else True
-  end.
-
- Definition of_Q q: t := 
- match q with x # y =>
-  Qq (BigZ.of_Z x) (BigN.of_N (Npos y))
- end.
-
- Definition of_Qc q := of_Q (this q).
-
- Definition to_Q (q: t) := 
- match q with 
-  Qz x => BigZ.to_Z x # 1
- |Qq x y => BigZ.to_Z x # Z2P (BigN.to_Z y)
- end.
-
- Definition to_Qc q := !!(to_Q q).
-
- Notation "[[ x ]]" := (to_Qc x).
-
- Notation "[ x ]" := (to_Q x).
-
- Theorem spec_to_Q: forall q: Q, [of_Q q] = q.
- intros (x,y); simpl.
- rewrite BigZ.spec_of_Z; simpl.
- rewrite (BigN.spec_of_pos); auto.
- Qed.
-
- Theorem spec_to_Qc: forall q, [[of_Qc q]] = q.
- intros (x, Hx); unfold of_Qc, to_Qc; simpl.
- apply Qc_decomp; simpl.
- intros; rewrite spec_to_Q; auto.
- Qed.
-
- Definition opp (x: t): t :=
-  match x with
-  | Qz zx => Qz (BigZ.opp zx)
-  | Qq nx dx => Qq (BigZ.opp nx) dx
-  end.
-
- Theorem wf_opp: forall x, wf x -> wf (opp x).
- intros [zx | nx dx]; unfold opp, wf; auto.
- Qed.
-
- Theorem spec_opp: forall q, ([opp q] = -[q])%Q.
- intros [z | x y]; simpl.
- rewrite BigZ.spec_opp; auto.
- rewrite BigZ.spec_opp; auto.
- Qed.
-
- Theorem spec_oppc: forall q, [[opp q]] = -[[q]].
- intros q; unfold Qcopp, to_Qc, Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- rewrite spec_opp.
- rewrite <- Qred_opp.
- rewrite Qred_involutive; auto.
- Qed.
-
- (* Les fonctions doivent assurer que si leur arguments sont valides alors
-    le resultat est correct et valide (si c'est un Q) 
- *)
-
- Definition compare (x y: t) :=
-  match x, y with
-  | Qz zx, Qz zy => BigZ.compare zx zy
-  | Qz zx, Qq ny dy => BigZ.compare (BigZ.mul zx (BigZ.Pos dy)) ny
-  | Qq nx dx, Qz zy => BigZ.compare nx (BigZ.mul zy (BigZ.Pos dx))  
-  | Qq nx dx, Qq ny dy => BigZ.compare (BigZ.mul nx (BigZ.Pos dy)) (BigZ.mul ny (BigZ.Pos dx))
-  end.
-
- Theorem spec_compare: forall q1 q2, wf q1 -> wf q2 ->
-  compare q1 q2 = ([q1] ?= [q2])%Q.
- intros [z1 | x1 y1] [z2 | x2 y2]; 
-   unfold Qcompare, compare, to_Q, Qnum, Qden, wf.
- repeat rewrite Zmult_1_r.
- generalize (BigZ.spec_compare z1 z2); case BigZ.compare; intros H; auto.
- rewrite H; rewrite Zcompare_refl; auto.
- rewrite Zmult_1_r.
- generalize (BigN.spec_eq_bool y2 BigN.zero);
-   case BigN.eq_bool.
-   intros _ _ HH; case HH.
- rewrite BigN.spec_0; intros HH _ _.
- rewrite Z2P_correct; auto with zarith.
-  2: generalize (BigN.spec_pos y2); auto with zarith.
- generalize (BigZ.spec_compare (z1 * BigZ.Pos y2) x2)%bigZ; case BigZ.compare;
-   rewrite BigZ.spec_mul; simpl; intros H; apply sym_equal; auto.
- rewrite H; rewrite Zcompare_refl; auto.
- generalize (BigN.spec_eq_bool y1 BigN.zero);
-   case BigN.eq_bool.
-   intros _ HH; case HH.
- rewrite BigN.spec_0; intros HH _ _.
- rewrite Z2P_correct; auto with zarith.
-  2: generalize (BigN.spec_pos y1); auto with zarith.
- rewrite Zmult_1_r.
- generalize (BigZ.spec_compare x1 (z2 * BigZ.Pos y1))%bigZ; case BigZ.compare;
-   rewrite BigZ.spec_mul; simpl; intros H; apply sym_equal; auto.
- rewrite H; rewrite Zcompare_refl; auto.
- generalize (BigN.spec_eq_bool y1 BigN.zero);
-   case BigN.eq_bool.
-   intros _ HH; case HH.
- rewrite BigN.spec_0; intros HH1. 
- generalize (BigN.spec_eq_bool y2 BigN.zero);
-   case BigN.eq_bool.
-   intros _ _ HH; case HH.
- rewrite BigN.spec_0; intros HH2 _ _.
- repeat rewrite Z2P_correct.
-  2: generalize (BigN.spec_pos y1); auto with zarith.
-  2: generalize (BigN.spec_pos y2); auto with zarith.
- generalize (BigZ.spec_compare (x1 * BigZ.Pos y2) 
-                               (x2 * BigZ.Pos y1))%bigZ; case BigZ.compare;
-   repeat rewrite BigZ.spec_mul; simpl; intros H; apply sym_equal; auto.
- rewrite H; rewrite Zcompare_refl; auto.
- Qed.
-
- Theorem spec_comparec: forall q1 q2, wf q1 -> wf q2 ->
-  compare q1 q2 = ([[q1]] ?= [[q2]]).
- unfold Qccompare, to_Qc. 
- intros q1 q2 Hq1 Hq2; rewrite spec_compare; simpl; auto.
- apply Qcompare_comp; apply Qeq_sym; apply Qred_correct.
- Qed.
-
- Definition norm n d: t :=
-  if BigZ.eq_bool n BigZ.zero then zero
-  else
-    let gcd := BigN.gcd (BigZ.to_N n) d in
-    if BigN.eq_bool gcd BigN.one then Qq n d
-    else	
-      let n := BigZ.div n (BigZ.Pos gcd) in
-      let d := BigN.div d gcd in
-      if BigN.eq_bool d BigN.one then Qz n
-      else Qq n d.
-
- Theorem wf_norm: forall n q,
-   (BigN.to_Z q <> 0)%Z -> wf (norm n q).
- intros p q; unfold norm, wf; intros Hq.
- assert (Hp := BigN.spec_pos (BigZ.to_N p)).
- match goal with  |- context[BigZ.eq_bool ?X ?Y] => 
-   generalize (BigZ.spec_eq_bool X Y); case BigZ.eq_bool
- end; auto; rewrite BigZ.spec_0; intros H1.
- simpl; auto.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto; rewrite BigN.spec_1.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto; rewrite BigN.spec_1.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto; rewrite BigN.spec_0.
- set (a := BigN.to_Z (BigZ.to_N p)).
- set (b := (BigN.to_Z q)).
- assert (F: (0 < Zgcd a b)%Z).
-   case (Zle_lt_or_eq _ _ (Zgcd_is_pos a b)); auto.
-   intros HH1; case Hq; apply (Zgcd_inv_0_r _ _ (sym_equal HH1)).
- rewrite BigN.spec_div; rewrite BigN.spec_gcd; auto; fold a; fold b.
- intros H; case Hq; fold b.
- rewrite (Zdivide_Zdiv_eq (Zgcd a b) b); auto.
- rewrite H; auto with zarith.
- assert (F1:= Zgcd_is_gcd a b); inversion F1; auto.
- Qed.
- 
- Theorem spec_norm: forall n q, 
-    ((0 < BigN.to_Z q)%Z -> [norm n q] == [Qq n q])%Q.
- intros p q; unfold norm; intros Hq.
- assert (Hp := BigN.spec_pos (BigZ.to_N p)).
- match goal with  |- context[BigZ.eq_bool ?X ?Y] => 
-   generalize (BigZ.spec_eq_bool X Y); case BigZ.eq_bool
- end; auto; rewrite BigZ.spec_0; intros H1.
-   red; simpl; rewrite H1; ring.
- case (Zle_lt_or_eq _ _ Hp); clear Hp; intros Hp.
- case (Zle_lt_or_eq _ _ 
-      (Zgcd_is_pos (BigN.to_Z (BigZ.to_N p)) (BigN.to_Z q))); intros H4.
- 2: generalize Hq; rewrite (Zgcd_inv_0_r _ _ (sym_equal H4)); auto with zarith.
- 2: red; simpl; auto with zarith.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto; rewrite BigN.spec_1; intros H2.
-   apply Qeq_refl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto; rewrite BigN.spec_1.
- red; simpl.
- rewrite BigZ.spec_div; simpl; rewrite BigN.spec_gcd; auto with zarith.
- rewrite BigN.spec_div; simpl; rewrite BigN.spec_gcd; auto with zarith.
- rewrite Zmult_1_r.
- rewrite Z2P_correct; auto with zarith.
- rewrite spec_to_N; intros; rewrite Zgcd_div_swap; auto.
- rewrite H; ring.
- intros H3.
- red; simpl.
- rewrite BigZ.spec_div; simpl; rewrite BigN.spec_gcd; auto with zarith.
- assert (F: (0 < BigN.to_Z (q / BigN.gcd (BigZ.to_N p) q)%bigN)%Z).
-   rewrite BigN.spec_div; auto with zarith.
-   rewrite BigN.spec_gcd.
-   apply Zgcd_div_pos; auto.
-   rewrite BigN.spec_gcd; auto.
- rewrite Z2P_correct; auto.
- rewrite Z2P_correct; auto.
- rewrite BigN.spec_div; simpl; rewrite BigN.spec_gcd; auto with zarith.
- rewrite spec_to_N; apply Zgcd_div_swap; auto.
- case H1; rewrite spec_to_N; rewrite <- Hp; ring.
- Qed.
-
- Theorem spec_normc: forall n q, 
-    (0 < BigN.to_Z q)%Z -> [[norm n q]] = [[Qq n q]].
- intros n q H; unfold to_Qc, Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete; apply spec_norm; auto.
- Qed.
-      
- Definition add (x y: t): t :=
-  match x, y with
-  | Qz zx, Qz zy => Qz (BigZ.add zx zy)
-  | Qz zx, Qq ny dy => Qq (BigZ.add (BigZ.mul zx (BigZ.Pos dy)) ny) dy
-  | Qq nx dx, Qz zy => Qq (BigZ.add nx (BigZ.mul zy (BigZ.Pos dx))) dx
-  | Qq nx dx, Qq ny dy => 
-    let n := BigZ.add (BigZ.mul nx (BigZ.Pos dy)) (BigZ.mul ny (BigZ.Pos dx)) in
-    let d := BigN.mul dx dy in
-    Qq n d
-  end.
-
- Theorem wf_add: forall x y, wf x -> wf y -> wf (add x y).
- intros [zx | nx dx] [zy | ny dy]; unfold add, wf; auto.
- repeat match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto; rewrite BigN.spec_0; rewrite BigN.spec_mul.
- intros H1 H2 H3.
- case (Zmult_integral _ _ H1); auto with zarith.
- Qed.
-
- Theorem spec_add x y: wf x -> wf y ->
-  ([add x y] == [x] + [y])%Q.
- intros [x | nx dx] [y | ny dy]; unfold Qplus; simpl.
- rewrite BigZ.spec_add; repeat rewrite Zmult_1_r; auto.
-  intros; apply Qeq_refl; auto.
- assert (F1:= BigN.spec_pos dy).
- rewrite Zmult_1_r.
- generalize (BigN.spec_eq_bool dy BigN.zero);
-   case BigN.eq_bool.
-   intros _ _ HH; case HH.
- rewrite BigN.spec_0; intros HH _ _.
- rewrite Z2P_correct; auto with zarith.
- rewrite BigZ.spec_add; rewrite BigZ.spec_mul.
- simpl; apply Qeq_refl.
- generalize (BigN.spec_eq_bool dx BigN.zero);
-   case BigN.eq_bool.
-   intros _ HH; case HH.
- rewrite BigN.spec_0; intros HH _ _.
- assert (F1:= BigN.spec_pos dx).
- rewrite Zmult_1_r; rewrite Pmult_1_r.
- simpl; rewrite Z2P_correct; auto with zarith.
- rewrite BigZ.spec_add; rewrite BigZ.spec_mul; simpl.
- apply Qeq_refl.
- generalize (BigN.spec_eq_bool dx BigN.zero);
-   case BigN.eq_bool.
-   intros _ HH; case HH.
- rewrite BigN.spec_0; intros HH1.
- generalize (BigN.spec_eq_bool dy BigN.zero);
-   case BigN.eq_bool.
-   intros _ _ HH; case HH.
- rewrite BigN.spec_0; intros HH2 _ _.
- assert (Fx: (0 < BigN.to_Z dx)%Z).
-   generalize (BigN.spec_pos dx); auto with zarith.
- assert (Fy: (0 < BigN.to_Z dy)%Z).
-   generalize (BigN.spec_pos dy); auto with zarith.
- rewrite BigZ.spec_add; repeat rewrite BigN.spec_mul.
- red; simpl.
- rewrite Zpos_mult_morphism.
- repeat rewrite Z2P_correct; auto.
- repeat rewrite BigZ.spec_mul; simpl; auto.
- apply Zmult_lt_0_compat; auto.
- Qed.
-
- Theorem spec_addc x y: wf x -> wf y ->
-  [[add x y]] = [[x]] + [[y]].
- intros x y H1 H2; unfold to_Qc.
- apply trans_equal with (!! ([x] + [y])).
- unfold Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete; apply spec_add; auto.
- unfold Qcplus, Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete.
- apply Qplus_comp; apply Qeq_sym; apply Qred_correct.
- Qed.
-
- Definition add_norm (x y: t): t := 
-  match x, y with
-  | Qz zx, Qz zy => Qz (BigZ.add zx zy)
-  | Qz zx, Qq ny dy => 
-    norm (BigZ.add (BigZ.mul zx (BigZ.Pos dy)) ny) dy 
-  | Qq nx dx, Qz zy =>
-    norm (BigZ.add (BigZ.mul zy (BigZ.Pos dx)) nx) dx
-  | Qq nx dx, Qq ny dy =>
-    let n := BigZ.add (BigZ.mul nx (BigZ.Pos dy)) (BigZ.mul ny (BigZ.Pos dx)) in
-    let d := BigN.mul dx dy in
-    norm n d 
-  end.
-
- Theorem wf_add_norm: forall x y, wf x -> wf y -> wf (add_norm x y).
- intros [zx | nx dx] [zy | ny dy]; unfold add_norm; auto.
- intros HH1 HH2; apply wf_norm.
- generalize HH2; simpl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto.
- intros HH1 HH2; apply wf_norm.
- generalize HH1; simpl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto.
- intros HH1 HH2; apply wf_norm.
- rewrite BigN.spec_mul; intros HH3.
- case (Zmult_integral _ _ HH3).
- generalize HH1; simpl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto.
- generalize HH2; simpl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto.
- Qed.
-
- Theorem spec_add_norm x y: wf x -> wf y ->
-  ([add_norm x y] == [x] + [y])%Q.
- intros x y H1 H2; rewrite <- spec_add; auto.
- generalize H1 H2; unfold add_norm, add, wf; case x; case y; clear H1 H2.
-  intros; apply Qeq_refl.
- intros p1 n p2 _.
- generalize (BigN.spec_eq_bool n BigN.zero);
-   case BigN.eq_bool.
-   intros _ HH; case HH.
- rewrite BigN.spec_0; intros HH _.
- match goal with |- [norm ?X ?Y] == _ =>
-  apply Qeq_trans with ([Qq X Y]);
-  [apply spec_norm | idtac]
- end.
- generalize (BigN.spec_pos n); auto with zarith.
- simpl.
- repeat rewrite BigZ.spec_add.
- repeat rewrite BigZ.spec_mul; simpl.
- apply Qeq_refl.
- intros p1 n p2.
- generalize (BigN.spec_eq_bool p2 BigN.zero);
-   case BigN.eq_bool.
-   intros _ HH; case HH.
- rewrite BigN.spec_0; intros HH _ _.
- match goal with |- [norm ?X ?Y] == _ =>
-  apply Qeq_trans with ([Qq X Y]);
-  [apply spec_norm | idtac]
- end.
- generalize (BigN.spec_pos p2); auto with zarith.
- simpl.
- repeat rewrite BigZ.spec_add.
- repeat rewrite BigZ.spec_mul; simpl.
- rewrite Zplus_comm.
- apply Qeq_refl.
- intros p1 q1 p2 q2.
- generalize (BigN.spec_eq_bool q2 BigN.zero);
-   case BigN.eq_bool.
-   intros _ HH; case HH.
- rewrite BigN.spec_0; intros HH1 _.
- generalize (BigN.spec_eq_bool q1 BigN.zero);
-   case BigN.eq_bool.
-   intros _ HH; case HH.
- rewrite BigN.spec_0; intros HH2 _.
- match goal with |- [norm ?X ?Y] == _ =>
-  apply Qeq_trans with ([Qq X Y]);
-  [apply spec_norm | idtac]
- end; try apply Qeq_refl.
- rewrite BigN.spec_mul.
- apply Zmult_lt_0_compat.
-  generalize (BigN.spec_pos q2); auto with zarith.
-  generalize (BigN.spec_pos q1); auto with zarith.
- Qed.
-
- Theorem spec_add_normc x y: wf x -> wf y ->
-  [[add_norm x y]] = [[x]] + [[y]].
- intros x y Hx Hy; unfold to_Qc.
- apply trans_equal with (!! ([x] + [y])).
- unfold Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete; apply spec_add_norm; auto.
- unfold Qcplus, Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete.
- apply Qplus_comp; apply Qeq_sym; apply Qred_correct.
- Qed.
-
- Definition sub x y := add x (opp y).
-
- Theorem wf_sub x y: wf x -> wf y -> wf (sub x y).
- intros x y Hx Hy; unfold sub; apply wf_add; auto.
- apply wf_opp; auto.
- Qed.
-
- Theorem spec_sub x y: wf x -> wf y ->
-  ([sub x y] == [x] - [y])%Q.
- intros x y Hx Hy; unfold sub; rewrite spec_add; auto.
- rewrite spec_opp; ring.
- apply wf_opp; auto.
- Qed.
-
- Theorem spec_subc x y: wf x -> wf y ->
-   [[sub x y]] = [[x]] - [[y]].
- intros x y Hx Hy; unfold sub; rewrite spec_addc; auto.
- rewrite spec_oppc; ring.
- apply wf_opp; auto.
- Qed.
-
- Definition sub_norm x y := add_norm x (opp y).
-
- Theorem wf_sub_norm x y: wf x -> wf y -> wf (sub_norm x y).
- intros x y Hx Hy; unfold sub_norm; apply wf_add_norm; auto.
- apply wf_opp; auto.
- Qed.
-
- Theorem spec_sub_norm x y: wf x -> wf y ->
-  ([sub_norm x y] == [x] - [y])%Q.
- intros x y Hx Hy; unfold sub_norm; rewrite spec_add_norm; auto.
- rewrite spec_opp; ring.
- apply wf_opp; auto.
- Qed.
-
- Theorem spec_sub_normc x y: wf x -> wf y ->
-   [[sub_norm x y]] = [[x]] - [[y]].
- intros x y Hx Hy; unfold sub_norm; rewrite spec_add_normc; auto.
- rewrite spec_oppc; ring.
- apply wf_opp; auto.
- Qed.
-
- Definition mul (x y: t): t :=
-  match x, y with
-  | Qz zx, Qz zy => Qz (BigZ.mul zx zy)
-  | Qz zx, Qq ny dy => Qq (BigZ.mul zx ny) dy
-  | Qq nx dx, Qz zy => Qq (BigZ.mul nx zy) dx
-  | Qq nx dx, Qq ny dy => 
-    Qq (BigZ.mul nx ny) (BigN.mul dx dy)
-  end.
-
- Theorem wf_mul: forall x y, wf x -> wf y -> wf (mul x y).
- intros [zx | nx dx] [zy | ny dy]; unfold mul, wf; auto.
- repeat match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto; rewrite BigN.spec_0; rewrite BigN.spec_mul.
- intros H1 H2 H3.
- case (Zmult_integral _ _ H1); auto with zarith.
- Qed.
-
- Theorem spec_mul x y: wf x -> wf y -> ([mul x y] == [x] * [y])%Q.
- intros [x | nx dx] [y | ny dy]; unfold Qmult; simpl.
- rewrite BigZ.spec_mul; repeat rewrite Zmult_1_r; auto.
-  intros; apply Qeq_refl; auto.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto.
- intros _ _ HH; case HH.
- rewrite BigN.spec_0; intros HH1 _ _.
- rewrite BigZ.spec_mul; apply Qeq_refl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto.
- intros _ HH; case HH.
- rewrite BigN.spec_0; intros HH1 _ _.
- rewrite BigZ.spec_mul; rewrite Pmult_1_r.
- apply Qeq_refl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto.
- intros _ HH; case HH.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto.
- intros _ _ _ HH; case HH.
- rewrite BigN.spec_0; intros H1 H2 _ _.
- rewrite BigZ.spec_mul; rewrite BigN.spec_mul.
- assert (tmp: 
-  (forall a b, 0 < a -> 0 < b -> Z2P (a * b) = (Z2P a * Z2P b)%positive)%Z).
-  intros [|a|a] [|b|b]; simpl; auto; intros; apply False_ind; auto with zarith.
- rewrite tmp; auto.
- apply Qeq_refl.
-  generalize (BigN.spec_pos dx); auto with zarith.
-  generalize (BigN.spec_pos dy); auto with zarith.
- Qed.
-
- Theorem spec_mulc x y: wf x -> wf y ->
-  [[mul x y]] = [[x]] * [[y]].
- intros x y Hx Hy; unfold to_Qc.
- apply trans_equal with (!! ([x] * [y])).
- unfold Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete; apply spec_mul; auto.
- unfold Qcmult, Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete.
- apply Qmult_comp; apply Qeq_sym; apply Qred_correct.
- Qed.
-
- Definition mul_norm (x y: t): t := 
-  match x, y with
-  | Qz zx, Qz zy => Qz (BigZ.mul zx zy)
-  | Qz zx, Qq ny dy =>
-    if BigZ.eq_bool zx BigZ.zero then zero
-    else	
-      let gcd := BigN.gcd (BigZ.to_N zx) dy in
-      if BigN.eq_bool gcd BigN.one then Qq (BigZ.mul zx ny) dy
-      else 
-        let zx := BigZ.div zx (BigZ.Pos gcd) in
-        let d := BigN.div dy gcd in
-        if BigN.eq_bool d BigN.one then Qz (BigZ.mul zx ny)
-        else Qq (BigZ.mul zx ny) d
-  | Qq nx dx, Qz zy =>   
-    if BigZ.eq_bool zy BigZ.zero then zero
-    else	
-      let gcd := BigN.gcd (BigZ.to_N zy) dx in
-      if BigN.eq_bool gcd BigN.one then Qq (BigZ.mul zy nx) dx
-      else 
-        let zy := BigZ.div zy (BigZ.Pos gcd) in
-        let d := BigN.div dx gcd in
-        if BigN.eq_bool d BigN.one then Qz (BigZ.mul zy nx)
-        else Qq (BigZ.mul zy nx) d
-  | Qq nx dx, Qq ny dy => norm (BigZ.mul nx ny) (BigN.mul dx dy)
-  end.
-
- Theorem wf_mul_norm: forall x y, wf x -> wf y -> wf (mul_norm x y).
- intros [zx | nx dx] [zy | ny dy]; unfold mul_norm; auto.
- intros HH1 HH2.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto;
- match goal with  |- context[BigZ.eq_bool ?X ?Y] => 
-   generalize (BigZ.spec_eq_bool X Y); case BigZ.eq_bool
- end; auto.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto.
- rewrite BigN.spec_1; rewrite BigZ.spec_0.
- intros H1 H2; unfold wf.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto.
- rewrite BigN.spec_0.
- set (a := BigN.to_Z (BigZ.to_N zx)).
- set (b := (BigN.to_Z dy)).
- assert (F: (0 < Zgcd a b)%Z).
-   case (Zle_lt_or_eq _ _ (Zgcd_is_pos a b)); auto.
-   intros HH3; case H2; rewrite spec_to_N; fold a.
-   rewrite (Zgcd_inv_0_l _ _ (sym_equal HH3)); try ring.
- rewrite BigN.spec_div; rewrite BigN.spec_gcd; fold a; fold b; auto.
- intros H.
- generalize HH2; simpl wf.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto.
- rewrite BigN.spec_0; intros HH; case HH; fold b.
- rewrite (Zdivide_Zdiv_eq (Zgcd a b) b); auto.
- rewrite H; auto with zarith.
- assert (F1:= Zgcd_is_gcd a b); inversion F1; auto.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto.
- rewrite BigN.spec_1; rewrite BigN.spec_gcd.
- intros HH1 H1 H2.
- match goal with  |- context[BigZ.eq_bool ?X ?Y] => 
-   generalize (BigZ.spec_eq_bool X Y); case BigZ.eq_bool
- end; auto.
- rewrite BigN.spec_1; rewrite BigN.spec_gcd.
- intros HH1 H1 H2.
- match goal with  |- context[BigZ.eq_bool ?X ?Y] => 
-   generalize (BigZ.spec_eq_bool X Y); case BigZ.eq_bool
- end; auto.
- rewrite BigZ.spec_0.
- intros HH2.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto.
- set (a := BigN.to_Z (BigZ.to_N zy)).
- set (b := (BigN.to_Z dx)).
- assert (F: (0 < Zgcd a b)%Z).
-   case (Zle_lt_or_eq _ _ (Zgcd_is_pos a b)); auto.
-   intros HH3; case HH2; rewrite spec_to_N; fold a.
-   rewrite (Zgcd_inv_0_l _ _ (sym_equal HH3)); try ring.
- rewrite BigN.spec_div; rewrite BigN.spec_gcd; fold a; fold b; auto.
- intros H; unfold wf.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto.
- rewrite BigN.spec_0.
- rewrite BigN.spec_div; rewrite BigN.spec_gcd; fold a; fold b; auto.
- intros HH; generalize H1; simpl wf.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto.
- rewrite BigN.spec_0.
- intros HH3; case HH3; fold b.
- rewrite (Zdivide_Zdiv_eq (Zgcd a b) b); auto.
- rewrite HH; auto with zarith.
- assert (F1:= Zgcd_is_gcd a b); inversion F1; auto.
- intros HH1 HH2; apply wf_norm.
- rewrite BigN.spec_mul; intros HH3.
- case (Zmult_integral _ _ HH3).
- generalize HH1; simpl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto.
- generalize HH2; simpl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto.
- Qed.
-
- Theorem spec_mul_norm x y: wf x -> wf y ->
-  ([mul_norm x y] == [x] * [y])%Q.
- intros x y Hx Hy; rewrite <- spec_mul; auto.
- unfold mul_norm, mul; generalize Hx Hy; case x; case y; clear Hx Hy.
-  intros; apply Qeq_refl.
- intros p1 n p2 Hx Hy.
- match goal with  |- context[BigZ.eq_bool ?X ?Y] => 
-   generalize (BigZ.spec_eq_bool X Y); case BigZ.eq_bool
- end; unfold zero, to_Q; repeat rewrite BigZ.spec_0; intros H.
- rewrite BigZ.spec_mul; rewrite H; red; auto.
- assert (F: (0 < BigN.to_Z (BigZ.to_N p2))%Z).
-  case (Zle_lt_or_eq _ _ (BigN.spec_pos (BigZ.to_N p2))); auto.
-  intros H1; case H; rewrite spec_to_N; rewrite <- H1; ring.
- assert (F1: (0 < BigN.to_Z n)%Z).
-  generalize Hy; simpl.
-  match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-    generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
-  end; auto.
-  intros _ HH; case HH.
-  rewrite BigN.spec_0; generalize (BigN.spec_pos n); auto with zarith.
- set (a := BigN.to_Z (BigZ.to_N p2)).
- set (b := BigN.to_Z n).
- assert (F2: (0 < Zgcd a b )%Z).
-   case (Zle_lt_or_eq _ _ (Zgcd_is_pos a b)); intros H3; auto.
-   generalize F; fold a; rewrite (Zgcd_inv_0_l _ _ (sym_equal H3)); auto with zarith.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_1; try rewrite BigN.spec_gcd; 
-  fold a b; intros H1.
-  intros; apply Qeq_refl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_1.
- rewrite BigN.spec_div; rewrite BigN.spec_gcd;
-   auto with zarith; fold a b; intros H2.
- red; simpl.
- repeat rewrite BigZ.spec_mul.
- rewrite BigZ.spec_div; simpl; rewrite BigN.spec_gcd; 
-   fold a b; auto with zarith.
- rewrite Z2P_correct; auto with zarith.
- rewrite spec_to_N; fold a; fold b.
- rewrite Zmult_1_r; repeat rewrite <- Zmult_assoc.
- rewrite (Zmult_comm (BigZ.to_Z p1)).
- repeat rewrite Zmult_assoc.
- rewrite Zgcd_div_swap; auto with zarith.
- rewrite H2; ring.
- repeat rewrite BigZ.spec_mul.
- rewrite BigZ.spec_div; simpl; rewrite BigN.spec_gcd; 
-   fold a b; auto with zarith.
- rewrite BigN.spec_div; simpl; rewrite BigN.spec_gcd; 
-   fold a b; auto with zarith.
- intros H2; red; simpl.
- repeat rewrite BigZ.spec_mul.
- rewrite Z2P_correct; auto with zarith.
- rewrite (spec_to_N p2); fold a b.
- rewrite Z2P_correct; auto with zarith.
- repeat rewrite <- Zmult_assoc.
- rewrite (Zmult_comm (BigZ.to_Z p1)).
- repeat rewrite Zmult_assoc.
- rewrite Zgcd_div_swap; auto; try ring.
- case (Zle_lt_or_eq _ _
-       (BigN.spec_pos  (n / 
-                         BigN.gcd (BigZ.to_N p2) 
-                                  n))%bigN);
- rewrite BigN.spec_div; simpl; rewrite BigN.spec_gcd; 
-   fold a b; auto with zarith.
- intros H3.
- apply False_ind; generalize F1.
- generalize Hy; simpl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; auto with zarith.
- intros HH; case HH; fold b.
- rewrite (Zdivide_Zdiv_eq (Zgcd a b) b); auto.
- rewrite <- H3; ring.
- assert (FF:= Zgcd_is_gcd a b); inversion FF; auto.
- intros p1 p2 n Hx Hy.
- match goal with  |- context[BigZ.eq_bool ?X ?Y] => 
-   generalize (BigZ.spec_eq_bool X Y); case BigZ.eq_bool
- end; unfold zero, to_Q; repeat rewrite BigZ.spec_0; intros H.
- rewrite BigZ.spec_mul; rewrite H; red; simpl; ring.
- set (a := BigN.to_Z (BigZ.to_N p1)).
- set (b := BigN.to_Z n).
- assert (F: (0 < a)%Z).
-  case (Zle_lt_or_eq _ _ (BigN.spec_pos (BigZ.to_N p1))); auto.
-  intros H1; case H; rewrite spec_to_N; rewrite <- H1; ring.
- assert (F1: (0 < b)%Z).
-  generalize Hx; unfold wf.
-  match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-    generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
-  end; rewrite BigN.spec_0; auto with zarith.
-  generalize (BigN.spec_pos n); fold b; auto with zarith.
- assert (F2: (0 < Zgcd a b)%Z).
-   case (Zle_lt_or_eq _ _ (Zgcd_is_pos a b)); intros H3; auto.
-   generalize F; rewrite (Zgcd_inv_0_l _ _ (sym_equal H3)); auto with zarith.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_1; rewrite BigN.spec_gcd; fold a b; intros H1.
-  intros; repeat rewrite BigZ.spec_mul; rewrite Zmult_comm; apply Qeq_refl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_1.
- rewrite BigN.spec_div; rewrite BigN.spec_gcd;
-   auto with zarith.
- fold a b; intros H2.
- red; simpl.
- repeat rewrite BigZ.spec_mul.
- rewrite BigZ.spec_div; simpl; rewrite BigN.spec_gcd;
-   fold a b; auto with zarith.
- rewrite Z2P_correct; auto with zarith.
- rewrite spec_to_N; fold a b.
- rewrite Zmult_1_r; repeat rewrite <- Zmult_assoc.
- rewrite (Zmult_comm (BigZ.to_Z p2)).
- repeat rewrite Zmult_assoc.
- rewrite Zgcd_div_swap; auto with zarith.
- rewrite H2; ring.
- intros H2.
- red; simpl.
- repeat rewrite BigZ.spec_mul.
- rewrite BigZ.spec_div; simpl; rewrite BigN.spec_gcd; 
-   fold a b; auto with zarith.
- rewrite Z2P_correct; auto with zarith.
- rewrite (spec_to_N p1); fold a b.
- case (Zle_lt_or_eq _ _
-       (BigN.spec_pos  (n / BigN.gcd (BigZ.to_N p1) n))%bigN); intros F3.
- rewrite Z2P_correct; auto with zarith.
- rewrite BigN.spec_div; simpl; rewrite BigN.spec_gcd; 
-   fold a b; auto with zarith.
- repeat rewrite <- Zmult_assoc.
- rewrite (Zmult_comm (BigZ.to_Z p2)).
- repeat rewrite Zmult_assoc.
- rewrite Zgcd_div_swap; auto; try ring.
- apply False_ind; generalize F1.
- rewrite (Zdivide_Zdiv_eq (Zgcd a b) b); auto.
- generalize F3; rewrite BigN.spec_div; rewrite BigN.spec_gcd; fold a b;
-   auto with zarith.
- intros HH; rewrite <- HH; auto with zarith.
- assert (FF:= Zgcd_is_gcd a b); inversion FF; auto.
- intros p1 n1 p2 n2 Hn1 Hn2.
- match goal with |- [norm ?X ?Y] == _ =>
-  apply Qeq_trans with ([Qq X Y]);
-  [apply spec_norm | idtac]
- end; try  apply Qeq_refl.
- rewrite BigN.spec_mul.
- apply Zmult_lt_0_compat.
- generalize Hn1; simpl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; auto with zarith.
- generalize (BigN.spec_pos n1) (BigN.spec_pos n2); auto with zarith.
- generalize Hn2; simpl.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; auto with zarith.
- generalize (BigN.spec_pos n1) (BigN.spec_pos n2); auto with zarith.
- Qed.
-
- Theorem spec_mul_normc x y: wf x -> wf y ->
-   [[mul_norm x y]] = [[x]] * [[y]].
- intros x y Hx Hy; unfold to_Qc.
- apply trans_equal with (!! ([x] * [y])).
- unfold Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete; apply spec_mul_norm; auto.
- unfold Qcmult, Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete.
- apply Qmult_comp; apply Qeq_sym; apply Qred_correct.
- Qed.
-
- Definition inv (x: t): t := 
-  match x with
-  | Qz (BigZ.Pos n) => 
-    if BigN.eq_bool n BigN.zero then zero else Qq BigZ.one n
-  | Qz (BigZ.Neg n) => 
-    if BigN.eq_bool n BigN.zero then zero else Qq BigZ.minus_one n
-  | Qq (BigZ.Pos n) d => 
-    if BigN.eq_bool n BigN.zero then zero else Qq (BigZ.Pos d) n
-  | Qq (BigZ.Neg n) d => 
-    if BigN.eq_bool n BigN.zero then zero else Qq (BigZ.Neg d) n
-  end.
-
-
- Theorem wf_inv: forall x, wf x -> wf (inv x).
- intros [ zx | nx dx]; unfold inv, wf; auto.
- case zx; clear zx.
- intros nx.
- repeat match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto; rewrite BigN.spec_0; rewrite BigN.spec_mul.
- intros nx.
- repeat match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto; rewrite BigN.spec_0; rewrite BigN.spec_mul.
- repeat match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto; rewrite BigN.spec_0.
- intros _ HH; case HH.
- intros H1 _.
- case nx; clear nx.
- intros nx.
- repeat match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; simpl; auto.
- intros nx.
- repeat match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; simpl; auto.
- Qed.
-
- Theorem spec_inv x: wf x ->
-   ([inv x] == /[x])%Q.
- intros [ [x | x] _ | [nx | nx] dx]; unfold inv.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H.
-  unfold zero, to_Q; rewrite BigZ.spec_0.
- unfold BigZ.to_Z; rewrite H; apply Qeq_refl.
- assert (F: (0 < BigN.to_Z x)%Z).
-   case (Zle_lt_or_eq _ _ (BigN.spec_pos x)); auto with zarith.
- unfold to_Q; rewrite BigZ.spec_1.
- red; unfold Qinv; simpl.
- generalize F; case BigN.to_Z; auto with zarith.
- intros p Hp; discriminate Hp.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H.
-  unfold zero, to_Q; rewrite BigZ.spec_0.
- unfold BigZ.to_Z; rewrite H; apply Qeq_refl.
- assert (F: (0 < BigN.to_Z x)%Z).
-   case (Zle_lt_or_eq _ _ (BigN.spec_pos x)); auto with zarith.
- red; unfold Qinv; simpl.
- generalize F; case BigN.to_Z; simpl; auto with zarith.
- intros p Hp; discriminate Hp.
- simpl wf.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H1.
- intros HH; case HH.
- intros _.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H.
-  unfold zero, to_Q; rewrite BigZ.spec_0.
- unfold BigZ.to_Z; rewrite H; apply Qeq_refl.
- assert (F: (0 < BigN.to_Z nx)%Z).
-   case (Zle_lt_or_eq _ _ (BigN.spec_pos nx)); auto with zarith.
- red; unfold Qinv; simpl.
- rewrite Z2P_correct; auto with zarith.
- generalize F; case BigN.to_Z; auto with zarith.
- intros p Hp; discriminate Hp.
- generalize (BigN.spec_pos dx); auto with zarith.
- simpl wf.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H1.
- intros HH; case HH.
- intros _.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; rewrite BigN.spec_0; intros H.
-  unfold zero, to_Q; rewrite BigZ.spec_0.
- unfold BigZ.to_Z; rewrite H; apply Qeq_refl.
- assert (F: (0 < BigN.to_Z nx)%Z).
-   case (Zle_lt_or_eq _ _ (BigN.spec_pos nx)); auto with zarith.
- red; unfold Qinv; simpl.
- rewrite Z2P_correct; auto with zarith.
- generalize F; case BigN.to_Z; auto with zarith.
- simpl; intros. 
- match goal with  |- (?X = Zneg ?Y)%Z => 
-   replace (Zneg Y) with (Zopp (Zpos Y));
-   try rewrite Z2P_correct; auto with zarith
- end.
- rewrite Zpos_mult_morphism; 
-   rewrite Z2P_correct; auto with zarith; try ring.
- generalize (BigN.spec_pos dx); auto with zarith.
- intros p Hp; discriminate Hp.
- generalize (BigN.spec_pos dx); auto with zarith.
- Qed.
-
- Theorem spec_invc x: wf x ->
-   [[inv x]] =  /[[x]].
- intros x Hx; unfold to_Qc.
- apply trans_equal with (!! (/[x])).
- unfold Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete; apply spec_inv; auto.
- unfold Qcinv, Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete.
- apply Qinv_comp; apply Qeq_sym; apply Qred_correct.
- Qed.
-
-
- Definition div x y := mul x (inv y).
-
- Theorem wf_div x y: wf x -> wf y -> wf (div x y).
- intros x y Hx Hy; unfold div; apply wf_mul; auto.
- apply wf_inv; auto.
- Qed.
-
- Theorem spec_div x y: wf x -> wf y ->
-  ([div x y] == [x] / [y])%Q.
- intros x y Hx Hy; unfold div; rewrite spec_mul; auto.
- unfold Qdiv; apply Qmult_comp.
- apply Qeq_refl.
- apply spec_inv; auto.
- apply wf_inv; auto.
- Qed.
-
- Theorem spec_divc x y: wf x -> wf y ->
-   [[div x y]] = [[x]] / [[y]].
- intros x y Hx Hy; unfold div; rewrite spec_mulc; auto.
- unfold Qcdiv; apply f_equal2 with (f := Qcmult); auto.
- apply spec_invc; auto. 
- apply wf_inv; auto.
- Qed.
-
- Definition div_norm x y := mul_norm x (inv y).
-
- Theorem wf_div_norm x y: wf x -> wf y -> wf (div_norm x y).
- intros x y Hx Hy; unfold div_norm; apply wf_mul_norm; auto.
- apply wf_inv; auto.
- Qed.
-
- Theorem spec_div_norm x y: wf x -> wf y ->
-  ([div_norm x y] == [x] / [y])%Q.
- intros x y Hx Hy; unfold div_norm; rewrite spec_mul_norm; auto.
- unfold Qdiv; apply Qmult_comp.
- apply Qeq_refl.
- apply spec_inv; auto.
- apply wf_inv; auto.
- Qed.
-
- Theorem spec_div_normc x y: wf x -> wf y ->
-   [[div_norm x y]] = [[x]] / [[y]].
- intros x y Hx Hy; unfold div_norm; rewrite spec_mul_normc; auto.
- unfold Qcdiv; apply f_equal2 with (f := Qcmult); auto.
- apply spec_invc; auto.
- apply wf_inv; auto.
- Qed.
-
- Definition square (x: t): t :=
-  match x with
-  | Qz zx => Qz (BigZ.square zx)
-  | Qq nx dx => Qq (BigZ.square nx) (BigN.square dx)
-  end.
-
- Theorem wf_square: forall x, wf x -> wf (square x).
- intros [ zx | nx dx]; unfold square, wf; auto.
- repeat match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto; rewrite BigN.spec_0.
- rewrite BigN.spec_square; intros H1 H2; case H2.
- case (Zmult_integral _ _ H1); auto.
- Qed.
-
- Theorem spec_square x: wf x -> ([square x] == [x] ^ 2)%Q.
- intros [ x | nx dx]; unfold square.
- intros _.
- red; simpl; rewrite BigZ.spec_square; auto with zarith.
- unfold wf.
- repeat match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto; rewrite BigN.spec_0.
- intros _ HH; case HH.
- intros H1 _.
- red; simpl; rewrite BigZ.spec_square; auto with zarith.
- assert (F: (0 < BigN.to_Z dx)%Z).
-   case (Zle_lt_or_eq _ _ (BigN.spec_pos dx)); auto with zarith.
- assert (F1 : (0 < BigN.to_Z (BigN.square dx))%Z).
-   rewrite BigN.spec_square; apply Zmult_lt_0_compat;
-     auto with zarith.
- rewrite Zpos_mult_morphism.
- repeat rewrite Z2P_correct; auto with zarith.
- rewrite BigN.spec_square; auto with zarith.
- Qed.
-
- Theorem spec_squarec x: wf x -> [[square x]] =  [[x]]^2.
- intros x Hx; unfold to_Qc.
- apply trans_equal with (!! ([x]^2)).
- unfold Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete; apply spec_square; auto.
- simpl Qcpower.
- replace (!! [x] * 1) with (!![x]); try ring.
- simpl.
- unfold Qcmult, Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete.
- apply Qmult_comp; apply Qeq_sym; apply Qred_correct.
- Qed.
-
-
- Definition power_pos (x: t) p: t :=
-  match x with
-  | Qz zx => Qz (BigZ.power_pos zx p)
-  | Qq nx dx => Qq (BigZ.power_pos nx p) (BigN.power_pos dx p)
-  end.
-
- Theorem wf_power_pos: forall x p, wf x -> wf (power_pos x p).
- intros [ zx | nx dx] p; unfold power_pos, wf; auto.
- repeat match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto; rewrite BigN.spec_0.
- rewrite BigN.spec_power_pos; simpl.
- intros H1 H2 _.
- case (Zle_lt_or_eq _ _ (BigN.spec_pos dx)); auto with zarith.
- intros H3; generalize (Zpower_pos_pos _ p H3); auto with zarith.
- Qed.
-
- Theorem spec_power_pos x p: wf x -> ([power_pos x p] == [x] ^ Zpos p)%Q.
- Proof.
- intros [x | nx dx] p; unfold power_pos.
-   intros _; unfold power_pos; red; simpl.
-   generalize (Qpower_decomp p (BigZ.to_Z x) 1).
-   unfold Qeq; simpl.
-   rewrite Zpower_pos_1_l; simpl Z2P.
-   rewrite Zmult_1_r.
-   intros H; rewrite H.
-   rewrite BigZ.spec_power_pos; simpl; ring.
- unfold wf.
- match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
- end; auto; rewrite BigN.spec_0.
- intros _ HH; case HH.
- intros H1 _.
- assert (F1: (0 < BigN.to_Z dx)%Z).
-     generalize (BigN.spec_pos dx); auto with zarith.
- assert (F2: (0 < BigN.to_Z dx  ^ ' p)%Z).
-  unfold Zpower; apply Zpower_pos_pos; auto.
- unfold power_pos; red; simpl.
- rewrite Z2P_correct; rewrite BigN.spec_power_pos; auto.
- generalize (Qpower_decomp p (BigZ.to_Z nx) 
-               (Z2P (BigN.to_Z dx))).
- unfold Qeq; simpl.
- repeat rewrite Z2P_correct; auto.
- unfold Qeq; simpl; intros HH.
- rewrite HH.
- rewrite BigZ.spec_power_pos; simpl; ring.
- Qed.
-
- Theorem spec_power_posc x p: wf x ->
-   [[power_pos x p]] = [[x]] ^ nat_of_P p.
- intros x p Hx; unfold to_Qc.
- apply trans_equal with (!! ([x]^Zpos p)).
- unfold Q2Qc.
- apply Qc_decomp; intros _ _; unfold this.
- apply Qred_complete; apply spec_power_pos; auto.
- pattern p; apply Pind; clear p.
- simpl; ring.
- intros p Hrec.
- rewrite nat_of_P_succ_morphism; simpl Qcpower.
- rewrite <- Hrec.
- unfold Qcmult, Q2Qc.
- apply Qc_decomp; intros _ _;
- unfold this.
- apply Qred_complete.
- assert (F: [x] ^ ' Psucc p == [x] *   [x] ^ ' p).
-  simpl; generalize Hx; case x; simpl; clear x Hx Hrec.
-  intros x _; simpl; repeat rewrite Qpower_decomp; simpl.
-  red; simpl; repeat rewrite Zpower_pos_1_l; simpl Z2P.
-  rewrite Pplus_one_succ_l.
-  rewrite Zpower_pos_is_exp.
-  rewrite Zpower_pos_1_r; auto.
-  intros nx dx.
-  match goal with  |- context[BigN.eq_bool ?X ?Y] => 
-   generalize (BigN.spec_eq_bool X Y); case BigN.eq_bool
-  end; auto; rewrite BigN.spec_0.
-  intros _ HH; case HH.
-  intros H1 _.
-  assert (F1: (0 < BigN.to_Z dx)%Z).
-     generalize (BigN.spec_pos dx); auto with zarith.
-  simpl; repeat rewrite Qpower_decomp; simpl.
-  red; simpl; repeat rewrite Zpower_pos_1_l; simpl Z2P.
-  rewrite Pplus_one_succ_l.
-  rewrite Zpower_pos_is_exp.
-  rewrite Zpower_pos_1_r; auto.
-  repeat rewrite Zpos_mult_morphism.
-  repeat rewrite Z2P_correct; auto.
-  2: apply Zpower_pos_pos; auto.
-  2: apply Zpower_pos_pos; auto.
-  rewrite Zpower_pos_is_exp.
-  rewrite Zpower_pos_1_r; auto.
- rewrite F.
- apply Qmult_comp; apply Qeq_sym; apply Qred_correct.
- Qed.
-
-End Qv.
-
diff --git a/theories/Numbers/Rational/SpecViaQ/QSig.v b/theories/Numbers/Rational/SpecViaQ/QSig.v
index 6840eae25..7c88d25aa 100644
--- a/theories/Numbers/Rational/SpecViaQ/QSig.v
+++ b/theories/Numbers/Rational/SpecViaQ/QSig.v
@@ -40,14 +40,24 @@ Module Type QType.
 
  Parameter compare : t -> t -> comparison.
 
- Parameter spec_compare: forall x y, compare x y = ([x] ?= [y]).
+ Parameter spec_compare : forall x y, compare x y = ([x] ?= [y]).
 
  Definition lt n m := compare n m = Lt.
  Definition le n m := compare n m <> Gt.
  Definition min n m := match compare n m with Gt => m | _ => n end.
  Definition max n m := match compare n m with Lt => m | _ => n end.
 
- Parameter add  : t -> t -> t.
+ Parameter eq_bool : t -> t -> bool.
+ 
+ Parameter spec_eq_bool : forall x y, 
+  if eq_bool x y then [x]==[y] else ~([x]==[y]).
+
+ Parameter red : t -> t.
+ 
+ Parameter spec_red : forall x, [red x] == [x].
+ Parameter strong_spec_red : forall x, [red x] = Qred [x].
+
+ Parameter add : t -> t -> t.
 
  Parameter spec_add: forall x y, [add x y] == [x] + [y].
 
@@ -75,10 +85,13 @@ Module Type QType.
 
  Parameter spec_div: forall x y, [div x y] == [x] / [y].
 
- Parameter power_pos : t -> positive -> t.
+ Parameter power : t -> Z -> t.
 
- Parameter spec_power_pos: forall x n, [power_pos x n] == [x] ^ Zpos n.
+ Parameter spec_power: forall x z, [power x z] == [x] ^ z.
 
 End QType.
 
-(* TODO: add norm function and variants, add eq_bool, what about Qc ? *)
\ No newline at end of file
+(** NB: several of the above functions come with [..._norm] variants
+     that expect reduced arguments and return reduced results. *)
+
+(** TODO : also speak of specifications via Qcanon ... *)