Built with Alectryon, running Coq+SerAPI v8.10.0+0.7.0. Coq sources are in this panel; goals and messages will appear in the other. Bubbles () indicate interactive fragments: hover for details, tap to reveal contents. Use Ctrl+↑ Ctrl+↓ to navigate, Ctrl+🖱️ to focus.

This file is part of the Flocq formalization of floating-point arithmetic in Coq: http://flocq.gforge.inria.fr/

This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the COPYING file for more details.

Missing definitions/lemmas

Require Import Psatz.
Require Export Reals ZArith.
Require Export Zaux.

Section Rmissing.

About R

Theorem Rle_0_minus :
  forall x y, (x <= y)%R -> (0 <= y - x)%R.forall x y : R, (x <= y)%R -> (0 <= y - x)%R
Proof.forall x y : R, (x <= y)%R -> (0 <= y - x)%R
intros.x, y:R
H:(x <= y)%R
(0 <= y - x)%R
apply Rge_le.x, y:R
H:(x <= y)%R
(y - x >= 0)%R
apply Rge_minus.x, y:R
H:(x <= y)%R
(y >= x)%R
now apply Rle_ge.
Qed.

Theorem Rabs_eq_Rabs :
  forall x y : R,
  Rabs x = Rabs y -> x = y \/ x = Ropp y.forall x y : R,
Rabs x = Rabs y -> x = y \/ x = (- y)%R
Proof.forall x y : R,
Rabs x = Rabs y -> x = y \/ x = (- y)%R
intros x y H.x, y:R
H:Rabs x = Rabs y
x = y \/ x = (- y)%R
unfold Rabs in H.x, y:R
H:(if Rcase_abs x then (- x)%R else x) =
(if Rcase_abs y then (- y)%R else y)
x = y \/ x = (- y)%R
destruct (Rcase_abs x) as [_|_].x, y:R
H:(- x)%R = (if Rcase_abs y then (- y)%R else y)
x = y \/ x = (- y)%R
x, y:R
H:x = (if Rcase_abs y then (- y)%R else y)
x = y \/ x = (- y)%R
assert (H' := f_equal Ropp H).x, y:R
H:(- x)%R = (if Rcase_abs y then (- y)%R else y)
H':(- - x)%R =
(- (if Rcase_abs y then - y else y))%R
x = y \/ x = (- y)%R
x, y:R
H:x = (if Rcase_abs y then (- y)%R else y)
x = y \/ x = (- y)%R
rewrite Ropp_involutive in H'.x, y:R
H:(- x)%R = (if Rcase_abs y then (- y)%R else y)
H':x = (- (if Rcase_abs y then - y else y))%R
x = y \/ x = (- y)%R
x, y:R
H:x = (if Rcase_abs y then (- y)%R else y)
x = y \/ x = (- y)%R
rewrite H'.x, y:R
H:(- x)%R = (if Rcase_abs y then (- y)%R else y)
H':x = (- (if Rcase_abs y then - y else y))%R
(- (if Rcase_abs y then - y else y))%R = y \/
(- (if Rcase_abs y then - y else y))%R = (- y)%R
x, y:R
H:x = (if Rcase_abs y then (- y)%R else y)
x = y \/ x = (- y)%R
destruct (Rcase_abs y) as [_|_].x, y:R
H:(- x)%R = (- y)%R
H':x = (- - y)%R
(- - y)%R = y \/ (- - y)%R = (- y)%R
x, y:R
H:(- x)%R = y
H':x = (- y)%R
(- y)%R = y \/ (- y)%R = (- y)%R
x, y:R
H:x = (if Rcase_abs y then (- y)%R else y)
x = y \/ x = (- y)%R
left.x, y:R
H:(- x)%R = (- y)%R
H':x = (- - y)%R
(- - y)%R = y
x, y:R
H:(- x)%R = y
H':x = (- y)%R
(- y)%R = y \/ (- y)%R = (- y)%R
x, y:R
H:x = (if Rcase_abs y then (- y)%R else y)
x = y \/ x = (- y)%R
apply Ropp_involutive.x, y:R
H:(- x)%R = y
H':x = (- y)%R
(- y)%R = y \/ (- y)%R = (- y)%R
x, y:R
H:x = (if Rcase_abs y then (- y)%R else y)
x = y \/ x = (- y)%R
now right.x, y:R
H:x = (if Rcase_abs y then (- y)%R else y)
x = y \/ x = (- y)%R
rewrite H.x, y:R
H:x = (if Rcase_abs y then (- y)%R else y)
(if Rcase_abs y then (- y)%R else y) = y \/
(if Rcase_abs y then (- y)%R else y) = (- y)%R
now destruct (Rcase_abs y) as [_|_] ; [right|left].
Qed.

Theorem Rabs_minus_le:
  forall x y : R,
  (0 <= y)%R -> (y <= 2*x)%R ->
  (Rabs (x-y) <= x)%R.forall x y : R,
(0 <= y)%R -> (y <= 2 * x)%R -> (Rabs (x - y) <= x)%R
Proof.forall x y : R,
(0 <= y)%R -> (y <= 2 * x)%R -> (Rabs (x - y) <= x)%R
intros x y Hx Hy.x, y:R
Hx:(0 <= y)%R
Hy:(y <= 2 * x)%R
(Rabs (x - y) <= x)%R
apply Rabs_le.x, y:R
Hx:(0 <= y)%R
Hy:(y <= 2 * x)%R
(- x <= x - y <= x)%R
lra.
Qed.

Theorem Rabs_eq_R0 x : (Rabs x = 0 -> x = 0)%R.x:R
Rabs x = 0%R -> x = 0%R
Proof.x:R
Rabs x = 0%R -> x = 0%R split_Rabs; lra. Qed.

Theorem Rplus_eq_reg_r :
  forall r r1 r2 : R,
  (r1 + r = r2 + r)%R -> (r1 = r2)%R.forall r r1 r2 : R, (r1 + r)%R = (r2 + r)%R -> r1 = r2
Proof.forall r r1 r2 : R, (r1 + r)%R = (r2 + r)%R -> r1 = r2
intros r r1 r2 H.r, r1, r2:R
H:(r1 + r)%R = (r2 + r)%R
r1 = r2
apply Rplus_eq_reg_l with r.r, r1, r2:R
H:(r1 + r)%R = (r2 + r)%R
(r + r1)%R = (r + r2)%R
now rewrite 2!(Rplus_comm r).
Qed.

Theorem Rmult_lt_compat :
  forall r1 r2 r3 r4,
  (0 <= r1)%R -> (0 <= r3)%R -> (r1 < r2)%R -> (r3 < r4)%R ->
  (r1 * r3 < r2 * r4)%R.forall r1 r2 r3 r4 : R,
(0 <= r1)%R ->
(0 <= r3)%R ->
(r1 < r2)%R -> (r3 < r4)%R -> (r1 * r3 < r2 * r4)%R
Proof.forall r1 r2 r3 r4 : R,
(0 <= r1)%R ->
(0 <= r3)%R ->
(r1 < r2)%R -> (r3 < r4)%R -> (r1 * r3 < r2 * r4)%R
intros r1 r2 r3 r4 Pr1 Pr3 H12 H34.r1, r2, r3, r4:R
Pr1:(0 <= r1)%R
Pr3:(0 <= r3)%R
H12:(r1 < r2)%R
H34:(r3 < r4)%R
(r1 * r3 < r2 * r4)%R
apply Rle_lt_trans with (r1 * r4)%R.r1, r2, r3, r4:R
Pr1:(0 <= r1)%R
Pr3:(0 <= r3)%R
H12:(r1 < r2)%R
H34:(r3 < r4)%R
(r1 * r3 <= r1 * r4)%R
r1, r2, r3, r4:R
Pr1:(0 <= r1)%R
Pr3:(0 <= r3)%R
H12:(r1 < r2)%R
H34:(r3 < r4)%R
(r1 * r4 < r2 * r4)%R
-r1, r2, r3, r4:R
Pr1:(0 <= r1)%R
Pr3:(0 <= r3)%R
H12:(r1 < r2)%R
H34:(r3 < r4)%R
(r1 * r3 <= r1 * r4)%R apply Rmult_le_compat_l.r1, r2, r3, r4:R
Pr1:(0 <= r1)%R
Pr3:(0 <= r3)%R
H12:(r1 < r2)%R
H34:(r3 < r4)%R
(0 <= r1)%R
r1, r2, r3, r4:R
Pr1:(0 <= r1)%R
Pr3:(0 <= r3)%R
H12:(r1 < r2)%R
H34:(r3 < r4)%R
(r3 <= r4)%R
  +r1, r2, r3, r4:R
Pr1:(0 <= r1)%R
Pr3:(0 <= r3)%R
H12:(r1 < r2)%R
H34:(r3 < r4)%R
(0 <= r1)%R exact Pr1.
  +r1, r2, r3, r4:R
Pr1:(0 <= r1)%R
Pr3:(0 <= r3)%R
H12:(r1 < r2)%R
H34:(r3 < r4)%R
(r3 <= r4)%R now apply Rlt_le.
-r1, r2, r3, r4:R
Pr1:(0 <= r1)%R
Pr3:(0 <= r3)%R
H12:(r1 < r2)%R
H34:(r3 < r4)%R
(r1 * r4 < r2 * r4)%R apply Rmult_lt_compat_r.r1, r2, r3, r4:R
Pr1:(0 <= r1)%R
Pr3:(0 <= r3)%R
H12:(r1 < r2)%R
H34:(r3 < r4)%R
(0 < r4)%R
r1, r2, r3, r4:R
Pr1:(0 <= r1)%R
Pr3:(0 <= r3)%R
H12:(r1 < r2)%R
H34:(r3 < r4)%R
(r1 < r2)%R
  +r1, r2, r3, r4:R
Pr1:(0 <= r1)%R
Pr3:(0 <= r3)%R
H12:(r1 < r2)%R
H34:(r3 < r4)%R
(0 < r4)%R now apply Rle_lt_trans with r3.
  +r1, r2, r3, r4:R
Pr1:(0 <= r1)%R
Pr3:(0 <= r3)%R
H12:(r1 < r2)%R
H34:(r3 < r4)%R
(r1 < r2)%R exact H12.
Qed.

Theorem Rmult_minus_distr_r :
  forall r r1 r2 : R,
  ((r1 - r2) * r = r1 * r - r2 * r)%R.forall r r1 r2 : R,
((r1 - r2) * r)%R = (r1 * r - r2 * r)%R
Proof.forall r r1 r2 : R,
((r1 - r2) * r)%R = (r1 * r - r2 * r)%R
intros r r1 r2.r, r1, r2:R
((r1 - r2) * r)%R = (r1 * r - r2 * r)%R
rewrite <- 3!(Rmult_comm r).r, r1, r2:R
(r * (r1 - r2))%R = (r * r1 - r * r2)%R
apply Rmult_minus_distr_l.
Qed.

Lemma Rmult_neq_reg_r :
  forall r1 r2 r3 : R, (r2 * r1 <> r3 * r1)%R -> r2 <> r3.forall r1 r2 r3 : R,
(r2 * r1)%R <> (r3 * r1)%R -> r2 <> r3
Proof.forall r1 r2 r3 : R,
(r2 * r1)%R <> (r3 * r1)%R -> r2 <> r3
intros r1 r2 r3 H1 H2.r1, r2, r3:R
H1:(r2 * r1)%R <> (r3 * r1)%R
H2:r2 = r3
False
apply H1; rewrite H2; ring.
Qed.

Lemma Rmult_neq_compat_r :
  forall r1 r2 r3 : R,
  (r1 <> 0)%R -> (r2 <> r3)%R ->
  (r2 * r1 <> r3 * r1)%R.forall r1 r2 r3 : R,
r1 <> 0%R -> r2 <> r3 -> (r2 * r1)%R <> (r3 * r1)%R
Proof.forall r1 r2 r3 : R,
r1 <> 0%R -> r2 <> r3 -> (r2 * r1)%R <> (r3 * r1)%R
intros r1 r2 r3 H H1 H2.r1, r2, r3:R
H:r1 <> 0%R
H1:r2 <> r3
H2:(r2 * r1)%R = (r3 * r1)%R
False
now apply H1, Rmult_eq_reg_r with r1.
Qed.


Theorem Rmult_min_distr_r :
  forall r r1 r2 : R,
  (0 <= r)%R ->
  (Rmin r1 r2 * r)%R = Rmin (r1 * r) (r2 * r).forall r r1 r2 : R,
(0 <= r)%R ->
(Rmin r1 r2 * r)%R = Rmin (r1 * r) (r2 * r)
Proof.forall r r1 r2 : R,
(0 <= r)%R ->
(Rmin r1 r2 * r)%R = Rmin (r1 * r) (r2 * r)
intros r r1 r2 [Hr|Hr].r, r1, r2:R
Hr:(0 < r)%R
(Rmin r1 r2 * r)%R = Rmin (r1 * r) (r2 * r)
r, r1, r2:R
Hr:0%R = r
(Rmin r1 r2 * r)%R = Rmin (r1 * r) (r2 * r)
unfold Rmin.r, r1, r2:R
Hr:(0 < r)%R
((if Rle_dec r1 r2 then r1 else r2) * r)%R =
(if Rle_dec (r1 * r) (r2 * r)
 then (r1 * r)%R
 else (r2 * r)%R)
r, r1, r2:R
Hr:0%R = r
(Rmin r1 r2 * r)%R = Rmin (r1 * r) (r2 * r)
destruct (Rle_dec r1 r2) as [H1|H1] ;
  destruct (Rle_dec (r1 * r) (r2 * r)) as [H2|H2] ;
  try easy.r, r1, r2:R
Hr:(0 < r)%R
H1:(r1 <= r2)%R
H2:~ (r1 * r <= r2 * r)%R
(r1 * r)%R = (r2 * r)%R
r, r1, r2:R
Hr:(0 < r)%R
H1:~ (r1 <= r2)%R
H2:(r1 * r <= r2 * r)%R
(r2 * r)%R = (r1 * r)%R
r, r1, r2:R
Hr:0%R = r
(Rmin r1 r2 * r)%R = Rmin (r1 * r) (r2 * r)
apply (f_equal (fun x => Rmult x r)).r, r1, r2:R
Hr:(0 < r)%R
H1:(r1 <= r2)%R
H2:~ (r1 * r <= r2 * r)%R
r1 = r2
r, r1, r2:R
Hr:(0 < r)%R
H1:~ (r1 <= r2)%R
H2:(r1 * r <= r2 * r)%R
(r2 * r)%R = (r1 * r)%R
r, r1, r2:R
Hr:0%R = r
(Rmin r1 r2 * r)%R = Rmin (r1 * r) (r2 * r)
apply Rle_antisym.r, r1, r2:R
Hr:(0 < r)%R
H1:(r1 <= r2)%R
H2:~ (r1 * r <= r2 * r)%R
(r1 <= r2)%R
r, r1, r2:R
Hr:(0 < r)%R
H1:(r1 <= r2)%R
H2:~ (r1 * r <= r2 * r)%R
(r2 <= r1)%R
r, r1, r2:R
Hr:(0 < r)%R
H1:~ (r1 <= r2)%R
H2:(r1 * r <= r2 * r)%R
(r2 * r)%R = (r1 * r)%R
r, r1, r2:R
Hr:0%R = r
(Rmin r1 r2 * r)%R = Rmin (r1 * r) (r2 * r)
exact H1.r, r1, r2:R
Hr:(0 < r)%R
H1:(r1 <= r2)%R
H2:~ (r1 * r <= r2 * r)%R
(r2 <= r1)%R
r, r1, r2:R
Hr:(0 < r)%R
H1:~ (r1 <= r2)%R
H2:(r1 * r <= r2 * r)%R
(r2 * r)%R = (r1 * r)%R
r, r1, r2:R
Hr:0%R = r
(Rmin r1 r2 * r)%R = Rmin (r1 * r) (r2 * r)
apply Rmult_le_reg_r with (1 := Hr).r, r1, r2:R
Hr:(0 < r)%R
H1:(r1 <= r2)%R
H2:~ (r1 * r <= r2 * r)%R
(r2 * r <= r1 * r)%R
r, r1, r2:R
Hr:(0 < r)%R
H1:~ (r1 <= r2)%R
H2:(r1 * r <= r2 * r)%R
(r2 * r)%R = (r1 * r)%R
r, r1, r2:R
Hr:0%R = r
(Rmin r1 r2 * r)%R = Rmin (r1 * r) (r2 * r)
apply Rlt_le.r, r1, r2:R
Hr:(0 < r)%R
H1:(r1 <= r2)%R
H2:~ (r1 * r <= r2 * r)%R
(r2 * r < r1 * r)%R
r, r1, r2:R
Hr:(0 < r)%R
H1:~ (r1 <= r2)%R
H2:(r1 * r <= r2 * r)%R
(r2 * r)%R = (r1 * r)%R
r, r1, r2:R
Hr:0%R = r
(Rmin r1 r2 * r)%R = Rmin (r1 * r) (r2 * r)
now apply Rnot_le_lt.r, r1, r2:R
Hr:(0 < r)%R
H1:~ (r1 <= r2)%R
H2:(r1 * r <= r2 * r)%R
(r2 * r)%R = (r1 * r)%R
r, r1, r2:R
Hr:0%R = r
(Rmin r1 r2 * r)%R = Rmin (r1 * r) (r2 * r)
apply Rle_antisym.r, r1, r2:R
Hr:(0 < r)%R
H1:~ (r1 <= r2)%R
H2:(r1 * r <= r2 * r)%R
(r2 * r <= r1 * r)%R
r, r1, r2:R
Hr:(0 < r)%R
H1:~ (r1 <= r2)%R
H2:(r1 * r <= r2 * r)%R
(r1 * r <= r2 * r)%R
r, r1, r2:R
Hr:0%R = r
(Rmin r1 r2 * r)%R = Rmin (r1 * r) (r2 * r)
apply Rmult_le_compat_r.r, r1, r2:R
Hr:(0 < r)%R
H1:~ (r1 <= r2)%R
H2:(r1 * r <= r2 * r)%R
(0 <= r)%R
r, r1, r2:R
Hr:(0 < r)%R
H1:~ (r1 <= r2)%R
H2:(r1 * r <= r2 * r)%R
(r2 <= r1)%R
r, r1, r2:R
Hr:(0 < r)%R
H1:~ (r1 <= r2)%R
H2:(r1 * r <= r2 * r)%R
(r1 * r <= r2 * r)%R
r, r1, r2:R
Hr:0%R = r
(Rmin r1 r2 * r)%R = Rmin (r1 * r) (r2 * r)
now apply Rlt_le.r, r1, r2:R
Hr:(0 < r)%R
H1:~ (r1 <= r2)%R
H2:(r1 * r <= r2 * r)%R
(r2 <= r1)%R
r, r1, r2:R
Hr:(0 < r)%R
H1:~ (r1 <= r2)%R
H2:(r1 * r <= r2 * r)%R
(r1 * r <= r2 * r)%R
r, r1, r2:R
Hr:0%R = r
(Rmin r1 r2 * r)%R = Rmin (r1 * r) (r2 * r)
apply Rlt_le.r, r1, r2:R
Hr:(0 < r)%R
H1:~ (r1 <= r2)%R
H2:(r1 * r <= r2 * r)%R
(r2 < r1)%R
r, r1, r2:R
Hr:(0 < r)%R
H1:~ (r1 <= r2)%R
H2:(r1 * r <= r2 * r)%R
(r1 * r <= r2 * r)%R
r, r1, r2:R
Hr:0%R = r
(Rmin r1 r2 * r)%R = Rmin (r1 * r) (r2 * r)
now apply Rnot_le_lt.r, r1, r2:R
Hr:(0 < r)%R
H1:~ (r1 <= r2)%R
H2:(r1 * r <= r2 * r)%R
(r1 * r <= r2 * r)%R
r, r1, r2:R
Hr:0%R = r
(Rmin r1 r2 * r)%R = Rmin (r1 * r) (r2 * r)
exact H2.r, r1, r2:R
Hr:0%R = r
(Rmin r1 r2 * r)%R = Rmin (r1 * r) (r2 * r)
rewrite <- Hr.r, r1, r2:R
Hr:0%R = r
(Rmin r1 r2 * 0)%R = Rmin (r1 * 0) (r2 * 0)
rewrite 3!Rmult_0_r.r, r1, r2:R
Hr:0%R = r
0%R = Rmin 0 0
unfold Rmin.r, r1, r2:R
Hr:0%R = r
0%R = (if Rle_dec 0 0 then 0%R else 0%R)
destruct (Rle_dec 0 0) as [H0|H0].r, r1, r2:R
Hr:0%R = r
H0:(0 <= 0)%R
0%R = 0%R
r, r1, r2:R
Hr:0%R = r
H0:~ (0 <= 0)%R
0%R = 0%R
easy.r, r1, r2:R
Hr:0%R = r
H0:~ (0 <= 0)%R
0%R = 0%R
elim H0.r, r1, r2:R
Hr:0%R = r
H0:~ (0 <= 0)%R
(0 <= 0)%R
apply Rle_refl.
Qed.

Theorem Rmult_min_distr_l :
  forall r r1 r2 : R,
  (0 <= r)%R ->
  (r * Rmin r1 r2)%R = Rmin (r * r1) (r * r2).forall r r1 r2 : R,
(0 <= r)%R ->
(r * Rmin r1 r2)%R = Rmin (r * r1) (r * r2)
Proof.forall r r1 r2 : R,
(0 <= r)%R ->
(r * Rmin r1 r2)%R = Rmin (r * r1) (r * r2)
intros r r1 r2 Hr.r, r1, r2:R
Hr:(0 <= r)%R
(r * Rmin r1 r2)%R = Rmin (r * r1) (r * r2)
rewrite 3!(Rmult_comm r).r, r1, r2:R
Hr:(0 <= r)%R
(Rmin r1 r2 * r)%R = Rmin (r1 * r) (r2 * r)
now apply Rmult_min_distr_r.
Qed.

Lemma Rmin_opp: forall x y, (Rmin (-x) (-y) = - Rmax x y)%R.forall x y : R, Rmin (- x) (- y) = (- Rmax x y)%R
Proof.forall x y : R, Rmin (- x) (- y) = (- Rmax x y)%R
intros x y.x, y:R
Rmin (- x) (- y) = (- Rmax x y)%R
apply Rmax_case_strong; intros H.x, y:R
H:(y <= x)%R
Rmin (- x) (- y) = (- x)%R
x, y:R
H:(x <= y)%R
Rmin (- x) (- y) = (- y)%R
rewrite Rmin_left; trivial.x, y:R
H:(y <= x)%R
(- x <= - y)%R
x, y:R
H:(x <= y)%R
Rmin (- x) (- y) = (- y)%R
now apply Ropp_le_contravar.x, y:R
H:(x <= y)%R
Rmin (- x) (- y) = (- y)%R
rewrite Rmin_right; trivial.x, y:R
H:(x <= y)%R
(- y <= - x)%R
now apply Ropp_le_contravar.
Qed.

Lemma Rmax_opp: forall x y, (Rmax (-x) (-y) = - Rmin x y)%R.forall x y : R, Rmax (- x) (- y) = (- Rmin x y)%R
Proof.forall x y : R, Rmax (- x) (- y) = (- Rmin x y)%R
intros x y.x, y:R
Rmax (- x) (- y) = (- Rmin x y)%R
apply Rmin_case_strong; intros H.x, y:R
H:(x <= y)%R
Rmax (- x) (- y) = (- x)%R
x, y:R
H:(y <= x)%R
Rmax (- x) (- y) = (- y)%R
rewrite Rmax_left; trivial.x, y:R
H:(x <= y)%R
(- y <= - x)%R
x, y:R
H:(y <= x)%R
Rmax (- x) (- y) = (- y)%R
now apply Ropp_le_contravar.x, y:R
H:(y <= x)%R
Rmax (- x) (- y) = (- y)%R
rewrite Rmax_right; trivial.x, y:R
H:(y <= x)%R
(- x <= - y)%R
now apply Ropp_le_contravar.
Qed.

Theorem exp_le :
  forall x y : R,
  (x <= y)%R -> (exp x <= exp y)%R.forall x y : R, (x <= y)%R -> (exp x <= exp y)%R
Proof.forall x y : R, (x <= y)%R -> (exp x <= exp y)%R
intros x y [H|H].x, y:R
H:(x < y)%R
(exp x <= exp y)%R
x, y:R
H:x = y
(exp x <= exp y)%R
apply Rlt_le.x, y:R
H:(x < y)%R
(exp x < exp y)%R
x, y:R
H:x = y
(exp x <= exp y)%R
now apply exp_increasing.x, y:R
H:x = y
(exp x <= exp y)%R
rewrite H.x, y:R
H:x = y
(exp y <= exp y)%R
apply Rle_refl.
Qed.

Theorem Rinv_lt :
  forall x y,
  (0 < x)%R -> (x < y)%R -> (/y < /x)%R.forall x y : R,
(0 < x)%R -> (x < y)%R -> (/ y < / x)%R
Proof.forall x y : R,
(0 < x)%R -> (x < y)%R -> (/ y < / x)%R
intros x y Hx Hxy.x, y:R
Hx:(0 < x)%R
Hxy:(x < y)%R
(/ y < / x)%R
apply Rinv_lt_contravar.x, y:R
Hx:(0 < x)%R
Hxy:(x < y)%R
(0 < x * y)%R
x, y:R
Hx:(0 < x)%R
Hxy:(x < y)%R
(x < y)%R
apply Rmult_lt_0_compat.x, y:R
Hx:(0 < x)%R
Hxy:(x < y)%R
(0 < x)%R
x, y:R
Hx:(0 < x)%R
Hxy:(x < y)%R
(0 < y)%R
x, y:R
Hx:(0 < x)%R
Hxy:(x < y)%R
(x < y)%R
exact Hx.x, y:R
Hx:(0 < x)%R
Hxy:(x < y)%R
(0 < y)%R
x, y:R
Hx:(0 < x)%R
Hxy:(x < y)%R
(x < y)%R
now apply Rlt_trans with x.x, y:R
Hx:(0 < x)%R
Hxy:(x < y)%R
(x < y)%R
exact Hxy.
Qed.

Theorem Rinv_le :
  forall x y,
  (0 < x)%R -> (x <= y)%R -> (/y <= /x)%R.forall x y : R,
(0 < x)%R -> (x <= y)%R -> (/ y <= / x)%R
Proof.forall x y : R,
(0 < x)%R -> (x <= y)%R -> (/ y <= / x)%R
intros x y Hx Hxy.x, y:R
Hx:(0 < x)%R
Hxy:(x <= y)%R
(/ y <= / x)%R
apply Rle_Rinv.x, y:R
Hx:(0 < x)%R
Hxy:(x <= y)%R
(0 < x)%R
x, y:R
Hx:(0 < x)%R
Hxy:(x <= y)%R
(0 < y)%R
x, y:R
Hx:(0 < x)%R
Hxy:(x <= y)%R
(x <= y)%R
exact Hx.x, y:R
Hx:(0 < x)%R
Hxy:(x <= y)%R
(0 < y)%R
x, y:R
Hx:(0 < x)%R
Hxy:(x <= y)%R
(x <= y)%R
now apply Rlt_le_trans with x.x, y:R
Hx:(0 < x)%R
Hxy:(x <= y)%R
(x <= y)%R
exact Hxy.
Qed.

Theorem sqrt_ge_0 :
  forall x : R,
  (0 <= sqrt x)%R.forall x : R, (0 <= sqrt x)%R
Proof.forall x : R, (0 <= sqrt x)%R
intros x.x:R
(0 <= sqrt x)%R
unfold sqrt.x:R
(0 <=
 match Rcase_abs x with
 | left _ => 0
 | right a =>
     Rsqrt
       {| nonneg := x; cond_nonneg := Rge_le x 0 a |}
 end)%R
destruct (Rcase_abs x) as [_|H].x:R
(0 <= 0)%R
x:R
H:(x >= 0)%R
(0 <=
 Rsqrt {| nonneg := x; cond_nonneg := Rge_le x 0 H |})%R
apply Rle_refl.x:R
H:(x >= 0)%R
(0 <=
 Rsqrt {| nonneg := x; cond_nonneg := Rge_le x 0 H |})%R
apply Rsqrt_positivity.
Qed.

Lemma sqrt_neg : forall x, (x <= 0)%R -> (sqrt x = 0)%R.forall x : R, (x <= 0)%R -> sqrt x = 0%R
Proof.forall x : R, (x <= 0)%R -> sqrt x = 0%R
intros x Npx.x:R
Npx:(x <= 0)%R
sqrt x = 0%R
destruct (Req_dec x 0) as [Zx|Nzx].x:R
Npx:(x <= 0)%R
Zx:x = 0%R
sqrt x = 0%R
x:R
Npx:(x <= 0)%R
Nzx:x <> 0%R
sqrt x = 0%R
- (* x = 0 *)x:R
Npx:(x <= 0)%R
Zx:x = 0%R
sqrt x = 0%R
  rewrite Zx.x:R
Npx:(x <= 0)%R
Zx:x = 0%R
sqrt 0 = 0%R
  exact sqrt_0.
- (* x < 0 *)x:R
Npx:(x <= 0)%R
Nzx:x <> 0%R
sqrt x = 0%R
  unfold sqrt.x:R
Npx:(x <= 0)%R
Nzx:x <> 0%R
match Rcase_abs x with
| left _ => 0%R
| right a =>
    Rsqrt
      {| nonneg := x; cond_nonneg := Rge_le x 0 a |}
end = 0%R
  destruct Rcase_abs.x:R
Npx:(x <= 0)%R
Nzx:x <> 0%R
r:(x < 0)%R
0%R = 0%R
x:R
Npx:(x <= 0)%R
Nzx:x <> 0%R
r:(x >= 0)%R
Rsqrt {| nonneg := x; cond_nonneg := Rge_le x 0 r |} =
0%R
  +x:R
Npx:(x <= 0)%R
Nzx:x <> 0%R
r:(x < 0)%R
0%R = 0%R reflexivity.
  +x:R
Npx:(x <= 0)%R
Nzx:x <> 0%R
r:(x >= 0)%R
Rsqrt {| nonneg := x; cond_nonneg := Rge_le x 0 r |} =
0%R casetype False.x:R
Npx:(x <= 0)%R
Nzx:x <> 0%R
r:(x >= 0)%R
False
    now apply Nzx, Rle_antisym; [|apply Rge_le].
Qed.

Lemma Rsqr_le_abs_0_alt :
  forall x y,
  (x² <= y² -> x <= Rabs y)%R.forall x y : R, (x² <= y²)%R -> (x <= Rabs y)%R
Proof.forall x y : R, (x² <= y²)%R -> (x <= Rabs y)%R
intros x y H.x, y:R
H:(x² <= y²)%R
(x <= Rabs y)%R
apply (Rle_trans _ (Rabs x)); [apply Rle_abs|apply (Rsqr_le_abs_0 _ _ H)].
Qed.

Theorem Rabs_le :
  forall x y,
  (-y <= x <= y)%R -> (Rabs x <= y)%R.forall x y : R, (- y <= x <= y)%R -> (Rabs x <= y)%R
Proof.forall x y : R, (- y <= x <= y)%R -> (Rabs x <= y)%R
intros x y (Hyx,Hxy).x, y:R
Hyx:(- y <= x)%R
Hxy:(x <= y)%R
(Rabs x <= y)%R
unfold Rabs.x, y:R
Hyx:(- y <= x)%R
Hxy:(x <= y)%R
((if Rcase_abs x then - x else x) <= y)%R
case Rcase_abs ; intros Hx.x, y:R
Hyx:(- y <= x)%R
Hxy:(x <= y)%R
Hx:(x < 0)%R
(- x <= y)%R
x, y:R
Hyx:(- y <= x)%R
Hxy:(x <= y)%R
Hx:(x >= 0)%R
(x <= y)%R
apply Ropp_le_cancel.x, y:R
Hyx:(- y <= x)%R
Hxy:(x <= y)%R
Hx:(x < 0)%R
(- y <= - - x)%R
x, y:R
Hyx:(- y <= x)%R
Hxy:(x <= y)%R
Hx:(x >= 0)%R
(x <= y)%R
now rewrite Ropp_involutive.x, y:R
Hyx:(- y <= x)%R
Hxy:(x <= y)%R
Hx:(x >= 0)%R
(x <= y)%R
exact Hxy.
Qed.

Theorem Rabs_le_inv :
  forall x y,
  (Rabs x <= y)%R -> (-y <= x <= y)%R.forall x y : R, (Rabs x <= y)%R -> (- y <= x <= y)%R
Proof.forall x y : R, (Rabs x <= y)%R -> (- y <= x <= y)%R
intros x y Hxy.x, y:R
Hxy:(Rabs x <= y)%R
(- y <= x <= y)%R
split.x, y:R
Hxy:(Rabs x <= y)%R
(- y <= x)%R
x, y:R
Hxy:(Rabs x <= y)%R
(x <= y)%R
apply Rle_trans with (- Rabs x)%R.x, y:R
Hxy:(Rabs x <= y)%R
(- y <= - Rabs x)%R
x, y:R
Hxy:(Rabs x <= y)%R
(- Rabs x <= x)%R
x, y:R
Hxy:(Rabs x <= y)%R
(x <= y)%R
now apply Ropp_le_contravar.x, y:R
Hxy:(Rabs x <= y)%R
(- Rabs x <= x)%R
x, y:R
Hxy:(Rabs x <= y)%R
(x <= y)%R
apply Ropp_le_cancel.x, y:R
Hxy:(Rabs x <= y)%R
(- x <= - - Rabs x)%R
x, y:R
Hxy:(Rabs x <= y)%R
(x <= y)%R
rewrite Ropp_involutive, <- Rabs_Ropp.x, y:R
Hxy:(Rabs x <= y)%R
(- x <= Rabs (- x))%R
x, y:R
Hxy:(Rabs x <= y)%R
(x <= y)%R
apply RRle_abs.x, y:R
Hxy:(Rabs x <= y)%R
(x <= y)%R
apply Rle_trans with (2 := Hxy).x, y:R
Hxy:(Rabs x <= y)%R
(x <= Rabs x)%R
apply RRle_abs.
Qed.

Theorem Rabs_ge :
  forall x y,
  (y <= -x \/ x <= y)%R -> (x <= Rabs y)%R.forall x y : R,
(y <= - x)%R \/ (x <= y)%R -> (x <= Rabs y)%R
Proof.forall x y : R,
(y <= - x)%R \/ (x <= y)%R -> (x <= Rabs y)%R
intros x y [Hyx|Hxy].x, y:R
Hyx:(y <= - x)%R
(x <= Rabs y)%R
x, y:R
Hxy:(x <= y)%R
(x <= Rabs y)%R
apply Rle_trans with (-y)%R.x, y:R
Hyx:(y <= - x)%R
(x <= - y)%R
x, y:R
Hyx:(y <= - x)%R
(- y <= Rabs y)%R
x, y:R
Hxy:(x <= y)%R
(x <= Rabs y)%R
apply Ropp_le_cancel.x, y:R
Hyx:(y <= - x)%R
(- - y <= - x)%R
x, y:R
Hyx:(y <= - x)%R
(- y <= Rabs y)%R
x, y:R
Hxy:(x <= y)%R
(x <= Rabs y)%R
now rewrite Ropp_involutive.x, y:R
Hyx:(y <= - x)%R
(- y <= Rabs y)%R
x, y:R
Hxy:(x <= y)%R
(x <= Rabs y)%R
rewrite <- Rabs_Ropp.x, y:R
Hyx:(y <= - x)%R
(- y <= Rabs (- y))%R
x, y:R
Hxy:(x <= y)%R
(x <= Rabs y)%R
apply RRle_abs.x, y:R
Hxy:(x <= y)%R
(x <= Rabs y)%R
apply Rle_trans with (1 := Hxy).x, y:R
Hxy:(x <= y)%R
(y <= Rabs y)%R
apply RRle_abs.
Qed.

Theorem Rabs_ge_inv :
  forall x y,
  (x <= Rabs y)%R -> (y <= -x \/ x <= y)%R.forall x y : R,
(x <= Rabs y)%R -> (y <= - x)%R \/ (x <= y)%R
Proof.forall x y : R,
(x <= Rabs y)%R -> (y <= - x)%R \/ (x <= y)%R
intros x y.x, y:R
(x <= Rabs y)%R -> (y <= - x)%R \/ (x <= y)%R
unfold Rabs.x, y:R
(x <= (if Rcase_abs y then - y else y))%R ->
(y <= - x)%R \/ (x <= y)%R
case Rcase_abs ; intros Hy Hxy.x, y:R
Hy:(y < 0)%R
Hxy:(x <= - y)%R
(y <= - x)%R \/ (x <= y)%R
x, y:R
Hy:(y >= 0)%R
Hxy:(x <= y)%R
(y <= - x)%R \/ (x <= y)%R
left.x, y:R
Hy:(y < 0)%R
Hxy:(x <= - y)%R
(y <= - x)%R
x, y:R
Hy:(y >= 0)%R
Hxy:(x <= y)%R
(y <= - x)%R \/ (x <= y)%R
apply Ropp_le_cancel.x, y:R
Hy:(y < 0)%R
Hxy:(x <= - y)%R
(- - x <= - y)%R
x, y:R
Hy:(y >= 0)%R
Hxy:(x <= y)%R
(y <= - x)%R \/ (x <= y)%R
now rewrite Ropp_involutive.x, y:R
Hy:(y >= 0)%R
Hxy:(x <= y)%R
(y <= - x)%R \/ (x <= y)%R
now right.
Qed.

Theorem Rabs_lt :
  forall x y,
  (-y < x < y)%R -> (Rabs x < y)%R.forall x y : R, (- y < x < y)%R -> (Rabs x < y)%R
Proof.forall x y : R, (- y < x < y)%R -> (Rabs x < y)%R
intros x y (Hyx,Hxy).x, y:R
Hyx:(- y < x)%R
Hxy:(x < y)%R
(Rabs x < y)%R
now apply Rabs_def1.
Qed.

Theorem Rabs_lt_inv :
  forall x y,
  (Rabs x < y)%R -> (-y < x < y)%R.forall x y : R, (Rabs x < y)%R -> (- y < x < y)%R
Proof.forall x y : R, (Rabs x < y)%R -> (- y < x < y)%R
intros x y H.x, y:R
H:(Rabs x < y)%R
(- y < x < y)%R
now split ; eapply Rabs_def2.
Qed.

Theorem Rabs_gt :
  forall x y,
  (y < -x \/ x < y)%R -> (x < Rabs y)%R.forall x y : R,
(y < - x)%R \/ (x < y)%R -> (x < Rabs y)%R
Proof.forall x y : R,
(y < - x)%R \/ (x < y)%R -> (x < Rabs y)%R
intros x y [Hyx|Hxy].x, y:R
Hyx:(y < - x)%R
(x < Rabs y)%R
x, y:R
Hxy:(x < y)%R
(x < Rabs y)%R
rewrite <- Rabs_Ropp.x, y:R
Hyx:(y < - x)%R
(x < Rabs (- y))%R
x, y:R
Hxy:(x < y)%R
(x < Rabs y)%R
apply Rlt_le_trans with (Ropp y).x, y:R
Hyx:(y < - x)%R
(x < - y)%R
x, y:R
Hyx:(y < - x)%R
(- y <= Rabs (- y))%R
x, y:R
Hxy:(x < y)%R
(x < Rabs y)%R
apply Ropp_lt_cancel.x, y:R
Hyx:(y < - x)%R
(- - y < - x)%R
x, y:R
Hyx:(y < - x)%R
(- y <= Rabs (- y))%R
x, y:R
Hxy:(x < y)%R
(x < Rabs y)%R
now rewrite Ropp_involutive.x, y:R
Hyx:(y < - x)%R
(- y <= Rabs (- y))%R
x, y:R
Hxy:(x < y)%R
(x < Rabs y)%R
apply RRle_abs.x, y:R
Hxy:(x < y)%R
(x < Rabs y)%R
apply Rlt_le_trans with (1 := Hxy).x, y:R
Hxy:(x < y)%R
(y <= Rabs y)%R
apply RRle_abs.
Qed.

Theorem Rabs_gt_inv :
  forall x y,
  (x < Rabs y)%R -> (y < -x \/ x < y)%R.forall x y : R,
(x < Rabs y)%R -> (y < - x)%R \/ (x < y)%R
Proof.forall x y : R,
(x < Rabs y)%R -> (y < - x)%R \/ (x < y)%R
intros x y.x, y:R
(x < Rabs y)%R -> (y < - x)%R \/ (x < y)%R
unfold Rabs.x, y:R
(x < (if Rcase_abs y then - y else y))%R ->
(y < - x)%R \/ (x < y)%R
case Rcase_abs ; intros Hy Hxy.x, y:R
Hy:(y < 0)%R
Hxy:(x < - y)%R
(y < - x)%R \/ (x < y)%R
x, y:R
Hy:(y >= 0)%R
Hxy:(x < y)%R
(y < - x)%R \/ (x < y)%R
left.x, y:R
Hy:(y < 0)%R
Hxy:(x < - y)%R
(y < - x)%R
x, y:R
Hy:(y >= 0)%R
Hxy:(x < y)%R
(y < - x)%R \/ (x < y)%R
apply Ropp_lt_cancel.x, y:R
Hy:(y < 0)%R
Hxy:(x < - y)%R
(- - x < - y)%R
x, y:R
Hy:(y >= 0)%R
Hxy:(x < y)%R
(y < - x)%R \/ (x < y)%R
now rewrite Ropp_involutive.x, y:R
Hy:(y >= 0)%R
Hxy:(x < y)%R
(y < - x)%R \/ (x < y)%R
now right.
Qed.

End Rmissing.

Section IZR.

Theorem IZR_le_lt :
  forall m n p, (m <= n < p)%Z -> (IZR m <= IZR n < IZR p)%R.forall m n p : Z,
(m <= n < p)%Z -> (IZR m <= IZR n < IZR p)%R
Proof.forall m n p : Z,
(m <= n < p)%Z -> (IZR m <= IZR n < IZR p)%R
intros m n p (H1, H2).m, n, p:Z
H1:(m <= n)%Z
H2:(n < p)%Z
(IZR m <= IZR n < IZR p)%R
split.m, n, p:Z
H1:(m <= n)%Z
H2:(n < p)%Z
(IZR m <= IZR n)%R
m, n, p:Z
H1:(m <= n)%Z
H2:(n < p)%Z
(IZR n < IZR p)%R
now apply IZR_le.m, n, p:Z
H1:(m <= n)%Z
H2:(n < p)%Z
(IZR n < IZR p)%R
now apply IZR_lt.
Qed.

Theorem le_lt_IZR :
  forall m n p, (IZR m <= IZR n < IZR p)%R -> (m <= n < p)%Z.forall m n p : Z,
(IZR m <= IZR n < IZR p)%R -> (m <= n < p)%Z
Proof.forall m n p : Z,
(IZR m <= IZR n < IZR p)%R -> (m <= n < p)%Z
intros m n p (H1, H2).m, n, p:Z
H1:(IZR m <= IZR n)%R
H2:(IZR n < IZR p)%R
(m <= n < p)%Z
split.m, n, p:Z
H1:(IZR m <= IZR n)%R
H2:(IZR n < IZR p)%R
(m <= n)%Z
m, n, p:Z
H1:(IZR m <= IZR n)%R
H2:(IZR n < IZR p)%R
(n < p)%Z
now apply le_IZR.m, n, p:Z
H1:(IZR m <= IZR n)%R
H2:(IZR n < IZR p)%R
(n < p)%Z
now apply lt_IZR.
Qed.

Theorem neq_IZR :
  forall m n, (IZR m <> IZR n)%R -> (m <> n)%Z.forall m n : Z, IZR m <> IZR n -> m <> n
Proof.forall m n : Z, IZR m <> IZR n -> m <> n
intros m n H H'.m, n:Z
H:IZR m <> IZR n
H':m = n
False
apply H.m, n:Z
H:IZR m <> IZR n
H':m = n
IZR m = IZR n
now apply f_equal.
Qed.

End IZR.

Decidable comparison on reals

Section Rcompare.

Definition Rcompare x y :=
  match total_order_T x y with
  | inleft (left _) => Lt
  | inleft (right _) => Eq
  | inright _ => Gt
  end.

Inductive Rcompare_prop (x y : R) : comparison -> Prop :=
  | Rcompare_Lt_ : (x < y)%R -> Rcompare_prop x y Lt
  | Rcompare_Eq_ : x = y -> Rcompare_prop x y Eq
  | Rcompare_Gt_ : (y < x)%R -> Rcompare_prop x y Gt.

Theorem Rcompare_spec :
  forall x y, Rcompare_prop x y (Rcompare x y).forall x y : R, Rcompare_prop x y (Rcompare x y)
Proof.forall x y : R, Rcompare_prop x y (Rcompare x y)
intros x y.x, y:R
Rcompare_prop x y (Rcompare x y)
unfold Rcompare.x, y:R
Rcompare_prop x y
  match total_order_T x y with
  | inleft (left _) => Lt
  | inleft (right _) => Eq
  | inright _ => Gt
  end
now destruct (total_order_T x y) as [[H|H]|H] ; constructor.
Qed.

Global Opaque Rcompare.

Theorem Rcompare_Lt :
  forall x y,
  (x < y)%R -> Rcompare x y = Lt.forall x y : R, (x < y)%R -> Rcompare x y = Lt
Proof.forall x y : R, (x < y)%R -> Rcompare x y = Lt
intros x y H.x, y:R
H:(x < y)%R
Rcompare x y = Lt
case Rcompare_spec ; intro H'.x, y:R
H, H':(x < y)%R
Lt = Lt
x, y:R
H:(x < y)%R
H':x = y
Eq = Lt
x, y:R
H:(x < y)%R
H':(y < x)%R
Gt = Lt
easy.x, y:R
H:(x < y)%R
H':x = y
Eq = Lt
x, y:R
H:(x < y)%R
H':(y < x)%R
Gt = Lt
rewrite H' in H.x, y:R
H:(y < y)%R
H':x = y
Eq = Lt
x, y:R
H:(x < y)%R
H':(y < x)%R
Gt = Lt
elim (Rlt_irrefl _ H).x, y:R
H:(x < y)%R
H':(y < x)%R
Gt = Lt
elim (Rlt_irrefl x).x, y:R
H:(x < y)%R
H':(y < x)%R
(x < x)%R
now apply Rlt_trans with y.
Qed.

Theorem Rcompare_Lt_inv :
  forall x y,
  Rcompare x y = Lt -> (x < y)%R.forall x y : R, Rcompare x y = Lt -> (x < y)%R
Proof.forall x y : R, Rcompare x y = Lt -> (x < y)%R
intros x y.x, y:R
Rcompare x y = Lt -> (x < y)%R
now case Rcompare_spec.
Qed.

Theorem Rcompare_not_Lt :
  forall x y,
  (y <= x)%R -> Rcompare x y <> Lt.forall x y : R, (y <= x)%R -> Rcompare x y <> Lt
Proof.forall x y : R, (y <= x)%R -> Rcompare x y <> Lt
intros x y H1 H2.x, y:R
H1:(y <= x)%R
H2:Rcompare x y = Lt
False
apply Rle_not_lt with (1 := H1).x, y:R
H1:(y <= x)%R
H2:Rcompare x y = Lt
(x < y)%R
now apply Rcompare_Lt_inv.
Qed.

Theorem Rcompare_not_Lt_inv :
  forall x y,
  Rcompare x y <> Lt -> (y <= x)%R.forall x y : R, Rcompare x y <> Lt -> (y <= x)%R
Proof.forall x y : R, Rcompare x y <> Lt -> (y <= x)%R
intros x y H.x, y:R
H:Rcompare x y <> Lt
(y <= x)%R
apply Rnot_lt_le.x, y:R
H:Rcompare x y <> Lt
~ (x < y)%R
contradict H.x, y:R
H:(x < y)%R
Rcompare x y = Lt
now apply Rcompare_Lt.
Qed.

Theorem Rcompare_Eq :
  forall x y,
  x = y -> Rcompare x y = Eq.forall x y : R, x = y -> Rcompare x y = Eq
Proof.forall x y : R, x = y -> Rcompare x y = Eq
intros x y H.x, y:R
H:x = y
Rcompare x y = Eq
rewrite H.x, y:R
H:x = y
Rcompare y y = Eq
now case Rcompare_spec ; intro H' ; try elim (Rlt_irrefl _ H').
Qed.

Theorem Rcompare_Eq_inv :
  forall x y,
  Rcompare x y = Eq -> x = y.forall x y : R, Rcompare x y = Eq -> x = y
Proof.forall x y : R, Rcompare x y = Eq -> x = y
intros x y.x, y:R
Rcompare x y = Eq -> x = y
now case Rcompare_spec.
Qed.

Theorem Rcompare_Gt :
  forall x y,
  (y < x)%R -> Rcompare x y = Gt.forall x y : R, (y < x)%R -> Rcompare x y = Gt
Proof.forall x y : R, (y < x)%R -> Rcompare x y = Gt
intros x y H.x, y:R
H:(y < x)%R
Rcompare x y = Gt
case Rcompare_spec ; intro H'.x, y:R
H:(y < x)%R
H':(x < y)%R
Lt = Gt
x, y:R
H:(y < x)%R
H':x = y
Eq = Gt
x, y:R
H, H':(y < x)%R
Gt = Gt
elim (Rlt_irrefl x).x, y:R
H:(y < x)%R
H':(x < y)%R
(x < x)%R
x, y:R
H:(y < x)%R
H':x = y
Eq = Gt
x, y:R
H, H':(y < x)%R
Gt = Gt
now apply Rlt_trans with y.x, y:R
H:(y < x)%R
H':x = y
Eq = Gt
x, y:R
H, H':(y < x)%R
Gt = Gt
rewrite H' in H.x, y:R
H:(y < y)%R
H':x = y
Eq = Gt
x, y:R
H, H':(y < x)%R
Gt = Gt
elim (Rlt_irrefl _ H).x, y:R
H, H':(y < x)%R
Gt = Gt
easy.
Qed.

Theorem Rcompare_Gt_inv :
  forall x y,
  Rcompare x y = Gt -> (y < x)%R.forall x y : R, Rcompare x y = Gt -> (y < x)%R
Proof.forall x y : R, Rcompare x y = Gt -> (y < x)%R
intros x y.x, y:R
Rcompare x y = Gt -> (y < x)%R
now case Rcompare_spec.
Qed.

Theorem Rcompare_not_Gt :
  forall x y,
  (x <= y)%R -> Rcompare x y <> Gt.forall x y : R, (x <= y)%R -> Rcompare x y <> Gt
Proof.forall x y : R, (x <= y)%R -> Rcompare x y <> Gt
intros x y H1 H2.x, y:R
H1:(x <= y)%R
H2:Rcompare x y = Gt
False
apply Rle_not_lt with (1 := H1).x, y:R
H1:(x <= y)%R
H2:Rcompare x y = Gt
(y < x)%R
now apply Rcompare_Gt_inv.
Qed.

Theorem Rcompare_not_Gt_inv :
  forall x y,
  Rcompare x y <> Gt -> (x <= y)%R.forall x y : R, Rcompare x y <> Gt -> (x <= y)%R
Proof.forall x y : R, Rcompare x y <> Gt -> (x <= y)%R
intros x y H.x, y:R
H:Rcompare x y <> Gt
(x <= y)%R
apply Rnot_lt_le.x, y:R
H:Rcompare x y <> Gt
~ (y < x)%R
contradict H.x, y:R
H:(y < x)%R
Rcompare x y = Gt
now apply Rcompare_Gt.
Qed.

Theorem Rcompare_IZR :
  forall x y, Rcompare (IZR x) (IZR y) = Z.compare x y.forall x y : Z, Rcompare (IZR x) (IZR y) = (x ?= y)%Z
Proof.forall x y : Z, Rcompare (IZR x) (IZR y) = (x ?= y)%Z
intros x y.x, y:Z
Rcompare (IZR x) (IZR y) = (x ?= y)%Z
case Rcompare_spec ; intros H ; apply sym_eq.x, y:Z
H:(IZR x < IZR y)%R
(x ?= y)%Z = Lt
x, y:Z
H:IZR x = IZR y
(x ?= y)%Z = Eq
x, y:Z
H:(IZR y < IZR x)%R
(x ?= y)%Z = Gt
apply Zcompare_Lt.x, y:Z
H:(IZR x < IZR y)%R
(x < y)%Z
x, y:Z
H:IZR x = IZR y
(x ?= y)%Z = Eq
x, y:Z
H:(IZR y < IZR x)%R
(x ?= y)%Z = Gt
now apply lt_IZR.x, y:Z
H:IZR x = IZR y
(x ?= y)%Z = Eq
x, y:Z
H:(IZR y < IZR x)%R
(x ?= y)%Z = Gt
apply Zcompare_Eq.x, y:Z
H:IZR x = IZR y
x = y
x, y:Z
H:(IZR y < IZR x)%R
(x ?= y)%Z = Gt
now apply eq_IZR.x, y:Z
H:(IZR y < IZR x)%R
(x ?= y)%Z = Gt
apply Zcompare_Gt.x, y:Z
H:(IZR y < IZR x)%R
(y < x)%Z
now apply lt_IZR.
Qed.

Theorem Rcompare_sym :
  forall x y,
  Rcompare x y = CompOpp (Rcompare y x).forall x y : R, Rcompare x y = CompOpp (Rcompare y x)
Proof.forall x y : R, Rcompare x y = CompOpp (Rcompare y x)
intros x y.x, y:R
Rcompare x y = CompOpp (Rcompare y x)
destruct (Rcompare_spec y x) as [H|H|H].x, y:R
H:(y < x)%R
Rcompare x y = CompOpp Lt
x, y:R
H:y = x
Rcompare x y = CompOpp Eq
x, y:R
H:(x < y)%R
Rcompare x y = CompOpp Gt
now apply Rcompare_Gt.x, y:R
H:y = x
Rcompare x y = CompOpp Eq
x, y:R
H:(x < y)%R
Rcompare x y = CompOpp Gt
now apply Rcompare_Eq.x, y:R
H:(x < y)%R
Rcompare x y = CompOpp Gt
now apply Rcompare_Lt.
Qed.

Lemma Rcompare_opp :
  forall x y,
  Rcompare (- x) (- y) = Rcompare y x.forall x y : R, Rcompare (- x) (- y) = Rcompare y x
Proof.forall x y : R, Rcompare (- x) (- y) = Rcompare y x
intros x y.x, y:R
Rcompare (- x) (- y) = Rcompare y x
destruct (Rcompare_spec y x);
  destruct (Rcompare_spec (- x) (- y));
  try reflexivity; exfalso; lra.
Qed.

Theorem Rcompare_plus_r :
  forall z x y,
  Rcompare (x + z) (y + z) = Rcompare x y.forall z x y : R,
Rcompare (x + z) (y + z) = Rcompare x y
Proof.forall z x y : R,
Rcompare (x + z) (y + z) = Rcompare x y
intros z x y.z, x, y:R
Rcompare (x + z) (y + z) = Rcompare x y
destruct (Rcompare_spec x y) as [H|H|H].z, x, y:R
H:(x < y)%R
Rcompare (x + z) (y + z) = Lt
z, x, y:R
H:x = y
Rcompare (x + z) (y + z) = Eq
z, x, y:R
H:(y < x)%R
Rcompare (x + z) (y + z) = Gt
apply Rcompare_Lt.z, x, y:R
H:(x < y)%R
(x + z < y + z)%R
z, x, y:R
H:x = y
Rcompare (x + z) (y + z) = Eq
z, x, y:R
H:(y < x)%R
Rcompare (x + z) (y + z) = Gt
now apply Rplus_lt_compat_r.z, x, y:R
H:x = y
Rcompare (x + z) (y + z) = Eq
z, x, y:R
H:(y < x)%R
Rcompare (x + z) (y + z) = Gt
apply Rcompare_Eq.z, x, y:R
H:x = y
(x + z)%R = (y + z)%R
z, x, y:R
H:(y < x)%R
Rcompare (x + z) (y + z) = Gt
now rewrite H.z, x, y:R
H:(y < x)%R
Rcompare (x + z) (y + z) = Gt
apply Rcompare_Gt.z, x, y:R
H:(y < x)%R
(y + z < x + z)%R
now apply Rplus_lt_compat_r.
Qed.

Theorem Rcompare_plus_l :
  forall z x y,
  Rcompare (z + x) (z + y) = Rcompare x y.forall z x y : R,
Rcompare (z + x) (z + y) = Rcompare x y
Proof.forall z x y : R,
Rcompare (z + x) (z + y) = Rcompare x y
intros z x y.z, x, y:R
Rcompare (z + x) (z + y) = Rcompare x y
rewrite 2!(Rplus_comm z).z, x, y:R
Rcompare (x + z) (y + z) = Rcompare x y
apply Rcompare_plus_r.
Qed.

Theorem Rcompare_mult_r :
  forall z x y,
  (0 < z)%R ->
  Rcompare (x * z) (y * z) = Rcompare x y.forall z x y : R,
(0 < z)%R -> Rcompare (x * z) (y * z) = Rcompare x y
Proof.forall z x y : R,
(0 < z)%R -> Rcompare (x * z) (y * z) = Rcompare x y
intros z x y Hz.z, x, y:R
Hz:(0 < z)%R
Rcompare (x * z) (y * z) = Rcompare x y
destruct (Rcompare_spec x y) as [H|H|H].z, x, y:R
Hz:(0 < z)%R
H:(x < y)%R
Rcompare (x * z) (y * z) = Lt
z, x, y:R
Hz:(0 < z)%R
H:x = y
Rcompare (x * z) (y * z) = Eq
z, x, y:R
Hz:(0 < z)%R
H:(y < x)%R
Rcompare (x * z) (y * z) = Gt
apply Rcompare_Lt.z, x, y:R
Hz:(0 < z)%R
H:(x < y)%R
(x * z < y * z)%R
z, x, y:R
Hz:(0 < z)%R
H:x = y
Rcompare (x * z) (y * z) = Eq
z, x, y:R
Hz:(0 < z)%R
H:(y < x)%R
Rcompare (x * z) (y * z) = Gt
now apply Rmult_lt_compat_r.z, x, y:R
Hz:(0 < z)%R
H:x = y
Rcompare (x * z) (y * z) = Eq
z, x, y:R
Hz:(0 < z)%R
H:(y < x)%R
Rcompare (x * z) (y * z) = Gt
apply Rcompare_Eq.z, x, y:R
Hz:(0 < z)%R
H:x = y
(x * z)%R = (y * z)%R
z, x, y:R
Hz:(0 < z)%R
H:(y < x)%R
Rcompare (x * z) (y * z) = Gt
now rewrite H.z, x, y:R
Hz:(0 < z)%R
H:(y < x)%R
Rcompare (x * z) (y * z) = Gt
apply Rcompare_Gt.z, x, y:R
Hz:(0 < z)%R
H:(y < x)%R
(y * z < x * z)%R
now apply Rmult_lt_compat_r.
Qed.

Theorem Rcompare_mult_l :
  forall z x y,
  (0 < z)%R ->
  Rcompare (z * x) (z * y) = Rcompare x y.forall z x y : R,
(0 < z)%R -> Rcompare (z * x) (z * y) = Rcompare x y
Proof.forall z x y : R,
(0 < z)%R -> Rcompare (z * x) (z * y) = Rcompare x y
intros z x y.z, x, y:R
(0 < z)%R -> Rcompare (z * x) (z * y) = Rcompare x y
rewrite 2!(Rmult_comm z).z, x, y:R
(0 < z)%R -> Rcompare (x * z) (y * z) = Rcompare x y
apply Rcompare_mult_r.
Qed.

Theorem Rcompare_middle :
  forall x d u,
  Rcompare (x - d) (u - x) = Rcompare x ((d + u) / 2).forall x d u : R,
Rcompare (x - d) (u - x) = Rcompare x ((d + u) / 2)
Proof.forall x d u : R,
Rcompare (x - d) (u - x) = Rcompare x ((d + u) / 2)
intros x d u.x, d, u:R
Rcompare (x - d) (u - x) = Rcompare x ((d + u) / 2)
rewrite <- (Rcompare_plus_r (- x / 2 - d / 2) x).x, d, u:R
Rcompare (x - d) (u - x) =
Rcompare (x + (- x / 2 - d / 2))
  ((d + u) / 2 + (- x / 2 - d / 2))
rewrite <- (Rcompare_mult_r (/2) (x - d)).x, d, u:R
Rcompare ((x - d) * / 2) ((u - x) * / 2) =
Rcompare (x + (- x / 2 - d / 2))
  ((d + u) / 2 + (- x / 2 - d / 2))
x, d, u:R
(0 < / 2)%R
field_simplify (x + (- x / 2 - d / 2))%R.x, d, u:R
Rcompare ((x - d) * / 2) ((u - x) * / 2) =
Rcompare ((x - d) / 2)
  ((d + u) / 2 + (- x / 2 - d / 2))
x, d, u:R
(0 < / 2)%R
now field_simplify ((d + u) / 2 + (- x / 2 - d / 2))%R.x, d, u:R
(0 < / 2)%R
apply Rinv_0_lt_compat.x, d, u:R
(0 < 2)%R
now apply IZR_lt.
Qed.

Theorem Rcompare_half_l :
  forall x y, Rcompare (x / 2) y = Rcompare x (2 * y).forall x y : R,
Rcompare (x / 2) y = Rcompare x (2 * y)
Proof.forall x y : R,
Rcompare (x / 2) y = Rcompare x (2 * y)
intros x y.x, y:R
Rcompare (x / 2) y = Rcompare x (2 * y)
rewrite <- (Rcompare_mult_r 2%R).x, y:R
Rcompare (x / 2 * 2) (y * 2) = Rcompare x (2 * y)
x, y:R
(0 < 2)%R
unfold Rdiv.x, y:R
Rcompare (x * / 2 * 2) (y * 2) = Rcompare x (2 * y)
x, y:R
(0 < 2)%R
rewrite Rmult_assoc, Rinv_l, Rmult_1_r.x, y:R
Rcompare x (y * 2) = Rcompare x (2 * y)
x, y:R
2%R <> 0%R
x, y:R
(0 < 2)%R
now rewrite Rmult_comm.x, y:R
2%R <> 0%R
x, y:R
(0 < 2)%R
now apply IZR_neq.x, y:R
(0 < 2)%R
now apply IZR_lt.
Qed.

Theorem Rcompare_half_r :
  forall x y, Rcompare x (y / 2) = Rcompare (2 * x) y.forall x y : R,
Rcompare x (y / 2) = Rcompare (2 * x) y
Proof.forall x y : R,
Rcompare x (y / 2) = Rcompare (2 * x) y
intros x y.x, y:R
Rcompare x (y / 2) = Rcompare (2 * x) y
rewrite <- (Rcompare_mult_r 2%R).x, y:R
Rcompare (x * 2) (y / 2 * 2) = Rcompare (2 * x) y
x, y:R
(0 < 2)%R
unfold Rdiv.x, y:R
Rcompare (x * 2) (y * / 2 * 2) = Rcompare (2 * x) y
x, y:R
(0 < 2)%R
rewrite Rmult_assoc, Rinv_l, Rmult_1_r.x, y:R
Rcompare (x * 2) y = Rcompare (2 * x) y
x, y:R
2%R <> 0%R
x, y:R
(0 < 2)%R
now rewrite Rmult_comm.x, y:R
2%R <> 0%R
x, y:R
(0 < 2)%R
now apply IZR_neq.x, y:R
(0 < 2)%R
now apply IZR_lt.
Qed.

Theorem Rcompare_sqr :
  forall x y,
  Rcompare (x * x) (y * y) = Rcompare (Rabs x) (Rabs y).forall x y : R,
Rcompare (x * x) (y * y) = Rcompare (Rabs x) (Rabs y)
Proof.forall x y : R,
Rcompare (x * x) (y * y) = Rcompare (Rabs x) (Rabs y)
intros x y.x, y:R
Rcompare (x * x) (y * y) = Rcompare (Rabs x) (Rabs y)
destruct (Rcompare_spec (Rabs x) (Rabs y)) as [H|H|H].x, y:R
H:(Rabs x < Rabs y)%R
Rcompare (x * x) (y * y) = Lt
x, y:R
H:Rabs x = Rabs y
Rcompare (x * x) (y * y) = Eq
x, y:R
H:(Rabs y < Rabs x)%R
Rcompare (x * x) (y * y) = Gt
apply Rcompare_Lt.x, y:R
H:(Rabs x < Rabs y)%R
(x * x < y * y)%R
x, y:R
H:Rabs x = Rabs y
Rcompare (x * x) (y * y) = Eq
x, y:R
H:(Rabs y < Rabs x)%R
Rcompare (x * x) (y * y) = Gt
now apply Rsqr_lt_abs_1.x, y:R
H:Rabs x = Rabs y
Rcompare (x * x) (y * y) = Eq
x, y:R
H:(Rabs y < Rabs x)%R
Rcompare (x * x) (y * y) = Gt
change (Rcompare (Rsqr x) (Rsqr y) = Eq).x, y:R
H:Rabs x = Rabs y
Rcompare x² y² = Eq
x, y:R
H:(Rabs y < Rabs x)%R
Rcompare (x * x) (y * y) = Gt
rewrite Rsqr_abs, H, (Rsqr_abs y).x, y:R
H:Rabs x = Rabs y
Rcompare (Rabs y)² (Rabs y)² = Eq
x, y:R
H:(Rabs y < Rabs x)%R
Rcompare (x * x) (y * y) = Gt
now apply Rcompare_Eq.x, y:R
H:(Rabs y < Rabs x)%R
Rcompare (x * x) (y * y) = Gt
apply Rcompare_Gt.x, y:R
H:(Rabs y < Rabs x)%R
(y * y < x * x)%R
now apply Rsqr_lt_abs_1.
Qed.

Theorem Rmin_compare :
  forall x y,
  Rmin x y = match Rcompare x y with Lt => x | Eq => x | Gt => y end.forall x y : R,
Rmin x y =
match Rcompare x y with
| Gt => y
| _ => x
end
Proof.forall x y : R,
Rmin x y =
match Rcompare x y with
| Gt => y
| _ => x
end
intros x y.x, y:R
Rmin x y =
match Rcompare x y with
| Gt => y
| _ => x
end
unfold Rmin.x, y:R
(if Rle_dec x y then x else y) =
match Rcompare x y with
| Gt => y
| _ => x
end
destruct (Rle_dec x y) as [[Hx|Hx]|Hx].x, y:R
Hx:(x < y)%R
x = match Rcompare x y with
    | Gt => y
    | _ => x
    end
x, y:R
Hx:x = y
x = match Rcompare x y with
    | Gt => y
    | _ => x
    end
x, y:R
Hx:~ (x <= y)%R
y = match Rcompare x y with
    | Gt => y
    | _ => x
    end
now rewrite Rcompare_Lt.x, y:R
Hx:x = y
x = match Rcompare x y with
    | Gt => y
    | _ => x
    end
x, y:R
Hx:~ (x <= y)%R
y = match Rcompare x y with
    | Gt => y
    | _ => x
    end
now rewrite Rcompare_Eq.x, y:R
Hx:~ (x <= y)%R
y = match Rcompare x y with
    | Gt => y
    | _ => x
    end
rewrite Rcompare_Gt.x, y:R
Hx:~ (x <= y)%R
y = y
x, y:R
Hx:~ (x <= y)%R
(y < x)%R
easy.x, y:R
Hx:~ (x <= y)%R
(y < x)%R
now apply Rnot_le_lt.
Qed.

End Rcompare.

Section Rle_bool.

Definition Rle_bool x y :=
  match Rcompare x y with
  | Gt => false
  | _ => true
  end.

Inductive Rle_bool_prop (x y : R) : bool -> Prop :=
  | Rle_bool_true_ : (x <= y)%R -> Rle_bool_prop x y true
  | Rle_bool_false_ : (y < x)%R -> Rle_bool_prop x y false.

Theorem Rle_bool_spec :
  forall x y, Rle_bool_prop x y (Rle_bool x y).forall x y : R, Rle_bool_prop x y (Rle_bool x y)
Proof.forall x y : R, Rle_bool_prop x y (Rle_bool x y)
intros x y.x, y:R
Rle_bool_prop x y (Rle_bool x y)
unfold Rle_bool.x, y:R
Rle_bool_prop x y
  match Rcompare x y with
  | Gt => false
  | _ => true
  end
case Rcompare_spec ; constructor.x, y:R
H:(x < y)%R
(x <= y)%R
x, y:R
H:x = y
(x <= y)%R
x, y:R
H:(y < x)%R
(y < x)%R
now apply Rlt_le.x, y:R
H:x = y
(x <= y)%R
x, y:R
H:(y < x)%R
(y < x)%R
rewrite H.x, y:R
H:x = y
(y <= y)%R
x, y:R
H:(y < x)%R
(y < x)%R
apply Rle_refl.x, y:R
H:(y < x)%R
(y < x)%R
exact H.
Qed.

Theorem Rle_bool_true :
  forall x y,
  (x <= y)%R -> Rle_bool x y = true.forall x y : R, (x <= y)%R -> Rle_bool x y = true
Proof.forall x y : R, (x <= y)%R -> Rle_bool x y = true
intros x y Hxy.x, y:R
Hxy:(x <= y)%R
Rle_bool x y = true
case Rle_bool_spec ; intros H.x, y:R
Hxy, H:(x <= y)%R
true = true
x, y:R
Hxy:(x <= y)%R
H:(y < x)%R
false = true
apply refl_equal.x, y:R
Hxy:(x <= y)%R
H:(y < x)%R
false = true
elim (Rlt_irrefl x).x, y:R
Hxy:(x <= y)%R
H:(y < x)%R
(x < x)%R
now apply Rle_lt_trans with y.
Qed.

Theorem Rle_bool_false :
  forall x y,
  (y < x)%R -> Rle_bool x y = false.forall x y : R, (y < x)%R -> Rle_bool x y = false
Proof.forall x y : R, (y < x)%R -> Rle_bool x y = false
intros x y Hxy.x, y:R
Hxy:(y < x)%R
Rle_bool x y = false
case Rle_bool_spec ; intros H.x, y:R
Hxy:(y < x)%R
H:(x <= y)%R
true = false
x, y:R
Hxy, H:(y < x)%R
false = false
elim (Rlt_irrefl x).x, y:R
Hxy:(y < x)%R
H:(x <= y)%R
(x < x)%R
x, y:R
Hxy, H:(y < x)%R
false = false
now apply Rle_lt_trans with y.x, y:R
Hxy, H:(y < x)%R
false = false
apply refl_equal.
Qed.

End Rle_bool.

Section Rlt_bool.

Definition Rlt_bool x y :=
  match Rcompare x y with
  | Lt => true
  | _ => false
  end.

Inductive Rlt_bool_prop (x y : R) : bool -> Prop :=
  | Rlt_bool_true_ : (x < y)%R -> Rlt_bool_prop x y true
  | Rlt_bool_false_ : (y <= x)%R -> Rlt_bool_prop x y false.

Theorem Rlt_bool_spec :
  forall x y, Rlt_bool_prop x y (Rlt_bool x y).forall x y : R, Rlt_bool_prop x y (Rlt_bool x y)
Proof.forall x y : R, Rlt_bool_prop x y (Rlt_bool x y)
intros x y.x, y:R
Rlt_bool_prop x y (Rlt_bool x y)
unfold Rlt_bool.x, y:R
Rlt_bool_prop x y
  match Rcompare x y with
  | Lt => true
  | _ => false
  end
case Rcompare_spec ; constructor.x, y:R
H:(x < y)%R
(x < y)%R
x, y:R
H:x = y
(y <= x)%R
x, y:R
H:(y < x)%R
(y <= x)%R
exact H.x, y:R
H:x = y
(y <= x)%R
x, y:R
H:(y < x)%R
(y <= x)%R
rewrite H.x, y:R
H:x = y
(y <= y)%R
x, y:R
H:(y < x)%R
(y <= x)%R
apply Rle_refl.x, y:R
H:(y < x)%R
(y <= x)%R
now apply Rlt_le.
Qed.

Theorem negb_Rlt_bool :
  forall x y,
  negb (Rle_bool x y) = Rlt_bool y x.forall x y : R, negb (Rle_bool x y) = Rlt_bool y x
Proof.forall x y : R, negb (Rle_bool x y) = Rlt_bool y x
intros x y.x, y:R
negb (Rle_bool x y) = Rlt_bool y x
unfold Rlt_bool, Rle_bool.x, y:R
negb
  match Rcompare x y with
  | Gt => false
  | _ => true
  end =
match Rcompare y x with
| Lt => true
| _ => false
end
rewrite Rcompare_sym.x, y:R
negb
  match CompOpp (Rcompare y x) with
  | Gt => false
  | _ => true
  end =
match Rcompare y x with
| Lt => true
| _ => false
end
now case Rcompare.
Qed.

Theorem negb_Rle_bool :
  forall x y,
  negb (Rlt_bool x y) = Rle_bool y x.forall x y : R, negb (Rlt_bool x y) = Rle_bool y x
Proof.forall x y : R, negb (Rlt_bool x y) = Rle_bool y x
intros x y.x, y:R
negb (Rlt_bool x y) = Rle_bool y x
unfold Rlt_bool, Rle_bool.x, y:R
negb
  match Rcompare x y with
  | Lt => true
  | _ => false
  end =
match Rcompare y x with
| Gt => false
| _ => true
end
rewrite Rcompare_sym.x, y:R
negb
  match CompOpp (Rcompare y x) with
  | Lt => true
  | _ => false
  end =
match Rcompare y x with
| Gt => false
| _ => true
end
now case Rcompare.
Qed.

Theorem Rlt_bool_true :
  forall x y,
  (x < y)%R -> Rlt_bool x y = true.forall x y : R, (x < y)%R -> Rlt_bool x y = true
Proof.forall x y : R, (x < y)%R -> Rlt_bool x y = true
intros x y Hxy.x, y:R
Hxy:(x < y)%R
Rlt_bool x y = true
rewrite <- negb_Rlt_bool.x, y:R
Hxy:(x < y)%R
negb (Rle_bool y x) = true
now rewrite Rle_bool_false.
Qed.

Theorem Rlt_bool_false :
  forall x y,
  (y <= x)%R -> Rlt_bool x y = false.forall x y : R, (y <= x)%R -> Rlt_bool x y = false
Proof.forall x y : R, (y <= x)%R -> Rlt_bool x y = false
intros x y Hxy.x, y:R
Hxy:(y <= x)%R
Rlt_bool x y = false
rewrite <- negb_Rlt_bool.x, y:R
Hxy:(y <= x)%R
negb (Rle_bool y x) = false
now rewrite Rle_bool_true.
Qed.

Lemma Rlt_bool_opp :
  forall x y,
  Rlt_bool (- x) (- y) = Rlt_bool y x.forall x y : R, Rlt_bool (- x) (- y) = Rlt_bool y x
Proof.forall x y : R, Rlt_bool (- x) (- y) = Rlt_bool y x
intros x y.x, y:R
Rlt_bool (- x) (- y) = Rlt_bool y x
now unfold Rlt_bool; rewrite Rcompare_opp.
Qed.

End Rlt_bool.

Section Req_bool.

Definition Req_bool x y :=
  match Rcompare x y with
  | Eq => true
  | _ => false
  end.

Inductive Req_bool_prop (x y : R) : bool -> Prop :=
  | Req_bool_true_ : (x = y)%R -> Req_bool_prop x y true
  | Req_bool_false_ : (x <> y)%R -> Req_bool_prop x y false.

Theorem Req_bool_spec :
  forall x y, Req_bool_prop x y (Req_bool x y).forall x y : R, Req_bool_prop x y (Req_bool x y)
Proof.forall x y : R, Req_bool_prop x y (Req_bool x y)
intros x y.x, y:R
Req_bool_prop x y (Req_bool x y)
unfold Req_bool.x, y:R
Req_bool_prop x y
  match Rcompare x y with
  | Eq => true
  | _ => false
  end
case Rcompare_spec ; constructor.x, y:R
H:(x < y)%R
x <> y
x, y:R
H:x = y
x = y
x, y:R
H:(y < x)%R
x <> y
now apply Rlt_not_eq.x, y:R
H:x = y
x = y
x, y:R
H:(y < x)%R
x <> y
easy.x, y:R
H:(y < x)%R
x <> y
now apply Rgt_not_eq.
Qed.

Theorem Req_bool_true :
  forall x y,
  (x = y)%R -> Req_bool x y = true.forall x y : R, x = y -> Req_bool x y = true
Proof.forall x y : R, x = y -> Req_bool x y = true
intros x y Hxy.x, y:R
Hxy:x = y
Req_bool x y = true
case Req_bool_spec ; intros H.x, y:R
Hxy, H:x = y
true = true
x, y:R
Hxy:x = y
H:x <> y
false = true
apply refl_equal.x, y:R
Hxy:x = y
H:x <> y
false = true
contradict H.x, y:R
Hxy:x = y
x = y
exact Hxy.
Qed.

Theorem Req_bool_false :
  forall x y,
  (x <> y)%R -> Req_bool x y = false.forall x y : R, x <> y -> Req_bool x y = false
Proof.forall x y : R, x <> y -> Req_bool x y = false
intros x y Hxy.x, y:R
Hxy:x <> y
Req_bool x y = false
case Req_bool_spec ; intros H.x, y:R
Hxy:x <> y
H:x = y
true = false
x, y:R
Hxy, H:x <> y
false = false
contradict Hxy.x, y:R
H:x = y
x = y
x, y:R
Hxy, H:x <> y
false = false
exact H.x, y:R
Hxy, H:x <> y
false = false
apply refl_equal.
Qed.

End Req_bool.

Section Floor_Ceil.

Zfloor and Zceil

Definition Zfloor (x : R) := (up x - 1)%Z.

Theorem Zfloor_lb :
  forall x : R,
  (IZR (Zfloor x) <= x)%R.forall x : R, (IZR (Zfloor x) <= x)%R
Proof.forall x : R, (IZR (Zfloor x) <= x)%R
intros x.x:R
(IZR (Zfloor x) <= x)%R
unfold Zfloor.x:R
(IZR (up x - 1) <= x)%R
rewrite minus_IZR.x:R
(IZR (up x) - 1 <= x)%R
simpl.x:R
(IZR (up x) - 1 <= x)%R
apply Rplus_le_reg_r with (1 - x)%R.x:R
(IZR (up x) - 1 + (1 - x) <= x + (1 - x))%R
ring_simplify.x:R
(IZR (up x) - x <= 1)%R
exact (proj2 (archimed x)).
Qed.

Theorem Zfloor_ub :
  forall x : R,
  (x < IZR (Zfloor x) + 1)%R.forall x : R, (x < IZR (Zfloor x) + 1)%R
Proof.forall x : R, (x < IZR (Zfloor x) + 1)%R
intros x.x:R
(x < IZR (Zfloor x) + 1)%R
unfold Zfloor.x:R
(x < IZR (up x - 1) + 1)%R
rewrite minus_IZR.x:R
(x < IZR (up x) - 1 + 1)%R
unfold Rminus.x:R
(x < IZR (up x) + - (1) + 1)%R
rewrite Rplus_assoc.x:R
(x < IZR (up x) + (- (1) + 1))%R
rewrite Rplus_opp_l, Rplus_0_r.x:R
(x < IZR (up x))%R
exact (proj1 (archimed x)).
Qed.

Theorem Zfloor_lub :
  forall n x,
  (IZR n <= x)%R ->
  (n <= Zfloor x)%Z.forall (n : Z) (x : R),
(IZR n <= x)%R -> (n <= Zfloor x)%Z
Proof.forall (n : Z) (x : R),
(IZR n <= x)%R -> (n <= Zfloor x)%Z
intros n x Hnx.n:Z
x:R
Hnx:(IZR n <= x)%R
(n <= Zfloor x)%Z
apply Zlt_succ_le.n:Z
x:R
Hnx:(IZR n <= x)%R
(n < Z.succ (Zfloor x))%Z
apply lt_IZR.n:Z
x:R
Hnx:(IZR n <= x)%R
(IZR n < IZR (Z.succ (Zfloor x)))%R
apply Rle_lt_trans with (1 := Hnx).n:Z
x:R
Hnx:(IZR n <= x)%R
(x < IZR (Z.succ (Zfloor x)))%R
unfold Z.succ.n:Z
x:R
Hnx:(IZR n <= x)%R
(x < IZR (Zfloor x + 1))%R
rewrite plus_IZR.n:Z
x:R
Hnx:(IZR n <= x)%R
(x < IZR (Zfloor x) + 1)%R
apply Zfloor_ub.
Qed.

Theorem Zfloor_imp :
  forall n x,
  (IZR n <= x < IZR (n + 1))%R ->
  Zfloor x = n.forall (n : Z) (x : R),
(IZR n <= x < IZR (n + 1))%R -> Zfloor x = n
Proof.forall (n : Z) (x : R),
(IZR n <= x < IZR (n + 1))%R -> Zfloor x = n
intros n x Hnx.n:Z
x:R
Hnx:(IZR n <= x < IZR (n + 1))%R
Zfloor x = n
apply Zle_antisym.n:Z
x:R
Hnx:(IZR n <= x < IZR (n + 1))%R
(Zfloor x <= n)%Z
n:Z
x:R
Hnx:(IZR n <= x < IZR (n + 1))%R
(n <= Zfloor x)%Z
apply Zlt_succ_le.n:Z
x:R
Hnx:(IZR n <= x < IZR (n + 1))%R
(Zfloor x < Z.succ n)%Z
n:Z
x:R
Hnx:(IZR n <= x < IZR (n + 1))%R
(n <= Zfloor x)%Z
apply lt_IZR.n:Z
x:R
Hnx:(IZR n <= x < IZR (n + 1))%R
(IZR (Zfloor x) < IZR (Z.succ n))%R
n:Z
x:R
Hnx:(IZR n <= x < IZR (n + 1))%R
(n <= Zfloor x)%Z
apply Rle_lt_trans with (2 := proj2 Hnx).n:Z
x:R
Hnx:(IZR n <= x < IZR (n + 1))%R
(IZR (Zfloor x) <= x)%R
n:Z
x:R
Hnx:(IZR n <= x < IZR (n + 1))%R
(n <= Zfloor x)%Z
apply Zfloor_lb.n:Z
x:R
Hnx:(IZR n <= x < IZR (n + 1))%R
(n <= Zfloor x)%Z
now apply Zfloor_lub.
Qed.

Theorem Zfloor_IZR :
  forall n,
  Zfloor (IZR n) = n.forall n : Z, Zfloor (IZR n) = n
Proof.forall n : Z, Zfloor (IZR n) = n
intros n.n:Z
Zfloor (IZR n) = n
apply Zfloor_imp.n:Z
(IZR n <= IZR n < IZR (n + 1))%R
split.n:Z
(IZR n <= IZR n)%R
n:Z
(IZR n < IZR (n + 1))%R
apply Rle_refl.n:Z
(IZR n < IZR (n + 1))%R
apply IZR_lt.n:Z
(n < n + 1)%Z
apply Zlt_succ.
Qed.

Theorem Zfloor_le :
  forall x y, (x <= y)%R ->
  (Zfloor x <= Zfloor y)%Z.forall x y : R, (x <= y)%R -> (Zfloor x <= Zfloor y)%Z
Proof.forall x y : R, (x <= y)%R -> (Zfloor x <= Zfloor y)%Z
intros x y Hxy.x, y:R
Hxy:(x <= y)%R
(Zfloor x <= Zfloor y)%Z
apply Zfloor_lub.x, y:R
Hxy:(x <= y)%R
(IZR (Zfloor x) <= y)%R
apply Rle_trans with (2 := Hxy).x, y:R
Hxy:(x <= y)%R
(IZR (Zfloor x) <= x)%R
apply Zfloor_lb.
Qed.

Definition Zceil (x : R) := (- Zfloor (- x))%Z.

Theorem Zceil_ub :
  forall x : R,
  (x <= IZR (Zceil x))%R.forall x : R, (x <= IZR (Zceil x))%R
Proof.forall x : R, (x <= IZR (Zceil x))%R
intros x.x:R
(x <= IZR (Zceil x))%R
unfold Zceil.x:R
(x <= IZR (- Zfloor (- x)))%R
rewrite opp_IZR.x:R
(x <= - IZR (Zfloor (- x)))%R
apply Ropp_le_cancel.x:R
(- - IZR (Zfloor (- x)) <= - x)%R
rewrite Ropp_involutive.x:R
(IZR (Zfloor (- x)) <= - x)%R
apply Zfloor_lb.
Qed.

Theorem Zceil_lb :
  forall x : R,
  (IZR (Zceil x) < x + 1)%R.forall x : R, (IZR (Zceil x) < x + 1)%R
Proof.forall x : R, (IZR (Zceil x) < x + 1)%R
intros x.x:R
(IZR (Zceil x) < x + 1)%R
unfold Zceil.x:R
(IZR (- Zfloor (- x)) < x + 1)%R
rewrite opp_IZR.x:R
(- IZR (Zfloor (- x)) < x + 1)%R
rewrite <-(Ropp_involutive (x + 1)), Ropp_plus_distr.x:R
(- IZR (Zfloor (- x)) < - (- x + - (1)))%R
apply Ropp_lt_contravar, (Rplus_lt_reg_r 1); ring_simplify.x:R
(- x < IZR (Zfloor (- x)) + 1)%R
apply Zfloor_ub.
Qed.

Theorem Zceil_glb :
  forall n x,
  (x <= IZR n)%R ->
  (Zceil x <= n)%Z.forall (n : Z) (x : R),
(x <= IZR n)%R -> (Zceil x <= n)%Z
Proof.forall (n : Z) (x : R),
(x <= IZR n)%R -> (Zceil x <= n)%Z
intros n x Hnx.n:Z
x:R
Hnx:(x <= IZR n)%R
(Zceil x <= n)%Z
unfold Zceil.n:Z
x:R
Hnx:(x <= IZR n)%R
(- Zfloor (- x) <= n)%Z
apply Zopp_le_cancel.n:Z
x:R
Hnx:(x <= IZR n)%R
(- n <= - - Zfloor (- x))%Z
rewrite Z.opp_involutive.n:Z
x:R
Hnx:(x <= IZR n)%R
(- n <= Zfloor (- x))%Z
apply Zfloor_lub.n:Z
x:R
Hnx:(x <= IZR n)%R
(IZR (- n) <= - x)%R
rewrite opp_IZR.n:Z
x:R
Hnx:(x <= IZR n)%R
(- IZR n <= - x)%R
now apply Ropp_le_contravar.
Qed.

Theorem Zceil_imp :
  forall n x,
  (IZR (n - 1) < x <= IZR n)%R ->
  Zceil x = n.forall (n : Z) (x : R),
(IZR (n - 1) < x <= IZR n)%R -> Zceil x = n
Proof.forall (n : Z) (x : R),
(IZR (n - 1) < x <= IZR n)%R -> Zceil x = n
intros n x Hnx.n:Z
x:R
Hnx:(IZR (n - 1) < x <= IZR n)%R
Zceil x = n
unfold Zceil.n:Z
x:R
Hnx:(IZR (n - 1) < x <= IZR n)%R
(- Zfloor (- x))%Z = n
rewrite <- (Z.opp_involutive n).n:Z
x:R
Hnx:(IZR (n - 1) < x <= IZR n)%R
(- Zfloor (- x))%Z = (- - n)%Z
apply f_equal.n:Z
x:R
Hnx:(IZR (n - 1) < x <= IZR n)%R
Zfloor (- x) = (- n)%Z
apply Zfloor_imp.n:Z
x:R
Hnx:(IZR (n - 1) < x <= IZR n)%R
(IZR (- n) <= - x < IZR (- n + 1))%R
split.n:Z
x:R
Hnx:(IZR (n - 1) < x <= IZR n)%R
(IZR (- n) <= - x)%R
n:Z
x:R
Hnx:(IZR (n - 1) < x <= IZR n)%R
(- x < IZR (- n + 1))%R
rewrite opp_IZR.n:Z
x:R
Hnx:(IZR (n - 1) < x <= IZR n)%R
(- IZR n <= - x)%R
n:Z
x:R
Hnx:(IZR (n - 1) < x <= IZR n)%R
(- x < IZR (- n + 1))%R
now apply Ropp_le_contravar.n:Z
x:R
Hnx:(IZR (n - 1) < x <= IZR n)%R
(- x < IZR (- n + 1))%R
rewrite <- (Z.opp_involutive 1).n:Z
x:R
Hnx:(IZR (n - 1) < x <= IZR n)%R
(- x < IZR (- n + - - (1)))%R
rewrite <- Zopp_plus_distr.n:Z
x:R
Hnx:(IZR (n - 1) < x <= IZR n)%R
(- x < IZR (- (n + - (1))))%R
rewrite opp_IZR.n:Z
x:R
Hnx:(IZR (n - 1) < x <= IZR n)%R
(- x < - IZR (n + - (1)))%R
now apply Ropp_lt_contravar.
Qed.

Theorem Zceil_IZR :
  forall n,
  Zceil (IZR n) = n.forall n : Z, Zceil (IZR n) = n
Proof.forall n : Z, Zceil (IZR n) = n
intros n.n:Z
Zceil (IZR n) = n
unfold Zceil.n:Z
(- Zfloor (- IZR n))%Z = n
rewrite <- opp_IZR, Zfloor_IZR.n:Z
(- - n)%Z = n
apply Z.opp_involutive.
Qed.

Theorem Zceil_le :
  forall x y, (x <= y)%R ->
  (Zceil x <= Zceil y)%Z.forall x y : R, (x <= y)%R -> (Zceil x <= Zceil y)%Z
Proof.forall x y : R, (x <= y)%R -> (Zceil x <= Zceil y)%Z
intros x y Hxy.x, y:R
Hxy:(x <= y)%R
(Zceil x <= Zceil y)%Z
apply Zceil_glb.x, y:R
Hxy:(x <= y)%R
(x <= IZR (Zceil y))%R
apply Rle_trans with (1 := Hxy).x, y:R
Hxy:(x <= y)%R
(y <= IZR (Zceil y))%R
apply Zceil_ub.
Qed.

Theorem Zceil_floor_neq :
  forall x : R,
  (IZR (Zfloor x) <> x)%R ->
  (Zceil x = Zfloor x + 1)%Z.forall x : R,
IZR (Zfloor x) <> x -> Zceil x = (Zfloor x + 1)%Z
Proof.forall x : R,
IZR (Zfloor x) <> x -> Zceil x = (Zfloor x + 1)%Z
intros x Hx.x:R
Hx:IZR (Zfloor x) <> x
Zceil x = (Zfloor x + 1)%Z
apply Zceil_imp.x:R
Hx:IZR (Zfloor x) <> x
(IZR (Zfloor x + 1 - 1) < x <= IZR (Zfloor x + 1))%R
split.x:R
Hx:IZR (Zfloor x) <> x
(IZR (Zfloor x + 1 - 1) < x)%R
x:R
Hx:IZR (Zfloor x) <> x
(x <= IZR (Zfloor x + 1))%R
ring_simplify (Zfloor x + 1 - 1)%Z.x:R
Hx:IZR (Zfloor x) <> x
(IZR (Zfloor x) < x)%R
x:R
Hx:IZR (Zfloor x) <> x
(x <= IZR (Zfloor x + 1))%R
apply Rnot_le_lt.x:R
Hx:IZR (Zfloor x) <> x
~ (x <= IZR (Zfloor x))%R
x:R
Hx:IZR (Zfloor x) <> x
(x <= IZR (Zfloor x + 1))%R
intros H.x:R
Hx:IZR (Zfloor x) <> x
H:(x <= IZR (Zfloor x))%R
False
x:R
Hx:IZR (Zfloor x) <> x
(x <= IZR (Zfloor x + 1))%R
apply Hx.x:R
Hx:IZR (Zfloor x) <> x
H:(x <= IZR (Zfloor x))%R
IZR (Zfloor x) = x
x:R
Hx:IZR (Zfloor x) <> x
(x <= IZR (Zfloor x + 1))%R
apply Rle_antisym.x:R
Hx:IZR (Zfloor x) <> x
H:(x <= IZR (Zfloor x))%R
(IZR (Zfloor x) <= x)%R
x:R
Hx:IZR (Zfloor x) <> x
H:(x <= IZR (Zfloor x))%R
(x <= IZR (Zfloor x))%R
x:R
Hx:IZR (Zfloor x) <> x
(x <= IZR (Zfloor x + 1))%R
apply Zfloor_lb.x:R
Hx:IZR (Zfloor x) <> x
H:(x <= IZR (Zfloor x))%R
(x <= IZR (Zfloor x))%R
x:R
Hx:IZR (Zfloor x) <> x
(x <= IZR (Zfloor x + 1))%R
exact H.x:R
Hx:IZR (Zfloor x) <> x
(x <= IZR (Zfloor x + 1))%R
apply Rlt_le.x:R
Hx:IZR (Zfloor x) <> x
(x < IZR (Zfloor x + 1))%R
rewrite plus_IZR.x:R
Hx:IZR (Zfloor x) <> x
(x < IZR (Zfloor x) + 1)%R
apply Zfloor_ub.
Qed.

Definition Ztrunc x := if Rlt_bool x 0 then Zceil x else Zfloor x.

Theorem Ztrunc_IZR :
  forall n,
  Ztrunc (IZR n) = n.forall n : Z, Ztrunc (IZR n) = n
Proof.forall n : Z, Ztrunc (IZR n) = n
intros n.n:Z
Ztrunc (IZR n) = n
unfold Ztrunc.n:Z
(if Rlt_bool (IZR n) 0
 then Zceil (IZR n)
 else Zfloor (IZR n)) = n
case Rlt_bool_spec ; intro H.n:Z
H:(IZR n < 0)%R
Zceil (IZR n) = n
n:Z
H:(0 <= IZR n)%R
Zfloor (IZR n) = n
apply Zceil_IZR.n:Z
H:(0 <= IZR n)%R
Zfloor (IZR n) = n
apply Zfloor_IZR.
Qed.

Theorem Ztrunc_floor :
  forall x,
  (0 <= x)%R ->
  Ztrunc x = Zfloor x.forall x : R, (0 <= x)%R -> Ztrunc x = Zfloor x
Proof.forall x : R, (0 <= x)%R -> Ztrunc x = Zfloor x
intros x Hx.x:R
Hx:(0 <= x)%R
Ztrunc x = Zfloor x
unfold Ztrunc.x:R
Hx:(0 <= x)%R
(if Rlt_bool x 0 then Zceil x else Zfloor x) =
Zfloor x
case Rlt_bool_spec ; intro H.x:R
Hx:(0 <= x)%R
H:(x < 0)%R
Zceil x = Zfloor x
x:R
Hx, H:(0 <= x)%R
Zfloor x = Zfloor x
elim Rlt_irrefl with x.x:R
Hx:(0 <= x)%R
H:(x < 0)%R
(x < x)%R
x:R
Hx, H:(0 <= x)%R
Zfloor x = Zfloor x
now apply Rlt_le_trans with R0.x:R
Hx, H:(0 <= x)%R
Zfloor x = Zfloor x
apply refl_equal.
Qed.

Theorem Ztrunc_ceil :
  forall x,
  (x <= 0)%R ->
  Ztrunc x = Zceil x.forall x : R, (x <= 0)%R -> Ztrunc x = Zceil x
Proof.forall x : R, (x <= 0)%R -> Ztrunc x = Zceil x
intros x Hx.x:R
Hx:(x <= 0)%R
Ztrunc x = Zceil x
unfold Ztrunc.x:R
Hx:(x <= 0)%R
(if Rlt_bool x 0 then Zceil x else Zfloor x) = Zceil x
case Rlt_bool_spec ; intro H.x:R
Hx:(x <= 0)%R
H:(x < 0)%R
Zceil x = Zceil x
x:R
Hx:(x <= 0)%R
H:(0 <= x)%R
Zfloor x = Zceil x
apply refl_equal.x:R
Hx:(x <= 0)%R
H:(0 <= x)%R
Zfloor x = Zceil x
rewrite (Rle_antisym _ _ Hx H).x:R
Hx:(x <= 0)%R
H:(0 <= x)%R
Zfloor 0 = Zceil 0
rewrite Zceil_IZR.x:R
Hx:(x <= 0)%R
H:(0 <= x)%R
Zfloor 0 = 0%Z
apply Zfloor_IZR.
Qed.

Theorem Ztrunc_le :
  forall x y, (x <= y)%R ->
  (Ztrunc x <= Ztrunc y)%Z.forall x y : R, (x <= y)%R -> (Ztrunc x <= Ztrunc y)%Z
Proof.forall x y : R, (x <= y)%R -> (Ztrunc x <= Ztrunc y)%Z
intros x y Hxy.x, y:R
Hxy:(x <= y)%R
(Ztrunc x <= Ztrunc y)%Z
unfold Ztrunc at 1.x, y:R
Hxy:(x <= y)%R
((if Rlt_bool x 0 then Zceil x else Zfloor x) <=
 Ztrunc y)%Z
case Rlt_bool_spec ; intro Hx.x, y:R
Hxy:(x <= y)%R
Hx:(x < 0)%R
(Zceil x <= Ztrunc y)%Z
x, y:R
Hxy:(x <= y)%R
Hx:(0 <= x)%R
(Zfloor x <= Ztrunc y)%Z
unfold Ztrunc.x, y:R
Hxy:(x <= y)%R
Hx:(x < 0)%R
(Zceil x <=
 (if Rlt_bool y 0 then Zceil y else Zfloor y))%Z
x, y:R
Hxy:(x <= y)%R
Hx:(0 <= x)%R
(Zfloor x <= Ztrunc y)%Z
case Rlt_bool_spec ; intro Hy.x, y:R
Hxy:(x <= y)%R
Hx:(x < 0)%R
Hy:(y < 0)%R
(Zceil x <= Zceil y)%Z
x, y:R
Hxy:(x <= y)%R
Hx:(x < 0)%R
Hy:(0 <= y)%R
(Zceil x <= Zfloor y)%Z
x, y:R
Hxy:(x <= y)%R
Hx:(0 <= x)%R
(Zfloor x <= Ztrunc y)%Z
now apply Zceil_le.x, y:R
Hxy:(x <= y)%R
Hx:(x < 0)%R
Hy:(0 <= y)%R
(Zceil x <= Zfloor y)%Z
x, y:R
Hxy:(x <= y)%R
Hx:(0 <= x)%R
(Zfloor x <= Ztrunc y)%Z
apply Z.le_trans with 0%Z.x, y:R
Hxy:(x <= y)%R
Hx:(x < 0)%R
Hy:(0 <= y)%R
(Zceil x <= 0)%Z
x, y:R
Hxy:(x <= y)%R
Hx:(x < 0)%R
Hy:(0 <= y)%R
(0 <= Zfloor y)%Z
x, y:R
Hxy:(x <= y)%R
Hx:(0 <= x)%R
(Zfloor x <= Ztrunc y)%Z
apply Zceil_glb.x, y:R
Hxy:(x <= y)%R
Hx:(x < 0)%R
Hy:(0 <= y)%R
(x <= 0)%R
x, y:R
Hxy:(x <= y)%R
Hx:(x < 0)%R
Hy:(0 <= y)%R
(0 <= Zfloor y)%Z
x, y:R
Hxy:(x <= y)%R
Hx:(0 <= x)%R
(Zfloor x <= Ztrunc y)%Z
now apply Rlt_le.x, y:R
Hxy:(x <= y)%R
Hx:(x < 0)%R
Hy:(0 <= y)%R
(0 <= Zfloor y)%Z
x, y:R
Hxy:(x <= y)%R
Hx:(0 <= x)%R
(Zfloor x <= Ztrunc y)%Z
now apply Zfloor_lub.x, y:R
Hxy:(x <= y)%R
Hx:(0 <= x)%R
(Zfloor x <= Ztrunc y)%Z
rewrite Ztrunc_floor.x, y:R
Hxy:(x <= y)%R
Hx:(0 <= x)%R
(Zfloor x <= Zfloor y)%Z
x, y:R
Hxy:(x <= y)%R
Hx:(0 <= x)%R
(0 <= y)%R
now apply Zfloor_le.x, y:R
Hxy:(x <= y)%R
Hx:(0 <= x)%R
(0 <= y)%R
now apply Rle_trans with x.
Qed.

Theorem Ztrunc_opp :
  forall x,
  Ztrunc (- x) = Z.opp (Ztrunc x).forall x : R, Ztrunc (- x) = (- Ztrunc x)%Z
Proof.forall x : R, Ztrunc (- x) = (- Ztrunc x)%Z
intros x.x:R
Ztrunc (- x) = (- Ztrunc x)%Z
unfold Ztrunc at 2.x:R
Ztrunc (- x) =
(- (if Rlt_bool x 0 then Zceil x else Zfloor x))%Z
case Rlt_bool_spec ; intros Hx.x:R
Hx:(x < 0)%R
Ztrunc (- x) = (- Zceil x)%Z
x:R
Hx:(0 <= x)%R
Ztrunc (- x) = (- Zfloor x)%Z
rewrite Ztrunc_floor.x:R
Hx:(x < 0)%R
Zfloor (- x) = (- Zceil x)%Z
x:R
Hx:(x < 0)%R
(0 <= - x)%R
x:R
Hx:(0 <= x)%R
Ztrunc (- x) = (- Zfloor x)%Z
apply sym_eq.x:R
Hx:(x < 0)%R
(- Zceil x)%Z = Zfloor (- x)
x:R
Hx:(x < 0)%R
(0 <= - x)%R
x:R
Hx:(0 <= x)%R
Ztrunc (- x) = (- Zfloor x)%Z
apply Z.opp_involutive.x:R
Hx:(x < 0)%R
(0 <= - x)%R
x:R
Hx:(0 <= x)%R
Ztrunc (- x) = (- Zfloor x)%Z
rewrite <- Ropp_0.x:R
Hx:(x < 0)%R
(- 0 <= - x)%R
x:R
Hx:(0 <= x)%R
Ztrunc (- x) = (- Zfloor x)%Z
apply Ropp_le_contravar.x:R
Hx:(x < 0)%R
(x <= 0)%R
x:R
Hx:(0 <= x)%R
Ztrunc (- x) = (- Zfloor x)%Z
now apply Rlt_le.x:R
Hx:(0 <= x)%R
Ztrunc (- x) = (- Zfloor x)%Z
rewrite Ztrunc_ceil.x:R
Hx:(0 <= x)%R
Zceil (- x) = (- Zfloor x)%Z
x:R
Hx:(0 <= x)%R
(- x <= 0)%R
unfold Zceil.x:R
Hx:(0 <= x)%R
(- Zfloor (- - x))%Z = (- Zfloor x)%Z
x:R
Hx:(0 <= x)%R
(- x <= 0)%R
now rewrite Ropp_involutive.x:R
Hx:(0 <= x)%R
(- x <= 0)%R
rewrite <- Ropp_0.x:R
Hx:(0 <= x)%R
(- x <= - 0)%R
now apply Ropp_le_contravar.
Qed.

Theorem Ztrunc_abs :
  forall x,
  Ztrunc (Rabs x) = Z.abs (Ztrunc x).forall x : R, Ztrunc (Rabs x) = Z.abs (Ztrunc x)
Proof.forall x : R, Ztrunc (Rabs x) = Z.abs (Ztrunc x)
intros x.x:R
Ztrunc (Rabs x) = Z.abs (Ztrunc x)
rewrite Ztrunc_floor.x:R
Zfloor (Rabs x) = Z.abs (Ztrunc x)
x:R
(0 <= Rabs x)%R 2: apply Rabs_pos.x:R
Zfloor (Rabs x) = Z.abs (Ztrunc x)
unfold Ztrunc.x:R
Zfloor (Rabs x) =
Z.abs (if Rlt_bool x 0 then Zceil x else Zfloor x)
case Rlt_bool_spec ; intro H.x:R
H:(x < 0)%R
Zfloor (Rabs x) = Z.abs (Zceil x)
x:R
H:(0 <= x)%R
Zfloor (Rabs x) = Z.abs (Zfloor x)
rewrite Rabs_left with (1 := H).x:R
H:(x < 0)%R
Zfloor (- x) = Z.abs (Zceil x)
x:R
H:(0 <= x)%R
Zfloor (Rabs x) = Z.abs (Zfloor x)
rewrite Zabs_non_eq.x:R
H:(x < 0)%R
Zfloor (- x) = (- Zceil x)%Z
x:R
H:(x < 0)%R
(Zceil x <= 0)%Z
x:R
H:(0 <= x)%R
Zfloor (Rabs x) = Z.abs (Zfloor x)
apply sym_eq.x:R
H:(x < 0)%R
(- Zceil x)%Z = Zfloor (- x)
x:R
H:(x < 0)%R
(Zceil x <= 0)%Z
x:R
H:(0 <= x)%R
Zfloor (Rabs x) = Z.abs (Zfloor x)
apply Z.opp_involutive.x:R
H:(x < 0)%R
(Zceil x <= 0)%Z
x:R
H:(0 <= x)%R
Zfloor (Rabs x) = Z.abs (Zfloor x)
apply Zceil_glb.x:R
H:(x < 0)%R
(x <= 0)%R
x:R
H:(0 <= x)%R
Zfloor (Rabs x) = Z.abs (Zfloor x)
now apply Rlt_le.x:R
H:(0 <= x)%R
Zfloor (Rabs x) = Z.abs (Zfloor x)
rewrite Rabs_pos_eq with (1 := H).x:R
H:(0 <= x)%R
Zfloor x = Z.abs (Zfloor x)
apply sym_eq.x:R
H:(0 <= x)%R
Z.abs (Zfloor x) = Zfloor x
apply Z.abs_eq.x:R
H:(0 <= x)%R
(0 <= Zfloor x)%Z
now apply Zfloor_lub.
Qed.

Theorem Ztrunc_lub :
  forall n x,
  (IZR n <= Rabs x)%R ->
  (n <= Z.abs (Ztrunc x))%Z.forall (n : Z) (x : R),
(IZR n <= Rabs x)%R -> (n <= Z.abs (Ztrunc x))%Z
Proof.forall (n : Z) (x : R),
(IZR n <= Rabs x)%R -> (n <= Z.abs (Ztrunc x))%Z
intros n x H.n:Z
x:R
H:(IZR n <= Rabs x)%R
(n <= Z.abs (Ztrunc x))%Z
rewrite <- Ztrunc_abs.n:Z
x:R
H:(IZR n <= Rabs x)%R
(n <= Ztrunc (Rabs x))%Z
rewrite Ztrunc_floor.n:Z
x:R
H:(IZR n <= Rabs x)%R
(n <= Zfloor (Rabs x))%Z
n:Z
x:R
H:(IZR n <= Rabs x)%R
(0 <= Rabs x)%R 2: apply Rabs_pos.n:Z
x:R
H:(IZR n <= Rabs x)%R
(n <= Zfloor (Rabs x))%Z
now apply Zfloor_lub.
Qed.

Definition Zaway x := if Rlt_bool x 0 then Zfloor x else Zceil x.

Theorem Zaway_IZR :
  forall n,
  Zaway (IZR n) = n.forall n : Z, Zaway (IZR n) = n
Proof.forall n : Z, Zaway (IZR n) = n
intros n.n:Z
Zaway (IZR n) = n
unfold Zaway.n:Z
(if Rlt_bool (IZR n) 0
 then Zfloor (IZR n)
 else Zceil (IZR n)) = n
case Rlt_bool_spec ; intro H.n:Z
H:(IZR n < 0)%R
Zfloor (IZR n) = n
n:Z
H:(0 <= IZR n)%R
Zceil (IZR n) = n
apply Zfloor_IZR.n:Z
H:(0 <= IZR n)%R
Zceil (IZR n) = n
apply Zceil_IZR.
Qed.

Theorem Zaway_ceil :
  forall x,
  (0 <= x)%R ->
  Zaway x = Zceil x.forall x : R, (0 <= x)%R -> Zaway x = Zceil x
Proof.forall x : R, (0 <= x)%R -> Zaway x = Zceil x
intros x Hx.x:R
Hx:(0 <= x)%R
Zaway x = Zceil x
unfold Zaway.x:R
Hx:(0 <= x)%R
(if Rlt_bool x 0 then Zfloor x else Zceil x) = Zceil x
case Rlt_bool_spec ; intro H.x:R
Hx:(0 <= x)%R
H:(x < 0)%R
Zfloor x = Zceil x
x:R
Hx, H:(0 <= x)%R
Zceil x = Zceil x
elim Rlt_irrefl with x.x:R
Hx:(0 <= x)%R
H:(x < 0)%R
(x < x)%R
x:R
Hx, H:(0 <= x)%R
Zceil x = Zceil x
now apply Rlt_le_trans with R0.x:R
Hx, H:(0 <= x)%R
Zceil x = Zceil x
apply refl_equal.
Qed.

Theorem Zaway_floor :
  forall x,
  (x <= 0)%R ->
  Zaway x = Zfloor x.forall x : R, (x <= 0)%R -> Zaway x = Zfloor x
Proof.forall x : R, (x <= 0)%R -> Zaway x = Zfloor x
intros x Hx.x:R
Hx:(x <= 0)%R
Zaway x = Zfloor x
unfold Zaway.x:R
Hx:(x <= 0)%R
(if Rlt_bool x 0 then Zfloor x else Zceil x) =
Zfloor x
case Rlt_bool_spec ; intro H.x:R
Hx:(x <= 0)%R
H:(x < 0)%R
Zfloor x = Zfloor x
x:R
Hx:(x <= 0)%R
H:(0 <= x)%R
Zceil x = Zfloor x
apply refl_equal.x:R
Hx:(x <= 0)%R
H:(0 <= x)%R
Zceil x = Zfloor x
rewrite (Rle_antisym _ _ Hx H).x:R
Hx:(x <= 0)%R
H:(0 <= x)%R
Zceil 0 = Zfloor 0
rewrite Zfloor_IZR.x:R
Hx:(x <= 0)%R
H:(0 <= x)%R
Zceil 0 = 0%Z
apply Zceil_IZR.
Qed.

Theorem Zaway_le :
  forall x y, (x <= y)%R ->
  (Zaway x <= Zaway y)%Z.forall x y : R, (x <= y)%R -> (Zaway x <= Zaway y)%Z
Proof.forall x y : R, (x <= y)%R -> (Zaway x <= Zaway y)%Z
intros x y Hxy.x, y:R
Hxy:(x <= y)%R
(Zaway x <= Zaway y)%Z
unfold Zaway at 1.x, y:R
Hxy:(x <= y)%R
((if Rlt_bool x 0 then Zfloor x else Zceil x) <=
 Zaway y)%Z
case Rlt_bool_spec ; intro Hx.x, y:R
Hxy:(x <= y)%R
Hx:(x < 0)%R
(Zfloor x <= Zaway y)%Z
x, y:R
Hxy:(x <= y)%R
Hx:(0 <= x)%R
(Zceil x <= Zaway y)%Z
unfold Zaway.x, y:R
Hxy:(x <= y)%R
Hx:(x < 0)%R
(Zfloor x <=
 (if Rlt_bool y 0 then Zfloor y else Zceil y))%Z
x, y:R
Hxy:(x <= y)%R
Hx:(0 <= x)%R
(Zceil x <= Zaway y)%Z
case Rlt_bool_spec ; intro Hy.x, y:R
Hxy:(x <= y)%R
Hx:(x < 0)%R
Hy:(y < 0)%R
(Zfloor x <= Zfloor y)%Z
x, y:R
Hxy:(x <= y)%R
Hx:(x < 0)%R
Hy:(0 <= y)%R
(Zfloor x <= Zceil y)%Z
x, y:R
Hxy:(x <= y)%R
Hx:(0 <= x)%R
(Zceil x <= Zaway y)%Z
now apply Zfloor_le.x, y:R
Hxy:(x <= y)%R
Hx:(x < 0)%R
Hy:(0 <= y)%R
(Zfloor x <= Zceil y)%Z
x, y:R
Hxy:(x <= y)%R
Hx:(0 <= x)%R
(Zceil x <= Zaway y)%Z
apply le_IZR.x, y:R
Hxy:(x <= y)%R
Hx:(x < 0)%R
Hy:(0 <= y)%R
(IZR (Zfloor x) <= IZR (Zceil y))%R
x, y:R
Hxy:(x <= y)%R
Hx:(0 <= x)%R
(Zceil x <= Zaway y)%Z
apply Rle_trans with 0%R.x, y:R
Hxy:(x <= y)%R
Hx:(x < 0)%R
Hy:(0 <= y)%R
(IZR (Zfloor x) <= 0)%R
x, y:R
Hxy:(x <= y)%R
Hx:(x < 0)%R
Hy:(0 <= y)%R
(0 <= IZR (Zceil y))%R
x, y:R
Hxy:(x <= y)%R
Hx:(0 <= x)%R
(Zceil x <= Zaway y)%Z
apply Rlt_le.x, y:R
Hxy:(x <= y)%R
Hx:(x < 0)%R
Hy:(0 <= y)%R
(IZR (Zfloor x) < 0)%R
x, y:R
Hxy:(x <= y)%R
Hx:(x < 0)%R
Hy:(0 <= y)%R
(0 <= IZR (Zceil y))%R
x, y:R
Hxy:(x <= y)%R
Hx:(0 <= x)%R
(Zceil x <= Zaway y)%Z
apply Rle_lt_trans with (2 := Hx).x, y:R
Hxy:(x <= y)%R
Hx:(x < 0)%R
Hy:(0 <= y)%R
(IZR (Zfloor x) <= x)%R
x, y:R
Hxy:(x <= y)%R
Hx:(x < 0)%R
Hy:(0 <= y)%R
(0 <= IZR (Zceil y))%R
x, y:R
Hxy:(x <= y)%R
Hx:(0 <= x)%R
(Zceil x <= Zaway y)%Z
apply Zfloor_lb.x, y:R
Hxy:(x <= y)%R
Hx:(x < 0)%R
Hy:(0 <= y)%R
(0 <= IZR (Zceil y))%R
x, y:R
Hxy:(x <= y)%R
Hx:(0 <= x)%R
(Zceil x <= Zaway y)%Z
apply Rle_trans with (1 := Hy).x, y:R
Hxy:(x <= y)%R
Hx:(x < 0)%R
Hy:(0 <= y)%R
(y <= IZR (Zceil y))%R
x, y:R
Hxy:(x <= y)%R
Hx:(0 <= x)%R
(Zceil x <= Zaway y)%Z
apply Zceil_ub.x, y:R
Hxy:(x <= y)%R
Hx:(0 <= x)%R
(Zceil x <= Zaway y)%Z
rewrite Zaway_ceil.x, y:R
Hxy:(x <= y)%R
Hx:(0 <= x)%R
(Zceil x <= Zceil y)%Z
x, y:R
Hxy:(x <= y)%R
Hx:(0 <= x)%R
(0 <= y)%R
now apply Zceil_le.x, y:R
Hxy:(x <= y)%R
Hx:(0 <= x)%R
(0 <= y)%R
now apply Rle_trans with x.
Qed.

Theorem Zaway_opp :
  forall x,
  Zaway (- x) = Z.opp (Zaway x).forall x : R, Zaway (- x) = (- Zaway x)%Z
Proof.forall x : R, Zaway (- x) = (- Zaway x)%Z
intros x.x:R
Zaway (- x) = (- Zaway x)%Z
unfold Zaway at 2.x:R
Zaway (- x) =
(- (if Rlt_bool x 0 then Zfloor x else Zceil x))%Z
case Rlt_bool_spec ; intro H.x:R
H:(x < 0)%R
Zaway (- x) = (- Zfloor x)%Z
x:R
H:(0 <= x)%R
Zaway (- x) = (- Zceil x)%Z
rewrite Zaway_ceil.x:R
H:(x < 0)%R
Zceil (- x) = (- Zfloor x)%Z
x:R
H:(x < 0)%R
(0 <= - x)%R
x:R
H:(0 <= x)%R
Zaway (- x) = (- Zceil x)%Z
unfold Zceil.x:R
H:(x < 0)%R
(- Zfloor (- - x))%Z = (- Zfloor x)%Z
x:R
H:(x < 0)%R
(0 <= - x)%R
x:R
H:(0 <= x)%R
Zaway (- x) = (- Zceil x)%Z
now rewrite Ropp_involutive.x:R
H:(x < 0)%R
(0 <= - x)%R
x:R
H:(0 <= x)%R
Zaway (- x) = (- Zceil x)%Z
apply Rlt_le.x:R
H:(x < 0)%R
(0 < - x)%R
x:R
H:(0 <= x)%R
Zaway (- x) = (- Zceil x)%Z
now apply Ropp_0_gt_lt_contravar.x:R
H:(0 <= x)%R
Zaway (- x) = (- Zceil x)%Z
rewrite Zaway_floor.x:R
H:(0 <= x)%R
Zfloor (- x) = (- Zceil x)%Z
x:R
H:(0 <= x)%R
(- x <= 0)%R
apply sym_eq.x:R
H:(0 <= x)%R
(- Zceil x)%Z = Zfloor (- x)
x:R
H:(0 <= x)%R
(- x <= 0)%R
apply Z.opp_involutive.x:R
H:(0 <= x)%R
(- x <= 0)%R
rewrite <- Ropp_0.x:R
H:(0 <= x)%R
(- x <= - 0)%R
now apply Ropp_le_contravar.
Qed.

Theorem Zaway_abs :
  forall x,
  Zaway (Rabs x) = Z.abs (Zaway x).forall x : R, Zaway (Rabs x) = Z.abs (Zaway x)
Proof.forall x : R, Zaway (Rabs x) = Z.abs (Zaway x)
intros x.x:R
Zaway (Rabs x) = Z.abs (Zaway x)
rewrite Zaway_ceil.x:R
Zceil (Rabs x) = Z.abs (Zaway x)
x:R
(0 <= Rabs x)%R 2: apply Rabs_pos.x:R
Zceil (Rabs x) = Z.abs (Zaway x)
unfold Zaway.x:R
Zceil (Rabs x) =
Z.abs (if Rlt_bool x 0 then Zfloor x else Zceil x)
case Rlt_bool_spec ; intro H.x:R
H:(x < 0)%R
Zceil (Rabs x) = Z.abs (Zfloor x)
x:R
H:(0 <= x)%R
Zceil (Rabs x) = Z.abs (Zceil x)
rewrite Rabs_left with (1 := H).x:R
H:(x < 0)%R
Zceil (- x) = Z.abs (Zfloor x)
x:R
H:(0 <= x)%R
Zceil (Rabs x) = Z.abs (Zceil x)
rewrite Zabs_non_eq.x:R
H:(x < 0)%R
Zceil (- x) = (- Zfloor x)%Z
x:R
H:(x < 0)%R
(Zfloor x <= 0)%Z
x:R
H:(0 <= x)%R
Zceil (Rabs x) = Z.abs (Zceil x)
apply (f_equal (fun v => - Zfloor v)%Z).x:R
H:(x < 0)%R
(- - x)%R = x
x:R
H:(x < 0)%R
(Zfloor x <= 0)%Z
x:R
H:(0 <= x)%R
Zceil (Rabs x) = Z.abs (Zceil x)
apply Ropp_involutive.x:R
H:(x < 0)%R
(Zfloor x <= 0)%Z
x:R
H:(0 <= x)%R
Zceil (Rabs x) = Z.abs (Zceil x)
apply le_IZR.x:R
H:(x < 0)%R
(IZR (Zfloor x) <= 0)%R
x:R
H:(0 <= x)%R
Zceil (Rabs x) = Z.abs (Zceil x)
apply Rlt_le.x:R
H:(x < 0)%R
(IZR (Zfloor x) < 0)%R
x:R
H:(0 <= x)%R
Zceil (Rabs x) = Z.abs (Zceil x)
apply Rle_lt_trans with (2 := H).x:R
H:(x < 0)%R
(IZR (Zfloor x) <= x)%R
x:R
H:(0 <= x)%R
Zceil (Rabs x) = Z.abs (Zceil x)
apply Zfloor_lb.x:R
H:(0 <= x)%R
Zceil (Rabs x) = Z.abs (Zceil x)
rewrite Rabs_pos_eq with (1 := H).x:R
H:(0 <= x)%R
Zceil x = Z.abs (Zceil x)
apply sym_eq.x:R
H:(0 <= x)%R
Z.abs (Zceil x) = Zceil x
apply Z.abs_eq.x:R
H:(0 <= x)%R
(0 <= Zceil x)%Z
apply le_IZR.x:R
H:(0 <= x)%R
(0 <= IZR (Zceil x))%R
apply Rle_trans with (1 := H).x:R
H:(0 <= x)%R
(x <= IZR (Zceil x))%R
apply Zceil_ub.
Qed.

End Floor_Ceil.

Theorem Rcompare_floor_ceil_middle :
  forall x,
  IZR (Zfloor x) <> x ->
  Rcompare (x - IZR (Zfloor x)) (/ 2) = Rcompare (x - IZR (Zfloor x)) (IZR (Zceil x) - x).forall x : R,
IZR (Zfloor x) <> x ->
Rcompare (x - IZR (Zfloor x)) (/ 2) =
Rcompare (x - IZR (Zfloor x)) (IZR (Zceil x) - x)
Proof.forall x : R,
IZR (Zfloor x) <> x ->
Rcompare (x - IZR (Zfloor x)) (/ 2) =
Rcompare (x - IZR (Zfloor x)) (IZR (Zceil x) - x)
intros x Hx.x:R
Hx:IZR (Zfloor x) <> x
Rcompare (x - IZR (Zfloor x)) (/ 2) =
Rcompare (x - IZR (Zfloor x)) (IZR (Zceil x) - x)
rewrite Zceil_floor_neq with (1 := Hx).x:R
Hx:IZR (Zfloor x) <> x
Rcompare (x - IZR (Zfloor x)) (/ 2) =
Rcompare (x - IZR (Zfloor x)) (IZR (Zfloor x + 1) - x)
rewrite plus_IZR.x:R
Hx:IZR (Zfloor x) <> x
Rcompare (x - IZR (Zfloor x)) (/ 2) =
Rcompare (x - IZR (Zfloor x)) (IZR (Zfloor x) + 1 - x)
destruct (Rcompare_spec (x - IZR (Zfloor x)) (/ 2)) as [H1|H1|H1] ; apply sym_eq.x:R
Hx:IZR (Zfloor x) <> x
H1:(x - IZR (Zfloor x) < / 2)%R
Rcompare (x - IZR (Zfloor x)) (IZR (Zfloor x) + 1 - x) =
Lt
x:R
Hx:IZR (Zfloor x) <> x
H1:(x - IZR (Zfloor x))%R = (/ 2)%R
Rcompare (x - IZR (Zfloor x)) (IZR (Zfloor x) + 1 - x) =
Eq
x:R
Hx:IZR (Zfloor x) <> x
H1:(/ 2 < x - IZR (Zfloor x))%R
Rcompare (x - IZR (Zfloor x)) (IZR (Zfloor x) + 1 - x) =
Gt
(* . *)
apply Rcompare_Lt.x:R
Hx:IZR (Zfloor x) <> x
H1:(x - IZR (Zfloor x) < / 2)%R
(x - IZR (Zfloor x) < IZR (Zfloor x) + 1 - x)%R
x:R
Hx:IZR (Zfloor x) <> x
H1:(x - IZR (Zfloor x))%R = (/ 2)%R
Rcompare (x - IZR (Zfloor x)) (IZR (Zfloor x) + 1 - x) =
Eq
x:R
Hx:IZR (Zfloor x) <> x
H1:(/ 2 < x - IZR (Zfloor x))%R
Rcompare (x - IZR (Zfloor x)) (IZR (Zfloor x) + 1 - x) =
Gt
apply Rplus_lt_reg_l with (x - IZR (Zfloor x))%R.x:R
Hx:IZR (Zfloor x) <> x
H1:(x - IZR (Zfloor x) < / 2)%R
(x - IZR (Zfloor x) + (x - IZR (Zfloor x)) <
 x - IZR (Zfloor x) + (IZR (Zfloor x) + 1 - x))%R
x:R
Hx:IZR (Zfloor x) <> x
H1:(x - IZR (Zfloor x))%R = (/ 2)%R
Rcompare (x - IZR (Zfloor x)) (IZR (Zfloor x) + 1 - x) =
Eq
x:R
Hx:IZR (Zfloor x) <> x
H1:(/ 2 < x - IZR (Zfloor x))%R
Rcompare (x - IZR (Zfloor x)) (IZR (Zfloor x) + 1 - x) =
Gt
replace (x - IZR (Zfloor x) + (x - IZR (Zfloor x)))%R with ((x - IZR (Zfloor x)) * 2)%R by ring.x:R
Hx:IZR (Zfloor x) <> x
H1:(x - IZR (Zfloor x) < / 2)%R
((x - IZR (Zfloor x)) * 2 <
 x - IZR (Zfloor x) + (IZR (Zfloor x) + 1 - x))%R
x:R
Hx:IZR (Zfloor x) <> x
H1:(x - IZR (Zfloor x))%R = (/ 2)%R
Rcompare (x - IZR (Zfloor x)) (IZR (Zfloor x) + 1 - x) =
Eq
x:R
Hx:IZR (Zfloor x) <> x
H1:(/ 2 < x - IZR (Zfloor x))%R
Rcompare (x - IZR (Zfloor x)) (IZR (Zfloor x) + 1 - x) =
Gt
replace (x - IZR (Zfloor x) + (IZR (Zfloor x) + 1 - x))%R with (/2 * 2)%R by field.x:R
Hx:IZR (Zfloor x) <> x
H1:(x - IZR (Zfloor x) < / 2)%R
((x - IZR (Zfloor x)) * 2 < / 2 * 2)%R
x:R
Hx:IZR (Zfloor x) <> x
H1:(x - IZR (Zfloor x))%R = (/ 2)%R
Rcompare (x - IZR (Zfloor x)) (IZR (Zfloor x) + 1 - x) =
Eq
x:R
Hx:IZR (Zfloor x) <> x
H1:(/ 2 < x - IZR (Zfloor x))%R
Rcompare (x - IZR (Zfloor x)) (IZR (Zfloor x) + 1 - x) =
Gt
apply Rmult_lt_compat_r with (2 := H1).x:R
Hx:IZR (Zfloor x) <> x
H1:(x - IZR (Zfloor x) < / 2)%R
(0 < 2)%R
x:R
Hx:IZR (Zfloor x) <> x
H1:(x - IZR (Zfloor x))%R = (/ 2)%R
Rcompare (x - IZR (Zfloor x)) (IZR (Zfloor x) + 1 - x) =
Eq
x:R
Hx:IZR (Zfloor x) <> x
H1:(/ 2 < x - IZR (Zfloor x))%R
Rcompare (x - IZR (Zfloor x)) (IZR (Zfloor x) + 1 - x) =
Gt
now apply IZR_lt.x:R
Hx:IZR (Zfloor x) <> x
H1:(x - IZR (Zfloor x))%R = (/ 2)%R
Rcompare (x - IZR (Zfloor x)) (IZR (Zfloor x) + 1 - x) =
Eq
x:R
Hx:IZR (Zfloor x) <> x
H1:(/ 2 < x - IZR (Zfloor x))%R
Rcompare (x - IZR (Zfloor x)) (IZR (Zfloor x) + 1 - x) =
Gt
(* . *)
apply Rcompare_Eq.x:R
Hx:IZR (Zfloor x) <> x
H1:(x - IZR (Zfloor x))%R = (/ 2)%R
(x - IZR (Zfloor x))%R = (IZR (Zfloor x) + 1 - x)%R
x:R
Hx:IZR (Zfloor x) <> x
H1:(/ 2 < x - IZR (Zfloor x))%R
Rcompare (x - IZR (Zfloor x)) (IZR (Zfloor x) + 1 - x) =
Gt
replace (IZR (Zfloor x) + 1 - x)%R with (1 - (x - IZR (Zfloor x)))%R by ring.x:R
Hx:IZR (Zfloor x) <> x
H1:(x - IZR (Zfloor x))%R = (/ 2)%R
(x - IZR (Zfloor x))%R = (1 - (x - IZR (Zfloor x)))%R
x:R
Hx:IZR (Zfloor x) <> x
H1:(/ 2 < x - IZR (Zfloor x))%R
Rcompare (x - IZR (Zfloor x)) (IZR (Zfloor x) + 1 - x) =
Gt
rewrite H1.x:R
Hx:IZR (Zfloor x) <> x
H1:(x - IZR (Zfloor x))%R = (/ 2)%R
(/ 2)%R = (1 - / 2)%R
x:R
Hx:IZR (Zfloor x) <> x
H1:(/ 2 < x - IZR (Zfloor x))%R
Rcompare (x - IZR (Zfloor x)) (IZR (Zfloor x) + 1 - x) =
Gt
field.x:R
Hx:IZR (Zfloor x) <> x
H1:(/ 2 < x - IZR (Zfloor x))%R
Rcompare (x - IZR (Zfloor x)) (IZR (Zfloor x) + 1 - x) =
Gt
(* . *)
apply Rcompare_Gt.x:R
Hx:IZR (Zfloor x) <> x
H1:(/ 2 < x - IZR (Zfloor x))%R
(IZR (Zfloor x) + 1 - x < x - IZR (Zfloor x))%R
apply Rplus_lt_reg_l with (x - IZR (Zfloor x))%R.x:R
Hx:IZR (Zfloor x) <> x
H1:(/ 2 < x - IZR (Zfloor x))%R
(x - IZR (Zfloor x) + (IZR (Zfloor x) + 1 - x) <
 x - IZR (Zfloor x) + (x - IZR (Zfloor x)))%R
replace (x - IZR (Zfloor x) + (x - IZR (Zfloor x)))%R with ((x - IZR (Zfloor x)) * 2)%R by ring.x:R
Hx:IZR (Zfloor x) <> x
H1:(/ 2 < x - IZR (Zfloor x))%R
(x - IZR (Zfloor x) + (IZR (Zfloor x) + 1 - x) <
 (x - IZR (Zfloor x)) * 2)%R
replace (x - IZR (Zfloor x) + (IZR (Zfloor x) + 1 - x))%R with (/2 * 2)%R by field.x:R
Hx:IZR (Zfloor x) <> x
H1:(/ 2 < x - IZR (Zfloor x))%R
(/ 2 * 2 < (x - IZR (Zfloor x)) * 2)%R
apply Rmult_lt_compat_r with (2 := H1).x:R
Hx:IZR (Zfloor x) <> x
H1:(/ 2 < x - IZR (Zfloor x))%R
(0 < 2)%R
now apply IZR_lt.
Qed.

Theorem Rcompare_ceil_floor_middle :
  forall x,
  IZR (Zfloor x) <> x ->
  Rcompare (IZR (Zceil x) - x) (/ 2) = Rcompare (IZR (Zceil x) - x) (x - IZR (Zfloor x)).forall x : R,
IZR (Zfloor x) <> x ->
Rcompare (IZR (Zceil x) - x) (/ 2) =
Rcompare (IZR (Zceil x) - x) (x - IZR (Zfloor x))
Proof.forall x : R,
IZR (Zfloor x) <> x ->
Rcompare (IZR (Zceil x) - x) (/ 2) =
Rcompare (IZR (Zceil x) - x) (x - IZR (Zfloor x))
intros x Hx.x:R
Hx:IZR (Zfloor x) <> x
Rcompare (IZR (Zceil x) - x) (/ 2) =
Rcompare (IZR (Zceil x) - x) (x - IZR (Zfloor x))
rewrite Zceil_floor_neq with (1 := Hx).x:R
Hx:IZR (Zfloor x) <> x
Rcompare (IZR (Zfloor x + 1) - x) (/ 2) =
Rcompare (IZR (Zfloor x + 1) - x) (x - IZR (Zfloor x))
rewrite plus_IZR.x:R
Hx:IZR (Zfloor x) <> x
Rcompare (IZR (Zfloor x) + 1 - x) (/ 2) =
Rcompare (IZR (Zfloor x) + 1 - x) (x - IZR (Zfloor x))
destruct (Rcompare_spec (IZR (Zfloor x) + 1 - x) (/ 2)) as [H1|H1|H1] ; apply sym_eq.x:R
Hx:IZR (Zfloor x) <> x
H1:(IZR (Zfloor x) + 1 - x < / 2)%R
Rcompare (IZR (Zfloor x) + 1 - x) (x - IZR (Zfloor x)) =
Lt
x:R
Hx:IZR (Zfloor x) <> x
H1:(IZR (Zfloor x) + 1 - x)%R = (/ 2)%R
Rcompare (IZR (Zfloor x) + 1 - x) (x - IZR (Zfloor x)) =
Eq
x:R
Hx:IZR (Zfloor x) <> x
H1:(/ 2 < IZR (Zfloor x) + 1 - x)%R
Rcompare (IZR (Zfloor x) + 1 - x) (x - IZR (Zfloor x)) =
Gt
(* . *)
apply Rcompare_Lt.x:R
Hx:IZR (Zfloor x) <> x
H1:(IZR (Zfloor x) + 1 - x < / 2)%R
(IZR (Zfloor x) + 1 - x < x - IZR (Zfloor x))%R
x:R
Hx:IZR (Zfloor x) <> x
H1:(IZR (Zfloor x) + 1 - x)%R = (/ 2)%R
Rcompare (IZR (Zfloor x) + 1 - x) (x - IZR (Zfloor x)) =
Eq
x:R
Hx:IZR (Zfloor x) <> x
H1:(/ 2 < IZR (Zfloor x) + 1 - x)%R
Rcompare (IZR (Zfloor x) + 1 - x) (x - IZR (Zfloor x)) =
Gt
apply Rplus_lt_reg_l with (IZR (Zfloor x) + 1 - x)%R.x:R
Hx:IZR (Zfloor x) <> x
H1:(IZR (Zfloor x) + 1 - x < / 2)%R
(IZR (Zfloor x) + 1 - x + (IZR (Zfloor x) + 1 - x) <
 IZR (Zfloor x) + 1 - x + (x - IZR (Zfloor x)))%R
x:R
Hx:IZR (Zfloor x) <> x
H1:(IZR (Zfloor x) + 1 - x)%R = (/ 2)%R
Rcompare (IZR (Zfloor x) + 1 - x) (x - IZR (Zfloor x)) =
Eq
x:R
Hx:IZR (Zfloor x) <> x
H1:(/ 2 < IZR (Zfloor x) + 1 - x)%R
Rcompare (IZR (Zfloor x) + 1 - x) (x - IZR (Zfloor x)) =
Gt
replace (IZR (Zfloor x) + 1 - x + (IZR (Zfloor x) + 1 - x))%R with ((IZR (Zfloor x) + 1 - x) * 2)%R by ring.x:R
Hx:IZR (Zfloor x) <> x
H1:(IZR (Zfloor x) + 1 - x < / 2)%R
((IZR (Zfloor x) + 1 - x) * 2 <
 IZR (Zfloor x) + 1 - x + (x - IZR (Zfloor x)))%R
x:R
Hx:IZR (Zfloor x) <> x
H1:(IZR (Zfloor x) + 1 - x)%R = (/ 2)%R
Rcompare (IZR (Zfloor x) + 1 - x) (x - IZR (Zfloor x)) =
Eq
x:R
Hx:IZR (Zfloor x) <> x
H1:(/ 2 < IZR (Zfloor x) + 1 - x)%R
Rcompare (IZR (Zfloor x) + 1 - x) (x - IZR (Zfloor x)) =
Gt
replace (IZR (Zfloor x) + 1 - x + (x - IZR (Zfloor x)))%R with (/2 * 2)%R by field.x:R
Hx:IZR (Zfloor x) <> x
H1:(IZR (Zfloor x) + 1 - x < / 2)%R
((IZR (Zfloor x) + 1 - x) * 2 < / 2 * 2)%R
x:R
Hx:IZR (Zfloor x) <> x
H1:(IZR (Zfloor x) + 1 - x)%R = (/ 2)%R
Rcompare (IZR (Zfloor x) + 1 - x) (x - IZR (Zfloor x)) =
Eq
x:R
Hx:IZR (Zfloor x) <> x
H1:(/ 2 < IZR (Zfloor x) + 1 - x)%R
Rcompare (IZR (Zfloor x) + 1 - x) (x - IZR (Zfloor x)) =
Gt
apply Rmult_lt_compat_r with (2 := H1).x:R
Hx:IZR (Zfloor x) <> x
H1:(IZR (Zfloor x) + 1 - x < / 2)%R
(0 < 2)%R
x:R
Hx:IZR (Zfloor x) <> x
H1:(IZR (Zfloor x) + 1 - x)%R = (/ 2)%R
Rcompare (IZR (Zfloor x) + 1 - x) (x - IZR (Zfloor x)) =
Eq
x:R
Hx:IZR (Zfloor x) <> x
H1:(/ 2 < IZR (Zfloor x) + 1 - x)%R
Rcompare (IZR (Zfloor x) + 1 - x) (x - IZR (Zfloor x)) =
Gt
now apply IZR_lt.x:R
Hx:IZR (Zfloor x) <> x
H1:(IZR (Zfloor x) + 1 - x)%R = (/ 2)%R
Rcompare (IZR (Zfloor x) + 1 - x) (x - IZR (Zfloor x)) =
Eq
x:R
Hx:IZR (Zfloor x) <> x
H1:(/ 2 < IZR (Zfloor x) + 1 - x)%R
Rcompare (IZR (Zfloor x) + 1 - x) (x - IZR (Zfloor x)) =
Gt
(* . *)
apply Rcompare_Eq.x:R
Hx:IZR (Zfloor x) <> x
H1:(IZR (Zfloor x) + 1 - x)%R = (/ 2)%R
(IZR (Zfloor x) + 1 - x)%R = (x - IZR (Zfloor x))%R
x:R
Hx:IZR (Zfloor x) <> x
H1:(/ 2 < IZR (Zfloor x) + 1 - x)%R
Rcompare (IZR (Zfloor x) + 1 - x) (x - IZR (Zfloor x)) =
Gt
replace (x - IZR (Zfloor x))%R with (1 - (IZR (Zfloor x) + 1 - x))%R by ring.x:R
Hx:IZR (Zfloor x) <> x
H1:(IZR (Zfloor x) + 1 - x)%R = (/ 2)%R
(IZR (Zfloor x) + 1 - x)%R =
(1 - (IZR (Zfloor x) + 1 - x))%R
x:R
Hx:IZR (Zfloor x) <> x
H1:(/ 2 < IZR (Zfloor x) + 1 - x)%R
Rcompare (IZR (Zfloor x) + 1 - x) (x - IZR (Zfloor x)) =
Gt
rewrite H1.x:R
Hx:IZR (Zfloor x) <> x
H1:(IZR (Zfloor x) + 1 - x)%R = (/ 2)%R
(/ 2)%R = (1 - / 2)%R
x:R
Hx:IZR (Zfloor x) <> x
H1:(/ 2 < IZR (Zfloor x) + 1 - x)%R
Rcompare (IZR (Zfloor x) + 1 - x) (x - IZR (Zfloor x)) =
Gt
field.x:R
Hx:IZR (Zfloor x) <> x
H1:(/ 2 < IZR (Zfloor x) + 1 - x)%R
Rcompare (IZR (Zfloor x) + 1 - x) (x - IZR (Zfloor x)) =
Gt
(* . *)
apply Rcompare_Gt.x:R
Hx:IZR (Zfloor x) <> x
H1:(/ 2 < IZR (Zfloor x) + 1 - x)%R
(x - IZR (Zfloor x) < IZR (Zfloor x) + 1 - x)%R
apply Rplus_lt_reg_l with (IZR (Zfloor x) + 1 - x)%R.x:R
Hx:IZR (Zfloor x) <> x
H1:(/ 2 < IZR (Zfloor x) + 1 - x)%R
(IZR (Zfloor x) + 1 - x + (x - IZR (Zfloor x)) <
 IZR (Zfloor x) + 1 - x + (IZR (Zfloor x) + 1 - x))%R
replace (IZR (Zfloor x) + 1 - x + (IZR (Zfloor x) + 1 - x))%R with ((IZR (Zfloor x) + 1 - x) * 2)%R by ring.x:R
Hx:IZR (Zfloor x) <> x
H1:(/ 2 < IZR (Zfloor x) + 1 - x)%R
(IZR (Zfloor x) + 1 - x + (x - IZR (Zfloor x)) <
 (IZR (Zfloor x) + 1 - x) * 2)%R
replace (IZR (Zfloor x) + 1 - x + (x - IZR (Zfloor x)))%R with (/2 * 2)%R by field.x:R
Hx:IZR (Zfloor x) <> x
H1:(/ 2 < IZR (Zfloor x) + 1 - x)%R
(/ 2 * 2 < (IZR (Zfloor x) + 1 - x) * 2)%R
apply Rmult_lt_compat_r with (2 := H1).x:R
Hx:IZR (Zfloor x) <> x
H1:(/ 2 < IZR (Zfloor x) + 1 - x)%R
(0 < 2)%R
now apply IZR_lt.
Qed.

Section Zdiv_Rdiv.

Theorem Zfloor_div :
  forall x y,
  y <> Z0 ->
  Zfloor (IZR x / IZR y) = (x / y)%Z.forall x y : Z,
y <> 0%Z -> Zfloor (IZR x / IZR y) = (x / y)%Z
Proof.forall x y : Z,
y <> 0%Z -> Zfloor (IZR x / IZR y) = (x / y)%Z
intros x y Zy.x, y:Z
Zy:y <> 0%Z
Zfloor (IZR x / IZR y) = (x / y)%Z
generalize (Z_div_mod_eq_full x y Zy).x, y:Z
Zy:y <> 0%Z
x = (y * (x / y) + x mod y)%Z ->
Zfloor (IZR x / IZR y) = (x / y)%Z
intros Hx.x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zfloor (IZR x / IZR y) = (x / y)%Z
rewrite Hx at 1.x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zfloor (IZR (y * (x / y) + x mod y) / IZR y) =
(x / y)%Z
assert (Zy': IZR y <> 0%R).x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
IZR y <> 0%R
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
Zfloor (IZR (y * (x / y) + x mod y) / IZR y) =
(x / y)%Z
contradict Zy.x, y:Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy:IZR y = 0%R
y = 0%Z
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
Zfloor (IZR (y * (x / y) + x mod y) / IZR y) =
(x / y)%Z
now apply eq_IZR.x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
Zfloor (IZR (y * (x / y) + x mod y) / IZR y) =
(x / y)%Z
unfold Rdiv.x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
Zfloor (IZR (y * (x / y) + x mod y) * / IZR y) =
(x / y)%Z
rewrite plus_IZR, Rmult_plus_distr_r, mult_IZR.x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
Zfloor
  (IZR y * IZR (x / y) * / IZR y +
   IZR (x mod y) * / IZR y) = (x / y)%Z
replace (IZR y * IZR (x / y) * / IZR y)%R with (IZR (x / y)) by now field.x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
Zfloor (IZR (x / y) + IZR (x mod y) * / IZR y) =
(x / y)%Z
apply Zfloor_imp.x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
(IZR (x / y) <=
 IZR (x / y) + IZR (x mod y) * / IZR y <
 IZR (x / y + 1))%R
rewrite plus_IZR.x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
(IZR (x / y) <=
 IZR (x / y) + IZR (x mod y) * / IZR y <
 IZR (x / y) + 1)%R
assert (0 <= IZR (x mod y) * / IZR y < 1)%R.x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
(0 <= IZR (x mod y) * / IZR y < 1)%R
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:(0 <= IZR (x mod y) * / IZR y < 1)%R
(IZR (x / y) <=
 IZR (x / y) + IZR (x mod y) * / IZR y <
 IZR (x / y) + 1)%R
(* *)
assert (forall x' y', (0 < y')%Z -> 0 <= IZR (x' mod y') * / IZR y' < 1)%R.x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
forall x' y' : Z,
(0 < y')%Z -> (0 <= IZR (x' mod y') * / IZR y' < 1)%R
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:forall x' y' : Z,
(0 < y')%Z ->
(0 <= IZR (x' mod y') * / IZR y' < 1)%R
(0 <= IZR (x mod y) * / IZR y < 1)%R
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:(0 <= IZR (x mod y) * / IZR y < 1)%R
(IZR (x / y) <=
 IZR (x / y) + IZR (x mod y) * / IZR y <
 IZR (x / y) + 1)%R
(* . *)
clear.forall x' y' : Z,
(0 < y')%Z -> (0 <= IZR (x' mod y') * / IZR y' < 1)%R
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:forall x' y' : Z,
(0 < y')%Z ->
(0 <= IZR (x' mod y') * / IZR y' < 1)%R
(0 <= IZR (x mod y) * / IZR y < 1)%R
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:(0 <= IZR (x mod y) * / IZR y < 1)%R
(IZR (x / y) <=
 IZR (x / y) + IZR (x mod y) * / IZR y <
 IZR (x / y) + 1)%R
intros x y Hy.x, y:Z
Hy:(0 < y)%Z
(0 <= IZR (x mod y) * / IZR y < 1)%R
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:forall x' y' : Z,
(0 < y')%Z ->
(0 <= IZR (x' mod y') * / IZR y' < 1)%R
(0 <= IZR (x mod y) * / IZR y < 1)%R
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:(0 <= IZR (x mod y) * / IZR y < 1)%R
(IZR (x / y) <=
 IZR (x / y) + IZR (x mod y) * / IZR y <
 IZR (x / y) + 1)%R
split.x, y:Z
Hy:(0 < y)%Z
(0 <= IZR (x mod y) * / IZR y)%R
x, y:Z
Hy:(0 < y)%Z
(IZR (x mod y) * / IZR y < 1)%R
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:forall x' y' : Z,
(0 < y')%Z ->
(0 <= IZR (x' mod y') * / IZR y' < 1)%R
(0 <= IZR (x mod y) * / IZR y < 1)%R
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:(0 <= IZR (x mod y) * / IZR y < 1)%R
(IZR (x / y) <=
 IZR (x / y) + IZR (x mod y) * / IZR y <
 IZR (x / y) + 1)%R
apply Rmult_le_pos.x, y:Z
Hy:(0 < y)%Z
(0 <= IZR (x mod y))%R
x, y:Z
Hy:(0 < y)%Z
(0 <= / IZR y)%R
x, y:Z
Hy:(0 < y)%Z
(IZR (x mod y) * / IZR y < 1)%R
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:forall x' y' : Z,
(0 < y')%Z ->
(0 <= IZR (x' mod y') * / IZR y' < 1)%R
(0 <= IZR (x mod y) * / IZR y < 1)%R
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:(0 <= IZR (x mod y) * / IZR y < 1)%R
(IZR (x / y) <=
 IZR (x / y) + IZR (x mod y) * / IZR y <
 IZR (x / y) + 1)%R
apply IZR_le.x, y:Z
Hy:(0 < y)%Z
(0 <= x mod y)%Z
x, y:Z
Hy:(0 < y)%Z
(0 <= / IZR y)%R
x, y:Z
Hy:(0 < y)%Z
(IZR (x mod y) * / IZR y < 1)%R
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:forall x' y' : Z,
(0 < y')%Z ->
(0 <= IZR (x' mod y') * / IZR y' < 1)%R
(0 <= IZR (x mod y) * / IZR y < 1)%R
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:(0 <= IZR (x mod y) * / IZR y < 1)%R
(IZR (x / y) <=
 IZR (x / y) + IZR (x mod y) * / IZR y <
 IZR (x / y) + 1)%R
refine (proj1 (Z_mod_lt _ _ _)).x, y:Z
Hy:(0 < y)%Z
(y > 0)%Z
x, y:Z
Hy:(0 < y)%Z
(0 <= / IZR y)%R
x, y:Z
Hy:(0 < y)%Z
(IZR (x mod y) * / IZR y < 1)%R
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:forall x' y' : Z,
(0 < y')%Z ->
(0 <= IZR (x' mod y') * / IZR y' < 1)%R
(0 <= IZR (x mod y) * / IZR y < 1)%R
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:(0 <= IZR (x mod y) * / IZR y < 1)%R
(IZR (x / y) <=
 IZR (x / y) + IZR (x mod y) * / IZR y <
 IZR (x / y) + 1)%R
now apply Z.lt_gt.x, y:Z
Hy:(0 < y)%Z
(0 <= / IZR y)%R
x, y:Z
Hy:(0 < y)%Z
(IZR (x mod y) * / IZR y < 1)%R
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:forall x' y' : Z,
(0 < y')%Z ->
(0 <= IZR (x' mod y') * / IZR y' < 1)%R
(0 <= IZR (x mod y) * / IZR y < 1)%R
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:(0 <= IZR (x mod y) * / IZR y < 1)%R
(IZR (x / y) <=
 IZR (x / y) + IZR (x mod y) * / IZR y <
 IZR (x / y) + 1)%R
apply Rlt_le.x, y:Z
Hy:(0 < y)%Z
(0 < / IZR y)%R
x, y:Z
Hy:(0 < y)%Z
(IZR (x mod y) * / IZR y < 1)%R
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:forall x' y' : Z,
(0 < y')%Z ->
(0 <= IZR (x' mod y') * / IZR y' < 1)%R
(0 <= IZR (x mod y) * / IZR y < 1)%R
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:(0 <= IZR (x mod y) * / IZR y < 1)%R
(IZR (x / y) <=
 IZR (x / y) + IZR (x mod y) * / IZR y <
 IZR (x / y) + 1)%R
apply Rinv_0_lt_compat.x, y:Z
Hy:(0 < y)%Z
(0 < IZR y)%R
x, y:Z
Hy:(0 < y)%Z
(IZR (x mod y) * / IZR y < 1)%R
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:forall x' y' : Z,
(0 < y')%Z ->
(0 <= IZR (x' mod y') * / IZR y' < 1)%R
(0 <= IZR (x mod y) * / IZR y < 1)%R
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:(0 <= IZR (x mod y) * / IZR y < 1)%R
(IZR (x / y) <=
 IZR (x / y) + IZR (x mod y) * / IZR y <
 IZR (x / y) + 1)%R
now apply IZR_lt.x, y:Z
Hy:(0 < y)%Z
(IZR (x mod y) * / IZR y < 1)%R
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:forall x' y' : Z,
(0 < y')%Z ->
(0 <= IZR (x' mod y') * / IZR y' < 1)%R
(0 <= IZR (x mod y) * / IZR y < 1)%R
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:(0 <= IZR (x mod y) * / IZR y < 1)%R
(IZR (x / y) <=
 IZR (x / y) + IZR (x mod y) * / IZR y <
 IZR (x / y) + 1)%R
apply Rmult_lt_reg_r with (IZR y).x, y:Z
Hy:(0 < y)%Z
(0 < IZR y)%R
x, y:Z
Hy:(0 < y)%Z
(IZR (x mod y) * / IZR y * IZR y < 1 * IZR y)%R
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:forall x' y' : Z,
(0 < y')%Z ->
(0 <= IZR (x' mod y') * / IZR y' < 1)%R
(0 <= IZR (x mod y) * / IZR y < 1)%R
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:(0 <= IZR (x mod y) * / IZR y < 1)%R
(IZR (x / y) <=
 IZR (x / y) + IZR (x mod y) * / IZR y <
 IZR (x / y) + 1)%R
now apply IZR_lt.x, y:Z
Hy:(0 < y)%Z
(IZR (x mod y) * / IZR y * IZR y < 1 * IZR y)%R
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:forall x' y' : Z,
(0 < y')%Z ->
(0 <= IZR (x' mod y') * / IZR y' < 1)%R
(0 <= IZR (x mod y) * / IZR y < 1)%R
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:(0 <= IZR (x mod y) * / IZR y < 1)%R
(IZR (x / y) <=
 IZR (x / y) + IZR (x mod y) * / IZR y <
 IZR (x / y) + 1)%R
rewrite Rmult_1_l, Rmult_assoc, Rinv_l, Rmult_1_r.x, y:Z
Hy:(0 < y)%Z
(IZR (x mod y) < IZR y)%R
x, y:Z
Hy:(0 < y)%Z
IZR y <> 0%R
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:forall x' y' : Z,
(0 < y')%Z ->
(0 <= IZR (x' mod y') * / IZR y' < 1)%R
(0 <= IZR (x mod y) * / IZR y < 1)%R
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:(0 <= IZR (x mod y) * / IZR y < 1)%R
(IZR (x / y) <=
 IZR (x / y) + IZR (x mod y) * / IZR y <
 IZR (x / y) + 1)%R
apply IZR_lt.x, y:Z
Hy:(0 < y)%Z
(x mod y < y)%Z
x, y:Z
Hy:(0 < y)%Z
IZR y <> 0%R
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:forall x' y' : Z,
(0 < y')%Z ->
(0 <= IZR (x' mod y') * / IZR y' < 1)%R
(0 <= IZR (x mod y) * / IZR y < 1)%R
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:(0 <= IZR (x mod y) * / IZR y < 1)%R
(IZR (x / y) <=
 IZR (x / y) + IZR (x mod y) * / IZR y <
 IZR (x / y) + 1)%R
eapply Z_mod_lt.x, y:Z
Hy:(0 < y)%Z
(y > 0)%Z
x, y:Z
Hy:(0 < y)%Z
IZR y <> 0%R
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:forall x' y' : Z,
(0 < y')%Z ->
(0 <= IZR (x' mod y') * / IZR y' < 1)%R
(0 <= IZR (x mod y) * / IZR y < 1)%R
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:(0 <= IZR (x mod y) * / IZR y < 1)%R
(IZR (x / y) <=
 IZR (x / y) + IZR (x mod y) * / IZR y <
 IZR (x / y) + 1)%R
now apply Z.lt_gt.x, y:Z
Hy:(0 < y)%Z
IZR y <> 0%R
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:forall x' y' : Z,
(0 < y')%Z ->
(0 <= IZR (x' mod y') * / IZR y' < 1)%R
(0 <= IZR (x mod y) * / IZR y < 1)%R
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:(0 <= IZR (x mod y) * / IZR y < 1)%R
(IZR (x / y) <=
 IZR (x / y) + IZR (x mod y) * / IZR y <
 IZR (x / y) + 1)%R
apply Rgt_not_eq.x, y:Z
Hy:(0 < y)%Z
(IZR y > 0)%R
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:forall x' y' : Z,
(0 < y')%Z ->
(0 <= IZR (x' mod y') * / IZR y' < 1)%R
(0 <= IZR (x mod y) * / IZR y < 1)%R
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:(0 <= IZR (x mod y) * / IZR y < 1)%R
(IZR (x / y) <=
 IZR (x / y) + IZR (x mod y) * / IZR y <
 IZR (x / y) + 1)%R
now apply IZR_lt.x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:forall x' y' : Z,
(0 < y')%Z ->
(0 <= IZR (x' mod y') * / IZR y' < 1)%R
(0 <= IZR (x mod y) * / IZR y < 1)%R
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:(0 <= IZR (x mod y) * / IZR y < 1)%R
(IZR (x / y) <=
 IZR (x / y) + IZR (x mod y) * / IZR y <
 IZR (x / y) + 1)%R
(* . *)
destruct (Z_lt_le_dec y 0) as [Hy|Hy].x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:forall x' y' : Z,
(0 < y')%Z ->
(0 <= IZR (x' mod y') * / IZR y' < 1)%R
Hy:(y < 0)%Z
(0 <= IZR (x mod y) * / IZR y < 1)%R
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:forall x' y' : Z,
(0 < y')%Z ->
(0 <= IZR (x' mod y') * / IZR y' < 1)%R
Hy:(0 <= y)%Z
(0 <= IZR (x mod y) * / IZR y < 1)%R
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:(0 <= IZR (x mod y) * / IZR y < 1)%R
(IZR (x / y) <=
 IZR (x / y) + IZR (x mod y) * / IZR y <
 IZR (x / y) + 1)%R
rewrite <- Rmult_opp_opp.x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:forall x' y' : Z,
(0 < y')%Z ->
(0 <= IZR (x' mod y') * / IZR y' < 1)%R
Hy:(y < 0)%Z
(0 <= - IZR (x mod y) * - / IZR y < 1)%R
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:forall x' y' : Z,
(0 < y')%Z ->
(0 <= IZR (x' mod y') * / IZR y' < 1)%R
Hy:(0 <= y)%Z
(0 <= IZR (x mod y) * / IZR y < 1)%R
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:(0 <= IZR (x mod y) * / IZR y < 1)%R
(IZR (x / y) <=
 IZR (x / y) + IZR (x mod y) * / IZR y <
 IZR (x / y) + 1)%R
rewrite Ropp_inv_permute with (1 := Zy').x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:forall x' y' : Z,
(0 < y')%Z ->
(0 <= IZR (x' mod y') * / IZR y' < 1)%R
Hy:(y < 0)%Z
(0 <= - IZR (x mod y) * / - IZR y < 1)%R
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:forall x' y' : Z,
(0 < y')%Z ->
(0 <= IZR (x' mod y') * / IZR y' < 1)%R
Hy:(0 <= y)%Z
(0 <= IZR (x mod y) * / IZR y < 1)%R
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:(0 <= IZR (x mod y) * / IZR y < 1)%R
(IZR (x / y) <=
 IZR (x / y) + IZR (x mod y) * / IZR y <
 IZR (x / y) + 1)%R
rewrite <- 2!opp_IZR.x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:forall x' y' : Z,
(0 < y')%Z ->
(0 <= IZR (x' mod y') * / IZR y' < 1)%R
Hy:(y < 0)%Z
(0 <= IZR (- (x mod y)) * / IZR (- y) < 1)%R
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:forall x' y' : Z,
(0 < y')%Z ->
(0 <= IZR (x' mod y') * / IZR y' < 1)%R
Hy:(0 <= y)%Z
(0 <= IZR (x mod y) * / IZR y < 1)%R
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:(0 <= IZR (x mod y) * / IZR y < 1)%R
(IZR (x / y) <=
 IZR (x / y) + IZR (x mod y) * / IZR y <
 IZR (x / y) + 1)%R
rewrite <- Zmod_opp_opp.x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:forall x' y' : Z,
(0 < y')%Z ->
(0 <= IZR (x' mod y') * / IZR y' < 1)%R
Hy:(y < 0)%Z
(0 <= IZR (- x mod - y) * / IZR (- y) < 1)%R
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:forall x' y' : Z,
(0 < y')%Z ->
(0 <= IZR (x' mod y') * / IZR y' < 1)%R
Hy:(0 <= y)%Z
(0 <= IZR (x mod y) * / IZR y < 1)%R
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:(0 <= IZR (x mod y) * / IZR y < 1)%R
(IZR (x / y) <=
 IZR (x / y) + IZR (x mod y) * / IZR y <
 IZR (x / y) + 1)%R
apply H.x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:forall x' y' : Z,
(0 < y')%Z ->
(0 <= IZR (x' mod y') * / IZR y' < 1)%R
Hy:(y < 0)%Z
(0 < - y)%Z
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:forall x' y' : Z,
(0 < y')%Z ->
(0 <= IZR (x' mod y') * / IZR y' < 1)%R
Hy:(0 <= y)%Z
(0 <= IZR (x mod y) * / IZR y < 1)%R
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:(0 <= IZR (x mod y) * / IZR y < 1)%R
(IZR (x / y) <=
 IZR (x / y) + IZR (x mod y) * / IZR y <
 IZR (x / y) + 1)%R
clear -Hy.y:Z
Hy:(y < 0)%Z
(0 < - y)%Z
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:forall x' y' : Z,
(0 < y')%Z ->
(0 <= IZR (x' mod y') * / IZR y' < 1)%R
Hy:(0 <= y)%Z
(0 <= IZR (x mod y) * / IZR y < 1)%R
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:(0 <= IZR (x mod y) * / IZR y < 1)%R
(IZR (x / y) <=
 IZR (x / y) + IZR (x mod y) * / IZR y <
 IZR (x / y) + 1)%R omega.x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:forall x' y' : Z,
(0 < y')%Z ->
(0 <= IZR (x' mod y') * / IZR y' < 1)%R
Hy:(0 <= y)%Z
(0 <= IZR (x mod y) * / IZR y < 1)%R
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:(0 <= IZR (x mod y) * / IZR y < 1)%R
(IZR (x / y) <=
 IZR (x / y) + IZR (x mod y) * / IZR y <
 IZR (x / y) + 1)%R
apply H.x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:forall x' y' : Z,
(0 < y')%Z ->
(0 <= IZR (x' mod y') * / IZR y' < 1)%R
Hy:(0 <= y)%Z
(0 < y)%Z
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:(0 <= IZR (x mod y) * / IZR y < 1)%R
(IZR (x / y) <=
 IZR (x / y) + IZR (x mod y) * / IZR y <
 IZR (x / y) + 1)%R
clear -Zy Hy.y:Z
Zy:y <> 0%Z
Hy:(0 <= y)%Z
(0 < y)%Z
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:(0 <= IZR (x mod y) * / IZR y < 1)%R
(IZR (x / y) <=
 IZR (x / y) + IZR (x mod y) * / IZR y <
 IZR (x / y) + 1)%R omega.x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:(0 <= IZR (x mod y) * / IZR y < 1)%R
(IZR (x / y) <=
 IZR (x / y) + IZR (x mod y) * / IZR y <
 IZR (x / y) + 1)%R
(* *)
split.x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:(0 <= IZR (x mod y) * / IZR y < 1)%R
(IZR (x / y) <= IZR (x / y) + IZR (x mod y) * / IZR y)%R
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:(0 <= IZR (x mod y) * / IZR y < 1)%R
(IZR (x / y) + IZR (x mod y) * / IZR y <
 IZR (x / y) + 1)%R
pattern (IZR (x / y)) at 1 ; rewrite <- Rplus_0_r.x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:(0 <= IZR (x mod y) * / IZR y < 1)%R
(IZR (x / y) + 0 <=
 IZR (x / y) + IZR (x mod y) * / IZR y)%R
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:(0 <= IZR (x mod y) * / IZR y < 1)%R
(IZR (x / y) + IZR (x mod y) * / IZR y <
 IZR (x / y) + 1)%R
apply Rplus_le_compat_l.x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:(0 <= IZR (x mod y) * / IZR y < 1)%R
(0 <= IZR (x mod y) * / IZR y)%R
x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:(0 <= IZR (x mod y) * / IZR y < 1)%R
(IZR (x / y) + IZR (x mod y) * / IZR y <
 IZR (x / y) + 1)%R
apply H.x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:(0 <= IZR (x mod y) * / IZR y < 1)%R
(IZR (x / y) + IZR (x mod y) * / IZR y <
 IZR (x / y) + 1)%R
apply Rplus_lt_compat_l.x, y:Z
Zy:y <> 0%Z
Hx:x = (y * (x / y) + x mod y)%Z
Zy':IZR y <> 0%R
H:(0 <= IZR (x mod y) * / IZR y < 1)%R
(IZR (x mod y) * / IZR y < 1)%R
apply H.
Qed.

End Zdiv_Rdiv.

Section pow.

Variable r : radix.

Theorem radix_pos : (0 < IZR r)%R.r:radix
(0 < IZR r)%R
Proof.r:radix
(0 < IZR r)%R
destruct r as (v, Hr).r:radix
v:Z
Hr:(2 <=? v)%Z = true
(0 < IZR {| radix_val := v; radix_prop := Hr |})%R simpl.r:radix
v:Z
Hr:(2 <=? v)%Z = true
(0 < IZR v)%R
apply IZR_lt.r:radix
v:Z
Hr:(2 <=? v)%Z = true
(0 < v)%Z
apply Z.lt_le_trans with 2%Z.r:radix
v:Z
Hr:(2 <=? v)%Z = true
(0 < 2)%Z
r:radix
v:Z
Hr:(2 <=? v)%Z = true
(2 <= v)%Z
easy.r:radix
v:Z
Hr:(2 <=? v)%Z = true
(2 <= v)%Z
now apply Zle_bool_imp_le.
Qed.

Well-used function called bpow for computing the power function β^e

Definition bpow e :=
  match e with
  | Zpos p => IZR (Zpower_pos r p)
  | Zneg p => Rinv (IZR (Zpower_pos r p))
  | Z0 => 1%R
  end.

Theorem IZR_Zpower_pos :
  forall n m,
  IZR (Zpower_pos n m) = powerRZ (IZR n) (Zpos m).r:radix
forall (n : Z) (m : positive),
IZR (Z.pow_pos n m) = powerRZ (IZR n) (Z.pos m)
Proof.r:radix
forall (n : Z) (m : positive),
IZR (Z.pow_pos n m) = powerRZ (IZR n) (Z.pos m)
intros.r:radix
n:Z
m:positive
IZR (Z.pow_pos n m) = powerRZ (IZR n) (Z.pos m)
rewrite Zpower_pos_nat.r:radix
n:Z
m:positive
IZR (Zpower_nat n (Pos.to_nat m)) =
powerRZ (IZR n) (Z.pos m)
simpl.r:radix
n:Z
m:positive
IZR (Zpower_nat n (Pos.to_nat m)) =
(IZR n ^ Pos.to_nat m)%R
induction (nat_of_P m).r:radix
n:Z
m:positive
IZR (Zpower_nat n 0) = (IZR n ^ 0)%R
r:radix
n:Z
m:positive
n0:nat
IHn0:IZR (Zpower_nat n n0) = (IZR n ^ n0)%R
IZR (Zpower_nat n (S n0)) = (IZR n ^ S n0)%R
apply refl_equal.r:radix
n:Z
m:positive
n0:nat
IHn0:IZR (Zpower_nat n n0) = (IZR n ^ n0)%R
IZR (Zpower_nat n (S n0)) = (IZR n ^ S n0)%R
unfold Zpower_nat.r:radix
n:Z
m:positive
n0:nat
IHn0:IZR (Zpower_nat n n0) = (IZR n ^ n0)%R
IZR
  (nat_rect (fun _ : nat => Z) 1%Z
     (fun _ : nat => Z.mul n) (S n0)) =
(IZR n ^ S n0)%R
simpl.r:radix
n:Z
m:positive
n0:nat
IHn0:IZR (Zpower_nat n n0) = (IZR n ^ n0)%R
IZR
  (n *
   nat_rect (fun _ : nat => Z) 1%Z
     (fun _ : nat => Z.mul n) n0) =
(IZR n * IZR n ^ n0)%R
rewrite mult_IZR.r:radix
n:Z
m:positive
n0:nat
IHn0:IZR (Zpower_nat n n0) = (IZR n ^ n0)%R
(IZR n *
 IZR
   (nat_rect (fun _ : nat => Z) 1%Z
      (fun _ : nat => Z.mul n) n0))%R =
(IZR n * IZR n ^ n0)%R
apply Rmult_eq_compat_l.r:radix
n:Z
m:positive
n0:nat
IHn0:IZR (Zpower_nat n n0) = (IZR n ^ n0)%R
IZR
  (nat_rect (fun _ : nat => Z) 1%Z
     (fun _ : nat => Z.mul n) n0) = (IZR n ^ n0)%R
exact IHn0.
Qed.

Theorem bpow_powerRZ :
  forall e,
  bpow e = powerRZ (IZR r) e.r:radix
forall e : Z, bpow e = powerRZ (IZR r) e
Proof.r:radix
forall e : Z, bpow e = powerRZ (IZR r) e
destruct e ; unfold bpow.r:radix
1%R = powerRZ (IZR r) 0
r:radix
p:positive
IZR (Z.pow_pos r p) = powerRZ (IZR r) (Z.pos p)
r:radix
p:positive
(/ IZR (Z.pow_pos r p))%R = powerRZ (IZR r) (Z.neg p)
reflexivity.r:radix
p:positive
IZR (Z.pow_pos r p) = powerRZ (IZR r) (Z.pos p)
r:radix
p:positive
(/ IZR (Z.pow_pos r p))%R = powerRZ (IZR r) (Z.neg p)
now rewrite IZR_Zpower_pos.r:radix
p:positive
(/ IZR (Z.pow_pos r p))%R = powerRZ (IZR r) (Z.neg p)
now rewrite IZR_Zpower_pos.
Qed.

Theorem  bpow_ge_0 :
  forall e : Z, (0 <= bpow e)%R.r:radix
forall e : Z, (0 <= bpow e)%R
Proof.r:radix
forall e : Z, (0 <= bpow e)%R
intros.r:radix
e:Z
(0 <= bpow e)%R
rewrite bpow_powerRZ.r:radix
e:Z
(0 <= powerRZ (IZR r) e)%R
apply powerRZ_le.r:radix
e:Z
(0 < IZR r)%R
apply radix_pos.
Qed.

Theorem bpow_gt_0 :
  forall e : Z, (0 < bpow e)%R.r:radix
forall e : Z, (0 < bpow e)%R
Proof.r:radix
forall e : Z, (0 < bpow e)%R
intros.r:radix
e:Z
(0 < bpow e)%R
rewrite bpow_powerRZ.r:radix
e:Z
(0 < powerRZ (IZR r) e)%R
apply powerRZ_lt.r:radix
e:Z
(0 < IZR r)%R
apply radix_pos.
Qed.

Theorem bpow_plus :
  forall e1 e2 : Z, (bpow (e1 + e2) = bpow e1 * bpow e2)%R.r:radix
forall e1 e2 : Z,
bpow (e1 + e2) = (bpow e1 * bpow e2)%R
Proof.r:radix
forall e1 e2 : Z,
bpow (e1 + e2) = (bpow e1 * bpow e2)%R
intros.r:radix
e1, e2:Z
bpow (e1 + e2) = (bpow e1 * bpow e2)%R
repeat rewrite bpow_powerRZ.r:radix
e1, e2:Z
powerRZ (IZR r) (e1 + e2) =
(powerRZ (IZR r) e1 * powerRZ (IZR r) e2)%R
apply powerRZ_add.r:radix
e1, e2:Z
IZR r <> 0%R
apply Rgt_not_eq.r:radix
e1, e2:Z
(IZR r > 0)%R
apply radix_pos.
Qed.

Theorem bpow_1 :
  bpow 1 = IZR r.r:radix
bpow 1 = IZR r
Proof.r:radix
bpow 1 = IZR r
unfold bpow, Zpower_pos.r:radix
IZR (Pos.iter (Z.mul r) 1%Z 1) = IZR r simpl.r:radix
IZR (r * 1) = IZR r
now rewrite Zmult_1_r.
Qed.

Theorem bpow_plus_1 :
  forall e : Z, (bpow (e + 1) = IZR r * bpow e)%R.r:radix
forall e : Z, bpow (e + 1) = (IZR r * bpow e)%R
Proof.r:radix
forall e : Z, bpow (e + 1) = (IZR r * bpow e)%R
intros.r:radix
e:Z
bpow (e + 1) = (IZR r * bpow e)%R
rewrite <- bpow_1.r:radix
e:Z
bpow (e + 1) = (bpow 1 * bpow e)%R
rewrite <- bpow_plus.r:radix
e:Z
bpow (e + 1) = bpow (1 + e)
now rewrite Zplus_comm.
Qed.

Theorem bpow_opp :
  forall e : Z, (bpow (-e) = /bpow e)%R.r:radix
forall e : Z, bpow (- e) = (/ bpow e)%R
Proof.r:radix
forall e : Z, bpow (- e) = (/ bpow e)%R
intros [|p|p].r:radix
bpow (- 0) = (/ bpow 0)%R
r:radix
p:positive
bpow (- Z.pos p) = (/ bpow (Z.pos p))%R
r:radix
p:positive
bpow (- Z.neg p) = (/ bpow (Z.neg p))%R
apply eq_sym, Rinv_1.r:radix
p:positive
bpow (- Z.pos p) = (/ bpow (Z.pos p))%R
r:radix
p:positive
bpow (- Z.neg p) = (/ bpow (Z.neg p))%R
now change (-Zpos p)%Z with (Zneg p).r:radix
p:positive
bpow (- Z.neg p) = (/ bpow (Z.neg p))%R
change (-Zneg p)%Z with (Zpos p).r:radix
p:positive
bpow (Z.pos p) = (/ bpow (Z.neg p))%R
simpl; rewrite Rinv_involutive; trivial.r:radix
p:positive
IZR (Z.pow_pos r p) <> 0%R
apply Rgt_not_eq.r:radix
p:positive
(IZR (Z.pow_pos r p) > 0)%R
apply (bpow_gt_0 (Zpos p)).
Qed.

Theorem IZR_Zpower_nat :
  forall e : nat,
  IZR (Zpower_nat r e) = bpow (Z_of_nat e).r:radix
forall e : nat,
IZR (Zpower_nat r e) = bpow (Z.of_nat e)
Proof.r:radix
forall e : nat,
IZR (Zpower_nat r e) = bpow (Z.of_nat e)
intros [|e].r:radix
IZR (Zpower_nat r 0) = bpow (Z.of_nat 0)
r:radix
e:nat
IZR (Zpower_nat r (S e)) = bpow (Z.of_nat (S e))
split.r:radix
e:nat
IZR (Zpower_nat r (S e)) = bpow (Z.of_nat (S e))
rewrite <- nat_of_P_o_P_of_succ_nat_eq_succ.r:radix
e:nat
IZR (Zpower_nat r (Pos.to_nat (Pos.of_succ_nat e))) =
bpow (Z.of_nat (Pos.to_nat (Pos.of_succ_nat e)))
rewrite <- Zpower_pos_nat.r:radix
e:nat
IZR (Z.pow_pos r (Pos.of_succ_nat e)) =
bpow (Z.of_nat (Pos.to_nat (Pos.of_succ_nat e)))
now rewrite <- Zpos_eq_Z_of_nat_o_nat_of_P.
Qed.

Theorem IZR_Zpower :
  forall e : Z,
  (0 <= e)%Z ->
  IZR (Zpower r e) = bpow e.r:radix
forall e : Z, (0 <= e)%Z -> IZR (r ^ e) = bpow e
Proof.r:radix
forall e : Z, (0 <= e)%Z -> IZR (r ^ e) = bpow e
intros [|e|e] H.r:radix
H:(0 <= 0)%Z
IZR (r ^ 0) = bpow 0
r:radix
e:positive
H:(0 <= Z.pos e)%Z
IZR (r ^ Z.pos e) = bpow (Z.pos e)
r:radix
e:positive
H:(0 <= Z.neg e)%Z
IZR (r ^ Z.neg e) = bpow (Z.neg e)
split.r:radix
e:positive
H:(0 <= Z.pos e)%Z
IZR (r ^ Z.pos e) = bpow (Z.pos e)
r:radix
e:positive
H:(0 <= Z.neg e)%Z
IZR (r ^ Z.neg e) = bpow (Z.neg e)
split.r:radix
e:positive
H:(0 <= Z.neg e)%Z
IZR (r ^ Z.neg e) = bpow (Z.neg e)
now elim H.
Qed.

Theorem bpow_lt :
  forall e1 e2 : Z,
  (e1 < e2)%Z -> (bpow e1 < bpow e2)%R.r:radix
forall e1 e2 : Z, (e1 < e2)%Z -> (bpow e1 < bpow e2)%R
Proof.r:radix
forall e1 e2 : Z, (e1 < e2)%Z -> (bpow e1 < bpow e2)%R
intros e1 e2 H.r:radix
e1, e2:Z
H:(e1 < e2)%Z
(bpow e1 < bpow e2)%R
replace e2 with (e1 + (e2 - e1))%Z by ring.r:radix
e1, e2:Z
H:(e1 < e2)%Z
(bpow e1 < bpow (e1 + (e2 - e1)))%R
rewrite <- (Rmult_1_r (bpow e1)).r:radix
e1, e2:Z
H:(e1 < e2)%Z
(bpow e1 * 1 < bpow (e1 + (e2 - e1)))%R
rewrite bpow_plus.r:radix
e1, e2:Z
H:(e1 < e2)%Z
(bpow e1 * 1 < bpow e1 * bpow (e2 - e1))%R
apply Rmult_lt_compat_l.r:radix
e1, e2:Z
H:(e1 < e2)%Z
(0 < bpow e1)%R
r:radix
e1, e2:Z
H:(e1 < e2)%Z
(1 < bpow (e2 - e1))%R
apply bpow_gt_0.r:radix
e1, e2:Z
H:(e1 < e2)%Z
(1 < bpow (e2 - e1))%R
assert (0 < e2 - e1)%Z by omega.r:radix
e1, e2:Z
H:(e1 < e2)%Z
H0:(0 < e2 - e1)%Z
(1 < bpow (e2 - e1))%R
destruct (e2 - e1)%Z ; try discriminate H0.r:radix
e1, e2:Z
H:(e1 < e2)%Z
p:positive
H0:(0 < Z.pos p)%Z
(1 < bpow (Z.pos p))%R
clear.r:radix
p:positive
(1 < bpow (Z.pos p))%R
rewrite <- IZR_Zpower by easy.r:radix
p:positive
(1 < IZR (r ^ Z.pos p))%R
apply IZR_lt.r:radix
p:positive
(1 < r ^ Z.pos p)%Z
now apply Zpower_gt_1.
Qed.

Theorem lt_bpow :
  forall e1 e2 : Z,
  (bpow e1 < bpow e2)%R -> (e1 < e2)%Z.r:radix
forall e1 e2 : Z, (bpow e1 < bpow e2)%R -> (e1 < e2)%Z
Proof.r:radix
forall e1 e2 : Z, (bpow e1 < bpow e2)%R -> (e1 < e2)%Z
intros e1 e2 H.r:radix
e1, e2:Z
H:(bpow e1 < bpow e2)%R
(e1 < e2)%Z
apply Z.gt_lt.r:radix
e1, e2:Z
H:(bpow e1 < bpow e2)%R
(e2 > e1)%Z
apply Znot_le_gt.r:radix
e1, e2:Z
H:(bpow e1 < bpow e2)%R
~ (e2 <= e1)%Z
intros H'.r:radix
e1, e2:Z
H:(bpow e1 < bpow e2)%R
H':(e2 <= e1)%Z
False
apply Rlt_not_le with (1 := H).r:radix
e1, e2:Z
H:(bpow e1 < bpow e2)%R
H':(e2 <= e1)%Z
(bpow e2 <= bpow e1)%R
destruct (Zle_lt_or_eq _ _ H').r:radix
e1, e2:Z
H:(bpow e1 < bpow e2)%R
H':(e2 <= e1)%Z
H0:(e2 < e1)%Z
(bpow e2 <= bpow e1)%R
r:radix
e1, e2:Z
H:(bpow e1 < bpow e2)%R
H':(e2 <= e1)%Z
H0:e2 = e1
(bpow e2 <= bpow e1)%R
apply Rlt_le.r:radix
e1, e2:Z
H:(bpow e1 < bpow e2)%R
H':(e2 <= e1)%Z
H0:(e2 < e1)%Z
(bpow e2 < bpow e1)%R
r:radix
e1, e2:Z
H:(bpow e1 < bpow e2)%R
H':(e2 <= e1)%Z
H0:e2 = e1
(bpow e2 <= bpow e1)%R
now apply bpow_lt.r:radix
e1, e2:Z
H:(bpow e1 < bpow e2)%R
H':(e2 <= e1)%Z
H0:e2 = e1
(bpow e2 <= bpow e1)%R
rewrite H0.r:radix
e1, e2:Z
H:(bpow e1 < bpow e2)%R
H':(e2 <= e1)%Z
H0:e2 = e1
(bpow e1 <= bpow e1)%R
apply Rle_refl.
Qed.

Theorem bpow_le :
  forall e1 e2 : Z,
  (e1 <= e2)%Z -> (bpow e1 <= bpow e2)%R.r:radix
forall e1 e2 : Z,
(e1 <= e2)%Z -> (bpow e1 <= bpow e2)%R
Proof.r:radix
forall e1 e2 : Z,
(e1 <= e2)%Z -> (bpow e1 <= bpow e2)%R
intros e1 e2 H.r:radix
e1, e2:Z
H:(e1 <= e2)%Z
(bpow e1 <= bpow e2)%R
apply Rnot_lt_le.r:radix
e1, e2:Z
H:(e1 <= e2)%Z
~ (bpow e2 < bpow e1)%R
intros H'.r:radix
e1, e2:Z
H:(e1 <= e2)%Z
H':(bpow e2 < bpow e1)%R
False
apply Zle_not_gt with (1 := H).r:radix
e1, e2:Z
H:(e1 <= e2)%Z
H':(bpow e2 < bpow e1)%R
(e1 > e2)%Z
apply Z.lt_gt.r:radix
e1, e2:Z
H:(e1 <= e2)%Z
H':(bpow e2 < bpow e1)%R
(e2 < e1)%Z
now apply lt_bpow.
Qed.

Theorem le_bpow :
  forall e1 e2 : Z,
  (bpow e1 <= bpow e2)%R -> (e1 <= e2)%Z.r:radix
forall e1 e2 : Z,
(bpow e1 <= bpow e2)%R -> (e1 <= e2)%Z
Proof.r:radix
forall e1 e2 : Z,
(bpow e1 <= bpow e2)%R -> (e1 <= e2)%Z
intros e1 e2 H.r:radix
e1, e2:Z
H:(bpow e1 <= bpow e2)%R
(e1 <= e2)%Z
apply Znot_gt_le.r:radix
e1, e2:Z
H:(bpow e1 <= bpow e2)%R
~ (e1 > e2)%Z
intros H'.r:radix
e1, e2:Z
H:(bpow e1 <= bpow e2)%R
H':(e1 > e2)%Z
False
apply Rle_not_lt with (1 := H).r:radix
e1, e2:Z
H:(bpow e1 <= bpow e2)%R
H':(e1 > e2)%Z
(bpow e2 < bpow e1)%R
apply bpow_lt.r:radix
e1, e2:Z
H:(bpow e1 <= bpow e2)%R
H':(e1 > e2)%Z
(e2 < e1)%Z
now apply Z.gt_lt.
Qed.

Theorem bpow_inj :
  forall e1 e2 : Z,
  bpow e1 = bpow e2 -> e1 = e2.r:radix
forall e1 e2 : Z, bpow e1 = bpow e2 -> e1 = e2
Proof.r:radix
forall e1 e2 : Z, bpow e1 = bpow e2 -> e1 = e2
intros.r:radix
e1, e2:Z
H:bpow e1 = bpow e2
e1 = e2
apply Zle_antisym.r:radix
e1, e2:Z
H:bpow e1 = bpow e2
(e1 <= e2)%Z
r:radix
e1, e2:Z
H:bpow e1 = bpow e2
(e2 <= e1)%Z
apply le_bpow.r:radix
e1, e2:Z
H:bpow e1 = bpow e2
(bpow e1 <= bpow e2)%R
r:radix
e1, e2:Z
H:bpow e1 = bpow e2
(e2 <= e1)%Z
now apply Req_le.r:radix
e1, e2:Z
H:bpow e1 = bpow e2
(e2 <= e1)%Z
apply le_bpow.r:radix
e1, e2:Z
H:bpow e1 = bpow e2
(bpow e2 <= bpow e1)%R
now apply Req_le.
Qed.

Theorem bpow_exp :
  forall e : Z,
  bpow e = exp (IZR e * ln (IZR r)).r:radix
forall e : Z, bpow e = exp (IZR e * ln (IZR r))
Proof.r:radix
forall e : Z, bpow e = exp (IZR e * ln (IZR r))
(* positive case *)
assert (forall e, bpow (Zpos e) = exp (IZR (Zpos e) * ln (IZR r))).r:radix
forall e : positive,
bpow (Z.pos e) = exp (IZR (Z.pos e) * ln (IZR r))
r:radix
H:forall e : positive,
bpow (Z.pos e) = exp (IZR (Z.pos e) * ln (IZR r))
forall e : Z, bpow e = exp (IZR e * ln (IZR r))
intros e.r:radix
e:positive
bpow (Z.pos e) = exp (IZR (Z.pos e) * ln (IZR r))
r:radix
H:forall e : positive,
bpow (Z.pos e) = exp (IZR (Z.pos e) * ln (IZR r))
forall e : Z, bpow e = exp (IZR e * ln (IZR r))
unfold bpow.r:radix
e:positive
IZR (Z.pow_pos r e) = exp (IZR (Z.pos e) * ln (IZR r))
r:radix
H:forall e : positive,
bpow (Z.pos e) = exp (IZR (Z.pos e) * ln (IZR r))
forall e : Z, bpow e = exp (IZR e * ln (IZR r))
rewrite Zpower_pos_nat.r:radix
e:positive
IZR (Zpower_nat r (Pos.to_nat e)) =
exp (IZR (Z.pos e) * ln (IZR r))
r:radix
H:forall e : positive,
bpow (Z.pos e) = exp (IZR (Z.pos e) * ln (IZR r))
forall e : Z, bpow e = exp (IZR e * ln (IZR r))
rewrite <- positive_nat_Z.r:radix
e:positive
IZR (Zpower_nat r (Pos.to_nat e)) =
exp (IZR (Z.of_nat (Pos.to_nat e)) * ln (IZR r))
r:radix
H:forall e : positive,
bpow (Z.pos e) = exp (IZR (Z.pos e) * ln (IZR r))
forall e : Z, bpow e = exp (IZR e * ln (IZR r))
rewrite <- INR_IZR_INZ.r:radix
e:positive
IZR (Zpower_nat r (Pos.to_nat e)) =
exp (INR (Pos.to_nat e) * ln (IZR r))
r:radix
H:forall e : positive,
bpow (Z.pos e) = exp (IZR (Z.pos e) * ln (IZR r))
forall e : Z, bpow e = exp (IZR e * ln (IZR r))
induction (nat_of_P e).r:radix
e:positive
IZR (Zpower_nat r 0) = exp (INR 0 * ln (IZR r))
r:radix
e:positive
n:nat
IHn:IZR (Zpower_nat r n) = exp (INR n * ln (IZR r))
IZR (Zpower_nat r (S n)) =
exp (INR (S n) * ln (IZR r))
r:radix
H:forall e : positive,
bpow (Z.pos e) = exp (IZR (Z.pos e) * ln (IZR r))
forall e : Z, bpow e = exp (IZR e * ln (IZR r))
rewrite Rmult_0_l.r:radix
e:positive
IZR (Zpower_nat r 0) = exp 0
r:radix
e:positive
n:nat
IHn:IZR (Zpower_nat r n) = exp (INR n * ln (IZR r))
IZR (Zpower_nat r (S n)) =
exp (INR (S n) * ln (IZR r))
r:radix
H:forall e : positive,
bpow (Z.pos e) = exp (IZR (Z.pos e) * ln (IZR r))
forall e : Z, bpow e = exp (IZR e * ln (IZR r))
now rewrite exp_0.r:radix
e:positive
n:nat
IHn:IZR (Zpower_nat r n) = exp (INR n * ln (IZR r))
IZR (Zpower_nat r (S n)) =
exp (INR (S n) * ln (IZR r))
r:radix
H:forall e : positive,
bpow (Z.pos e) = exp (IZR (Z.pos e) * ln (IZR r))
forall e : Z, bpow e = exp (IZR e * ln (IZR r))
rewrite Zpower_nat_S.r:radix
e:positive
n:nat
IHn:IZR (Zpower_nat r n) = exp (INR n * ln (IZR r))
IZR (r * Zpower_nat r n) =
exp (INR (S n) * ln (IZR r))
r:radix
H:forall e : positive,
bpow (Z.pos e) = exp (IZR (Z.pos e) * ln (IZR r))
forall e : Z, bpow e = exp (IZR e * ln (IZR r))
rewrite S_INR.r:radix
e:positive
n:nat
IHn:IZR (Zpower_nat r n) = exp (INR n * ln (IZR r))
IZR (r * Zpower_nat r n) =
exp ((INR n + 1) * ln (IZR r))
r:radix
H:forall e : positive,
bpow (Z.pos e) = exp (IZR (Z.pos e) * ln (IZR r))
forall e : Z, bpow e = exp (IZR e * ln (IZR r))
rewrite Rmult_plus_distr_r.r:radix
e:positive
n:nat
IHn:IZR (Zpower_nat r n) = exp (INR n * ln (IZR r))
IZR (r * Zpower_nat r n) =
exp (INR n * ln (IZR r) + 1 * ln (IZR r))
r:radix
H:forall e : positive,
bpow (Z.pos e) = exp (IZR (Z.pos e) * ln (IZR r))
forall e : Z, bpow e = exp (IZR e * ln (IZR r))
rewrite exp_plus.r:radix
e:positive
n:nat
IHn:IZR (Zpower_nat r n) = exp (INR n * ln (IZR r))
IZR (r * Zpower_nat r n) =
(exp (INR n * ln (IZR r)) * exp (1 * ln (IZR r)))%R
r:radix
H:forall e : positive,
bpow (Z.pos e) = exp (IZR (Z.pos e) * ln (IZR r))
forall e : Z, bpow e = exp (IZR e * ln (IZR r))
rewrite Rmult_1_l.r:radix
e:positive
n:nat
IHn:IZR (Zpower_nat r n) = exp (INR n * ln (IZR r))
IZR (r * Zpower_nat r n) =
(exp (INR n * ln (IZR r)) * exp (ln (IZR r)))%R
r:radix
H:forall e : positive,
bpow (Z.pos e) = exp (IZR (Z.pos e) * ln (IZR r))
forall e : Z, bpow e = exp (IZR e * ln (IZR r))
rewrite exp_ln.r:radix
e:positive
n:nat
IHn:IZR (Zpower_nat r n) = exp (INR n * ln (IZR r))
IZR (r * Zpower_nat r n) =
(exp (INR n * ln (IZR r)) * IZR r)%R
r:radix
e:positive
n:nat
IHn:IZR (Zpower_nat r n) = exp (INR n * ln (IZR r))
(0 < IZR r)%R
r:radix
H:forall e : positive,
bpow (Z.pos e) = exp (IZR (Z.pos e) * ln (IZR r))
forall e : Z, bpow e = exp (IZR e * ln (IZR r))
rewrite <- IHn.r:radix
e:positive
n:nat
IHn:IZR (Zpower_nat r n) = exp (INR n * ln (IZR r))
IZR (r * Zpower_nat r n) =
(IZR (Zpower_nat r n) * IZR r)%R
r:radix
e:positive
n:nat
IHn:IZR (Zpower_nat r n) = exp (INR n * ln (IZR r))
(0 < IZR r)%R
r:radix
H:forall e : positive,
bpow (Z.pos e) = exp (IZR (Z.pos e) * ln (IZR r))
forall e : Z, bpow e = exp (IZR e * ln (IZR r))
rewrite <- mult_IZR.r:radix
e:positive
n:nat
IHn:IZR (Zpower_nat r n) = exp (INR n * ln (IZR r))
IZR (r * Zpower_nat r n) = IZR (Zpower_nat r n * r)
r:radix
e:positive
n:nat
IHn:IZR (Zpower_nat r n) = exp (INR n * ln (IZR r))
(0 < IZR r)%R
r:radix
H:forall e : positive,
bpow (Z.pos e) = exp (IZR (Z.pos e) * ln (IZR r))
forall e : Z, bpow e = exp (IZR e * ln (IZR r))
now rewrite Zmult_comm.r:radix
e:positive
n:nat
IHn:IZR (Zpower_nat r n) = exp (INR n * ln (IZR r))
(0 < IZR r)%R
r:radix
H:forall e : positive,
bpow (Z.pos e) = exp (IZR (Z.pos e) * ln (IZR r))
forall e : Z, bpow e = exp (IZR e * ln (IZR r))
apply radix_pos.r:radix
H:forall e : positive,
bpow (Z.pos e) = exp (IZR (Z.pos e) * ln (IZR r))
forall e : Z, bpow e = exp (IZR e * ln (IZR r))
(* general case *)
intros [|e|e].r:radix
H:forall e : positive,
bpow (Z.pos e) = exp (IZR (Z.pos e) * ln (IZR r))
bpow 0 = exp (0 * ln (IZR r))
r:radix
H:forall e0 : positive,
bpow (Z.pos e0) =
exp (IZR (Z.pos e0) * ln (IZR r))
e:positive
bpow (Z.pos e) = exp (IZR (Z.pos e) * ln (IZR r))
r:radix
H:forall e0 : positive,
bpow (Z.pos e0) =
exp (IZR (Z.pos e0) * ln (IZR r))
e:positive
bpow (Z.neg e) = exp (IZR (Z.neg e) * ln (IZR r))
rewrite Rmult_0_l.r:radix
H:forall e : positive,
bpow (Z.pos e) = exp (IZR (Z.pos e) * ln (IZR r))
bpow 0 = exp 0
r:radix
H:forall e0 : positive,
bpow (Z.pos e0) =
exp (IZR (Z.pos e0) * ln (IZR r))
e:positive
bpow (Z.pos e) = exp (IZR (Z.pos e) * ln (IZR r))
r:radix
H:forall e0 : positive,
bpow (Z.pos e0) =
exp (IZR (Z.pos e0) * ln (IZR r))
e:positive
bpow (Z.neg e) = exp (IZR (Z.neg e) * ln (IZR r))
now rewrite exp_0.r:radix
H:forall e0 : positive,
bpow (Z.pos e0) =
exp (IZR (Z.pos e0) * ln (IZR r))
e:positive
bpow (Z.pos e) = exp (IZR (Z.pos e) * ln (IZR r))
r:radix
H:forall e0 : positive,
bpow (Z.pos e0) =
exp (IZR (Z.pos e0) * ln (IZR r))
e:positive
bpow (Z.neg e) = exp (IZR (Z.neg e) * ln (IZR r))
apply H.r:radix
H:forall e0 : positive,
bpow (Z.pos e0) =
exp (IZR (Z.pos e0) * ln (IZR r))
e:positive
bpow (Z.neg e) = exp (IZR (Z.neg e) * ln (IZR r))
unfold bpow.r:radix
H:forall e0 : positive,
bpow (Z.pos e0) =
exp (IZR (Z.pos e0) * ln (IZR r))
e:positive
(/ IZR (Z.pow_pos r e))%R =
exp (IZR (Z.neg e) * ln (IZR r))
change (IZR (Zpower_pos r e)) with (bpow (Zpos e)).r:radix
H:forall e0 : positive,
bpow (Z.pos e0) =
exp (IZR (Z.pos e0) * ln (IZR r))
e:positive
(/ bpow (Z.pos e))%R =
exp (IZR (Z.neg e) * ln (IZR r))
rewrite H.r:radix
H:forall e0 : positive,
bpow (Z.pos e0) =
exp (IZR (Z.pos e0) * ln (IZR r))
e:positive
(/ exp (IZR (Z.pos e) * ln (IZR r)))%R =
exp (IZR (Z.neg e) * ln (IZR r))
rewrite <- exp_Ropp.r:radix
H:forall e0 : positive,
bpow (Z.pos e0) =
exp (IZR (Z.pos e0) * ln (IZR r))
e:positive
exp (- (IZR (Z.pos e) * ln (IZR r))) =
exp (IZR (Z.neg e) * ln (IZR r))
rewrite <- Ropp_mult_distr_l_reverse.r:radix
H:forall e0 : positive,
bpow (Z.pos e0) =
exp (IZR (Z.pos e0) * ln (IZR r))
e:positive
exp (- IZR (Z.pos e) * ln (IZR r)) =
exp (IZR (Z.neg e) * ln (IZR r))
now rewrite <- opp_IZR.
Qed.

Lemma sqrt_bpow :
  forall e,
  sqrt (bpow (2 * e)) = bpow e.r:radix
forall e : Z, sqrt (bpow (2 * e)) = bpow e
Proof.r:radix
forall e : Z, sqrt (bpow (2 * e)) = bpow e
intro e.r:radix
e:Z
sqrt (bpow (2 * e)) = bpow e
change 2%Z with (1 + 1)%Z; rewrite Z.mul_add_distr_r, Z.mul_1_l, bpow_plus.r:radix
e:Z
sqrt (bpow e * bpow e) = bpow e
apply sqrt_square, bpow_ge_0.
Qed.

Lemma sqrt_bpow_ge :
  forall e,
  (bpow (e / 2) <= sqrt (bpow e))%R.r:radix
forall e : Z, (bpow (e / 2) <= sqrt (bpow e))%R
Proof.r:radix
forall e : Z, (bpow (e / 2) <= sqrt (bpow e))%R
intro e.r:radix
e:Z
(bpow (e / 2) <= sqrt (bpow e))%R
rewrite <- (sqrt_square (bpow _)); [|now apply bpow_ge_0].r:radix
e:Z
(sqrt (bpow (e / 2) * bpow (e / 2)) <= sqrt (bpow e))%R
apply sqrt_le_1_alt; rewrite <- bpow_plus; apply bpow_le.r:radix
e:Z
(e / 2 + e / 2 <= e)%Z
now replace (_ + _)%Z with (2 * (e / 2))%Z by ring; apply Z_mult_div_ge.
Qed.

Another well-used function for having the magnitude of a real number x to the base β

Record mag_prop x := {
  mag_val :> Z ;
  _ : (x <> 0)%R -> (bpow (mag_val - 1)%Z <= Rabs x < bpow mag_val)%R
}.

Definition mag :
  forall x : R, mag_prop x.r:radix
forall x : R, mag_prop x
Proof.r:radix
forall x : R, mag_prop x
intros x.r:radix
x:R
mag_prop x
set (fact := ln (IZR r)).r:radix
x:R
fact:=ln (IZR r):R
mag_prop x
(* . *)
assert (0 < fact)%R.r:radix
x:R
fact:=ln (IZR r):R
(0 < fact)%R
r:radix
x:R
fact:=ln (IZR r):R
H:(0 < fact)%R
mag_prop x
apply exp_lt_inv.r:radix
x:R
fact:=ln (IZR r):R
(exp 0 < exp fact)%R
r:radix
x:R
fact:=ln (IZR r):R
H:(0 < fact)%R
mag_prop x
rewrite exp_0.r:radix
x:R
fact:=ln (IZR r):R
(1 < exp fact)%R
r:radix
x:R
fact:=ln (IZR r):R
H:(0 < fact)%R
mag_prop x
unfold fact.r:radix
x:R
fact:=ln (IZR r):R
(1 < exp (ln (IZR r)))%R
r:radix
x:R
fact:=ln (IZR r):R
H:(0 < fact)%R
mag_prop x
rewrite exp_ln.r:radix
x:R
fact:=ln (IZR r):R
(1 < IZR r)%R
r:radix
x:R
fact:=ln (IZR r):R
(0 < IZR r)%R
r:radix
x:R
fact:=ln (IZR r):R
H:(0 < fact)%R
mag_prop x
apply IZR_lt.r:radix
x:R
fact:=ln (IZR r):R
(1 < r)%Z
r:radix
x:R
fact:=ln (IZR r):R
(0 < IZR r)%R
r:radix
x:R
fact:=ln (IZR r):R
H:(0 < fact)%R
mag_prop x
apply radix_gt_1.r:radix
x:R
fact:=ln (IZR r):R
(0 < IZR r)%R
r:radix
x:R
fact:=ln (IZR r):R
H:(0 < fact)%R
mag_prop x
apply radix_pos.r:radix
x:R
fact:=ln (IZR r):R
H:(0 < fact)%R
mag_prop x
(* . *)
exists (Zfloor (ln (Rabs x) / fact) + 1)%Z.r:radix
x:R
fact:=ln (IZR r):R
H:(0 < fact)%R
x <> 0%R ->
(bpow (Zfloor (ln (Rabs x) / fact) + 1 - 1) <=
 Rabs x < bpow (Zfloor (ln (Rabs x) / fact) + 1))%R
intros Hx'.r:radix
x:R
fact:=ln (IZR r):R
H:(0 < fact)%R
Hx':x <> 0%R
(bpow (Zfloor (ln (Rabs x) / fact) + 1 - 1) <=
 Rabs x < bpow (Zfloor (ln (Rabs x) / fact) + 1))%R
generalize (Rabs_pos_lt _ Hx').r:radix
x:R
fact:=ln (IZR r):R
H:(0 < fact)%R
Hx':x <> 0%R
(0 < Rabs x)%R ->
(bpow (Zfloor (ln (Rabs x) / fact) + 1 - 1) <=
 Rabs x < bpow (Zfloor (ln (Rabs x) / fact) + 1))%R clear Hx'.r:radix
x:R
fact:=ln (IZR r):R
H:(0 < fact)%R
(0 < Rabs x)%R ->
(bpow (Zfloor (ln (Rabs x) / fact) + 1 - 1) <=
 Rabs x < bpow (Zfloor (ln (Rabs x) / fact) + 1))%R
generalize (Rabs x).r:radix
x:R
fact:=ln (IZR r):R
H:(0 < fact)%R
forall r0 : R,
(0 < r0)%R ->
(bpow (Zfloor (ln r0 / fact) + 1 - 1) <= r0 <
 bpow (Zfloor (ln r0 / fact) + 1))%R clear x.r:radix
fact:=ln (IZR r):R
H:(0 < fact)%R
forall r0 : R,
(0 < r0)%R ->
(bpow (Zfloor (ln r0 / fact) + 1 - 1) <= r0 <
 bpow (Zfloor (ln r0 / fact) + 1))%R
intros x Hx.r:radix
fact:=ln (IZR r):R
H:(0 < fact)%R
x:R
Hx:(0 < x)%R
(bpow (Zfloor (ln x / fact) + 1 - 1) <= x <
 bpow (Zfloor (ln x / fact) + 1))%R
rewrite 2!bpow_exp.r:radix
fact:=ln (IZR r):R
H:(0 < fact)%R
x:R
Hx:(0 < x)%R
(exp (IZR (Zfloor (ln x / fact) + 1 - 1) * ln (IZR r)) <=
 x < exp (IZR (Zfloor (ln x / fact) + 1) * ln (IZR r)))%R
fold fact.r:radix
fact:=ln (IZR r):R
H:(0 < fact)%R
x:R
Hx:(0 < x)%R
(exp (IZR (Zfloor (ln x / fact) + 1 - 1) * fact) <=
 x < exp (IZR (Zfloor (ln x / fact) + 1) * fact))%R
pattern x at 2 3 ; replace x with (exp (ln x * / fact * fact)).r:radix
fact:=ln (IZR r):R
H:(0 < fact)%R
x:R
Hx:(0 < x)%R
(exp (IZR (Zfloor (ln x / fact) + 1 - 1) * fact) <=
 exp (ln x * / fact * fact) <
 exp (IZR (Zfloor (ln x / fact) + 1) * fact))%R
r:radix
fact:=ln (IZR r):R
H:(0 < fact)%R
x:R
Hx:(0 < x)%R
exp (ln x * / fact * fact) = x
split.r:radix
fact:=ln (IZR r):R
H:(0 < fact)%R
x:R
Hx:(0 < x)%R
(exp (IZR (Zfloor (ln x / fact) + 1 - 1) * fact) <=
 exp (ln x * / fact * fact))%R
r:radix
fact:=ln (IZR r):R
H:(0 < fact)%R
x:R
Hx:(0 < x)%R
(exp (ln x * / fact * fact) <
 exp (IZR (Zfloor (ln x / fact) + 1) * fact))%R
r:radix
fact:=ln (IZR r):R
H:(0 < fact)%R
x:R
Hx:(0 < x)%R
exp (ln x * / fact * fact) = x
rewrite minus_IZR.r:radix
fact:=ln (IZR r):R
H:(0 < fact)%R
x:R
Hx:(0 < x)%R
(exp ((IZR (Zfloor (ln x / fact) + 1) - 1) * fact) <=
 exp (ln x * / fact * fact))%R
r:radix
fact:=ln (IZR r):R
H:(0 < fact)%R
x:R
Hx:(0 < x)%R
(exp (ln x * / fact * fact) <
 exp (IZR (Zfloor (ln x / fact) + 1) * fact))%R
r:radix
fact:=ln (IZR r):R
H:(0 < fact)%R
x:R
Hx:(0 < x)%R
exp (ln x * / fact * fact) = x
apply exp_le.r:radix
fact:=ln (IZR r):R
H:(0 < fact)%R
x:R
Hx:(0 < x)%R
((IZR (Zfloor (ln x / fact) + 1) - 1) * fact <=
 ln x * / fact * fact)%R
r:radix
fact:=ln (IZR r):R
H:(0 < fact)%R
x:R
Hx:(0 < x)%R
(exp (ln x * / fact * fact) <
 exp (IZR (Zfloor (ln x / fact) + 1) * fact))%R
r:radix
fact:=ln (IZR r):R
H:(0 < fact)%R
x:R
Hx:(0 < x)%R
exp (ln x * / fact * fact) = x
apply Rmult_le_compat_r.r:radix
fact:=ln (IZR r):R
H:(0 < fact)%R
x:R
Hx:(0 < x)%R
(0 <= fact)%R
r:radix
fact:=ln (IZR r):R
H:(0 < fact)%R
x:R
Hx:(0 < x)%R
(IZR (Zfloor (ln x / fact) + 1) - 1 <= ln x * / fact)%R
r:radix
fact:=ln (IZR r):R
H:(0 < fact)%R
x:R
Hx:(0 < x)%R
(exp (ln x * / fact * fact) <
 exp (IZR (Zfloor (ln x / fact) + 1) * fact))%R
r:radix
fact:=ln (IZR r):R
H:(0 < fact)%R
x:R
Hx:(0 < x)%R
exp (ln x * / fact * fact) = x
now apply Rlt_le.r:radix
fact:=ln (IZR r):R
H:(0 < fact)%R
x:R
Hx:(0 < x)%R
(IZR (Zfloor (ln x / fact) + 1) - 1 <= ln x * / fact)%R
r:radix
fact:=ln (IZR r):R
H:(0 < fact)%R
x:R
Hx:(0 < x)%R
(exp (ln x * / fact * fact) <
 exp (IZR (Zfloor (ln x / fact) + 1) * fact))%R
r:radix
fact:=ln (IZR r):R
H:(0 < fact)%R
x:R
Hx:(0 < x)%R
exp (ln x * / fact * fact) = x
unfold Rminus.r:radix
fact:=ln (IZR r):R
H:(0 < fact)%R
x:R
Hx:(0 < x)%R
(IZR (Zfloor (ln x / fact) + 1) + - (1) <=
 ln x * / fact)%R
r:radix
fact:=ln (IZR r):R
H:(0 < fact)%R
x:R
Hx:(0 < x)%R
(exp (ln x * / fact * fact) <
 exp (IZR (Zfloor (ln x / fact) + 1) * fact))%R
r:radix
fact:=ln (IZR r):R
H:(0 < fact)%R
x:R
Hx:(0 < x)%R
exp (ln x * / fact * fact) = x
rewrite plus_IZR.r:radix
fact:=ln (IZR r):R
H:(0 < fact)%R
x:R
Hx:(0 < x)%R
(IZR (Zfloor (ln x / fact)) + 1 + - (1) <=
 ln x * / fact)%R
r:radix
fact:=ln (IZR r):R
H:(0 < fact)%R
x:R
Hx:(0 < x)%R
(exp (ln x * / fact * fact) <
 exp (IZR (Zfloor (ln x / fact) + 1) * fact))%R
r:radix
fact:=ln (IZR r):R
H:(0 < fact)%R
x:R
Hx:(0 < x)%R
exp (ln x * / fact * fact) = x
rewrite Rplus_assoc.r:radix
fact:=ln (IZR r):R
H:(0 < fact)%R
x:R
Hx:(0 < x)%R
(IZR (Zfloor (ln x / fact)) + (1 + - (1)) <=
 ln x * / fact)%R
r:radix
fact:=ln (IZR r):R
H:(0 < fact)%R
x:R
Hx:(0 < x)%R
(exp (ln x * / fact * fact) <
 exp (IZR (Zfloor (ln x / fact) + 1) * fact))%R
r:radix
fact:=ln (IZR r):R
H:(0 < fact)%R
x:R
Hx:(0 < x)%R
exp (ln x * / fact * fact) = x
rewrite Rplus_opp_r, Rplus_0_r.r:radix
fact:=ln (IZR r):R
H:(0 < fact)%R
x:R
Hx:(0 < x)%R
(IZR (Zfloor (ln x / fact)) <= ln x * / fact)%R
r:radix
fact:=ln (IZR r):R
H:(0 < fact)%R
x:R
Hx:(0 < x)%R
(exp (ln x * / fact * fact) <
 exp (IZR (Zfloor (ln x / fact) + 1) * fact))%R
r:radix
fact:=ln (IZR r):R
H:(0 < fact)%R
x:R
Hx:(0 < x)%R
exp (ln x * / fact * fact) = x
apply Zfloor_lb.r:radix
fact:=ln (IZR r):R
H:(0 < fact)%R
x:R
Hx:(0 < x)%R
(exp (ln x * / fact * fact) <
 exp (IZR (Zfloor (ln x / fact) + 1) * fact))%R
r:radix
fact:=ln (IZR r):R
H:(0 < fact)%R
x:R
Hx:(0 < x)%R
exp (ln x * / fact * fact) = x
apply exp_increasing.r:radix
fact:=ln (IZR r):R
H:(0 < fact)%R
x:R
Hx:(0 < x)%R
(ln x * / fact * fact <
 IZR (Zfloor (ln x / fact) + 1) * fact)%R
r:radix
fact:=ln (IZR r):R
H:(0 < fact)%R
x:R
Hx:(0 < x)%R
exp (ln x * / fact * fact) = x
apply Rmult_lt_compat_r.r:radix
fact:=ln (IZR r):R
H:(0 < fact)%R
x:R
Hx:(0 < x)%R
(0 < fact)%R
r:radix
fact:=ln (IZR r):R
H:(0 < fact)%R
x:R
Hx:(0 < x)%R
(ln x * / fact < IZR (Zfloor (ln x / fact) + 1))%R
r:radix
fact:=ln (IZR r):R
H:(0 < fact)%R
x:R
Hx:(0 < x)%R
exp (ln x * / fact * fact) = x
exact H.r:radix
fact:=ln (IZR r):R
H:(0 < fact)%R
x:R
Hx:(0 < x)%R
(ln x * / fact < IZR (Zfloor (ln x / fact) + 1))%R
r:radix
fact:=ln (IZR r):R
H:(0 < fact)%R
x:R
Hx:(0 < x)%R
exp (ln x * / fact * fact) = x
rewrite plus_IZR.r:radix
fact:=ln (IZR r):R
H:(0 < fact)%R
x:R
Hx:(0 < x)%R
(ln x * / fact < IZR (Zfloor (ln x / fact)) + 1)%R
r:radix
fact:=ln (IZR r):R
H:(0 < fact)%R
x:R
Hx:(0 < x)%R
exp (ln x * / fact * fact) = x
apply Zfloor_ub.r:radix
fact:=ln (IZR r):R
H:(0 < fact)%R
x:R
Hx:(0 < x)%R
exp (ln x * / fact * fact) = x
rewrite Rmult_assoc.r:radix
fact:=ln (IZR r):R
H:(0 < fact)%R
x:R
Hx:(0 < x)%R
exp (ln x * (/ fact * fact)) = x
rewrite Rinv_l.r:radix
fact:=ln (IZR r):R
H:(0 < fact)%R
x:R
Hx:(0 < x)%R
exp (ln x * 1) = x
r:radix
fact:=ln (IZR r):R
H:(0 < fact)%R
x:R
Hx:(0 < x)%R
fact <> 0%R
rewrite Rmult_1_r.r:radix
fact:=ln (IZR r):R
H:(0 < fact)%R
x:R
Hx:(0 < x)%R
exp (ln x) = x
r:radix
fact:=ln (IZR r):R
H:(0 < fact)%R
x:R
Hx:(0 < x)%R
fact <> 0%R
now apply exp_ln.r:radix
fact:=ln (IZR r):R
H:(0 < fact)%R
x:R
Hx:(0 < x)%R
fact <> 0%R
now apply Rgt_not_eq.
Qed.

Theorem bpow_lt_bpow :
  forall e1 e2,
  (bpow (e1 - 1) < bpow e2)%R ->
  (e1 <= e2)%Z.r:radix
forall e1 e2 : Z,
(bpow (e1 - 1) < bpow e2)%R -> (e1 <= e2)%Z
Proof.r:radix
forall e1 e2 : Z,
(bpow (e1 - 1) < bpow e2)%R -> (e1 <= e2)%Z
intros e1 e2 He.r:radix
e1, e2:Z
He:(bpow (e1 - 1) < bpow e2)%R
(e1 <= e2)%Z
rewrite (Zsucc_pred e1).r:radix
e1, e2:Z
He:(bpow (e1 - 1) < bpow e2)%R
(Z.succ (Z.pred e1) <= e2)%Z
apply Zlt_le_succ.r:radix
e1, e2:Z
He:(bpow (e1 - 1) < bpow e2)%R
(Z.pred e1 < e2)%Z
now apply lt_bpow.
Qed.

Theorem bpow_unique :
  forall x e1 e2,
  (bpow (e1 - 1) <= x < bpow e1)%R ->
  (bpow (e2 - 1) <= x < bpow e2)%R ->
  e1 = e2.r:radix
forall (x : R) (e1 e2 : Z),
(bpow (e1 - 1) <= x < bpow e1)%R ->
(bpow (e2 - 1) <= x < bpow e2)%R -> e1 = e2
Proof.r:radix
forall (x : R) (e1 e2 : Z),
(bpow (e1 - 1) <= x < bpow e1)%R ->
(bpow (e2 - 1) <= x < bpow e2)%R -> e1 = e2
intros x e1 e2 (H1a,H1b) (H2a,H2b).r:radix
x:R
e1, e2:Z
H1a:(bpow (e1 - 1) <= x)%R
H1b:(x < bpow e1)%R
H2a:(bpow (e2 - 1) <= x)%R
H2b:(x < bpow e2)%R
e1 = e2
apply Zle_antisym ;
  apply bpow_lt_bpow ;
  apply Rle_lt_trans with x ;
  assumption.
Qed.

Theorem mag_unique :
  forall (x : R) (e : Z),
  (bpow (e - 1) <= Rabs x < bpow e)%R ->
  mag x = e :> Z.r:radix
forall (x : R) (e : Z),
(bpow (e - 1) <= Rabs x < bpow e)%R -> mag x = e
Proof.r:radix
forall (x : R) (e : Z),
(bpow (e - 1) <= Rabs x < bpow e)%R -> mag x = e
intros x e1 He.r:radix
x:R
e1:Z
He:(bpow (e1 - 1) <= Rabs x < bpow e1)%R
mag x = e1
destruct (Req_dec x 0) as [Hx|Hx].r:radix
x:R
e1:Z
He:(bpow (e1 - 1) <= Rabs x < bpow e1)%R
Hx:x = 0%R
mag x = e1
r:radix
x:R
e1:Z
He:(bpow (e1 - 1) <= Rabs x < bpow e1)%R
Hx:x <> 0%R
mag x = e1
elim Rle_not_lt with (1 := proj1 He).r:radix
x:R
e1:Z
He:(bpow (e1 - 1) <= Rabs x < bpow e1)%R
Hx:x = 0%R
(Rabs x < bpow (e1 - 1))%R
r:radix
x:R
e1:Z
He:(bpow (e1 - 1) <= Rabs x < bpow e1)%R
Hx:x <> 0%R
mag x = e1
rewrite Hx, Rabs_R0.r:radix
x:R
e1:Z
He:(bpow (e1 - 1) <= Rabs x < bpow e1)%R
Hx:x = 0%R
(0 < bpow (e1 - 1))%R
r:radix
x:R
e1:Z
He:(bpow (e1 - 1) <= Rabs x < bpow e1)%R
Hx:x <> 0%R
mag x = e1
apply bpow_gt_0.r:radix
x:R
e1:Z
He:(bpow (e1 - 1) <= Rabs x < bpow e1)%R
Hx:x <> 0%R
mag x = e1
destruct (mag x) as (e2, Hx2).r:radix
x:R
e1:Z
He:(bpow (e1 - 1) <= Rabs x < bpow e1)%R
Hx:x <> 0%R
e2:Z
Hx2:x <> 0%R -> (bpow (e2 - 1) <= Rabs x < bpow e2)%R
Build_mag_prop x e2 Hx2 = e1
simpl.r:radix
x:R
e1:Z
He:(bpow (e1 - 1) <= Rabs x < bpow e1)%R
Hx:x <> 0%R
e2:Z
Hx2:x <> 0%R -> (bpow (e2 - 1) <= Rabs x < bpow e2)%R
e2 = e1
apply bpow_unique with (2 := He).r:radix
x:R
e1:Z
He:(bpow (e1 - 1) <= Rabs x < bpow e1)%R
Hx:x <> 0%R
e2:Z
Hx2:x <> 0%R -> (bpow (e2 - 1) <= Rabs x < bpow e2)%R
(bpow (e2 - 1) <= Rabs x < bpow e2)%R
now apply Hx2.
Qed.

Theorem mag_opp :
  forall x,
  mag (-x) = mag x :> Z.r:radix
forall x : R, mag (- x) = mag x
Proof.r:radix
forall x : R, mag (- x) = mag x
intros x.r:radix
x:R
mag (- x) = mag x
destruct (Req_dec x 0) as [Hx|Hx].r:radix
x:R
Hx:x = 0%R
mag (- x) = mag x
r:radix
x:R
Hx:x <> 0%R
mag (- x) = mag x
now rewrite Hx, Ropp_0.r:radix
x:R
Hx:x <> 0%R
mag (- x) = mag x
destruct (mag x) as (e, He).r:radix
x:R
Hx:x <> 0%R
e:Z
He:x <> 0%R -> (bpow (e - 1) <= Rabs x < bpow e)%R
mag (- x) = Build_mag_prop x e He
simpl.r:radix
x:R
Hx:x <> 0%R
e:Z
He:x <> 0%R -> (bpow (e - 1) <= Rabs x < bpow e)%R
mag (- x) = e
specialize (He Hx).r:radix
x:R
Hx:x <> 0%R
e:Z
He:(bpow (e - 1) <= Rabs x < bpow e)%R
mag (- x) = e
apply mag_unique.r:radix
x:R
Hx:x <> 0%R
e:Z
He:(bpow (e - 1) <= Rabs x < bpow e)%R
(bpow (e - 1) <= Rabs (- x) < bpow e)%R
now rewrite Rabs_Ropp.
Qed.

Theorem mag_abs :
  forall x,
  mag (Rabs x) = mag x :> Z.r:radix
forall x : R, mag (Rabs x) = mag x
Proof.r:radix
forall x : R, mag (Rabs x) = mag x
intros x.r:radix
x:R
mag (Rabs x) = mag x
unfold Rabs.r:radix
x:R
mag (if Rcase_abs x then (- x)%R else x) = mag x
case Rcase_abs ; intros _.r:radix
x:R
mag (- x) = mag x
r:radix
x:R
mag x = mag x
apply mag_opp.r:radix
x:R
mag x = mag x
apply refl_equal.
Qed.

Theorem mag_unique_pos :
  forall (x : R) (e : Z),
  (bpow (e - 1) <= x < bpow e)%R ->
  mag x = e :> Z.r:radix
forall (x : R) (e : Z),
(bpow (e - 1) <= x < bpow e)%R -> mag x = e
Proof.r:radix
forall (x : R) (e : Z),
(bpow (e - 1) <= x < bpow e)%R -> mag x = e
intros x e1 He1.r:radix
x:R
e1:Z
He1:(bpow (e1 - 1) <= x < bpow e1)%R
mag x = e1
rewrite <- mag_abs.r:radix
x:R
e1:Z
He1:(bpow (e1 - 1) <= x < bpow e1)%R
mag (Rabs x) = e1
apply mag_unique.r:radix
x:R
e1:Z
He1:(bpow (e1 - 1) <= x < bpow e1)%R
(bpow (e1 - 1) <= Rabs (Rabs x) < bpow e1)%R
rewrite 2!Rabs_pos_eq.r:radix
x:R
e1:Z
He1:(bpow (e1 - 1) <= x < bpow e1)%R
(bpow (e1 - 1) <= x < bpow e1)%R
r:radix
x:R
e1:Z
He1:(bpow (e1 - 1) <= x < bpow e1)%R
(0 <= x)%R
r:radix
x:R
e1:Z
He1:(bpow (e1 - 1) <= x < bpow e1)%R
(0 <= Rabs x)%R
exact He1.r:radix
x:R
e1:Z
He1:(bpow (e1 - 1) <= x < bpow e1)%R
(0 <= x)%R
r:radix
x:R
e1:Z
He1:(bpow (e1 - 1) <= x < bpow e1)%R
(0 <= Rabs x)%R
apply Rle_trans with (2 := proj1 He1).r:radix
x:R
e1:Z
He1:(bpow (e1 - 1) <= x < bpow e1)%R
(0 <= bpow (e1 - 1))%R
r:radix
x:R
e1:Z
He1:(bpow (e1 - 1) <= x < bpow e1)%R
(0 <= Rabs x)%R
apply bpow_ge_0.r:radix
x:R
e1:Z
He1:(bpow (e1 - 1) <= x < bpow e1)%R
(0 <= Rabs x)%R
apply Rabs_pos.
Qed.

Theorem mag_le_abs :
  forall x y,
  (x <> 0)%R -> (Rabs x <= Rabs y)%R ->
  (mag x <= mag y)%Z.r:radix
forall x y : R,
x <> 0%R -> (Rabs x <= Rabs y)%R -> (mag x <= mag y)%Z
Proof.r:radix
forall x y : R,
x <> 0%R -> (Rabs x <= Rabs y)%R -> (mag x <= mag y)%Z
intros x y H0x Hxy.r:radix
x, y:R
H0x:x <> 0%R
Hxy:(Rabs x <= Rabs y)%R
(mag x <= mag y)%Z
destruct (mag x) as (ex, Hx).r:radix
x, y:R
H0x:x <> 0%R
Hxy:(Rabs x <= Rabs y)%R
ex:Z
Hx:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
(Build_mag_prop x ex Hx <= mag y)%Z
destruct (mag y) as (ey, Hy).r:radix
x, y:R
H0x:x <> 0%R
Hxy:(Rabs x <= Rabs y)%R
ex:Z
Hx:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hy:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
(Build_mag_prop x ex Hx <= Build_mag_prop y ey Hy)%Z
simpl.r:radix
x, y:R
H0x:x <> 0%R
Hxy:(Rabs x <= Rabs y)%R
ex:Z
Hx:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hy:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
(ex <= ey)%Z
apply bpow_lt_bpow.r:radix
x, y:R
H0x:x <> 0%R
Hxy:(Rabs x <= Rabs y)%R
ex:Z
Hx:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hy:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
(bpow (ex - 1) < bpow ey)%R
specialize (Hx H0x).r:radix
x, y:R
H0x:x <> 0%R
Hxy:(Rabs x <= Rabs y)%R
ex:Z
Hx:(bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hy:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
(bpow (ex - 1) < bpow ey)%R
apply Rle_lt_trans with (1 := proj1 Hx).r:radix
x, y:R
H0x:x <> 0%R
Hxy:(Rabs x <= Rabs y)%R
ex:Z
Hx:(bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hy:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
(Rabs x < bpow ey)%R
apply Rle_lt_trans with (1 := Hxy).r:radix
x, y:R
H0x:x <> 0%R
Hxy:(Rabs x <= Rabs y)%R
ex:Z
Hx:(bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hy:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
(Rabs y < bpow ey)%R
apply Hy.r:radix
x, y:R
H0x:x <> 0%R
Hxy:(Rabs x <= Rabs y)%R
ex:Z
Hx:(bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hy:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
y <> 0%R
intros Hy'.r:radix
x, y:R
H0x:x <> 0%R
Hxy:(Rabs x <= Rabs y)%R
ex:Z
Hx:(bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hy:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
Hy':y = 0%R
False
apply Rlt_not_le with (1 := Rabs_pos_lt _ H0x).r:radix
x, y:R
H0x:x <> 0%R
Hxy:(Rabs x <= Rabs y)%R
ex:Z
Hx:(bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hy:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
Hy':y = 0%R
(Rabs x <= 0)%R
apply Rle_trans with (1 := Hxy).r:radix
x, y:R
H0x:x <> 0%R
Hxy:(Rabs x <= Rabs y)%R
ex:Z
Hx:(bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hy:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
Hy':y = 0%R
(Rabs y <= 0)%R
rewrite Hy', Rabs_R0.r:radix
x, y:R
H0x:x <> 0%R
Hxy:(Rabs x <= Rabs y)%R
ex:Z
Hx:(bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hy:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
Hy':y = 0%R
(0 <= 0)%R
apply Rle_refl.
Qed.

Theorem mag_le :
  forall x y,
  (0 < x)%R -> (x <= y)%R ->
  (mag x <= mag y)%Z.r:radix
forall x y : R,
(0 < x)%R -> (x <= y)%R -> (mag x <= mag y)%Z
Proof.r:radix
forall x y : R,
(0 < x)%R -> (x <= y)%R -> (mag x <= mag y)%Z
intros x y H0x Hxy.r:radix
x, y:R
H0x:(0 < x)%R
Hxy:(x <= y)%R
(mag x <= mag y)%Z
apply mag_le_abs.r:radix
x, y:R
H0x:(0 < x)%R
Hxy:(x <= y)%R
x <> 0%R
r:radix
x, y:R
H0x:(0 < x)%R
Hxy:(x <= y)%R
(Rabs x <= Rabs y)%R
now apply Rgt_not_eq.r:radix
x, y:R
H0x:(0 < x)%R
Hxy:(x <= y)%R
(Rabs x <= Rabs y)%R
rewrite 2!Rabs_pos_eq.r:radix
x, y:R
H0x:(0 < x)%R
Hxy:(x <= y)%R
(x <= y)%R
r:radix
x, y:R
H0x:(0 < x)%R
Hxy:(x <= y)%R
(0 <= y)%R
r:radix
x, y:R
H0x:(0 < x)%R
Hxy:(x <= y)%R
(0 <= x)%R
exact Hxy.r:radix
x, y:R
H0x:(0 < x)%R
Hxy:(x <= y)%R
(0 <= y)%R
r:radix
x, y:R
H0x:(0 < x)%R
Hxy:(x <= y)%R
(0 <= x)%R
apply Rle_trans with (2 := Hxy).r:radix
x, y:R
H0x:(0 < x)%R
Hxy:(x <= y)%R
(0 <= x)%R
r:radix
x, y:R
H0x:(0 < x)%R
Hxy:(x <= y)%R
(0 <= x)%R
now apply Rlt_le.r:radix
x, y:R
H0x:(0 < x)%R
Hxy:(x <= y)%R
(0 <= x)%R
now apply Rlt_le.
Qed.

Lemma lt_mag :
  forall x y,
  (0 < y)%R ->
  (mag x < mag y)%Z -> (x < y)%R.r:radix
forall x y : R,
(0 < y)%R -> (mag x < mag y)%Z -> (x < y)%R
Proof.r:radix
forall x y : R,
(0 < y)%R -> (mag x < mag y)%Z -> (x < y)%R
intros x y Py.r:radix
x, y:R
Py:(0 < y)%R
(mag x < mag y)%Z -> (x < y)%R
case (Rle_or_lt x 0); intros Px.r:radix
x, y:R
Py:(0 < y)%R
Px:(x <= 0)%R
(mag x < mag y)%Z -> (x < y)%R
r:radix
x, y:R
Py:(0 < y)%R
Px:(0 < x)%R
(mag x < mag y)%Z -> (x < y)%R
intros H.r:radix
x, y:R
Py:(0 < y)%R
Px:(x <= 0)%R
H:(mag x < mag y)%Z
(x < y)%R
r:radix
x, y:R
Py:(0 < y)%R
Px:(0 < x)%R
(mag x < mag y)%Z -> (x < y)%R
now apply Rle_lt_trans with 0%R.r:radix
x, y:R
Py:(0 < y)%R
Px:(0 < x)%R
(mag x < mag y)%Z -> (x < y)%R
destruct (mag x) as (ex, Hex).r:radix
x, y:R
Py:(0 < y)%R
Px:(0 < x)%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
(Build_mag_prop x ex Hex < mag y)%Z -> (x < y)%R
destruct (mag y) as (ey, Hey).r:radix
x, y:R
Py:(0 < y)%R
Px:(0 < x)%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
(Build_mag_prop x ex Hex < Build_mag_prop y ey Hey)%Z ->
(x < y)%R
simpl.r:radix
x, y:R
Py:(0 < y)%R
Px:(0 < x)%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
(ex < ey)%Z -> (x < y)%R
intro H.r:radix
x, y:R
Py:(0 < y)%R
Px:(0 < x)%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
H:(ex < ey)%Z
(x < y)%R
destruct Hex as (_,Hex); [now apply Rgt_not_eq|].r:radix
x, y:R
Py:(0 < y)%R
Px:(0 < x)%R
ex, ey:Z
Hey:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
H:(ex < ey)%Z
Hex:(Rabs x < bpow ex)%R
(x < y)%R
destruct Hey as (Hey,_); [now apply Rgt_not_eq|].r:radix
x, y:R
Py:(0 < y)%R
Px:(0 < x)%R
ex, ey:Z
H:(ex < ey)%Z
Hex:(Rabs x < bpow ex)%R
Hey:(bpow (ey - 1) <= Rabs y)%R
(x < y)%R
rewrite Rabs_right in Hex; [|now apply Rle_ge; apply Rlt_le].r:radix
x, y:R
Py:(0 < y)%R
Px:(0 < x)%R
ex, ey:Z
H:(ex < ey)%Z
Hex:(x < bpow ex)%R
Hey:(bpow (ey - 1) <= Rabs y)%R
(x < y)%R
rewrite Rabs_right in Hey; [|now apply Rle_ge; apply Rlt_le].r:radix
x, y:R
Py:(0 < y)%R
Px:(0 < x)%R
ex, ey:Z
H:(ex < ey)%Z
Hex:(x < bpow ex)%R
Hey:(bpow (ey - 1) <= y)%R
(x < y)%R
apply (Rlt_le_trans _ _ _ Hex).r:radix
x, y:R
Py:(0 < y)%R
Px:(0 < x)%R
ex, ey:Z
H:(ex < ey)%Z
Hex:(x < bpow ex)%R
Hey:(bpow (ey - 1) <= y)%R
(bpow ex <= y)%R
apply Rle_trans with (bpow (ey - 1)); [|exact Hey].r:radix
x, y:R
Py:(0 < y)%R
Px:(0 < x)%R
ex, ey:Z
H:(ex < ey)%Z
Hex:(x < bpow ex)%R
Hey:(bpow (ey - 1) <= y)%R
(bpow ex <= bpow (ey - 1))%R
now apply bpow_le; omega.
Qed.

Theorem mag_bpow :
  forall e, (mag (bpow e) = e + 1 :> Z)%Z.r:radix
forall e : Z, mag (bpow e) = (e + 1)%Z
Proof.r:radix
forall e : Z, mag (bpow e) = (e + 1)%Z
intros e.r:radix
e:Z
mag (bpow e) = (e + 1)%Z
apply mag_unique.r:radix
e:Z
(bpow (e + 1 - 1) <= Rabs (bpow e) < bpow (e + 1))%R
rewrite Rabs_right.r:radix
e:Z
(bpow (e + 1 - 1) <= bpow e < bpow (e + 1))%R
r:radix
e:Z
(bpow e >= 0)%R
replace (e + 1 - 1)%Z with e by ring.r:radix
e:Z
(bpow e <= bpow e < bpow (e + 1))%R
r:radix
e:Z
(bpow e >= 0)%R
split.r:radix
e:Z
(bpow e <= bpow e)%R
r:radix
e:Z
(bpow e < bpow (e + 1))%R
r:radix
e:Z
(bpow e >= 0)%R
apply Rle_refl.r:radix
e:Z
(bpow e < bpow (e + 1))%R
r:radix
e:Z
(bpow e >= 0)%R
apply bpow_lt.r:radix
e:Z
(e < e + 1)%Z
r:radix
e:Z
(bpow e >= 0)%R
apply Zlt_succ.r:radix
e:Z
(bpow e >= 0)%R
apply Rle_ge.r:radix
e:Z
(0 <= bpow e)%R
apply bpow_ge_0.
Qed.

Theorem mag_mult_bpow :
  forall x e, x <> 0%R ->
  (mag (x * bpow e) = mag x + e :>Z)%Z.r:radix
forall (x : R) (e : Z),
x <> 0%R -> mag (x * bpow e) = (mag x + e)%Z
Proof.r:radix
forall (x : R) (e : Z),
x <> 0%R -> mag (x * bpow e) = (mag x + e)%Z
intros x e Zx.r:radix
x:R
e:Z
Zx:x <> 0%R
mag (x * bpow e) = (mag x + e)%Z
destruct (mag x) as (ex, Ex) ; simpl.r:radix
x:R
e:Z
Zx:x <> 0%R
ex:Z
Ex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
mag (x * bpow e) = (ex + e)%Z
specialize (Ex Zx).r:radix
x:R
e:Z
Zx:x <> 0%R
ex:Z
Ex:(bpow (ex - 1) <= Rabs x < bpow ex)%R
mag (x * bpow e) = (ex + e)%Z
apply mag_unique.r:radix
x:R
e:Z
Zx:x <> 0%R
ex:Z
Ex:(bpow (ex - 1) <= Rabs x < bpow ex)%R
(bpow (ex + e - 1) <= Rabs (x * bpow e) <
 bpow (ex + e))%R
rewrite Rabs_mult.r:radix
x:R
e:Z
Zx:x <> 0%R
ex:Z
Ex:(bpow (ex - 1) <= Rabs x < bpow ex)%R
(bpow (ex + e - 1) <= Rabs x * Rabs (bpow e) <
 bpow (ex + e))%R
rewrite (Rabs_pos_eq (bpow e)) by apply bpow_ge_0.r:radix
x:R
e:Z
Zx:x <> 0%R
ex:Z
Ex:(bpow (ex - 1) <= Rabs x < bpow ex)%R
(bpow (ex + e - 1) <= Rabs x * bpow e < bpow (ex + e))%R
split.r:radix
x:R
e:Z
Zx:x <> 0%R
ex:Z
Ex:(bpow (ex - 1) <= Rabs x < bpow ex)%R
(bpow (ex + e - 1) <= Rabs x * bpow e)%R
r:radix
x:R
e:Z
Zx:x <> 0%R
ex:Z
Ex:(bpow (ex - 1) <= Rabs x < bpow ex)%R
(Rabs x * bpow e < bpow (ex + e))%R
replace (ex + e - 1)%Z with (ex - 1 + e)%Z by ring.r:radix
x:R
e:Z
Zx:x <> 0%R
ex:Z
Ex:(bpow (ex - 1) <= Rabs x < bpow ex)%R
(bpow (ex - 1 + e) <= Rabs x * bpow e)%R
r:radix
x:R
e:Z
Zx:x <> 0%R
ex:Z
Ex:(bpow (ex - 1) <= Rabs x < bpow ex)%R
(Rabs x * bpow e < bpow (ex + e))%R
rewrite bpow_plus.r:radix
x:R
e:Z
Zx:x <> 0%R
ex:Z
Ex:(bpow (ex - 1) <= Rabs x < bpow ex)%R
(bpow (ex - 1) * bpow e <= Rabs x * bpow e)%R
r:radix
x:R
e:Z
Zx:x <> 0%R
ex:Z
Ex:(bpow (ex - 1) <= Rabs x < bpow ex)%R
(Rabs x * bpow e < bpow (ex + e))%R
apply Rmult_le_compat_r.r:radix
x:R
e:Z
Zx:x <> 0%R
ex:Z
Ex:(bpow (ex - 1) <= Rabs x < bpow ex)%R
(0 <= bpow e)%R
r:radix
x:R
e:Z
Zx:x <> 0%R
ex:Z
Ex:(bpow (ex - 1) <= Rabs x < bpow ex)%R
(bpow (ex - 1) <= Rabs x)%R
r:radix
x:R
e:Z
Zx:x <> 0%R
ex:Z
Ex:(bpow (ex - 1) <= Rabs x < bpow ex)%R
(Rabs x * bpow e < bpow (ex + e))%R
apply bpow_ge_0.r:radix
x:R
e:Z
Zx:x <> 0%R
ex:Z
Ex:(bpow (ex - 1) <= Rabs x < bpow ex)%R
(bpow (ex - 1) <= Rabs x)%R
r:radix
x:R
e:Z
Zx:x <> 0%R
ex:Z
Ex:(bpow (ex - 1) <= Rabs x < bpow ex)%R
(Rabs x * bpow e < bpow (ex + e))%R
apply Ex.r:radix
x:R
e:Z
Zx:x <> 0%R
ex:Z
Ex:(bpow (ex - 1) <= Rabs x < bpow ex)%R
(Rabs x * bpow e < bpow (ex + e))%R
rewrite bpow_plus.r:radix
x:R
e:Z
Zx:x <> 0%R
ex:Z
Ex:(bpow (ex - 1) <= Rabs x < bpow ex)%R
(Rabs x * bpow e < bpow ex * bpow e)%R
apply Rmult_lt_compat_r.r:radix
x:R
e:Z
Zx:x <> 0%R
ex:Z
Ex:(bpow (ex - 1) <= Rabs x < bpow ex)%R
(0 < bpow e)%R
r:radix
x:R
e:Z
Zx:x <> 0%R
ex:Z
Ex:(bpow (ex - 1) <= Rabs x < bpow ex)%R
(Rabs x < bpow ex)%R
apply bpow_gt_0.r:radix
x:R
e:Z
Zx:x <> 0%R
ex:Z
Ex:(bpow (ex - 1) <= Rabs x < bpow ex)%R
(Rabs x < bpow ex)%R
apply Ex.
Qed.

Theorem mag_le_bpow :
  forall x e,
  x <> 0%R ->
  (Rabs x < bpow e)%R ->
  (mag x <= e)%Z.r:radix
forall (x : R) (e : Z),
x <> 0%R -> (Rabs x < bpow e)%R -> (mag x <= e)%Z
Proof.r:radix
forall (x : R) (e : Z),
x <> 0%R -> (Rabs x < bpow e)%R -> (mag x <= e)%Z
intros x e Zx Hx.r:radix
x:R
e:Z
Zx:x <> 0%R
Hx:(Rabs x < bpow e)%R
(mag x <= e)%Z
destruct (mag x) as (ex, Ex) ; simpl.r:radix
x:R
e:Z
Zx:x <> 0%R
Hx:(Rabs x < bpow e)%R
ex:Z
Ex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
(ex <= e)%Z
specialize (Ex Zx).r:radix
x:R
e:Z
Zx:x <> 0%R
Hx:(Rabs x < bpow e)%R
ex:Z
Ex:(bpow (ex - 1) <= Rabs x < bpow ex)%R
(ex <= e)%Z
apply bpow_lt_bpow.r:radix
x:R
e:Z
Zx:x <> 0%R
Hx:(Rabs x < bpow e)%R
ex:Z
Ex:(bpow (ex - 1) <= Rabs x < bpow ex)%R
(bpow (ex - 1) < bpow e)%R
now apply Rle_lt_trans with (Rabs x).
Qed.

Theorem mag_gt_bpow :
  forall x e,
  (bpow e <= Rabs x)%R ->
  (e < mag x)%Z.r:radix
forall (x : R) (e : Z),
(bpow e <= Rabs x)%R -> (e < mag x)%Z
Proof.r:radix
forall (x : R) (e : Z),
(bpow e <= Rabs x)%R -> (e < mag x)%Z
intros x e Hx.r:radix
x:R
e:Z
Hx:(bpow e <= Rabs x)%R
(e < mag x)%Z
destruct (mag x) as (ex, Ex) ; simpl.r:radix
x:R
e:Z
Hx:(bpow e <= Rabs x)%R
ex:Z
Ex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
(e < ex)%Z
apply lt_bpow.r:radix
x:R
e:Z
Hx:(bpow e <= Rabs x)%R
ex:Z
Ex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
(bpow e < bpow ex)%R
apply Rle_lt_trans with (1 := Hx).r:radix
x:R
e:Z
Hx:(bpow e <= Rabs x)%R
ex:Z
Ex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
(Rabs x < bpow ex)%R
apply Ex.r:radix
x:R
e:Z
Hx:(bpow e <= Rabs x)%R
ex:Z
Ex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
x <> 0%R
intros Zx.r:radix
x:R
e:Z
Hx:(bpow e <= Rabs x)%R
ex:Z
Ex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
Zx:x = 0%R
False
apply Rle_not_lt with (1 := Hx).r:radix
x:R
e:Z
Hx:(bpow e <= Rabs x)%R
ex:Z
Ex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
Zx:x = 0%R
(Rabs x < bpow e)%R
rewrite Zx, Rabs_R0.r:radix
x:R
e:Z
Hx:(bpow e <= Rabs x)%R
ex:Z
Ex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
Zx:x = 0%R
(0 < bpow e)%R
apply bpow_gt_0.
Qed.

Theorem mag_ge_bpow :
  forall x e,
  (bpow (e - 1) <= Rabs x)%R ->
  (e <= mag x)%Z.r:radix
forall (x : R) (e : Z),
(bpow (e - 1) <= Rabs x)%R -> (e <= mag x)%Z
Proof.r:radix
forall (x : R) (e : Z),
(bpow (e - 1) <= Rabs x)%R -> (e <= mag x)%Z
intros x e H.r:radix
x:R
e:Z
H:(bpow (e - 1) <= Rabs x)%R
(e <= mag x)%Z
destruct (Rlt_or_le (Rabs x) (bpow e)) as [Hxe|Hxe].r:radix
x:R
e:Z
H:(bpow (e - 1) <= Rabs x)%R
Hxe:(Rabs x < bpow e)%R
(e <= mag x)%Z
r:radix
x:R
e:Z
H:(bpow (e - 1) <= Rabs x)%R
Hxe:(bpow e <= Rabs x)%R
(e <= mag x)%Z
- (* Rabs x w bpow e *)r:radix
x:R
e:Z
H:(bpow (e - 1) <= Rabs x)%R
Hxe:(Rabs x < bpow e)%R
(e <= mag x)%Z
  assert (mag x = e :> Z) as Hln.r:radix
x:R
e:Z
H:(bpow (e - 1) <= Rabs x)%R
Hxe:(Rabs x < bpow e)%R
mag x = e
r:radix
x:R
e:Z
H:(bpow (e - 1) <= Rabs x)%R
Hxe:(Rabs x < bpow e)%R
Hln:mag x = e
(e <= mag x)%Z
  now apply mag_unique; split.r:radix
x:R
e:Z
H:(bpow (e - 1) <= Rabs x)%R
Hxe:(Rabs x < bpow e)%R
Hln:mag x = e
(e <= mag x)%Z
  rewrite Hln.r:radix
x:R
e:Z
H:(bpow (e - 1) <= Rabs x)%R
Hxe:(Rabs x < bpow e)%R
Hln:mag x = e
(e <= e)%Z
  now apply Z.le_refl.
- (* bpow e <= Rabs x *)r:radix
x:R
e:Z
H:(bpow (e - 1) <= Rabs x)%R
Hxe:(bpow e <= Rabs x)%R
(e <= mag x)%Z
  apply Zlt_le_weak.r:radix
x:R
e:Z
H:(bpow (e - 1) <= Rabs x)%R
Hxe:(bpow e <= Rabs x)%R
(e < mag x)%Z
  now apply mag_gt_bpow.
Qed.

Theorem bpow_mag_gt :
  forall x,
  (Rabs x < bpow (mag x))%R.r:radix
forall x : R, (Rabs x < bpow (mag x))%R
Proof.r:radix
forall x : R, (Rabs x < bpow (mag x))%R
intros x.r:radix
x:R
(Rabs x < bpow (mag x))%R
destruct (Req_dec x 0) as [Zx|Zx].r:radix
x:R
Zx:x = 0%R
(Rabs x < bpow (mag x))%R
r:radix
x:R
Zx:x <> 0%R
(Rabs x < bpow (mag x))%R
rewrite Zx, Rabs_R0.r:radix
x:R
Zx:x = 0%R
(0 < bpow (mag 0))%R
r:radix
x:R
Zx:x <> 0%R
(Rabs x < bpow (mag x))%R
apply bpow_gt_0.r:radix
x:R
Zx:x <> 0%R
(Rabs x < bpow (mag x))%R
destruct (mag x) as (ex, Ex) ; simpl.r:radix
x:R
Zx:x <> 0%R
ex:Z
Ex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
(Rabs x < bpow ex)%R
now apply Ex.
Qed.

Theorem bpow_mag_le :
  forall x, (x <> 0)%R ->
    (bpow (mag x-1) <= Rabs x)%R.r:radix
forall x : R,
x <> 0%R -> (bpow (mag x - 1) <= Rabs x)%R
Proof.r:radix
forall x : R,
x <> 0%R -> (bpow (mag x - 1) <= Rabs x)%R
intros x Hx.r:radix
x:R
Hx:x <> 0%R
(bpow (mag x - 1) <= Rabs x)%R
destruct (mag x) as (ex, Ex) ; simpl.r:radix
x:R
Hx:x <> 0%R
ex:Z
Ex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
(bpow (ex - 1) <= Rabs x)%R
now apply Ex.
Qed.


Theorem mag_le_Zpower :
  forall m e,
  m <> Z0 ->
  (Z.abs m < Zpower r e)%Z->
  (mag (IZR m) <= e)%Z.r:radix
forall m e : Z,
m <> 0%Z ->
(Z.abs m < r ^ e)%Z -> (mag (IZR m) <= e)%Z
Proof.r:radix
forall m e : Z,
m <> 0%Z ->
(Z.abs m < r ^ e)%Z -> (mag (IZR m) <= e)%Z
intros m e Zm Hm.r:radix
m, e:Z
Zm:m <> 0%Z
Hm:(Z.abs m < r ^ e)%Z
(mag (IZR m) <= e)%Z
apply mag_le_bpow.r:radix
m, e:Z
Zm:m <> 0%Z
Hm:(Z.abs m < r ^ e)%Z
IZR m <> 0%R
r:radix
m, e:Z
Zm:m <> 0%Z
Hm:(Z.abs m < r ^ e)%Z
(Rabs (IZR m) < bpow e)%R
now apply IZR_neq.r:radix
m, e:Z
Zm:m <> 0%Z
Hm:(Z.abs m < r ^ e)%Z
(Rabs (IZR m) < bpow e)%R
destruct (Zle_or_lt 0 e).r:radix
m, e:Z
Zm:m <> 0%Z
Hm:(Z.abs m < r ^ e)%Z
H:(0 <= e)%Z
(Rabs (IZR m) < bpow e)%R
r:radix
m, e:Z
Zm:m <> 0%Z
Hm:(Z.abs m < r ^ e)%Z
H:(e < 0)%Z
(Rabs (IZR m) < bpow e)%R
rewrite <- abs_IZR, <- IZR_Zpower with (1 := H).r:radix
m, e:Z
Zm:m <> 0%Z
Hm:(Z.abs m < r ^ e)%Z
H:(0 <= e)%Z
(IZR (Z.abs m) < IZR (r ^ e))%R
r:radix
m, e:Z
Zm:m <> 0%Z
Hm:(Z.abs m < r ^ e)%Z
H:(e < 0)%Z
(Rabs (IZR m) < bpow e)%R
now apply IZR_lt.r:radix
m, e:Z
Zm:m <> 0%Z
Hm:(Z.abs m < r ^ e)%Z
H:(e < 0)%Z
(Rabs (IZR m) < bpow e)%R
elim Zm.r:radix
m, e:Z
Zm:m <> 0%Z
Hm:(Z.abs m < r ^ e)%Z
H:(e < 0)%Z
m = 0%Z
cut (Z.abs m < 0)%Z.r:radix
m, e:Z
Zm:m <> 0%Z
Hm:(Z.abs m < r ^ e)%Z
H:(e < 0)%Z
(Z.abs m < 0)%Z -> m = 0%Z
r:radix
m, e:Z
Zm:m <> 0%Z
Hm:(Z.abs m < r ^ e)%Z
H:(e < 0)%Z
(Z.abs m < 0)%Z
now case m.r:radix
m, e:Z
Zm:m <> 0%Z
Hm:(Z.abs m < r ^ e)%Z
H:(e < 0)%Z
(Z.abs m < 0)%Z
clear -Hm H.r:radix
m, e:Z
Hm:(Z.abs m < r ^ e)%Z
H:(e < 0)%Z
(Z.abs m < 0)%Z
now destruct e.
Qed.

Theorem mag_gt_Zpower :
  forall m e,
  m <> Z0 ->
  (Zpower r e <= Z.abs m)%Z ->
  (e < mag (IZR m))%Z.r:radix
forall m e : Z,
m <> 0%Z ->
(r ^ e <= Z.abs m)%Z -> (e < mag (IZR m))%Z
Proof.r:radix
forall m e : Z,
m <> 0%Z ->
(r ^ e <= Z.abs m)%Z -> (e < mag (IZR m))%Z
intros m e Zm Hm.r:radix
m, e:Z
Zm:m <> 0%Z
Hm:(r ^ e <= Z.abs m)%Z
(e < mag (IZR m))%Z
apply mag_gt_bpow.r:radix
m, e:Z
Zm:m <> 0%Z
Hm:(r ^ e <= Z.abs m)%Z
(bpow e <= Rabs (IZR m))%R
rewrite <- abs_IZR.r:radix
m, e:Z
Zm:m <> 0%Z
Hm:(r ^ e <= Z.abs m)%Z
(bpow e <= IZR (Z.abs m))%R
destruct (Zle_or_lt 0 e).r:radix
m, e:Z
Zm:m <> 0%Z
Hm:(r ^ e <= Z.abs m)%Z
H:(0 <= e)%Z
(bpow e <= IZR (Z.abs m))%R
r:radix
m, e:Z
Zm:m <> 0%Z
Hm:(r ^ e <= Z.abs m)%Z
H:(e < 0)%Z
(bpow e <= IZR (Z.abs m))%R
rewrite <- IZR_Zpower with (1 := H).r:radix
m, e:Z
Zm:m <> 0%Z
Hm:(r ^ e <= Z.abs m)%Z
H:(0 <= e)%Z
(IZR (r ^ e) <= IZR (Z.abs m))%R
r:radix
m, e:Z
Zm:m <> 0%Z
Hm:(r ^ e <= Z.abs m)%Z
H:(e < 0)%Z
(bpow e <= IZR (Z.abs m))%R
now apply IZR_le.r:radix
m, e:Z
Zm:m <> 0%Z
Hm:(r ^ e <= Z.abs m)%Z
H:(e < 0)%Z
(bpow e <= IZR (Z.abs m))%R
apply Rle_trans with (bpow 0).r:radix
m, e:Z
Zm:m <> 0%Z
Hm:(r ^ e <= Z.abs m)%Z
H:(e < 0)%Z
(bpow e <= bpow 0)%R
r:radix
m, e:Z
Zm:m <> 0%Z
Hm:(r ^ e <= Z.abs m)%Z
H:(e < 0)%Z
(bpow 0 <= IZR (Z.abs m))%R
apply bpow_le.r:radix
m, e:Z
Zm:m <> 0%Z
Hm:(r ^ e <= Z.abs m)%Z
H:(e < 0)%Z
(e <= 0)%Z
r:radix
m, e:Z
Zm:m <> 0%Z
Hm:(r ^ e <= Z.abs m)%Z
H:(e < 0)%Z
(bpow 0 <= IZR (Z.abs m))%R
now apply Zlt_le_weak.r:radix
m, e:Z
Zm:m <> 0%Z
Hm:(r ^ e <= Z.abs m)%Z
H:(e < 0)%Z
(bpow 0 <= IZR (Z.abs m))%R
apply IZR_le.r:radix
m, e:Z
Zm:m <> 0%Z
Hm:(r ^ e <= Z.abs m)%Z
H:(e < 0)%Z
(1 <= Z.abs m)%Z
clear -Zm.m:Z
Zm:m <> 0%Z
(1 <= Z.abs m)%Z
zify ; omega.
Qed.

Lemma mag_mult :
  forall x y,
  (x <> 0)%R -> (y <> 0)%R ->
  (mag x + mag y - 1 <= mag (x * y) <= mag x + mag y)%Z.r:radix
forall x y : R,
x <> 0%R ->
y <> 0%R ->
(mag x + mag y - 1 <= mag (x * y) <= mag x + mag y)%Z
Proof.r:radix
forall x y : R,
x <> 0%R ->
y <> 0%R ->
(mag x + mag y - 1 <= mag (x * y) <= mag x + mag y)%Z
intros x y Hx Hy.r:radix
x, y:R
Hx:x <> 0%R
Hy:y <> 0%R
(mag x + mag y - 1 <= mag (x * y) <= mag x + mag y)%Z
destruct (mag x) as (ex, Hx2).r:radix
x, y:R
Hx:x <> 0%R
Hy:y <> 0%R
ex:Z
Hx2:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
(Build_mag_prop x ex Hx2 + mag y - 1 <= mag (x * y) <=
 Build_mag_prop x ex Hx2 + mag y)%Z
destruct (mag y) as (ey, Hy2).r:radix
x, y:R
Hx:x <> 0%R
Hy:y <> 0%R
ex:Z
Hx2:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hy2:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
(Build_mag_prop x ex Hx2 + Build_mag_prop y ey Hy2 - 1 <=
 mag (x * y) <=
 Build_mag_prop x ex Hx2 + Build_mag_prop y ey Hy2)%Z
simpl.r:radix
x, y:R
Hx:x <> 0%R
Hy:y <> 0%R
ex:Z
Hx2:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hy2:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
(ex + ey - 1 <= mag (x * y) <= ex + ey)%Z
destruct (Hx2 Hx) as (Hx21,Hx22); clear Hx2.r:radix
x, y:R
Hx:x <> 0%R
Hy:y <> 0%R
ex, ey:Z
Hy2:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
Hx21:(bpow (ex - 1) <= Rabs x)%R
Hx22:(Rabs x < bpow ex)%R
(ex + ey - 1 <= mag (x * y) <= ex + ey)%Z
destruct (Hy2 Hy) as (Hy21,Hy22); clear Hy2.r:radix
x, y:R
Hx:x <> 0%R
Hy:y <> 0%R
ex, ey:Z
Hx21:(bpow (ex - 1) <= Rabs x)%R
Hx22:(Rabs x < bpow ex)%R
Hy21:(bpow (ey - 1) <= Rabs y)%R
Hy22:(Rabs y < bpow ey)%R
(ex + ey - 1 <= mag (x * y) <= ex + ey)%Z
assert (Hxy : (bpow (ex + ey - 1 - 1) <= Rabs (x * y))%R).r:radix
x, y:R
Hx:x <> 0%R
Hy:y <> 0%R
ex, ey:Z
Hx21:(bpow (ex - 1) <= Rabs x)%R
Hx22:(Rabs x < bpow ex)%R
Hy21:(bpow (ey - 1) <= Rabs y)%R
Hy22:(Rabs y < bpow ey)%R
(bpow (ex + ey - 1 - 1) <= Rabs (x * y))%R
r:radix
x, y:R
Hx:x <> 0%R
Hy:y <> 0%R
ex, ey:Z
Hx21:(bpow (ex - 1) <= Rabs x)%R
Hx22:(Rabs x < bpow ex)%R
Hy21:(bpow (ey - 1) <= Rabs y)%R
Hy22:(Rabs y < bpow ey)%R
Hxy:(bpow (ex + ey - 1 - 1) <= Rabs (x * y))%R
(ex + ey - 1 <= mag (x * y) <= ex + ey)%Z
{r:radix
x, y:R
Hx:x <> 0%R
Hy:y <> 0%R
ex, ey:Z
Hx21:(bpow (ex - 1) <= Rabs x)%R
Hx22:(Rabs x < bpow ex)%R
Hy21:(bpow (ey - 1) <= Rabs y)%R
Hy22:(Rabs y < bpow ey)%R
(bpow (ex + ey - 1 - 1) <= Rabs (x * y))%R replace (ex + ey -1 -1)%Z with (ex - 1 + (ey - 1))%Z; [|ring].r:radix
x, y:R
Hx:x <> 0%R
Hy:y <> 0%R
ex, ey:Z
Hx21:(bpow (ex - 1) <= Rabs x)%R
Hx22:(Rabs x < bpow ex)%R
Hy21:(bpow (ey - 1) <= Rabs y)%R
Hy22:(Rabs y < bpow ey)%R
(bpow (ex - 1 + (ey - 1)) <= Rabs (x * y))%R
  rewrite bpow_plus.r:radix
x, y:R
Hx:x <> 0%R
Hy:y <> 0%R
ex, ey:Z
Hx21:(bpow (ex - 1) <= Rabs x)%R
Hx22:(Rabs x < bpow ex)%R
Hy21:(bpow (ey - 1) <= Rabs y)%R
Hy22:(Rabs y < bpow ey)%R
(bpow (ex - 1) * bpow (ey - 1) <= Rabs (x * y))%R
  rewrite Rabs_mult.r:radix
x, y:R
Hx:x <> 0%R
Hy:y <> 0%R
ex, ey:Z
Hx21:(bpow (ex - 1) <= Rabs x)%R
Hx22:(Rabs x < bpow ex)%R
Hy21:(bpow (ey - 1) <= Rabs y)%R
Hy22:(Rabs y < bpow ey)%R
(bpow (ex - 1) * bpow (ey - 1) <= Rabs x * Rabs y)%R
  now apply Rmult_le_compat; try apply bpow_ge_0. }r:radix
x, y:R
Hx:x <> 0%R
Hy:y <> 0%R
ex, ey:Z
Hx21:(bpow (ex - 1) <= Rabs x)%R
Hx22:(Rabs x < bpow ex)%R
Hy21:(bpow (ey - 1) <= Rabs y)%R
Hy22:(Rabs y < bpow ey)%R
Hxy:(bpow (ex + ey - 1 - 1) <= Rabs (x * y))%R
(ex + ey - 1 <= mag (x * y) <= ex + ey)%Z
assert (Hxy2 : (Rabs (x * y) < bpow (ex + ey))%R).r:radix
x, y:R
Hx:x <> 0%R
Hy:y <> 0%R
ex, ey:Z
Hx21:(bpow (ex - 1) <= Rabs x)%R
Hx22:(Rabs x < bpow ex)%R
Hy21:(bpow (ey - 1) <= Rabs y)%R
Hy22:(Rabs y < bpow ey)%R
Hxy:(bpow (ex + ey - 1 - 1) <= Rabs (x * y))%R
(Rabs (x * y) < bpow (ex + ey))%R
r:radix
x, y:R
Hx:x <> 0%R
Hy:y <> 0%R
ex, ey:Z
Hx21:(bpow (ex - 1) <= Rabs x)%R
Hx22:(Rabs x < bpow ex)%R
Hy21:(bpow (ey - 1) <= Rabs y)%R
Hy22:(Rabs y < bpow ey)%R
Hxy:(bpow (ex + ey - 1 - 1) <= Rabs (x * y))%R
Hxy2:(Rabs (x * y) < bpow (ex + ey))%R
(ex + ey - 1 <= mag (x * y) <= ex + ey)%Z
{r:radix
x, y:R
Hx:x <> 0%R
Hy:y <> 0%R
ex, ey:Z
Hx21:(bpow (ex - 1) <= Rabs x)%R
Hx22:(Rabs x < bpow ex)%R
Hy21:(bpow (ey - 1) <= Rabs y)%R
Hy22:(Rabs y < bpow ey)%R
Hxy:(bpow (ex + ey - 1 - 1) <= Rabs (x * y))%R
(Rabs (x * y) < bpow (ex + ey))%R rewrite Rabs_mult.r:radix
x, y:R
Hx:x <> 0%R
Hy:y <> 0%R
ex, ey:Z
Hx21:(bpow (ex - 1) <= Rabs x)%R
Hx22:(Rabs x < bpow ex)%R
Hy21:(bpow (ey - 1) <= Rabs y)%R
Hy22:(Rabs y < bpow ey)%R
Hxy:(bpow (ex + ey - 1 - 1) <= Rabs (x * y))%R
(Rabs x * Rabs y < bpow (ex + ey))%R
  rewrite bpow_plus.r:radix
x, y:R
Hx:x <> 0%R
Hy:y <> 0%R
ex, ey:Z
Hx21:(bpow (ex - 1) <= Rabs x)%R
Hx22:(Rabs x < bpow ex)%R
Hy21:(bpow (ey - 1) <= Rabs y)%R
Hy22:(Rabs y < bpow ey)%R
Hxy:(bpow (ex + ey - 1 - 1) <= Rabs (x * y))%R
(Rabs x * Rabs y < bpow ex * bpow ey)%R
  apply Rmult_le_0_lt_compat; try assumption.r:radix
x, y:R
Hx:x <> 0%R
Hy:y <> 0%R
ex, ey:Z
Hx21:(bpow (ex - 1) <= Rabs x)%R
Hx22:(Rabs x < bpow ex)%R
Hy21:(bpow (ey - 1) <= Rabs y)%R
Hy22:(Rabs y < bpow ey)%R
Hxy:(bpow (ex + ey - 1 - 1) <= Rabs (x * y))%R
(0 <= Rabs x)%R
r:radix
x, y:R
Hx:x <> 0%R
Hy:y <> 0%R
ex, ey:Z
Hx21:(bpow (ex - 1) <= Rabs x)%R
Hx22:(Rabs x < bpow ex)%R
Hy21:(bpow (ey - 1) <= Rabs y)%R
Hy22:(Rabs y < bpow ey)%R
Hxy:(bpow (ex + ey - 1 - 1) <= Rabs (x * y))%R
(0 <= Rabs y)%R
  now apply Rle_trans with (bpow (ex - 1)); try apply bpow_ge_0.r:radix
x, y:R
Hx:x <> 0%R
Hy:y <> 0%R
ex, ey:Z
Hx21:(bpow (ex - 1) <= Rabs x)%R
Hx22:(Rabs x < bpow ex)%R
Hy21:(bpow (ey - 1) <= Rabs y)%R
Hy22:(Rabs y < bpow ey)%R
Hxy:(bpow (ex + ey - 1 - 1) <= Rabs (x * y))%R
(0 <= Rabs y)%R
  now apply Rle_trans with (bpow (ey - 1)); try apply bpow_ge_0. }r:radix
x, y:R
Hx:x <> 0%R
Hy:y <> 0%R
ex, ey:Z
Hx21:(bpow (ex - 1) <= Rabs x)%R
Hx22:(Rabs x < bpow ex)%R
Hy21:(bpow (ey - 1) <= Rabs y)%R
Hy22:(Rabs y < bpow ey)%R
Hxy:(bpow (ex + ey - 1 - 1) <= Rabs (x * y))%R
Hxy2:(Rabs (x * y) < bpow (ex + ey))%R
(ex + ey - 1 <= mag (x * y) <= ex + ey)%Z
split.r:radix
x, y:R
Hx:x <> 0%R
Hy:y <> 0%R
ex, ey:Z
Hx21:(bpow (ex - 1) <= Rabs x)%R
Hx22:(Rabs x < bpow ex)%R
Hy21:(bpow (ey - 1) <= Rabs y)%R
Hy22:(Rabs y < bpow ey)%R
Hxy:(bpow (ex + ey - 1 - 1) <= Rabs (x * y))%R
Hxy2:(Rabs (x * y) < bpow (ex + ey))%R
(ex + ey - 1 <= mag (x * y))%Z
r:radix
x, y:R
Hx:x <> 0%R
Hy:y <> 0%R
ex, ey:Z
Hx21:(bpow (ex - 1) <= Rabs x)%R
Hx22:(Rabs x < bpow ex)%R
Hy21:(bpow (ey - 1) <= Rabs y)%R
Hy22:(Rabs y < bpow ey)%R
Hxy:(bpow (ex + ey - 1 - 1) <= Rabs (x * y))%R
Hxy2:(Rabs (x * y) < bpow (ex + ey))%R
(mag (x * y) <= ex + ey)%Z
-r:radix
x, y:R
Hx:x <> 0%R
Hy:y <> 0%R
ex, ey:Z
Hx21:(bpow (ex - 1) <= Rabs x)%R
Hx22:(Rabs x < bpow ex)%R
Hy21:(bpow (ey - 1) <= Rabs y)%R
Hy22:(Rabs y < bpow ey)%R
Hxy:(bpow (ex + ey - 1 - 1) <= Rabs (x * y))%R
Hxy2:(Rabs (x * y) < bpow (ex + ey))%R
(ex + ey - 1 <= mag (x * y))%Z now apply mag_ge_bpow.
-r:radix
x, y:R
Hx:x <> 0%R
Hy:y <> 0%R
ex, ey:Z
Hx21:(bpow (ex - 1) <= Rabs x)%R
Hx22:(Rabs x < bpow ex)%R
Hy21:(bpow (ey - 1) <= Rabs y)%R
Hy22:(Rabs y < bpow ey)%R
Hxy:(bpow (ex + ey - 1 - 1) <= Rabs (x * y))%R
Hxy2:(Rabs (x * y) < bpow (ex + ey))%R
(mag (x * y) <= ex + ey)%Z apply mag_le_bpow.r:radix
x, y:R
Hx:x <> 0%R
Hy:y <> 0%R
ex, ey:Z
Hx21:(bpow (ex - 1) <= Rabs x)%R
Hx22:(Rabs x < bpow ex)%R
Hy21:(bpow (ey - 1) <= Rabs y)%R
Hy22:(Rabs y < bpow ey)%R
Hxy:(bpow (ex + ey - 1 - 1) <= Rabs (x * y))%R
Hxy2:(Rabs (x * y) < bpow (ex + ey))%R
(x * y)%R <> 0%R
r:radix
x, y:R
Hx:x <> 0%R
Hy:y <> 0%R
ex, ey:Z
Hx21:(bpow (ex - 1) <= Rabs x)%R
Hx22:(Rabs x < bpow ex)%R
Hy21:(bpow (ey - 1) <= Rabs y)%R
Hy22:(Rabs y < bpow ey)%R
Hxy:(bpow (ex + ey - 1 - 1) <= Rabs (x * y))%R
Hxy2:(Rabs (x * y) < bpow (ex + ey))%R
(Rabs (x * y) < bpow (ex + ey))%R
  +r:radix
x, y:R
Hx:x <> 0%R
Hy:y <> 0%R
ex, ey:Z
Hx21:(bpow (ex - 1) <= Rabs x)%R
Hx22:(Rabs x < bpow ex)%R
Hy21:(bpow (ey - 1) <= Rabs y)%R
Hy22:(Rabs y < bpow ey)%R
Hxy:(bpow (ex + ey - 1 - 1) <= Rabs (x * y))%R
Hxy2:(Rabs (x * y) < bpow (ex + ey))%R
(x * y)%R <> 0%R now apply Rmult_integral_contrapositive_currified.
  +r:radix
x, y:R
Hx:x <> 0%R
Hy:y <> 0%R
ex, ey:Z
Hx21:(bpow (ex - 1) <= Rabs x)%R
Hx22:(Rabs x < bpow ex)%R
Hy21:(bpow (ey - 1) <= Rabs y)%R
Hy22:(Rabs y < bpow ey)%R
Hxy:(bpow (ex + ey - 1 - 1) <= Rabs (x * y))%R
Hxy2:(Rabs (x * y) < bpow (ex + ey))%R
(Rabs (x * y) < bpow (ex + ey))%R assumption.
Qed.

Lemma mag_plus :
  forall x y,
  (0 < y)%R -> (y <= x)%R ->
  (mag x <= mag (x + y) <= mag x + 1)%Z.r:radix
forall x y : R,
(0 < y)%R ->
(y <= x)%R -> (mag x <= mag (x + y) <= mag x + 1)%Z
Proof.r:radix
forall x y : R,
(0 < y)%R ->
(y <= x)%R -> (mag x <= mag (x + y) <= mag x + 1)%Z
assert (Hr : (2 <= r)%Z).r:radix
(2 <= r)%Z
r:radix
Hr:(2 <= r)%Z
forall x y : R,
(0 < y)%R ->
(y <= x)%R -> (mag x <= mag (x + y) <= mag x + 1)%Z
{r:radix
(2 <= r)%Z destruct r as (beta_val,beta_prop).r:radix
beta_val:Z
beta_prop:(2 <=? beta_val)%Z = true
(2 <=
 {| radix_val := beta_val; radix_prop := beta_prop |})%Z
  now apply Zle_bool_imp_le. }r:radix
Hr:(2 <= r)%Z
forall x y : R,
(0 < y)%R ->
(y <= x)%R -> (mag x <= mag (x + y) <= mag x + 1)%Z
intros x y Hy Hxy.r:radix
Hr:(2 <= r)%Z
x, y:R
Hy:(0 < y)%R
Hxy:(y <= x)%R
(mag x <= mag (x + y) <= mag x + 1)%Z
assert (Hx : (0 < x)%R) by apply (Rlt_le_trans _ _ _ Hy Hxy).r:radix
Hr:(2 <= r)%Z
x, y:R
Hy:(0 < y)%R
Hxy:(y <= x)%R
Hx:(0 < x)%R
(mag x <= mag (x + y) <= mag x + 1)%Z
destruct (mag x) as (ex,Hex); simpl.r:radix
Hr:(2 <= r)%Z
x, y:R
Hy:(0 < y)%R
Hxy:(y <= x)%R
Hx:(0 < x)%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
(ex <= mag (x + y) <= ex + 1)%Z
destruct Hex as (Hex0,Hex1); [now apply Rgt_not_eq|].r:radix
Hr:(2 <= r)%Z
x, y:R
Hy:(0 < y)%R
Hxy:(y <= x)%R
Hx:(0 < x)%R
ex:Z
Hex0:(bpow (ex - 1) <= Rabs x)%R
Hex1:(Rabs x < bpow ex)%R
(ex <= mag (x + y) <= ex + 1)%Z
assert (Haxy : (Rabs (x + y) < bpow (ex + 1))%R).r:radix
Hr:(2 <= r)%Z
x, y:R
Hy:(0 < y)%R
Hxy:(y <= x)%R
Hx:(0 < x)%R
ex:Z
Hex0:(bpow (ex - 1) <= Rabs x)%R
Hex1:(Rabs x < bpow ex)%R
(Rabs (x + y) < bpow (ex + 1))%R
r:radix
Hr:(2 <= r)%Z
x, y:R
Hy:(0 < y)%R
Hxy:(y <= x)%R
Hx:(0 < x)%R
ex:Z
Hex0:(bpow (ex - 1) <= Rabs x)%R
Hex1:(Rabs x < bpow ex)%R
Haxy:(Rabs (x + y) < bpow (ex + 1))%R
(ex <= mag (x + y) <= ex + 1)%Z
{r:radix
Hr:(2 <= r)%Z
x, y:R
Hy:(0 < y)%R
Hxy:(y <= x)%R
Hx:(0 < x)%R
ex:Z
Hex0:(bpow (ex - 1) <= Rabs x)%R
Hex1:(Rabs x < bpow ex)%R
(Rabs (x + y) < bpow (ex + 1))%R rewrite bpow_plus_1.r:radix
Hr:(2 <= r)%Z
x, y:R
Hy:(0 < y)%R
Hxy:(y <= x)%R
Hx:(0 < x)%R
ex:Z
Hex0:(bpow (ex - 1) <= Rabs x)%R
Hex1:(Rabs x < bpow ex)%R
(Rabs (x + y) < IZR r * bpow ex)%R
  apply Rlt_le_trans with (2 * bpow ex)%R.r:radix
Hr:(2 <= r)%Z
x, y:R
Hy:(0 < y)%R
Hxy:(y <= x)%R
Hx:(0 < x)%R
ex:Z
Hex0:(bpow (ex - 1) <= Rabs x)%R
Hex1:(Rabs x < bpow ex)%R
(Rabs (x + y) < 2 * bpow ex)%R
r:radix
Hr:(2 <= r)%Z
x, y:R
Hy:(0 < y)%R
Hxy:(y <= x)%R
Hx:(0 < x)%R
ex:Z
Hex0:(bpow (ex - 1) <= Rabs x)%R
Hex1:(Rabs x < bpow ex)%R
(2 * bpow ex <= IZR r * bpow ex)%R
  -r:radix
Hr:(2 <= r)%Z
x, y:R
Hy:(0 < y)%R
Hxy:(y <= x)%R
Hx:(0 < x)%R
ex:Z
Hex0:(bpow (ex - 1) <= Rabs x)%R
Hex1:(Rabs x < bpow ex)%R
(Rabs (x + y) < 2 * bpow ex)%R rewrite Rabs_pos_eq.r:radix
Hr:(2 <= r)%Z
x, y:R
Hy:(0 < y)%R
Hxy:(y <= x)%R
Hx:(0 < x)%R
ex:Z
Hex0:(bpow (ex - 1) <= Rabs x)%R
Hex1:(Rabs x < bpow ex)%R
(x + y < 2 * bpow ex)%R
r:radix
Hr:(2 <= r)%Z
x, y:R
Hy:(0 < y)%R
Hxy:(y <= x)%R
Hx:(0 < x)%R
ex:Z
Hex0:(bpow (ex - 1) <= Rabs x)%R
Hex1:(Rabs x < bpow ex)%R
(0 <= x + y)%R
    apply Rle_lt_trans with (2 * Rabs x)%R.r:radix
Hr:(2 <= r)%Z
x, y:R
Hy:(0 < y)%R
Hxy:(y <= x)%R
Hx:(0 < x)%R
ex:Z
Hex0:(bpow (ex - 1) <= Rabs x)%R
Hex1:(Rabs x < bpow ex)%R
(x + y <= 2 * Rabs x)%R
r:radix
Hr:(2 <= r)%Z
x, y:R
Hy:(0 < y)%R
Hxy:(y <= x)%R
Hx:(0 < x)%R
ex:Z
Hex0:(bpow (ex - 1) <= Rabs x)%R
Hex1:(Rabs x < bpow ex)%R
(2 * Rabs x < 2 * bpow ex)%R
r:radix
Hr:(2 <= r)%Z
x, y:R
Hy:(0 < y)%R
Hxy:(y <= x)%R
Hx:(0 < x)%R
ex:Z
Hex0:(bpow (ex - 1) <= Rabs x)%R
Hex1:(Rabs x < bpow ex)%R
(0 <= x + y)%R
    +r:radix
Hr:(2 <= r)%Z
x, y:R
Hy:(0 < y)%R
Hxy:(y <= x)%R
Hx:(0 < x)%R
ex:Z
Hex0:(bpow (ex - 1) <= Rabs x)%R
Hex1:(Rabs x < bpow ex)%R
(x + y <= 2 * Rabs x)%R rewrite Rabs_pos_eq.r:radix
Hr:(2 <= r)%Z
x, y:R
Hy:(0 < y)%R
Hxy:(y <= x)%R
Hx:(0 < x)%R
ex:Z
Hex0:(bpow (ex - 1) <= Rabs x)%R
Hex1:(Rabs x < bpow ex)%R
(x + y <= 2 * x)%R
r:radix
Hr:(2 <= r)%Z
x, y:R
Hy:(0 < y)%R
Hxy:(y <= x)%R
Hx:(0 < x)%R
ex:Z
Hex0:(bpow (ex - 1) <= Rabs x)%R
Hex1:(Rabs x < bpow ex)%R
(0 <= x)%R
      replace (2 * x)%R with (x + x)%R by ring.r:radix
Hr:(2 <= r)%Z
x, y:R
Hy:(0 < y)%R
Hxy:(y <= x)%R
Hx:(0 < x)%R
ex:Z
Hex0:(bpow (ex - 1) <= Rabs x)%R
Hex1:(Rabs x < bpow ex)%R
(x + y <= x + x)%R
r:radix
Hr:(2 <= r)%Z
x, y:R
Hy:(0 < y)%R
Hxy:(y <= x)%R
Hx:(0 < x)%R
ex:Z
Hex0:(bpow (ex - 1) <= Rabs x)%R
Hex1:(Rabs x < bpow ex)%R
(0 <= x)%R
      now apply Rplus_le_compat_l.r:radix
Hr:(2 <= r)%Z
x, y:R
Hy:(0 < y)%R
Hxy:(y <= x)%R
Hx:(0 < x)%R
ex:Z
Hex0:(bpow (ex - 1) <= Rabs x)%R
Hex1:(Rabs x < bpow ex)%R
(0 <= x)%R
      now apply Rlt_le.
    +r:radix
Hr:(2 <= r)%Z
x, y:R
Hy:(0 < y)%R
Hxy:(y <= x)%R
Hx:(0 < x)%R
ex:Z
Hex0:(bpow (ex - 1) <= Rabs x)%R
Hex1:(Rabs x < bpow ex)%R
(2 * Rabs x < 2 * bpow ex)%R apply Rmult_lt_compat_l with (2 := Hex1).r:radix
Hr:(2 <= r)%Z
x, y:R
Hy:(0 < y)%R
Hxy:(y <= x)%R
Hx:(0 < x)%R
ex:Z
Hex0:(bpow (ex - 1) <= Rabs x)%R
Hex1:(Rabs x < bpow ex)%R
(0 < 2)%R
      exact Rlt_0_2.
    +r:radix
Hr:(2 <= r)%Z
x, y:R
Hy:(0 < y)%R
Hxy:(y <= x)%R
Hx:(0 < x)%R
ex:Z
Hex0:(bpow (ex - 1) <= Rabs x)%R
Hex1:(Rabs x < bpow ex)%R
(0 <= x + y)%R rewrite <- (Rplus_0_l 0).r:radix
Hr:(2 <= r)%Z
x, y:R
Hy:(0 < y)%R
Hxy:(y <= x)%R
Hx:(0 < x)%R
ex:Z
Hex0:(bpow (ex - 1) <= Rabs x)%R
Hex1:(Rabs x < bpow ex)%R
(0 + 0 <= x + y)%R
      now apply Rlt_le, Rplus_lt_compat.
  -r:radix
Hr:(2 <= r)%Z
x, y:R
Hy:(0 < y)%R
Hxy:(y <= x)%R
Hx:(0 < x)%R
ex:Z
Hex0:(bpow (ex - 1) <= Rabs x)%R
Hex1:(Rabs x < bpow ex)%R
(2 * bpow ex <= IZR r * bpow ex)%R apply Rmult_le_compat_r.r:radix
Hr:(2 <= r)%Z
x, y:R
Hy:(0 < y)%R
Hxy:(y <= x)%R
Hx:(0 < x)%R
ex:Z
Hex0:(bpow (ex - 1) <= Rabs x)%R
Hex1:(Rabs x < bpow ex)%R
(0 <= bpow ex)%R
r:radix
Hr:(2 <= r)%Z
x, y:R
Hy:(0 < y)%R
Hxy:(y <= x)%R
Hx:(0 < x)%R
ex:Z
Hex0:(bpow (ex - 1) <= Rabs x)%R
Hex1:(Rabs x < bpow ex)%R
(2 <= IZR r)%R
    now apply bpow_ge_0.r:radix
Hr:(2 <= r)%Z
x, y:R
Hy:(0 < y)%R
Hxy:(y <= x)%R
Hx:(0 < x)%R
ex:Z
Hex0:(bpow (ex - 1) <= Rabs x)%R
Hex1:(Rabs x < bpow ex)%R
(2 <= IZR r)%R
    now apply IZR_le. }r:radix
Hr:(2 <= r)%Z
x, y:R
Hy:(0 < y)%R
Hxy:(y <= x)%R
Hx:(0 < x)%R
ex:Z
Hex0:(bpow (ex - 1) <= Rabs x)%R
Hex1:(Rabs x < bpow ex)%R
Haxy:(Rabs (x + y) < bpow (ex + 1))%R
(ex <= mag (x + y) <= ex + 1)%Z
assert (Haxy2 : (bpow (ex - 1) <= Rabs (x + y))%R).r:radix
Hr:(2 <= r)%Z
x, y:R
Hy:(0 < y)%R
Hxy:(y <= x)%R
Hx:(0 < x)%R
ex:Z
Hex0:(bpow (ex - 1) <= Rabs x)%R
Hex1:(Rabs x < bpow ex)%R
Haxy:(Rabs (x + y) < bpow (ex + 1))%R
(bpow (ex - 1) <= Rabs (x + y))%R
r:radix
Hr:(2 <= r)%Z
x, y:R
Hy:(0 < y)%R
Hxy:(y <= x)%R
Hx:(0 < x)%R
ex:Z
Hex0:(bpow (ex - 1) <= Rabs x)%R
Hex1:(Rabs x < bpow ex)%R
Haxy:(Rabs (x + y) < bpow (ex + 1))%R
Haxy2:(bpow (ex - 1) <= Rabs (x + y))%R
(ex <= mag (x + y) <= ex + 1)%Z
{r:radix
Hr:(2 <= r)%Z
x, y:R
Hy:(0 < y)%R
Hxy:(y <= x)%R
Hx:(0 < x)%R
ex:Z
Hex0:(bpow (ex - 1) <= Rabs x)%R
Hex1:(Rabs x < bpow ex)%R
Haxy:(Rabs (x + y) < bpow (ex + 1))%R
(bpow (ex - 1) <= Rabs (x + y))%R apply (Rle_trans _ _ _ Hex0).r:radix
Hr:(2 <= r)%Z
x, y:R
Hy:(0 < y)%R
Hxy:(y <= x)%R
Hx:(0 < x)%R
ex:Z
Hex0:(bpow (ex - 1) <= Rabs x)%R
Hex1:(Rabs x < bpow ex)%R
Haxy:(Rabs (x + y) < bpow (ex + 1))%R
(Rabs x <= Rabs (x + y))%R
  rewrite Rabs_right; [|now apply Rgt_ge].r:radix
Hr:(2 <= r)%Z
x, y:R
Hy:(0 < y)%R
Hxy:(y <= x)%R
Hx:(0 < x)%R
ex:Z
Hex0:(bpow (ex - 1) <= Rabs x)%R
Hex1:(Rabs x < bpow ex)%R
Haxy:(Rabs (x + y) < bpow (ex + 1))%R
(x <= Rabs (x + y))%R
  apply Rabs_ge; right.r:radix
Hr:(2 <= r)%Z
x, y:R
Hy:(0 < y)%R
Hxy:(y <= x)%R
Hx:(0 < x)%R
ex:Z
Hex0:(bpow (ex - 1) <= Rabs x)%R
Hex1:(Rabs x < bpow ex)%R
Haxy:(Rabs (x + y) < bpow (ex + 1))%R
(x <= x + y)%R
  rewrite <- (Rplus_0_r x) at 1.r:radix
Hr:(2 <= r)%Z
x, y:R
Hy:(0 < y)%R
Hxy:(y <= x)%R
Hx:(0 < x)%R
ex:Z
Hex0:(bpow (ex - 1) <= Rabs x)%R
Hex1:(Rabs x < bpow ex)%R
Haxy:(Rabs (x + y) < bpow (ex + 1))%R
(x + 0 <= x + y)%R
  apply Rplus_le_compat_l.r:radix
Hr:(2 <= r)%Z
x, y:R
Hy:(0 < y)%R
Hxy:(y <= x)%R
Hx:(0 < x)%R
ex:Z
Hex0:(bpow (ex - 1) <= Rabs x)%R
Hex1:(Rabs x < bpow ex)%R
Haxy:(Rabs (x + y) < bpow (ex + 1))%R
(0 <= y)%R
  now apply Rlt_le. }r:radix
Hr:(2 <= r)%Z
x, y:R
Hy:(0 < y)%R
Hxy:(y <= x)%R
Hx:(0 < x)%R
ex:Z
Hex0:(bpow (ex - 1) <= Rabs x)%R
Hex1:(Rabs x < bpow ex)%R
Haxy:(Rabs (x + y) < bpow (ex + 1))%R
Haxy2:(bpow (ex - 1) <= Rabs (x + y))%R
(ex <= mag (x + y) <= ex + 1)%Z
split.r:radix
Hr:(2 <= r)%Z
x, y:R
Hy:(0 < y)%R
Hxy:(y <= x)%R
Hx:(0 < x)%R
ex:Z
Hex0:(bpow (ex - 1) <= Rabs x)%R
Hex1:(Rabs x < bpow ex)%R
Haxy:(Rabs (x + y) < bpow (ex + 1))%R
Haxy2:(bpow (ex - 1) <= Rabs (x + y))%R
(ex <= mag (x + y))%Z
r:radix
Hr:(2 <= r)%Z
x, y:R
Hy:(0 < y)%R
Hxy:(y <= x)%R
Hx:(0 < x)%R
ex:Z
Hex0:(bpow (ex - 1) <= Rabs x)%R
Hex1:(Rabs x < bpow ex)%R
Haxy:(Rabs (x + y) < bpow (ex + 1))%R
Haxy2:(bpow (ex - 1) <= Rabs (x + y))%R
(mag (x + y) <= ex + 1)%Z
-r:radix
Hr:(2 <= r)%Z
x, y:R
Hy:(0 < y)%R
Hxy:(y <= x)%R
Hx:(0 < x)%R
ex:Z
Hex0:(bpow (ex - 1) <= Rabs x)%R
Hex1:(Rabs x < bpow ex)%R
Haxy:(Rabs (x + y) < bpow (ex + 1))%R
Haxy2:(bpow (ex - 1) <= Rabs (x + y))%R
(ex <= mag (x + y))%Z now apply mag_ge_bpow.
-r:radix
Hr:(2 <= r)%Z
x, y:R
Hy:(0 < y)%R
Hxy:(y <= x)%R
Hx:(0 < x)%R
ex:Z
Hex0:(bpow (ex - 1) <= Rabs x)%R
Hex1:(Rabs x < bpow ex)%R
Haxy:(Rabs (x + y) < bpow (ex + 1))%R
Haxy2:(bpow (ex - 1) <= Rabs (x + y))%R
(mag (x + y) <= ex + 1)%Z apply mag_le_bpow.r:radix
Hr:(2 <= r)%Z
x, y:R
Hy:(0 < y)%R
Hxy:(y <= x)%R
Hx:(0 < x)%R
ex:Z
Hex0:(bpow (ex - 1) <= Rabs x)%R
Hex1:(Rabs x < bpow ex)%R
Haxy:(Rabs (x + y) < bpow (ex + 1))%R
Haxy2:(bpow (ex - 1) <= Rabs (x + y))%R
(x + y)%R <> 0%R
r:radix
Hr:(2 <= r)%Z
x, y:R
Hy:(0 < y)%R
Hxy:(y <= x)%R
Hx:(0 < x)%R
ex:Z
Hex0:(bpow (ex - 1) <= Rabs x)%R
Hex1:(Rabs x < bpow ex)%R
Haxy:(Rabs (x + y) < bpow (ex + 1))%R
Haxy2:(bpow (ex - 1) <= Rabs (x + y))%R
(Rabs (x + y) < bpow (ex + 1))%R
  +r:radix
Hr:(2 <= r)%Z
x, y:R
Hy:(0 < y)%R
Hxy:(y <= x)%R
Hx:(0 < x)%R
ex:Z
Hex0:(bpow (ex - 1) <= Rabs x)%R
Hex1:(Rabs x < bpow ex)%R
Haxy:(Rabs (x + y) < bpow (ex + 1))%R
Haxy2:(bpow (ex - 1) <= Rabs (x + y))%R
(x + y)%R <> 0%R now apply tech_Rplus; [apply Rlt_le|].
  +r:radix
Hr:(2 <= r)%Z
x, y:R
Hy:(0 < y)%R
Hxy:(y <= x)%R
Hx:(0 < x)%R
ex:Z
Hex0:(bpow (ex - 1) <= Rabs x)%R
Hex1:(Rabs x < bpow ex)%R
Haxy:(Rabs (x + y) < bpow (ex + 1))%R
Haxy2:(bpow (ex - 1) <= Rabs (x + y))%R
(Rabs (x + y) < bpow (ex + 1))%R exact Haxy.
Qed.

Lemma mag_minus :
  forall x y,
  (0 < y)%R -> (y < x)%R ->
  (mag (x - y) <= mag x)%Z.r:radix
forall x y : R,
(0 < y)%R -> (y < x)%R -> (mag (x - y) <= mag x)%Z
Proof.r:radix
forall x y : R,
(0 < y)%R -> (y < x)%R -> (mag (x - y) <= mag x)%Z
intros x y Py Hxy.r:radix
x, y:R
Py:(0 < y)%R
Hxy:(y < x)%R
(mag (x - y) <= mag x)%Z
assert (Px : (0 < x)%R) by apply (Rlt_trans _ _ _ Py Hxy).r:radix
x, y:R
Py:(0 < y)%R
Hxy:(y < x)%R
Px:(0 < x)%R
(mag (x - y) <= mag x)%Z
apply mag_le.r:radix
x, y:R
Py:(0 < y)%R
Hxy:(y < x)%R
Px:(0 < x)%R
(0 < x - y)%R
r:radix
x, y:R
Py:(0 < y)%R
Hxy:(y < x)%R
Px:(0 < x)%R
(x - y <= x)%R
-r:radix
x, y:R
Py:(0 < y)%R
Hxy:(y < x)%R
Px:(0 < x)%R
(0 < x - y)%R now apply Rlt_Rminus.
-r:radix
x, y:R
Py:(0 < y)%R
Hxy:(y < x)%R
Px:(0 < x)%R
(x - y <= x)%R rewrite <- (Rplus_0_r x) at 2.r:radix
x, y:R
Py:(0 < y)%R
Hxy:(y < x)%R
Px:(0 < x)%R
(x - y <= x + 0)%R
  apply Rplus_le_compat_l.r:radix
x, y:R
Py:(0 < y)%R
Hxy:(y < x)%R
Px:(0 < x)%R
(- y <= 0)%R
  rewrite <- Ropp_0.r:radix
x, y:R
Py:(0 < y)%R
Hxy:(y < x)%R
Px:(0 < x)%R
(- y <= - 0)%R
  now apply Ropp_le_contravar; apply Rlt_le.
Qed.

Lemma mag_minus_lb :
  forall x y,
  (0 < x)%R -> (0 < y)%R ->
  (mag y <= mag x - 2)%Z ->
  (mag x - 1 <= mag (x - y))%Z.r:radix
forall x y : R,
(0 < x)%R ->
(0 < y)%R ->
(mag y <= mag x - 2)%Z -> (mag x - 1 <= mag (x - y))%Z
Proof.r:radix
forall x y : R,
(0 < x)%R ->
(0 < y)%R ->
(mag y <= mag x - 2)%Z -> (mag x - 1 <= mag (x - y))%Z
assert (Hbeta : (2 <= r)%Z).r:radix
(2 <= r)%Z
r:radix
Hbeta:(2 <= r)%Z
forall x y : R,
(0 < x)%R ->
(0 < y)%R ->
(mag y <= mag x - 2)%Z -> (mag x - 1 <= mag (x - y))%Z
{r:radix
(2 <= r)%Z destruct r as (beta_val,beta_prop).r:radix
beta_val:Z
beta_prop:(2 <=? beta_val)%Z = true
(2 <=
 {| radix_val := beta_val; radix_prop := beta_prop |})%Z
  now apply Zle_bool_imp_le. }r:radix
Hbeta:(2 <= r)%Z
forall x y : R,
(0 < x)%R ->
(0 < y)%R ->
(mag y <= mag x - 2)%Z -> (mag x - 1 <= mag (x - y))%Z
intros x y Px Py Hln.r:radix
Hbeta:(2 <= r)%Z
x, y:R
Px:(0 < x)%R
Py:(0 < y)%R
Hln:(mag y <= mag x - 2)%Z
(mag x - 1 <= mag (x - y))%Z
assert (Oxy : (y < x)%R); [apply lt_mag;[assumption|omega]|].r:radix
Hbeta:(2 <= r)%Z
x, y:R
Px:(0 < x)%R
Py:(0 < y)%R
Hln:(mag y <= mag x - 2)%Z
Oxy:(y < x)%R
(mag x - 1 <= mag (x - y))%Z
destruct (mag x) as (ex,Hex).r:radix
Hbeta:(2 <= r)%Z
x, y:R
Px:(0 < x)%R
Py:(0 < y)%R
ex:Z
Hex:x <> 0%R ->
(bpow (ex - 1) <= Rabs x < bpow ex)%R
Hln:(mag y <= Build_mag_prop x ex Hex - 2)%Z
Oxy:(y < x)%R
(Build_mag_prop x ex Hex - 1 <= mag (x - y))%Z
destruct (mag y) as (ey,Hey).r:radix
Hbeta:(2 <= r)%Z
x, y:R
Px:(0 < x)%R
Py:(0 < y)%R
ex:Z
Hex:x <> 0%R ->
(bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R ->
(bpow (ey - 1) <= Rabs y < bpow ey)%R
Hln:(Build_mag_prop y ey Hey <=
 Build_mag_prop x ex Hex - 2)%Z
Oxy:(y < x)%R
(Build_mag_prop x ex Hex - 1 <= mag (x - y))%Z
simpl in Hln |- *.r:radix
Hbeta:(2 <= r)%Z
x, y:R
Px:(0 < x)%R
Py:(0 < y)%R
ex:Z
Hex:x <> 0%R ->
(bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R ->
(bpow (ey - 1) <= Rabs y < bpow ey)%R
Hln:(ey <= ex - 2)%Z
Oxy:(y < x)%R
(ex - 1 <= mag (x - y))%Z
destruct Hex as (Hex,_); [now apply Rgt_not_eq|].r:radix
Hbeta:(2 <= r)%Z
x, y:R
Px:(0 < x)%R
Py:(0 < y)%R
ex, ey:Z
Hey:y <> 0%R ->
(bpow (ey - 1) <= Rabs y < bpow ey)%R
Hln:(ey <= ex - 2)%Z
Oxy:(y < x)%R
Hex:(bpow (ex - 1) <= Rabs x)%R
(ex - 1 <= mag (x - y))%Z
destruct Hey as (_,Hey); [now apply Rgt_not_eq|].r:radix
Hbeta:(2 <= r)%Z
x, y:R
Px:(0 < x)%R
Py:(0 < y)%R
ex, ey:Z
Hln:(ey <= ex - 2)%Z
Oxy:(y < x)%R
Hex:(bpow (ex - 1) <= Rabs x)%R
Hey:(Rabs y < bpow ey)%R
(ex - 1 <= mag (x - y))%Z
assert (Hbx : (bpow (ex - 2) + bpow (ex - 2) <= x)%R).r:radix
Hbeta:(2 <= r)%Z
x, y:R
Px:(0 < x)%R
Py:(0 < y)%R
ex, ey:Z
Hln:(ey <= ex - 2)%Z
Oxy:(y < x)%R
Hex:(bpow (ex - 1) <= Rabs x)%R
Hey:(Rabs y < bpow ey)%R
(bpow (ex - 2) + bpow (ex - 2) <= x)%R
r:radix
Hbeta:(2 <= r)%Z
x, y:R
Px:(0 < x)%R
Py:(0 < y)%R
ex, ey:Z
Hln:(ey <= ex - 2)%Z
Oxy:(y < x)%R
Hex:(bpow (ex - 1) <= Rabs x)%R
Hey:(Rabs y < bpow ey)%R
Hbx:(bpow (ex - 2) + bpow (ex - 2) <= x)%R
(ex - 1 <= mag (x - y))%Z
{r:radix
Hbeta:(2 <= r)%Z
x, y:R
Px:(0 < x)%R
Py:(0 < y)%R
ex, ey:Z
Hln:(ey <= ex - 2)%Z
Oxy:(y < x)%R
Hex:(bpow (ex - 1) <= Rabs x)%R
Hey:(Rabs y < bpow ey)%R
(bpow (ex - 2) + bpow (ex - 2) <= x)%R ring_simplify.r:radix
Hbeta:(2 <= r)%Z
x, y:R
Px:(0 < x)%R
Py:(0 < y)%R
ex, ey:Z
Hln:(ey <= ex - 2)%Z
Oxy:(y < x)%R
Hex:(bpow (ex - 1) <= Rabs x)%R
Hey:(Rabs y < bpow ey)%R
(2 * bpow (ex - 2) <= x)%R
  apply Rle_trans with (bpow (ex - 1)).r:radix
Hbeta:(2 <= r)%Z
x, y:R
Px:(0 < x)%R
Py:(0 < y)%R
ex, ey:Z
Hln:(ey <= ex - 2)%Z
Oxy:(y < x)%R
Hex:(bpow (ex - 1) <= Rabs x)%R
Hey:(Rabs y < bpow ey)%R
(2 * bpow (ex - 2) <= bpow (ex - 1))%R
r:radix
Hbeta:(2 <= r)%Z
x, y:R
Px:(0 < x)%R
Py:(0 < y)%R
ex, ey:Z
Hln:(ey <= ex - 2)%Z
Oxy:(y < x)%R
Hex:(bpow (ex - 1) <= Rabs x)%R
Hey:(Rabs y < bpow ey)%R
(bpow (ex - 1) <= x)%R
  -r:radix
Hbeta:(2 <= r)%Z
x, y:R
Px:(0 < x)%R
Py:(0 < y)%R
ex, ey:Z
Hln:(ey <= ex - 2)%Z
Oxy:(y < x)%R
Hex:(bpow (ex - 1) <= Rabs x)%R
Hey:(Rabs y < bpow ey)%R
(2 * bpow (ex - 2) <= bpow (ex - 1))%R replace (ex - 1)%Z with (ex - 2 + 1)%Z by ring.r:radix
Hbeta:(2 <= r)%Z
x, y:R
Px:(0 < x)%R
Py:(0 < y)%R
ex, ey:Z
Hln:(ey <= ex - 2)%Z
Oxy:(y < x)%R
Hex:(bpow (ex - 1) <= Rabs x)%R
Hey:(Rabs y < bpow ey)%R
(2 * bpow (ex - 2) <= bpow (ex - 2 + 1))%R
    rewrite bpow_plus_1.r:radix
Hbeta:(2 <= r)%Z
x, y:R
Px:(0 < x)%R
Py:(0 < y)%R
ex, ey:Z
Hln:(ey <= ex - 2)%Z
Oxy:(y < x)%R
Hex:(bpow (ex - 1) <= Rabs x)%R
Hey:(Rabs y < bpow ey)%R
(2 * bpow (ex - 2) <= IZR r * bpow (ex - 2))%R
    apply Rmult_le_compat_r; [now apply bpow_ge_0|].r:radix
Hbeta:(2 <= r)%Z
x, y:R
Px:(0 < x)%R
Py:(0 < y)%R
ex, ey:Z
Hln:(ey <= ex - 2)%Z
Oxy:(y < x)%R
Hex:(bpow (ex - 1) <= Rabs x)%R
Hey:(Rabs y < bpow ey)%R
(2 <= IZR r)%R
    now apply IZR_le.
  -r:radix
Hbeta:(2 <= r)%Z
x, y:R
Px:(0 < x)%R
Py:(0 < y)%R
ex, ey:Z
Hln:(ey <= ex - 2)%Z
Oxy:(y < x)%R
Hex:(bpow (ex - 1) <= Rabs x)%R
Hey:(Rabs y < bpow ey)%R
(bpow (ex - 1) <= x)%R now rewrite Rabs_right in Hex; [|apply Rle_ge; apply Rlt_le]. }r:radix
Hbeta:(2 <= r)%Z
x, y:R
Px:(0 < x)%R
Py:(0 < y)%R
ex, ey:Z
Hln:(ey <= ex - 2)%Z
Oxy:(y < x)%R
Hex:(bpow (ex - 1) <= Rabs x)%R
Hey:(Rabs y < bpow ey)%R
Hbx:(bpow (ex - 2) + bpow (ex - 2) <= x)%R
(ex - 1 <= mag (x - y))%Z
assert (Hby : (y < bpow (ex - 2))%R).r:radix
Hbeta:(2 <= r)%Z
x, y:R
Px:(0 < x)%R
Py:(0 < y)%R
ex, ey:Z
Hln:(ey <= ex - 2)%Z
Oxy:(y < x)%R
Hex:(bpow (ex - 1) <= Rabs x)%R
Hey:(Rabs y < bpow ey)%R
Hbx:(bpow (ex - 2) + bpow (ex - 2) <= x)%R
(y < bpow (ex - 2))%R
r:radix
Hbeta:(2 <= r)%Z
x, y:R
Px:(0 < x)%R
Py:(0 < y)%R
ex, ey:Z
Hln:(ey <= ex - 2)%Z
Oxy:(y < x)%R
Hex:(bpow (ex - 1) <= Rabs x)%R
Hey:(Rabs y < bpow ey)%R
Hbx:(bpow (ex - 2) + bpow (ex - 2) <= x)%R
Hby:(y < bpow (ex - 2))%R
(ex - 1 <= mag (x - y))%Z
{r:radix
Hbeta:(2 <= r)%Z
x, y:R
Px:(0 < x)%R
Py:(0 < y)%R
ex, ey:Z
Hln:(ey <= ex - 2)%Z
Oxy:(y < x)%R
Hex:(bpow (ex - 1) <= Rabs x)%R
Hey:(Rabs y < bpow ey)%R
Hbx:(bpow (ex - 2) + bpow (ex - 2) <= x)%R
(y < bpow (ex - 2))%R apply Rlt_le_trans with (bpow ey).r:radix
Hbeta:(2 <= r)%Z
x, y:R
Px:(0 < x)%R
Py:(0 < y)%R
ex, ey:Z
Hln:(ey <= ex - 2)%Z
Oxy:(y < x)%R
Hex:(bpow (ex - 1) <= Rabs x)%R
Hey:(Rabs y < bpow ey)%R
Hbx:(bpow (ex - 2) + bpow (ex - 2) <= x)%R
(y < bpow ey)%R
r:radix
Hbeta:(2 <= r)%Z
x, y:R
Px:(0 < x)%R
Py:(0 < y)%R
ex, ey:Z
Hln:(ey <= ex - 2)%Z
Oxy:(y < x)%R
Hex:(bpow (ex - 1) <= Rabs x)%R
Hey:(Rabs y < bpow ey)%R
Hbx:(bpow (ex - 2) + bpow (ex - 2) <= x)%R
(bpow ey <= bpow (ex - 2))%R
  now rewrite Rabs_right in Hey; [|apply Rle_ge; apply Rlt_le].r:radix
Hbeta:(2 <= r)%Z
x, y:R
Px:(0 < x)%R
Py:(0 < y)%R
ex, ey:Z
Hln:(ey <= ex - 2)%Z
Oxy:(y < x)%R
Hex:(bpow (ex - 1) <= Rabs x)%R
Hey:(Rabs y < bpow ey)%R
Hbx:(bpow (ex - 2) + bpow (ex - 2) <= x)%R
(bpow ey <= bpow (ex - 2))%R
  now apply bpow_le. }r:radix
Hbeta:(2 <= r)%Z
x, y:R
Px:(0 < x)%R
Py:(0 < y)%R
ex, ey:Z
Hln:(ey <= ex - 2)%Z
Oxy:(y < x)%R
Hex:(bpow (ex - 1) <= Rabs x)%R
Hey:(Rabs y < bpow ey)%R
Hbx:(bpow (ex - 2) + bpow (ex - 2) <= x)%R
Hby:(y < bpow (ex - 2))%R
(ex - 1 <= mag (x - y))%Z
assert (Hbxy : (bpow (ex - 2) <= x - y)%R).r:radix
Hbeta:(2 <= r)%Z
x, y:R
Px:(0 < x)%R
Py:(0 < y)%R
ex, ey:Z
Hln:(ey <= ex - 2)%Z
Oxy:(y < x)%R
Hex:(bpow (ex - 1) <= Rabs x)%R
Hey:(Rabs y < bpow ey)%R
Hbx:(bpow (ex - 2) + bpow (ex - 2) <= x)%R
Hby:(y < bpow (ex - 2))%R
(bpow (ex - 2) <= x - y)%R
r:radix
Hbeta:(2 <= r)%Z
x, y:R
Px:(0 < x)%R
Py:(0 < y)%R
ex, ey:Z
Hln:(ey <= ex - 2)%Z
Oxy:(y < x)%R
Hex:(bpow (ex - 1) <= Rabs x)%R
Hey:(Rabs y < bpow ey)%R
Hbx:(bpow (ex - 2) + bpow (ex - 2) <= x)%R
Hby:(y < bpow (ex - 2))%R
Hbxy:(bpow (ex - 2) <= x - y)%R
(ex - 1 <= mag (x - y))%Z
{r:radix
Hbeta:(2 <= r)%Z
x, y:R
Px:(0 < x)%R
Py:(0 < y)%R
ex, ey:Z
Hln:(ey <= ex - 2)%Z
Oxy:(y < x)%R
Hex:(bpow (ex - 1) <= Rabs x)%R
Hey:(Rabs y < bpow ey)%R
Hbx:(bpow (ex - 2) + bpow (ex - 2) <= x)%R
Hby:(y < bpow (ex - 2))%R
(bpow (ex - 2) <= x - y)%R apply Ropp_lt_contravar in Hby.r:radix
Hbeta:(2 <= r)%Z
x, y:R
Px:(0 < x)%R
Py:(0 < y)%R
ex, ey:Z
Hln:(ey <= ex - 2)%Z
Oxy:(y < x)%R
Hex:(bpow (ex - 1) <= Rabs x)%R
Hey:(Rabs y < bpow ey)%R
Hbx:(bpow (ex - 2) + bpow (ex - 2) <= x)%R
Hby:(- bpow (ex - 2) < - y)%R
(bpow (ex - 2) <= x - y)%R
  apply Rlt_le in Hby.r:radix
Hbeta:(2 <= r)%Z
x, y:R
Px:(0 < x)%R
Py:(0 < y)%R
ex, ey:Z
Hln:(ey <= ex - 2)%Z
Oxy:(y < x)%R
Hex:(bpow (ex - 1) <= Rabs x)%R
Hey:(Rabs y < bpow ey)%R
Hbx:(bpow (ex - 2) + bpow (ex - 2) <= x)%R
Hby:(- bpow (ex - 2) <= - y)%R
(bpow (ex - 2) <= x - y)%R
  replace (bpow (ex - 2))%R with (bpow (ex - 2) + bpow (ex - 2)
                                                  - bpow (ex - 2))%R by ring.r:radix
Hbeta:(2 <= r)%Z
x, y:R
Px:(0 < x)%R
Py:(0 < y)%R
ex, ey:Z
Hln:(ey <= ex - 2)%Z
Oxy:(y < x)%R
Hex:(bpow (ex - 1) <= Rabs x)%R
Hey:(Rabs y < bpow ey)%R
Hbx:(bpow (ex - 2) + bpow (ex - 2) <= x)%R
Hby:(- bpow (ex - 2) <= - y)%R
(bpow (ex - 2) + bpow (ex - 2) - bpow (ex - 2) <=
 x - y)%R
  now apply Rplus_le_compat. }r:radix
Hbeta:(2 <= r)%Z
x, y:R
Px:(0 < x)%R
Py:(0 < y)%R
ex, ey:Z
Hln:(ey <= ex - 2)%Z
Oxy:(y < x)%R
Hex:(bpow (ex - 1) <= Rabs x)%R
Hey:(Rabs y < bpow ey)%R
Hbx:(bpow (ex - 2) + bpow (ex - 2) <= x)%R
Hby:(y < bpow (ex - 2))%R
Hbxy:(bpow (ex - 2) <= x - y)%R
(ex - 1 <= mag (x - y))%Z
apply mag_ge_bpow.r:radix
Hbeta:(2 <= r)%Z
x, y:R
Px:(0 < x)%R
Py:(0 < y)%R
ex, ey:Z
Hln:(ey <= ex - 2)%Z
Oxy:(y < x)%R
Hex:(bpow (ex - 1) <= Rabs x)%R
Hey:(Rabs y < bpow ey)%R
Hbx:(bpow (ex - 2) + bpow (ex - 2) <= x)%R
Hby:(y < bpow (ex - 2))%R
Hbxy:(bpow (ex - 2) <= x - y)%R
(bpow (ex - 1 - 1) <= Rabs (x - y))%R
replace (ex - 1 - 1)%Z with (ex - 2)%Z by ring.r:radix
Hbeta:(2 <= r)%Z
x, y:R
Px:(0 < x)%R
Py:(0 < y)%R
ex, ey:Z
Hln:(ey <= ex - 2)%Z
Oxy:(y < x)%R
Hex:(bpow (ex - 1) <= Rabs x)%R
Hey:(Rabs y < bpow ey)%R
Hbx:(bpow (ex - 2) + bpow (ex - 2) <= x)%R
Hby:(y < bpow (ex - 2))%R
Hbxy:(bpow (ex - 2) <= x - y)%R
(bpow (ex - 2) <= Rabs (x - y))%R
now apply Rabs_ge; right.
Qed.

Lemma mag_div :
  forall x y : R,
  x <> 0%R -> y <> 0%R ->
  (mag x - mag y <= mag (x / y) <= mag x - mag y + 1)%Z.r:radix
forall x y : R,
x <> 0%R ->
y <> 0%R ->
(mag x - mag y <= mag (x / y) <= mag x - mag y + 1)%Z
Proof.r:radix
forall x y : R,
x <> 0%R ->
y <> 0%R ->
(mag x - mag y <= mag (x / y) <= mag x - mag y + 1)%Z
intros x y Px Py.r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
(mag x - mag y <= mag (x / y) <= mag x - mag y + 1)%Z
destruct (mag x) as (ex,Hex).r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
(Build_mag_prop x ex Hex - mag y <= mag (x / y) <=
 Build_mag_prop x ex Hex - mag y + 1)%Z
destruct (mag y) as (ey,Hey).r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
(Build_mag_prop x ex Hex - Build_mag_prop y ey Hey <=
 mag (x / y) <=
 Build_mag_prop x ex Hex - Build_mag_prop y ey Hey + 1)%Z
simpl.r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
(ex - ey <= mag (x / y) <= ex - ey + 1)%Z
unfold Rdiv.r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
(ex - ey <= mag (x * / y) <= ex - ey + 1)%Z
assert (Heiy : (bpow (- ey) < Rabs (/ y) <= bpow (- ey + 1))%R).r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
(bpow (- ey) < Rabs (/ y) <= bpow (- ey + 1))%R
r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
Heiy:(bpow (- ey) < Rabs (/ y) <= bpow (- ey + 1))%R
(ex - ey <= mag (x * / y) <= ex - ey + 1)%Z
{r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
(bpow (- ey) < Rabs (/ y) <= bpow (- ey + 1))%R rewrite Rabs_Rinv by easy.r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
(bpow (- ey) < / Rabs y <= bpow (- ey + 1))%R
  split.r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
(bpow (- ey) < / Rabs y)%R
r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
(/ Rabs y <= bpow (- ey + 1))%R
  -r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
(bpow (- ey) < / Rabs y)%R rewrite bpow_opp.r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
(/ bpow ey < / Rabs y)%R
    apply Rinv_lt_contravar.r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
(0 < Rabs y * bpow ey)%R
r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
(Rabs y < bpow ey)%R
    +r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
(0 < Rabs y * bpow ey)%R apply Rmult_lt_0_compat.r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
(0 < Rabs y)%R
r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
(0 < bpow ey)%R
      now apply Rabs_pos_lt.r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
(0 < bpow ey)%R
      now apply bpow_gt_0.
    +r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
(Rabs y < bpow ey)%R now apply Hey.
  -r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
(/ Rabs y <= bpow (- ey + 1))%R replace (_ + _)%Z with (- (ey - 1))%Z by ring.r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
(/ Rabs y <= bpow (- (ey - 1)))%R
    rewrite bpow_opp.r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
(/ Rabs y <= / bpow (ey - 1))%R
    apply Rinv_le; [now apply bpow_gt_0|].r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
(bpow (ey - 1) <= Rabs y)%R
    now apply Hey. }r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
Heiy:(bpow (- ey) < Rabs (/ y) <= bpow (- ey + 1))%R
(ex - ey <= mag (x * / y) <= ex - ey + 1)%Z
split.r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
Heiy:(bpow (- ey) < Rabs (/ y) <= bpow (- ey + 1))%R
(ex - ey <= mag (x * / y))%Z
r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R ->
(bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R ->
(bpow (ey - 1) <= Rabs y < bpow ey)%R
Heiy:(bpow (- ey) < Rabs (/ y) <= bpow (- ey + 1))%R
(mag (x * / y) <= ex - ey + 1)%Z
-r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
Heiy:(bpow (- ey) < Rabs (/ y) <= bpow (- ey + 1))%R
(ex - ey <= mag (x * / y))%Z apply mag_ge_bpow.r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
Heiy:(bpow (- ey) < Rabs (/ y) <= bpow (- ey + 1))%R
(bpow (ex - ey - 1) <= Rabs (x * / y))%R
  replace (_ - _)%Z with (ex - 1 - ey)%Z by ring.r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
Heiy:(bpow (- ey) < Rabs (/ y) <= bpow (- ey + 1))%R
(bpow (ex - 1 - ey) <= Rabs (x * / y))%R
  unfold Zminus at 1; rewrite bpow_plus.r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
Heiy:(bpow (- ey) < Rabs (/ y) <= bpow (- ey + 1))%R
(bpow (ex - 1) * bpow (- ey) <= Rabs (x * / y))%R
  rewrite Rabs_mult.r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
Heiy:(bpow (- ey) < Rabs (/ y) <= bpow (- ey + 1))%R
(bpow (ex - 1) * bpow (- ey) <= Rabs x * Rabs (/ y))%R
  apply Rmult_le_compat.r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
Heiy:(bpow (- ey) < Rabs (/ y) <= bpow (- ey + 1))%R
(0 <= bpow (ex - 1))%R
r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R ->
(bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R ->
(bpow (ey - 1) <= Rabs y < bpow ey)%R
Heiy:(bpow (- ey) < Rabs (/ y) <= bpow (- ey + 1))%R
(0 <= bpow (- ey))%R
r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R ->
(bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R ->
(bpow (ey - 1) <= Rabs y < bpow ey)%R
Heiy:(bpow (- ey) < Rabs (/ y) <= bpow (- ey + 1))%R
(bpow (ex - 1) <= Rabs x)%R
r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R ->
(bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R ->
(bpow (ey - 1) <= Rabs y < bpow ey)%R
Heiy:(bpow (- ey) < Rabs (/ y) <= bpow (- ey + 1))%R
(bpow (- ey) <= Rabs (/ y))%R
  +r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
Heiy:(bpow (- ey) < Rabs (/ y) <= bpow (- ey + 1))%R
(0 <= bpow (ex - 1))%R now apply bpow_ge_0.
  +r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
Heiy:(bpow (- ey) < Rabs (/ y) <= bpow (- ey + 1))%R
(0 <= bpow (- ey))%R now apply bpow_ge_0.
  +r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
Heiy:(bpow (- ey) < Rabs (/ y) <= bpow (- ey + 1))%R
(bpow (ex - 1) <= Rabs x)%R now apply Hex.
  +r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
Heiy:(bpow (- ey) < Rabs (/ y) <= bpow (- ey + 1))%R
(bpow (- ey) <= Rabs (/ y))%R now apply Rlt_le; apply Heiy.
-r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
Heiy:(bpow (- ey) < Rabs (/ y) <= bpow (- ey + 1))%R
(mag (x * / y) <= ex - ey + 1)%Z apply mag_le_bpow.r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
Heiy:(bpow (- ey) < Rabs (/ y) <= bpow (- ey + 1))%R
(x * / y)%R <> 0%R
r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R ->
(bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R ->
(bpow (ey - 1) <= Rabs y < bpow ey)%R
Heiy:(bpow (- ey) < Rabs (/ y) <= bpow (- ey + 1))%R
(Rabs (x * / y) < bpow (ex - ey + 1))%R
  +r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
Heiy:(bpow (- ey) < Rabs (/ y) <= bpow (- ey + 1))%R
(x * / y)%R <> 0%R apply Rmult_integral_contrapositive_currified.r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
Heiy:(bpow (- ey) < Rabs (/ y) <= bpow (- ey + 1))%R
x <> 0%R
r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R ->
(bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R ->
(bpow (ey - 1) <= Rabs y < bpow ey)%R
Heiy:(bpow (- ey) < Rabs (/ y) <= bpow (- ey + 1))%R
(/ y)%R <> 0%R
    exact Px.r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
Heiy:(bpow (- ey) < Rabs (/ y) <= bpow (- ey + 1))%R
(/ y)%R <> 0%R
    now apply Rinv_neq_0_compat.
  +r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
Heiy:(bpow (- ey) < Rabs (/ y) <= bpow (- ey + 1))%R
(Rabs (x * / y) < bpow (ex - ey + 1))%R replace (_ + 1)%Z with (ex + (- ey + 1))%Z by ring.r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
Heiy:(bpow (- ey) < Rabs (/ y) <= bpow (- ey + 1))%R
(Rabs (x * / y) < bpow (ex + (- ey + 1)))%R
    rewrite bpow_plus.r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
Heiy:(bpow (- ey) < Rabs (/ y) <= bpow (- ey + 1))%R
(Rabs (x * / y) < bpow ex * bpow (- ey + 1))%R
    apply Rlt_le_trans with (bpow ex * Rabs (/ y))%R.r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
Heiy:(bpow (- ey) < Rabs (/ y) <= bpow (- ey + 1))%R
(Rabs (x * / y) < bpow ex * Rabs (/ y))%R
r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R ->
(bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R ->
(bpow (ey - 1) <= Rabs y < bpow ey)%R
Heiy:(bpow (- ey) < Rabs (/ y) <= bpow (- ey + 1))%R
(bpow ex * Rabs (/ y) <= bpow ex * bpow (- ey + 1))%R
    *r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
Heiy:(bpow (- ey) < Rabs (/ y) <= bpow (- ey + 1))%R
(Rabs (x * / y) < bpow ex * Rabs (/ y))%R rewrite Rabs_mult.r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
Heiy:(bpow (- ey) < Rabs (/ y) <= bpow (- ey + 1))%R
(Rabs x * Rabs (/ y) < bpow ex * Rabs (/ y))%R
      apply Rmult_lt_compat_r.r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
Heiy:(bpow (- ey) < Rabs (/ y) <= bpow (- ey + 1))%R
(0 < Rabs (/ y))%R
r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R ->
(bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R ->
(bpow (ey - 1) <= Rabs y < bpow ey)%R
Heiy:(bpow (- ey) < Rabs (/ y) <= bpow (- ey + 1))%R
(Rabs x < bpow ex)%R
      apply Rabs_pos_lt.r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
Heiy:(bpow (- ey) < Rabs (/ y) <= bpow (- ey + 1))%R
(/ y)%R <> 0%R
r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R ->
(bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R ->
(bpow (ey - 1) <= Rabs y < bpow ey)%R
Heiy:(bpow (- ey) < Rabs (/ y) <= bpow (- ey + 1))%R
(Rabs x < bpow ex)%R
      now apply Rinv_neq_0_compat.r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
Heiy:(bpow (- ey) < Rabs (/ y) <= bpow (- ey + 1))%R
(Rabs x < bpow ex)%R
      now apply Hex.
    *r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
Heiy:(bpow (- ey) < Rabs (/ y) <= bpow (- ey + 1))%R
(bpow ex * Rabs (/ y) <= bpow ex * bpow (- ey + 1))%R apply Rmult_le_compat_l; [now apply bpow_ge_0|].r:radix
x, y:R
Px:x <> 0%R
Py:y <> 0%R
ex:Z
Hex:x <> 0%R -> (bpow (ex - 1) <= Rabs x < bpow ex)%R
ey:Z
Hey:y <> 0%R -> (bpow (ey - 1) <= Rabs y < bpow ey)%R
Heiy:(bpow (- ey) < Rabs (/ y) <= bpow (- ey + 1))%R
(Rabs (/ y) <= bpow (- ey + 1))%R
      apply Heiy.
Qed.

Lemma mag_sqrt :
  forall x,
  (0 < x)%R ->
  mag (sqrt x) = Z.div2 (mag x + 1) :> Z.r:radix
forall x : R,
(0 < x)%R -> mag (sqrt x) = Z.div2 (mag x + 1)
Proof.r:radix
forall x : R,
(0 < x)%R -> mag (sqrt x) = Z.div2 (mag x + 1)
intros x Px.r:radix
x:R
Px:(0 < x)%R
mag (sqrt x) = Z.div2 (mag x + 1)
apply mag_unique.r:radix
x:R
Px:(0 < x)%R
(bpow (Z.div2 (mag x + 1) - 1) <= Rabs (sqrt x) <
 bpow (Z.div2 (mag x + 1)))%R
destruct mag as [e He].r:radix
x:R
Px:(0 < x)%R
e:Z
He:x <> 0%R -> (bpow (e - 1) <= Rabs x < bpow e)%R
(bpow (Z.div2 (Build_mag_prop x e He + 1) - 1) <=
 Rabs (sqrt x) <
 bpow (Z.div2 (Build_mag_prop x e He + 1)))%R
simpl.r:radix
x:R
Px:(0 < x)%R
e:Z
He:x <> 0%R -> (bpow (e - 1) <= Rabs x < bpow e)%R
(bpow (Z.div2 (e + 1) - 1) <= Rabs (sqrt x) <
 bpow (Z.div2 (e + 1)))%R
specialize (He (Rgt_not_eq _ _ Px)).r:radix
x:R
Px:(0 < x)%R
e:Z
He:(bpow (e - 1) <= Rabs x < bpow e)%R
(bpow (Z.div2 (e + 1) - 1) <= Rabs (sqrt x) <
 bpow (Z.div2 (e + 1)))%R
rewrite Rabs_pos_eq in He by now apply Rlt_le.r:radix
x:R
Px:(0 < x)%R
e:Z
He:(bpow (e - 1) <= x < bpow e)%R
(bpow (Z.div2 (e + 1) - 1) <= Rabs (sqrt x) <
 bpow (Z.div2 (e + 1)))%R
split.r:radix
x:R
Px:(0 < x)%R
e:Z
He:(bpow (e - 1) <= x < bpow e)%R
(bpow (Z.div2 (e + 1) - 1) <= Rabs (sqrt x))%R
r:radix
x:R
Px:(0 < x)%R
e:Z
He:(bpow (e - 1) <= x < bpow e)%R
(Rabs (sqrt x) < bpow (Z.div2 (e + 1)))%R
-r:radix
x:R
Px:(0 < x)%R
e:Z
He:(bpow (e - 1) <= x < bpow e)%R
(bpow (Z.div2 (e + 1) - 1) <= Rabs (sqrt x))%R rewrite <- (Rabs_pos_eq (bpow _)) by apply bpow_ge_0.r:radix
x:R
Px:(0 < x)%R
e:Z
He:(bpow (e - 1) <= x < bpow e)%R
(Rabs (bpow (Z.div2 (e + 1) - 1)) <= Rabs (sqrt x))%R
  apply Rsqr_le_abs_0.r:radix
x:R
Px:(0 < x)%R
e:Z
He:(bpow (e - 1) <= x < bpow e)%R
((bpow (Z.div2 (e + 1) - 1))² <= (sqrt x)²)%R
  rewrite Rsqr_sqrt by now apply Rlt_le.r:radix
x:R
Px:(0 < x)%R
e:Z
He:(bpow (e - 1) <= x < bpow e)%R
((bpow (Z.div2 (e + 1) - 1))² <= x)%R
  apply Rle_trans with (2 := proj1 He).r:radix
x:R
Px:(0 < x)%R
e:Z
He:(bpow (e - 1) <= x < bpow e)%R
((bpow (Z.div2 (e + 1) - 1))² <= bpow (e - 1))%R
  unfold Rsqr ; rewrite <- bpow_plus.r:radix
x:R
Px:(0 < x)%R
e:Z
He:(bpow (e - 1) <= x < bpow e)%R
(bpow (Z.div2 (e + 1) - 1 + (Z.div2 (e + 1) - 1)) <=
 bpow (e - 1))%R
  apply bpow_le.r:radix
x:R
Px:(0 < x)%R
e:Z
He:(bpow (e - 1) <= x < bpow e)%R
(Z.div2 (e + 1) - 1 + (Z.div2 (e + 1) - 1) <= e - 1)%Z
  generalize (Zdiv2_odd_eqn (e + 1)).r:radix
x:R
Px:(0 < x)%R
e:Z
He:(bpow (e - 1) <= x < bpow e)%R
(e + 1)%Z =
(2 * Z.div2 (e + 1) + (if Z.odd (e + 1) then 1 else 0))%Z ->
(Z.div2 (e + 1) - 1 + (Z.div2 (e + 1) - 1) <= e - 1)%Z
  destruct Z.odd ; intros ; omega.
-r:radix
x:R
Px:(0 < x)%R
e:Z
He:(bpow (e - 1) <= x < bpow e)%R
(Rabs (sqrt x) < bpow (Z.div2 (e + 1)))%R rewrite <- (Rabs_pos_eq (bpow _)) by apply bpow_ge_0.r:radix
x:R
Px:(0 < x)%R
e:Z
He:(bpow (e - 1) <= x < bpow e)%R
(Rabs (sqrt x) < Rabs (bpow (Z.div2 (e + 1))))%R
  apply Rsqr_lt_abs_0.r:radix
x:R
Px:(0 < x)%R
e:Z
He:(bpow (e - 1) <= x < bpow e)%R
((sqrt x)² < (bpow (Z.div2 (e + 1)))²)%R
  rewrite Rsqr_sqrt by now apply Rlt_le.r:radix
x:R
Px:(0 < x)%R
e:Z
He:(bpow (e - 1) <= x < bpow e)%R
(x < (bpow (Z.div2 (e + 1)))²)%R
  apply Rlt_le_trans with (1 := proj2 He).r:radix
x:R
Px:(0 < x)%R
e:Z
He:(bpow (e - 1) <= x < bpow e)%R
(bpow e <= (bpow (Z.div2 (e + 1)))²)%R
  unfold Rsqr ; rewrite <- bpow_plus.r:radix
x:R
Px:(0 < x)%R
e:Z
He:(bpow (e - 1) <= x < bpow e)%R
(bpow e <= bpow (Z.div2 (e + 1) + Z.div2 (e + 1)))%R
  apply bpow_le.r:radix
x:R
Px:(0 < x)%R
e:Z
He:(bpow (e - 1) <= x < bpow e)%R
(e <= Z.div2 (e + 1) + Z.div2 (e + 1))%Z
  generalize (Zdiv2_odd_eqn (e + 1)).r:radix
x:R
Px:(0 < x)%R
e:Z
He:(bpow (e - 1) <= x < bpow e)%R
(e + 1)%Z =
(2 * Z.div2 (e + 1) + (if Z.odd (e + 1) then 1 else 0))%Z ->
(e <= Z.div2 (e + 1) + Z.div2 (e + 1))%Z
  destruct Z.odd ; intros ; omega.
Qed.

Lemma mag_1 : mag 1 = 1%Z :> Z.r:radix
mag 1 = 1%Z
Proof.r:radix
mag 1 = 1%Z
apply mag_unique_pos; rewrite bpow_1; simpl; split; [now right|apply IZR_lt].r:radix
(1 < r)%Z
assert (H := Zle_bool_imp_le _ _ (radix_prop r)); revert H.r:radix
(2 <= r)%Z -> (1 < r)%Z
now apply Z.lt_le_trans.
Qed.

End pow.

Section Bool.

Theorem eqb_sym :
  forall x y, Bool.eqb x y = Bool.eqb y x.forall x y : bool, Bool.eqb x y = Bool.eqb y x
Proof.forall x y : bool, Bool.eqb x y = Bool.eqb y x
now intros [|] [|].
Qed.

Theorem eqb_false :
  forall x y, x = negb y -> Bool.eqb x y = false.forall x y : bool, x = negb y -> Bool.eqb x y = false
Proof.forall x y : bool, x = negb y -> Bool.eqb x y = false
now intros [|] [|].
Qed.

Theorem eqb_true :
  forall x y, x = y -> Bool.eqb x y = true.forall x y : bool, x = y -> Bool.eqb x y = true
Proof.forall x y : bool, x = y -> Bool.eqb x y = true
now intros [|] [|].
Qed.

End Bool.

Section cond_Ropp.

Definition cond_Ropp (b : bool) m := if b then Ropp m else m.

Theorem IZR_cond_Zopp :
  forall b m,
  IZR (cond_Zopp b m) = cond_Ropp b (IZR m).forall (b : bool) (m : Z),
IZR (SpecFloatCopy.cond_Zopp b m) =
cond_Ropp b (IZR m)
Proof.forall (b : bool) (m : Z),
IZR (SpecFloatCopy.cond_Zopp b m) =
cond_Ropp b (IZR m)
intros [|] m.m:Z
IZR (SpecFloatCopy.cond_Zopp true m) =
cond_Ropp true (IZR m)
m:Z
IZR (SpecFloatCopy.cond_Zopp false m) =
cond_Ropp false (IZR m)
apply opp_IZR.m:Z
IZR (SpecFloatCopy.cond_Zopp false m) =
cond_Ropp false (IZR m)
apply refl_equal.
Qed.

Theorem abs_cond_Ropp :
  forall b m,
  Rabs (cond_Ropp b m) = Rabs m.forall (b : bool) (m : R),
Rabs (cond_Ropp b m) = Rabs m
Proof.forall (b : bool) (m : R),
Rabs (cond_Ropp b m) = Rabs m
intros [|] m.m:R
Rabs (cond_Ropp true m) = Rabs m
m:R
Rabs (cond_Ropp false m) = Rabs m
apply Rabs_Ropp.m:R
Rabs (cond_Ropp false m) = Rabs m
apply refl_equal.
Qed.

Theorem cond_Ropp_Rlt_bool :
  forall m,
  cond_Ropp (Rlt_bool m 0) m = Rabs m.forall m : R, cond_Ropp (Rlt_bool m 0) m = Rabs m
Proof.forall m : R, cond_Ropp (Rlt_bool m 0) m = Rabs m
intros m.m:R
cond_Ropp (Rlt_bool m 0) m = Rabs m
apply sym_eq.m:R
Rabs m = cond_Ropp (Rlt_bool m 0) m
case Rlt_bool_spec ; intros Hm.m:R
Hm:(m < 0)%R
Rabs m = cond_Ropp true m
m:R
Hm:(0 <= m)%R
Rabs m = cond_Ropp false m
now apply Rabs_left.m:R
Hm:(0 <= m)%R
Rabs m = cond_Ropp false m
now apply Rabs_pos_eq.
Qed.

Theorem cond_Ropp_involutive :
  forall b x,
  cond_Ropp b (cond_Ropp b x) = x.forall (b : bool) (x : R),
cond_Ropp b (cond_Ropp b x) = x
Proof.forall (b : bool) (x : R),
cond_Ropp b (cond_Ropp b x) = x
intros [|] x.x:R
cond_Ropp true (cond_Ropp true x) = x
x:R
cond_Ropp false (cond_Ropp false x) = x
apply Ropp_involutive.x:R
cond_Ropp false (cond_Ropp false x) = x
apply refl_equal.
Qed.

Theorem cond_Ropp_inj :
  forall b x y,
  cond_Ropp b x = cond_Ropp b y -> x = y.forall (b : bool) (x y : R),
cond_Ropp b x = cond_Ropp b y -> x = y
Proof.forall (b : bool) (x y : R),
cond_Ropp b x = cond_Ropp b y -> x = y
intros b x y H.b:bool
x, y:R
H:cond_Ropp b x = cond_Ropp b y
x = y
rewrite <- (cond_Ropp_involutive b x), H.b:bool
x, y:R
H:cond_Ropp b x = cond_Ropp b y
cond_Ropp b (cond_Ropp b y) = y
apply cond_Ropp_involutive.
Qed.

Theorem cond_Ropp_mult_l :
  forall b x y,
  cond_Ropp b (x * y) = (cond_Ropp b x * y)%R.forall (b : bool) (x y : R),
cond_Ropp b (x * y) = (cond_Ropp b x * y)%R
Proof.forall (b : bool) (x y : R),
cond_Ropp b (x * y) = (cond_Ropp b x * y)%R
intros [|] x y.x, y:R
cond_Ropp true (x * y) = (cond_Ropp true x * y)%R
x, y:R
cond_Ropp false (x * y) = (cond_Ropp false x * y)%R
apply sym_eq.x, y:R
(cond_Ropp true x * y)%R = cond_Ropp true (x * y)
x, y:R
cond_Ropp false (x * y) = (cond_Ropp false x * y)%R
apply Ropp_mult_distr_l_reverse.x, y:R
cond_Ropp false (x * y) = (cond_Ropp false x * y)%R
apply refl_equal.
Qed.

Theorem cond_Ropp_mult_r :
  forall b x y,
  cond_Ropp b (x * y) = (x * cond_Ropp b y)%R.forall (b : bool) (x y : R),
cond_Ropp b (x * y) = (x * cond_Ropp b y)%R
Proof.forall (b : bool) (x y : R),
cond_Ropp b (x * y) = (x * cond_Ropp b y)%R
intros [|] x y.x, y:R
cond_Ropp true (x * y) = (x * cond_Ropp true y)%R
x, y:R
cond_Ropp false (x * y) = (x * cond_Ropp false y)%R
apply sym_eq.x, y:R
(x * cond_Ropp true y)%R = cond_Ropp true (x * y)
x, y:R
cond_Ropp false (x * y) = (x * cond_Ropp false y)%R
apply Ropp_mult_distr_r_reverse.x, y:R
cond_Ropp false (x * y) = (x * cond_Ropp false y)%R
apply refl_equal.
Qed.

Theorem cond_Ropp_plus :
  forall b x y,
  cond_Ropp b (x + y) = (cond_Ropp b x + cond_Ropp b y)%R.forall (b : bool) (x y : R),
cond_Ropp b (x + y) =
(cond_Ropp b x + cond_Ropp b y)%R
Proof.forall (b : bool) (x y : R),
cond_Ropp b (x + y) =
(cond_Ropp b x + cond_Ropp b y)%R
intros [|] x y.x, y:R
cond_Ropp true (x + y) =
(cond_Ropp true x + cond_Ropp true y)%R
x, y:R
cond_Ropp false (x + y) =
(cond_Ropp false x + cond_Ropp false y)%R
apply Ropp_plus_distr.x, y:R
cond_Ropp false (x + y) =
(cond_Ropp false x + cond_Ropp false y)%R
apply refl_equal.
Qed.

End cond_Ropp.

LPO taken from Coquelicot

Theorem LPO_min :
  forall P : nat -> Prop, (forall n, P n \/ ~ P n) ->
  {n : nat | P n /\ forall i, (i < n)%nat -> ~ P i} + {forall n, ~ P n}.forall P : nat -> Prop,
(forall n : nat, P n \/ ~ P n) ->
{n : nat | P n /\ (forall i : nat, i < n -> ~ P i)} +
{forall n : nat, ~ P n}
Proof.forall P : nat -> Prop,
(forall n : nat, P n \/ ~ P n) ->
{n : nat | P n /\ (forall i : nat, i < n -> ~ P i)} +
{forall n : nat, ~ P n}
assert (Hi: forall n, (0 < INR n + 1)%R).forall n : nat, (0 < INR n + 1)%R
Hi:forall n : nat, (0 < INR n + 1)%R
forall P : nat -> Prop,
(forall n : nat, P n \/ ~ P n) ->
{n : nat | P n /\ (forall i : nat, i < n -> ~ P i)} +
{forall n : nat, ~ P n}
  intros N.N:nat
(0 < INR N + 1)%R
Hi:forall n : nat, (0 < INR n + 1)%R
forall P : nat -> Prop,
(forall n : nat, P n \/ ~ P n) ->
{n : nat | P n /\ (forall i : nat, i < n -> ~ P i)} +
{forall n : nat, ~ P n}
  rewrite <- S_INR.N:nat
(0 < INR (S N))%R
Hi:forall n : nat, (0 < INR n + 1)%R
forall P : nat -> Prop,
(forall n : nat, P n \/ ~ P n) ->
{n : nat | P n /\ (forall i : nat, i < n -> ~ P i)} +
{forall n : nat, ~ P n}
  apply lt_0_INR.N:nat
0 < S N
Hi:forall n : nat, (0 < INR n + 1)%R
forall P : nat -> Prop,
(forall n : nat, P n \/ ~ P n) ->
{n : nat | P n /\ (forall i : nat, i < n -> ~ P i)} +
{forall n : nat, ~ P n}
  apply lt_0_Sn.Hi:forall n : nat, (0 < INR n + 1)%R
forall P : nat -> Prop,
(forall n : nat, P n \/ ~ P n) ->
{n : nat | P n /\ (forall i : nat, i < n -> ~ P i)} +
{forall n : nat, ~ P n}
intros P HP.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
{n : nat | P n /\ (forall i : nat, i < n -> ~ P i)} +
{forall n : nat, ~ P n}
set (E y := exists n, (P n /\ y = / (INR n + 1))%R \/ (~ P n /\ y = 0)%R).Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
{n : nat | P n /\ (forall i : nat, i < n -> ~ P i)} +
{forall n : nat, ~ P n}
assert (HE: forall n, P n -> E (/ (INR n + 1))%R).Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
forall n : nat, P n -> E (/ (INR n + 1))%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
{n : nat | P n /\ (forall i : nat, i < n -> ~ P i)} +
{forall n : nat, ~ P n}
  intros n Pn.Hi:forall n0 : nat, (0 < INR n0 + 1)%R
P:nat -> Prop
HP:forall n0 : nat, P n0 \/ ~ P n0
E:=fun y : R =>
exists n0 : nat,
  P n0 /\ y = (/ (INR n0 + 1))%R \/
  ~ P n0 /\ y = 0%R:R -> Prop
n:nat
Pn:P n
E (/ (INR n + 1))%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
{n : nat | P n /\ (forall i : nat, i < n -> ~ P i)} +
{forall n : nat, ~ P n}
  exists n.Hi:forall n0 : nat, (0 < INR n0 + 1)%R
P:nat -> Prop
HP:forall n0 : nat, P n0 \/ ~ P n0
E:=fun y : R =>
exists n0 : nat,
  P n0 /\ y = (/ (INR n0 + 1))%R \/
  ~ P n0 /\ y = 0%R:R -> Prop
n:nat
Pn:P n
P n /\ (/ (INR n + 1))%R = (/ (INR n + 1))%R \/
~ P n /\ (/ (INR n + 1))%R = 0%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
{n : nat | P n /\ (forall i : nat, i < n -> ~ P i)} +
{forall n : nat, ~ P n}
  left.Hi:forall n0 : nat, (0 < INR n0 + 1)%R
P:nat -> Prop
HP:forall n0 : nat, P n0 \/ ~ P n0
E:=fun y : R =>
exists n0 : nat,
  P n0 /\ y = (/ (INR n0 + 1))%R \/
  ~ P n0 /\ y = 0%R:R -> Prop
n:nat
Pn:P n
P n /\ (/ (INR n + 1))%R = (/ (INR n + 1))%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
{n : nat | P n /\ (forall i : nat, i < n -> ~ P i)} +
{forall n : nat, ~ P n}
  now split.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
{n : nat | P n /\ (forall i : nat, i < n -> ~ P i)} +
{forall n : nat, ~ P n}
assert (BE: is_upper_bound E 1).Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
is_upper_bound E 1
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
{n : nat | P n /\ (forall i : nat, i < n -> ~ P i)} +
{forall n : nat, ~ P n}
  intros x [y [[_ ->]|[_ ->]]].Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y0 : R =>
exists n : nat,
  P n /\ y0 = (/ (INR n + 1))%R \/
  ~ P n /\ y0 = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
y:nat
(/ (INR y + 1) <= 1)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y0 : R =>
exists n : nat,
  P n /\ y0 = (/ (INR n + 1))%R \/
  ~ P n /\ y0 = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
y:nat
(0 <= 1)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
{n : nat | P n /\ (forall i : nat, i < n -> ~ P i)} +
{forall n : nat, ~ P n}
  rewrite <- Rinv_1 at 2.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y0 : R =>
exists n : nat,
  P n /\ y0 = (/ (INR n + 1))%R \/
  ~ P n /\ y0 = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
y:nat
(/ (INR y + 1) <= / 1)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y0 : R =>
exists n : nat,
  P n /\ y0 = (/ (INR n + 1))%R \/
  ~ P n /\ y0 = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
y:nat
(0 <= 1)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
{n : nat | P n /\ (forall i : nat, i < n -> ~ P i)} +
{forall n : nat, ~ P n}
  apply Rinv_le.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y0 : R =>
exists n : nat,
  P n /\ y0 = (/ (INR n + 1))%R \/
  ~ P n /\ y0 = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
y:nat
(0 < 1)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y0 : R =>
exists n : nat,
  P n /\ y0 = (/ (INR n + 1))%R \/
  ~ P n /\ y0 = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
y:nat
(1 <= INR y + 1)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y0 : R =>
exists n : nat,
  P n /\ y0 = (/ (INR n + 1))%R \/
  ~ P n /\ y0 = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
y:nat
(0 <= 1)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
{n : nat | P n /\ (forall i : nat, i < n -> ~ P i)} +
{forall n : nat, ~ P n}
  exact Rlt_0_1.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y0 : R =>
exists n : nat,
  P n /\ y0 = (/ (INR n + 1))%R \/
  ~ P n /\ y0 = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
y:nat
(1 <= INR y + 1)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y0 : R =>
exists n : nat,
  P n /\ y0 = (/ (INR n + 1))%R \/
  ~ P n /\ y0 = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
y:nat
(0 <= 1)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
{n : nat | P n /\ (forall i : nat, i < n -> ~ P i)} +
{forall n : nat, ~ P n}
  rewrite <- S_INR.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y0 : R =>
exists n : nat,
  P n /\ y0 = (/ (INR n + 1))%R \/
  ~ P n /\ y0 = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
y:nat
(1 <= INR (S y))%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y0 : R =>
exists n : nat,
  P n /\ y0 = (/ (INR n + 1))%R \/
  ~ P n /\ y0 = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
y:nat
(0 <= 1)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
{n : nat | P n /\ (forall i : nat, i < n -> ~ P i)} +
{forall n : nat, ~ P n}
  apply (le_INR 1), le_n_S, le_0_n.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y0 : R =>
exists n : nat,
  P n /\ y0 = (/ (INR n + 1))%R \/
  ~ P n /\ y0 = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
y:nat
(0 <= 1)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
{n : nat | P n /\ (forall i : nat, i < n -> ~ P i)} +
{forall n : nat, ~ P n}
  exact Rle_0_1.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
{n : nat | P n /\ (forall i : nat, i < n -> ~ P i)} +
{forall n : nat, ~ P n}
destruct (completeness E) as [l [ub lub]].Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
bound E
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
exists x : R, E x
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
{n : nat | P n /\ (forall i : nat, i < n -> ~ P i)} +
{forall n : nat, ~ P n}
  now exists 1%R.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
exists x : R, E x
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
{n : nat | P n /\ (forall i : nat, i < n -> ~ P i)} +
{forall n : nat, ~ P n}
  destruct (HP O) as [H0|H0].Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
H0:P 0
exists x : R, E x
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
H0:~ P 0
exists x : R, E x
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
{n : nat | P n /\ (forall i : nat, i < n -> ~ P i)} +
{forall n : nat, ~ P n}
  exists 1%R.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
H0:P 0
E 1%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
H0:~ P 0
exists x : R, E x
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
{n : nat | P n /\ (forall i : nat, i < n -> ~ P i)} +
{forall n : nat, ~ P n}
  exists O.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
H0:P 0
P 0 /\ 1%R = (/ (INR 0 + 1))%R \/ ~ P 0 /\ 1%R = 0%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
H0:~ P 0
exists x : R, E x
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
{n : nat | P n /\ (forall i : nat, i < n -> ~ P i)} +
{forall n : nat, ~ P n}
  left.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
H0:P 0
P 0 /\ 1%R = (/ (INR 0 + 1))%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
H0:~ P 0
exists x : R, E x
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
{n : nat | P n /\ (forall i : nat, i < n -> ~ P i)} +
{forall n : nat, ~ P n}
  apply (conj H0).Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
H0:P 0
1%R = (/ (INR 0 + 1))%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
H0:~ P 0
exists x : R, E x
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
{n : nat | P n /\ (forall i : nat, i < n -> ~ P i)} +
{forall n : nat, ~ P n}
  rewrite Rplus_0_l.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
H0:P 0
1%R = (/ 1)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
H0:~ P 0
exists x : R, E x
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
{n : nat | P n /\ (forall i : nat, i < n -> ~ P i)} +
{forall n : nat, ~ P n}
  apply sym_eq, Rinv_1.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
H0:~ P 0
exists x : R, E x
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
{n : nat | P n /\ (forall i : nat, i < n -> ~ P i)} +
{forall n : nat, ~ P n}
  exists 0%R.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
H0:~ P 0
E 0%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
{n : nat | P n /\ (forall i : nat, i < n -> ~ P i)} +
{forall n : nat, ~ P n}
  exists O.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
H0:~ P 0
P 0 /\ 0%R = (/ (INR 0 + 1))%R \/ ~ P 0 /\ 0%R = 0%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
{n : nat | P n /\ (forall i : nat, i < n -> ~ P i)} +
{forall n : nat, ~ P n}
  right.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
H0:~ P 0
~ P 0 /\ 0%R = 0%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
{n : nat | P n /\ (forall i : nat, i < n -> ~ P i)} +
{forall n : nat, ~ P n}
  now split.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
{n : nat | P n /\ (forall i : nat, i < n -> ~ P i)} +
{forall n : nat, ~ P n}
destruct (Rle_lt_dec l 0) as [Hl|Hl].Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(l <= 0)%R
{n : nat | P n /\ (forall i : nat, i < n -> ~ P i)} +
{forall n : nat, ~ P n}
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
{n : nat | P n /\ (forall i : nat, i < n -> ~ P i)} +
{forall n : nat, ~ P n}
  right.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(l <= 0)%R
forall n : nat, ~ P n
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
{n : nat | P n /\ (forall i : nat, i < n -> ~ P i)} +
{forall n : nat, ~ P n}
  intros n Pn.Hi:forall n0 : nat, (0 < INR n0 + 1)%R
P:nat -> Prop
HP:forall n0 : nat, P n0 \/ ~ P n0
E:=fun y : R =>
exists n0 : nat,
  P n0 /\ y = (/ (INR n0 + 1))%R \/
  ~ P n0 /\ y = 0%R:R -> Prop
HE:forall n0 : nat, P n0 -> E (/ (INR n0 + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(l <= 0)%R
n:nat
Pn:P n
False
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
{n : nat | P n /\ (forall i : nat, i < n -> ~ P i)} +
{forall n : nat, ~ P n}
  apply Rle_not_lt with (1 := Hl).Hi:forall n0 : nat, (0 < INR n0 + 1)%R
P:nat -> Prop
HP:forall n0 : nat, P n0 \/ ~ P n0
E:=fun y : R =>
exists n0 : nat,
  P n0 /\ y = (/ (INR n0 + 1))%R \/
  ~ P n0 /\ y = 0%R:R -> Prop
HE:forall n0 : nat, P n0 -> E (/ (INR n0 + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(l <= 0)%R
n:nat
Pn:P n
(0 < l)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
{n : nat | P n /\ (forall i : nat, i < n -> ~ P i)} +
{forall n : nat, ~ P n}
  apply Rlt_le_trans with (/ (INR n + 1))%R.Hi:forall n0 : nat, (0 < INR n0 + 1)%R
P:nat -> Prop
HP:forall n0 : nat, P n0 \/ ~ P n0
E:=fun y : R =>
exists n0 : nat,
  P n0 /\ y = (/ (INR n0 + 1))%R \/
  ~ P n0 /\ y = 0%R:R -> Prop
HE:forall n0 : nat, P n0 -> E (/ (INR n0 + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(l <= 0)%R
n:nat
Pn:P n
(0 < / (INR n + 1))%R
Hi:forall n0 : nat, (0 < INR n0 + 1)%R
P:nat -> Prop
HP:forall n0 : nat, P n0 \/ ~ P n0
E:=fun y : R =>
exists n0 : nat,
  P n0 /\ y = (/ (INR n0 + 1))%R \/
  ~ P n0 /\ y = 0%R:R -> Prop
HE:forall n0 : nat, P n0 -> E (/ (INR n0 + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(l <= 0)%R
n:nat
Pn:P n
(/ (INR n + 1) <= l)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
{n : nat | P n /\ (forall i : nat, i < n -> ~ P i)} +
{forall n : nat, ~ P n}
  now apply Rinv_0_lt_compat.Hi:forall n0 : nat, (0 < INR n0 + 1)%R
P:nat -> Prop
HP:forall n0 : nat, P n0 \/ ~ P n0
E:=fun y : R =>
exists n0 : nat,
  P n0 /\ y = (/ (INR n0 + 1))%R \/
  ~ P n0 /\ y = 0%R:R -> Prop
HE:forall n0 : nat, P n0 -> E (/ (INR n0 + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(l <= 0)%R
n:nat
Pn:P n
(/ (INR n + 1) <= l)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
{n : nat | P n /\ (forall i : nat, i < n -> ~ P i)} +
{forall n : nat, ~ P n}
  apply ub.Hi:forall n0 : nat, (0 < INR n0 + 1)%R
P:nat -> Prop
HP:forall n0 : nat, P n0 \/ ~ P n0
E:=fun y : R =>
exists n0 : nat,
  P n0 /\ y = (/ (INR n0 + 1))%R \/
  ~ P n0 /\ y = 0%R:R -> Prop
HE:forall n0 : nat, P n0 -> E (/ (INR n0 + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(l <= 0)%R
n:nat
Pn:P n
E (/ (INR n + 1))%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
{n : nat | P n /\ (forall i : nat, i < n -> ~ P i)} +
{forall n : nat, ~ P n}
  now apply HE.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
{n : nat | P n /\ (forall i : nat, i < n -> ~ P i)} +
{forall n : nat, ~ P n}
left.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
{n : nat | P n /\ (forall i : nat, i < n -> ~ P i)}
set (N := Z.abs_nat (up (/l) - 2)).Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
{n : nat | P n /\ (forall i : nat, i < n -> ~ P i)}
exists N.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
P N /\ (forall i : nat, i < N -> ~ P i)
assert (HN: (INR N + 1 = IZR (up (/ l)) - 1)%R).Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
P N /\ (forall i : nat, i < N -> ~ P i)
  unfold N.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
(INR (Z.abs_nat (up (/ l) - 2)) + 1)%R =
(IZR (up (/ l)) - 1)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
P N /\ (forall i : nat, i < N -> ~ P i)
  rewrite INR_IZR_INZ.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
(IZR (Z.of_nat (Z.abs_nat (up (/ l) - 2))) + 1)%R =
(IZR (up (/ l)) - 1)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
P N /\ (forall i : nat, i < N -> ~ P i)
  rewrite inj_Zabs_nat.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
(IZR (Z.abs (up (/ l) - 2)) + 1)%R =
(IZR (up (/ l)) - 1)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
P N /\ (forall i : nat, i < N -> ~ P i)
  replace (IZR (up (/ l)) - 1)%R with (IZR (up (/ l) - 2) + 1)%R.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
(IZR (Z.abs (up (/ l) - 2)) + 1)%R =
(IZR (up (/ l) - 2) + 1)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
(IZR (up (/ l) - 2) + 1)%R = (IZR (up (/ l)) - 1)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
P N /\ (forall i : nat, i < N -> ~ P i)
  apply (f_equal (fun v => IZR v + 1)%R).Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
Z.abs (up (/ l) - 2) = (up (/ l) - 2)%Z
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
(IZR (up (/ l) - 2) + 1)%R = (IZR (up (/ l)) - 1)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
P N /\ (forall i : nat, i < N -> ~ P i)
  apply Z.abs_eq.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
(0 <= up (/ l) - 2)%Z
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
(IZR (up (/ l) - 2) + 1)%R = (IZR (up (/ l)) - 1)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
P N /\ (forall i : nat, i < N -> ~ P i)
  apply Zle_minus_le_0.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
(2 <= up (/ l))%Z
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
(IZR (up (/ l) - 2) + 1)%R = (IZR (up (/ l)) - 1)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
P N /\ (forall i : nat, i < N -> ~ P i)
  apply (Zlt_le_succ 1).Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
(1 < up (/ l))%Z
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
(IZR (up (/ l) - 2) + 1)%R = (IZR (up (/ l)) - 1)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
P N /\ (forall i : nat, i < N -> ~ P i)
  apply lt_IZR.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
(1 < IZR (up (/ l)))%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
(IZR (up (/ l) - 2) + 1)%R = (IZR (up (/ l)) - 1)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
P N /\ (forall i : nat, i < N -> ~ P i)
  apply Rle_lt_trans with (/l)%R.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
(1 <= / l)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
(/ l < IZR (up (/ l)))%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
(IZR (up (/ l) - 2) + 1)%R = (IZR (up (/ l)) - 1)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
P N /\ (forall i : nat, i < N -> ~ P i)
  apply Rmult_le_reg_r with (1 := Hl).Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
(1 * l <= / l * l)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
(/ l < IZR (up (/ l)))%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
(IZR (up (/ l) - 2) + 1)%R = (IZR (up (/ l)) - 1)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
P N /\ (forall i : nat, i < N -> ~ P i)
  rewrite Rmult_1_l, Rinv_l by now apply Rgt_not_eq.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
(l <= 1)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
(/ l < IZR (up (/ l)))%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
(IZR (up (/ l) - 2) + 1)%R = (IZR (up (/ l)) - 1)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
P N /\ (forall i : nat, i < N -> ~ P i)
  apply lub.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
is_upper_bound E 1
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
(/ l < IZR (up (/ l)))%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
(IZR (up (/ l) - 2) + 1)%R = (IZR (up (/ l)) - 1)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
P N /\ (forall i : nat, i < N -> ~ P i)
  exact BE.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
(/ l < IZR (up (/ l)))%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
(IZR (up (/ l) - 2) + 1)%R = (IZR (up (/ l)) - 1)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
P N /\ (forall i : nat, i < N -> ~ P i)
  apply archimed.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
(IZR (up (/ l) - 2) + 1)%R = (IZR (up (/ l)) - 1)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
P N /\ (forall i : nat, i < N -> ~ P i)
  rewrite minus_IZR.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
(IZR (up (/ l)) - 2 + 1)%R = (IZR (up (/ l)) - 1)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
P N /\ (forall i : nat, i < N -> ~ P i)
  simpl.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
(IZR (up (/ l)) - 2 + 1)%R = (IZR (up (/ l)) - 1)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
P N /\ (forall i : nat, i < N -> ~ P i)
  ring.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
P N /\ (forall i : nat, i < N -> ~ P i)
assert (H: forall i, (i < N)%nat -> ~ P i).Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
forall i : nat, i < N -> ~ P i
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
P N /\ (forall i : nat, i < N -> ~ P i)
  intros i HiN Pi.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
i:nat
HiN:i < N
Pi:P i
False
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
P N /\ (forall i : nat, i < N -> ~ P i)
  unfold is_upper_bound in ub.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:forall x : R, E x -> (x <= l)%R
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
i:nat
HiN:i < N
Pi:P i
False
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
P N /\ (forall i : nat, i < N -> ~ P i)
  refine (Rle_not_lt _ _ (ub (/ (INR i + 1))%R _) _).Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:forall x : R, E x -> (x <= l)%R
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
i:nat
HiN:i < N
Pi:P i
E (/ (INR i + 1))%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:forall x : R, E x -> (x <= l)%R
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
i:nat
HiN:i < N
Pi:P i
(l < / (INR i + 1))%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
P N /\ (forall i : nat, i < N -> ~ P i)
  now apply HE.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:forall x : R, E x -> (x <= l)%R
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
i:nat
HiN:i < N
Pi:P i
(l < / (INR i + 1))%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
P N /\ (forall i : nat, i < N -> ~ P i)
  rewrite <- (Rinv_involutive l) by now apply Rgt_not_eq.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:forall x : R, E x -> (x <= l)%R
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
i:nat
HiN:i < N
Pi:P i
(/ / l < / (INR i + 1))%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
P N /\ (forall i : nat, i < N -> ~ P i)
  apply Rinv_1_lt_contravar.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:forall x : R, E x -> (x <= l)%R
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
i:nat
HiN:i < N
Pi:P i
(1 <= INR i + 1)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:forall x : R, E x -> (x <= l)%R
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
i:nat
HiN:i < N
Pi:P i
(INR i + 1 < / l)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
P N /\ (forall i : nat, i < N -> ~ P i)
  rewrite <- S_INR.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:forall x : R, E x -> (x <= l)%R
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
i:nat
HiN:i < N
Pi:P i
(1 <= INR (S i))%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:forall x : R, E x -> (x <= l)%R
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
i:nat
HiN:i < N
Pi:P i
(INR i + 1 < / l)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
P N /\ (forall i : nat, i < N -> ~ P i)
  apply (le_INR 1).Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:forall x : R, E x -> (x <= l)%R
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
i:nat
HiN:i < N
Pi:P i
1 <= S i
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:forall x : R, E x -> (x <= l)%R
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
i:nat
HiN:i < N
Pi:P i
(INR i + 1 < / l)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
P N /\ (forall i : nat, i < N -> ~ P i)
  apply le_n_S.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:forall x : R, E x -> (x <= l)%R
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
i:nat
HiN:i < N
Pi:P i
0 <= i
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:forall x : R, E x -> (x <= l)%R
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
i:nat
HiN:i < N
Pi:P i
(INR i + 1 < / l)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
P N /\ (forall i : nat, i < N -> ~ P i)
  apply le_0_n.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:forall x : R, E x -> (x <= l)%R
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
i:nat
HiN:i < N
Pi:P i
(INR i + 1 < / l)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
P N /\ (forall i : nat, i < N -> ~ P i)
  apply Rlt_le_trans with (INR N + 1)%R.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:forall x : R, E x -> (x <= l)%R
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
i:nat
HiN:i < N
Pi:P i
(INR i + 1 < INR N + 1)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:forall x : R, E x -> (x <= l)%R
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
i:nat
HiN:i < N
Pi:P i
(INR N + 1 <= / l)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
P N /\ (forall i : nat, i < N -> ~ P i)
  apply Rplus_lt_compat_r.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:forall x : R, E x -> (x <= l)%R
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
i:nat
HiN:i < N
Pi:P i
(INR i < INR N)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:forall x : R, E x -> (x <= l)%R
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
i:nat
HiN:i < N
Pi:P i
(INR N + 1 <= / l)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
P N /\ (forall i : nat, i < N -> ~ P i)
  now apply lt_INR.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:forall x : R, E x -> (x <= l)%R
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
i:nat
HiN:i < N
Pi:P i
(INR N + 1 <= / l)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
P N /\ (forall i : nat, i < N -> ~ P i)
  rewrite HN.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:forall x : R, E x -> (x <= l)%R
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
i:nat
HiN:i < N
Pi:P i
(IZR (up (/ l)) - 1 <= / l)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
P N /\ (forall i : nat, i < N -> ~ P i)
  apply Rplus_le_reg_r with (-/l + 1)%R.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:forall x : R, E x -> (x <= l)%R
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
i:nat
HiN:i < N
Pi:P i
(IZR (up (/ l)) - 1 + (- / l + 1) <= / l + (- / l + 1))%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
P N /\ (forall i : nat, i < N -> ~ P i)
  ring_simplify.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:forall x : R, E x -> (x <= l)%R
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
i:nat
HiN:i < N
Pi:P i
(IZR (up (/ l)) - / l <= 1)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
P N /\ (forall i : nat, i < N -> ~ P i)
  apply archimed.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
P N /\ (forall i : nat, i < N -> ~ P i)
destruct (HP N) as [PN|PN].Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:P N
P N /\ (forall i : nat, i < N -> ~ P i)
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
P N /\ (forall i : nat, i < N -> ~ P i)
  now split.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
P N /\ (forall i : nat, i < N -> ~ P i)
elimtype False.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
False
refine (Rle_not_lt _ _ (lub (/ (INR (S N) + 1))%R _) _).Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
is_upper_bound E (/ (INR (S N) + 1))
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
(/ (INR (S N) + 1) < l)%R
  intros x [y [[Py ->]|[_ ->]]].Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y0 : R =>
exists n : nat,
  P n /\ y0 = (/ (INR n + 1))%R \/
  ~ P n /\ y0 = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
y:nat
Py:P y
(/ (INR y + 1) <= / (INR (S N) + 1))%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y0 : R =>
exists n : nat,
  P n /\ y0 = (/ (INR n + 1))%R \/
  ~ P n /\ y0 = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
y:nat
(0 <= / (INR (S N) + 1))%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
(/ (INR (S N) + 1) < l)%R
  destruct (eq_nat_dec y N) as [HyN|HyN].Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y0 : R =>
exists n : nat,
  P n /\ y0 = (/ (INR n + 1))%R \/
  ~ P n /\ y0 = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
y:nat
Py:P y
HyN:y = N
(/ (INR y + 1) <= / (INR (S N) + 1))%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y0 : R =>
exists n : nat,
  P n /\ y0 = (/ (INR n + 1))%R \/
  ~ P n /\ y0 = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
y:nat
Py:P y
HyN:y <> N
(/ (INR y + 1) <= / (INR (S N) + 1))%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y0 : R =>
exists n : nat,
  P n /\ y0 = (/ (INR n + 1))%R \/
  ~ P n /\ y0 = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
y:nat
(0 <= / (INR (S N) + 1))%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
(/ (INR (S N) + 1) < l)%R
  elim PN.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y0 : R =>
exists n : nat,
  P n /\ y0 = (/ (INR n + 1))%R \/
  ~ P n /\ y0 = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
y:nat
Py:P y
HyN:y = N
P N
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y0 : R =>
exists n : nat,
  P n /\ y0 = (/ (INR n + 1))%R \/
  ~ P n /\ y0 = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
y:nat
Py:P y
HyN:y <> N
(/ (INR y + 1) <= / (INR (S N) + 1))%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y0 : R =>
exists n : nat,
  P n /\ y0 = (/ (INR n + 1))%R \/
  ~ P n /\ y0 = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
y:nat
(0 <= / (INR (S N) + 1))%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
(/ (INR (S N) + 1) < l)%R
  now rewrite <- HyN.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y0 : R =>
exists n : nat,
  P n /\ y0 = (/ (INR n + 1))%R \/
  ~ P n /\ y0 = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
y:nat
Py:P y
HyN:y <> N
(/ (INR y + 1) <= / (INR (S N) + 1))%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y0 : R =>
exists n : nat,
  P n /\ y0 = (/ (INR n + 1))%R \/
  ~ P n /\ y0 = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
y:nat
(0 <= / (INR (S N) + 1))%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
(/ (INR (S N) + 1) < l)%R
  apply Rinv_le.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y0 : R =>
exists n : nat,
  P n /\ y0 = (/ (INR n + 1))%R \/
  ~ P n /\ y0 = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
y:nat
Py:P y
HyN:y <> N
(0 < INR (S N) + 1)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y0 : R =>
exists n : nat,
  P n /\ y0 = (/ (INR n + 1))%R \/
  ~ P n /\ y0 = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
y:nat
Py:P y
HyN:y <> N
(INR (S N) + 1 <= INR y + 1)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y0 : R =>
exists n : nat,
  P n /\ y0 = (/ (INR n + 1))%R \/
  ~ P n /\ y0 = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
y:nat
(0 <= / (INR (S N) + 1))%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
(/ (INR (S N) + 1) < l)%R
  apply Hi.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y0 : R =>
exists n : nat,
  P n /\ y0 = (/ (INR n + 1))%R \/
  ~ P n /\ y0 = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
y:nat
Py:P y
HyN:y <> N
(INR (S N) + 1 <= INR y + 1)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y0 : R =>
exists n : nat,
  P n /\ y0 = (/ (INR n + 1))%R \/
  ~ P n /\ y0 = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
y:nat
(0 <= / (INR (S N) + 1))%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
(/ (INR (S N) + 1) < l)%R
  apply Rplus_le_compat_r.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y0 : R =>
exists n : nat,
  P n /\ y0 = (/ (INR n + 1))%R \/
  ~ P n /\ y0 = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
y:nat
Py:P y
HyN:y <> N
(INR (S N) <= INR y)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y0 : R =>
exists n : nat,
  P n /\ y0 = (/ (INR n + 1))%R \/
  ~ P n /\ y0 = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
y:nat
(0 <= / (INR (S N) + 1))%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
(/ (INR (S N) + 1) < l)%R
  apply Rnot_lt_le.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y0 : R =>
exists n : nat,
  P n /\ y0 = (/ (INR n + 1))%R \/
  ~ P n /\ y0 = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
y:nat
Py:P y
HyN:y <> N
~ (INR y < INR (S N))%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y0 : R =>
exists n : nat,
  P n /\ y0 = (/ (INR n + 1))%R \/
  ~ P n /\ y0 = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
y:nat
(0 <= / (INR (S N) + 1))%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
(/ (INR (S N) + 1) < l)%R
  intros Hy.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y0 : R =>
exists n : nat,
  P n /\ y0 = (/ (INR n + 1))%R \/
  ~ P n /\ y0 = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
y:nat
Py:P y
HyN:y <> N
Hy:(INR y < INR (S N))%R
False
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y0 : R =>
exists n : nat,
  P n /\ y0 = (/ (INR n + 1))%R \/
  ~ P n /\ y0 = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
y:nat
(0 <= / (INR (S N) + 1))%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
(/ (INR (S N) + 1) < l)%R
  refine (H _ _ Py).Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y0 : R =>
exists n : nat,
  P n /\ y0 = (/ (INR n + 1))%R \/
  ~ P n /\ y0 = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
y:nat
Py:P y
HyN:y <> N
Hy:(INR y < INR (S N))%R
y < N
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y0 : R =>
exists n : nat,
  P n /\ y0 = (/ (INR n + 1))%R \/
  ~ P n /\ y0 = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
y:nat
(0 <= / (INR (S N) + 1))%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
(/ (INR (S N) + 1) < l)%R
  apply INR_lt in Hy.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y0 : R =>
exists n : nat,
  P n /\ y0 = (/ (INR n + 1))%R \/
  ~ P n /\ y0 = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
y:nat
Py:P y
HyN:y <> N
Hy:y < S N
y < N
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y0 : R =>
exists n : nat,
  P n /\ y0 = (/ (INR n + 1))%R \/
  ~ P n /\ y0 = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
y:nat
(0 <= / (INR (S N) + 1))%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
(/ (INR (S N) + 1) < l)%R
  clear -Hy HyN.l:R
N:=Z.abs_nat (up (/ l) - 2):nat
y:nat
HyN:y <> N
Hy:y < S N
y < N
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y0 : R =>
exists n : nat,
  P n /\ y0 = (/ (INR n + 1))%R \/
  ~ P n /\ y0 = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
y:nat
(0 <= / (INR (S N) + 1))%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
(/ (INR (S N) + 1) < l)%R
  omega.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y0 : R =>
exists n : nat,
  P n /\ y0 = (/ (INR n + 1))%R \/
  ~ P n /\ y0 = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
y:nat
(0 <= / (INR (S N) + 1))%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
(/ (INR (S N) + 1) < l)%R
  now apply Rlt_le, Rinv_0_lt_compat.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
(/ (INR (S N) + 1) < l)%R
rewrite S_INR, HN.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
(/ (IZR (up (/ l)) - 1 + 1) < l)%R
ring_simplify (IZR (up (/ l)) - 1 + 1)%R.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
(/ IZR (up (/ l)) < l)%R
rewrite <- (Rinv_involutive l) at 2 by now apply Rgt_not_eq.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
(/ IZR (up (/ l)) < / / l)%R
apply Rinv_1_lt_contravar.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
(1 <= / l)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
(/ l < IZR (up (/ l)))%R
rewrite <- Rinv_1.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
(/ 1 <= / l)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
(/ l < IZR (up (/ l)))%R
apply Rinv_le.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
(0 < l)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
(l <= 1)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
(/ l < IZR (up (/ l)))%R
exact Hl.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
(l <= 1)%R
Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
(/ l < IZR (up (/ l)))%R
now apply lub.Hi:forall n : nat, (0 < INR n + 1)%R
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
E:=fun y : R =>
exists n : nat,
  P n /\ y = (/ (INR n + 1))%R \/ ~ P n /\ y = 0%R:R -> Prop
HE:forall n : nat, P n -> E (/ (INR n + 1))%R
BE:is_upper_bound E 1
l:R
ub:is_upper_bound E l
lub:forall b : R, is_upper_bound E b -> (l <= b)%R
Hl:(0 < l)%R
N:=Z.abs_nat (up (/ l) - 2):nat
HN:(INR N + 1)%R = (IZR (up (/ l)) - 1)%R
H:forall i : nat, i < N -> ~ P i
PN:~ P N
(/ l < IZR (up (/ l)))%R
apply archimed.
Qed.

Theorem LPO :
  forall P : nat -> Prop, (forall n, P n \/ ~ P n) ->
  {n : nat | P n} + {forall n, ~ P n}.forall P : nat -> Prop,
(forall n : nat, P n \/ ~ P n) ->
{n : nat | P n} + {forall n : nat, ~ P n}
Proof.forall P : nat -> Prop,
(forall n : nat, P n \/ ~ P n) ->
{n : nat | P n} + {forall n : nat, ~ P n}
intros P HP.P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
{n : nat | P n} + {forall n : nat, ~ P n}
destruct (LPO_min P HP) as [[n [Pn _]]|Pn].P:nat -> Prop
HP:forall n0 : nat, P n0 \/ ~ P n0
n:nat
Pn:P n
{n0 : nat | P n0} + {forall n0 : nat, ~ P n0}
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
Pn:forall n : nat, ~ P n
{n : nat | P n} + {forall n : nat, ~ P n}
left.P:nat -> Prop
HP:forall n0 : nat, P n0 \/ ~ P n0
n:nat
Pn:P n
{n0 : nat | P n0}
P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
Pn:forall n : nat, ~ P n
{n : nat | P n} + {forall n : nat, ~ P n}
now exists n.P:nat -> Prop
HP:forall n : nat, P n \/ ~ P n
Pn:forall n : nat, ~ P n
{n : nat | P n} + {forall n : nat, ~ P n}
now right.
Qed.


Lemma LPO_Z : forall P : Z -> Prop, (forall n, P n \/ ~P n) ->
  {n : Z| P n} + {forall n, ~ P n}.forall P : Z -> Prop,
(forall n : Z, P n \/ ~ P n) ->
{n : Z | P n} + {forall n : Z, ~ P n}
Proof.forall P : Z -> Prop,
(forall n : Z, P n \/ ~ P n) ->
{n : Z | P n} + {forall n : Z, ~ P n}
intros P H.P:Z -> Prop
H:forall n : Z, P n \/ ~ P n
{n : Z | P n} + {forall n : Z, ~ P n}
destruct (LPO (fun n => P (Z.of_nat n))) as [J|J].P:Z -> Prop
H:forall n : Z, P n \/ ~ P n
forall n : nat, P (Z.of_nat n) \/ ~ P (Z.of_nat n)
P:Z -> Prop
H:forall n : Z, P n \/ ~ P n
J:{n : nat | P (Z.of_nat n)}
{n : Z | P n} + {forall n : Z, ~ P n}
P:Z -> Prop
H:forall n : Z, P n \/ ~ P n
J:forall n : nat, ~ P (Z.of_nat n)
{n : Z | P n} + {forall n : Z, ~ P n}
intros n; apply H.P:Z -> Prop
H:forall n : Z, P n \/ ~ P n
J:{n : nat | P (Z.of_nat n)}
{n : Z | P n} + {forall n : Z, ~ P n}
P:Z -> Prop
H:forall n : Z, P n \/ ~ P n
J:forall n : nat, ~ P (Z.of_nat n)
{n : Z | P n} + {forall n : Z, ~ P n}
destruct J as (n, Hn).P:Z -> Prop
H:forall n0 : Z, P n0 \/ ~ P n0
n:nat
Hn:P (Z.of_nat n)
{n0 : Z | P n0} + {forall n0 : Z, ~ P n0}
P:Z -> Prop
H:forall n : Z, P n \/ ~ P n
J:forall n : nat, ~ P (Z.of_nat n)
{n : Z | P n} + {forall n : Z, ~ P n}
left; now exists (Z.of_nat n).P:Z -> Prop
H:forall n : Z, P n \/ ~ P n
J:forall n : nat, ~ P (Z.of_nat n)
{n : Z | P n} + {forall n : Z, ~ P n}
destruct (LPO (fun n => P (-Z.of_nat n)%Z)) as [K|K].P:Z -> Prop
H:forall n : Z, P n \/ ~ P n
J:forall n : nat, ~ P (Z.of_nat n)
forall n : nat,
P (- Z.of_nat n)%Z \/ ~ P (- Z.of_nat n)%Z
P:Z -> Prop
H:forall n : Z, P n \/ ~ P n
J:forall n : nat, ~ P (Z.of_nat n)
K:{n : nat | P (- Z.of_nat n)%Z}
{n : Z | P n} + {forall n : Z, ~ P n}
P:Z -> Prop
H:forall n : Z, P n \/ ~ P n
J:forall n : nat, ~ P (Z.of_nat n)
K:forall n : nat, ~ P (- Z.of_nat n)%Z
{n : Z | P n} + {forall n : Z, ~ P n}
intros n; apply H.P:Z -> Prop
H:forall n : Z, P n \/ ~ P n
J:forall n : nat, ~ P (Z.of_nat n)
K:{n : nat | P (- Z.of_nat n)%Z}
{n : Z | P n} + {forall n : Z, ~ P n}
P:Z -> Prop
H:forall n : Z, P n \/ ~ P n
J:forall n : nat, ~ P (Z.of_nat n)
K:forall n : nat, ~ P (- Z.of_nat n)%Z
{n : Z | P n} + {forall n : Z, ~ P n}
destruct K as (n, Hn).P:Z -> Prop
H:forall n0 : Z, P n0 \/ ~ P n0
J:forall n0 : nat, ~ P (Z.of_nat n0)
n:nat
Hn:P (- Z.of_nat n)%Z
{n0 : Z | P n0} + {forall n0 : Z, ~ P n0}
P:Z -> Prop
H:forall n : Z, P n \/ ~ P n
J:forall n : nat, ~ P (Z.of_nat n)
K:forall n : nat, ~ P (- Z.of_nat n)%Z
{n : Z | P n} + {forall n : Z, ~ P n}
left; now exists (-Z.of_nat n)%Z.P:Z -> Prop
H:forall n : Z, P n \/ ~ P n
J:forall n : nat, ~ P (Z.of_nat n)
K:forall n : nat, ~ P (- Z.of_nat n)%Z
{n : Z | P n} + {forall n : Z, ~ P n}
right; intros n; case (Zle_or_lt 0 n); intros M.P:Z -> Prop
H:forall n0 : Z, P n0 \/ ~ P n0
J:forall n0 : nat, ~ P (Z.of_nat n0)
K:forall n0 : nat, ~ P (- Z.of_nat n0)%Z
n:Z
M:(0 <= n)%Z
~ P n
P:Z -> Prop
H:forall n0 : Z, P n0 \/ ~ P n0
J:forall n0 : nat, ~ P (Z.of_nat n0)
K:forall n0 : nat, ~ P (- Z.of_nat n0)%Z
n:Z
M:(n < 0)%Z
~ P n
rewrite <- (Z.abs_eq n); trivial.P:Z -> Prop
H:forall n0 : Z, P n0 \/ ~ P n0
J:forall n0 : nat, ~ P (Z.of_nat n0)
K:forall n0 : nat, ~ P (- Z.of_nat n0)%Z
n:Z
M:(0 <= n)%Z
~ P (Z.abs n)
P:Z -> Prop
H:forall n0 : Z, P n0 \/ ~ P n0
J:forall n0 : nat, ~ P (Z.of_nat n0)
K:forall n0 : nat, ~ P (- Z.of_nat n0)%Z
n:Z
M:(n < 0)%Z
~ P n
rewrite <- Zabs2Nat.id_abs.P:Z -> Prop
H:forall n0 : Z, P n0 \/ ~ P n0
J:forall n0 : nat, ~ P (Z.of_nat n0)
K:forall n0 : nat, ~ P (- Z.of_nat n0)%Z
n:Z
M:(0 <= n)%Z
~ P (Z.of_nat (Z.abs_nat n))
P:Z -> Prop
H:forall n0 : Z, P n0 \/ ~ P n0
J:forall n0 : nat, ~ P (Z.of_nat n0)
K:forall n0 : nat, ~ P (- Z.of_nat n0)%Z
n:Z
M:(n < 0)%Z
~ P n
apply J.P:Z -> Prop
H:forall n0 : Z, P n0 \/ ~ P n0
J:forall n0 : nat, ~ P (Z.of_nat n0)
K:forall n0 : nat, ~ P (- Z.of_nat n0)%Z
n:Z
M:(n < 0)%Z
~ P n
rewrite <- (Z.opp_involutive n).P:Z -> Prop
H:forall n0 : Z, P n0 \/ ~ P n0
J:forall n0 : nat, ~ P (Z.of_nat n0)
K:forall n0 : nat, ~ P (- Z.of_nat n0)%Z
n:Z
M:(n < 0)%Z
~ P (- - n)%Z
rewrite <- (Z.abs_neq n).P:Z -> Prop
H:forall n0 : Z, P n0 \/ ~ P n0
J:forall n0 : nat, ~ P (Z.of_nat n0)
K:forall n0 : nat, ~ P (- Z.of_nat n0)%Z
n:Z
M:(n < 0)%Z
~ P (- Z.abs n)%Z
P:Z -> Prop
H:forall n0 : Z, P n0 \/ ~ P n0
J:forall n0 : nat, ~ P (Z.of_nat n0)
K:forall n0 : nat, ~ P (- Z.of_nat n0)%Z
n:Z
M:(n < 0)%Z
(n <= 0)%Z
rewrite <- Zabs2Nat.id_abs.P:Z -> Prop
H:forall n0 : Z, P n0 \/ ~ P n0
J:forall n0 : nat, ~ P (Z.of_nat n0)
K:forall n0 : nat, ~ P (- Z.of_nat n0)%Z
n:Z
M:(n < 0)%Z
~ P (- Z.of_nat (Z.abs_nat n))%Z
P:Z -> Prop
H:forall n0 : Z, P n0 \/ ~ P n0
J:forall n0 : nat, ~ P (Z.of_nat n0)
K:forall n0 : nat, ~ P (- Z.of_nat n0)%Z
n:Z
M:(n < 0)%Z
(n <= 0)%Z
apply K.P:Z -> Prop
H:forall n0 : Z, P n0 \/ ~ P n0
J:forall n0 : nat, ~ P (Z.of_nat n0)
K:forall n0 : nat, ~ P (- Z.of_nat n0)%Z
n:Z
M:(n < 0)%Z
(n <= 0)%Z
omega.
Qed.

A little tactic to simplify terms of the form bpow a × bpow b.

Ltac bpow_simplify :=
  (* bpow ex * bpow ey ~~> bpow (ex + ey) *)
  repeat
    match goal with
      | |- context [(bpow _ _ * bpow _ _)] =>
        rewrite <- bpow_plus
      | |- context [(?X1 * bpow _ _ * bpow _ _)] =>
        rewrite (Rmult_assoc X1); rewrite <- bpow_plus
      | |- context [(?X1 * (?X2 * bpow _ _) * bpow _ _)] =>
        rewrite <- (Rmult_assoc X1 X2); rewrite (Rmult_assoc (X1 * X2));
        rewrite <- bpow_plus
    end;
  (* ring_simplify arguments of bpow *)
  repeat
    match goal with
      | |- context [(bpow _ ?X)] =>
        progress ring_simplify X
    end;
  (* bpow 0 ~~> 1 *)
  change (bpow _ 0) with 1;
  repeat
    match goal with
      | |- context [(_ * 1)] =>
        rewrite Rmult_1_r
    end.