(************************************************************************)
(*         *   The Coq Proof Assistant / The Coq Development Team       *)
(*  v      *   INRIA, CNRS and contributors - Copyright 1999-2018       *)
(* <O___,, *       (see CREDITS file for the list of authors)           *)
(*   \VV/  **************************************************************)
(*    //   *    This file is distributed under the terms of the         *)
(*         *     GNU Lesser General Public License Version 2.1          *)
(*         *     (see LICENSE file for the text of the license)         *)
(************************************************************************)


Require Import Coq.Reals.Rdefinitions.
Require Import Coq.Reals.Raxioms.
Require Import Rfunctions.
Require Import Coq.Reals.RIneq.
Require Import Coq.Logic.FinFun.
Require Import Coq.Logic.ConstructiveEpsilon.


Definition enumeration (A : Type) (u : nat -> A) (v : A -> nat) : Prop :=
  (forall x : A, u (v x) = x) /\ (forall n : nat, v (u n) = n).

Definition in_holed_interval (a b hole : R) (u : nat -> R) (n : nat) : Prop :=
  Rlt a (u n) /\ Rlt (u n) b /\ u n <> hole.

(* Here we use axiom total_order_T, which is not constructive *)
Lemma in_holed_interval_dec (a b h : R) (u : nat -> R) (n : nat)
  : {in_holed_interval a b h u n} + {~in_holed_interval a b h u n}.
a, b, h:R
u:nat -> R
n:nat
{in_holed_interval a b h u n} +
{~ in_holed_interval a b h u n}
Proof.
a, b, h:R
u:nat -> R
n:nat
{in_holed_interval a b h u n} +
{~ in_holed_interval a b h u n}
  destruct (total_order_T a (u n)) as [[l|e]|hi].
a, b, h:R
u:nat -> R
n:nat
l:(a < u n)%R
{in_holed_interval a b h u n} +
{~ in_holed_interval a b h u n}
a, b, h:R
u:nat -> R
n:nat
e:a = u n
{in_holed_interval a b h u n} +
{~ in_holed_interval a b h u n}
a, b, h:R
u:nat -> R
n:nat
hi:(a > u n)%R
{in_holed_interval a b h u n} +
{~ in_holed_interval a b h u n}
  -
a, b, h:R
u:nat -> R
n:nat
l:(a < u n)%R
{in_holed_interval a b h u n} +
{~ in_holed_interval a b h u n} destruct (total_order_T b (u n)) as [[lb|eb]|hb].
a, b, h:R
u:nat -> R
n:nat
l:(a < u n)%R
lb:(b < u n)%R
{in_holed_interval a b h u n} +
{~ in_holed_interval a b h u n}
a, b, h:R
u:nat -> R
n:nat
l:(a < u n)%R
eb:b = u n
{in_holed_interval a b h u n} +
{~ in_holed_interval a b h u n}
a, b, h:R
u:nat -> R
n:nat
l:(a < u n)%R
hb:(b > u n)%R
{in_holed_interval a b h u n} +
{~ in_holed_interval a b h u n}
    +
a, b, h:R
u:nat -> R
n:nat
l:(a < u n)%R
lb:(b < u n)%R
{in_holed_interval a b h u n} +
{~ in_holed_interval a b h u n} right.
a, b, h:R
u:nat -> R
n:nat
l:(a < u n)%R
lb:(b < u n)%R
~ in_holed_interval a b h u n intro H.
a, b, h:R
u:nat -> R
n:nat
l:(a < u n)%R
lb:(b < u n)%R
H:in_holed_interval a b h u n
False destruct H.
a, b, h:R
u:nat -> R
n:nat
l:(a < u n)%R
lb:(b < u n)%R
H:(a < u n)%R
H0:(u n < b)%R /\ u n <> h
False destruct H0.
a, b, h:R
u:nat -> R
n:nat
l:(a < u n)%R
lb:(b < u n)%R
H:(a < u n)%R
H0:(u n < b)%R
H1:u n <> h
False apply Rlt_asym in H0.
a, b, h:R
u:nat -> R
n:nat
l:(a < u n)%R
lb:(b < u n)%R
H:(a < u n)%R
H0:~ (b < u n)%R
H1:u n <> h
False contradiction.
    +
a, b, h:R
u:nat -> R
n:nat
l:(a < u n)%R
eb:b = u n
{in_holed_interval a b h u n} +
{~ in_holed_interval a b h u n} subst.
a, h:R
u:nat -> R
n:nat
l:(a < u n)%R
{in_holed_interval a (u n) h u n} +
{~ in_holed_interval a (u n) h u n} right.
a, h:R
u:nat -> R
n:nat
l:(a < u n)%R
~ in_holed_interval a (u n) h u n intro H.
a, h:R
u:nat -> R
n:nat
l:(a < u n)%R
H:in_holed_interval a (u n) h u n
False destruct H.
a, h:R
u:nat -> R
n:nat
l, H:(a < u n)%R
H0:(u n < u n)%R /\ u n <> h
False destruct H0.
a, h:R
u:nat -> R
n:nat
l, H:(a < u n)%R
H0:(u n < u n)%R
H1:u n <> h
False
      pose proof (Rlt_asym (u n) (u n) H0).
a, h:R
u:nat -> R
n:nat
l, H:(a < u n)%R
H0:(u n < u n)%R
H1:u n <> h
H2:~ (u n < u n)%R
False contradiction.
    +
a, b, h:R
u:nat -> R
n:nat
l:(a < u n)%R
hb:(b > u n)%R
{in_holed_interval a b h u n} +
{~ in_holed_interval a b h u n} destruct (Req_EM_T h (u n)).
a, b, h:R
u:nat -> R
n:nat
l:(a < u n)%R
hb:(b > u n)%R
e:h = u n
{in_holed_interval a b h u n} +
{~ in_holed_interval a b h u n}
a, b, h:R
u:nat -> R
n:nat
l:(a < u n)%R
hb:(b > u n)%R
n0:h <> u n
{in_holed_interval a b h u n} +
{~ in_holed_interval a b h u n} subst.
a, b:R
u:nat -> R
n:nat
l:(a < u n)%R
hb:(b > u n)%R
{in_holed_interval a b (u n) u n} +
{~ in_holed_interval a b (u n) u n}
a, b, h:R
u:nat -> R
n:nat
l:(a < u n)%R
hb:(b > u n)%R
n0:h <> u n
{in_holed_interval a b h u n} +
{~ in_holed_interval a b h u n} right.
a, b:R
u:nat -> R
n:nat
l:(a < u n)%R
hb:(b > u n)%R
~ in_holed_interval a b (u n) u n
a, b, h:R
u:nat -> R
n:nat
l:(a < u n)%R
hb:(b > u n)%R
n0:h <> u n
{in_holed_interval a b h u n} +
{~ in_holed_interval a b h u n} intro H.
a, b:R
u:nat -> R
n:nat
l:(a < u n)%R
hb:(b > u n)%R
H:in_holed_interval a b (u n) u n
False
a, b, h:R
u:nat -> R
n:nat
l:(a < u n)%R
hb:(b > u n)%R
n0:h <> u n
{in_holed_interval a b h u n} +
{~ in_holed_interval a b h u n} destruct H.
a, b:R
u:nat -> R
n:nat
l:(a < u n)%R
hb:(b > u n)%R
H:(a < u n)%R
H0:(u n < b)%R /\ u n <> u n
False
a, b, h:R
u:nat -> R
n:nat
l:(a < u n)%R
hb:(b > u n)%R
n0:h <> u n
{in_holed_interval a b h u n} +
{~ in_holed_interval a b h u n} destruct H0.
a, b:R
u:nat -> R
n:nat
l:(a < u n)%R
hb:(b > u n)%R
H:(a < u n)%R
H0:(u n < b)%R
H1:u n <> u n
False
a, b, h:R
u:nat -> R
n:nat
l:(a < u n)%R
hb:(b > u n)%R
n0:h <> u n
{in_holed_interval a b h u n} +
{~ in_holed_interval a b h u n}
      exact (H1 eq_refl).
a, b, h:R
u:nat -> R
n:nat
l:(a < u n)%R
hb:(b > u n)%R
n0:h <> u n
{in_holed_interval a b h u n} +
{~ in_holed_interval a b h u n} left.
a, b, h:R
u:nat -> R
n:nat
l:(a < u n)%R
hb:(b > u n)%R
n0:h <> u n
in_holed_interval a b h u n split.
a, b, h:R
u:nat -> R
n:nat
l:(a < u n)%R
hb:(b > u n)%R
n0:h <> u n
(a < u n)%R
a, b, h:R
u:nat -> R
n:nat
l:(a < u n)%R
hb:(b > u n)%R
n0:h <> u n
(u n < b)%R /\ u n <> h assumption.
a, b, h:R
u:nat -> R
n:nat
l:(a < u n)%R
hb:(b > u n)%R
n0:h <> u n
(u n < b)%R /\ u n <> h split.
a, b, h:R
u:nat -> R
n:nat
l:(a < u n)%R
hb:(b > u n)%R
n0:h <> u n
(u n < b)%R
a, b, h:R
u:nat -> R
n:nat
l:(a < u n)%R
hb:(b > u n)%R
n0:h <> u n
u n <> h assumption.
a, b, h:R
u:nat -> R
n:nat
l:(a < u n)%R
hb:(b > u n)%R
n0:h <> u n
u n <> h intro H.
a, b, h:R
u:nat -> R
n:nat
l:(a < u n)%R
hb:(b > u n)%R
n0:h <> u n
H:u n = h
False subst.
a, b:R
u:nat -> R
n:nat
l:(a < u n)%R
hb:(b > u n)%R
n0:u n <> u n
False
      exact (n0 eq_refl).
  -
a, b, h:R
u:nat -> R
n:nat
e:a = u n
{in_holed_interval a b h u n} +
{~ in_holed_interval a b h u n} subst.
b, h:R
u:nat -> R
n:nat
{in_holed_interval (u n) b h u n} +
{~ in_holed_interval (u n) b h u n} right.
b, h:R
u:nat -> R
n:nat
~ in_holed_interval (u n) b h u n intro H.
b, h:R
u:nat -> R
n:nat
H:in_holed_interval (u n) b h u n
False destruct H.
b, h:R
u:nat -> R
n:nat
H:(u n < u n)%R
H0:(u n < b)%R /\ u n <> h
False pose proof (Rlt_asym (u n) (u n) H).
b, h:R
u:nat -> R
n:nat
H:(u n < u n)%R
H0:(u n < b)%R /\ u n <> h
H1:~ (u n < u n)%R
False contradiction.
  -
a, b, h:R
u:nat -> R
n:nat
hi:(a > u n)%R
{in_holed_interval a b h u n} +
{~ in_holed_interval a b h u n} right.
a, b, h:R
u:nat -> R
n:nat
hi:(a > u n)%R
~ in_holed_interval a b h u n intro H.
a, b, h:R
u:nat -> R
n:nat
hi:(a > u n)%R
H:in_holed_interval a b h u n
False destruct H.
a, b, h:R
u:nat -> R
n:nat
hi:(a > u n)%R
H:(a < u n)%R
H0:(u n < b)%R /\ u n <> h
False apply Rlt_asym in H.
a, b, h:R
u:nat -> R
n:nat
hi:(a > u n)%R
H:~ (u n < a)%R
H0:(u n < b)%R /\ u n <> h
False contradiction.
Qed.

Definition point_in_holed_interval (a b h : R) : R :=
  if Req_EM_T h (Rdiv (Rplus a b) (INR 2)) then (Rdiv (Rplus a h) (INR 2))
  else (Rdiv (Rplus a b) (INR 2)).

Lemma middle_in_interval : forall a b : R, Rlt a b -> (a < (a + b) / INR 2 < b)%R.
forall a b : R,
(a < b)%R -> (a < (a + b) / INR 2 < b)%R
Proof.
forall a b : R,
(a < b)%R -> (a < (a + b) / INR 2 < b)%R
  intros.
a, b:R
H:(a < b)%R
(a < (a + b) / INR 2 < b)%R
  assert (twoNotZero: INR 2 <> 0%R).
a, b:R
H:(a < b)%R
INR 2 <> 0%R
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
(a < (a + b) / INR 2 < b)%R
  {
a, b:R
H:(a < b)%R
INR 2 <> 0%R apply not_0_INR.
a, b:R
H:(a < b)%R
2 <> 0 intro abs.
a, b:R
H:(a < b)%R
abs:2 = 0
False inversion abs. }
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
(a < (a + b) / INR 2 < b)%R
  assert (twoAboveZero : (0 < / INR 2)%R).
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
(0 < / INR 2)%R
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
(a < (a + b) / INR 2 < b)%R
  {
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
(0 < / INR 2)%R apply Rinv_0_lt_compat.
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
(0 < INR 2)%R apply lt_0_INR.
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
0 < 2 apply le_n_S.
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
0 <= 1 apply le_S.
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
0 <= 0 apply le_n. }
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
(a < (a + b) / INR 2 < b)%R
  assert (double : forall x : R, Rplus x x = ((INR 2) * x)%R).
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
forall x : R, (x + x)%R = (INR 2 * x)%R
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
(a < (a + b) / INR 2 < b)%R
  {
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
forall x : R, (x + x)%R = (INR 2 * x)%R intro x.
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
x:R
(x + x)%R = (INR 2 * x)%R rewrite -> S_O_plus_INR.
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
x:R
(x + x)%R = ((INR 1 + INR 1) * x)%R rewrite -> Rmult_plus_distr_r.
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
x:R
(x + x)%R = (INR 1 * x + INR 1 * x)%R
    rewrite -> Rmult_1_l.
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
x:R
(x + x)%R = (x + x)%R reflexivity. }
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
(a < (a + b) / INR 2 < b)%R
  split.
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
(a < (a + b) / INR 2)%R
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
((a + b) / INR 2 < b)%R
  -
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
(a < (a + b) / INR 2)%R assert (a + a < a + b)%R.
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
(a + a < a + b)%R
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
H0:(a + a < a + b)%R
(a < (a + b) / INR 2)%R {
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
(a + a < a + b)%R apply (Rplus_lt_compat_l a a b).
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
(a < b)%R assumption. }
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
H0:(a + a < a + b)%R
(a < (a + b) / INR 2)%R
    rewrite -> double in H0.
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
H0:(INR 2 * a < a + b)%R
(a < (a + b) / INR 2)%R apply (Rmult_lt_compat_l (/ (INR 2))) in H0.
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
H0:(/ INR 2 * (INR 2 * a) < / INR 2 * (a + b))%R
(a < (a + b) / INR 2)%R
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
H0:(INR 2 * a < a + b)%R
(0 < / INR 2)%R
    rewrite <- Rmult_assoc in H0.
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
H0:(/ INR 2 * INR 2 * a < / INR 2 * (a + b))%R
(a < (a + b) / INR 2)%R
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
H0:(INR 2 * a < a + b)%R
(0 < / INR 2)%R rewrite -> Rinv_l in H0.
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
H0:(1 * a < / INR 2 * (a + b))%R
(a < (a + b) / INR 2)%R
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
H0:(/ INR 2 * INR 2 * a < / INR 2 * (a + b))%R
INR 2 <> 0%R
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
H0:(INR 2 * a < a + b)%R
(0 < / INR 2)%R simpl in H0.
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
H0:(1 * a < / (1 + 1) * (a + b))%R
(a < (a + b) / INR 2)%R
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
H0:(/ INR 2 * INR 2 * a < / INR 2 * (a + b))%R
INR 2 <> 0%R
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
H0:(INR 2 * a < a + b)%R
(0 < / INR 2)%R
    rewrite -> Rmult_1_l in H0.
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
H0:(a < / (1 + 1) * (a + b))%R
(a < (a + b) / INR 2)%R
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
H0:(/ INR 2 * INR 2 * a < / INR 2 * (a + b))%R
INR 2 <> 0%R
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
H0:(INR 2 * a < a + b)%R
(0 < / INR 2)%R rewrite -> Rmult_comm in H0.
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
H0:(a < (a + b) * / (1 + 1))%R
(a < (a + b) / INR 2)%R
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
H0:(/ INR 2 * INR 2 * a < / INR 2 * (a + b))%R
INR 2 <> 0%R
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
H0:(INR 2 * a < a + b)%R
(0 < / INR 2)%R assumption.
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
H0:(/ INR 2 * INR 2 * a < / INR 2 * (a + b))%R
INR 2 <> 0%R
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
H0:(INR 2 * a < a + b)%R
(0 < / INR 2)%R
    assumption.
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
H0:(INR 2 * a < a + b)%R
(0 < / INR 2)%R assumption.
  -
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
((a + b) / INR 2 < b)%R assert (b + a < b + b)%R.
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
(b + a < b + b)%R
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
H0:(b + a < b + b)%R
((a + b) / INR 2 < b)%R {
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
(b + a < b + b)%R apply (Rplus_lt_compat_l b a b).
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
(a < b)%R assumption. }
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
H0:(b + a < b + b)%R
((a + b) / INR 2 < b)%R
    rewrite -> Rplus_comm in H0.
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
H0:(a + b < b + b)%R
((a + b) / INR 2 < b)%R rewrite -> double in H0.
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
H0:(a + b < INR 2 * b)%R
((a + b) / INR 2 < b)%R
    apply (Rmult_lt_compat_l (/ (INR 2))) in H0.
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
H0:(/ INR 2 * (a + b) < / INR 2 * (INR 2 * b))%R
((a + b) / INR 2 < b)%R
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
H0:(a + b < INR 2 * b)%R
(0 < / INR 2)%R
    rewrite <- Rmult_assoc in H0.
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
H0:(/ INR 2 * (a + b) < / INR 2 * INR 2 * b)%R
((a + b) / INR 2 < b)%R
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
H0:(a + b < INR 2 * b)%R
(0 < / INR 2)%R rewrite -> Rinv_l in H0.
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
H0:(/ INR 2 * (a + b) < 1 * b)%R
((a + b) / INR 2 < b)%R
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
H0:(/ INR 2 * (a + b) < / INR 2 * INR 2 * b)%R
INR 2 <> 0%R
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
H0:(a + b < INR 2 * b)%R
(0 < / INR 2)%R simpl in H0.
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
H0:(/ (1 + 1) * (a + b) < 1 * b)%R
((a + b) / INR 2 < b)%R
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
H0:(/ INR 2 * (a + b) < / INR 2 * INR 2 * b)%R
INR 2 <> 0%R
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
H0:(a + b < INR 2 * b)%R
(0 < / INR 2)%R
    rewrite -> Rmult_1_l in H0.
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
H0:(/ (1 + 1) * (a + b) < b)%R
((a + b) / INR 2 < b)%R
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
H0:(/ INR 2 * (a + b) < / INR 2 * INR 2 * b)%R
INR 2 <> 0%R
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
H0:(a + b < INR 2 * b)%R
(0 < / INR 2)%R rewrite -> Rmult_comm in H0.
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
H0:((a + b) * / (1 + 1) < b)%R
((a + b) / INR 2 < b)%R
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
H0:(/ INR 2 * (a + b) < / INR 2 * INR 2 * b)%R
INR 2 <> 0%R
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
H0:(a + b < INR 2 * b)%R
(0 < / INR 2)%R assumption.
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
H0:(/ INR 2 * (a + b) < / INR 2 * INR 2 * b)%R
INR 2 <> 0%R
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
H0:(a + b < INR 2 * b)%R
(0 < / INR 2)%R
    assumption.
a, b:R
H:(a < b)%R
twoNotZero:INR 2 <> 0%R
twoAboveZero:(0 < / INR 2)%R
double:forall x : R, (x + x)%R = (INR 2 * x)%R
H0:(a + b < INR 2 * b)%R
(0 < / INR 2)%R assumption.
Qed.

Lemma point_in_holed_interval_works (a b h : R) :
  Rlt a b -> let p := point_in_holed_interval a b h in
             Rlt a p /\ Rlt p b /\ p <> h.
a, b, h:R
(a < b)%R ->
let p := point_in_holed_interval a b h in
(a < p)%R /\ (p < b)%R /\ p <> h
Proof.
a, b, h:R
(a < b)%R ->
let p := point_in_holed_interval a b h in
(a < p)%R /\ (p < b)%R /\ p <> h
  intros.
a, b, h:R
H:(a < b)%R
p:=point_in_holed_interval a b h:R
(a < p)%R /\ (p < b)%R /\ p <> h unfold point_in_holed_interval in p.
a, b, h:R
H:(a < b)%R
p:=if Req_EM_T h ((a + b) / INR 2)
then ((a + h) / INR 2)%R
else ((a + b) / INR 2)%R:R
(a < p)%R /\ (p < b)%R /\ p <> h
  pose proof (middle_in_interval a b H).
a, b, h:R
H:(a < b)%R
p:=if Req_EM_T h ((a + b) / INR 2)
then ((a + h) / INR 2)%R
else ((a + b) / INR 2)%R:R
H0:(a < (a + b) / INR 2 < b)%R
(a < p)%R /\ (p < b)%R /\ p <> h destruct H0.
a, b, h:R
H:(a < b)%R
p:=if Req_EM_T h ((a + b) / INR 2)
then ((a + h) / INR 2)%R
else ((a + b) / INR 2)%R:R
H0:(a < (a + b) / INR 2)%R
H1:((a + b) / INR 2 < b)%R
(a < p)%R /\ (p < b)%R /\ p <> h
  destruct (Req_EM_T h ((a + b) / INR 2)).
a, b, h:R
H:(a < b)%R
e:h = ((a + b) / INR 2)%R
p:=((a + h) / INR 2)%R:R
H0:(a < (a + b) / INR 2)%R
H1:((a + b) / INR 2 < b)%R
(a < p)%R /\ (p < b)%R /\ p <> h
a, b, h:R
H:(a < b)%R
n:h <> ((a + b) / INR 2)%R
p:=((a + b) / INR 2)%R:R
H0:(a < (a + b) / INR 2)%R
H1:((a + b) / INR 2 < b)%R
(a < p)%R /\ (p < b)%R /\ p <> h
  - (* middle hole, p is quarter *)
a, b, h:R
H:(a < b)%R
e:h = ((a + b) / INR 2)%R
p:=((a + h) / INR 2)%R:R
H0:(a < (a + b) / INR 2)%R
H1:((a + b) / INR 2 < b)%R
(a < p)%R /\ (p < b)%R /\ p <> h subst.
a, b:R
H:(a < b)%R
p:=((a + (a + b) / INR 2) / INR 2)%R:R
H0:(a < (a + b) / INR 2)%R
H1:((a + b) / INR 2 < b)%R
(a < p)%R /\ (p < b)%R /\ p <> ((a + b) / INR 2)%R
    pose proof (middle_in_interval a ((a + b) / INR 2) H0).
a, b:R
H:(a < b)%R
p:=((a + (a + b) / INR 2) / INR 2)%R:R
H0:(a < (a + b) / INR 2)%R
H1:((a + b) / INR 2 < b)%R
H2:(a < (a + (a + b) / INR 2) / INR 2 <
 (a + b) / INR 2)%R
(a < p)%R /\ (p < b)%R /\ p <> ((a + b) / INR 2)%R destruct H2.
a, b:R
H:(a < b)%R
p:=((a + (a + b) / INR 2) / INR 2)%R:R
H0:(a < (a + b) / INR 2)%R
H1:((a + b) / INR 2 < b)%R
H2:(a < (a + (a + b) / INR 2) / INR 2)%R
H3:((a + (a + b) / INR 2) / INR 2 < (a + b) / INR 2)%R
(a < p)%R /\ (p < b)%R /\ p <> ((a + b) / INR 2)%R
    split.
a, b:R
H:(a < b)%R
p:=((a + (a + b) / INR 2) / INR 2)%R:R
H0:(a < (a + b) / INR 2)%R
H1:((a + b) / INR 2 < b)%R
H2:(a < (a + (a + b) / INR 2) / INR 2)%R
H3:((a + (a + b) / INR 2) / INR 2 < (a + b) / INR 2)%R
(a < p)%R
a, b:R
H:(a < b)%R
p:=((a + (a + b) / INR 2) / INR 2)%R:R
H0:(a < (a + b) / INR 2)%R
H1:((a + b) / INR 2 < b)%R
H2:(a < (a + (a + b) / INR 2) / INR 2)%R
H3:((a + (a + b) / INR 2) / INR 2 < (a + b) / INR 2)%R
(p < b)%R /\ p <> ((a + b) / INR 2)%R assumption.
a, b:R
H:(a < b)%R
p:=((a + (a + b) / INR 2) / INR 2)%R:R
H0:(a < (a + b) / INR 2)%R
H1:((a + b) / INR 2 < b)%R
H2:(a < (a + (a + b) / INR 2) / INR 2)%R
H3:((a + (a + b) / INR 2) / INR 2 < (a + b) / INR 2)%R
(p < b)%R /\ p <> ((a + b) / INR 2)%R split.
a, b:R
H:(a < b)%R
p:=((a + (a + b) / INR 2) / INR 2)%R:R
H0:(a < (a + b) / INR 2)%R
H1:((a + b) / INR 2 < b)%R
H2:(a < (a + (a + b) / INR 2) / INR 2)%R
H3:((a + (a + b) / INR 2) / INR 2 < (a + b) / INR 2)%R
(p < b)%R
a, b:R
H:(a < b)%R
p:=((a + (a + b) / INR 2) / INR 2)%R:R
H0:(a < (a + b) / INR 2)%R
H1:((a + b) / INR 2 < b)%R
H2:(a < (a + (a + b) / INR 2) / INR 2)%R
H3:((a + (a + b) / INR 2) / INR 2 < (a + b) / INR 2)%R
p <> ((a + b) / INR 2)%R apply (Rlt_trans p ((a + b) / INR 2)%R).
a, b:R
H:(a < b)%R
p:=((a + (a + b) / INR 2) / INR 2)%R:R
H0:(a < (a + b) / INR 2)%R
H1:((a + b) / INR 2 < b)%R
H2:(a < (a + (a + b) / INR 2) / INR 2)%R
H3:((a + (a + b) / INR 2) / INR 2 < (a + b) / INR 2)%R
(p < (a + b) / INR 2)%R
a, b:R
H:(a < b)%R
p:=((a + (a + b) / INR 2) / INR 2)%R:R
H0:(a < (a + b) / INR 2)%R
H1:((a + b) / INR 2 < b)%R
H2:(a < (a + (a + b) / INR 2) / INR 2)%R
H3:((a + (a + b) / INR 2) / INR 2 < (a + b) / INR 2)%R
((a + b) / INR 2 < b)%R
a, b:R
H:(a < b)%R
p:=((a + (a + b) / INR 2) / INR 2)%R:R
H0:(a < (a + b) / INR 2)%R
H1:((a + b) / INR 2 < b)%R
H2:(a < (a + (a + b) / INR 2) / INR 2)%R
H3:((a + (a + b) / INR 2) / INR 2 < (a + b) / INR 2)%R
p <> ((a + b) / INR 2)%R assumption.
a, b:R
H:(a < b)%R
p:=((a + (a + b) / INR 2) / INR 2)%R:R
H0:(a < (a + b) / INR 2)%R
H1:((a + b) / INR 2 < b)%R
H2:(a < (a + (a + b) / INR 2) / INR 2)%R
H3:((a + (a + b) / INR 2) / INR 2 < (a + b) / INR 2)%R
((a + b) / INR 2 < b)%R
a, b:R
H:(a < b)%R
p:=((a + (a + b) / INR 2) / INR 2)%R:R
H0:(a < (a + b) / INR 2)%R
H1:((a + b) / INR 2 < b)%R
H2:(a < (a + (a + b) / INR 2) / INR 2)%R
H3:((a + (a + b) / INR 2) / INR 2 < (a + b) / INR 2)%R
p <> ((a + b) / INR 2)%R
    assumption.
a, b:R
H:(a < b)%R
p:=((a + (a + b) / INR 2) / INR 2)%R:R
H0:(a < (a + b) / INR 2)%R
H1:((a + b) / INR 2 < b)%R
H2:(a < (a + (a + b) / INR 2) / INR 2)%R
H3:((a + (a + b) / INR 2) / INR 2 < (a + b) / INR 2)%R
p <> ((a + b) / INR 2)%R apply Rlt_not_eq.
a, b:R
H:(a < b)%R
p:=((a + (a + b) / INR 2) / INR 2)%R:R
H0:(a < (a + b) / INR 2)%R
H1:((a + b) / INR 2 < b)%R
H2:(a < (a + (a + b) / INR 2) / INR 2)%R
H3:((a + (a + b) / INR 2) / INR 2 < (a + b) / INR 2)%R
(p < (a + b) / INR 2)%R assumption.
  -
a, b, h:R
H:(a < b)%R
n:h <> ((a + b) / INR 2)%R
p:=((a + b) / INR 2)%R:R
H0:(a < (a + b) / INR 2)%R
H1:((a + b) / INR 2 < b)%R
(a < p)%R /\ (p < b)%R /\ p <> h split.
a, b, h:R
H:(a < b)%R
n:h <> ((a + b) / INR 2)%R
p:=((a + b) / INR 2)%R:R
H0:(a < (a + b) / INR 2)%R
H1:((a + b) / INR 2 < b)%R
(a < p)%R
a, b, h:R
H:(a < b)%R
n:h <> ((a + b) / INR 2)%R
p:=((a + b) / INR 2)%R:R
H0:(a < (a + b) / INR 2)%R
H1:((a + b) / INR 2 < b)%R
(p < b)%R /\ p <> h assumption.
a, b, h:R
H:(a < b)%R
n:h <> ((a + b) / INR 2)%R
p:=((a + b) / INR 2)%R:R
H0:(a < (a + b) / INR 2)%R
H1:((a + b) / INR 2 < b)%R
(p < b)%R /\ p <> h split.
a, b, h:R
H:(a < b)%R
n:h <> ((a + b) / INR 2)%R
p:=((a + b) / INR 2)%R:R
H0:(a < (a + b) / INR 2)%R
H1:((a + b) / INR 2 < b)%R
(p < b)%R
a, b, h:R
H:(a < b)%R
n:h <> ((a + b) / INR 2)%R
p:=((a + b) / INR 2)%R:R
H0:(a < (a + b) / INR 2)%R
H1:((a + b) / INR 2 < b)%R
p <> h assumption.
a, b, h:R
H:(a < b)%R
n:h <> ((a + b) / INR 2)%R
p:=((a + b) / INR 2)%R:R
H0:(a < (a + b) / INR 2)%R
H1:((a + b) / INR 2 < b)%R
p <> h intro abs.
a, b, h:R
H:(a < b)%R
n:h <> ((a + b) / INR 2)%R
p:=((a + b) / INR 2)%R:R
H0:(a < (a + b) / INR 2)%R
H1:((a + b) / INR 2 < b)%R
abs:p = h
False subst.
a, b:R
H:(a < b)%R
p:=((a + b) / INR 2)%R:R
n:p <> ((a + b) / INR 2)%R
H0:(a < (a + b) / INR 2)%R
H1:((a + b) / INR 2 < b)%R
False contradiction.
Qed.

(* An enumeration of R reaches any open interval of R,
   extract the first two real numbers in it. *)
Definition first_in_holed_interval (u : nat -> R) (v : R -> nat) (a b h : R)
  : enumeration R u v -> Rlt a b
    -> { n : nat | in_holed_interval a b h u n
                /\ forall k : nat, k < n -> ~in_holed_interval a b h u k }.
u:nat -> R
v:R -> nat
a, b, h:R
enumeration R u v ->
(a < b)%R ->
{n : nat |
in_holed_interval a b h u n /\
(forall k : nat,
 k < n -> ~ in_holed_interval a b h u k)}
Proof.
u:nat -> R
v:R -> nat
a, b, h:R
enumeration R u v ->
(a < b)%R ->
{n : nat |
in_holed_interval a b h u n /\
(forall k : nat,
 k < n -> ~ in_holed_interval a b h u k)}
  intros.
u:nat -> R
v:R -> nat
a, b, h:R
H:enumeration R u v
H0:(a < b)%R
{n : nat |
in_holed_interval a b h u n /\
(forall k : nat,
 k < n -> ~ in_holed_interval a b h u k)} apply epsilon_smallest.
u:nat -> R
v:R -> nat
a, b, h:R
H:enumeration R u v
H0:(a < b)%R
forall n : nat,
{in_holed_interval a b h u n} +
{~ in_holed_interval a b h u n}
u:nat -> R
v:R -> nat
a, b, h:R
H:enumeration R u v
H0:(a < b)%R
exists n : nat, in_holed_interval a b h u n apply (in_holed_interval_dec a b h u).
u:nat -> R
v:R -> nat
a, b, h:R
H:enumeration R u v
H0:(a < b)%R
exists n : nat, in_holed_interval a b h u n
  exists (v (point_in_holed_interval a b h)).
u:nat -> R
v:R -> nat
a, b, h:R
H:enumeration R u v
H0:(a < b)%R
in_holed_interval a b h u
  (v (point_in_holed_interval a b h))
  destruct H.
u:nat -> R
v:R -> nat
a, b, h:R
H:forall x : R, u (v x) = x
H1:forall n : nat, v (u n) = n
H0:(a < b)%R
in_holed_interval a b h u
  (v (point_in_holed_interval a b h)) unfold in_holed_interval.
u:nat -> R
v:R -> nat
a, b, h:R
H:forall x : R, u (v x) = x
H1:forall n : nat, v (u n) = n
H0:(a < b)%R
(a < u (v (point_in_holed_interval a b h)))%R /\
(u (v (point_in_holed_interval a b h)) < b)%R /\
u (v (point_in_holed_interval a b h)) <> h rewrite -> H.
u:nat -> R
v:R -> nat
a, b, h:R
H:forall x : R, u (v x) = x
H1:forall n : nat, v (u n) = n
H0:(a < b)%R
(a < point_in_holed_interval a b h)%R /\
(point_in_holed_interval a b h < b)%R /\
point_in_holed_interval a b h <> h
  apply point_in_holed_interval_works.
u:nat -> R
v:R -> nat
a, b, h:R
H:forall x : R, u (v x) = x
H1:forall n : nat, v (u n) = n
H0:(a < b)%R
(a < b)%R assumption.
Defined.

Lemma first_in_holed_interval_works (u : nat -> R) (v : R -> nat) (a b h : R)
  (pen : enumeration R u v) (plow : Rlt a b) :
  let (c,_) := first_in_holed_interval u v a b h pen plow in
  forall x:R, Rlt a x -> Rlt x b -> x <> h -> x <> u c -> c < v x.
u:nat -> R
v:R -> nat
a, b, h:R
pen:enumeration R u v
plow:(a < b)%R
let (c, _) :=
  first_in_holed_interval u v a b h pen plow in
forall x : R,
(a < x)%R ->
(x < b)%R -> x <> h -> x <> u c -> c < v x
Proof.
u:nat -> R
v:R -> nat
a, b, h:R
pen:enumeration R u v
plow:(a < b)%R
let (c, _) :=
  first_in_holed_interval u v a b h pen plow in
forall x : R,
(a < x)%R ->
(x < b)%R -> x <> h -> x <> u c -> c < v x
  destruct (first_in_holed_interval u v a b h pen plow) as [c].
u:nat -> R
v:R -> nat
a, b, h:R
pen:enumeration R u v
plow:(a < b)%R
c:nat
a0:in_holed_interval a b h u c /\
(forall k : nat,
 k < c -> ~ in_holed_interval a b h u k)
forall x : R,
(a < x)%R ->
(x < b)%R -> x <> h -> x <> u c -> c < v x intros.
u:nat -> R
v:R -> nat
a, b, h:R
pen:enumeration R u v
plow:(a < b)%R
c:nat
a0:in_holed_interval a b h u c /\
(forall k : nat,
 k < c -> ~ in_holed_interval a b h u k)
x:R
H:(a < x)%R
H0:(x < b)%R
H1:x <> h
H2:x <> u c
c < v x
  destruct (c ?= v x) eqn:order.
u:nat -> R
v:R -> nat
a, b, h:R
pen:enumeration R u v
plow:(a < b)%R
c:nat
a0:in_holed_interval a b h u c /\
(forall k : nat,
 k < c -> ~ in_holed_interval a b h u k)
x:R
H:(a < x)%R
H0:(x < b)%R
H1:x <> h
H2:x <> u c
order:(c ?= v x) = Eq
c < v x
u:nat -> R
v:R -> nat
a, b, h:R
pen:enumeration R u v
plow:(a < b)%R
c:nat
a0:in_holed_interval a b h u c /\
(forall k : nat,
 k < c -> ~ in_holed_interval a b h u k)
x:R
H:(a < x)%R
H0:(x < b)%R
H1:x <> h
H2:x <> u c
order:(c ?= v x) = Lt
c < v x
u:nat -> R
v:R -> nat
a, b, h:R
pen:enumeration R u v
plow:(a < b)%R
c:nat
a0:in_holed_interval a b h u c /\
(forall k : nat,
 k < c -> ~ in_holed_interval a b h u k)
x:R
H:(a < x)%R
H0:(x < b)%R
H1:x <> h
H2:x <> u c
order:(c ?= v x) = Gt
c < v x
  -
u:nat -> R
v:R -> nat
a, b, h:R
pen:enumeration R u v
plow:(a < b)%R
c:nat
a0:in_holed_interval a b h u c /\
(forall k : nat,
 k < c -> ~ in_holed_interval a b h u k)
x:R
H:(a < x)%R
H0:(x < b)%R
H1:x <> h
H2:x <> u c
order:(c ?= v x) = Eq
c < v x exfalso.
u:nat -> R
v:R -> nat
a, b, h:R
pen:enumeration R u v
plow:(a < b)%R
c:nat
a0:in_holed_interval a b h u c /\
(forall k : nat,
 k < c -> ~ in_holed_interval a b h u k)
x:R
H:(a < x)%R
H0:(x < b)%R
H1:x <> h
H2:x <> u c
order:(c ?= v x) = Eq
False apply Nat.compare_eq_iff in order.
u:nat -> R
v:R -> nat
a, b, h:R
pen:enumeration R u v
plow:(a < b)%R
c:nat
a0:in_holed_interval a b h u c /\
(forall k : nat,
 k < c -> ~ in_holed_interval a b h u k)
x:R
H:(a < x)%R
H0:(x < b)%R
H1:x <> h
H2:x <> u c
order:c = v x
False rewrite -> order in H2.
u:nat -> R
v:R -> nat
a, b, h:R
pen:enumeration R u v
plow:(a < b)%R
c:nat
a0:in_holed_interval a b h u c /\
(forall k : nat,
 k < c -> ~ in_holed_interval a b h u k)
x:R
H:(a < x)%R
H0:(x < b)%R
H1:x <> h
H2:x <> u (v x)
order:c = v x
False
    destruct pen.
u:nat -> R
v:R -> nat
a, b, h:R
H3:forall x0 : R, u (v x0) = x0
H4:forall n : nat, v (u n) = n
plow:(a < b)%R
c:nat
a0:in_holed_interval a b h u c /\
(forall k : nat,
 k < c -> ~ in_holed_interval a b h u k)
x:R
H:(a < x)%R
H0:(x < b)%R
H1:x <> h
H2:x <> u (v x)
order:c = v x
False rewrite -> H3 in H2.
u:nat -> R
v:R -> nat
a, b, h:R
H3:forall x0 : R, u (v x0) = x0
H4:forall n : nat, v (u n) = n
plow:(a < b)%R
c:nat
a0:in_holed_interval a b h u c /\
(forall k : nat,
 k < c -> ~ in_holed_interval a b h u k)
x:R
H:(a < x)%R
H0:(x < b)%R
H1:x <> h
H2:x <> x
order:c = v x
False exact (H2 eq_refl).
  -
u:nat -> R
v:R -> nat
a, b, h:R
pen:enumeration R u v
plow:(a < b)%R
c:nat
a0:in_holed_interval a b h u c /\
(forall k : nat,
 k < c -> ~ in_holed_interval a b h u k)
x:R
H:(a < x)%R
H0:(x < b)%R
H1:x <> h
H2:x <> u c
order:(c ?= v x) = Lt
c < v x apply Nat.compare_lt_iff in order.
u:nat -> R
v:R -> nat
a, b, h:R
pen:enumeration R u v
plow:(a < b)%R
c:nat
a0:in_holed_interval a b h u c /\
(forall k : nat,
 k < c -> ~ in_holed_interval a b h u k)
x:R
H:(a < x)%R
H0:(x < b)%R
H1:x <> h
H2:x <> u c
order:c < v x
c < v x assumption.
  -
u:nat -> R
v:R -> nat
a, b, h:R
pen:enumeration R u v
plow:(a < b)%R
c:nat
a0:in_holed_interval a b h u c /\
(forall k : nat,
 k < c -> ~ in_holed_interval a b h u k)
x:R
H:(a < x)%R
H0:(x < b)%R
H1:x <> h
H2:x <> u c
order:(c ?= v x) = Gt
c < v x exfalso.
u:nat -> R
v:R -> nat
a, b, h:R
pen:enumeration R u v
plow:(a < b)%R
c:nat
a0:in_holed_interval a b h u c /\
(forall k : nat,
 k < c -> ~ in_holed_interval a b h u k)
x:R
H:(a < x)%R
H0:(x < b)%R
H1:x <> h
H2:x <> u c
order:(c ?= v x) = Gt
False apply Nat.compare_gt_iff in order.
u:nat -> R
v:R -> nat
a, b, h:R
pen:enumeration R u v
plow:(a < b)%R
c:nat
a0:in_holed_interval a b h u c /\
(forall k : nat,
 k < c -> ~ in_holed_interval a b h u k)
x:R
H:(a < x)%R
H0:(x < b)%R
H1:x <> h
H2:x <> u c
order:v x < c
False
    destruct a0.
u:nat -> R
v:R -> nat
a, b, h:R
pen:enumeration R u v
plow:(a < b)%R
c:nat
H3:in_holed_interval a b h u c
H4:forall k : nat,
k < c -> ~ in_holed_interval a b h u k
x:R
H:(a < x)%R
H0:(x < b)%R
H1:x <> h
H2:x <> u c
order:v x < c
False specialize (H4 (v x) order).
u:nat -> R
v:R -> nat
a, b, h:R
pen:enumeration R u v
plow:(a < b)%R
c:nat
H3:in_holed_interval a b h u c
x:R
H4:~ in_holed_interval a b h u (v x)
H:(a < x)%R
H0:(x < b)%R
H1:x <> h
H2:x <> u c
order:v x < c
False assert (in_holed_interval a b h u (v x)).
u:nat -> R
v:R -> nat
a, b, h:R
pen:enumeration R u v
plow:(a < b)%R
c:nat
H3:in_holed_interval a b h u c
x:R
H4:~ in_holed_interval a b h u (v x)
H:(a < x)%R
H0:(x < b)%R
H1:x <> h
H2:x <> u c
order:v x < c
in_holed_interval a b h u (v x)
u:nat -> R
v:R -> nat
a, b, h:R
pen:enumeration R u v
plow:(a < b)%R
c:nat
H3:in_holed_interval a b h u c
x:R
H4:~ in_holed_interval a b h u (v x)
H:(a < x)%R
H0:(x < b)%R
H1:x <> h
H2:x <> u c
order:v x < c
H5:in_holed_interval a b h u (v x)
False
    {
u:nat -> R
v:R -> nat
a, b, h:R
pen:enumeration R u v
plow:(a < b)%R
c:nat
H3:in_holed_interval a b h u c
x:R
H4:~ in_holed_interval a b h u (v x)
H:(a < x)%R
H0:(x < b)%R
H1:x <> h
H2:x <> u c
order:v x < c
in_holed_interval a b h u (v x) destruct pen.
u:nat -> R
v:R -> nat
a, b, h:R
H5:forall x0 : R, u (v x0) = x0
H6:forall n : nat, v (u n) = n
plow:(a < b)%R
c:nat
H3:in_holed_interval a b h u c
x:R
H4:~ in_holed_interval a b h u (v x)
H:(a < x)%R
H0:(x < b)%R
H1:x <> h
H2:x <> u c
order:v x < c
in_holed_interval a b h u (v x) split.
u:nat -> R
v:R -> nat
a, b, h:R
H5:forall x0 : R, u (v x0) = x0
H6:forall n : nat, v (u n) = n
plow:(a < b)%R
c:nat
H3:in_holed_interval a b h u c
x:R
H4:~ in_holed_interval a b h u (v x)
H:(a < x)%R
H0:(x < b)%R
H1:x <> h
H2:x <> u c
order:v x < c
(a < u (v x))%R
u:nat -> R
v:R -> nat
a, b, h:R
H5:forall x0 : R, u (v x0) = x0
H6:forall n : nat, v (u n) = n
plow:(a < b)%R
c:nat
H3:in_holed_interval a b h u c
x:R
H4:~ in_holed_interval a b h u (v x)
H:(a < x)%R
H0:(x < b)%R
H1:x <> h
H2:x <> u c
order:v x < c
(u (v x) < b)%R /\ u (v x) <> h rewrite -> H5.
u:nat -> R
v:R -> nat
a, b, h:R
H5:forall x0 : R, u (v x0) = x0
H6:forall n : nat, v (u n) = n
plow:(a < b)%R
c:nat
H3:in_holed_interval a b h u c
x:R
H4:~ in_holed_interval a b h u (v x)
H:(a < x)%R
H0:(x < b)%R
H1:x <> h
H2:x <> u c
order:v x < c
(a < x)%R
u:nat -> R
v:R -> nat
a, b, h:R
H5:forall x0 : R, u (v x0) = x0
H6:forall n : nat, v (u n) = n
plow:(a < b)%R
c:nat
H3:in_holed_interval a b h u c
x:R
H4:~ in_holed_interval a b h u (v x)
H:(a < x)%R
H0:(x < b)%R
H1:x <> h
H2:x <> u c
order:v x < c
(u (v x) < b)%R /\ u (v x) <> h assumption.
u:nat -> R
v:R -> nat
a, b, h:R
H5:forall x0 : R, u (v x0) = x0
H6:forall n : nat, v (u n) = n
plow:(a < b)%R
c:nat
H3:in_holed_interval a b h u c
x:R
H4:~ in_holed_interval a b h u (v x)
H:(a < x)%R
H0:(x < b)%R
H1:x <> h
H2:x <> u c
order:v x < c
(u (v x) < b)%R /\ u (v x) <> h rewrite -> H5.
u:nat -> R
v:R -> nat
a, b, h:R
H5:forall x0 : R, u (v x0) = x0
H6:forall n : nat, v (u n) = n
plow:(a < b)%R
c:nat
H3:in_holed_interval a b h u c
x:R
H4:~ in_holed_interval a b h u (v x)
H:(a < x)%R
H0:(x < b)%R
H1:x <> h
H2:x <> u c
order:v x < c
(x < b)%R /\ x <> h split; assumption. }
u:nat -> R
v:R -> nat
a, b, h:R
pen:enumeration R u v
plow:(a < b)%R
c:nat
H3:in_holed_interval a b h u c
x:R
H4:~ in_holed_interval a b h u (v x)
H:(a < x)%R
H0:(x < b)%R
H1:x <> h
H2:x <> u c
order:v x < c
H5:in_holed_interval a b h u (v x)
False
    contradiction.
Qed.

Definition first_two_in_interval (u : nat -> R) (v : R -> nat) (a b : R)
           (pen : enumeration R u v) (plow : Rlt a b)
  : prod R R :=
  let (first_index, pr) := first_in_holed_interval u v a b b pen plow in
  let (second_index, pr2) := first_in_holed_interval u v a b (u first_index) pen plow in
  if Rle_dec (u first_index) (u second_index) then (u first_index, u second_index)
  else (u second_index, u first_index).


Lemma split_couple_eq : forall a b c d : R, (a,b) = (c,d) -> a = c /\ b = d.
forall a b c d : R, (a, b) = (c, d) -> a = c /\ b = d
Proof.
forall a b c d : R, (a, b) = (c, d) -> a = c /\ b = d
  intros.
a, b, c, d:R
H:(a, b) = (c, d)
a = c /\ b = d injection H.
a, b, c, d:R
H:(a, b) = (c, d)
b = d -> a = c -> a = c /\ b = d intros.
a, b, c, d:R
H:(a, b) = (c, d)
H0:b = d
H1:a = c
a = c /\ b = d split.
a, b, c, d:R
H:(a, b) = (c, d)
H0:b = d
H1:a = c
a = c
a, b, c, d:R
H:(a, b) = (c, d)
H0:b = d
H1:a = c
b = d subst.
c, d:R
H:(c, d) = (c, d)
c = c
a, b, c, d:R
H:(a, b) = (c, d)
H0:b = d
H1:a = c
b = d reflexivity.
a, b, c, d:R
H:(a, b) = (c, d)
H0:b = d
H1:a = c
b = d subst.
c, d:R
H:(c, d) = (c, d)
d = d reflexivity.
Qed.

Lemma first_two_in_interval_works (u : nat -> R) (v : R -> nat) (a b : R)
  (pen : enumeration R u v) (plow : Rlt a b) :
  let (c,d) := first_two_in_interval u v a b pen plow in
  Rlt a c /\ Rlt c b
  /\ Rlt a d /\ Rlt d b
  /\ Rlt c d
  /\ (forall x:R, Rlt a x -> Rlt x b -> x <> c -> x <> d -> v c < v x).
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
let (c, d) :=
  first_two_in_interval u v a b pen plow in
(a < c)%R /\
(c < b)%R /\
(a < d)%R /\
(d < b)%R /\
(c < d)%R /\
(forall x : R,
 (a < x)%R ->
 (x < b)%R -> x <> c -> x <> d -> v c < v x)
Proof.
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
let (c, d) :=
  first_two_in_interval u v a b pen plow in
(a < c)%R /\
(c < b)%R /\
(a < d)%R /\
(d < b)%R /\
(c < d)%R /\
(forall x : R,
 (a < x)%R ->
 (x < b)%R -> x <> c -> x <> d -> v c < v x)
  intros.
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
let (c, d) :=
  first_two_in_interval u v a b pen plow in
(a < c)%R /\
(c < b)%R /\
(a < d)%R /\
(d < b)%R /\
(c < d)%R /\
(forall x : R,
 (a < x)%R ->
 (x < b)%R -> x <> c -> x <> d -> v c < v x) destruct (first_two_in_interval u v a b) eqn:ft.
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
r, r0:R
ft:first_two_in_interval u v a b pen plow = (r, r0)
(a < r)%R /\
(r < b)%R /\
(a < r0)%R /\
(r0 < b)%R /\
(r < r0)%R /\
(forall x : R,
 (a < x)%R ->
 (x < b)%R -> x <> r -> x <> r0 -> v r < v x)
  unfold first_two_in_interval in ft.
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
r, r0:R
ft:(let (first_index, _) :=
   first_in_holed_interval u v a b b pen plow in
 let (second_index, _) :=
   first_in_holed_interval u v a b
     (u first_index) pen plow in
 if Rle_dec (u first_index) (u second_index)
 then (u first_index, u second_index)
 else (u second_index, u first_index)) = 
(r, r0)
(a < r)%R /\
(r < b)%R /\
(a < r0)%R /\
(r0 < b)%R /\
(r < r0)%R /\
(forall x : R,
 (a < x)%R ->
 (x < b)%R -> x <> r -> x <> r0 -> v r < v x)
  pose proof (first_in_holed_interval_works u v a b b pen plow).
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
r, r0:R
ft:(let (first_index, _) :=
   first_in_holed_interval u v a b b pen plow in
 let (second_index, _) :=
   first_in_holed_interval u v a b
     (u first_index) pen plow in
 if Rle_dec (u first_index) (u second_index)
 then (u first_index, u second_index)
 else (u second_index, u first_index)) = 
(r, r0)
H:let (c, _) :=
  first_in_holed_interval u v a b b pen plow in
forall x : R,
(a < x)%R ->
(x < b)%R -> x <> b -> x <> u c -> c < v x
(a < r)%R /\
(r < b)%R /\
(a < r0)%R /\
(r0 < b)%R /\
(r < r0)%R /\
(forall x : R,
 (a < x)%R ->
 (x < b)%R -> x <> r -> x <> r0 -> v r < v x)
  destruct (first_in_holed_interval u v a b b pen plow) as [first_index pr].
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
r, r0:R
first_index:nat
pr:in_holed_interval a b b u first_index /\
(forall k : nat,
 k < first_index -> ~ in_holed_interval a b b u k)
ft:(let (second_index, _) :=
   first_in_holed_interval u v a b
     (u first_index) pen plow in
 if Rle_dec (u first_index) (u second_index)
 then (u first_index, u second_index)
 else (u second_index, u first_index)) = 
(r, r0)
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
(a < r)%R /\
(r < b)%R /\
(a < r0)%R /\
(r0 < b)%R /\
(r < r0)%R /\
(forall x : R,
 (a < x)%R ->
 (x < b)%R -> x <> r -> x <> r0 -> v r < v x)
  pose proof (first_in_holed_interval_works u v a b (u first_index) pen plow).
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
r, r0:R
first_index:nat
pr:in_holed_interval a b b u first_index /\
(forall k : nat,
 k < first_index -> ~ in_holed_interval a b b u k)
ft:(let (second_index, _) :=
   first_in_holed_interval u v a b
     (u first_index) pen plow in
 if Rle_dec (u first_index) (u second_index)
 then (u first_index, u second_index)
 else (u second_index, u first_index)) = 
(r, r0)
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:let (c, _) :=
  first_in_holed_interval u v a b 
    (u first_index) pen plow in
forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index -> x <> u c -> c < v x
(a < r)%R /\
(r < b)%R /\
(a < r0)%R /\
(r0 < b)%R /\
(r < r0)%R /\
(forall x : R,
 (a < x)%R ->
 (x < b)%R -> x <> r -> x <> r0 -> v r < v x)
  destruct pr.
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
r, r0:R
first_index:nat
H1:in_holed_interval a b b u first_index
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
ft:(let (second_index, _) :=
   first_in_holed_interval u v a b
     (u first_index) pen plow in
 if Rle_dec (u first_index) (u second_index)
 then (u first_index, u second_index)
 else (u second_index, u first_index)) = 
(r, r0)
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:let (c, _) :=
  first_in_holed_interval u v a b 
    (u first_index) pen plow in
forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index -> x <> u c -> c < v x
(a < r)%R /\
(r < b)%R /\
(a < r0)%R /\
(r0 < b)%R /\
(r < r0)%R /\
(forall x : R,
 (a < x)%R ->
 (x < b)%R -> x <> r -> x <> r0 -> v r < v x) destruct H1.
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
r, r0:R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R /\ u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
ft:(let (second_index, _) :=
   first_in_holed_interval u v a b
     (u first_index) pen plow in
 if Rle_dec (u first_index) (u second_index)
 then (u first_index, u second_index)
 else (u second_index, u first_index)) = 
(r, r0)
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:let (c, _) :=
  first_in_holed_interval u v a b 
    (u first_index) pen plow in
forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index -> x <> u c -> c < v x
(a < r)%R /\
(r < b)%R /\
(a < r0)%R /\
(r0 < b)%R /\
(r < r0)%R /\
(forall x : R,
 (a < x)%R ->
 (x < b)%R -> x <> r -> x <> r0 -> v r < v x) destruct H3.
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
r, r0:R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
ft:(let (second_index, _) :=
   first_in_holed_interval u v a b
     (u first_index) pen plow in
 if Rle_dec (u first_index) (u second_index)
 then (u first_index, u second_index)
 else (u second_index, u first_index)) = 
(r, r0)
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:let (c, _) :=
  first_in_holed_interval u v a b 
    (u first_index) pen plow in
forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index -> x <> u c -> c < v x
(a < r)%R /\
(r < b)%R /\
(a < r0)%R /\
(r0 < b)%R /\
(r < r0)%R /\
(forall x : R,
 (a < x)%R ->
 (x < b)%R -> x <> r -> x <> r0 -> v r < v x)
  destruct (first_in_holed_interval u v a b (u first_index) pen plow)
    as [second_index pr2].
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
r, r0:R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
pr2:in_holed_interval a b (u first_index) u
  second_index /\
(forall k : nat,
 k < second_index ->
 ~ in_holed_interval a b (u first_index) u k)
ft:(if Rle_dec (u first_index) (u second_index)
 then (u first_index, u second_index)
 else (u second_index, u first_index)) = 
(r, r0)
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> second_index < v x
(a < r)%R /\
(r < b)%R /\
(a < r0)%R /\
(r0 < b)%R /\
(r < r0)%R /\
(forall x : R,
 (a < x)%R ->
 (x < b)%R -> x <> r -> x <> r0 -> v r < v x)
  destruct pr2.
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
r, r0:R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:in_holed_interval a b (u first_index) u
  second_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
ft:(if Rle_dec (u first_index) (u second_index)
 then (u first_index, u second_index)
 else (u second_index, u first_index)) = 
(r, r0)
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> second_index < v x
(a < r)%R /\
(r < b)%R /\
(a < r0)%R /\
(r0 < b)%R /\
(r < r0)%R /\
(forall x : R,
 (a < x)%R ->
 (x < b)%R -> x <> r -> x <> r0 -> v r < v x) destruct H5.
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
r, r0:R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R /\
u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
ft:(if Rle_dec (u first_index) (u second_index)
 then (u first_index, u second_index)
 else (u second_index, u first_index)) = 
(r, r0)
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> second_index < v x
(a < r)%R /\
(r < b)%R /\
(a < r0)%R /\
(r0 < b)%R /\
(r < r0)%R /\
(forall x : R,
 (a < x)%R ->
 (x < b)%R -> x <> r -> x <> r0 -> v r < v x) destruct H7.
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
r, r0:R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
ft:(if Rle_dec (u first_index) (u second_index)
 then (u first_index, u second_index)
 else (u second_index, u first_index)) = 
(r, r0)
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> second_index < v x
(a < r)%R /\
(r < b)%R /\
(a < r0)%R /\
(r0 < b)%R /\
(r < r0)%R /\
(forall x : R,
 (a < x)%R ->
 (x < b)%R -> x <> r -> x <> r0 -> v r < v x)
  destruct (Rle_dec (u first_index) (u second_index)).
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
r, r0:R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
r1:(u first_index <= u second_index)%R
ft:(u first_index, u second_index) = (r, r0)
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> second_index < v x
(a < r)%R /\
(r < b)%R /\
(a < r0)%R /\
(r0 < b)%R /\
(r < r0)%R /\
(forall x : R,
 (a < x)%R ->
 (x < b)%R -> x <> r -> x <> r0 -> v r < v x)
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
r, r0:R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
n:~ (u first_index <= u second_index)%R
ft:(u second_index, u first_index) = (r, r0)
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> second_index < v x
(a < r)%R /\
(r < b)%R /\
(a < r0)%R /\
(r0 < b)%R /\
(r < r0)%R /\
(forall x : R,
 (a < x)%R ->
 (x < b)%R -> x <> r -> x <> r0 -> v r < v x)
  -
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
r, r0:R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
r1:(u first_index <= u second_index)%R
ft:(u first_index, u second_index) = (r, r0)
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> second_index < v x
(a < r)%R /\
(r < b)%R /\
(a < r0)%R /\
(r0 < b)%R /\
(r < r0)%R /\
(forall x : R,
 (a < x)%R ->
 (x < b)%R -> x <> r -> x <> r0 -> v r < v x) apply split_couple_eq in ft as [ft ft0].
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
r, r0:R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
r1:(u first_index <= u second_index)%R
ft:u first_index = r
ft0:u second_index = r0
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> second_index < v x
(a < r)%R /\
(r < b)%R /\
(a < r0)%R /\
(r0 < b)%R /\
(r < r0)%R /\
(forall x : R,
 (a < x)%R ->
 (x < b)%R -> x <> r -> x <> r0 -> v r < v x) subst.
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
r1:(u first_index <= u second_index)%R
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> second_index < v x
(a < u first_index)%R /\
(u first_index < b)%R /\
(a < u second_index)%R /\
(u second_index < b)%R /\
(u first_index < u second_index)%R /\
(forall x : R,
 (a < x)%R ->
 (x < b)%R ->
 x <> u first_index ->
 x <> u second_index -> v (u first_index) < v x) split.
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
r1:(u first_index <= u second_index)%R
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> second_index < v x
(a < u first_index)%R
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
r1:(u first_index <= u second_index)%R
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> second_index < v x
(u first_index < b)%R /\
(a < u second_index)%R /\
(u second_index < b)%R /\
(u first_index < u second_index)%R /\
(forall x : R,
 (a < x)%R ->
 (x < b)%R ->
 x <> u first_index ->
 x <> u second_index -> v (u first_index) < v x) assumption.
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
r1:(u first_index <= u second_index)%R
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> second_index < v x
(u first_index < b)%R /\
(a < u second_index)%R /\
(u second_index < b)%R /\
(u first_index < u second_index)%R /\
(forall x : R,
 (a < x)%R ->
 (x < b)%R ->
 x <> u first_index ->
 x <> u second_index -> v (u first_index) < v x)
    split.
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
r1:(u first_index <= u second_index)%R
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> second_index < v x
(u first_index < b)%R
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
r1:(u first_index <= u second_index)%R
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> second_index < v x
(a < u second_index)%R /\
(u second_index < b)%R /\
(u first_index < u second_index)%R /\
(forall x : R,
 (a < x)%R ->
 (x < b)%R ->
 x <> u first_index ->
 x <> u second_index -> v (u first_index) < v x) assumption.
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
r1:(u first_index <= u second_index)%R
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> second_index < v x
(a < u second_index)%R /\
(u second_index < b)%R /\
(u first_index < u second_index)%R /\
(forall x : R,
 (a < x)%R ->
 (x < b)%R ->
 x <> u first_index ->
 x <> u second_index -> v (u first_index) < v x) split.
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
r1:(u first_index <= u second_index)%R
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> second_index < v x
(a < u second_index)%R
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
r1:(u first_index <= u second_index)%R
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> second_index < v x
(u second_index < b)%R /\
(u first_index < u second_index)%R /\
(forall x : R,
 (a < x)%R ->
 (x < b)%R ->
 x <> u first_index ->
 x <> u second_index -> v (u first_index) < v x) assumption.
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
r1:(u first_index <= u second_index)%R
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> second_index < v x
(u second_index < b)%R /\
(u first_index < u second_index)%R /\
(forall x : R,
 (a < x)%R ->
 (x < b)%R ->
 x <> u first_index ->
 x <> u second_index -> v (u first_index) < v x) split.
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
r1:(u first_index <= u second_index)%R
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> second_index < v x
(u second_index < b)%R
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
r1:(u first_index <= u second_index)%R
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> second_index < v x
(u first_index < u second_index)%R /\
(forall x : R,
 (a < x)%R ->
 (x < b)%R ->
 x <> u first_index ->
 x <> u second_index -> v (u first_index) < v x) assumption.
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
r1:(u first_index <= u second_index)%R
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> second_index < v x
(u first_index < u second_index)%R /\
(forall x : R,
 (a < x)%R ->
 (x < b)%R ->
 x <> u first_index ->
 x <> u second_index -> v (u first_index) < v x) split.
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
r1:(u first_index <= u second_index)%R
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> second_index < v x
(u first_index < u second_index)%R
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
r1:(u first_index <= u second_index)%R
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> second_index < v x
forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> v (u first_index) < v x
    apply Rle_lt_or_eq_dec in r1.
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
r1:{(u first_index < u second_index)%R} +
{u first_index = u second_index}
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> second_index < v x
(u first_index < u second_index)%R
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
r1:(u first_index <= u second_index)%R
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> second_index < v x
forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> v (u first_index) < v x destruct r1.
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
r:(u first_index < u second_index)%R
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> second_index < v x
(u first_index < u second_index)%R
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
e:u first_index = u second_index
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> second_index < v x
(u first_index < u second_index)%R
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
r1:(u first_index <= u second_index)%R
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> second_index < v x
forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> v (u first_index) < v x assumption.
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
e:u first_index = u second_index
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> second_index < v x
(u first_index < u second_index)%R
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
r1:(u first_index <= u second_index)%R
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> second_index < v x
forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> v (u first_index) < v x exfalso.
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
e:u first_index = u second_index
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> second_index < v x
False
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
r1:(u first_index <= u second_index)%R
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> second_index < v x
forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> v (u first_index) < v x
    rewrite -> e in H8.
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u second_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
e:u first_index = u second_index
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> second_index < v x
False
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
r1:(u first_index <= u second_index)%R
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> second_index < v x
forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> v (u first_index) < v x exact (H8 eq_refl).
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
r1:(u first_index <= u second_index)%R
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> second_index < v x
forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> v (u first_index) < v x intros.
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
r1:(u first_index <= u second_index)%R
H:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> b ->
x0 <> u first_index -> first_index < v x0
H0:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> u first_index ->
x0 <> u second_index -> second_index < v x0
x:R
H9:(a < x)%R
H10:(x < b)%R
H11:x <> u first_index
H12:x <> u second_index
v (u first_index) < v x destruct pen.
u:nat -> R
v:R -> nat
a, b:R
H13:forall x0 : R, u (v x0) = x0
H14:forall n : nat, v (u n) = n
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
r1:(u first_index <= u second_index)%R
H:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> b ->
x0 <> u first_index -> first_index < v x0
H0:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> u first_index ->
x0 <> u second_index -> second_index < v x0
x:R
H9:(a < x)%R
H10:(x < b)%R
H11:x <> u first_index
H12:x <> u second_index
v (u first_index) < v x rewrite -> H14.
u:nat -> R
v:R -> nat
a, b:R
H13:forall x0 : R, u (v x0) = x0
H14:forall n : nat, v (u n) = n
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
r1:(u first_index <= u second_index)%R
H:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> b ->
x0 <> u first_index -> first_index < v x0
H0:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> u first_index ->
x0 <> u second_index -> second_index < v x0
x:R
H9:(a < x)%R
H10:(x < b)%R
H11:x <> u first_index
H12:x <> u second_index
first_index < v x
    apply H.
u:nat -> R
v:R -> nat
a, b:R
H13:forall x0 : R, u (v x0) = x0
H14:forall n : nat, v (u n) = n
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
r1:(u first_index <= u second_index)%R
H:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> b ->
x0 <> u first_index -> first_index < v x0
H0:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> u first_index ->
x0 <> u second_index -> second_index < v x0
x:R
H9:(a < x)%R
H10:(x < b)%R
H11:x <> u first_index
H12:x <> u second_index
(a < x)%R
u:nat -> R
v:R -> nat
a, b:R
H13:forall x0 : R, u (v x0) = x0
H14:forall n : nat, v (u n) = n
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
r1:(u first_index <= u second_index)%R
H:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> b ->
x0 <> u first_index -> first_index < v x0
H0:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> u first_index ->
x0 <> u second_index -> second_index < v x0
x:R
H9:(a < x)%R
H10:(x < b)%R
H11:x <> u first_index
H12:x <> u second_index
(x < b)%R
u:nat -> R
v:R -> nat
a, b:R
H13:forall x0 : R, u (v x0) = x0
H14:forall n : nat, v (u n) = n
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
r1:(u first_index <= u second_index)%R
H:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> b ->
x0 <> u first_index -> first_index < v x0
H0:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> u first_index ->
x0 <> u second_index -> second_index < v x0
x:R
H9:(a < x)%R
H10:(x < b)%R
H11:x <> u first_index
H12:x <> u second_index
x <> b
u:nat -> R
v:R -> nat
a, b:R
H13:forall x0 : R, u (v x0) = x0
H14:forall n : nat, v (u n) = n
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
r1:(u first_index <= u second_index)%R
H:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> b ->
x0 <> u first_index -> first_index < v x0
H0:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> u first_index ->
x0 <> u second_index -> second_index < v x0
x:R
H9:(a < x)%R
H10:(x < b)%R
H11:x <> u first_index
H12:x <> u second_index
x <> u first_index assumption.
u:nat -> R
v:R -> nat
a, b:R
H13:forall x0 : R, u (v x0) = x0
H14:forall n : nat, v (u n) = n
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
r1:(u first_index <= u second_index)%R
H:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> b ->
x0 <> u first_index -> first_index < v x0
H0:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> u first_index ->
x0 <> u second_index -> second_index < v x0
x:R
H9:(a < x)%R
H10:(x < b)%R
H11:x <> u first_index
H12:x <> u second_index
(x < b)%R
u:nat -> R
v:R -> nat
a, b:R
H13:forall x0 : R, u (v x0) = x0
H14:forall n : nat, v (u n) = n
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
r1:(u first_index <= u second_index)%R
H:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> b ->
x0 <> u first_index -> first_index < v x0
H0:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> u first_index ->
x0 <> u second_index -> second_index < v x0
x:R
H9:(a < x)%R
H10:(x < b)%R
H11:x <> u first_index
H12:x <> u second_index
x <> b
u:nat -> R
v:R -> nat
a, b:R
H13:forall x0 : R, u (v x0) = x0
H14:forall n : nat, v (u n) = n
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
r1:(u first_index <= u second_index)%R
H:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> b ->
x0 <> u first_index -> first_index < v x0
H0:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> u first_index ->
x0 <> u second_index -> second_index < v x0
x:R
H9:(a < x)%R
H10:(x < b)%R
H11:x <> u first_index
H12:x <> u second_index
x <> u first_index assumption.
u:nat -> R
v:R -> nat
a, b:R
H13:forall x0 : R, u (v x0) = x0
H14:forall n : nat, v (u n) = n
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
r1:(u first_index <= u second_index)%R
H:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> b ->
x0 <> u first_index -> first_index < v x0
H0:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> u first_index ->
x0 <> u second_index -> second_index < v x0
x:R
H9:(a < x)%R
H10:(x < b)%R
H11:x <> u first_index
H12:x <> u second_index
x <> b
u:nat -> R
v:R -> nat
a, b:R
H13:forall x0 : R, u (v x0) = x0
H14:forall n : nat, v (u n) = n
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
r1:(u first_index <= u second_index)%R
H:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> b ->
x0 <> u first_index -> first_index < v x0
H0:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> u first_index ->
x0 <> u second_index -> second_index < v x0
x:R
H9:(a < x)%R
H10:(x < b)%R
H11:x <> u first_index
H12:x <> u second_index
x <> u first_index apply Rlt_not_eq.
u:nat -> R
v:R -> nat
a, b:R
H13:forall x0 : R, u (v x0) = x0
H14:forall n : nat, v (u n) = n
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
r1:(u first_index <= u second_index)%R
H:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> b ->
x0 <> u first_index -> first_index < v x0
H0:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> u first_index ->
x0 <> u second_index -> second_index < v x0
x:R
H9:(a < x)%R
H10:(x < b)%R
H11:x <> u first_index
H12:x <> u second_index
(x < b)%R
u:nat -> R
v:R -> nat
a, b:R
H13:forall x0 : R, u (v x0) = x0
H14:forall n : nat, v (u n) = n
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
r1:(u first_index <= u second_index)%R
H:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> b ->
x0 <> u first_index -> first_index < v x0
H0:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> u first_index ->
x0 <> u second_index -> second_index < v x0
x:R
H9:(a < x)%R
H10:(x < b)%R
H11:x <> u first_index
H12:x <> u second_index
x <> u first_index assumption.
u:nat -> R
v:R -> nat
a, b:R
H13:forall x0 : R, u (v x0) = x0
H14:forall n : nat, v (u n) = n
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
r1:(u first_index <= u second_index)%R
H:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> b ->
x0 <> u first_index -> first_index < v x0
H0:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> u first_index ->
x0 <> u second_index -> second_index < v x0
x:R
H9:(a < x)%R
H10:(x < b)%R
H11:x <> u first_index
H12:x <> u second_index
x <> u first_index assumption.
  -
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
r, r0:R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
n:~ (u first_index <= u second_index)%R
ft:(u second_index, u first_index) = (r, r0)
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> second_index < v x
(a < r)%R /\
(r < b)%R /\
(a < r0)%R /\
(r0 < b)%R /\
(r < r0)%R /\
(forall x : R,
 (a < x)%R ->
 (x < b)%R -> x <> r -> x <> r0 -> v r < v x) apply split_couple_eq in ft as [ft ft0].
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
r, r0:R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
n:~ (u first_index <= u second_index)%R
ft:u second_index = r
ft0:u first_index = r0
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> second_index < v x
(a < r)%R /\
(r < b)%R /\
(a < r0)%R /\
(r0 < b)%R /\
(r < r0)%R /\
(forall x : R,
 (a < x)%R ->
 (x < b)%R -> x <> r -> x <> r0 -> v r < v x) subst.
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
n:~ (u first_index <= u second_index)%R
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> second_index < v x
(a < u second_index)%R /\
(u second_index < b)%R /\
(a < u first_index)%R /\
(u first_index < b)%R /\
(u second_index < u first_index)%R /\
(forall x : R,
 (a < x)%R ->
 (x < b)%R ->
 x <> u second_index ->
 x <> u first_index -> v (u second_index) < v x) split.
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
n:~ (u first_index <= u second_index)%R
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> second_index < v x
(a < u second_index)%R
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
n:~ (u first_index <= u second_index)%R
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> second_index < v x
(u second_index < b)%R /\
(a < u first_index)%R /\
(u first_index < b)%R /\
(u second_index < u first_index)%R /\
(forall x : R,
 (a < x)%R ->
 (x < b)%R ->
 x <> u second_index ->
 x <> u first_index -> v (u second_index) < v x) assumption.
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
n:~ (u first_index <= u second_index)%R
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> second_index < v x
(u second_index < b)%R /\
(a < u first_index)%R /\
(u first_index < b)%R /\
(u second_index < u first_index)%R /\
(forall x : R,
 (a < x)%R ->
 (x < b)%R ->
 x <> u second_index ->
 x <> u first_index -> v (u second_index) < v x)
    split.
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
n:~ (u first_index <= u second_index)%R
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> second_index < v x
(u second_index < b)%R
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
n:~ (u first_index <= u second_index)%R
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> second_index < v x
(a < u first_index)%R /\
(u first_index < b)%R /\
(u second_index < u first_index)%R /\
(forall x : R,
 (a < x)%R ->
 (x < b)%R ->
 x <> u second_index ->
 x <> u first_index -> v (u second_index) < v x) assumption.
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
n:~ (u first_index <= u second_index)%R
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> second_index < v x
(a < u first_index)%R /\
(u first_index < b)%R /\
(u second_index < u first_index)%R /\
(forall x : R,
 (a < x)%R ->
 (x < b)%R ->
 x <> u second_index ->
 x <> u first_index -> v (u second_index) < v x) split.
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
n:~ (u first_index <= u second_index)%R
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> second_index < v x
(a < u first_index)%R
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
n:~ (u first_index <= u second_index)%R
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> second_index < v x
(u first_index < b)%R /\
(u second_index < u first_index)%R /\
(forall x : R,
 (a < x)%R ->
 (x < b)%R ->
 x <> u second_index ->
 x <> u first_index -> v (u second_index) < v x) assumption.
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
n:~ (u first_index <= u second_index)%R
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> second_index < v x
(u first_index < b)%R /\
(u second_index < u first_index)%R /\
(forall x : R,
 (a < x)%R ->
 (x < b)%R ->
 x <> u second_index ->
 x <> u first_index -> v (u second_index) < v x) split.
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
n:~ (u first_index <= u second_index)%R
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> second_index < v x
(u first_index < b)%R
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
n:~ (u first_index <= u second_index)%R
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> second_index < v x
(u second_index < u first_index)%R /\
(forall x : R,
 (a < x)%R ->
 (x < b)%R ->
 x <> u second_index ->
 x <> u first_index -> v (u second_index) < v x) assumption.
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
n:~ (u first_index <= u second_index)%R
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> second_index < v x
(u second_index < u first_index)%R /\
(forall x : R,
 (a < x)%R ->
 (x < b)%R ->
 x <> u second_index ->
 x <> u first_index -> v (u second_index) < v x) split.
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
n:~ (u first_index <= u second_index)%R
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> second_index < v x
(u second_index < u first_index)%R
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
n:~ (u first_index <= u second_index)%R
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> second_index < v x
forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u second_index ->
x <> u first_index -> v (u second_index) < v x
    apply Rnot_le_lt in n.
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
n:(u second_index < u first_index)%R
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> second_index < v x
(u second_index < u first_index)%R
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
n:~ (u first_index <= u second_index)%R
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> second_index < v x
forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u second_index ->
x <> u first_index -> v (u second_index) < v x assumption.
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
n:~ (u first_index <= u second_index)%R
H:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> b -> x <> u first_index -> first_index < v x
H0:forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u first_index ->
x <> u second_index -> second_index < v x
forall x : R,
(a < x)%R ->
(x < b)%R ->
x <> u second_index ->
x <> u first_index -> v (u second_index) < v x intros.
u:nat -> R
v:R -> nat
a, b:R
pen:enumeration R u v
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
n:~ (u first_index <= u second_index)%R
H:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> b ->
x0 <> u first_index -> first_index < v x0
H0:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> u first_index ->
x0 <> u second_index -> second_index < v x0
x:R
H9:(a < x)%R
H10:(x < b)%R
H11:x <> u second_index
H12:x <> u first_index
v (u second_index) < v x destruct pen.
u:nat -> R
v:R -> nat
a, b:R
H13:forall x0 : R, u (v x0) = x0
H14:forall n0 : nat, v (u n0) = n0
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
n:~ (u first_index <= u second_index)%R
H:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> b ->
x0 <> u first_index -> first_index < v x0
H0:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> u first_index ->
x0 <> u second_index -> second_index < v x0
x:R
H9:(a < x)%R
H10:(x < b)%R
H11:x <> u second_index
H12:x <> u first_index
v (u second_index) < v x rewrite -> H14.
u:nat -> R
v:R -> nat
a, b:R
H13:forall x0 : R, u (v x0) = x0
H14:forall n0 : nat, v (u n0) = n0
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
n:~ (u first_index <= u second_index)%R
H:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> b ->
x0 <> u first_index -> first_index < v x0
H0:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> u first_index ->
x0 <> u second_index -> second_index < v x0
x:R
H9:(a < x)%R
H10:(x < b)%R
H11:x <> u second_index
H12:x <> u first_index
second_index < v x
    apply H0.
u:nat -> R
v:R -> nat
a, b:R
H13:forall x0 : R, u (v x0) = x0
H14:forall n0 : nat, v (u n0) = n0
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
n:~ (u first_index <= u second_index)%R
H:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> b ->
x0 <> u first_index -> first_index < v x0
H0:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> u first_index ->
x0 <> u second_index -> second_index < v x0
x:R
H9:(a < x)%R
H10:(x < b)%R
H11:x <> u second_index
H12:x <> u first_index
(a < x)%R
u:nat -> R
v:R -> nat
a, b:R
H13:forall x0 : R, u (v x0) = x0
H14:forall n0 : nat, v (u n0) = n0
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
n:~ (u first_index <= u second_index)%R
H:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> b ->
x0 <> u first_index -> first_index < v x0
H0:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> u first_index ->
x0 <> u second_index -> second_index < v x0
x:R
H9:(a < x)%R
H10:(x < b)%R
H11:x <> u second_index
H12:x <> u first_index
(x < b)%R
u:nat -> R
v:R -> nat
a, b:R
H13:forall x0 : R, u (v x0) = x0
H14:forall n0 : nat, v (u n0) = n0
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
n:~ (u first_index <= u second_index)%R
H:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> b ->
x0 <> u first_index -> first_index < v x0
H0:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> u first_index ->
x0 <> u second_index -> second_index < v x0
x:R
H9:(a < x)%R
H10:(x < b)%R
H11:x <> u second_index
H12:x <> u first_index
x <> u first_index
u:nat -> R
v:R -> nat
a, b:R
H13:forall x0 : R, u (v x0) = x0
H14:forall n0 : nat, v (u n0) = n0
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
n:~ (u first_index <= u second_index)%R
H:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> b ->
x0 <> u first_index -> first_index < v x0
H0:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> u first_index ->
x0 <> u second_index -> second_index < v x0
x:R
H9:(a < x)%R
H10:(x < b)%R
H11:x <> u second_index
H12:x <> u first_index
x <> u second_index assumption.
u:nat -> R
v:R -> nat
a, b:R
H13:forall x0 : R, u (v x0) = x0
H14:forall n0 : nat, v (u n0) = n0
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
n:~ (u first_index <= u second_index)%R
H:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> b ->
x0 <> u first_index -> first_index < v x0
H0:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> u first_index ->
x0 <> u second_index -> second_index < v x0
x:R
H9:(a < x)%R
H10:(x < b)%R
H11:x <> u second_index
H12:x <> u first_index
(x < b)%R
u:nat -> R
v:R -> nat
a, b:R
H13:forall x0 : R, u (v x0) = x0
H14:forall n0 : nat, v (u n0) = n0
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
n:~ (u first_index <= u second_index)%R
H:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> b ->
x0 <> u first_index -> first_index < v x0
H0:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> u first_index ->
x0 <> u second_index -> second_index < v x0
x:R
H9:(a < x)%R
H10:(x < b)%R
H11:x <> u second_index
H12:x <> u first_index
x <> u first_index
u:nat -> R
v:R -> nat
a, b:R
H13:forall x0 : R, u (v x0) = x0
H14:forall n0 : nat, v (u n0) = n0
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
n:~ (u first_index <= u second_index)%R
H:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> b ->
x0 <> u first_index -> first_index < v x0
H0:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> u first_index ->
x0 <> u second_index -> second_index < v x0
x:R
H9:(a < x)%R
H10:(x < b)%R
H11:x <> u second_index
H12:x <> u first_index
x <> u second_index assumption.
u:nat -> R
v:R -> nat
a, b:R
H13:forall x0 : R, u (v x0) = x0
H14:forall n0 : nat, v (u n0) = n0
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
n:~ (u first_index <= u second_index)%R
H:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> b ->
x0 <> u first_index -> first_index < v x0
H0:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> u first_index ->
x0 <> u second_index -> second_index < v x0
x:R
H9:(a < x)%R
H10:(x < b)%R
H11:x <> u second_index
H12:x <> u first_index
x <> u first_index
u:nat -> R
v:R -> nat
a, b:R
H13:forall x0 : R, u (v x0) = x0
H14:forall n0 : nat, v (u n0) = n0
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
n:~ (u first_index <= u second_index)%R
H:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> b ->
x0 <> u first_index -> first_index < v x0
H0:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> u first_index ->
x0 <> u second_index -> second_index < v x0
x:R
H9:(a < x)%R
H10:(x < b)%R
H11:x <> u second_index
H12:x <> u first_index
x <> u second_index assumption.
u:nat -> R
v:R -> nat
a, b:R
H13:forall x0 : R, u (v x0) = x0
H14:forall n0 : nat, v (u n0) = n0
plow:(a < b)%R
first_index:nat
H1:(a < u first_index)%R
H3:(u first_index < b)%R
H4:u first_index <> b
H2:forall k : nat,
k < first_index -> ~ in_holed_interval a b b u k
second_index:nat
H5:(a < u second_index)%R
H7:(u second_index < b)%R
H8:u second_index <> u first_index
H6:forall k : nat,
k < second_index ->
~ in_holed_interval a b (u first_index) u k
n:~ (u first_index <= u second_index)%R
H:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> b ->
x0 <> u first_index -> first_index < v x0
H0:forall x0 : R,
(a < x0)%R ->
(x0 < b)%R ->
x0 <> u first_index ->
x0 <> u second_index -> second_index < v x0
x:R
H9:(a < x)%R
H10:(x < b)%R
H11:x <> u second_index
H12:x <> u first_index
x <> u second_index assumption.
Qed.

(* If u,v is an enumeration of R, this sequence of open intervals
   tears the segment [0,1]. The recursive definition needs the proof that the
   previous interval is ordered, hence the type.

   The first sequence is increasing, the second decreasing.
   The first is below the second.
   Therefore the first sequence has a limit, a least upper bound b, that u cannot reach,
   which contradicts u (v b) = b. *)
Definition tearing_sequences (u : nat -> R) (v : R -> nat)
  : (enumeration R u v) -> nat -> { ab : prod R R | Rlt (fst ab) (snd ab) }.
u:nat -> R
v:R -> nat
enumeration R u v ->
nat -> {ab : R * R | (fst ab < snd ab)%R}
Proof.
u:nat -> R
v:R -> nat
enumeration R u v ->
nat -> {ab : R * R | (fst ab < snd ab)%R}
  intro pen.
u:nat -> R
v:R -> nat
pen:enumeration R u v
nat -> {ab : R * R | (fst ab < snd ab)%R} apply nat_rec.
u:nat -> R
v:R -> nat
pen:enumeration R u v
{ab : R * R | (fst ab < snd ab)%R}
u:nat -> R
v:R -> nat
pen:enumeration R u v
nat ->
{ab : R * R | (fst ab < snd ab)%R} ->
{ab : R * R | (fst ab < snd ab)%R}
  -
u:nat -> R
v:R -> nat
pen:enumeration R u v
{ab : R * R | (fst ab < snd ab)%R} exists (INR 0, INR 1).
u:nat -> R
v:R -> nat
pen:enumeration R u v
(fst (INR 0, INR 1) < snd (INR 0, INR 1))%R simpl.
u:nat -> R
v:R -> nat
pen:enumeration R u v
(0 < 1)%R apply Rlt_0_1.
  -
u:nat -> R
v:R -> nat
pen:enumeration R u v
nat ->
{ab : R * R | (fst ab < snd ab)%R} ->
{ab : R * R | (fst ab < snd ab)%R} intros n [[a b] pr].
u:nat -> R
v:R -> nat
pen:enumeration R u v
n:nat
a, b:R
pr:(fst (a, b) < snd (a, b))%R
{ab : R * R | (fst ab < snd ab)%R} exists (first_two_in_interval u v a b pen pr).
u:nat -> R
v:R -> nat
pen:enumeration R u v
n:nat
a, b:R
pr:(fst (a, b) < snd (a, b))%R
(fst (first_two_in_interval u v a b pen pr) <
 snd (first_two_in_interval u v a b pen pr))%R
    pose proof (first_two_in_interval_works u v a b pen pr).
u:nat -> R
v:R -> nat
pen:enumeration R u v
n:nat
a, b:R
pr:(fst (a, b) < snd (a, b))%R
H:let (c, d) :=
  first_two_in_interval u v a b pen pr in
(a < c)%R /\
(c < b)%R /\
(a < d)%R /\
(d < b)%R /\
(c < d)%R /\
(forall x : R,
 (a < x)%R ->
 (x < b)%R -> x <> c -> x <> d -> v c < v x)
(fst (first_two_in_interval u v a b pen pr) <
 snd (first_two_in_interval u v a b pen pr))%R
    destruct (first_two_in_interval u v a b pen pr).
u:nat -> R
v:R -> nat
pen:enumeration R u v
n:nat
a, b:R
pr:(fst (a, b) < snd (a, b))%R
r, r0:R
H:(a < r)%R /\
(r < b)%R /\
(a < r0)%R /\
(r0 < b)%R /\
(r < r0)%R /\
(forall x : R,
 (a < x)%R ->
 (x < b)%R -> x <> r -> x <> r0 -> v r < v x)
(fst (r, r0) < snd (r, r0))%R apply H.
Defined.

Lemma tearing_sequences_projsig (u : nat -> R) (v : R -> nat) (en : enumeration R u v)
      (n : nat)
  : let (I,pr) := tearing_sequences u v en n in
    proj1_sig (tearing_sequences u v en (S n))
    = first_two_in_interval u v (fst I) (snd I) en pr.
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
let (I, pr) := tearing_sequences u v en n in
proj1_sig (tearing_sequences u v en (S n)) =
first_two_in_interval u v (fst I) (snd I) en pr
Proof.
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
let (I, pr) := tearing_sequences u v en n in
proj1_sig (tearing_sequences u v en (S n)) =
first_two_in_interval u v (fst I) (snd I) en pr
  simpl.
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
let (I, pr) := tearing_sequences u v en n in
proj1_sig
  (let (x, x0) := tearing_sequences u v en n in
   (let
      (a, b) as p
       return
         ((fst p < snd p)%R ->
          {ab : R * R | (fst ab < snd ab)%R}) := x in
    fun pr0 : (a < b)%R =>
    exist (fun ab : R * R => (fst ab < snd ab)%R)
      (first_two_in_interval u v a b en pr0)
      ((let
          (r, r0) as p
           return
             ((let (c, d) := p in
               (a < c)%R /\
               (c < b)%R /\
               (a < d)%R /\
               (d < b)%R /\ (...)%R /\ (...)) ->
              (fst p < snd p)%R) :=
          first_two_in_interval u v a b en pr0 in
        fun
          H : (a < r)%R /\
              (r < b)%R /\
              (a < r0)%R /\
              (r0 < b)%R /\
              (r < r0)%R /\
              (forall x0 : R,
               (a < x0)%R -> (...)%R -> ... -> ...) =>
        match
          match
            match ... with
            | conj _ H1 => H1
            end
          with
          | conj _ H1 => H1
          end
        with
        | conj H0 _ => H0
        end)
         (first_two_in_interval_works u v a b en pr0)))
     x0) =
first_two_in_interval u v (fst I) (snd I) en pr destruct (tearing_sequences u v en n) as [[a b] pr].
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
a, b:R
pr:(fst (a, b) < snd (a, b))%R
proj1_sig
  (exist (fun ab : R * R => (fst ab < snd ab)%R)
     (first_two_in_interval u v a b en pr)
     ((let
         (r, r0) as p
          return
            ((let (c, d) := p in
              (a < c)%R /\
              (c < b)%R /\
              (a < d)%R /\
              (d < b)%R /\
              (c < d)%R /\
              (forall x : R,
               (a < x)%R ->
               (x < b)%R ->
               x <> c -> x <> d -> ... < ...)) ->
             (fst p < snd p)%R) :=
         first_two_in_interval u v a b en pr in
       fun
         H : (a < r)%R /\
             (r < b)%R /\
             (a < r0)%R /\
             (r0 < b)%R /\
             (r < r0)%R /\
             (forall x : R,
              (a < x)%R ->
              (x < b)%R ->
              x <> r -> x <> r0 -> v r < v x) =>
       match
         match
           match
             match match ... with
                   | ... H1
                   end with
             | conj _ H1 => H1
             end
           with
           | conj _ H1 => H1
           end
         with
         | conj _ H1 => H1
         end
       with
       | conj H0 _ => H0
       end)
        (first_two_in_interval_works u v a b en pr))) =
first_two_in_interval u v (fst (a, b)) (snd (a, b)) en
  pr simpl.
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
a, b:R
pr:(fst (a, b) < snd (a, b))%R
first_two_in_interval u v a b en pr =
first_two_in_interval u v a b en pr reflexivity.
Qed.

(* The first tearing sequence in increasing, the second decreasing.
   That means the tearing sequences are nested intervals. *)
Lemma tearing_sequences_inc_dec (u : nat -> R) (v : R -> nat) (pen : enumeration R u v)
  : forall n : nat,
    let I := proj1_sig (tearing_sequences u v pen n) in
    let SI := proj1_sig (tearing_sequences u v pen (S n)) in
    Rlt (fst I) (fst SI) /\ Rlt (snd SI) (snd I).
u:nat -> R
v:R -> nat
pen:enumeration R u v
forall n : nat,
let I := proj1_sig (tearing_sequences u v pen n) in
let SI := proj1_sig (tearing_sequences u v pen (S n))
  in
(fst I < fst SI)%R /\ (snd SI < snd I)%R
Proof.
u:nat -> R
v:R -> nat
pen:enumeration R u v
forall n : nat,
let I := proj1_sig (tearing_sequences u v pen n) in
let SI := proj1_sig (tearing_sequences u v pen (S n))
  in
(fst I < fst SI)%R /\ (snd SI < snd I)%R
  intro n.
u:nat -> R
v:R -> nat
pen:enumeration R u v
n:nat
let I := proj1_sig (tearing_sequences u v pen n) in
let SI := proj1_sig (tearing_sequences u v pen (S n))
  in
(fst I < fst SI)%R /\ (snd SI < snd I)%R simpl.
u:nat -> R
v:R -> nat
pen:enumeration R u v
n:nat
(fst (proj1_sig (tearing_sequences u v pen n)) <
 fst
   (proj1_sig
      (let (x, x0) := tearing_sequences u v pen n in
       (let
          (a, b) as p
           return
             (fst p < snd p ->
              {ab : R * R | fst ab < snd ab}) := x in
        fun pr : a < b =>
        exist (fun ab : R * R => fst ab < snd ab)
          (first_two_in_interval u v a b pen pr)
          ((let
              (r, r0) as p
               return
                 ((let (c, d) := p in
                   a < c /\ c < b /\ ... /\ ...) ->
                  fst p < snd p) :=
              first_two_in_interval u v a b pen pr in
            fun
              H : a < r /\
                  r < b /\
                  a < r0 /\
                  r0 < b /\ r < r0 /\ (..., ...) =>
            match
              match ...
                    ...
                    end with
              | conj _ H1 => H1
              end
            with
            | conj H0 _ => H0
            end)
             (first_two_in_interval_works u v a b pen
                pr))) x0)))%R /\
(snd
   (proj1_sig
      (let (x, x0) := tearing_sequences u v pen n in
       (let
          (a, b) as p
           return
             (fst p < snd p ->
              {ab : R * R | fst ab < snd ab}) := x in
        fun pr : a < b =>
        exist (fun ab : R * R => fst ab < snd ab)
          (first_two_in_interval u v a b pen pr)
          ((let
              (r, r0) as p
               return
                 ((let (c, d) := p in
                   a < c /\ c < b /\ ... /\ ...) ->
                  fst p < snd p) :=
              first_two_in_interval u v a b pen pr in
            fun
              H : a < r /\
                  r < b /\
                  a < r0 /\
                  r0 < b /\ r < r0 /\ (..., ...) =>
            match
              match ...
                    ...
                    end with
              | conj _ H1 => H1
              end
            with
            | conj H0 _ => H0
            end)
             (first_two_in_interval_works u v a b pen
                pr))) x0)) <
 snd (proj1_sig (tearing_sequences u v pen n)))%R destruct (tearing_sequences u v pen n) as [[a b] pr].
u:nat -> R
v:R -> nat
pen:enumeration R u v
n:nat
a, b:R
pr:(fst (a, b) < snd (a, b))%R
(fst
   (proj1_sig
      (exist (fun ab : R * R => fst ab < snd ab)
         (a, b) pr)) <
 fst
   (proj1_sig
      (exist (fun ab : R * R => fst ab < snd ab)
         (first_two_in_interval u v a b pen pr)
         ((let
             (r, r0) as p
              return
                ((let (c, d) := p in
                  a < c /\
                  c < b /\
                  a < d /\
                  d < b /\
                  c < d /\ (forall ..., ... -> ...)) ->
                 fst p < snd p) :=
             first_two_in_interval u v a b pen pr in
           fun
             H : a < r /\
                 r < b /\
                 a < r0 /\
                 r0 < b /\
                 r < r0 /\
                 (forall x : R,
                  a < x ->
                  x < b ->
                  x <> r -> x <> r0 -> (...)%nat) =>
           match
             match
               match match ... with
                     | ... H1
                     end with
               | conj _ H1 => H1
               end
             with
             | conj _ H1 => H1
             end
           with
           | conj H0 _ => H0
           end)
            (first_two_in_interval_works u v a b pen
               pr)))))%R /\
(snd
   (proj1_sig
      (exist (fun ab : R * R => fst ab < snd ab)
         (first_two_in_interval u v a b pen pr)
         ((let
             (r, r0) as p
              return
                ((let (c, d) := p in
                  a < c /\
                  c < b /\
                  a < d /\
                  d < b /\
                  c < d /\ (forall ..., ... -> ...)) ->
                 fst p < snd p) :=
             first_two_in_interval u v a b pen pr in
           fun
             H : a < r /\
                 r < b /\
                 a < r0 /\
                 r0 < b /\
                 r < r0 /\
                 (forall x : R,
                  a < x ->
                  x < b ->
                  x <> r -> x <> r0 -> (...)%nat) =>
           match
             match
               match match ... with
                     | ... H1
                     end with
               | conj _ H1 => H1
               end
             with
             | conj _ H1 => H1
             end
           with
           | conj H0 _ => H0
           end)
            (first_two_in_interval_works u v a b pen
               pr)))) <
 snd
   (proj1_sig
      (exist (fun ab : R * R => fst ab < snd ab)
         (a, b) pr)))%R
  simpl.
u:nat -> R
v:R -> nat
pen:enumeration R u v
n:nat
a, b:R
pr:(fst (a, b) < snd (a, b))%R
(a < fst (first_two_in_interval u v a b pen pr))%R /\
(snd (first_two_in_interval u v a b pen pr) < b)%R pose proof (first_two_in_interval_works u v a b pen pr).
u:nat -> R
v:R -> nat
pen:enumeration R u v
n:nat
a, b:R
pr:(fst (a, b) < snd (a, b))%R
H:let (c, d) :=
  first_two_in_interval u v a b pen pr in
(a < c)%R /\
(c < b)%R /\
(a < d)%R /\
(d < b)%R /\
(c < d)%R /\
(forall x : R,
 (a < x)%R ->
 (x < b)%R -> x <> c -> x <> d -> v c < v x)
(a < fst (first_two_in_interval u v a b pen pr))%R /\
(snd (first_two_in_interval u v a b pen pr) < b)%R
  destruct (first_two_in_interval u v a b pen pr).
u:nat -> R
v:R -> nat
pen:enumeration R u v
n:nat
a, b:R
pr:(fst (a, b) < snd (a, b))%R
r, r0:R
H:(a < r)%R /\
(r < b)%R /\
(a < r0)%R /\
(r0 < b)%R /\
(r < r0)%R /\
(forall x : R,
 (a < x)%R ->
 (x < b)%R -> x <> r -> x <> r0 -> v r < v x)
(a < fst (r, r0))%R /\ (snd (r, r0) < b)%R
  simpl.
u:nat -> R
v:R -> nat
pen:enumeration R u v
n:nat
a, b:R
pr:(fst (a, b) < snd (a, b))%R
r, r0:R
H:(a < r)%R /\
(r < b)%R /\
(a < r0)%R /\
(r0 < b)%R /\
(r < r0)%R /\
(forall x : R,
 (a < x)%R ->
 (x < b)%R -> x <> r -> x <> r0 -> v r < v x)
(a < r)%R /\ (r0 < b)%R split.
u:nat -> R
v:R -> nat
pen:enumeration R u v
n:nat
a, b:R
pr:(fst (a, b) < snd (a, b))%R
r, r0:R
H:(a < r)%R /\
(r < b)%R /\
(a < r0)%R /\
(r0 < b)%R /\
(r < r0)%R /\
(forall x : R,
 (a < x)%R ->
 (x < b)%R -> x <> r -> x <> r0 -> v r < v x)
(a < r)%R
u:nat -> R
v:R -> nat
pen:enumeration R u v
n:nat
a, b:R
pr:(fst (a, b) < snd (a, b))%R
r, r0:R
H:(a < r)%R /\
(r < b)%R /\
(a < r0)%R /\
(r0 < b)%R /\
(r < r0)%R /\
(forall x : R,
 (a < x)%R ->
 (x < b)%R -> x <> r -> x <> r0 -> v r < v x)
(r0 < b)%R destruct H.
u:nat -> R
v:R -> nat
pen:enumeration R u v
n:nat
a, b:R
pr:(fst (a, b) < snd (a, b))%R
r, r0:R
H:(a < r)%R
H0:(r < b)%R /\
(a < r0)%R /\
(r0 < b)%R /\
(r < r0)%R /\
(forall x : R,
 (a < x)%R ->
 (x < b)%R -> x <> r -> x <> r0 -> v r < v x)
(a < r)%R
u:nat -> R
v:R -> nat
pen:enumeration R u v
n:nat
a, b:R
pr:(fst (a, b) < snd (a, b))%R
r, r0:R
H:(a < r)%R /\
(r < b)%R /\
(a < r0)%R /\
(r0 < b)%R /\
(r < r0)%R /\
(forall x : R,
 (a < x)%R ->
 (x < b)%R -> x <> r -> x <> r0 -> v r < v x)
(r0 < b)%R assumption.
u:nat -> R
v:R -> nat
pen:enumeration R u v
n:nat
a, b:R
pr:(fst (a, b) < snd (a, b))%R
r, r0:R
H:(a < r)%R /\
(r < b)%R /\
(a < r0)%R /\
(r0 < b)%R /\
(r < r0)%R /\
(forall x : R,
 (a < x)%R ->
 (x < b)%R -> x <> r -> x <> r0 -> v r < v x)
(r0 < b)%R
  destruct H as [H1 [H2 [H3 [H4 H5]]]].
u:nat -> R
v:R -> nat
pen:enumeration R u v
n:nat
a, b:R
pr:(fst (a, b) < snd (a, b))%R
r, r0:R
H1:(a < r)%R
H2:(r < b)%R
H3:(a < r0)%R
H4:(r0 < b)%R
H5:(r < r0)%R /\
(forall x : R,
 (a < x)%R ->
 (x < b)%R -> x <> r -> x <> r0 -> v r < v x)
(r0 < b)%R assumption.
Qed.

Lemma split_lt_succ : forall n m : nat, lt n (S m) -> lt n m \/ n = m.
forall n m : nat, n < S m -> n < m \/ n = m
Proof.
forall n m : nat, n < S m -> n < m \/ n = m
  intros n m.
n, m:nat
n < S m -> n < m \/ n = m generalize dependent n.
m:nat
forall n : nat, n < S m -> n < m \/ n = m induction m.
forall n : nat, n < 1 -> n < 0 \/ n = 0
m:nat
IHm:forall n : nat, n < S m -> n < m \/ n = m
forall n : nat, n < S (S m) -> n < S m \/ n = S m
  -
forall n : nat, n < 1 -> n < 0 \/ n = 0 intros.
n:nat
H:n < 1
n < 0 \/ n = 0 destruct n.
H:0 < 1
0 < 0 \/ 0 = 0
n:nat
H:S n < 1
S n < 0 \/ S n = 0 right.
H:0 < 1
0 = 0
n:nat
H:S n < 1
S n < 0 \/ S n = 0 reflexivity.
n:nat
H:S n < 1
S n < 0 \/ S n = 0 exfalso.
n:nat
H:S n < 1
False inversion H.
n:nat
H:S n < 1
m:nat
H1:S (S n) <= 0
H0:m = 0
False inversion H1.
  -
m:nat
IHm:forall n : nat, n < S m -> n < m \/ n = m
forall n : nat, n < S (S m) -> n < S m \/ n = S m intros.
m:nat
IHm:forall n0 : nat, n0 < S m -> n0 < m \/ n0 = m
n:nat
H:n < S (S m)
n < S m \/ n = S m destruct n.
m:nat
IHm:forall n : nat, n < S m -> n < m \/ n = m
H:0 < S (S m)
0 < S m \/ 0 = S m
m:nat
IHm:forall n0 : nat, n0 < S m -> n0 < m \/ n0 = m
n:nat
H:S n < S (S m)
S n < S m \/ S n = S m left.
m:nat
IHm:forall n : nat, n < S m -> n < m \/ n = m
H:0 < S (S m)
0 < S m
m:nat
IHm:forall n0 : nat, n0 < S m -> n0 < m \/ n0 = m
n:nat
H:S n < S (S m)
S n < S m \/ S n = S m unfold lt.
m:nat
IHm:forall n : nat, n < S m -> n < m \/ n = m
H:0 < S (S m)
1 <= S m
m:nat
IHm:forall n0 : nat, n0 < S m -> n0 < m \/ n0 = m
n:nat
H:S n < S (S m)
S n < S m \/ S n = S m apply le_n_S.
m:nat
IHm:forall n : nat, n < S m -> n < m \/ n = m
H:0 < S (S m)
0 <= m
m:nat
IHm:forall n0 : nat, n0 < S m -> n0 < m \/ n0 = m
n:nat
H:S n < S (S m)
S n < S m \/ S n = S m apply le_0_n.
m:nat
IHm:forall n0 : nat, n0 < S m -> n0 < m \/ n0 = m
n:nat
H:S n < S (S m)
S n < S m \/ S n = S m
    apply lt_pred in H.
m:nat
IHm:forall n0 : nat, n0 < S m -> n0 < m \/ n0 = m
n:nat
H:n < Init.Nat.pred (S (S m))
S n < S m \/ S n = S m simpl in H.
m:nat
IHm:forall n0 : nat, n0 < S m -> n0 < m \/ n0 = m
n:nat
H:n < S m
S n < S m \/ S n = S m specialize (IHm n H).
m, n:nat
IHm:n < m \/ n = m
H:n < S m
S n < S m \/ S n = S m destruct IHm.
m, n:nat
H0:n < m
H:n < S m
S n < S m \/ S n = S m
m, n:nat
H0:n = m
H:n < S m
S n < S m \/ S n = S m left.
m, n:nat
H0:n < m
H:n < S m
S n < S m
m, n:nat
H0:n = m
H:n < S m
S n < S m \/ S n = S m apply lt_n_S.
m, n:nat
H0:n < m
H:n < S m
n < m
m, n:nat
H0:n = m
H:n < S m
S n < S m \/ S n = S m assumption.
m, n:nat
H0:n = m
H:n < S m
S n < S m \/ S n = S m
    subst.
m:nat
H:m < S m
S m < S m \/ S m = S m right.
m:nat
H:m < S m
S m = S m reflexivity.
Qed.

Lemma increase_seq_transit (u : nat -> R) :
  (forall n : nat, Rlt (u n) (u (S n))) -> (forall n m : nat, n < m -> Rlt (u n) (u m)).
u:nat -> R
(forall n : nat, (u n < u (S n))%R) ->
forall n m : nat, n < m -> (u n < u m)%R
Proof.
u:nat -> R
(forall n : nat, (u n < u (S n))%R) ->
forall n m : nat, n < m -> (u n < u m)%R
  intros.
u:nat -> R
H:forall n0 : nat, (u n0 < u (S n0))%R
n, m:nat
H0:n < m
(u n < u m)%R induction m.
u:nat -> R
H:forall n0 : nat, (u n0 < u (S n0))%R
n:nat
H0:n < 0
(u n < u 0%nat)%R
u:nat -> R
H:forall n0 : nat, (u n0 < u (S n0))%R
n, m:nat
H0:n < S m
IHm:n < m -> (u n < u m)%R
(u n < u (S m))%R
  -
u:nat -> R
H:forall n0 : nat, (u n0 < u (S n0))%R
n:nat
H0:n < 0
(u n < u 0%nat)%R intros.
u:nat -> R
H:forall n0 : nat, (u n0 < u (S n0))%R
n:nat
H0:n < 0
(u n < u 0%nat)%R inversion H0.
  -
u:nat -> R
H:forall n0 : nat, (u n0 < u (S n0))%R
n, m:nat
H0:n < S m
IHm:n < m -> (u n < u m)%R
(u n < u (S m))%R intros.
u:nat -> R
H:forall n0 : nat, (u n0 < u (S n0))%R
n, m:nat
H0:n < S m
IHm:n < m -> (u n < u m)%R
(u n < u (S m))%R destruct (split_lt_succ n m H0).
u:nat -> R
H:forall n0 : nat, (u n0 < u (S n0))%R
n, m:nat
H0:n < S m
IHm:n < m -> (u n < u m)%R
H1:n < m
(u n < u (S m))%R
u:nat -> R
H:forall n0 : nat, (u n0 < u (S n0))%R
n, m:nat
H0:n < S m
IHm:n < m -> (u n < u m)%R
H1:n = m
(u n < u (S m))%R
    +
u:nat -> R
H:forall n0 : nat, (u n0 < u (S n0))%R
n, m:nat
H0:n < S m
IHm:n < m -> (u n < u m)%R
H1:n < m
(u n < u (S m))%R apply (Rlt_trans (u n) (u m)).
u:nat -> R
H:forall n0 : nat, (u n0 < u (S n0))%R
n, m:nat
H0:n < S m
IHm:n < m -> (u n < u m)%R
H1:n < m
(u n < u m)%R
u:nat -> R
H:forall n0 : nat, (u n0 < u (S n0))%R
n, m:nat
H0:n < S m
IHm:n < m -> (u n < u m)%R
H1:n < m
(u m < u (S m))%R apply IHm.
u:nat -> R
H:forall n0 : nat, (u n0 < u (S n0))%R
n, m:nat
H0:n < S m
IHm:n < m -> (u n < u m)%R
H1:n < m
n < m
u:nat -> R
H:forall n0 : nat, (u n0 < u (S n0))%R
n, m:nat
H0:n < S m
IHm:n < m -> (u n < u m)%R
H1:n < m
(u m < u (S m))%R assumption.
u:nat -> R
H:forall n0 : nat, (u n0 < u (S n0))%R
n, m:nat
H0:n < S m
IHm:n < m -> (u n < u m)%R
H1:n < m
(u m < u (S m))%R apply H.
    +
u:nat -> R
H:forall n0 : nat, (u n0 < u (S n0))%R
n, m:nat
H0:n < S m
IHm:n < m -> (u n < u m)%R
H1:n = m
(u n < u (S m))%R subst.
u:nat -> R
H:forall n : nat, (u n < u (S n))%R
m:nat
IHm:m < m -> (u m < u m)%R
H0:m < S m
(u m < u (S m))%R apply H.
Qed.

Lemma decrease_seq_transit (u : nat -> R) :
  (forall n : nat, Rlt (u (S n)) (u n)) -> (forall n m : nat, n < m -> Rlt (u m) (u n)).
u:nat -> R
(forall n : nat, (u (S n) < u n)%R) ->
forall n m : nat, n < m -> (u m < u n)%R
Proof.
u:nat -> R
(forall n : nat, (u (S n) < u n)%R) ->
forall n m : nat, n < m -> (u m < u n)%R
  intros.
u:nat -> R
H:forall n0 : nat, (u (S n0) < u n0)%R
n, m:nat
H0:n < m
(u m < u n)%R induction m.
u:nat -> R
H:forall n0 : nat, (u (S n0) < u n0)%R
n:nat
H0:n < 0
(u 0%nat < u n)%R
u:nat -> R
H:forall n0 : nat, (u (S n0) < u n0)%R
n, m:nat
H0:n < S m
IHm:n < m -> (u m < u n)%R
(u (S m) < u n)%R
  -
u:nat -> R
H:forall n0 : nat, (u (S n0) < u n0)%R
n:nat
H0:n < 0
(u 0%nat < u n)%R intros.
u:nat -> R
H:forall n0 : nat, (u (S n0) < u n0)%R
n:nat
H0:n < 0
(u 0%nat < u n)%R inversion H0.
  -
u:nat -> R
H:forall n0 : nat, (u (S n0) < u n0)%R
n, m:nat
H0:n < S m
IHm:n < m -> (u m < u n)%R
(u (S m) < u n)%R intros.
u:nat -> R
H:forall n0 : nat, (u (S n0) < u n0)%R
n, m:nat
H0:n < S m
IHm:n < m -> (u m < u n)%R
(u (S m) < u n)%R destruct (split_lt_succ n m H0).
u:nat -> R
H:forall n0 : nat, (u (S n0) < u n0)%R
n, m:nat
H0:n < S m
IHm:n < m -> (u m < u n)%R
H1:n < m
(u (S m) < u n)%R
u:nat -> R
H:forall n0 : nat, (u (S n0) < u n0)%R
n, m:nat
H0:n < S m
IHm:n < m -> (u m < u n)%R
H1:n = m
(u (S m) < u n)%R
    +
u:nat -> R
H:forall n0 : nat, (u (S n0) < u n0)%R
n, m:nat
H0:n < S m
IHm:n < m -> (u m < u n)%R
H1:n < m
(u (S m) < u n)%R apply (Rlt_trans (u (S m)) (u m)).
u:nat -> R
H:forall n0 : nat, (u (S n0) < u n0)%R
n, m:nat
H0:n < S m
IHm:n < m -> (u m < u n)%R
H1:n < m
(u (S m) < u m)%R
u:nat -> R
H:forall n0 : nat, (u (S n0) < u n0)%R
n, m:nat
H0:n < S m
IHm:n < m -> (u m < u n)%R
H1:n < m
(u m < u n)%R apply H.
u:nat -> R
H:forall n0 : nat, (u (S n0) < u n0)%R
n, m:nat
H0:n < S m
IHm:n < m -> (u m < u n)%R
H1:n < m
(u m < u n)%R apply IHm.
u:nat -> R
H:forall n0 : nat, (u (S n0) < u n0)%R
n, m:nat
H0:n < S m
IHm:n < m -> (u m < u n)%R
H1:n < m
n < m assumption.
    +
u:nat -> R
H:forall n0 : nat, (u (S n0) < u n0)%R
n, m:nat
H0:n < S m
IHm:n < m -> (u m < u n)%R
H1:n = m
(u (S m) < u n)%R subst.
u:nat -> R
H:forall n : nat, (u (S n) < u n)%R
m:nat
IHm:m < m -> (u m < u m)%R
H0:m < S m
(u (S m) < u m)%R apply H.
Qed.

(* Either increase the first sequence, or decrease the second sequence,
   until n = m and conclude by tearing_sequences_ordered *)
Lemma tearing_sequences_ordered_forall (u : nat -> R) (v : R -> nat)
      (pen : enumeration R u v) :
  forall n m : nat, let In := proj1_sig (tearing_sequences u v pen n) in
             let Im := proj1_sig (tearing_sequences u v pen m) in
             Rlt (fst In) (snd Im).
u:nat -> R
v:R -> nat
pen:enumeration R u v
forall n m : nat,
let In := proj1_sig (tearing_sequences u v pen n) in
let Im := proj1_sig (tearing_sequences u v pen m) in
(fst In < snd Im)%R
Proof.
u:nat -> R
v:R -> nat
pen:enumeration R u v
forall n m : nat,
let In := proj1_sig (tearing_sequences u v pen n) in
let Im := proj1_sig (tearing_sequences u v pen m) in
(fst In < snd Im)%R
  intros.
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
In:=proj1_sig (tearing_sequences u v pen n):(R * R)%type
Im:=proj1_sig (tearing_sequences u v pen m):(R * R)%type
(fst In < snd Im)%R destruct (tearing_sequences u v pen n) eqn:tn.
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=proj1_sig
  (exist (fun ab : R * R => (fst ab < snd ab)%R) x
     r):(R * R)%type
Im:=proj1_sig (tearing_sequences u v pen m):(R * R)%type
(fst In < snd Im)%R simpl in In.
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
Im:=proj1_sig (tearing_sequences u v pen m):(R * R)%type
(fst In < snd Im)%R
  destruct (tearing_sequences u v pen m) eqn:tm.
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=proj1_sig
  (exist (fun ab : R * R => (fst ab < snd ab)%R)
     x0 r0):(R * R)%type
(fst In < snd Im)%R simpl in Im.
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
(fst In < snd Im)%R
  destruct (n ?= m) eqn:order.
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:(n ?= m) = Eq
(fst In < snd Im)%R
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:(n ?= m) = Lt
(fst In < snd Im)%R
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:(n ?= m) = Gt
(fst In < snd Im)%R
  -
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:(n ?= m) = Eq
(fst In < snd Im)%R apply Nat.compare_eq_iff in order.
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:n = m
(fst In < snd Im)%R subst.
u:nat -> R
v:R -> nat
pen:enumeration R u v
m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
(fst In < snd Im)%R rewrite -> tm in tn.
u:nat -> R
v:R -> nat
pen:enumeration R u v
m:nat
x:(R * R)%type
r:(fst x < snd x)%R
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tn:exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0 =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
(fst In < snd Im)%R
    inversion tn.
u:nat -> R
v:R -> nat
pen:enumeration R u v
m:nat
x:(R * R)%type
r:(fst x < snd x)%R
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tn:exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0 =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
H0:x0 = x
(fst In < snd Im)%R subst.
u:nat -> R
v:R -> nat
pen:enumeration R u v
m:nat
x:(R * R)%type
r, r0:(fst x < snd x)%R
tn:exist (fun ab : R * R => (fst ab < snd ab)%R) x
  r0 =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In, Im:=x:(R * R)%type
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x
  r0
(fst In < snd Im)%R assumption.
  -
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:(n ?= m) = Lt
(fst In < snd Im)%R apply Nat.compare_lt_iff in order. (* increase first sequence *)
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:n < m
(fst In < snd Im)%R
    apply (Rlt_trans (fst In) (fst Im)).
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:n < m
(fst In < fst Im)%R
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:n < m
(fst Im < snd Im)%R
    remember (fun n => fst (proj1_sig (tearing_sequences u v pen n))) as fseq.
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:n < m
fseq:nat -> R
Heqfseq:fseq =
(fun n0 : nat =>
 fst
   (proj1_sig (tearing_sequences u v pen n0)))
(fst In < fst Im)%R
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:n < m
(fst Im < snd Im)%R
    pose proof (increase_seq_transit fseq).
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:n < m
fseq:nat -> R
Heqfseq:fseq =
(fun n0 : nat =>
 fst
   (proj1_sig (tearing_sequences u v pen n0)))
H:(forall n0 : nat, (fseq n0 < fseq (S n0))%R) ->
forall n0 m0 : nat,
n0 < m0 -> (fseq n0 < fseq m0)%R
(fst In < fst Im)%R
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:n < m
(fst Im < snd Im)%R
    assert ((forall n : nat, (fseq n < fseq (S n))%R)).
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:n < m
fseq:nat -> R
Heqfseq:fseq =
(fun n0 : nat =>
 fst
   (proj1_sig (tearing_sequences u v pen n0)))
H:(forall n0 : nat, (fseq n0 < fseq (S n0))%R) ->
forall n0 m0 : nat,
n0 < m0 -> (fseq n0 < fseq m0)%R
forall n0 : nat, (fseq n0 < fseq (S n0))%R
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:n < m
fseq:nat -> R
Heqfseq:fseq =
(fun n0 : nat =>
 fst
   (proj1_sig (tearing_sequences u v pen n0)))
H:(forall n0 : nat, (fseq n0 < fseq (S n0))%R) ->
forall n0 m0 : nat,
n0 < m0 -> (fseq n0 < fseq m0)%R
H0:forall n0 : nat, (fseq n0 < fseq (S n0))%R
(fst In < fst Im)%R
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:n < m
(fst Im < snd Im)%R
    {
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:n < m
fseq:nat -> R
Heqfseq:fseq =
(fun n0 : nat =>
 fst
   (proj1_sig (tearing_sequences u v pen n0)))
H:(forall n0 : nat, (fseq n0 < fseq (S n0))%R) ->
forall n0 m0 : nat,
n0 < m0 -> (fseq n0 < fseq m0)%R
forall n0 : nat, (fseq n0 < fseq (S n0))%R intro n0.
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:n < m
fseq:nat -> R
Heqfseq:fseq =
(fun n1 : nat =>
 fst
   (proj1_sig (tearing_sequences u v pen n1)))
H:(forall n1 : nat, (fseq n1 < fseq (S n1))%R) ->
forall n1 m0 : nat,
n1 < m0 -> (fseq n1 < fseq m0)%R
n0:nat
(fseq n0 < fseq (S n0))%R rewrite -> Heqfseq.
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:n < m
fseq:nat -> R
Heqfseq:fseq =
(fun n1 : nat =>
 fst
   (proj1_sig (tearing_sequences u v pen n1)))
H:(forall n1 : nat, (fseq n1 < fseq (S n1))%R) ->
forall n1 m0 : nat,
n1 < m0 -> (fseq n1 < fseq m0)%R
n0:nat
(fst (proj1_sig (tearing_sequences u v pen n0)) <
 fst (proj1_sig (tearing_sequences u v pen (S n0))))%R pose proof (tearing_sequences_inc_dec u v pen n0).
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:n < m
fseq:nat -> R
Heqfseq:fseq =
(fun n1 : nat =>
 fst
   (proj1_sig (tearing_sequences u v pen n1)))
H:(forall n1 : nat, (fseq n1 < fseq (S n1))%R) ->
forall n1 m0 : nat,
n1 < m0 -> (fseq n1 < fseq m0)%R
n0:nat
H0:let I := proj1_sig (tearing_sequences u v pen n0)
  in
let SI :=
  proj1_sig (tearing_sequences u v pen (S n0)) in
(fst I < fst SI)%R /\ (snd SI < snd I)%R
(fst (proj1_sig (tearing_sequences u v pen n0)) <
 fst (proj1_sig (tearing_sequences u v pen (S n0))))%R
      destruct (tearing_sequences u v pen (S n0)).
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:n < m
fseq:nat -> R
Heqfseq:fseq =
(fun n1 : nat =>
 fst
   (proj1_sig (tearing_sequences u v pen n1)))
H:(forall n1 : nat, (fseq n1 < fseq (S n1))%R) ->
forall n1 m0 : nat,
n1 < m0 -> (fseq n1 < fseq m0)%R
n0:nat
x1:(R * R)%type
r1:(fst x1 < snd x1)%R
H0:let I := proj1_sig (tearing_sequences u v pen n0)
  in
let SI :=
  proj1_sig
    (exist
       (fun ab : R * R => (fst ab < snd ab)%R) x1
       r1) in
(fst I < fst SI)%R /\ (snd SI < snd I)%R
(fst (proj1_sig (tearing_sequences u v pen n0)) <
 fst
   (proj1_sig
      (exist (fun ab : R * R => fst ab < snd ab) x1 r1)))%R simpl.
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:n < m
fseq:nat -> R
Heqfseq:fseq =
(fun n1 : nat =>
 fst
   (proj1_sig (tearing_sequences u v pen n1)))
H:(forall n1 : nat, (fseq n1 < fseq (S n1))%R) ->
forall n1 m0 : nat,
n1 < m0 -> (fseq n1 < fseq m0)%R
n0:nat
x1:(R * R)%type
r1:(fst x1 < snd x1)%R
H0:let I := proj1_sig (tearing_sequences u v pen n0)
  in
let SI :=
  proj1_sig
    (exist
       (fun ab : R * R => (fst ab < snd ab)%R) x1
       r1) in
(fst I < fst SI)%R /\ (snd SI < snd I)%R
(fst (proj1_sig (tearing_sequences u v pen n0)) <
 fst x1)%R
      destruct ((tearing_sequences u v pen n0)).
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:n < m
fseq:nat -> R
Heqfseq:fseq =
(fun n1 : nat =>
 fst
   (proj1_sig (tearing_sequences u v pen n1)))
H:(forall n1 : nat, (fseq n1 < fseq (S n1))%R) ->
forall n1 m0 : nat,
n1 < m0 -> (fseq n1 < fseq m0)%R
n0:nat
x1:(R * R)%type
r1:(fst x1 < snd x1)%R
x2:(R * R)%type
r2:(fst x2 < snd x2)%R
H0:let I :=
  proj1_sig
    (exist
       (fun ab : R * R => (fst ab < snd ab)%R) x2
       r2) in
let SI :=
  proj1_sig
    (exist
       (fun ab : R * R => (fst ab < snd ab)%R) x1
       r1) in
(fst I < fst SI)%R /\ (snd SI < snd I)%R
(fst
   (proj1_sig
      (exist (fun ab : R * R => fst ab < snd ab) x2 r2)) <
 fst x1)%R apply H0. }
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:n < m
fseq:nat -> R
Heqfseq:fseq =
(fun n0 : nat =>
 fst
   (proj1_sig (tearing_sequences u v pen n0)))
H:(forall n0 : nat, (fseq n0 < fseq (S n0))%R) ->
forall n0 m0 : nat,
n0 < m0 -> (fseq n0 < fseq m0)%R
H0:forall n0 : nat, (fseq n0 < fseq (S n0))%R
(fst In < fst Im)%R
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:n < m
(fst Im < snd Im)%R
    specialize (H H0).
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:n < m
fseq:nat -> R
Heqfseq:fseq =
(fun n0 : nat =>
 fst
   (proj1_sig (tearing_sequences u v pen n0)))
H:forall n0 m0 : nat,
n0 < m0 -> (fseq n0 < fseq m0)%R
H0:forall n0 : nat, (fseq n0 < fseq (S n0))%R
(fst In < fst Im)%R
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:n < m
(fst Im < snd Im)%R rewrite -> Heqfseq in H.
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:n < m
fseq:nat -> R
Heqfseq:fseq =
(fun n0 : nat =>
 fst
   (proj1_sig (tearing_sequences u v pen n0)))
H:forall n0 m0 : nat,
n0 < m0 ->
(fst (proj1_sig (tearing_sequences u v pen n0)) <
 fst (proj1_sig (tearing_sequences u v pen m0)))%R
H0:forall n0 : nat, (fseq n0 < fseq (S n0))%R
(fst In < fst Im)%R
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:n < m
(fst Im < snd Im)%R specialize (H n m order).
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:n < m
fseq:nat -> R
Heqfseq:fseq =
(fun n0 : nat =>
 fst
   (proj1_sig (tearing_sequences u v pen n0)))
H:(fst (proj1_sig (tearing_sequences u v pen n)) <
 fst (proj1_sig (tearing_sequences u v pen m)))%R
H0:forall n0 : nat, (fseq n0 < fseq (S n0))%R
(fst In < fst Im)%R
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:n < m
(fst Im < snd Im)%R
    rewrite -> tn in H.
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:n < m
fseq:nat -> R
Heqfseq:fseq =
(fun n0 : nat =>
 fst
   (proj1_sig (tearing_sequences u v pen n0)))
H:(fst
   (proj1_sig
      (exist (fun ab : R * R => fst ab < snd ab) x
         r)) <
 fst (proj1_sig (tearing_sequences u v pen m)))%R
H0:forall n0 : nat, (fseq n0 < fseq (S n0))%R
(fst In < fst Im)%R
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:n < m
(fst Im < snd Im)%R rewrite -> tm in H.
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:n < m
fseq:nat -> R
Heqfseq:fseq =
(fun n0 : nat =>
 fst
   (proj1_sig (tearing_sequences u v pen n0)))
H:(fst
   (proj1_sig
      (exist (fun ab : R * R => fst ab < snd ab) x
         r)) <
 fst
   (proj1_sig
      (exist (fun ab : R * R => fst ab < snd ab)
         x0 r0)))%R
H0:forall n0 : nat, (fseq n0 < fseq (S n0))%R
(fst In < fst Im)%R
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:n < m
(fst Im < snd Im)%R simpl in H.
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:n < m
fseq:nat -> R
Heqfseq:fseq =
(fun n0 : nat =>
 fst
   (proj1_sig (tearing_sequences u v pen n0)))
H:(fst x < fst x0)%R
H0:forall n0 : nat, (fseq n0 < fseq (S n0))%R
(fst In < fst Im)%R
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:n < m
(fst Im < snd Im)%R apply H.
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:n < m
(fst Im < snd Im)%R assumption.
  -
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:(n ?= m) = Gt
(fst In < snd Im)%R apply Nat.compare_gt_iff in order. (* decrease second sequence *)
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:m < n
(fst In < snd Im)%R
    apply (Rlt_trans (fst In) (snd In)).
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:m < n
(fst In < snd In)%R
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:m < n
(snd In < snd Im)%R assumption.
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:m < n
(snd In < snd Im)%R
    remember (fun n => snd (proj1_sig (tearing_sequences u v pen n))) as sseq.
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:m < n
sseq:nat -> R
Heqsseq:sseq =
(fun n0 : nat =>
 snd
   (proj1_sig (tearing_sequences u v pen n0)))
(snd In < snd Im)%R
    pose proof (decrease_seq_transit sseq).
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:m < n
sseq:nat -> R
Heqsseq:sseq =
(fun n0 : nat =>
 snd
   (proj1_sig (tearing_sequences u v pen n0)))
H:(forall n0 : nat, (sseq (S n0) < sseq n0)%R) ->
forall n0 m0 : nat,
n0 < m0 -> (sseq m0 < sseq n0)%R
(snd In < snd Im)%R
    assert ((forall n : nat, (sseq (S n) < sseq n)%R)).
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:m < n
sseq:nat -> R
Heqsseq:sseq =
(fun n0 : nat =>
 snd
   (proj1_sig (tearing_sequences u v pen n0)))
H:(forall n0 : nat, (sseq (S n0) < sseq n0)%R) ->
forall n0 m0 : nat,
n0 < m0 -> (sseq m0 < sseq n0)%R
forall n0 : nat, (sseq (S n0) < sseq n0)%R
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:m < n
sseq:nat -> R
Heqsseq:sseq =
(fun n0 : nat =>
 snd
   (proj1_sig (tearing_sequences u v pen n0)))
H:(forall n0 : nat, (sseq (S n0) < sseq n0)%R) ->
forall n0 m0 : nat,
n0 < m0 -> (sseq m0 < sseq n0)%R
H0:forall n0 : nat, (sseq (S n0) < sseq n0)%R
(snd In < snd Im)%R
    {
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:m < n
sseq:nat -> R
Heqsseq:sseq =
(fun n0 : nat =>
 snd
   (proj1_sig (tearing_sequences u v pen n0)))
H:(forall n0 : nat, (sseq (S n0) < sseq n0)%R) ->
forall n0 m0 : nat,
n0 < m0 -> (sseq m0 < sseq n0)%R
forall n0 : nat, (sseq (S n0) < sseq n0)%R intro n0.
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:m < n
sseq:nat -> R
Heqsseq:sseq =
(fun n1 : nat =>
 snd
   (proj1_sig (tearing_sequences u v pen n1)))
H:(forall n1 : nat, (sseq (S n1) < sseq n1)%R) ->
forall n1 m0 : nat,
n1 < m0 -> (sseq m0 < sseq n1)%R
n0:nat
(sseq (S n0) < sseq n0)%R rewrite -> Heqsseq.
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:m < n
sseq:nat -> R
Heqsseq:sseq =
(fun n1 : nat =>
 snd
   (proj1_sig (tearing_sequences u v pen n1)))
H:(forall n1 : nat, (sseq (S n1) < sseq n1)%R) ->
forall n1 m0 : nat,
n1 < m0 -> (sseq m0 < sseq n1)%R
n0:nat
(snd (proj1_sig (tearing_sequences u v pen (S n0))) <
 snd (proj1_sig (tearing_sequences u v pen n0)))%R pose proof (tearing_sequences_inc_dec u v pen n0).
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:m < n
sseq:nat -> R
Heqsseq:sseq =
(fun n1 : nat =>
 snd
   (proj1_sig (tearing_sequences u v pen n1)))
H:(forall n1 : nat, (sseq (S n1) < sseq n1)%R) ->
forall n1 m0 : nat,
n1 < m0 -> (sseq m0 < sseq n1)%R
n0:nat
H0:let I := proj1_sig (tearing_sequences u v pen n0)
  in
let SI :=
  proj1_sig (tearing_sequences u v pen (S n0)) in
(fst I < fst SI)%R /\ (snd SI < snd I)%R
(snd (proj1_sig (tearing_sequences u v pen (S n0))) <
 snd (proj1_sig (tearing_sequences u v pen n0)))%R
      destruct (tearing_sequences u v pen (S n0)).
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:m < n
sseq:nat -> R
Heqsseq:sseq =
(fun n1 : nat =>
 snd
   (proj1_sig (tearing_sequences u v pen n1)))
H:(forall n1 : nat, (sseq (S n1) < sseq n1)%R) ->
forall n1 m0 : nat,
n1 < m0 -> (sseq m0 < sseq n1)%R
n0:nat
x1:(R * R)%type
r1:(fst x1 < snd x1)%R
H0:let I := proj1_sig (tearing_sequences u v pen n0)
  in
let SI :=
  proj1_sig
    (exist
       (fun ab : R * R => (fst ab < snd ab)%R) x1
       r1) in
(fst I < fst SI)%R /\ (snd SI < snd I)%R
(snd
   (proj1_sig
      (exist (fun ab : R * R => fst ab < snd ab) x1 r1)) <
 snd (proj1_sig (tearing_sequences u v pen n0)))%R simpl.
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:m < n
sseq:nat -> R
Heqsseq:sseq =
(fun n1 : nat =>
 snd
   (proj1_sig (tearing_sequences u v pen n1)))
H:(forall n1 : nat, (sseq (S n1) < sseq n1)%R) ->
forall n1 m0 : nat,
n1 < m0 -> (sseq m0 < sseq n1)%R
n0:nat
x1:(R * R)%type
r1:(fst x1 < snd x1)%R
H0:let I := proj1_sig (tearing_sequences u v pen n0)
  in
let SI :=
  proj1_sig
    (exist
       (fun ab : R * R => (fst ab < snd ab)%R) x1
       r1) in
(fst I < fst SI)%R /\ (snd SI < snd I)%R
(snd x1 <
 snd (proj1_sig (tearing_sequences u v pen n0)))%R
      destruct ((tearing_sequences u v pen n0)).
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:m < n
sseq:nat -> R
Heqsseq:sseq =
(fun n1 : nat =>
 snd
   (proj1_sig (tearing_sequences u v pen n1)))
H:(forall n1 : nat, (sseq (S n1) < sseq n1)%R) ->
forall n1 m0 : nat,
n1 < m0 -> (sseq m0 < sseq n1)%R
n0:nat
x1:(R * R)%type
r1:(fst x1 < snd x1)%R
x2:(R * R)%type
r2:(fst x2 < snd x2)%R
H0:let I :=
  proj1_sig
    (exist
       (fun ab : R * R => (fst ab < snd ab)%R) x2
       r2) in
let SI :=
  proj1_sig
    (exist
       (fun ab : R * R => (fst ab < snd ab)%R) x1
       r1) in
(fst I < fst SI)%R /\ (snd SI < snd I)%R
(snd x1 <
 snd
   (proj1_sig
      (exist (fun ab : R * R => fst ab < snd ab) x2 r2)))%R apply H0. }
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:m < n
sseq:nat -> R
Heqsseq:sseq =
(fun n0 : nat =>
 snd
   (proj1_sig (tearing_sequences u v pen n0)))
H:(forall n0 : nat, (sseq (S n0) < sseq n0)%R) ->
forall n0 m0 : nat,
n0 < m0 -> (sseq m0 < sseq n0)%R
H0:forall n0 : nat, (sseq (S n0) < sseq n0)%R
(snd In < snd Im)%R
    specialize (H H0).
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:m < n
sseq:nat -> R
Heqsseq:sseq =
(fun n0 : nat =>
 snd
   (proj1_sig (tearing_sequences u v pen n0)))
H:forall n0 m0 : nat,
n0 < m0 -> (sseq m0 < sseq n0)%R
H0:forall n0 : nat, (sseq (S n0) < sseq n0)%R
(snd In < snd Im)%R rewrite -> Heqsseq in H.
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:m < n
sseq:nat -> R
Heqsseq:sseq =
(fun n0 : nat =>
 snd
   (proj1_sig (tearing_sequences u v pen n0)))
H:forall n0 m0 : nat,
n0 < m0 ->
(snd (proj1_sig (tearing_sequences u v pen m0)) <
 snd (proj1_sig (tearing_sequences u v pen n0)))%R
H0:forall n0 : nat, (sseq (S n0) < sseq n0)%R
(snd In < snd Im)%R specialize (H m n order).
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:m < n
sseq:nat -> R
Heqsseq:sseq =
(fun n0 : nat =>
 snd
   (proj1_sig (tearing_sequences u v pen n0)))
H:(snd (proj1_sig (tearing_sequences u v pen n)) <
 snd (proj1_sig (tearing_sequences u v pen m)))%R
H0:forall n0 : nat, (sseq (S n0) < sseq n0)%R
(snd In < snd Im)%R
    rewrite -> tn in H.
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:m < n
sseq:nat -> R
Heqsseq:sseq =
(fun n0 : nat =>
 snd
   (proj1_sig (tearing_sequences u v pen n0)))
H:(snd
   (proj1_sig
      (exist (fun ab : R * R => fst ab < snd ab) x
         r)) <
 snd (proj1_sig (tearing_sequences u v pen m)))%R
H0:forall n0 : nat, (sseq (S n0) < sseq n0)%R
(snd In < snd Im)%R rewrite -> tm in H.
u:nat -> R
v:R -> nat
pen:enumeration R u v
n, m:nat
x:(R * R)%type
r:(fst x < snd x)%R
tn:tearing_sequences u v pen n =
exist (fun ab : R * R => (fst ab < snd ab)%R) x r
In:=x:(R * R)%type
x0:(R * R)%type
r0:(fst x0 < snd x0)%R
tm:tearing_sequences u v pen m =
exist (fun ab : R * R => (fst ab < snd ab)%R) x0
  r0
Im:=x0:(R * R)%type
order:m < n
sseq:nat -> R
Heqsseq:sseq =
(fun n0 : nat =>
 snd
   (proj1_sig (tearing_sequences u v pen n0)))
H:(snd
   (proj1_sig
      (exist (fun ab : R * R => fst ab < snd ab) x
         r)) <
 snd
   (proj1_sig
      (exist (fun ab : R * R => fst ab < snd ab)
         x0 r0)))%R
H0:forall n0 : nat, (sseq (S n0) < sseq n0)%R
(snd In < snd Im)%R apply H.
Qed.

Definition tearing_elem_fst (u : nat -> R) (v : R -> nat) (pen : enumeration R u v) (x : R)
  := exists n : nat, x = fst (proj1_sig (tearing_sequences u v pen n)).

(* The limit of the first tearing sequence cannot be reached by u *)
Definition torn_number (u : nat -> R) (v : R -> nat) (pen : enumeration R u v) :
  {m : R | is_lub (tearing_elem_fst u v pen) m}.
u:nat -> R
v:R -> nat
pen:enumeration R u v
{m : R | is_lub (tearing_elem_fst u v pen) m}
Proof.
u:nat -> R
v:R -> nat
pen:enumeration R u v
{m : R | is_lub (tearing_elem_fst u v pen) m}
  intros.
u:nat -> R
v:R -> nat
pen:enumeration R u v
{m : R | is_lub (tearing_elem_fst u v pen) m} assert (bound (tearing_elem_fst u v pen)).
u:nat -> R
v:R -> nat
pen:enumeration R u v
bound (tearing_elem_fst u v pen)
u:nat -> R
v:R -> nat
pen:enumeration R u v
H:bound (tearing_elem_fst u v pen)
{m : R | is_lub (tearing_elem_fst u v pen) m}
  {
u:nat -> R
v:R -> nat
pen:enumeration R u v
bound (tearing_elem_fst u v pen) exists (INR 1).
u:nat -> R
v:R -> nat
pen:enumeration R u v
is_upper_bound (tearing_elem_fst u v pen) (INR 1) intros x H0.
u:nat -> R
v:R -> nat
pen:enumeration R u v
x:R
H0:tearing_elem_fst u v pen x
(x <= INR 1)%R destruct H0 as [n H0].
u:nat -> R
v:R -> nat
pen:enumeration R u v
x:R
n:nat
H0:x = fst (proj1_sig (tearing_sequences u v pen n))
(x <= INR 1)%R subst.
u:nat -> R
v:R -> nat
pen:enumeration R u v
n:nat
(fst (proj1_sig (tearing_sequences u v pen n)) <=
 INR 1)%R left.
u:nat -> R
v:R -> nat
pen:enumeration R u v
n:nat
(fst (proj1_sig (tearing_sequences u v pen n)) < INR 1)%R
    apply (tearing_sequences_ordered_forall u v pen n 0). }
u:nat -> R
v:R -> nat
pen:enumeration R u v
H:bound (tearing_elem_fst u v pen)
{m : R | is_lub (tearing_elem_fst u v pen) m}
  apply (completeness (tearing_elem_fst u v pen) H).
u:nat -> R
v:R -> nat
pen:enumeration R u v
H:bound (tearing_elem_fst u v pen)
exists x : R, tearing_elem_fst u v pen x
  exists (INR 0).
u:nat -> R
v:R -> nat
pen:enumeration R u v
H:bound (tearing_elem_fst u v pen)
tearing_elem_fst u v pen (INR 0) exists 0.
u:nat -> R
v:R -> nat
pen:enumeration R u v
H:bound (tearing_elem_fst u v pen)
INR 0 = fst (proj1_sig (tearing_sequences u v pen 0)) reflexivity.
Defined.

Lemma torn_number_above_first_sequence (u : nat -> R) (v : R -> nat) (en : enumeration R u v)
  : forall n : nat, Rlt (fst (proj1_sig (tearing_sequences u v en n)))
                 (proj1_sig (torn_number u v en)).
u:nat -> R
v:R -> nat
en:enumeration R u v
forall n : nat,
(fst (proj1_sig (tearing_sequences u v en n)) <
 proj1_sig (torn_number u v en))%R
Proof.
u:nat -> R
v:R -> nat
en:enumeration R u v
forall n : nat,
(fst (proj1_sig (tearing_sequences u v en n)) <
 proj1_sig (torn_number u v en))%R
  intros.
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
(fst (proj1_sig (tearing_sequences u v en n)) <
 proj1_sig (torn_number u v en))%R destruct (torn_number u v en) as [torn i].
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
torn:R
i:is_lub (tearing_elem_fst u v en) torn
(fst (proj1_sig (tearing_sequences u v en n)) <
 proj1_sig
   (exist
      (fun m : R => is_lub (tearing_elem_fst u v en) m)
      torn i))%R simpl.
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
torn:R
i:is_lub (tearing_elem_fst u v en) torn
(fst (proj1_sig (tearing_sequences u v en n)) < torn)%R
  destruct (Rlt_le_dec (fst (proj1_sig (tearing_sequences u v en n))) torn).
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
torn:R
i:is_lub (tearing_elem_fst u v en) torn
r:(fst (proj1_sig (tearing_sequences u v en n)) <
 torn)%R
(fst (proj1_sig (tearing_sequences u v en n)) < torn)%R
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
torn:R
i:is_lub (tearing_elem_fst u v en) torn
r:(torn <=
 fst (proj1_sig (tearing_sequences u v en n)))%R
(fst (proj1_sig (tearing_sequences u v en n)) < torn)%R
  assumption.
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
torn:R
i:is_lub (tearing_elem_fst u v en) torn
r:(torn <=
 fst (proj1_sig (tearing_sequences u v en n)))%R
(fst (proj1_sig (tearing_sequences u v en n)) < torn)%R exfalso.
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
torn:R
i:is_lub (tearing_elem_fst u v en) torn
r:(torn <=
 fst (proj1_sig (tearing_sequences u v en n)))%R
False
  destruct i. (* Apply the first sequence once to make the inequality strict *)
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
torn:R
H:is_upper_bound (tearing_elem_fst u v en) torn
H0:forall b : R,
is_upper_bound (tearing_elem_fst u v en) b ->
(torn <= b)%R
r:(torn <=
 fst (proj1_sig (tearing_sequences u v en n)))%R
False
  assert (Rlt torn (fst (proj1_sig (tearing_sequences u v en (S n))))).
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
torn:R
H:is_upper_bound (tearing_elem_fst u v en) torn
H0:forall b : R,
is_upper_bound (tearing_elem_fst u v en) b ->
(torn <= b)%R
r:(torn <=
 fst (proj1_sig (tearing_sequences u v en n)))%R
(torn <
 fst (proj1_sig (tearing_sequences u v en (S n))))%R
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
torn:R
H:is_upper_bound (tearing_elem_fst u v en) torn
H0:forall b : R,
is_upper_bound (tearing_elem_fst u v en) b ->
(torn <= b)%R
r:(torn <=
 fst (proj1_sig (tearing_sequences u v en n)))%R
H1:(torn <
 fst (proj1_sig (tearing_sequences u v en (S n))))%R
False
  {
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
torn:R
H:is_upper_bound (tearing_elem_fst u v en) torn
H0:forall b : R,
is_upper_bound (tearing_elem_fst u v en) b ->
(torn <= b)%R
r:(torn <=
 fst (proj1_sig (tearing_sequences u v en n)))%R
(torn <
 fst (proj1_sig (tearing_sequences u v en (S n))))%R apply (Rle_lt_trans torn (fst (proj1_sig (tearing_sequences u v en n)))).
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
torn:R
H:is_upper_bound (tearing_elem_fst u v en) torn
H0:forall b : R,
is_upper_bound (tearing_elem_fst u v en) b ->
(torn <= b)%R
r:(torn <=
 fst (proj1_sig (tearing_sequences u v en n)))%R
(torn <= fst (proj1_sig (tearing_sequences u v en n)))%R
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
torn:R
H:is_upper_bound (tearing_elem_fst u v en) torn
H0:forall b : R,
is_upper_bound (tearing_elem_fst u v en) b ->
(torn <= b)%R
r:(torn <=
 fst (proj1_sig (tearing_sequences u v en n)))%R
(fst (proj1_sig (tearing_sequences u v en n)) <
 fst (proj1_sig (tearing_sequences u v en (S n))))%R
    assumption.
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
torn:R
H:is_upper_bound (tearing_elem_fst u v en) torn
H0:forall b : R,
is_upper_bound (tearing_elem_fst u v en) b ->
(torn <= b)%R
r:(torn <=
 fst (proj1_sig (tearing_sequences u v en n)))%R
(fst (proj1_sig (tearing_sequences u v en n)) <
 fst (proj1_sig (tearing_sequences u v en (S n))))%R apply tearing_sequences_inc_dec. }
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
torn:R
H:is_upper_bound (tearing_elem_fst u v en) torn
H0:forall b : R,
is_upper_bound (tearing_elem_fst u v en) b ->
(torn <= b)%R
r:(torn <=
 fst (proj1_sig (tearing_sequences u v en n)))%R
H1:(torn <
 fst (proj1_sig (tearing_sequences u v en (S n))))%R
False
  clear r.
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
torn:R
H:is_upper_bound (tearing_elem_fst u v en) torn
H0:forall b : R,
is_upper_bound (tearing_elem_fst u v en) b ->
(torn <= b)%R
H1:(torn <
 fst (proj1_sig (tearing_sequences u v en (S n))))%R
False specialize (H (fst (proj1_sig (tearing_sequences u v en (S n))))).
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
torn:R
H:tearing_elem_fst u v en
  (fst
     (proj1_sig (tearing_sequences u v en (S n)))) ->
(fst (proj1_sig (tearing_sequences u v en (S n))) <=
 torn)%R
H0:forall b : R,
is_upper_bound (tearing_elem_fst u v en) b ->
(torn <= b)%R
H1:(torn <
 fst (proj1_sig (tearing_sequences u v en (S n))))%R
False
  assert (tearing_elem_fst u v en (fst (proj1_sig (tearing_sequences u v en (S n))))).
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
torn:R
H:tearing_elem_fst u v en
  (fst
     (proj1_sig (tearing_sequences u v en (S n)))) ->
(fst (proj1_sig (tearing_sequences u v en (S n))) <=
 torn)%R
H0:forall b : R,
is_upper_bound (tearing_elem_fst u v en) b ->
(torn <= b)%R
H1:(torn <
 fst (proj1_sig (tearing_sequences u v en (S n))))%R
tearing_elem_fst u v en
  (fst (proj1_sig (tearing_sequences u v en (S n))))
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
torn:R
H:tearing_elem_fst u v en
  (fst
     (proj1_sig (tearing_sequences u v en (S n)))) ->
(fst (proj1_sig (tearing_sequences u v en (S n))) <=
 torn)%R
H0:forall b : R,
is_upper_bound (tearing_elem_fst u v en) b ->
(torn <= b)%R
H1:(torn <
 fst (proj1_sig (tearing_sequences u v en (S n))))%R
H2:tearing_elem_fst u v en
  (fst
     (proj1_sig (tearing_sequences u v en (S n))))
False
  {
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
torn:R
H:tearing_elem_fst u v en
  (fst
     (proj1_sig (tearing_sequences u v en (S n)))) ->
(fst (proj1_sig (tearing_sequences u v en (S n))) <=
 torn)%R
H0:forall b : R,
is_upper_bound (tearing_elem_fst u v en) b ->
(torn <= b)%R
H1:(torn <
 fst (proj1_sig (tearing_sequences u v en (S n))))%R
tearing_elem_fst u v en
  (fst (proj1_sig (tearing_sequences u v en (S n)))) exists (S n).
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
torn:R
H:tearing_elem_fst u v en
  (fst
     (proj1_sig (tearing_sequences u v en (S n)))) ->
(fst (proj1_sig (tearing_sequences u v en (S n))) <=
 torn)%R
H0:forall b : R,
is_upper_bound (tearing_elem_fst u v en) b ->
(torn <= b)%R
H1:(torn <
 fst (proj1_sig (tearing_sequences u v en (S n))))%R
fst (proj1_sig (tearing_sequences u v en (S n))) =
fst (proj1_sig (tearing_sequences u v en (S n))) reflexivity. }
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
torn:R
H:tearing_elem_fst u v en
  (fst
     (proj1_sig (tearing_sequences u v en (S n)))) ->
(fst (proj1_sig (tearing_sequences u v en (S n))) <=
 torn)%R
H0:forall b : R,
is_upper_bound (tearing_elem_fst u v en) b ->
(torn <= b)%R
H1:(torn <
 fst (proj1_sig (tearing_sequences u v en (S n))))%R
H2:tearing_elem_fst u v en
  (fst
     (proj1_sig (tearing_sequences u v en (S n))))
False
  specialize (H H2).
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
torn:R
H:(fst (proj1_sig (tearing_sequences u v en (S n))) <=
 torn)%R
H0:forall b : R,
is_upper_bound (tearing_elem_fst u v en) b ->
(torn <= b)%R
H1:(torn <
 fst (proj1_sig (tearing_sequences u v en (S n))))%R
H2:tearing_elem_fst u v en
  (fst
     (proj1_sig (tearing_sequences u v en (S n))))
False assert (Rlt torn torn).
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
torn:R
H:(fst (proj1_sig (tearing_sequences u v en (S n))) <=
 torn)%R
H0:forall b : R,
is_upper_bound (tearing_elem_fst u v en) b ->
(torn <= b)%R
H1:(torn <
 fst (proj1_sig (tearing_sequences u v en (S n))))%R
H2:tearing_elem_fst u v en
  (fst
     (proj1_sig (tearing_sequences u v en (S n))))
(torn < torn)%R
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
torn:R
H:(fst (proj1_sig (tearing_sequences u v en (S n))) <=
 torn)%R
H0:forall b : R,
is_upper_bound (tearing_elem_fst u v en) b ->
(torn <= b)%R
H1:(torn <
 fst (proj1_sig (tearing_sequences u v en (S n))))%R
H2:tearing_elem_fst u v en
  (fst
     (proj1_sig (tearing_sequences u v en (S n))))
H3:(torn < torn)%R
False
  {
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
torn:R
H:(fst (proj1_sig (tearing_sequences u v en (S n))) <=
 torn)%R
H0:forall b : R,
is_upper_bound (tearing_elem_fst u v en) b ->
(torn <= b)%R
H1:(torn <
 fst (proj1_sig (tearing_sequences u v en (S n))))%R
H2:tearing_elem_fst u v en
  (fst
     (proj1_sig (tearing_sequences u v en (S n))))
(torn < torn)%R apply (Rlt_le_trans torn (fst (proj1_sig (tearing_sequences u v en (S n)))));
      assumption. }
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
torn:R
H:(fst (proj1_sig (tearing_sequences u v en (S n))) <=
 torn)%R
H0:forall b : R,
is_upper_bound (tearing_elem_fst u v en) b ->
(torn <= b)%R
H1:(torn <
 fst (proj1_sig (tearing_sequences u v en (S n))))%R
H2:tearing_elem_fst u v en
  (fst
     (proj1_sig (tearing_sequences u v en (S n))))
H3:(torn < torn)%R
False
  apply Rlt_irrefl in H3.
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
torn:R
H:(fst (proj1_sig (tearing_sequences u v en (S n))) <=
 torn)%R
H0:forall b : R,
is_upper_bound (tearing_elem_fst u v en) b ->
(torn <= b)%R
H1:(torn <
 fst (proj1_sig (tearing_sequences u v en (S n))))%R
H2:tearing_elem_fst u v en
  (fst
     (proj1_sig (tearing_sequences u v en (S n))))
H3:False
False contradiction.
Qed.

(* The torn number is between both tearing sequences, so it could have been chosen
   at each step. *)
Lemma torn_number_below_second_sequence (u : nat -> R) (v : R -> nat)
      (en : enumeration R u v) :
  forall n : nat, Rlt (proj1_sig (torn_number u v en))
               (snd (proj1_sig (tearing_sequences u v en n))).
u:nat -> R
v:R -> nat
en:enumeration R u v
forall n : nat,
(proj1_sig (torn_number u v en) <
 snd (proj1_sig (tearing_sequences u v en n)))%R
Proof.
u:nat -> R
v:R -> nat
en:enumeration R u v
forall n : nat,
(proj1_sig (torn_number u v en) <
 snd (proj1_sig (tearing_sequences u v en n)))%R
  intros.
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
(proj1_sig (torn_number u v en) <
 snd (proj1_sig (tearing_sequences u v en n)))%R destruct (torn_number u v en) as [torn i].
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
torn:R
i:is_lub (tearing_elem_fst u v en) torn
(proj1_sig
   (exist
      (fun m : R => is_lub (tearing_elem_fst u v en) m)
      torn i) <
 snd (proj1_sig (tearing_sequences u v en n)))%R simpl.
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
torn:R
i:is_lub (tearing_elem_fst u v en) torn
(torn < snd (proj1_sig (tearing_sequences u v en n)))%R
  destruct (Rlt_le_dec torn (snd (proj1_sig (tearing_sequences u v en n))))
    as [l|h].
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
torn:R
i:is_lub (tearing_elem_fst u v en) torn
l:(torn <
 snd (proj1_sig (tearing_sequences u v en n)))%R
(torn < snd (proj1_sig (tearing_sequences u v en n)))%R
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
torn:R
i:is_lub (tearing_elem_fst u v en) torn
h:(snd (proj1_sig (tearing_sequences u v en n)) <=
 torn)%R
(torn < snd (proj1_sig (tearing_sequences u v en n)))%R
  -
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
torn:R
i:is_lub (tearing_elem_fst u v en) torn
l:(torn <
 snd (proj1_sig (tearing_sequences u v en n)))%R
(torn < snd (proj1_sig (tearing_sequences u v en n)))%R assumption.
  -
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
torn:R
i:is_lub (tearing_elem_fst u v en) torn
h:(snd (proj1_sig (tearing_sequences u v en n)) <=
 torn)%R
(torn < snd (proj1_sig (tearing_sequences u v en n)))%R exfalso. (* Apply the second sequence once to make the inequality strict *)
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
torn:R
i:is_lub (tearing_elem_fst u v en) torn
h:(snd (proj1_sig (tearing_sequences u v en n)) <=
 torn)%R
False
    assert (Rlt (snd (proj1_sig (tearing_sequences u v en (S n)))) torn).
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
torn:R
i:is_lub (tearing_elem_fst u v en) torn
h:(snd (proj1_sig (tearing_sequences u v en n)) <=
 torn)%R
(snd (proj1_sig (tearing_sequences u v en (S n))) <
 torn)%R
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
torn:R
i:is_lub (tearing_elem_fst u v en) torn
h:(snd (proj1_sig (tearing_sequences u v en n)) <=
 torn)%R
H:(snd (proj1_sig (tearing_sequences u v en (S n))) <
 torn)%R
False
    {
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
torn:R
i:is_lub (tearing_elem_fst u v en) torn
h:(snd (proj1_sig (tearing_sequences u v en n)) <=
 torn)%R
(snd (proj1_sig (tearing_sequences u v en (S n))) <
 torn)%R apply (Rlt_le_trans (snd (proj1_sig (tearing_sequences u v en (S n))))
                          (snd (proj1_sig (tearing_sequences u v en n))) torn).
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
torn:R
i:is_lub (tearing_elem_fst u v en) torn
h:(snd (proj1_sig (tearing_sequences u v en n)) <=
 torn)%R
(snd (proj1_sig (tearing_sequences u v en (S n))) <
 snd (proj1_sig (tearing_sequences u v en n)))%R
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
torn:R
i:is_lub (tearing_elem_fst u v en) torn
h:(snd (proj1_sig (tearing_sequences u v en n)) <=
 torn)%R
(snd (proj1_sig (tearing_sequences u v en n)) <= torn)%R
      apply (tearing_sequences_inc_dec u v en n).
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
torn:R
i:is_lub (tearing_elem_fst u v en) torn
h:(snd (proj1_sig (tearing_sequences u v en n)) <=
 torn)%R
(snd (proj1_sig (tearing_sequences u v en n)) <= torn)%R assumption. }
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
torn:R
i:is_lub (tearing_elem_fst u v en) torn
h:(snd (proj1_sig (tearing_sequences u v en n)) <=
 torn)%R
H:(snd (proj1_sig (tearing_sequences u v en (S n))) <
 torn)%R
False
    clear h.
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
torn:R
i:is_lub (tearing_elem_fst u v en) torn
H:(snd (proj1_sig (tearing_sequences u v en (S n))) <
 torn)%R
False (* Then prove snd (tearing_sequences u v (S n)) is an upper bound of the first
                sequence. It will yield the contradiction torn < torn. *)
    assert (is_upper_bound (tearing_elem_fst u v en)
                           (snd (proj1_sig (tearing_sequences u v en (S n))))).
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
torn:R
i:is_lub (tearing_elem_fst u v en) torn
H:(snd (proj1_sig (tearing_sequences u v en (S n))) <
 torn)%R
is_upper_bound (tearing_elem_fst u v en)
  (snd (proj1_sig (tearing_sequences u v en (S n))))
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
torn:R
i:is_lub (tearing_elem_fst u v en) torn
H:(snd (proj1_sig (tearing_sequences u v en (S n))) <
 torn)%R
H0:is_upper_bound (tearing_elem_fst u v en)
  (snd
     (proj1_sig (tearing_sequences u v en (S n))))
False
    {
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
torn:R
i:is_lub (tearing_elem_fst u v en) torn
H:(snd (proj1_sig (tearing_sequences u v en (S n))) <
 torn)%R
is_upper_bound (tearing_elem_fst u v en)
  (snd (proj1_sig (tearing_sequences u v en (S n)))) intros x H0.
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
torn:R
i:is_lub (tearing_elem_fst u v en) torn
H:(snd (proj1_sig (tearing_sequences u v en (S n))) <
 torn)%R
x:R
H0:tearing_elem_fst u v en x
(x <= snd (proj1_sig (tearing_sequences u v en (S n))))%R destruct H0.
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
torn:R
i:is_lub (tearing_elem_fst u v en) torn
H:(snd (proj1_sig (tearing_sequences u v en (S n))) <
 torn)%R
x:R
x0:nat
H0:x = fst (proj1_sig (tearing_sequences u v en x0))
(x <= snd (proj1_sig (tearing_sequences u v en (S n))))%R subst.
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
torn:R
i:is_lub (tearing_elem_fst u v en) torn
H:(snd (proj1_sig (tearing_sequences u v en (S n))) <
 torn)%R
x0:nat
(fst (proj1_sig (tearing_sequences u v en x0)) <=
 snd (proj1_sig (tearing_sequences u v en (S n))))%R left.
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
torn:R
i:is_lub (tearing_elem_fst u v en) torn
H:(snd (proj1_sig (tearing_sequences u v en (S n))) <
 torn)%R
x0:nat
(fst (proj1_sig (tearing_sequences u v en x0)) <
 snd (proj1_sig (tearing_sequences u v en (S n))))%R apply tearing_sequences_ordered_forall. }
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
torn:R
i:is_lub (tearing_elem_fst u v en) torn
H:(snd (proj1_sig (tearing_sequences u v en (S n))) <
 torn)%R
H0:is_upper_bound (tearing_elem_fst u v en)
  (snd
     (proj1_sig (tearing_sequences u v en (S n))))
False
    destruct i.
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
torn:R
H1:is_upper_bound (tearing_elem_fst u v en) torn
H2:forall b : R,
is_upper_bound (tearing_elem_fst u v en) b ->
(torn <= b)%R
H:(snd (proj1_sig (tearing_sequences u v en (S n))) <
 torn)%R
H0:is_upper_bound (tearing_elem_fst u v en)
  (snd
     (proj1_sig (tearing_sequences u v en (S n))))
False apply H2 in H0.
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
torn:R
H1:is_upper_bound (tearing_elem_fst u v en) torn
H2:forall b : R,
is_upper_bound (tearing_elem_fst u v en) b ->
(torn <= b)%R
H:(snd (proj1_sig (tearing_sequences u v en (S n))) <
 torn)%R
H0:(torn <=
 snd (proj1_sig (tearing_sequences u v en (S n))))%R
False
    pose proof (Rle_lt_trans torn (snd (proj1_sig (tearing_sequences u v en (S n)))) torn H0 H).
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
torn:R
H1:is_upper_bound (tearing_elem_fst u v en) torn
H2:forall b : R,
is_upper_bound (tearing_elem_fst u v en) b ->
(torn <= b)%R
H:(snd (proj1_sig (tearing_sequences u v en (S n))) <
 torn)%R
H0:(torn <=
 snd (proj1_sig (tearing_sequences u v en (S n))))%R
H3:(torn < torn)%R
False
    apply Rlt_irrefl in H3.
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
torn:R
H1:is_upper_bound (tearing_elem_fst u v en) torn
H2:forall b : R,
is_upper_bound (tearing_elem_fst u v en) b ->
(torn <= b)%R
H:(snd (proj1_sig (tearing_sequences u v en (S n))) <
 torn)%R
H0:(torn <=
 snd (proj1_sig (tearing_sequences u v en (S n))))%R
H3:False
False contradiction.
Qed.

(* Here is the contradiction : the torn number's index is above a sequence
   that tends to infinity *)
Lemma limit_index_above_all_indices (u : nat -> R) (v : R -> nat) (en : enumeration R u v) :
  forall n : nat, v (fst (proj1_sig (tearing_sequences u v en (S n))))
           < v (proj1_sig (torn_number u v en)).
u:nat -> R
v:R -> nat
en:enumeration R u v
forall n : nat,
v (fst (proj1_sig (tearing_sequences u v en (S n)))) <
v (proj1_sig (torn_number u v en))
Proof.
u:nat -> R
v:R -> nat
en:enumeration R u v
forall n : nat,
v (fst (proj1_sig (tearing_sequences u v en (S n)))) <
v (proj1_sig (torn_number u v en))
  intros.
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
v (fst (proj1_sig (tearing_sequences u v en (S n)))) <
v (proj1_sig (torn_number u v en)) simpl.
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
v
  (fst
     (proj1_sig
        (let (x, x0) := tearing_sequences u v en n in
         (let
            (a, b) as p
             return
               ((fst p < snd p)%R ->
                {ab : R * R | (fst ab < snd ab)%R}) :=
            x in
          fun pr : (a < b)%R =>
          exist
            (fun ab : R * R => (fst ab < snd ab)%R)
            (first_two_in_interval u v a b en pr)
            ((let
                (r, r0) as p
                 return
                   ((let (c, d) := p in
                     (a < c)%R /\
                     (...)%R /\ ...%R /\ ...) ->
                    (fst p < snd p)%R) :=
                first_two_in_interval u v a b en pr in
              fun
                H : (a < r)%R /\
                    (r < b)%R /\
                    (a < r0)%R /\
                    (r0 < b)%R /\
                    (r < r0)%R /\ (..., ...) =>
              match
                match ...
                      ...
                      end with
                | conj _ H1 => H1
                end
              with
              | conj H0 _ => H0
              end)
               (first_two_in_interval_works u v a b en
                  pr))) x0))) <
v (proj1_sig (torn_number u v en)) destruct (tearing_sequences u v en n) as [[r r0] H] eqn:tear.
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
r, r0:R
H:(fst (r, r0) < snd (r, r0))%R
tear:tearing_sequences u v en n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H
v
  (fst
     (proj1_sig
        (exist (fun ab : R * R => (fst ab < snd ab)%R)
           (first_two_in_interval u v r r0 en H)
           ((let
               (r1, r2) as p
                return
                  ((let (c, d) := p in
                    (r < c)%R /\
                    (c < r0)%R /\
                    (r < d)%R /\
                    (d < r0)%R /\
                    (c < d)%R /\
                    (forall ..., ...%R -> ...)) ->
                   (fst p < snd p)%R) :=
               first_two_in_interval u v r r0 en H in
             fun
               H0 : (r < r1)%R /\
                    (r1 < r0)%R /\
                    (r < r2)%R /\
                    (r2 < r0)%R /\
                    (r1 < r2)%R /\
                    (forall x : R,
                     (r < x)%R ->
                     (x < r0)%R ->
                     x <> r1 -> x <> r2 -> ... < ...)
             =>
             match
               match
                 match
                   match ... with
                   | ... H2
                   end
                 with
                 | conj _ H2 => H2
                 end
               with
               | conj _ H2 => H2
               end
             with
             | conj H1 _ => H1
             end)
              (first_two_in_interval_works u v r r0 en
                 H))))) <
v (proj1_sig (torn_number u v en))
  (* The torn number was not chosen, so its index is above *)
  simpl.
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
r, r0:R
H:(fst (r, r0) < snd (r, r0))%R
tear:tearing_sequences u v en n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H
v (fst (first_two_in_interval u v r r0 en H)) <
v (proj1_sig (torn_number u v en))
  pose proof (first_two_in_interval_works u v r r0 en H).
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
r, r0:R
H:(fst (r, r0) < snd (r, r0))%R
tear:tearing_sequences u v en n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H
H0:let (c, d) :=
  first_two_in_interval u v r r0 en H in
(r < c)%R /\
(c < r0)%R /\
(r < d)%R /\
(d < r0)%R /\
(c < d)%R /\
(forall x : R,
 (r < x)%R ->
 (x < r0)%R -> x <> c -> x <> d -> v c < v x)
v (fst (first_two_in_interval u v r r0 en H)) <
v (proj1_sig (torn_number u v en))
  destruct (first_two_in_interval u v r r0) eqn:ft.
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
r, r0:R
H:(fst (r, r0) < snd (r, r0))%R
tear:tearing_sequences u v en n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H
r1, r2:R
ft:first_two_in_interval u v r r0 en H = (r1, r2)
H0:(r < r1)%R /\
(r1 < r0)%R /\
(r < r2)%R /\
(r2 < r0)%R /\
(r1 < r2)%R /\
(forall x : R,
 (r < x)%R ->
 (x < r0)%R -> x <> r1 -> x <> r2 -> v r1 < v x)
v (fst (r1, r2)) < v (proj1_sig (torn_number u v en)) simpl.
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
r, r0:R
H:(fst (r, r0) < snd (r, r0))%R
tear:tearing_sequences u v en n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H
r1, r2:R
ft:first_two_in_interval u v r r0 en H = (r1, r2)
H0:(r < r1)%R /\
(r1 < r0)%R /\
(r < r2)%R /\
(r2 < r0)%R /\
(r1 < r2)%R /\
(forall x : R,
 (r < x)%R ->
 (x < r0)%R -> x <> r1 -> x <> r2 -> v r1 < v x)
v r1 < v (proj1_sig (torn_number u v en))
  assert (proj1_sig (tearing_sequences u v en (S n)) = (r1, r2)).
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
r, r0:R
H:(fst (r, r0) < snd (r, r0))%R
tear:tearing_sequences u v en n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H
r1, r2:R
ft:first_two_in_interval u v r r0 en H = (r1, r2)
H0:(r < r1)%R /\
(r1 < r0)%R /\
(r < r2)%R /\
(r2 < r0)%R /\
(r1 < r2)%R /\
(forall x : R,
 (r < x)%R ->
 (x < r0)%R -> x <> r1 -> x <> r2 -> v r1 < v x)
proj1_sig (tearing_sequences u v en (S n)) = (r1, r2)
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
r, r0:R
H:(fst (r, r0) < snd (r, r0))%R
tear:tearing_sequences u v en n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H
r1, r2:R
ft:first_two_in_interval u v r r0 en H = (r1, r2)
H0:(r < r1)%R /\
(r1 < r0)%R /\
(r < r2)%R /\
(r2 < r0)%R /\
(r1 < r2)%R /\
(forall x : R,
 (r < x)%R ->
 (x < r0)%R -> x <> r1 -> x <> r2 -> v r1 < v x)
H1:proj1_sig (tearing_sequences u v en (S n)) =
(r1, r2)
v r1 < v (proj1_sig (torn_number u v en))
  {
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
r, r0:R
H:(fst (r, r0) < snd (r, r0))%R
tear:tearing_sequences u v en n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H
r1, r2:R
ft:first_two_in_interval u v r r0 en H = (r1, r2)
H0:(r < r1)%R /\
(r1 < r0)%R /\
(r < r2)%R /\
(r2 < r0)%R /\
(r1 < r2)%R /\
(forall x : R,
 (r < x)%R ->
 (x < r0)%R -> x <> r1 -> x <> r2 -> v r1 < v x)
proj1_sig (tearing_sequences u v en (S n)) = (r1, r2) simpl.
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
r, r0:R
H:(fst (r, r0) < snd (r, r0))%R
tear:tearing_sequences u v en n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H
r1, r2:R
ft:first_two_in_interval u v r r0 en H = (r1, r2)
H0:(r < r1)%R /\
(r1 < r0)%R /\
(r < r2)%R /\
(r2 < r0)%R /\
(r1 < r2)%R /\
(forall x : R,
 (r < x)%R ->
 (x < r0)%R -> x <> r1 -> x <> r2 -> v r1 < v x)
proj1_sig
  (let (x, x0) := tearing_sequences u v en n in
   (let
      (a, b) as p
       return
         ((fst p < snd p)%R ->
          {ab : R * R | (fst ab < snd ab)%R}) := x in
    fun pr : (a < b)%R =>
    exist (fun ab : R * R => (fst ab < snd ab)%R)
      (first_two_in_interval u v a b en pr)
      ((let
          (r3, r4) as p
           return
             ((let (c, d) := p in
               (a < c)%R /\
               (c < b)%R /\
               (a < d)%R /\
               (d < b)%R /\ (c < d)%R /\ (..., ...)) ->
              (fst p < snd p)%R) :=
          first_two_in_interval u v a b en pr in
        fun
          H1 : (a < r3)%R /\
               (r3 < b)%R /\
               (a < r4)%R /\
               (r4 < b)%R /\
               (r3 < r4)%R /\
               (forall x0 : R,
                (a < x0)%R ->
                (x0 < b)%R -> x0 <> r3 -> ... -> ...)
        =>
        match
          match
            match ...
                  ...
                  end with
            | conj _ H3 => H3
            end
          with
          | conj _ H3 => H3
          end
        with
        | conj H2 _ => H2
        end)
         (first_two_in_interval_works u v a b en pr)))
     x0) = (r1, r2) rewrite -> tear.
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
r, r0:R
H:(fst (r, r0) < snd (r, r0))%R
tear:tearing_sequences u v en n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H
r1, r2:R
ft:first_two_in_interval u v r r0 en H = (r1, r2)
H0:(r < r1)%R /\
(r1 < r0)%R /\
(r < r2)%R /\
(r2 < r0)%R /\
(r1 < r2)%R /\
(forall x : R,
 (r < x)%R ->
 (x < r0)%R -> x <> r1 -> x <> r2 -> v r1 < v x)
proj1_sig
  (exist (fun ab : R * R => (fst ab < snd ab)%R)
     (first_two_in_interval u v r r0 en H)
     ((let
         (r3, r4) as p
          return
            ((let (c, d) := p in
              (r < c)%R /\
              (c < r0)%R /\
              (r < d)%R /\
              (d < r0)%R /\
              (c < d)%R /\
              (forall x : R,
               (r < x)%R ->
               (x < r0)%R ->
               x <> c -> x <> d -> ... < ...)) ->
             (fst p < snd p)%R) :=
         first_two_in_interval u v r r0 en H in
       fun
         H1 : (r < r3)%R /\
              (r3 < r0)%R /\
              (r < r4)%R /\
              (r4 < r0)%R /\
              (r3 < r4)%R /\
              (forall x : R,
               (r < x)%R ->
               (x < r0)%R ->
               x <> r3 -> x <> r4 -> v r3 < v x) =>
       match
         match
           match
             match match ... with
                   | ... H3
                   end with
             | conj _ H3 => H3
             end
           with
           | conj _ H3 => H3
           end
         with
         | conj _ H3 => H3
         end
       with
       | conj H2 _ => H2
       end)
        (first_two_in_interval_works u v r r0 en H))) =
(r1, r2) assumption. }
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
r, r0:R
H:(fst (r, r0) < snd (r, r0))%R
tear:tearing_sequences u v en n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H
r1, r2:R
ft:first_two_in_interval u v r r0 en H = (r1, r2)
H0:(r < r1)%R /\
(r1 < r0)%R /\
(r < r2)%R /\
(r2 < r0)%R /\
(r1 < r2)%R /\
(forall x : R,
 (r < x)%R ->
 (x < r0)%R -> x <> r1 -> x <> r2 -> v r1 < v x)
H1:proj1_sig (tearing_sequences u v en (S n)) =
(r1, r2)
v r1 < v (proj1_sig (torn_number u v en))
  apply H0.
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
r, r0:R
H:(fst (r, r0) < snd (r, r0))%R
tear:tearing_sequences u v en n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H
r1, r2:R
ft:first_two_in_interval u v r r0 en H = (r1, r2)
H0:(r < r1)%R /\
(r1 < r0)%R /\
(r < r2)%R /\
(r2 < r0)%R /\
(r1 < r2)%R /\
(forall x : R,
 (r < x)%R ->
 (x < r0)%R -> x <> r1 -> x <> r2 -> v r1 < v x)
H1:proj1_sig (tearing_sequences u v en (S n)) =
(r1, r2)
(r < proj1_sig (torn_number u v en))%R
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
r, r0:R
H:(fst (r, r0) < snd (r, r0))%R
tear:tearing_sequences u v en n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H
r1, r2:R
ft:first_two_in_interval u v r r0 en H = (r1, r2)
H0:(r < r1)%R /\
(r1 < r0)%R /\
(r < r2)%R /\
(r2 < r0)%R /\
(r1 < r2)%R /\
(forall x : R,
 (r < x)%R ->
 (x < r0)%R -> x <> r1 -> x <> r2 -> v r1 < v x)
H1:proj1_sig (tearing_sequences u v en (S n)) =
(r1, r2)
(proj1_sig (torn_number u v en) < r0)%R
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
r, r0:R
H:(fst (r, r0) < snd (r, r0))%R
tear:tearing_sequences u v en n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H
r1, r2:R
ft:first_two_in_interval u v r r0 en H = (r1, r2)
H0:(r < r1)%R /\
(r1 < r0)%R /\
(r < r2)%R /\
(r2 < r0)%R /\
(r1 < r2)%R /\
(forall x : R,
 (r < x)%R ->
 (x < r0)%R -> x <> r1 -> x <> r2 -> v r1 < v x)
H1:proj1_sig (tearing_sequences u v en (S n)) =
(r1, r2)
proj1_sig (torn_number u v en) <> r1
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
r, r0:R
H:(fst (r, r0) < snd (r, r0))%R
tear:tearing_sequences u v en n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H
r1, r2:R
ft:first_two_in_interval u v r r0 en H = (r1, r2)
H0:(r < r1)%R /\
(r1 < r0)%R /\
(r < r2)%R /\
(r2 < r0)%R /\
(r1 < r2)%R /\
(forall x : R,
 (r < x)%R ->
 (x < r0)%R -> x <> r1 -> x <> r2 -> v r1 < v x)
H1:proj1_sig (tearing_sequences u v en (S n)) =
(r1, r2)
proj1_sig (torn_number u v en) <> r2
  -
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
r, r0:R
H:(fst (r, r0) < snd (r, r0))%R
tear:tearing_sequences u v en n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H
r1, r2:R
ft:first_two_in_interval u v r r0 en H = (r1, r2)
H0:(r < r1)%R /\
(r1 < r0)%R /\
(r < r2)%R /\
(r2 < r0)%R /\
(r1 < r2)%R /\
(forall x : R,
 (r < x)%R ->
 (x < r0)%R -> x <> r1 -> x <> r2 -> v r1 < v x)
H1:proj1_sig (tearing_sequences u v en (S n)) =
(r1, r2)
(r < proj1_sig (torn_number u v en))%R pose proof (torn_number_above_first_sequence u v en n).
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
r, r0:R
H:(fst (r, r0) < snd (r, r0))%R
tear:tearing_sequences u v en n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H
r1, r2:R
ft:first_two_in_interval u v r r0 en H = (r1, r2)
H0:(r < r1)%R /\
(r1 < r0)%R /\
(r < r2)%R /\
(r2 < r0)%R /\
(r1 < r2)%R /\
(forall x : R,
 (r < x)%R ->
 (x < r0)%R -> x <> r1 -> x <> r2 -> v r1 < v x)
H1:proj1_sig (tearing_sequences u v en (S n)) =
(r1, r2)
H2:(fst (proj1_sig (tearing_sequences u v en n)) <
 proj1_sig (torn_number u v en))%R
(r < proj1_sig (torn_number u v en))%R rewrite -> tear in H2.
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
r, r0:R
H:(fst (r, r0) < snd (r, r0))%R
tear:tearing_sequences u v en n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H
r1, r2:R
ft:first_two_in_interval u v r r0 en H = (r1, r2)
H0:(r < r1)%R /\
(r1 < r0)%R /\
(r < r2)%R /\
(r2 < r0)%R /\
(r1 < r2)%R /\
(forall x : R,
 (r < x)%R ->
 (x < r0)%R -> x <> r1 -> x <> r2 -> v r1 < v x)
H1:proj1_sig (tearing_sequences u v en (S n)) =
(r1, r2)
H2:(fst
   (proj1_sig
      (exist (fun ab : R * R => fst ab < snd ab)
         (r, r0) H)) <
 proj1_sig (torn_number u v en))%R
(r < proj1_sig (torn_number u v en))%R assumption.
  -
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
r, r0:R
H:(fst (r, r0) < snd (r, r0))%R
tear:tearing_sequences u v en n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H
r1, r2:R
ft:first_two_in_interval u v r r0 en H = (r1, r2)
H0:(r < r1)%R /\
(r1 < r0)%R /\
(r < r2)%R /\
(r2 < r0)%R /\
(r1 < r2)%R /\
(forall x : R,
 (r < x)%R ->
 (x < r0)%R -> x <> r1 -> x <> r2 -> v r1 < v x)
H1:proj1_sig (tearing_sequences u v en (S n)) =
(r1, r2)
(proj1_sig (torn_number u v en) < r0)%R pose proof (torn_number_below_second_sequence u v en n).
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
r, r0:R
H:(fst (r, r0) < snd (r, r0))%R
tear:tearing_sequences u v en n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H
r1, r2:R
ft:first_two_in_interval u v r r0 en H = (r1, r2)
H0:(r < r1)%R /\
(r1 < r0)%R /\
(r < r2)%R /\
(r2 < r0)%R /\
(r1 < r2)%R /\
(forall x : R,
 (r < x)%R ->
 (x < r0)%R -> x <> r1 -> x <> r2 -> v r1 < v x)
H1:proj1_sig (tearing_sequences u v en (S n)) =
(r1, r2)
H2:(proj1_sig (torn_number u v en) <
 snd (proj1_sig (tearing_sequences u v en n)))%R
(proj1_sig (torn_number u v en) < r0)%R rewrite -> tear in H2.
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
r, r0:R
H:(fst (r, r0) < snd (r, r0))%R
tear:tearing_sequences u v en n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H
r1, r2:R
ft:first_two_in_interval u v r r0 en H = (r1, r2)
H0:(r < r1)%R /\
(r1 < r0)%R /\
(r < r2)%R /\
(r2 < r0)%R /\
(r1 < r2)%R /\
(forall x : R,
 (r < x)%R ->
 (x < r0)%R -> x <> r1 -> x <> r2 -> v r1 < v x)
H1:proj1_sig (tearing_sequences u v en (S n)) =
(r1, r2)
H2:(proj1_sig (torn_number u v en) <
 snd
   (proj1_sig
      (exist (fun ab : R * R => fst ab < snd ab)
         (r, r0) H)))%R
(proj1_sig (torn_number u v en) < r0)%R assumption.
  -
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
r, r0:R
H:(fst (r, r0) < snd (r, r0))%R
tear:tearing_sequences u v en n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H
r1, r2:R
ft:first_two_in_interval u v r r0 en H = (r1, r2)
H0:(r < r1)%R /\
(r1 < r0)%R /\
(r < r2)%R /\
(r2 < r0)%R /\
(r1 < r2)%R /\
(forall x : R,
 (r < x)%R ->
 (x < r0)%R -> x <> r1 -> x <> r2 -> v r1 < v x)
H1:proj1_sig (tearing_sequences u v en (S n)) =
(r1, r2)
proj1_sig (torn_number u v en) <> r1 pose proof (torn_number_above_first_sequence u v en (S n)).
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
r, r0:R
H:(fst (r, r0) < snd (r, r0))%R
tear:tearing_sequences u v en n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H
r1, r2:R
ft:first_two_in_interval u v r r0 en H = (r1, r2)
H0:(r < r1)%R /\
(r1 < r0)%R /\
(r < r2)%R /\
(r2 < r0)%R /\
(r1 < r2)%R /\
(forall x : R,
 (r < x)%R ->
 (x < r0)%R -> x <> r1 -> x <> r2 -> v r1 < v x)
H1:proj1_sig (tearing_sequences u v en (S n)) =
(r1, r2)
H2:(fst (proj1_sig (tearing_sequences u v en (S n))) <
 proj1_sig (torn_number u v en))%R
proj1_sig (torn_number u v en) <> r1 rewrite -> H1 in H2.
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
r, r0:R
H:(fst (r, r0) < snd (r, r0))%R
tear:tearing_sequences u v en n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H
r1, r2:R
ft:first_two_in_interval u v r r0 en H = (r1, r2)
H0:(r < r1)%R /\
(r1 < r0)%R /\
(r < r2)%R /\
(r2 < r0)%R /\
(r1 < r2)%R /\
(forall x : R,
 (r < x)%R ->
 (x < r0)%R -> x <> r1 -> x <> r2 -> v r1 < v x)
H1:proj1_sig (tearing_sequences u v en (S n)) =
(r1, r2)
H2:(fst (r1, r2) < proj1_sig (torn_number u v en))%R
proj1_sig (torn_number u v en) <> r1 simpl in H2.
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
r, r0:R
H:(fst (r, r0) < snd (r, r0))%R
tear:tearing_sequences u v en n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H
r1, r2:R
ft:first_two_in_interval u v r r0 en H = (r1, r2)
H0:(r < r1)%R /\
(r1 < r0)%R /\
(r < r2)%R /\
(r2 < r0)%R /\
(r1 < r2)%R /\
(forall x : R,
 (r < x)%R ->
 (x < r0)%R -> x <> r1 -> x <> r2 -> v r1 < v x)
H1:proj1_sig (tearing_sequences u v en (S n)) =
(r1, r2)
H2:(r1 < proj1_sig (torn_number u v en))%R
proj1_sig (torn_number u v en) <> r1
    intro H5.
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
r, r0:R
H:(fst (r, r0) < snd (r, r0))%R
tear:tearing_sequences u v en n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H
r1, r2:R
ft:first_two_in_interval u v r r0 en H = (r1, r2)
H0:(r < r1)%R /\
(r1 < r0)%R /\
(r < r2)%R /\
(r2 < r0)%R /\
(r1 < r2)%R /\
(forall x : R,
 (r < x)%R ->
 (x < r0)%R -> x <> r1 -> x <> r2 -> v r1 < v x)
H1:proj1_sig (tearing_sequences u v en (S n)) =
(r1, r2)
H2:(r1 < proj1_sig (torn_number u v en))%R
H5:proj1_sig (torn_number u v en) = r1
False subst.
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
r, r0:R
H:(fst (r, r0) < snd (r, r0))%R
tear:tearing_sequences u v en n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H
r2:R
H2:(proj1_sig (torn_number u v en) <
 proj1_sig (torn_number u v en))%R
H1:proj1_sig (tearing_sequences u v en (S n)) =
(proj1_sig (torn_number u v en), r2)
H0:(r < proj1_sig (torn_number u v en))%R /\
(proj1_sig (torn_number u v en) < r0)%R /\
(r < r2)%R /\
(r2 < r0)%R /\
(proj1_sig (torn_number u v en) < r2)%R /\
(forall x : R,
 (r < x)%R ->
 (x < r0)%R ->
 x <> proj1_sig (torn_number u v en) ->
 x <> r2 ->
 v (proj1_sig (torn_number u v en)) < v x)
ft:first_two_in_interval u v r r0 en H =
(proj1_sig (torn_number u v en), r2)
False apply Rlt_irrefl in H2.
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
r, r0:R
H:(fst (r, r0) < snd (r, r0))%R
tear:tearing_sequences u v en n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H
r2:R
H2:False
H1:proj1_sig (tearing_sequences u v en (S n)) =
(proj1_sig (torn_number u v en), r2)
H0:(r < proj1_sig (torn_number u v en))%R /\
(proj1_sig (torn_number u v en) < r0)%R /\
(r < r2)%R /\
(r2 < r0)%R /\
(proj1_sig (torn_number u v en) < r2)%R /\
(forall x : R,
 (r < x)%R ->
 (x < r0)%R ->
 x <> proj1_sig (torn_number u v en) ->
 x <> r2 ->
 v (proj1_sig (torn_number u v en)) < v x)
ft:first_two_in_interval u v r r0 en H =
(proj1_sig (torn_number u v en), r2)
False contradiction.
  -
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
r, r0:R
H:(fst (r, r0) < snd (r, r0))%R
tear:tearing_sequences u v en n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H
r1, r2:R
ft:first_two_in_interval u v r r0 en H = (r1, r2)
H0:(r < r1)%R /\
(r1 < r0)%R /\
(r < r2)%R /\
(r2 < r0)%R /\
(r1 < r2)%R /\
(forall x : R,
 (r < x)%R ->
 (x < r0)%R -> x <> r1 -> x <> r2 -> v r1 < v x)
H1:proj1_sig (tearing_sequences u v en (S n)) =
(r1, r2)
proj1_sig (torn_number u v en) <> r2 pose proof (torn_number_below_second_sequence u v en (S n)).
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
r, r0:R
H:(fst (r, r0) < snd (r, r0))%R
tear:tearing_sequences u v en n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H
r1, r2:R
ft:first_two_in_interval u v r r0 en H = (r1, r2)
H0:(r < r1)%R /\
(r1 < r0)%R /\
(r < r2)%R /\
(r2 < r0)%R /\
(r1 < r2)%R /\
(forall x : R,
 (r < x)%R ->
 (x < r0)%R -> x <> r1 -> x <> r2 -> v r1 < v x)
H1:proj1_sig (tearing_sequences u v en (S n)) =
(r1, r2)
H2:(proj1_sig (torn_number u v en) <
 snd (proj1_sig (tearing_sequences u v en (S n))))%R
proj1_sig (torn_number u v en) <> r2 rewrite -> H1 in H2.
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
r, r0:R
H:(fst (r, r0) < snd (r, r0))%R
tear:tearing_sequences u v en n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H
r1, r2:R
ft:first_two_in_interval u v r r0 en H = (r1, r2)
H0:(r < r1)%R /\
(r1 < r0)%R /\
(r < r2)%R /\
(r2 < r0)%R /\
(r1 < r2)%R /\
(forall x : R,
 (r < x)%R ->
 (x < r0)%R -> x <> r1 -> x <> r2 -> v r1 < v x)
H1:proj1_sig (tearing_sequences u v en (S n)) =
(r1, r2)
H2:(proj1_sig (torn_number u v en) < snd (r1, r2))%R
proj1_sig (torn_number u v en) <> r2 simpl in H2.
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
r, r0:R
H:(fst (r, r0) < snd (r, r0))%R
tear:tearing_sequences u v en n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H
r1, r2:R
ft:first_two_in_interval u v r r0 en H = (r1, r2)
H0:(r < r1)%R /\
(r1 < r0)%R /\
(r < r2)%R /\
(r2 < r0)%R /\
(r1 < r2)%R /\
(forall x : R,
 (r < x)%R ->
 (x < r0)%R -> x <> r1 -> x <> r2 -> v r1 < v x)
H1:proj1_sig (tearing_sequences u v en (S n)) =
(r1, r2)
H2:(proj1_sig (torn_number u v en) < r2)%R
proj1_sig (torn_number u v en) <> r2
    intro H5.
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
r, r0:R
H:(fst (r, r0) < snd (r, r0))%R
tear:tearing_sequences u v en n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H
r1, r2:R
ft:first_two_in_interval u v r r0 en H = (r1, r2)
H0:(r < r1)%R /\
(r1 < r0)%R /\
(r < r2)%R /\
(r2 < r0)%R /\
(r1 < r2)%R /\
(forall x : R,
 (r < x)%R ->
 (x < r0)%R -> x <> r1 -> x <> r2 -> v r1 < v x)
H1:proj1_sig (tearing_sequences u v en (S n)) =
(r1, r2)
H2:(proj1_sig (torn_number u v en) < r2)%R
H5:proj1_sig (torn_number u v en) = r2
False subst.
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
r, r0:R
H:(fst (r, r0) < snd (r, r0))%R
tear:tearing_sequences u v en n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H
r1:R
H2:(proj1_sig (torn_number u v en) <
 proj1_sig (torn_number u v en))%R
H1:proj1_sig (tearing_sequences u v en (S n)) =
(r1, proj1_sig (torn_number u v en))
H0:(r < r1)%R /\
(r1 < r0)%R /\
(r < proj1_sig (torn_number u v en))%R /\
(proj1_sig (torn_number u v en) < r0)%R /\
(r1 < proj1_sig (torn_number u v en))%R /\
(forall x : R,
 (r < x)%R ->
 (x < r0)%R ->
 x <> r1 ->
 x <> proj1_sig (torn_number u v en) ->
 v r1 < v x)
ft:first_two_in_interval u v r r0 en H =
(r1, proj1_sig (torn_number u v en))
False apply Rlt_irrefl in H2.
u:nat -> R
v:R -> nat
en:enumeration R u v
n:nat
r, r0:R
H:(fst (r, r0) < snd (r, r0))%R
tear:tearing_sequences u v en n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H
r1:R
H2:False
H1:proj1_sig (tearing_sequences u v en (S n)) =
(r1, proj1_sig (torn_number u v en))
H0:(r < r1)%R /\
(r1 < r0)%R /\
(r < proj1_sig (torn_number u v en))%R /\
(proj1_sig (torn_number u v en) < r0)%R /\
(r1 < proj1_sig (torn_number u v en))%R /\
(forall x : R,
 (r < x)%R ->
 (x < r0)%R ->
 x <> r1 ->
 x <> proj1_sig (torn_number u v en) ->
 v r1 < v x)
ft:first_two_in_interval u v r r0 en H =
(r1, proj1_sig (torn_number u v en))
False contradiction.
Qed.

(* The indices increase because each time the minimum index is chosen *)
Lemma first_indices_increasing (u : nat -> R) (v : R -> nat) (H : enumeration R u v)
  : forall n : nat, n <> 0 -> v (fst (proj1_sig (tearing_sequences u v H n)))
                     < v (fst (proj1_sig (tearing_sequences u v H (S n)))).
u:nat -> R
v:R -> nat
H:enumeration R u v
forall n : nat,
n <> 0 ->
v (fst (proj1_sig (tearing_sequences u v H n))) <
v (fst (proj1_sig (tearing_sequences u v H (S n))))
Proof.
u:nat -> R
v:R -> nat
H:enumeration R u v
forall n : nat,
n <> 0 ->
v (fst (proj1_sig (tearing_sequences u v H n))) <
v (fst (proj1_sig (tearing_sequences u v H (S n))))
  intros.
u:nat -> R
v:R -> nat
H:enumeration R u v
n:nat
H0:n <> 0
v (fst (proj1_sig (tearing_sequences u v H n))) <
v (fst (proj1_sig (tearing_sequences u v H (S n)))) destruct n.
u:nat -> R
v:R -> nat
H:enumeration R u v
H0:0 <> 0
v (fst (proj1_sig (tearing_sequences u v H 0))) <
v (fst (proj1_sig (tearing_sequences u v H 1)))
u:nat -> R
v:R -> nat
H:enumeration R u v
n:nat
H0:S n <> 0
v (fst (proj1_sig (tearing_sequences u v H (S n)))) <
v
  (fst (proj1_sig (tearing_sequences u v H (S (S n))))) contradiction.
u:nat -> R
v:R -> nat
H:enumeration R u v
n:nat
H0:S n <> 0
v (fst (proj1_sig (tearing_sequences u v H (S n)))) <
v
  (fst (proj1_sig (tearing_sequences u v H (S (S n)))))
  (* The n+1 and n+2 intervals are drawn from the n-th interval, which we note r r0 *)
  destruct (tearing_sequences u v H n) as [[r r0] H1] eqn:In.
u:nat -> R
v:R -> nat
H:enumeration R u v
n:nat
H0:S n <> 0
r, r0:R
H1:(fst (r, r0) < snd (r, r0))%R
In:tearing_sequences u v H n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H1
v (fst (proj1_sig (tearing_sequences u v H (S n)))) <
v
  (fst (proj1_sig (tearing_sequences u v H (S (S n))))) simpl in H1.
u:nat -> R
v:R -> nat
H:enumeration R u v
n:nat
H0:S n <> 0
r, r0:R
H1:(r < r0)%R
In:tearing_sequences u v H n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H1
v (fst (proj1_sig (tearing_sequences u v H (S n)))) <
v
  (fst (proj1_sig (tearing_sequences u v H (S (S n)))))
  (* Draw the n+1 interval *)
  destruct (tearing_sequences u v H (S n)) as [[r1 r2] H2] eqn:ISn.
u:nat -> R
v:R -> nat
H:enumeration R u v
n:nat
H0:S n <> 0
r, r0:R
H1:(r < r0)%R
In:tearing_sequences u v H n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H1
r1, r2:R
H2:(fst (r1, r2) < snd (r1, r2))%R
ISn:tearing_sequences u v H (S n) =
exist (fun ab : R * R => (fst ab < snd ab)%R) (r1, r2) H2
v
  (fst
     (proj1_sig
        (exist (fun ab : R * R => (fst ab < snd ab)%R)
           (r1, r2) H2))) <
v
  (fst (proj1_sig (tearing_sequences u v H (S (S n))))) simpl in H2.
u:nat -> R
v:R -> nat
H:enumeration R u v
n:nat
H0:S n <> 0
r, r0:R
H1:(r < r0)%R
In:tearing_sequences u v H n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H1
r1, r2:R
H2:(r1 < r2)%R
ISn:tearing_sequences u v H (S n) =
exist (fun ab : R * R => (fst ab < snd ab)%R) (r1, r2) H2
v
  (fst
     (proj1_sig
        (exist (fun ab : R * R => (fst ab < snd ab)%R)
           (r1, r2) H2))) <
v
  (fst (proj1_sig (tearing_sequences u v H (S (S n)))))
  (* Draw the n+2 interval *)
  destruct (tearing_sequences u v H (S (S n))) as [[r3 r4] H3] eqn:ISSn.
u:nat -> R
v:R -> nat
H:enumeration R u v
n:nat
H0:S n <> 0
r, r0:R
H1:(r < r0)%R
In:tearing_sequences u v H n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H1
r1, r2:R
H2:(r1 < r2)%R
ISn:tearing_sequences u v H (S n) =
exist (fun ab : R * R => (fst ab < snd ab)%R) (r1, r2) H2
r3, r4:R
H3:(fst (r3, r4) < snd (r3, r4))%R
ISSn:tearing_sequences u v H (S (S n)) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r3, r4) H3
v
  (fst
     (proj1_sig
        (exist (fun ab : R * R => (fst ab < snd ab)%R)
           (r1, r2) H2))) <
v
  (fst
     (proj1_sig
        (exist (fun ab : R * R => (fst ab < snd ab)%R)
           (r3, r4) H3))) simpl in H3.
u:nat -> R
v:R -> nat
H:enumeration R u v
n:nat
H0:S n <> 0
r, r0:R
H1:(r < r0)%R
In:tearing_sequences u v H n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H1
r1, r2:R
H2:(r1 < r2)%R
ISn:tearing_sequences u v H (S n) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r1, r2) H2
r3, r4:R
H3:(r3 < r4)%R
ISSn:tearing_sequences u v H (S (S n)) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r3, r4) H3
v
  (fst
     (proj1_sig
        (exist (fun ab : R * R => (fst ab < snd ab)%R)
           (r1, r2) H2))) <
v
  (fst
     (proj1_sig
        (exist (fun ab : R * R => (fst ab < snd ab)%R)
           (r3, r4) H3)))
  simpl.
u:nat -> R
v:R -> nat
H:enumeration R u v
n:nat
H0:S n <> 0
r, r0:R
H1:(r < r0)%R
In:tearing_sequences u v H n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H1
r1, r2:R
H2:(r1 < r2)%R
ISn:tearing_sequences u v H (S n) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r1, r2) H2
r3, r4:R
H3:(r3 < r4)%R
ISSn:tearing_sequences u v H (S (S n)) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r3, r4) H3
v r1 < v r3

  assert ((r1,r2) = first_two_in_interval u v r r0 H H1).
u:nat -> R
v:R -> nat
H:enumeration R u v
n:nat
H0:S n <> 0
r, r0:R
H1:(r < r0)%R
In:tearing_sequences u v H n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H1
r1, r2:R
H2:(r1 < r2)%R
ISn:tearing_sequences u v H (S n) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r1, r2) H2
r3, r4:R
H3:(r3 < r4)%R
ISSn:tearing_sequences u v H (S (S n)) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r3, r4) H3
(r1, r2) = first_two_in_interval u v r r0 H H1
u:nat -> R
v:R -> nat
H:enumeration R u v
n:nat
H0:S n <> 0
r, r0:R
H1:(r < r0)%R
In:tearing_sequences u v H n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H1
r1, r2:R
H2:(r1 < r2)%R
ISn:tearing_sequences u v H (S n) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r1, r2) H2
r3, r4:R
H3:(r3 < r4)%R
ISSn:tearing_sequences u v H (S (S n)) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r3, r4) H3
H4:(r1, r2) = first_two_in_interval u v r r0 H H1
v r1 < v r3
  {
u:nat -> R
v:R -> nat
H:enumeration R u v
n:nat
H0:S n <> 0
r, r0:R
H1:(r < r0)%R
In:tearing_sequences u v H n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H1
r1, r2:R
H2:(r1 < r2)%R
ISn:tearing_sequences u v H (S n) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r1, r2) H2
r3, r4:R
H3:(r3 < r4)%R
ISSn:tearing_sequences u v H (S (S n)) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r3, r4) H3
(r1, r2) = first_two_in_interval u v r r0 H H1 simpl in ISn.
u:nat -> R
v:R -> nat
H:enumeration R u v
n:nat
H0:S n <> 0
r, r0:R
H1:(r < r0)%R
In:tearing_sequences u v H n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H1
r1, r2:R
H2:(r1 < r2)%R
ISn:(let (x, x0) := tearing_sequences u v H n in
 (let
    (a, b) as p
     return
       ((fst p < snd p)%R ->
        {ab : R * R | (fst ab < snd ab)%R}) :=
    x in
  fun pr : (a < b)%R =>
  exist (fun ab : R * R => (fst ab < snd ab)%R)
    (first_two_in_interval u v a b H pr)
    ((let
        (r5, r6) as p
         return
           ((let (c, d) := p in
             (a < c)%R /\
             (c < b)%R /\
             (a < d)%R /\
             (d < b)%R /\
             (c < d)%R /\
             (forall ..., ...%R -> ...)) ->
            (fst p < snd p)%R) :=
        first_two_in_interval u v a b H pr in
      fun
        H4 : (a < r5)%R /\
             (r5 < b)%R /\
             (a < r6)%R /\
             (r6 < b)%R /\
             (r5 < r6)%R /\
             (forall x0 : R,
              (a < x0)%R ->
              (x0 < b)%R ->
              x0 <> r5 -> x0 <> r6 -> ... < ...)
      =>
      match
        match
          match match ... with
                | ... H6
                end with
          | conj _ H6 => H6
          end
        with
        | conj _ H6 => H6
        end
      with
      | conj H5 _ => H5
      end)
       (first_two_in_interval_works u v a b H pr)))
   x0) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r1, r2) H2
r3, r4:R
H3:(r3 < r4)%R
ISSn:tearing_sequences u v H (S (S n)) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r3, r4) H3
(r1, r2) = first_two_in_interval u v r r0 H H1 rewrite -> In in ISn.
u:nat -> R
v:R -> nat
H:enumeration R u v
n:nat
H0:S n <> 0
r, r0:R
H1:(r < r0)%R
In:tearing_sequences u v H n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H1
r1, r2:R
H2:(r1 < r2)%R
ISn:exist (fun ab : R * R => (fst ab < snd ab)%R)
  (first_two_in_interval u v r r0 H H1)
  ((let
      (r5, r6) as p
       return
         ((let (c, d) := p in
           (r < c)%R /\
           (c < r0)%R /\
           (r < d)%R /\
           (d < r0)%R /\
           (c < d)%R /\
           (forall x : R,
            (r < x)%R ->
            (x < r0)%R ->
            x <> c -> x <> d -> v c < v x)) ->
          (fst p < snd p)%R) :=
      first_two_in_interval u v r r0 H H1 in
    fun
      H4 : (r < r5)%R /\
           (r5 < r0)%R /\
           (r < r6)%R /\
           (r6 < r0)%R /\
           (r5 < r6)%R /\
           (forall x : R,
            (r < x)%R ->
            (x < r0)%R ->
            x <> r5 -> x <> r6 -> v r5 < v x) =>
    match
      match
        match
          match
            match H4 with
            | conj _ H6 => H6
            end
          with
          | conj _ H6 => H6
          end
        with
        | conj _ H6 => H6
        end
      with
      | conj _ H6 => H6
      end
    with
    | conj H5 _ => H5
    end)
     (first_two_in_interval_works u v r r0 H H1)) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r1, r2) H2
r3, r4:R
H3:(r3 < r4)%R
ISSn:tearing_sequences u v H (S (S n)) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r3, r4) H3
(r1, r2) = first_two_in_interval u v r r0 H H1 inversion ISn.
u:nat -> R
v:R -> nat
H:enumeration R u v
n:nat
H0:S n <> 0
r, r0:R
H1:(r < r0)%R
In:tearing_sequences u v H n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H1
r1, r2:R
H2:(r1 < r2)%R
ISn:exist (fun ab : R * R => (fst ab < snd ab)%R)
  (first_two_in_interval u v r r0 H H1)
  ((let
      (r5, r6) as p
       return
         ((let (c, d) := p in
           (r < c)%R /\
           (c < r0)%R /\
           (r < d)%R /\
           (d < r0)%R /\
           (c < d)%R /\
           (forall x : R,
            (r < x)%R ->
            (x < r0)%R ->
            x <> c -> x <> d -> v c < v x)) ->
          (fst p < snd p)%R) :=
      first_two_in_interval u v r r0 H H1 in
    fun
      H4 : (r < r5)%R /\
           (r5 < r0)%R /\
           (r < r6)%R /\
           (r6 < r0)%R /\
           (r5 < r6)%R /\
           (forall x : R,
            (r < x)%R ->
            (x < r0)%R ->
            x <> r5 -> x <> r6 -> v r5 < v x) =>
    match
      match
        match
          match
            match H4 with
            | conj _ H7 => H7
            end
          with
          | conj _ H7 => H7
          end
        with
        | conj _ H7 => H7
        end
      with
      | conj _ H7 => H7
      end
    with
    | conj H6 _ => H6
    end)
     (first_two_in_interval_works u v r r0 H H1)) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r1, r2) H2
r3, r4:R
H3:(r3 < r4)%R
ISSn:tearing_sequences u v H (S (S n)) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r3, r4) H3
H5:first_two_in_interval u v r r0 H H1 = (r1, r2)
first_two_in_interval u v r r0 H H1 =
first_two_in_interval u v r r0 H H1 reflexivity. }
u:nat -> R
v:R -> nat
H:enumeration R u v
n:nat
H0:S n <> 0
r, r0:R
H1:(r < r0)%R
In:tearing_sequences u v H n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H1
r1, r2:R
H2:(r1 < r2)%R
ISn:tearing_sequences u v H (S n) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r1, r2) H2
r3, r4:R
H3:(r3 < r4)%R
ISSn:tearing_sequences u v H (S (S n)) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r3, r4) H3
H4:(r1, r2) = first_two_in_interval u v r r0 H H1
v r1 < v r3
  assert ((r3,r4) = first_two_in_interval u v r1 r2 H H2).
u:nat -> R
v:R -> nat
H:enumeration R u v
n:nat
H0:S n <> 0
r, r0:R
H1:(r < r0)%R
In:tearing_sequences u v H n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H1
r1, r2:R
H2:(r1 < r2)%R
ISn:tearing_sequences u v H (S n) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r1, r2) H2
r3, r4:R
H3:(r3 < r4)%R
ISSn:tearing_sequences u v H (S (S n)) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r3, r4) H3
H4:(r1, r2) = first_two_in_interval u v r r0 H H1
(r3, r4) = first_two_in_interval u v r1 r2 H H2
u:nat -> R
v:R -> nat
H:enumeration R u v
n:nat
H0:S n <> 0
r, r0:R
H1:(r < r0)%R
In:tearing_sequences u v H n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H1
r1, r2:R
H2:(r1 < r2)%R
ISn:tearing_sequences u v H (S n) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r1, r2) H2
r3, r4:R
H3:(r3 < r4)%R
ISSn:tearing_sequences u v H (S (S n)) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r3, r4) H3
H4:(r1, r2) = first_two_in_interval u v r r0 H H1
H5:(r3, r4) = first_two_in_interval u v r1 r2 H H2
v r1 < v r3
  {
u:nat -> R
v:R -> nat
H:enumeration R u v
n:nat
H0:S n <> 0
r, r0:R
H1:(r < r0)%R
In:tearing_sequences u v H n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H1
r1, r2:R
H2:(r1 < r2)%R
ISn:tearing_sequences u v H (S n) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r1, r2) H2
r3, r4:R
H3:(r3 < r4)%R
ISSn:tearing_sequences u v H (S (S n)) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r3, r4) H3
H4:(r1, r2) = first_two_in_interval u v r r0 H H1
(r3, r4) = first_two_in_interval u v r1 r2 H H2 pose proof (tearing_sequences_projsig u v H (S n)).
u:nat -> R
v:R -> nat
H:enumeration R u v
n:nat
H0:S n <> 0
r, r0:R
H1:(r < r0)%R
In:tearing_sequences u v H n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H1
r1, r2:R
H2:(r1 < r2)%R
ISn:tearing_sequences u v H (S n) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r1, r2) H2
r3, r4:R
H3:(r3 < r4)%R
ISSn:tearing_sequences u v H (S (S n)) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r3, r4) H3
H4:(r1, r2) = first_two_in_interval u v r r0 H H1
H5:let (I, pr) := tearing_sequences u v H (S n) in
proj1_sig (tearing_sequences u v H (S (S n))) =
first_two_in_interval u v (fst I) (snd I) H pr
(r3, r4) = first_two_in_interval u v r1 r2 H H2 rewrite -> ISn in H5.
u:nat -> R
v:R -> nat
H:enumeration R u v
n:nat
H0:S n <> 0
r, r0:R
H1:(r < r0)%R
In:tearing_sequences u v H n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H1
r1, r2:R
H2:(r1 < r2)%R
ISn:tearing_sequences u v H (S n) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r1, r2) H2
r3, r4:R
H3:(r3 < r4)%R
ISSn:tearing_sequences u v H (S (S n)) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r3, r4) H3
H4:(r1, r2) = first_two_in_interval u v r r0 H H1
H5:proj1_sig (tearing_sequences u v H (S (S n))) =
first_two_in_interval u v 
  (fst (r1, r2)) (snd (r1, r2)) H H2
(r3, r4) = first_two_in_interval u v r1 r2 H H2
    rewrite -> ISSn in H5.
u:nat -> R
v:R -> nat
H:enumeration R u v
n:nat
H0:S n <> 0
r, r0:R
H1:(r < r0)%R
In:tearing_sequences u v H n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H1
r1, r2:R
H2:(r1 < r2)%R
ISn:tearing_sequences u v H (S n) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r1, r2) H2
r3, r4:R
H3:(r3 < r4)%R
ISSn:tearing_sequences u v H (S (S n)) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r3, r4) H3
H4:(r1, r2) = first_two_in_interval u v r r0 H H1
H5:proj1_sig
  (exist (fun ab : R * R => (fst ab < snd ab)%R)
     (r3, r4) H3) =
first_two_in_interval u v 
  (fst (r1, r2)) (snd (r1, r2)) H H2
(r3, r4) = first_two_in_interval u v r1 r2 H H2 apply H5. }
u:nat -> R
v:R -> nat
H:enumeration R u v
n:nat
H0:S n <> 0
r, r0:R
H1:(r < r0)%R
In:tearing_sequences u v H n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H1
r1, r2:R
H2:(r1 < r2)%R
ISn:tearing_sequences u v H (S n) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r1, r2) H2
r3, r4:R
H3:(r3 < r4)%R
ISSn:tearing_sequences u v H (S (S n)) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r3, r4) H3
H4:(r1, r2) = first_two_in_interval u v r r0 H H1
H5:(r3, r4) = first_two_in_interval u v r1 r2 H H2
v r1 < v r3

  pose proof (first_two_in_interval_works u v r r0 H H1) as firstChoiceWorks.
u:nat -> R
v:R -> nat
H:enumeration R u v
n:nat
H0:S n <> 0
r, r0:R
H1:(r < r0)%R
In:tearing_sequences u v H n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H1
r1, r2:R
H2:(r1 < r2)%R
ISn:tearing_sequences u v H (S n) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r1, r2) H2
r3, r4:R
H3:(r3 < r4)%R
ISSn:tearing_sequences u v H (S (S n)) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r3, r4) H3
H4:(r1, r2) = first_two_in_interval u v r r0 H H1
H5:(r3, r4) = first_two_in_interval u v r1 r2 H H2
firstChoiceWorks:let (c, d) :=
  first_two_in_interval u v r r0 H
    H1 in
(r < c)%R /\
(c < r0)%R /\
(r < d)%R /\
(d < r0)%R /\
(c < d)%R /\
(forall x : R,
 (r < x)%R ->
 (x < r0)%R ->
 x <> c -> x <> d -> v c < v x)
v r1 < v r3
  rewrite <- H4 in firstChoiceWorks.
u:nat -> R
v:R -> nat
H:enumeration R u v
n:nat
H0:S n <> 0
r, r0:R
H1:(r < r0)%R
In:tearing_sequences u v H n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H1
r1, r2:R
H2:(r1 < r2)%R
ISn:tearing_sequences u v H (S n) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r1, r2) H2
r3, r4:R
H3:(r3 < r4)%R
ISSn:tearing_sequences u v H (S (S n)) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r3, r4) H3
H4:(r1, r2) = first_two_in_interval u v r r0 H H1
H5:(r3, r4) = first_two_in_interval u v r1 r2 H H2
firstChoiceWorks:(r < r1)%R /\
(r1 < r0)%R /\
(r < r2)%R /\
(r2 < r0)%R /\
(r1 < r2)%R /\
(forall x : R,
 (r < x)%R ->
 (x < r0)%R ->
 x <> r1 -> x <> r2 -> v r1 < v x)
v r1 < v r3
  destruct firstChoiceWorks as [fth [fth0 [fth1 [fth2 [fth3 fth4]]]]].
u:nat -> R
v:R -> nat
H:enumeration R u v
n:nat
H0:S n <> 0
r, r0:R
H1:(r < r0)%R
In:tearing_sequences u v H n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H1
r1, r2:R
H2:(r1 < r2)%R
ISn:tearing_sequences u v H (S n) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r1, r2) H2
r3, r4:R
H3:(r3 < r4)%R
ISSn:tearing_sequences u v H (S (S n)) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r3, r4) H3
H4:(r1, r2) = first_two_in_interval u v r r0 H H1
H5:(r3, r4) = first_two_in_interval u v r1 r2 H H2
fth:(r < r1)%R
fth0:(r1 < r0)%R
fth1:(r < r2)%R
fth2:(r2 < r0)%R
fth3:(r1 < r2)%R
fth4:forall x : R,
(r < x)%R ->
(x < r0)%R -> x <> r1 -> x <> r2 -> v r1 < v x
v r1 < v r3

  (* to prove the n+2 left bound in between r1 and r2 *)
  pose proof (first_two_in_interval_works u v r1 r2 H H2).
u:nat -> R
v:R -> nat
H:enumeration R u v
n:nat
H0:S n <> 0
r, r0:R
H1:(r < r0)%R
In:tearing_sequences u v H n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H1
r1, r2:R
H2:(r1 < r2)%R
ISn:tearing_sequences u v H (S n) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r1, r2) H2
r3, r4:R
H3:(r3 < r4)%R
ISSn:tearing_sequences u v H (S (S n)) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r3, r4) H3
H4:(r1, r2) = first_two_in_interval u v r r0 H H1
H5:(r3, r4) = first_two_in_interval u v r1 r2 H H2
fth:(r < r1)%R
fth0:(r1 < r0)%R
fth1:(r < r2)%R
fth2:(r2 < r0)%R
fth3:(r1 < r2)%R
fth4:forall x : R,
(r < x)%R ->
(x < r0)%R -> x <> r1 -> x <> r2 -> v r1 < v x
H6:let (c, d) :=
  first_two_in_interval u v r1 r2 H H2 in
(r1 < c)%R /\
(c < r2)%R /\
(r1 < d)%R /\
(d < r2)%R /\
(c < d)%R /\
(forall x : R,
 (r1 < x)%R ->
 (x < r2)%R -> x <> c -> x <> d -> v c < v x)
v r1 < v r3
  rewrite <- H5 in H6.
u:nat -> R
v:R -> nat
H:enumeration R u v
n:nat
H0:S n <> 0
r, r0:R
H1:(r < r0)%R
In:tearing_sequences u v H n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H1
r1, r2:R
H2:(r1 < r2)%R
ISn:tearing_sequences u v H (S n) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r1, r2) H2
r3, r4:R
H3:(r3 < r4)%R
ISSn:tearing_sequences u v H (S (S n)) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r3, r4) H3
H4:(r1, r2) = first_two_in_interval u v r r0 H H1
H5:(r3, r4) = first_two_in_interval u v r1 r2 H H2
fth:(r < r1)%R
fth0:(r1 < r0)%R
fth1:(r < r2)%R
fth2:(r2 < r0)%R
fth3:(r1 < r2)%R
fth4:forall x : R,
(r < x)%R ->
(x < r0)%R -> x <> r1 -> x <> r2 -> v r1 < v x
H6:(r1 < r3)%R /\
(r3 < r2)%R /\
(r1 < r4)%R /\
(r4 < r2)%R /\
(r3 < r4)%R /\
(forall x : R,
 (r1 < x)%R ->
 (x < r2)%R -> x <> r3 -> x <> r4 -> v r3 < v x)
v r1 < v r3 destruct H6 as [H6 [H7 [H8 [H9 [H10 H11]]]]].
u:nat -> R
v:R -> nat
H:enumeration R u v
n:nat
H0:S n <> 0
r, r0:R
H1:(r < r0)%R
In:tearing_sequences u v H n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H1
r1, r2:R
H2:(r1 < r2)%R
ISn:tearing_sequences u v H (S n) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r1, r2) H2
r3, r4:R
H3:(r3 < r4)%R
ISSn:tearing_sequences u v H (S (S n)) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r3, r4) H3
H4:(r1, r2) = first_two_in_interval u v r r0 H H1
H5:(r3, r4) = first_two_in_interval u v r1 r2 H H2
fth:(r < r1)%R
fth0:(r1 < r0)%R
fth1:(r < r2)%R
fth2:(r2 < r0)%R
fth3:(r1 < r2)%R
fth4:forall x : R,
(r < x)%R ->
(x < r0)%R -> x <> r1 -> x <> r2 -> v r1 < v x
H6:(r1 < r3)%R
H7:(r3 < r2)%R
H8:(r1 < r4)%R
H9:(r4 < r2)%R
H10:(r3 < r4)%R
H11:forall x : R,
(r1 < x)%R ->
(x < r2)%R -> x <> r3 -> x <> r4 -> v r3 < v x
v r1 < v r3 apply fth4.
u:nat -> R
v:R -> nat
H:enumeration R u v
n:nat
H0:S n <> 0
r, r0:R
H1:(r < r0)%R
In:tearing_sequences u v H n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H1
r1, r2:R
H2:(r1 < r2)%R
ISn:tearing_sequences u v H (S n) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r1, r2) H2
r3, r4:R
H3:(r3 < r4)%R
ISSn:tearing_sequences u v H (S (S n)) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r3, r4) H3
H4:(r1, r2) = first_two_in_interval u v r r0 H H1
H5:(r3, r4) = first_two_in_interval u v r1 r2 H H2
fth:(r < r1)%R
fth0:(r1 < r0)%R
fth1:(r < r2)%R
fth2:(r2 < r0)%R
fth3:(r1 < r2)%R
fth4:forall x : R,
(r < x)%R ->
(x < r0)%R -> x <> r1 -> x <> r2 -> v r1 < v x
H6:(r1 < r3)%R
H7:(r3 < r2)%R
H8:(r1 < r4)%R
H9:(r4 < r2)%R
H10:(r3 < r4)%R
H11:forall x : R,
(r1 < x)%R ->
(x < r2)%R -> x <> r3 -> x <> r4 -> v r3 < v x
(r < r3)%R
u:nat -> R
v:R -> nat
H:enumeration R u v
n:nat
H0:S n <> 0
r, r0:R
H1:(r < r0)%R
In:tearing_sequences u v H n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H1
r1, r2:R
H2:(r1 < r2)%R
ISn:tearing_sequences u v H (S n) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r1, r2) H2
r3, r4:R
H3:(r3 < r4)%R
ISSn:tearing_sequences u v H (S (S n)) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r3, r4) H3
H4:(r1, r2) = first_two_in_interval u v r r0 H H1
H5:(r3, r4) = first_two_in_interval u v r1 r2 H H2
fth:(r < r1)%R
fth0:(r1 < r0)%R
fth1:(r < r2)%R
fth2:(r2 < r0)%R
fth3:(r1 < r2)%R
fth4:forall x : R,
(r < x)%R ->
(x < r0)%R -> x <> r1 -> x <> r2 -> v r1 < v x
H6:(r1 < r3)%R
H7:(r3 < r2)%R
H8:(r1 < r4)%R
H9:(r4 < r2)%R
H10:(r3 < r4)%R
H11:forall x : R,
(r1 < x)%R ->
(x < r2)%R -> x <> r3 -> x <> r4 -> v r3 < v x
(r3 < r0)%R
u:nat -> R
v:R -> nat
H:enumeration R u v
n:nat
H0:S n <> 0
r, r0:R
H1:(r < r0)%R
In:tearing_sequences u v H n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H1
r1, r2:R
H2:(r1 < r2)%R
ISn:tearing_sequences u v H (S n) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r1, r2) H2
r3, r4:R
H3:(r3 < r4)%R
ISSn:tearing_sequences u v H (S (S n)) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r3, r4) H3
H4:(r1, r2) = first_two_in_interval u v r r0 H H1
H5:(r3, r4) = first_two_in_interval u v r1 r2 H H2
fth:(r < r1)%R
fth0:(r1 < r0)%R
fth1:(r < r2)%R
fth2:(r2 < r0)%R
fth3:(r1 < r2)%R
fth4:forall x : R,
(r < x)%R ->
(x < r0)%R -> x <> r1 -> x <> r2 -> v r1 < v x
H6:(r1 < r3)%R
H7:(r3 < r2)%R
H8:(r1 < r4)%R
H9:(r4 < r2)%R
H10:(r3 < r4)%R
H11:forall x : R,
(r1 < x)%R ->
(x < r2)%R -> x <> r3 -> x <> r4 -> v r3 < v x
r3 <> r1
u:nat -> R
v:R -> nat
H:enumeration R u v
n:nat
H0:S n <> 0
r, r0:R
H1:(r < r0)%R
In:tearing_sequences u v H n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H1
r1, r2:R
H2:(r1 < r2)%R
ISn:tearing_sequences u v H (S n) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r1, r2) H2
r3, r4:R
H3:(r3 < r4)%R
ISSn:tearing_sequences u v H (S (S n)) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r3, r4) H3
H4:(r1, r2) = first_two_in_interval u v r r0 H H1
H5:(r3, r4) = first_two_in_interval u v r1 r2 H H2
fth:(r < r1)%R
fth0:(r1 < r0)%R
fth1:(r < r2)%R
fth2:(r2 < r0)%R
fth3:(r1 < r2)%R
fth4:forall x : R,
(r < x)%R ->
(x < r0)%R -> x <> r1 -> x <> r2 -> v r1 < v x
H6:(r1 < r3)%R
H7:(r3 < r2)%R
H8:(r1 < r4)%R
H9:(r4 < r2)%R
H10:(r3 < r4)%R
H11:forall x : R,
(r1 < x)%R ->
(x < r2)%R -> x <> r3 -> x <> r4 -> v r3 < v x
r3 <> r2
  -
u:nat -> R
v:R -> nat
H:enumeration R u v
n:nat
H0:S n <> 0
r, r0:R
H1:(r < r0)%R
In:tearing_sequences u v H n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H1
r1, r2:R
H2:(r1 < r2)%R
ISn:tearing_sequences u v H (S n) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r1, r2) H2
r3, r4:R
H3:(r3 < r4)%R
ISSn:tearing_sequences u v H (S (S n)) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r3, r4) H3
H4:(r1, r2) = first_two_in_interval u v r r0 H H1
H5:(r3, r4) = first_two_in_interval u v r1 r2 H H2
fth:(r < r1)%R
fth0:(r1 < r0)%R
fth1:(r < r2)%R
fth2:(r2 < r0)%R
fth3:(r1 < r2)%R
fth4:forall x : R,
(r < x)%R ->
(x < r0)%R -> x <> r1 -> x <> r2 -> v r1 < v x
H6:(r1 < r3)%R
H7:(r3 < r2)%R
H8:(r1 < r4)%R
H9:(r4 < r2)%R
H10:(r3 < r4)%R
H11:forall x : R,
(r1 < x)%R ->
(x < r2)%R -> x <> r3 -> x <> r4 -> v r3 < v x
(r < r3)%R apply (Rlt_trans r r1); assumption.
  -
u:nat -> R
v:R -> nat
H:enumeration R u v
n:nat
H0:S n <> 0
r, r0:R
H1:(r < r0)%R
In:tearing_sequences u v H n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H1
r1, r2:R
H2:(r1 < r2)%R
ISn:tearing_sequences u v H (S n) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r1, r2) H2
r3, r4:R
H3:(r3 < r4)%R
ISSn:tearing_sequences u v H (S (S n)) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r3, r4) H3
H4:(r1, r2) = first_two_in_interval u v r r0 H H1
H5:(r3, r4) = first_two_in_interval u v r1 r2 H H2
fth:(r < r1)%R
fth0:(r1 < r0)%R
fth1:(r < r2)%R
fth2:(r2 < r0)%R
fth3:(r1 < r2)%R
fth4:forall x : R,
(r < x)%R ->
(x < r0)%R -> x <> r1 -> x <> r2 -> v r1 < v x
H6:(r1 < r3)%R
H7:(r3 < r2)%R
H8:(r1 < r4)%R
H9:(r4 < r2)%R
H10:(r3 < r4)%R
H11:forall x : R,
(r1 < x)%R ->
(x < r2)%R -> x <> r3 -> x <> r4 -> v r3 < v x
(r3 < r0)%R apply (Rlt_trans r3 r2); assumption.
  -
u:nat -> R
v:R -> nat
H:enumeration R u v
n:nat
H0:S n <> 0
r, r0:R
H1:(r < r0)%R
In:tearing_sequences u v H n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H1
r1, r2:R
H2:(r1 < r2)%R
ISn:tearing_sequences u v H (S n) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r1, r2) H2
r3, r4:R
H3:(r3 < r4)%R
ISSn:tearing_sequences u v H (S (S n)) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r3, r4) H3
H4:(r1, r2) = first_two_in_interval u v r r0 H H1
H5:(r3, r4) = first_two_in_interval u v r1 r2 H H2
fth:(r < r1)%R
fth0:(r1 < r0)%R
fth1:(r < r2)%R
fth2:(r2 < r0)%R
fth3:(r1 < r2)%R
fth4:forall x : R,
(r < x)%R ->
(x < r0)%R -> x <> r1 -> x <> r2 -> v r1 < v x
H6:(r1 < r3)%R
H7:(r3 < r2)%R
H8:(r1 < r4)%R
H9:(r4 < r2)%R
H10:(r3 < r4)%R
H11:forall x : R,
(r1 < x)%R ->
(x < r2)%R -> x <> r3 -> x <> r4 -> v r3 < v x
r3 <> r1 intro abs.
u:nat -> R
v:R -> nat
H:enumeration R u v
n:nat
H0:S n <> 0
r, r0:R
H1:(r < r0)%R
In:tearing_sequences u v H n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H1
r1, r2:R
H2:(r1 < r2)%R
ISn:tearing_sequences u v H (S n) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r1, r2) H2
r3, r4:R
H3:(r3 < r4)%R
ISSn:tearing_sequences u v H (S (S n)) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r3, r4) H3
H4:(r1, r2) = first_two_in_interval u v r r0 H H1
H5:(r3, r4) = first_two_in_interval u v r1 r2 H H2
fth:(r < r1)%R
fth0:(r1 < r0)%R
fth1:(r < r2)%R
fth2:(r2 < r0)%R
fth3:(r1 < r2)%R
fth4:forall x : R,
(r < x)%R ->
(x < r0)%R -> x <> r1 -> x <> r2 -> v r1 < v x
H6:(r1 < r3)%R
H7:(r3 < r2)%R
H8:(r1 < r4)%R
H9:(r4 < r2)%R
H10:(r3 < r4)%R
H11:forall x : R,
(r1 < x)%R ->
(x < r2)%R -> x <> r3 -> x <> r4 -> v r3 < v x
abs:r3 = r1
False subst.
u:nat -> R
v:R -> nat
H:enumeration R u v
n:nat
H0:S n <> 0
r, r0:R
H1:(r < r0)%R
In:tearing_sequences u v H n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H1
r1, r2:R
H2:(r1 < r2)%R
ISn:tearing_sequences u v H (S n) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r1, r2) H2
r4:R
H3:(r1 < r4)%R
ISSn:tearing_sequences u v H (S (S n)) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r1, r4) H3
H4:(r1, r2) = first_two_in_interval u v r r0 H H1
H5:(r1, r4) = first_two_in_interval u v r1 r2 H H2
fth:(r < r1)%R
fth0:(r1 < r0)%R
fth1:(r < r2)%R
fth2:(r2 < r0)%R
fth3:(r1 < r2)%R
fth4:forall x : R,
(r < x)%R ->
(x < r0)%R -> x <> r1 -> x <> r2 -> v r1 < v x
H7:(r1 < r2)%R
H6:(r1 < r1)%R
H8:(r1 < r4)%R
H9:(r4 < r2)%R
H11:forall x : R,
(r1 < x)%R ->
(x < r2)%R -> x <> r1 -> x <> r4 -> v r1 < v x
H10:(r1 < r4)%R
False apply Rlt_irrefl in H6.
u:nat -> R
v:R -> nat
H:enumeration R u v
n:nat
H0:S n <> 0
r, r0:R
H1:(r < r0)%R
In:tearing_sequences u v H n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H1
r1, r2:R
H2:(r1 < r2)%R
ISn:tearing_sequences u v H (S n) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r1, r2) H2
r4:R
H3:(r1 < r4)%R
ISSn:tearing_sequences u v H (S (S n)) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r1, r4) H3
H4:(r1, r2) = first_two_in_interval u v r r0 H H1
H5:(r1, r4) = first_two_in_interval u v r1 r2 H H2
fth:(r < r1)%R
fth0:(r1 < r0)%R
fth1:(r < r2)%R
fth2:(r2 < r0)%R
fth3:(r1 < r2)%R
fth4:forall x : R,
(r < x)%R ->
(x < r0)%R -> x <> r1 -> x <> r2 -> v r1 < v x
H7:(r1 < r2)%R
H6:False
H8:(r1 < r4)%R
H9:(r4 < r2)%R
H11:forall x : R,
(r1 < x)%R ->
(x < r2)%R -> x <> r1 -> x <> r4 -> v r1 < v x
H10:(r1 < r4)%R
False contradiction.
  -
u:nat -> R
v:R -> nat
H:enumeration R u v
n:nat
H0:S n <> 0
r, r0:R
H1:(r < r0)%R
In:tearing_sequences u v H n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H1
r1, r2:R
H2:(r1 < r2)%R
ISn:tearing_sequences u v H (S n) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r1, r2) H2
r3, r4:R
H3:(r3 < r4)%R
ISSn:tearing_sequences u v H (S (S n)) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r3, r4) H3
H4:(r1, r2) = first_two_in_interval u v r r0 H H1
H5:(r3, r4) = first_two_in_interval u v r1 r2 H H2
fth:(r < r1)%R
fth0:(r1 < r0)%R
fth1:(r < r2)%R
fth2:(r2 < r0)%R
fth3:(r1 < r2)%R
fth4:forall x : R,
(r < x)%R ->
(x < r0)%R -> x <> r1 -> x <> r2 -> v r1 < v x
H6:(r1 < r3)%R
H7:(r3 < r2)%R
H8:(r1 < r4)%R
H9:(r4 < r2)%R
H10:(r3 < r4)%R
H11:forall x : R,
(r1 < x)%R ->
(x < r2)%R -> x <> r3 -> x <> r4 -> v r3 < v x
r3 <> r2 intro abs.
u:nat -> R
v:R -> nat
H:enumeration R u v
n:nat
H0:S n <> 0
r, r0:R
H1:(r < r0)%R
In:tearing_sequences u v H n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H1
r1, r2:R
H2:(r1 < r2)%R
ISn:tearing_sequences u v H (S n) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r1, r2) H2
r3, r4:R
H3:(r3 < r4)%R
ISSn:tearing_sequences u v H (S (S n)) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r3, r4) H3
H4:(r1, r2) = first_two_in_interval u v r r0 H H1
H5:(r3, r4) = first_two_in_interval u v r1 r2 H H2
fth:(r < r1)%R
fth0:(r1 < r0)%R
fth1:(r < r2)%R
fth2:(r2 < r0)%R
fth3:(r1 < r2)%R
fth4:forall x : R,
(r < x)%R ->
(x < r0)%R -> x <> r1 -> x <> r2 -> v r1 < v x
H6:(r1 < r3)%R
H7:(r3 < r2)%R
H8:(r1 < r4)%R
H9:(r4 < r2)%R
H10:(r3 < r4)%R
H11:forall x : R,
(r1 < x)%R ->
(x < r2)%R -> x <> r3 -> x <> r4 -> v r3 < v x
abs:r3 = r2
False subst.
u:nat -> R
v:R -> nat
H:enumeration R u v
n:nat
H0:S n <> 0
r, r0:R
H1:(r < r0)%R
In:tearing_sequences u v H n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H1
r1, r2:R
H2:(r1 < r2)%R
ISn:tearing_sequences u v H (S n) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r1, r2) H2
r4:R
H3:(r2 < r4)%R
ISSn:tearing_sequences u v H (S (S n)) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r2, r4) H3
H4:(r1, r2) = first_two_in_interval u v r r0 H H1
H5:(r2, r4) = first_two_in_interval u v r1 r2 H H2
fth:(r < r1)%R
fth0:(r1 < r0)%R
fth1:(r < r2)%R
fth2:(r2 < r0)%R
fth3:(r1 < r2)%R
fth4:forall x : R,
(r < x)%R ->
(x < r0)%R -> x <> r1 -> x <> r2 -> v r1 < v x
H7:(r2 < r2)%R
H6:(r1 < r2)%R
H8:(r1 < r4)%R
H9:(r4 < r2)%R
H11:forall x : R,
(r1 < x)%R ->
(x < r2)%R -> x <> r2 -> x <> r4 -> v r2 < v x
H10:(r2 < r4)%R
False apply Rlt_irrefl in H7.
u:nat -> R
v:R -> nat
H:enumeration R u v
n:nat
H0:S n <> 0
r, r0:R
H1:(r < r0)%R
In:tearing_sequences u v H n =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r, r0) H1
r1, r2:R
H2:(r1 < r2)%R
ISn:tearing_sequences u v H (S n) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r1, r2) H2
r4:R
H3:(r2 < r4)%R
ISSn:tearing_sequences u v H (S (S n)) =
exist (fun ab : R * R => (fst ab < snd ab)%R)
  (r2, r4) H3
H4:(r1, r2) = first_two_in_interval u v r r0 H H1
H5:(r2, r4) = first_two_in_interval u v r1 r2 H H2
fth:(r < r1)%R
fth0:(r1 < r0)%R
fth1:(r < r2)%R
fth2:(r2 < r0)%R
fth3:(r1 < r2)%R
fth4:forall x : R,
(r < x)%R ->
(x < r0)%R -> x <> r1 -> x <> r2 -> v r1 < v x
H7:False
H6:(r1 < r2)%R
H8:(r1 < r4)%R
H9:(r4 < r2)%R
H11:forall x : R,
(r1 < x)%R ->
(x < r2)%R -> x <> r2 -> x <> r4 -> v r2 < v x
H10:(r2 < r4)%R
False contradiction.
Qed.

Theorem R_uncountable : forall u : nat -> R, ~Bijective u.
forall u : nat -> R, ~ Bijective u
Proof.
forall u : nat -> R, ~ Bijective u
  intros u [v [H3 H4]].
u:nat -> R
v:R -> nat
H3:forall x : nat, v (u x) = x
H4:forall y : R, u (v y) = y
False pose proof (conj H4 H3) as H.
u:nat -> R
v:R -> nat
H3:forall x : nat, v (u x) = x
H4:forall y : R, u (v y) = y
H:(forall y : R, u (v y) = y) /\
(forall x : nat, v (u x) = x)
False
  assert (forall n : nat, n + v (fst (proj1_sig (tearing_sequences u v H 1)))
                   <= v (fst (proj1_sig (tearing_sequences u v H (S n))))).
u:nat -> R
v:R -> nat
H3:forall x : nat, v (u x) = x
H4:forall y : R, u (v y) = y
H:(forall y : R, u (v y) = y) /\
(forall x : nat, v (u x) = x)
forall n : nat,
n + v (fst (proj1_sig (tearing_sequences u v H 1))) <=
v (fst (proj1_sig (tearing_sequences u v H (S n))))
u:nat -> R
v:R -> nat
H3:forall x : nat, v (u x) = x
H4:forall y : R, u (v y) = y
H:(forall y : R, u (v y) = y) /\
(forall x : nat, v (u x) = x)
H0:forall n : nat,
n +
v (fst (proj1_sig (tearing_sequences u v H 1))) <=
v
  (fst
     (proj1_sig (tearing_sequences u v H (S n))))
False
  {
u:nat -> R
v:R -> nat
H3:forall x : nat, v (u x) = x
H4:forall y : R, u (v y) = y
H:(forall y : R, u (v y) = y) /\
(forall x : nat, v (u x) = x)
forall n : nat,
n + v (fst (proj1_sig (tearing_sequences u v H 1))) <=
v (fst (proj1_sig (tearing_sequences u v H (S n)))) induction n.
u:nat -> R
v:R -> nat
H3:forall x : nat, v (u x) = x
H4:forall y : R, u (v y) = y
H:(forall y : R, u (v y) = y) /\
(forall x : nat, v (u x) = x)
0 + v (fst (proj1_sig (tearing_sequences u v H 1))) <=
v (fst (proj1_sig (tearing_sequences u v H 1)))
u:nat -> R
v:R -> nat
H3:forall x : nat, v (u x) = x
H4:forall y : R, u (v y) = y
H:(forall y : R, u (v y) = y) /\
(forall x : nat, v (u x) = x)
n:nat
IHn:n + v (fst (proj1_sig (tearing_sequences u v H 1))) <=
v (fst (proj1_sig (tearing_sequences u v H (S n))))
S n + v (fst (proj1_sig (tearing_sequences u v H 1))) <=
v
  (fst (proj1_sig (tearing_sequences u v H (S (S n))))) simpl.
u:nat -> R
v:R -> nat
H3:forall x : nat, v (u x) = x
H4:forall y : R, u (v y) = y
H:(forall y : R, u (v y) = y) /\
(forall x : nat, v (u x) = x)
v (fst (first_two_in_interval u v 0 1 H Rlt_0_1)) <=
v (fst (first_two_in_interval u v 0 1 H Rlt_0_1))
u:nat -> R
v:R -> nat
H3:forall x : nat, v (u x) = x
H4:forall y : R, u (v y) = y
H:(forall y : R, u (v y) = y) /\
(forall x : nat, v (u x) = x)
n:nat
IHn:n + v (fst (proj1_sig (tearing_sequences u v H 1))) <=
v (fst (proj1_sig (tearing_sequences u v H (S n))))
S n + v (fst (proj1_sig (tearing_sequences u v H 1))) <=
v
  (fst (proj1_sig (tearing_sequences u v H (S (S n))))) apply le_refl.
u:nat -> R
v:R -> nat
H3:forall x : nat, v (u x) = x
H4:forall y : R, u (v y) = y
H:(forall y : R, u (v y) = y) /\
(forall x : nat, v (u x) = x)
n:nat
IHn:n + v (fst (proj1_sig (tearing_sequences u v H 1))) <=
v (fst (proj1_sig (tearing_sequences u v H (S n))))
S n + v (fst (proj1_sig (tearing_sequences u v H 1))) <=
v
  (fst (proj1_sig (tearing_sequences u v H (S (S n)))))
    apply (le_trans (S n + v (fst (proj1_sig (tearing_sequences u v H 1))))
                    (S (v (fst (proj1_sig (tearing_sequences u v H (S n))))))).
u:nat -> R
v:R -> nat
H3:forall x : nat, v (u x) = x
H4:forall y : R, u (v y) = y
H:(forall y : R, u (v y) = y) /\
(forall x : nat, v (u x) = x)
n:nat
IHn:n + v (fst (proj1_sig (tearing_sequences u v H 1))) <=
v (fst (proj1_sig (tearing_sequences u v H (S n))))
S n + v (fst (proj1_sig (tearing_sequences u v H 1))) <=
S
  (v (fst (proj1_sig (tearing_sequences u v H (S n)))))
u:nat -> R
v:R -> nat
H3:forall x : nat, v (u x) = x
H4:forall y : R, u (v y) = y
H:(forall y : R, u (v y) = y) /\
(forall x : nat, v (u x) = x)
n:nat
IHn:n + v (fst (proj1_sig (tearing_sequences u v H 1))) <=
v (fst (proj1_sig (tearing_sequences u v H (S n))))
S
  (v (fst (proj1_sig (tearing_sequences u v H (S n))))) <=
v
  (fst (proj1_sig (tearing_sequences u v H (S (S n)))))
    simpl.
u:nat -> R
v:R -> nat
H3:forall x : nat, v (u x) = x
H4:forall y : R, u (v y) = y
H:(forall y : R, u (v y) = y) /\
(forall x : nat, v (u x) = x)
n:nat
IHn:n + v (fst (proj1_sig (tearing_sequences u v H 1))) <=
v (fst (proj1_sig (tearing_sequences u v H (S n))))
S
  (n +
   v (fst (first_two_in_interval u v 0 1 H Rlt_0_1))) <=
S
  (v
     (fst
        (proj1_sig
           (let (x, x0) :=
              tearing_sequences u v H n in
            (let
               (a, b) as p
                return
                  ((fst p < snd p)%R ->
                   {ab : R * R | (fst ab < snd ab)%R}) :=
               x in
             fun pr : (a < b)%R =>
             exist
               (fun ab : R * R => (fst ab < snd ab)%R)
               (first_two_in_interval u v a b H pr)
               ((let
                   (r, r0) as p
                    return
                      ((let ... p in ...%R /\ ...) ->
                       (fst p < snd p)%R) :=
                   first_two_in_interval u v a b H pr in
                 fun
                   H0 : (a < r)%R /\
                        (r < b)%R /\
                        (a < r0)%R /\
                        (...)%R /\ ...%R /\ ... =>
                 match
                   match ... with
                   | conj _ H2 => H2
                   end
                 with
                 | conj H1 _ => H1
                 end)
                  (first_two_in_interval_works u v a b
                     H pr))) x0))))
u:nat -> R
v:R -> nat
H3:forall x : nat, v (u x) = x
H4:forall y : R, u (v y) = y
H:(forall y : R, u (v y) = y) /\
(forall x : nat, v (u x) = x)
n:nat
IHn:n + v (fst (proj1_sig (tearing_sequences u v H 1))) <=
v (fst (proj1_sig (tearing_sequences u v H (S n))))
S
  (v (fst (proj1_sig (tearing_sequences u v H (S n))))) <=
v
  (fst (proj1_sig (tearing_sequences u v H (S (S n))))) apply le_n_S.
u:nat -> R
v:R -> nat
H3:forall x : nat, v (u x) = x
H4:forall y : R, u (v y) = y
H:(forall y : R, u (v y) = y) /\
(forall x : nat, v (u x) = x)
n:nat
IHn:n + v (fst (proj1_sig (tearing_sequences u v H 1))) <=
v (fst (proj1_sig (tearing_sequences u v H (S n))))
n + v (fst (first_two_in_interval u v 0 1 H Rlt_0_1)) <=
v
  (fst
     (proj1_sig
        (let (x, x0) := tearing_sequences u v H n in
         (let
            (a, b) as p
             return
               ((fst p < snd p)%R ->
                {ab : R * R | (fst ab < snd ab)%R}) :=
            x in
          fun pr : (a < b)%R =>
          exist
            (fun ab : R * R => (fst ab < snd ab)%R)
            (first_two_in_interval u v a b H pr)
            ((let
                (r, r0) as p
                 return
                   ((let (c, d) := p in
                     (a < c)%R /\
                     (...)%R /\ ...%R /\ ...) ->
                    (fst p < snd p)%R) :=
                first_two_in_interval u v a b H pr in
              fun
                H0 : (a < r)%R /\
                     (r < b)%R /\
                     (a < r0)%R /\
                     (r0 < b)%R /\
                     (r < r0)%R /\ (..., ...) =>
              match
                match ...
                      ...
                      end with
                | conj _ H2 => H2
                end
              with
              | conj H1 _ => H1
              end)
               (first_two_in_interval_works u v a b H
                  pr))) x0)))
u:nat -> R
v:R -> nat
H3:forall x : nat, v (u x) = x
H4:forall y : R, u (v y) = y
H:(forall y : R, u (v y) = y) /\
(forall x : nat, v (u x) = x)
n:nat
IHn:n + v (fst (proj1_sig (tearing_sequences u v H 1))) <=
v (fst (proj1_sig (tearing_sequences u v H (S n))))
S
  (v (fst (proj1_sig (tearing_sequences u v H (S n))))) <=
v
  (fst (proj1_sig (tearing_sequences u v H (S (S n))))) assumption.
u:nat -> R
v:R -> nat
H3:forall x : nat, v (u x) = x
H4:forall y : R, u (v y) = y
H:(forall y : R, u (v y) = y) /\
(forall x : nat, v (u x) = x)
n:nat
IHn:n + v (fst (proj1_sig (tearing_sequences u v H 1))) <=
v (fst (proj1_sig (tearing_sequences u v H (S n))))
S
  (v (fst (proj1_sig (tearing_sequences u v H (S n))))) <=
v
  (fst (proj1_sig (tearing_sequences u v H (S (S n))))) apply first_indices_increasing.
u:nat -> R
v:R -> nat
H3:forall x : nat, v (u x) = x
H4:forall y : R, u (v y) = y
H:(forall y : R, u (v y) = y) /\
(forall x : nat, v (u x) = x)
n:nat
IHn:n + v (fst (proj1_sig (tearing_sequences u v H 1))) <=
v (fst (proj1_sig (tearing_sequences u v H (S n))))
S n <> 0
    intro H1.
u:nat -> R
v:R -> nat
H3:forall x : nat, v (u x) = x
H4:forall y : R, u (v y) = y
H:(forall y : R, u (v y) = y) /\
(forall x : nat, v (u x) = x)
n:nat
IHn:n + v (fst (proj1_sig (tearing_sequences u v H 1))) <=
v (fst (proj1_sig (tearing_sequences u v H (S n))))
H1:S n = 0
False discriminate. }
u:nat -> R
v:R -> nat
H3:forall x : nat, v (u x) = x
H4:forall y : R, u (v y) = y
H:(forall y : R, u (v y) = y) /\
(forall x : nat, v (u x) = x)
H0:forall n : nat,
n +
v (fst (proj1_sig (tearing_sequences u v H 1))) <=
v
  (fst
     (proj1_sig (tearing_sequences u v H (S n))))
False
  assert (v (proj1_sig (torn_number u v H)) + v (fst (proj1_sig (tearing_sequences u v H 1)))
          < v (proj1_sig (torn_number u v H))).
u:nat -> R
v:R -> nat
H3:forall x : nat, v (u x) = x
H4:forall y : R, u (v y) = y
H:(forall y : R, u (v y) = y) /\
(forall x : nat, v (u x) = x)
H0:forall n : nat,
n +
v (fst (proj1_sig (tearing_sequences u v H 1))) <=
v
  (fst
     (proj1_sig (tearing_sequences u v H (S n))))
v (proj1_sig (torn_number u v H)) +
v (fst (proj1_sig (tearing_sequences u v H 1))) <
v (proj1_sig (torn_number u v H))
u:nat -> R
v:R -> nat
H3:forall x : nat, v (u x) = x
H4:forall y : R, u (v y) = y
H:(forall y : R, u (v y) = y) /\
(forall x : nat, v (u x) = x)
H0:forall n : nat,
n +
v (fst (proj1_sig (tearing_sequences u v H 1))) <=
v
  (fst
     (proj1_sig (tearing_sequences u v H (S n))))
H1:v (proj1_sig (torn_number u v H)) +
v (fst (proj1_sig (tearing_sequences u v H 1))) <
v (proj1_sig (torn_number u v H))
False
  {
u:nat -> R
v:R -> nat
H3:forall x : nat, v (u x) = x
H4:forall y : R, u (v y) = y
H:(forall y : R, u (v y) = y) /\
(forall x : nat, v (u x) = x)
H0:forall n : nat,
n +
v (fst (proj1_sig (tearing_sequences u v H 1))) <=
v
  (fst
     (proj1_sig (tearing_sequences u v H (S n))))
v (proj1_sig (torn_number u v H)) +
v (fst (proj1_sig (tearing_sequences u v H 1))) <
v (proj1_sig (torn_number u v H)) pose proof (limit_index_above_all_indices u v H (v (proj1_sig (torn_number u v H)))).
u:nat -> R
v:R -> nat
H3:forall x : nat, v (u x) = x
H4:forall y : R, u (v y) = y
H:(forall y : R, u (v y) = y) /\
(forall x : nat, v (u x) = x)
H0:forall n : nat,
n +
v (fst (proj1_sig (tearing_sequences u v H 1))) <=
v
  (fst
     (proj1_sig (tearing_sequences u v H (S n))))
H1:v
  (fst
     (proj1_sig
        (tearing_sequences u v H
           (S (v (proj1_sig (torn_number u v H))))))) <
v (proj1_sig (torn_number u v H))
v (proj1_sig (torn_number u v H)) +
v (fst (proj1_sig (tearing_sequences u v H 1))) <
v (proj1_sig (torn_number u v H))
    specialize (H0 (v (proj1_sig (torn_number u v H)))).
u:nat -> R
v:R -> nat
H3:forall x : nat, v (u x) = x
H4:forall y : R, u (v y) = y
H:(forall y : R, u (v y) = y) /\
(forall x : nat, v (u x) = x)
H0:v (proj1_sig (torn_number u v H)) +
v (fst (proj1_sig (tearing_sequences u v H 1))) <=
v
  (fst
     (proj1_sig
        (tearing_sequences u v H
           (S (v (proj1_sig (torn_number u v H)))))))
H1:v
  (fst
     (proj1_sig
        (tearing_sequences u v H
           (S (v (proj1_sig (torn_number u v H))))))) <
v (proj1_sig (torn_number u v H))
v (proj1_sig (torn_number u v H)) +
v (fst (proj1_sig (tearing_sequences u v H 1))) <
v (proj1_sig (torn_number u v H))
    apply (le_lt_trans (v (proj1_sig (torn_number u v H))
                        + v (fst (proj1_sig (tearing_sequences u v H 1))))
                       (v (fst (proj1_sig (tearing_sequences u v H (S (v (proj1_sig (torn_number u v H))))))))).
u:nat -> R
v:R -> nat
H3:forall x : nat, v (u x) = x
H4:forall y : R, u (v y) = y
H:(forall y : R, u (v y) = y) /\
(forall x : nat, v (u x) = x)
H0:v (proj1_sig (torn_number u v H)) +
v (fst (proj1_sig (tearing_sequences u v H 1))) <=
v
  (fst
     (proj1_sig
        (tearing_sequences u v H
           (S (v (proj1_sig (torn_number u v H)))))))
H1:v
  (fst
     (proj1_sig
        (tearing_sequences u v H
           (S (v (proj1_sig (torn_number u v H))))))) <
v (proj1_sig (torn_number u v H))
v (proj1_sig (torn_number u v H)) +
v (fst (proj1_sig (tearing_sequences u v H 1))) <=
v
  (fst
     (proj1_sig
        (tearing_sequences u v H
           (S (v (proj1_sig (torn_number u v H)))))))
u:nat -> R
v:R -> nat
H3:forall x : nat, v (u x) = x
H4:forall y : R, u (v y) = y
H:(forall y : R, u (v y) = y) /\
(forall x : nat, v (u x) = x)
H0:v (proj1_sig (torn_number u v H)) +
v (fst (proj1_sig (tearing_sequences u v H 1))) <=
v
  (fst
     (proj1_sig
        (tearing_sequences u v H
           (S (v (proj1_sig (torn_number u v H)))))))
H1:v
  (fst
     (proj1_sig
        (tearing_sequences u v H
           (S (v (proj1_sig (torn_number u v H))))))) <
v (proj1_sig (torn_number u v H))
v
  (fst
     (proj1_sig
        (tearing_sequences u v H
           (S (v (proj1_sig (torn_number u v H))))))) <
v (proj1_sig (torn_number u v H))
    assumption.
u:nat -> R
v:R -> nat
H3:forall x : nat, v (u x) = x
H4:forall y : R, u (v y) = y
H:(forall y : R, u (v y) = y) /\
(forall x : nat, v (u x) = x)
H0:v (proj1_sig (torn_number u v H)) +
v (fst (proj1_sig (tearing_sequences u v H 1))) <=
v
  (fst
     (proj1_sig
        (tearing_sequences u v H
           (S (v (proj1_sig (torn_number u v H)))))))
H1:v
  (fst
     (proj1_sig
        (tearing_sequences u v H
           (S (v (proj1_sig (torn_number u v H))))))) <
v (proj1_sig (torn_number u v H))
v
  (fst
     (proj1_sig
        (tearing_sequences u v H
           (S (v (proj1_sig (torn_number u v H))))))) <
v (proj1_sig (torn_number u v H)) assumption. }
u:nat -> R
v:R -> nat
H3:forall x : nat, v (u x) = x
H4:forall y : R, u (v y) = y
H:(forall y : R, u (v y) = y) /\
(forall x : nat, v (u x) = x)
H0:forall n : nat,
n +
v (fst (proj1_sig (tearing_sequences u v H 1))) <=
v
  (fst
     (proj1_sig (tearing_sequences u v H (S n))))
H1:v (proj1_sig (torn_number u v H)) +
v (fst (proj1_sig (tearing_sequences u v H 1))) <
v (proj1_sig (torn_number u v H))
False
  assert (forall n m : nat, ~(n + m < n)).
u:nat -> R
v:R -> nat
H3:forall x : nat, v (u x) = x
H4:forall y : R, u (v y) = y
H:(forall y : R, u (v y) = y) /\
(forall x : nat, v (u x) = x)
H0:forall n : nat,
n +
v (fst (proj1_sig (tearing_sequences u v H 1))) <=
v
  (fst
     (proj1_sig (tearing_sequences u v H (S n))))
H1:v (proj1_sig (torn_number u v H)) +
v (fst (proj1_sig (tearing_sequences u v H 1))) <
v (proj1_sig (torn_number u v H))
forall n m : nat, ~ n + m < n
u:nat -> R
v:R -> nat
H3:forall x : nat, v (u x) = x
H4:forall y : R, u (v y) = y
H:(forall y : R, u (v y) = y) /\
(forall x : nat, v (u x) = x)
H0:forall n : nat,
n +
v (fst (proj1_sig (tearing_sequences u v H 1))) <=
v
  (fst
     (proj1_sig (tearing_sequences u v H (S n))))
H1:v (proj1_sig (torn_number u v H)) +
v (fst (proj1_sig (tearing_sequences u v H 1))) <
v (proj1_sig (torn_number u v H))
H2:forall n m : nat, ~ n + m < n
False
  {
u:nat -> R
v:R -> nat
H3:forall x : nat, v (u x) = x
H4:forall y : R, u (v y) = y
H:(forall y : R, u (v y) = y) /\
(forall x : nat, v (u x) = x)
H0:forall n : nat,
n +
v (fst (proj1_sig (tearing_sequences u v H 1))) <=
v
  (fst
     (proj1_sig (tearing_sequences u v H (S n))))
H1:v (proj1_sig (torn_number u v H)) +
v (fst (proj1_sig (tearing_sequences u v H 1))) <
v (proj1_sig (torn_number u v H))
forall n m : nat, ~ n + m < n induction n.
u:nat -> R
v:R -> nat
H3:forall x : nat, v (u x) = x
H4:forall y : R, u (v y) = y
H:(forall y : R, u (v y) = y) /\
(forall x : nat, v (u x) = x)
H0:forall n : nat,
n +
v (fst (proj1_sig (tearing_sequences u v H 1))) <=
v
  (fst
     (proj1_sig (tearing_sequences u v H (S n))))
H1:v (proj1_sig (torn_number u v H)) +
v (fst (proj1_sig (tearing_sequences u v H 1))) <
v (proj1_sig (torn_number u v H))
forall m : nat, ~ 0 + m < 0
u:nat -> R
v:R -> nat
H3:forall x : nat, v (u x) = x
H4:forall y : R, u (v y) = y
H:(forall y : R, u (v y) = y) /\
(forall x : nat, v (u x) = x)
H0:forall n0 : nat,
n0 +
v (fst (proj1_sig (tearing_sequences u v H 1))) <=
v
  (fst
     (proj1_sig (tearing_sequences u v H (S n0))))
H1:v (proj1_sig (torn_number u v H)) +
v (fst (proj1_sig (tearing_sequences u v H 1))) <
v (proj1_sig (torn_number u v H))
n:nat
IHn:forall m : nat, ~ n + m < n
forall m : nat, ~ S n + m < S n intros.
u:nat -> R
v:R -> nat
H3:forall x : nat, v (u x) = x
H4:forall y : R, u (v y) = y
H:(forall y : R, u (v y) = y) /\
(forall x : nat, v (u x) = x)
H0:forall n : nat,
n +
v (fst (proj1_sig (tearing_sequences u v H 1))) <=
v
  (fst
     (proj1_sig (tearing_sequences u v H (S n))))
H1:v (proj1_sig (torn_number u v H)) +
v (fst (proj1_sig (tearing_sequences u v H 1))) <
v (proj1_sig (torn_number u v H))
m:nat
~ 0 + m < 0
u:nat -> R
v:R -> nat
H3:forall x : nat, v (u x) = x
H4:forall y : R, u (v y) = y
H:(forall y : R, u (v y) = y) /\
(forall x : nat, v (u x) = x)
H0:forall n0 : nat,
n0 +
v (fst (proj1_sig (tearing_sequences u v H 1))) <=
v
  (fst
     (proj1_sig (tearing_sequences u v H (S n0))))
H1:v (proj1_sig (torn_number u v H)) +
v (fst (proj1_sig (tearing_sequences u v H 1))) <
v (proj1_sig (torn_number u v H))
n:nat
IHn:forall m : nat, ~ n + m < n
forall m : nat, ~ S n + m < S n intro H2.
u:nat -> R
v:R -> nat
H3:forall x : nat, v (u x) = x
H4:forall y : R, u (v y) = y
H:(forall y : R, u (v y) = y) /\
(forall x : nat, v (u x) = x)
H0:forall n : nat,
n +
v (fst (proj1_sig (tearing_sequences u v H 1))) <=
v
  (fst
     (proj1_sig (tearing_sequences u v H (S n))))
H1:v (proj1_sig (torn_number u v H)) +
v (fst (proj1_sig (tearing_sequences u v H 1))) <
v (proj1_sig (torn_number u v H))
m:nat
H2:0 + m < 0
False
u:nat -> R
v:R -> nat
H3:forall x : nat, v (u x) = x
H4:forall y : R, u (v y) = y
H:(forall y : R, u (v y) = y) /\
(forall x : nat, v (u x) = x)
H0:forall n0 : nat,
n0 +
v (fst (proj1_sig (tearing_sequences u v H 1))) <=
v
  (fst
     (proj1_sig (tearing_sequences u v H (S n0))))
H1:v (proj1_sig (torn_number u v H)) +
v (fst (proj1_sig (tearing_sequences u v H 1))) <
v (proj1_sig (torn_number u v H))
n:nat
IHn:forall m : nat, ~ n + m < n
forall m : nat, ~ S n + m < S n inversion H2.
u:nat -> R
v:R -> nat
H3:forall x : nat, v (u x) = x
H4:forall y : R, u (v y) = y
H:(forall y : R, u (v y) = y) /\
(forall x : nat, v (u x) = x)
H0:forall n0 : nat,
n0 +
v (fst (proj1_sig (tearing_sequences u v H 1))) <=
v
  (fst
     (proj1_sig (tearing_sequences u v H (S n0))))
H1:v (proj1_sig (torn_number u v H)) +
v (fst (proj1_sig (tearing_sequences u v H 1))) <
v (proj1_sig (torn_number u v H))
n:nat
IHn:forall m : nat, ~ n + m < n
forall m : nat, ~ S n + m < S n intro m.
u:nat -> R
v:R -> nat
H3:forall x : nat, v (u x) = x
H4:forall y : R, u (v y) = y
H:(forall y : R, u (v y) = y) /\
(forall x : nat, v (u x) = x)
H0:forall n0 : nat,
n0 +
v (fst (proj1_sig (tearing_sequences u v H 1))) <=
v
  (fst
     (proj1_sig (tearing_sequences u v H (S n0))))
H1:v (proj1_sig (torn_number u v H)) +
v (fst (proj1_sig (tearing_sequences u v H 1))) <
v (proj1_sig (torn_number u v H))
n:nat
IHn:forall m0 : nat, ~ n + m0 < n
m:nat
~ S n + m < S n intro H2.
u:nat -> R
v:R -> nat
H3:forall x : nat, v (u x) = x
H4:forall y : R, u (v y) = y
H:(forall y : R, u (v y) = y) /\
(forall x : nat, v (u x) = x)
H0:forall n0 : nat,
n0 +
v (fst (proj1_sig (tearing_sequences u v H 1))) <=
v
  (fst
     (proj1_sig (tearing_sequences u v H (S n0))))
H1:v (proj1_sig (torn_number u v H)) +
v (fst (proj1_sig (tearing_sequences u v H 1))) <
v (proj1_sig (torn_number u v H))
n:nat
IHn:forall m0 : nat, ~ n + m0 < n
m:nat
H2:S n + m < S n
False simpl in H2.
u:nat -> R
v:R -> nat
H3:forall x : nat, v (u x) = x
H4:forall y : R, u (v y) = y
H:(forall y : R, u (v y) = y) /\
(forall x : nat, v (u x) = x)
H0:forall n0 : nat,
n0 +
v (fst (proj1_sig (tearing_sequences u v H 1))) <=
v
  (fst
     (proj1_sig (tearing_sequences u v H (S n0))))
H1:v (proj1_sig (torn_number u v H)) +
v (fst (proj1_sig (tearing_sequences u v H 1))) <
v (proj1_sig (torn_number u v H))
n:nat
IHn:forall m0 : nat, ~ n + m0 < n
m:nat
H2:S (n + m) < S n
False
    apply lt_pred in H2.
u:nat -> R
v:R -> nat
H3:forall x : nat, v (u x) = x
H4:forall y : R, u (v y) = y
H:(forall y : R, u (v y) = y) /\
(forall x : nat, v (u x) = x)
H0:forall n0 : nat,
n0 +
v (fst (proj1_sig (tearing_sequences u v H 1))) <=
v
  (fst
     (proj1_sig (tearing_sequences u v H (S n0))))
H1:v (proj1_sig (torn_number u v H)) +
v (fst (proj1_sig (tearing_sequences u v H 1))) <
v (proj1_sig (torn_number u v H))
n:nat
IHn:forall m0 : nat, ~ n + m0 < n
m:nat
H2:n + m < Init.Nat.pred (S n)
False simpl in H2.
u:nat -> R
v:R -> nat
H3:forall x : nat, v (u x) = x
H4:forall y : R, u (v y) = y
H:(forall y : R, u (v y) = y) /\
(forall x : nat, v (u x) = x)
H0:forall n0 : nat,
n0 +
v (fst (proj1_sig (tearing_sequences u v H 1))) <=
v
  (fst
     (proj1_sig (tearing_sequences u v H (S n0))))
H1:v (proj1_sig (torn_number u v H)) +
v (fst (proj1_sig (tearing_sequences u v H 1))) <
v (proj1_sig (torn_number u v H))
n:nat
IHn:forall m0 : nat, ~ n + m0 < n
m:nat
H2:n + m < n
False apply IHn in H2.
u:nat -> R
v:R -> nat
H3:forall x : nat, v (u x) = x
H4:forall y : R, u (v y) = y
H:(forall y : R, u (v y) = y) /\
(forall x : nat, v (u x) = x)
H0:forall n0 : nat,
n0 +
v (fst (proj1_sig (tearing_sequences u v H 1))) <=
v
  (fst
     (proj1_sig (tearing_sequences u v H (S n0))))
H1:v (proj1_sig (torn_number u v H)) +
v (fst (proj1_sig (tearing_sequences u v H 1))) <
v (proj1_sig (torn_number u v H))
n:nat
IHn:forall m0 : nat, ~ n + m0 < n
m:nat
H2:False
False contradiction. }
u:nat -> R
v:R -> nat
H3:forall x : nat, v (u x) = x
H4:forall y : R, u (v y) = y
H:(forall y : R, u (v y) = y) /\
(forall x : nat, v (u x) = x)
H0:forall n : nat,
n +
v (fst (proj1_sig (tearing_sequences u v H 1))) <=
v
  (fst
     (proj1_sig (tearing_sequences u v H (S n))))
H1:v (proj1_sig (torn_number u v H)) +
v (fst (proj1_sig (tearing_sequences u v H 1))) <
v (proj1_sig (torn_number u v H))
H2:forall n m : nat, ~ n + m < n
False
  apply H2 in H1.
u:nat -> R
v:R -> nat
H3:forall x : nat, v (u x) = x
H4:forall y : R, u (v y) = y
H:(forall y : R, u (v y) = y) /\
(forall x : nat, v (u x) = x)
H0:forall n : nat,
n +
v (fst (proj1_sig (tearing_sequences u v H 1))) <=
v
  (fst
     (proj1_sig (tearing_sequences u v H (S n))))
H1:False
H2:forall n m : nat, ~ n + m < n
False contradiction.
Qed.