(************************************************************************)
(*         *   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 Rbase.
Require Import Rfunctions.
Require Import Rseries.
Require Import Max.
Require Import Omega.
Local Open Scope R_scope.

(*****************************************************************)

(*****************************************************************)

Definition Un_decreasing (Un:nat -> R) : Prop :=
  forall n:nat, Un (S n) <= Un n.
Definition opp_seq (Un:nat -> R) (n:nat) : R := - Un n.
Definition has_ub (Un:nat -> R) : Prop := bound (EUn Un).
Definition has_lb (Un:nat -> R) : Prop := bound (EUn (opp_seq Un)).

(**********)
Lemma growing_cv :
  forall Un:nat -> R, Un_growing Un -> has_ub Un -> { l:R | Un_cv Un l }.
forall Un : nat -> R,
Un_growing Un -> has_ub Un -> {l : R | Un_cv Un l}
Proof.
forall Un : nat -> R,
Un_growing Un -> has_ub Un -> {l : R | Un_cv Un l}
  intros Un Hug Heub.
Un:nat -> R
Hug:Un_growing Un
Heub:has_ub Un
{l : R | Un_cv Un l}
  exists (proj1_sig (completeness (EUn Un) Heub (EUn_noempty Un))).
Un:nat -> R
Hug:Un_growing Un
Heub:has_ub Un
Un_cv Un
  (proj1_sig
     (completeness (EUn Un) Heub (EUn_noempty Un)))
  destruct (completeness _ Heub (EUn_noempty Un)) as (l, H).
Un:nat -> R
Hug:Un_growing Un
Heub:has_ub Un
l:R
H:is_lub (EUn Un) l
Un_cv Un
  (proj1_sig
     (exist (fun m : R => is_lub (EUn Un) m) l H))
  now apply Un_cv_crit_lub.
Qed.

Lemma decreasing_growing :
  forall Un:nat -> R, Un_decreasing Un -> Un_growing (opp_seq Un).
forall Un : nat -> R,
Un_decreasing Un -> Un_growing (opp_seq Un)
Proof.
forall Un : nat -> R,
Un_decreasing Un -> Un_growing (opp_seq Un)
  intro.
Un:nat -> R
Un_decreasing Un -> Un_growing (opp_seq Un)
  unfold Un_growing, opp_seq, Un_decreasing.
Un:nat -> R
(forall n : nat, Un (S n) <= Un n) ->
forall n : nat, - Un n <= - Un (S n)
  intros.
Un:nat -> R
H:forall n0 : nat, Un (S n0) <= Un n0
n:nat
- Un n <= - Un (S n)
  apply Ropp_le_contravar.
Un:nat -> R
H:forall n0 : nat, Un (S n0) <= Un n0
n:nat
Un (S n) <= Un n
  apply H.
Qed.

Lemma decreasing_cv :
  forall Un:nat -> R, Un_decreasing Un -> has_lb Un -> { l:R | Un_cv Un l }.
forall Un : nat -> R,
Un_decreasing Un -> has_lb Un -> {l : R | Un_cv Un l}
Proof.
forall Un : nat -> R,
Un_decreasing Un -> has_lb Un -> {l : R | Un_cv Un l}
  intros.
Un:nat -> R
H:Un_decreasing Un
H0:has_lb Un
{l : R | Un_cv Un l}
  cut ({ l:R | Un_cv (opp_seq Un) l } -> { l:R | Un_cv Un l }).
Un:nat -> R
H:Un_decreasing Un
H0:has_lb Un
({l : R | Un_cv (opp_seq Un) l} ->
 {l : R | Un_cv Un l}) -> {l : R | Un_cv Un l}
Un:nat -> R
H:Un_decreasing Un
H0:has_lb Un
{l : R | Un_cv (opp_seq Un) l} -> {l : R | Un_cv Un l}
  intro X.
Un:nat -> R
H:Un_decreasing Un
H0:has_lb Un
X:{l : R | Un_cv (opp_seq Un) l} ->
{l : R | Un_cv Un l}
{l : R | Un_cv Un l}
Un:nat -> R
H:Un_decreasing Un
H0:has_lb Un
{l : R | Un_cv (opp_seq Un) l} -> {l : R | Un_cv Un l}
  apply X.
Un:nat -> R
H:Un_decreasing Un
H0:has_lb Un
X:{l : R | Un_cv (opp_seq Un) l} ->
{l : R | Un_cv Un l}
{l : R | Un_cv (opp_seq Un) l}
Un:nat -> R
H:Un_decreasing Un
H0:has_lb Un
{l : R | Un_cv (opp_seq Un) l} -> {l : R | Un_cv Un l}
  apply growing_cv.
Un:nat -> R
H:Un_decreasing Un
H0:has_lb Un
X:{l : R | Un_cv (opp_seq Un) l} ->
{l : R | Un_cv Un l}
Un_growing (opp_seq Un)
Un:nat -> R
H:Un_decreasing Un
H0:has_lb Un
X:{l : R | Un_cv (opp_seq Un) l} ->
{l : R | Un_cv Un l}
has_ub (opp_seq Un)
Un:nat -> R
H:Un_decreasing Un
H0:has_lb Un
{l : R | Un_cv (opp_seq Un) l} -> {l : R | Un_cv Un l}
  apply decreasing_growing; assumption.
Un:nat -> R
H:Un_decreasing Un
H0:has_lb Un
X:{l : R | Un_cv (opp_seq Un) l} ->
{l : R | Un_cv Un l}
has_ub (opp_seq Un)
Un:nat -> R
H:Un_decreasing Un
H0:has_lb Un
{l : R | Un_cv (opp_seq Un) l} -> {l : R | Un_cv Un l}
  exact H0.
Un:nat -> R
H:Un_decreasing Un
H0:has_lb Un
{l : R | Un_cv (opp_seq Un) l} -> {l : R | Un_cv Un l}
  intros (x,p).
Un:nat -> R
H:Un_decreasing Un
H0:has_lb Un
x:R
p:Un_cv (opp_seq Un) x
{l : R | Un_cv Un l}
  exists (- x).
Un:nat -> R
H:Un_decreasing Un
H0:has_lb Un
x:R
p:Un_cv (opp_seq Un) x
Un_cv Un (- x)
  unfold Un_cv in p.
Un:nat -> R
H:Un_decreasing Un
H0:has_lb Un
x:R
p:forall eps : R,
eps > 0 ->
exists N : nat,
  forall n : nat,
  (n >= N)%nat -> R_dist (opp_seq Un n) x < eps
Un_cv Un (- x)
  unfold R_dist in p.
Un:nat -> R
H:Un_decreasing Un
H0:has_lb Un
x:R
p:forall eps : R,
eps > 0 ->
exists N : nat,
  forall n : nat,
  (n >= N)%nat -> Rabs (opp_seq Un n - x) < eps
Un_cv Un (- x)
  unfold opp_seq in p.
Un:nat -> R
H:Un_decreasing Un
H0:has_lb Un
x:R
p:forall eps : R,
eps > 0 ->
exists N : nat,
  forall n : nat,
  (n >= N)%nat -> Rabs (- Un n - x) < eps
Un_cv Un (- x)
  unfold Un_cv.
Un:nat -> R
H:Un_decreasing Un
H0:has_lb Un
x:R
p:forall eps : R,
eps > 0 ->
exists N : nat,
  forall n : nat,
  (n >= N)%nat -> Rabs (- Un n - x) < eps
forall eps : R,
eps > 0 ->
exists N : nat,
  forall n : nat,
  (n >= N)%nat -> R_dist (Un n) (- x) < eps
  unfold R_dist.
Un:nat -> R
H:Un_decreasing Un
H0:has_lb Un
x:R
p:forall eps : R,
eps > 0 ->
exists N : nat,
  forall n : nat,
  (n >= N)%nat -> Rabs (- Un n - x) < eps
forall eps : R,
eps > 0 ->
exists N : nat,
  forall n : nat,
  (n >= N)%nat -> Rabs (Un n - - x) < eps
  intros.
Un:nat -> R
H:Un_decreasing Un
H0:has_lb Un
x:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n : nat,
  (n >= N)%nat -> Rabs (- Un n - x) < eps0
eps:R
H1:eps > 0
exists N : nat,
  forall n : nat,
  (n >= N)%nat -> Rabs (Un n - - x) < eps
  elim (p eps H1); intros.
Un:nat -> R
H:Un_decreasing Un
H0:has_lb Un
x:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n : nat,
  (n >= N)%nat -> Rabs (- Un n - x) < eps0
eps:R
H1:eps > 0
x0:nat
H2:forall n : nat,
(n >= x0)%nat -> Rabs (- Un n - x) < eps
exists N : nat,
  forall n : nat,
  (n >= N)%nat -> Rabs (Un n - - x) < eps
  exists x0; intros.
Un:nat -> R
H:Un_decreasing Un
H0:has_lb Un
x:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n0 : nat,
  (n0 >= N)%nat -> Rabs (- Un n0 - x) < eps0
eps:R
H1:eps > 0
x0:nat
H2:forall n0 : nat,
(n0 >= x0)%nat -> Rabs (- Un n0 - x) < eps
n:nat
H3:(n >= x0)%nat
Rabs (Un n - - x) < eps
  assert (H4 := H2 n H3).
Un:nat -> R
H:Un_decreasing Un
H0:has_lb Un
x:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n0 : nat,
  (n0 >= N)%nat -> Rabs (- Un n0 - x) < eps0
eps:R
H1:eps > 0
x0:nat
H2:forall n0 : nat,
(n0 >= x0)%nat -> Rabs (- Un n0 - x) < eps
n:nat
H3:(n >= x0)%nat
H4:Rabs (- Un n - x) < eps
Rabs (Un n - - x) < eps
  rewrite <- Rabs_Ropp.
Un:nat -> R
H:Un_decreasing Un
H0:has_lb Un
x:R
p:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n0 : nat,
  (n0 >= N)%nat -> Rabs (- Un n0 - x) < eps0
eps:R
H1:eps > 0
x0:nat
H2:forall n0 : nat,
(n0 >= x0)%nat -> Rabs (- Un n0 - x) < eps
n:nat
H3:(n >= x0)%nat
H4:Rabs (- Un n - x) < eps
Rabs (- (Un n - - x)) < eps
  replace (- (Un n - - x)) with (- Un n - x); [ assumption | ring ].
Qed.

(***********)
Lemma ub_to_lub :
  forall Un:nat -> R, has_ub Un -> { l:R | is_lub (EUn Un) l }.
forall Un : nat -> R,
has_ub Un -> {l : R | is_lub (EUn Un) l}
Proof.
forall Un : nat -> R,
has_ub Un -> {l : R | is_lub (EUn Un) l}
  intros.
Un:nat -> R
H:has_ub Un
{l : R | is_lub (EUn Un) l}
  unfold has_ub in H.
Un:nat -> R
H:bound (EUn Un)
{l : R | is_lub (EUn Un) l}
  apply completeness.
Un:nat -> R
H:bound (EUn Un)
bound (EUn Un)
Un:nat -> R
H:bound (EUn Un)
exists x : R, EUn Un x
  assumption.
Un:nat -> R
H:bound (EUn Un)
exists x : R, EUn Un x
  exists (Un 0%nat).
Un:nat -> R
H:bound (EUn Un)
EUn Un (Un 0%nat)
  unfold EUn.
Un:nat -> R
H:bound (EUn Un)
exists i : nat, Un 0%nat = Un i
  exists 0%nat; reflexivity.
Qed.

(**********)
Lemma lb_to_glb :
  forall Un:nat -> R, has_lb Un -> { l:R | is_lub (EUn (opp_seq Un)) l }.
forall Un : nat -> R,
has_lb Un -> {l : R | is_lub (EUn (opp_seq Un)) l}
Proof.
forall Un : nat -> R,
has_lb Un -> {l : R | is_lub (EUn (opp_seq Un)) l}
  intros; unfold has_lb in H.
Un:nat -> R
H:bound (EUn (opp_seq Un))
{l : R | is_lub (EUn (opp_seq Un)) l}
  apply completeness.
Un:nat -> R
H:bound (EUn (opp_seq Un))
bound (EUn (opp_seq Un))
Un:nat -> R
H:bound (EUn (opp_seq Un))
exists x : R, EUn (opp_seq Un) x
  assumption.
Un:nat -> R
H:bound (EUn (opp_seq Un))
exists x : R, EUn (opp_seq Un) x
  exists (- Un 0%nat).
Un:nat -> R
H:bound (EUn (opp_seq Un))
EUn (opp_seq Un) (- Un 0%nat)
  exists 0%nat.
Un:nat -> R
H:bound (EUn (opp_seq Un))
- Un 0%nat = opp_seq Un 0
  reflexivity.
Qed.

Definition lub (Un:nat -> R) (pr:has_ub Un) : R :=
  let (a,_) := ub_to_lub Un pr in a.

Definition glb (Un:nat -> R) (pr:has_lb Un) : R :=
  let (a,_) := lb_to_glb Un pr in - a.

(* Compatibility with previous unappropriate terminology *)
Notation maj_sup := ub_to_lub (only parsing).
Notation min_inf := lb_to_glb (only parsing).
Notation majorant := lub (only parsing).
Notation minorant := glb (only parsing).

Lemma maj_ss :
  forall (Un:nat -> R) (k:nat),
    has_ub Un -> has_ub (fun i:nat => Un (k + i)%nat).
forall (Un : nat -> R) (k : nat),
has_ub Un -> has_ub (fun i : nat => Un (k + i)%nat)
Proof.
forall (Un : nat -> R) (k : nat),
has_ub Un -> has_ub (fun i : nat => Un (k + i)%nat)
  intros.
Un:nat -> R
k:nat
H:has_ub Un
has_ub (fun i : nat => Un (k + i)%nat)
  unfold has_ub in H.
Un:nat -> R
k:nat
H:bound (EUn Un)
has_ub (fun i : nat => Un (k + i)%nat)
  unfold bound in H.
Un:nat -> R
k:nat
H:exists m : R, is_upper_bound (EUn Un) m
has_ub (fun i : nat => Un (k + i)%nat)
  elim H; intros.
Un:nat -> R
k:nat
H:exists m : R, is_upper_bound (EUn Un) m
x:R
H0:is_upper_bound (EUn Un) x
has_ub (fun i : nat => Un (k + i)%nat)
  unfold is_upper_bound in H0.
Un:nat -> R
k:nat
H:exists m : R, is_upper_bound (EUn Un) m
x:R
H0:forall x0 : R, EUn Un x0 -> x0 <= x
has_ub (fun i : nat => Un (k + i)%nat)
  unfold has_ub.
Un:nat -> R
k:nat
H:exists m : R, is_upper_bound (EUn Un) m
x:R
H0:forall x0 : R, EUn Un x0 -> x0 <= x
bound (EUn (fun i : nat => Un (k + i)%nat))
  exists x.
Un:nat -> R
k:nat
H:exists m : R, is_upper_bound (EUn Un) m
x:R
H0:forall x0 : R, EUn Un x0 -> x0 <= x
is_upper_bound (EUn (fun i : nat => Un (k + i)%nat)) x
  unfold is_upper_bound.
Un:nat -> R
k:nat
H:exists m : R, is_upper_bound (EUn Un) m
x:R
H0:forall x0 : R, EUn Un x0 -> x0 <= x
forall x0 : R,
EUn (fun i : nat => Un (k + i)%nat) x0 -> x0 <= x
  intros.
Un:nat -> R
k:nat
H:exists m : R, is_upper_bound (EUn Un) m
x:R
H0:forall x1 : R, EUn Un x1 -> x1 <= x
x0:R
H1:EUn (fun i : nat => Un (k + i)%nat) x0
x0 <= x
  apply H0.
Un:nat -> R
k:nat
H:exists m : R, is_upper_bound (EUn Un) m
x:R
H0:forall x1 : R, EUn Un x1 -> x1 <= x
x0:R
H1:EUn (fun i : nat => Un (k + i)%nat) x0
EUn Un x0
  elim H1; intros.
Un:nat -> R
k:nat
H:exists m : R, is_upper_bound (EUn Un) m
x:R
H0:forall x2 : R, EUn Un x2 -> x2 <= x
x0:R
H1:EUn (fun i : nat => Un (k + i)%nat) x0
x1:nat
H2:x0 = Un (k + x1)%nat
EUn Un x0
  exists (k + x1)%nat; assumption.
Qed.

Lemma min_ss :
  forall (Un:nat -> R) (k:nat),
    has_lb Un -> has_lb (fun i:nat => Un (k + i)%nat).
forall (Un : nat -> R) (k : nat),
has_lb Un -> has_lb (fun i : nat => Un (k + i)%nat)
Proof.
forall (Un : nat -> R) (k : nat),
has_lb Un -> has_lb (fun i : nat => Un (k + i)%nat)
  intros.
Un:nat -> R
k:nat
H:has_lb Un
has_lb (fun i : nat => Un (k + i)%nat)
  unfold has_lb in H.
Un:nat -> R
k:nat
H:bound (EUn (opp_seq Un))
has_lb (fun i : nat => Un (k + i)%nat)
  unfold bound in H.
Un:nat -> R
k:nat
H:exists m : R, is_upper_bound (EUn (opp_seq Un)) m
has_lb (fun i : nat => Un (k + i)%nat)
  elim H; intros.
Un:nat -> R
k:nat
H:exists m : R, is_upper_bound (EUn (opp_seq Un)) m
x:R
H0:is_upper_bound (EUn (opp_seq Un)) x
has_lb (fun i : nat => Un (k + i)%nat)
  unfold is_upper_bound in H0.
Un:nat -> R
k:nat
H:exists m : R, is_upper_bound (EUn (opp_seq Un)) m
x:R
H0:forall x0 : R, EUn (opp_seq Un) x0 -> x0 <= x
has_lb (fun i : nat => Un (k + i)%nat)
  unfold has_lb.
Un:nat -> R
k:nat
H:exists m : R, is_upper_bound (EUn (opp_seq Un)) m
x:R
H0:forall x0 : R, EUn (opp_seq Un) x0 -> x0 <= x
bound (EUn (opp_seq (fun i : nat => Un (k + i)%nat)))
  exists x.
Un:nat -> R
k:nat
H:exists m : R, is_upper_bound (EUn (opp_seq Un)) m
x:R
H0:forall x0 : R, EUn (opp_seq Un) x0 -> x0 <= x
is_upper_bound
  (EUn (opp_seq (fun i : nat => Un (k + i)%nat))) x
  unfold is_upper_bound.
Un:nat -> R
k:nat
H:exists m : R, is_upper_bound (EUn (opp_seq Un)) m
x:R
H0:forall x0 : R, EUn (opp_seq Un) x0 -> x0 <= x
forall x0 : R,
EUn (opp_seq (fun i : nat => Un (k + i)%nat)) x0 ->
x0 <= x
  intros.
Un:nat -> R
k:nat
H:exists m : R, is_upper_bound (EUn (opp_seq Un)) m
x:R
H0:forall x1 : R, EUn (opp_seq Un) x1 -> x1 <= x
x0:R
H1:EUn (opp_seq (fun i : nat => Un (k + i)%nat)) x0
x0 <= x
  apply H0.
Un:nat -> R
k:nat
H:exists m : R, is_upper_bound (EUn (opp_seq Un)) m
x:R
H0:forall x1 : R, EUn (opp_seq Un) x1 -> x1 <= x
x0:R
H1:EUn (opp_seq (fun i : nat => Un (k + i)%nat)) x0
EUn (opp_seq Un) x0
  elim H1; intros.
Un:nat -> R
k:nat
H:exists m : R, is_upper_bound (EUn (opp_seq Un)) m
x:R
H0:forall x2 : R, EUn (opp_seq Un) x2 -> x2 <= x
x0:R
H1:EUn (opp_seq (fun i : nat => Un (k + i)%nat)) x0
x1:nat
H2:x0 = opp_seq (fun i : nat => Un (k + i)%nat) x1
EUn (opp_seq Un) x0
  exists (k + x1)%nat; assumption.
Qed.

Definition sequence_ub (Un:nat -> R) (pr:has_ub Un)
  (i:nat) : R := lub (fun k:nat => Un (i + k)%nat) (maj_ss Un i pr).

Definition sequence_lb (Un:nat -> R) (pr:has_lb Un)
  (i:nat) : R := glb (fun k:nat => Un (i + k)%nat) (min_ss Un i pr).

(* Compatibility *)
Notation sequence_majorant := sequence_ub (only parsing).
Notation sequence_minorant := sequence_lb (only parsing).

Lemma Wn_decreasing :
  forall (Un:nat -> R) (pr:has_ub Un), Un_decreasing (sequence_ub Un pr).
forall (Un : nat -> R) (pr : has_ub Un),
Un_decreasing (sequence_ub Un pr)
Proof.
forall (Un : nat -> R) (pr : has_ub Un),
Un_decreasing (sequence_ub Un pr)
  intros.
Un:nat -> R
pr:has_ub Un
Un_decreasing (sequence_ub Un pr)
  unfold Un_decreasing.
Un:nat -> R
pr:has_ub Un
forall n : nat,
sequence_ub Un pr (S n) <= sequence_ub Un pr n
  intro.
Un:nat -> R
pr:has_ub Un
n:nat
sequence_ub Un pr (S n) <= sequence_ub Un pr n
  unfold sequence_ub.
Un:nat -> R
pr:has_ub Un
n:nat
lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) <=
lub (fun k : nat => Un (n + k)%nat) (maj_ss Un n pr)
  pose proof (ub_to_lub (fun k:nat => Un (S n + k)%nat) (maj_ss Un (S n) pr)) as (x,(H1,H2)).
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) <=
lub (fun k : nat => Un (n + k)%nat) (maj_ss Un n pr)
  pose proof (ub_to_lub (fun k:nat => Un (n + k)%nat) (maj_ss Un n pr)) as (x0,(H3,H4)).
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) <=
lub (fun k : nat => Un (n + k)%nat) (maj_ss Un n pr)
  cut (lub (fun k:nat => Un (S n + k)%nat) (maj_ss Un (S n) pr) = x);
    [ intro Maj1; rewrite Maj1 | idtac ].
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
Maj1:lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
x <=
lub (fun k : nat => Un (n + k)%nat) (maj_ss Un n pr)
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
  cut (lub (fun k:nat => Un (n + k)%nat) (maj_ss Un n pr) = x0);
    [ intro Maj2; rewrite Maj2 | idtac ].
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
Maj1:lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
Maj2:lub (fun k : nat => Un (n + k)%nat)
  (maj_ss Un n pr) = x0
x <= x0
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
Maj1:lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
lub (fun k : nat => Un (n + k)%nat) (maj_ss Un n pr) =
x0
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
  apply H2.
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
Maj1:lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
Maj2:lub (fun k : nat => Un (n + k)%nat)
  (maj_ss Un n pr) = x0
is_upper_bound (EUn (fun k : nat => Un (S n + k)%nat))
  x0
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
Maj1:lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
lub (fun k : nat => Un (n + k)%nat) (maj_ss Un n pr) =
x0
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
  unfold is_upper_bound.
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
Maj1:lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
Maj2:lub (fun k : nat => Un (n + k)%nat)
  (maj_ss Un n pr) = x0
forall x1 : R,
EUn (fun k : nat => Un (S n + k)%nat) x1 -> x1 <= x0
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
Maj1:lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
lub (fun k : nat => Un (n + k)%nat) (maj_ss Un n pr) =
x0
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
  intros x1 H5.
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
Maj1:lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
Maj2:lub (fun k : nat => Un (n + k)%nat)
  (maj_ss Un n pr) = x0
x1:R
H5:EUn (fun k : nat => Un (S n + k)%nat) x1
x1 <= x0
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
Maj1:lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
lub (fun k : nat => Un (n + k)%nat) (maj_ss Un n pr) =
x0
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
  unfold is_upper_bound in H3.
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:forall x2 : R,
EUn (fun k : nat => Un (n + k)%nat) x2 ->
x2 <= x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
Maj1:lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
Maj2:lub (fun k : nat => Un (n + k)%nat)
  (maj_ss Un n pr) = x0
x1:R
H5:EUn (fun k : nat => Un (S n + k)%nat) x1
x1 <= x0
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
Maj1:lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
lub (fun k : nat => Un (n + k)%nat) (maj_ss Un n pr) =
x0
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
  apply H3.
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:forall x2 : R,
EUn (fun k : nat => Un (n + k)%nat) x2 ->
x2 <= x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
Maj1:lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
Maj2:lub (fun k : nat => Un (n + k)%nat)
  (maj_ss Un n pr) = x0
x1:R
H5:EUn (fun k : nat => Un (S n + k)%nat) x1
EUn (fun k : nat => Un (n + k)%nat) x1
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
Maj1:lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
lub (fun k : nat => Un (n + k)%nat) (maj_ss Un n pr) =
x0
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
  elim H5; intros.
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:forall x3 : R,
EUn (fun k : nat => Un (n + k)%nat) x3 ->
x3 <= x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
Maj1:lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
Maj2:lub (fun k : nat => Un (n + k)%nat)
  (maj_ss Un n pr) = x0
x1:R
H5:EUn (fun k : nat => Un (S n + k)%nat) x1
x2:nat
H:x1 = Un (S n + x2)%nat
EUn (fun k : nat => Un (n + k)%nat) x1
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
Maj1:lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
lub (fun k : nat => Un (n + k)%nat) (maj_ss Un n pr) =
x0
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
  exists (1 + x2)%nat.
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:forall x3 : R,
EUn (fun k : nat => Un (n + k)%nat) x3 ->
x3 <= x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
Maj1:lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
Maj2:lub (fun k : nat => Un (n + k)%nat)
  (maj_ss Un n pr) = x0
x1:R
H5:EUn (fun k : nat => Un (S n + k)%nat) x1
x2:nat
H:x1 = Un (S n + x2)%nat
x1 = Un (n + (1 + x2))%nat
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
Maj1:lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
lub (fun k : nat => Un (n + k)%nat) (maj_ss Un n pr) =
x0
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
  replace (n + (1 + x2))%nat with (S n + x2)%nat.
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:forall x3 : R,
EUn (fun k : nat => Un (n + k)%nat) x3 ->
x3 <= x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
Maj1:lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
Maj2:lub (fun k : nat => Un (n + k)%nat)
  (maj_ss Un n pr) = x0
x1:R
H5:EUn (fun k : nat => Un (S n + k)%nat) x1
x2:nat
H:x1 = Un (S n + x2)%nat
x1 = Un (S n + x2)%nat
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:forall x3 : R,
EUn (fun k : nat => Un (n + k)%nat) x3 ->
x3 <= x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
Maj1:lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
Maj2:lub (fun k : nat => Un (n + k)%nat)
  (maj_ss Un n pr) = x0
x1:R
H5:EUn (fun k : nat => Un (S n + k)%nat) x1
x2:nat
H:x1 = Un (S n + x2)%nat
(S n + x2)%nat = (n + (1 + x2))%nat
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
Maj1:lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
lub (fun k : nat => Un (n + k)%nat) (maj_ss Un n pr) =
x0
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
  assumption.
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:forall x3 : R,
EUn (fun k : nat => Un (n + k)%nat) x3 ->
x3 <= x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
Maj1:lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
Maj2:lub (fun k : nat => Un (n + k)%nat)
  (maj_ss Un n pr) = x0
x1:R
H5:EUn (fun k : nat => Un (S n + k)%nat) x1
x2:nat
H:x1 = Un (S n + x2)%nat
(S n + x2)%nat = (n + (1 + x2))%nat
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
Maj1:lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
lub (fun k : nat => Un (n + k)%nat) (maj_ss Un n pr) =
x0
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
  replace (S n) with (1 + n)%nat; [ ring | ring ].
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
Maj1:lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
lub (fun k : nat => Un (n + k)%nat) (maj_ss Un n pr) =
x0
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
  cut
    (is_lub (EUn (fun k:nat => Un (n + k)%nat))
      (lub (fun k:nat => Un (n + k)%nat) (maj_ss Un n pr))).
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
Maj1:lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
is_lub (EUn (fun k : nat => Un (n + k)%nat))
  (lub (fun k : nat => Un (n + k)%nat)
     (maj_ss Un n pr)) ->
lub (fun k : nat => Un (n + k)%nat) (maj_ss Un n pr) =
x0
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
Maj1:lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
is_lub (EUn (fun k : nat => Un (n + k)%nat))
  (lub (fun k : nat => Un (n + k)%nat)
     (maj_ss Un n pr))
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
  intros (H5,H6).
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
Maj1:lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
H5:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat))
  (lub (fun k : nat => Un (n + k)%nat)
     (maj_ss Un n pr))
H6:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
lub (fun k : nat => Un (n + k)%nat)
  (maj_ss Un n pr) <= b
lub (fun k : nat => Un (n + k)%nat) (maj_ss Un n pr) =
x0
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
Maj1:lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
is_lub (EUn (fun k : nat => Un (n + k)%nat))
  (lub (fun k : nat => Un (n + k)%nat)
     (maj_ss Un n pr))
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
  assert (H7 := H6 x0 H3).
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
Maj1:lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
H5:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat))
  (lub (fun k : nat => Un (n + k)%nat)
     (maj_ss Un n pr))
H6:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
lub (fun k : nat => Un (n + k)%nat)
  (maj_ss Un n pr) <= b
H7:lub (fun k : nat => Un (n + k)%nat)
  (maj_ss Un n pr) <= x0
lub (fun k : nat => Un (n + k)%nat) (maj_ss Un n pr) =
x0
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
Maj1:lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
is_lub (EUn (fun k : nat => Un (n + k)%nat))
  (lub (fun k : nat => Un (n + k)%nat)
     (maj_ss Un n pr))
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
  assert
    (H8 := H4 (lub (fun k:nat => Un (n + k)%nat) (maj_ss Un n pr)) H5).
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
Maj1:lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
H5:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat))
  (lub (fun k : nat => Un (n + k)%nat)
     (maj_ss Un n pr))
H6:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
lub (fun k : nat => Un (n + k)%nat)
  (maj_ss Un n pr) <= b
H7:lub (fun k : nat => Un (n + k)%nat)
  (maj_ss Un n pr) <= x0
H8:x0 <=
lub (fun k : nat => Un (n + k)%nat)
  (maj_ss Un n pr)
lub (fun k : nat => Un (n + k)%nat) (maj_ss Un n pr) =
x0
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
Maj1:lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
is_lub (EUn (fun k : nat => Un (n + k)%nat))
  (lub (fun k : nat => Un (n + k)%nat)
     (maj_ss Un n pr))
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
  apply Rle_antisym; assumption.
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
Maj1:lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
is_lub (EUn (fun k : nat => Un (n + k)%nat))
  (lub (fun k : nat => Un (n + k)%nat)
     (maj_ss Un n pr))
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
  unfold lub.
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
Maj1:lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
is_lub (EUn (fun k : nat => Un (n + k)%nat))
  (let (a, _) :=
     ub_to_lub (fun k : nat => Un (n + k)%nat)
       (maj_ss Un n pr) in
   a)
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
  case (ub_to_lub (fun k:nat => Un (n + k)%nat) (maj_ss Un n pr)).
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
Maj1:lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
forall x1 : R,
is_lub (EUn (fun k : nat => Un (n + k)%nat)) x1 ->
is_lub (EUn (fun k : nat => Un (n + k)%nat)) x1
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
  trivial.
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
  cut
    (is_lub (EUn (fun k:nat => Un (S n + k)%nat))
      (lub (fun k:nat => Un (S n + k)%nat) (maj_ss Un (S n) pr))).
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
is_lub (EUn (fun k : nat => Un (S n + k)%nat))
  (lub (fun k : nat => Un (S n + k)%nat)
     (maj_ss Un (S n) pr)) ->
lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
is_lub (EUn (fun k : nat => Un (S n + k)%nat))
  (lub (fun k : nat => Un (S n + k)%nat)
     (maj_ss Un (S n) pr))
  intros (H5,H6).
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
H5:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat))
  (lub (fun k : nat => Un (S n + k)%nat)
     (maj_ss Un (S n) pr))
H6:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) <= b
lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
is_lub (EUn (fun k : nat => Un (S n + k)%nat))
  (lub (fun k : nat => Un (S n + k)%nat)
     (maj_ss Un (S n) pr))
  assert (H7 := H6 x H1).
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
H5:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat))
  (lub (fun k : nat => Un (S n + k)%nat)
     (maj_ss Un (S n) pr))
H6:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) <= b
H7:lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) <= x
lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
is_lub (EUn (fun k : nat => Un (S n + k)%nat))
  (lub (fun k : nat => Un (S n + k)%nat)
     (maj_ss Un (S n) pr))
  assert
    (H8 :=
      H2 (lub (fun k:nat => Un (S n + k)%nat) (maj_ss Un (S n) pr)) H5).
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
H5:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat))
  (lub (fun k : nat => Un (S n + k)%nat)
     (maj_ss Un (S n) pr))
H6:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) <= b
H7:lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) <= x
H8:x <=
lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr)
lub (fun k : nat => Un (S n + k)%nat)
  (maj_ss Un (S n) pr) = x
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
is_lub (EUn (fun k : nat => Un (S n + k)%nat))
  (lub (fun k : nat => Un (S n + k)%nat)
     (maj_ss Un (S n) pr))
  apply Rle_antisym; assumption.
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
is_lub (EUn (fun k : nat => Un (S n + k)%nat))
  (lub (fun k : nat => Un (S n + k)%nat)
     (maj_ss Un (S n) pr))
  unfold lub.
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
is_lub (EUn (fun k : nat => Un (S n + k)%nat))
  (let (a, _) :=
     ub_to_lub (fun k : nat => Un (S n + k)%nat)
       (maj_ss Un (S n) pr) in
   a)
  case (ub_to_lub (fun k:nat => Un (S n + k)%nat) (maj_ss Un (S n) pr)).
Un:nat -> R
pr:has_ub Un
n:nat
x:R
H1:is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) x
H2:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (S n + k)%nat)) b ->
x <= b
x0:R
H3:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) x0
H4:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
x0 <= b
forall x1 : R,
is_lub (EUn (fun k : nat => Un (S n + k)%nat)) x1 ->
is_lub (EUn (fun k : nat => Un (S n + k)%nat)) x1
  trivial.
Qed.

Lemma Vn_growing :
  forall (Un:nat -> R) (pr:has_lb Un), Un_growing (sequence_lb Un pr).
forall (Un : nat -> R) (pr : has_lb Un),
Un_growing (sequence_lb Un pr)
Proof.
forall (Un : nat -> R) (pr : has_lb Un),
Un_growing (sequence_lb Un pr)
  intros.
Un:nat -> R
pr:has_lb Un
Un_growing (sequence_lb Un pr)
  unfold Un_growing.
Un:nat -> R
pr:has_lb Un
forall n : nat,
sequence_lb Un pr n <= sequence_lb Un pr (S n)
  intro.
Un:nat -> R
pr:has_lb Un
n:nat
sequence_lb Un pr n <= sequence_lb Un pr (S n)
  unfold sequence_lb.
Un:nat -> R
pr:has_lb Un
n:nat
glb (fun k : nat => Un (n + k)%nat) (min_ss Un n pr) <=
glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr)
  assert (H := lb_to_glb (fun k:nat => Un (S n + k)%nat) (min_ss Un (S n) pr)).
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
glb (fun k : nat => Un (n + k)%nat) (min_ss Un n pr) <=
glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr)
  assert (H0 := lb_to_glb (fun k:nat => Un (n + k)%nat) (min_ss Un n pr)).
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
glb (fun k : nat => Un (n + k)%nat) (min_ss Un n pr) <=
glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr)
  elim H; intros.
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
glb (fun k : nat => Un (n + k)%nat) (min_ss Un n pr) <=
glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr)
  elim H0; intros.
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
glb (fun k : nat => Un (n + k)%nat) (min_ss Un n pr) <=
glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr)
  cut (glb (fun k:nat => Un (S n + k)%nat) (min_ss Un (S n) pr) = - x);
    [ intro Maj1; rewrite Maj1 | idtac ].
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
Maj1:glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
glb (fun k : nat => Un (n + k)%nat) (min_ss Un n pr) <=
- x
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
  cut (glb (fun k:nat => Un (n + k)%nat) (min_ss Un n pr) = - x0);
    [ intro Maj2; rewrite Maj2 | idtac ].
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
Maj1:glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
Maj2:glb (fun k : nat => Un (n + k)%nat)
  (min_ss Un n pr) = - x0
- x0 <= - x
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
Maj1:glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
glb (fun k : nat => Un (n + k)%nat) (min_ss Un n pr) =
- x0
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
  unfold is_lub in p.
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x /\
(forall b : R,
 is_upper_bound
   (EUn
      (opp_seq (fun k : nat => Un (S n + k)%nat)))
   b -> x <= b)
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
Maj1:glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
Maj2:glb (fun k : nat => Un (n + k)%nat)
  (min_ss Un n pr) = - x0
- x0 <= - x
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
Maj1:glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
glb (fun k : nat => Un (n + k)%nat) (min_ss Un n pr) =
- x0
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
  unfold is_lub in p0.
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x /\
(forall b : R,
 is_upper_bound
   (EUn
      (opp_seq (fun k : nat => Un (S n + k)%nat)))
   b -> x <= b)
x0:R
p0:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0 /\
(forall b : R,
 is_upper_bound
   (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
   b -> x0 <= b)
Maj1:glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
Maj2:glb (fun k : nat => Un (n + k)%nat)
  (min_ss Un n pr) = - x0
- x0 <= - x
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
Maj1:glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
glb (fun k : nat => Un (n + k)%nat) (min_ss Un n pr) =
- x0
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
  elim p; intros.
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x /\
(forall b : R,
 is_upper_bound
   (EUn
      (opp_seq (fun k : nat => Un (S n + k)%nat)))
   b -> x <= b)
x0:R
p0:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0 /\
(forall b : R,
 is_upper_bound
   (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
   b -> x0 <= b)
Maj1:glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
Maj2:glb (fun k : nat => Un (n + k)%nat)
  (min_ss Un n pr) = - x0
H1:is_upper_bound
  (EUn
     (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
H2:forall b : R,
is_upper_bound
  (EUn
     (opp_seq (fun k : nat => Un (S n + k)%nat)))
  b -> x <= b
- x0 <= - x
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
Maj1:glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
glb (fun k : nat => Un (n + k)%nat) (min_ss Un n pr) =
- x0
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
  apply Ropp_le_contravar.
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x /\
(forall b : R,
 is_upper_bound
   (EUn
      (opp_seq (fun k : nat => Un (S n + k)%nat)))
   b -> x <= b)
x0:R
p0:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0 /\
(forall b : R,
 is_upper_bound
   (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
   b -> x0 <= b)
Maj1:glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
Maj2:glb (fun k : nat => Un (n + k)%nat)
  (min_ss Un n pr) = - x0
H1:is_upper_bound
  (EUn
     (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
H2:forall b : R,
is_upper_bound
  (EUn
     (opp_seq (fun k : nat => Un (S n + k)%nat)))
  b -> x <= b
x <= x0
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
Maj1:glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
glb (fun k : nat => Un (n + k)%nat) (min_ss Un n pr) =
- x0
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
  apply H2.
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x /\
(forall b : R,
 is_upper_bound
   (EUn
      (opp_seq (fun k : nat => Un (S n + k)%nat)))
   b -> x <= b)
x0:R
p0:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0 /\
(forall b : R,
 is_upper_bound
   (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
   b -> x0 <= b)
Maj1:glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
Maj2:glb (fun k : nat => Un (n + k)%nat)
  (min_ss Un n pr) = - x0
H1:is_upper_bound
  (EUn
     (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
H2:forall b : R,
is_upper_bound
  (EUn
     (opp_seq (fun k : nat => Un (S n + k)%nat)))
  b -> x <= b
is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat))) x0
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
Maj1:glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
glb (fun k : nat => Un (n + k)%nat) (min_ss Un n pr) =
- x0
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
  elim p0; intros.
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x /\
(forall b : R,
 is_upper_bound
   (EUn
      (opp_seq (fun k : nat => Un (S n + k)%nat)))
   b -> x <= b)
x0:R
p0:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0 /\
(forall b : R,
 is_upper_bound
   (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
   b -> x0 <= b)
Maj1:glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
Maj2:glb (fun k : nat => Un (n + k)%nat)
  (min_ss Un n pr) = - x0
H1:is_upper_bound
  (EUn
     (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
H2:forall b : R,
is_upper_bound
  (EUn
     (opp_seq (fun k : nat => Un (S n + k)%nat)))
  b -> x <= b
H3:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
H4:forall b : R,
is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  b -> x0 <= b
is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat))) x0
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
Maj1:glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
glb (fun k : nat => Un (n + k)%nat) (min_ss Un n pr) =
- x0
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
  unfold is_upper_bound.
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x /\
(forall b : R,
 is_upper_bound
   (EUn
      (opp_seq (fun k : nat => Un (S n + k)%nat)))
   b -> x <= b)
x0:R
p0:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0 /\
(forall b : R,
 is_upper_bound
   (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
   b -> x0 <= b)
Maj1:glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
Maj2:glb (fun k : nat => Un (n + k)%nat)
  (min_ss Un n pr) = - x0
H1:is_upper_bound
  (EUn
     (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
H2:forall b : R,
is_upper_bound
  (EUn
     (opp_seq (fun k : nat => Un (S n + k)%nat)))
  b -> x <= b
H3:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
H4:forall b : R,
is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  b -> x0 <= b
forall x1 : R,
EUn (opp_seq (fun k : nat => Un (S n + k)%nat)) x1 ->
x1 <= x0
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
Maj1:glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
glb (fun k : nat => Un (n + k)%nat) (min_ss Un n pr) =
- x0
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
  intros.
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x /\
(forall b : R,
 is_upper_bound
   (EUn
      (opp_seq (fun k : nat => Un (S n + k)%nat)))
   b -> x <= b)
x0:R
p0:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0 /\
(forall b : R,
 is_upper_bound
   (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
   b -> x0 <= b)
Maj1:glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
Maj2:glb (fun k : nat => Un (n + k)%nat)
  (min_ss Un n pr) = - x0
H1:is_upper_bound
  (EUn
     (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
H2:forall b : R,
is_upper_bound
  (EUn
     (opp_seq (fun k : nat => Un (S n + k)%nat)))
  b -> x <= b
H3:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
H4:forall b : R,
is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  b -> x0 <= b
x1:R
H5:EUn (opp_seq (fun k : nat => Un (S n + k)%nat))
  x1
x1 <= x0
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
Maj1:glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
glb (fun k : nat => Un (n + k)%nat) (min_ss Un n pr) =
- x0
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
  unfold is_upper_bound in H3.
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x /\
(forall b : R,
 is_upper_bound
   (EUn
      (opp_seq (fun k : nat => Un (S n + k)%nat)))
   b -> x <= b)
x0:R
p0:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0 /\
(forall b : R,
 is_upper_bound
   (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
   b -> x0 <= b)
Maj1:glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
Maj2:glb (fun k : nat => Un (n + k)%nat)
  (min_ss Un n pr) = - x0
H1:is_upper_bound
  (EUn
     (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
H2:forall b : R,
is_upper_bound
  (EUn
     (opp_seq (fun k : nat => Un (S n + k)%nat)))
  b -> x <= b
H3:forall x2 : R,
EUn (opp_seq (fun k : nat => Un (n + k)%nat)) x2 ->
x2 <= x0
H4:forall b : R,
is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  b -> x0 <= b
x1:R
H5:EUn (opp_seq (fun k : nat => Un (S n + k)%nat))
  x1
x1 <= x0
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
Maj1:glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
glb (fun k : nat => Un (n + k)%nat) (min_ss Un n pr) =
- x0
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
  apply H3.
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x /\
(forall b : R,
 is_upper_bound
   (EUn
      (opp_seq (fun k : nat => Un (S n + k)%nat)))
   b -> x <= b)
x0:R
p0:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0 /\
(forall b : R,
 is_upper_bound
   (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
   b -> x0 <= b)
Maj1:glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
Maj2:glb (fun k : nat => Un (n + k)%nat)
  (min_ss Un n pr) = - x0
H1:is_upper_bound
  (EUn
     (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
H2:forall b : R,
is_upper_bound
  (EUn
     (opp_seq (fun k : nat => Un (S n + k)%nat)))
  b -> x <= b
H3:forall x2 : R,
EUn (opp_seq (fun k : nat => Un (n + k)%nat)) x2 ->
x2 <= x0
H4:forall b : R,
is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  b -> x0 <= b
x1:R
H5:EUn (opp_seq (fun k : nat => Un (S n + k)%nat))
  x1
EUn (opp_seq (fun k : nat => Un (n + k)%nat)) x1
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
Maj1:glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
glb (fun k : nat => Un (n + k)%nat) (min_ss Un n pr) =
- x0
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
  elim H5; intros.
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x /\
(forall b : R,
 is_upper_bound
   (EUn
      (opp_seq (fun k : nat => Un (S n + k)%nat)))
   b -> x <= b)
x0:R
p0:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0 /\
(forall b : R,
 is_upper_bound
   (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
   b -> x0 <= b)
Maj1:glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
Maj2:glb (fun k : nat => Un (n + k)%nat)
  (min_ss Un n pr) = - x0
H1:is_upper_bound
  (EUn
     (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
H2:forall b : R,
is_upper_bound
  (EUn
     (opp_seq (fun k : nat => Un (S n + k)%nat)))
  b -> x <= b
H3:forall x3 : R,
EUn (opp_seq (fun k : nat => Un (n + k)%nat)) x3 ->
x3 <= x0
H4:forall b : R,
is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  b -> x0 <= b
x1:R
H5:EUn (opp_seq (fun k : nat => Un (S n + k)%nat))
  x1
x2:nat
H6:x1 = opp_seq (fun k : nat => Un (S n + k)%nat) x2
EUn (opp_seq (fun k : nat => Un (n + k)%nat)) x1
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
Maj1:glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
glb (fun k : nat => Un (n + k)%nat) (min_ss Un n pr) =
- x0
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
  exists (1 + x2)%nat.
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x /\
(forall b : R,
 is_upper_bound
   (EUn
      (opp_seq (fun k : nat => Un (S n + k)%nat)))
   b -> x <= b)
x0:R
p0:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0 /\
(forall b : R,
 is_upper_bound
   (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
   b -> x0 <= b)
Maj1:glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
Maj2:glb (fun k : nat => Un (n + k)%nat)
  (min_ss Un n pr) = - x0
H1:is_upper_bound
  (EUn
     (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
H2:forall b : R,
is_upper_bound
  (EUn
     (opp_seq (fun k : nat => Un (S n + k)%nat)))
  b -> x <= b
H3:forall x3 : R,
EUn (opp_seq (fun k : nat => Un (n + k)%nat)) x3 ->
x3 <= x0
H4:forall b : R,
is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  b -> x0 <= b
x1:R
H5:EUn (opp_seq (fun k : nat => Un (S n + k)%nat))
  x1
x2:nat
H6:x1 = opp_seq (fun k : nat => Un (S n + k)%nat) x2
x1 = opp_seq (fun k : nat => Un (n + k)%nat) (1 + x2)
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
Maj1:glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
glb (fun k : nat => Un (n + k)%nat) (min_ss Un n pr) =
- x0
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
  unfold opp_seq in H6.
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x /\
(forall b : R,
 is_upper_bound
   (EUn
      (opp_seq (fun k : nat => Un (S n + k)%nat)))
   b -> x <= b)
x0:R
p0:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0 /\
(forall b : R,
 is_upper_bound
   (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
   b -> x0 <= b)
Maj1:glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
Maj2:glb (fun k : nat => Un (n + k)%nat)
  (min_ss Un n pr) = - x0
H1:is_upper_bound
  (EUn
     (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
H2:forall b : R,
is_upper_bound
  (EUn
     (opp_seq (fun k : nat => Un (S n + k)%nat)))
  b -> x <= b
H3:forall x3 : R,
EUn (opp_seq (fun k : nat => Un (n + k)%nat)) x3 ->
x3 <= x0
H4:forall b : R,
is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  b -> x0 <= b
x1:R
H5:EUn (opp_seq (fun k : nat => Un (S n + k)%nat))
  x1
x2:nat
H6:x1 = - Un (S n + x2)%nat
x1 = opp_seq (fun k : nat => Un (n + k)%nat) (1 + x2)
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
Maj1:glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
glb (fun k : nat => Un (n + k)%nat) (min_ss Un n pr) =
- x0
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
  unfold opp_seq.
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x /\
(forall b : R,
 is_upper_bound
   (EUn
      (opp_seq (fun k : nat => Un (S n + k)%nat)))
   b -> x <= b)
x0:R
p0:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0 /\
(forall b : R,
 is_upper_bound
   (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
   b -> x0 <= b)
Maj1:glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
Maj2:glb (fun k : nat => Un (n + k)%nat)
  (min_ss Un n pr) = - x0
H1:is_upper_bound
  (EUn
     (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
H2:forall b : R,
is_upper_bound
  (EUn
     (opp_seq (fun k : nat => Un (S n + k)%nat)))
  b -> x <= b
H3:forall x3 : R,
EUn (opp_seq (fun k : nat => Un (n + k)%nat)) x3 ->
x3 <= x0
H4:forall b : R,
is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  b -> x0 <= b
x1:R
H5:EUn (opp_seq (fun k : nat => Un (S n + k)%nat))
  x1
x2:nat
H6:x1 = - Un (S n + x2)%nat
x1 = - Un (n + (1 + x2))%nat
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
Maj1:glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
glb (fun k : nat => Un (n + k)%nat) (min_ss Un n pr) =
- x0
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
  replace (n + (1 + x2))%nat with (S n + x2)%nat.
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x /\
(forall b : R,
 is_upper_bound
   (EUn
      (opp_seq (fun k : nat => Un (S n + k)%nat)))
   b -> x <= b)
x0:R
p0:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0 /\
(forall b : R,
 is_upper_bound
   (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
   b -> x0 <= b)
Maj1:glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
Maj2:glb (fun k : nat => Un (n + k)%nat)
  (min_ss Un n pr) = - x0
H1:is_upper_bound
  (EUn
     (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
H2:forall b : R,
is_upper_bound
  (EUn
     (opp_seq (fun k : nat => Un (S n + k)%nat)))
  b -> x <= b
H3:forall x3 : R,
EUn (opp_seq (fun k : nat => Un (n + k)%nat)) x3 ->
x3 <= x0
H4:forall b : R,
is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  b -> x0 <= b
x1:R
H5:EUn (opp_seq (fun k : nat => Un (S n + k)%nat))
  x1
x2:nat
H6:x1 = - Un (S n + x2)%nat
x1 = - Un (S n + x2)%nat
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x /\
(forall b : R,
 is_upper_bound
   (EUn
      (opp_seq (fun k : nat => Un (S n + k)%nat)))
   b -> x <= b)
x0:R
p0:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0 /\
(forall b : R,
 is_upper_bound
   (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
   b -> x0 <= b)
Maj1:glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
Maj2:glb (fun k : nat => Un (n + k)%nat)
  (min_ss Un n pr) = - x0
H1:is_upper_bound
  (EUn
     (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
H2:forall b : R,
is_upper_bound
  (EUn
     (opp_seq (fun k : nat => Un (S n + k)%nat)))
  b -> x <= b
H3:forall x3 : R,
EUn (opp_seq (fun k : nat => Un (n + k)%nat)) x3 ->
x3 <= x0
H4:forall b : R,
is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  b -> x0 <= b
x1:R
H5:EUn (opp_seq (fun k : nat => Un (S n + k)%nat))
  x1
x2:nat
H6:x1 = - Un (S n + x2)%nat
(S n + x2)%nat = (n + (1 + x2))%nat
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
Maj1:glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
glb (fun k : nat => Un (n + k)%nat) (min_ss Un n pr) =
- x0
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
  assumption.
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x /\
(forall b : R,
 is_upper_bound
   (EUn
      (opp_seq (fun k : nat => Un (S n + k)%nat)))
   b -> x <= b)
x0:R
p0:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0 /\
(forall b : R,
 is_upper_bound
   (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
   b -> x0 <= b)
Maj1:glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
Maj2:glb (fun k : nat => Un (n + k)%nat)
  (min_ss Un n pr) = - x0
H1:is_upper_bound
  (EUn
     (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
H2:forall b : R,
is_upper_bound
  (EUn
     (opp_seq (fun k : nat => Un (S n + k)%nat)))
  b -> x <= b
H3:forall x3 : R,
EUn (opp_seq (fun k : nat => Un (n + k)%nat)) x3 ->
x3 <= x0
H4:forall b : R,
is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  b -> x0 <= b
x1:R
H5:EUn (opp_seq (fun k : nat => Un (S n + k)%nat))
  x1
x2:nat
H6:x1 = - Un (S n + x2)%nat
(S n + x2)%nat = (n + (1 + x2))%nat
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
Maj1:glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
glb (fun k : nat => Un (n + k)%nat) (min_ss Un n pr) =
- x0
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
  replace (S n) with (1 + n)%nat; [ ring | ring ].
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
Maj1:glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
glb (fun k : nat => Un (n + k)%nat) (min_ss Un n pr) =
- x0
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
  cut
    (is_lub (EUn (opp_seq (fun k:nat => Un (n + k)%nat)))
      (- glb (fun k:nat => Un (n + k)%nat) (min_ss Un n pr))).
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
Maj1:glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
is_lub (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  (-
   glb (fun k : nat => Un (n + k)%nat)
     (min_ss Un n pr)) ->
glb (fun k : nat => Un (n + k)%nat) (min_ss Un n pr) =
- x0
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
Maj1:glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
is_lub (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  (-
   glb (fun k : nat => Un (n + k)%nat)
     (min_ss Un n pr))
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
  intro.
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
Maj1:glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
H1:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  (-
   glb (fun k : nat => Un (n + k)%nat)
     (min_ss Un n pr))
glb (fun k : nat => Un (n + k)%nat) (min_ss Un n pr) =
- x0
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
Maj1:glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
is_lub (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  (-
   glb (fun k : nat => Un (n + k)%nat)
     (min_ss Un n pr))
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
  unfold is_lub in p0; unfold is_lub in H1.
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0 /\
(forall b : R,
 is_upper_bound
   (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
   b -> x0 <= b)
Maj1:glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
H1:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  (-
   glb (fun k : nat => Un (n + k)%nat)
     (min_ss Un n pr)) /\
(forall b : R,
 is_upper_bound
   (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
   b ->
 -
 glb (fun k : nat => Un (n + k)%nat)
   (min_ss Un n pr) <= b)
glb (fun k : nat => Un (n + k)%nat) (min_ss Un n pr) =
- x0
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
Maj1:glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
is_lub (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  (-
   glb (fun k : nat => Un (n + k)%nat)
     (min_ss Un n pr))
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
  elim p0; intros; elim H1; intros.
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0 /\
(forall b : R,
 is_upper_bound
   (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
   b -> x0 <= b)
Maj1:glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
H1:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  (-
   glb (fun k : nat => Un (n + k)%nat)
     (min_ss Un n pr)) /\
(forall b : R,
 is_upper_bound
   (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
   b ->
 -
 glb (fun k : nat => Un (n + k)%nat)
   (min_ss Un n pr) <= b)
H2:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
H3:forall b : R,
is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  b -> x0 <= b
H4:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  (-
   glb (fun k : nat => Un (n + k)%nat)
     (min_ss Un n pr))
H5:forall b : R,
is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  b ->
-
glb (fun k : nat => Un (n + k)%nat)
  (min_ss Un n pr) <= b
glb (fun k : nat => Un (n + k)%nat) (min_ss Un n pr) =
- x0
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
Maj1:glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
is_lub (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  (-
   glb (fun k : nat => Un (n + k)%nat)
     (min_ss Un n pr))
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
  assert (H6 := H5 x0 H2).
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0 /\
(forall b : R,
 is_upper_bound
   (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
   b -> x0 <= b)
Maj1:glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
H1:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  (-
   glb (fun k : nat => Un (n + k)%nat)
     (min_ss Un n pr)) /\
(forall b : R,
 is_upper_bound
   (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
   b ->
 -
 glb (fun k : nat => Un (n + k)%nat)
   (min_ss Un n pr) <= b)
H2:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
H3:forall b : R,
is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  b -> x0 <= b
H4:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  (-
   glb (fun k : nat => Un (n + k)%nat)
     (min_ss Un n pr))
H5:forall b : R,
is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  b ->
-
glb (fun k : nat => Un (n + k)%nat)
  (min_ss Un n pr) <= b
H6:-
glb (fun k : nat => Un (n + k)%nat)
  (min_ss Un n pr) <= x0
glb (fun k : nat => Un (n + k)%nat) (min_ss Un n pr) =
- x0
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
Maj1:glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
is_lub (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  (-
   glb (fun k : nat => Un (n + k)%nat)
     (min_ss Un n pr))
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
  assert
    (H7 := H3 (- glb (fun k:nat => Un (n + k)%nat) (min_ss Un n pr)) H4).
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0 /\
(forall b : R,
 is_upper_bound
   (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
   b -> x0 <= b)
Maj1:glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
H1:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  (-
   glb (fun k : nat => Un (n + k)%nat)
     (min_ss Un n pr)) /\
(forall b : R,
 is_upper_bound
   (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
   b ->
 -
 glb (fun k : nat => Un (n + k)%nat)
   (min_ss Un n pr) <= b)
H2:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
H3:forall b : R,
is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  b -> x0 <= b
H4:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  (-
   glb (fun k : nat => Un (n + k)%nat)
     (min_ss Un n pr))
H5:forall b : R,
is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  b ->
-
glb (fun k : nat => Un (n + k)%nat)
  (min_ss Un n pr) <= b
H6:-
glb (fun k : nat => Un (n + k)%nat)
  (min_ss Un n pr) <= x0
H7:x0 <=
-
glb (fun k : nat => Un (n + k)%nat)
  (min_ss Un n pr)
glb (fun k : nat => Un (n + k)%nat) (min_ss Un n pr) =
- x0
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
Maj1:glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
is_lub (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  (-
   glb (fun k : nat => Un (n + k)%nat)
     (min_ss Un n pr))
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
  rewrite <-
    (Ropp_involutive (glb (fun k:nat => Un (n + k)%nat) (min_ss Un n pr)))
    .
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0 /\
(forall b : R,
 is_upper_bound
   (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
   b -> x0 <= b)
Maj1:glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
H1:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  (-
   glb (fun k : nat => Un (n + k)%nat)
     (min_ss Un n pr)) /\
(forall b : R,
 is_upper_bound
   (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
   b ->
 -
 glb (fun k : nat => Un (n + k)%nat)
   (min_ss Un n pr) <= b)
H2:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
H3:forall b : R,
is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  b -> x0 <= b
H4:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  (-
   glb (fun k : nat => Un (n + k)%nat)
     (min_ss Un n pr))
H5:forall b : R,
is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  b ->
-
glb (fun k : nat => Un (n + k)%nat)
  (min_ss Un n pr) <= b
H6:-
glb (fun k : nat => Un (n + k)%nat)
  (min_ss Un n pr) <= x0
H7:x0 <=
-
glb (fun k : nat => Un (n + k)%nat)
  (min_ss Un n pr)
-
- glb (fun k : nat => Un (n + k)%nat) (min_ss Un n pr) =
- x0
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
Maj1:glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
is_lub (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  (-
   glb (fun k : nat => Un (n + k)%nat)
     (min_ss Un n pr))
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
  apply Ropp_eq_compat; apply Rle_antisym; assumption.
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
Maj1:glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
is_lub (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  (-
   glb (fun k : nat => Un (n + k)%nat)
     (min_ss Un n pr))
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
  unfold glb.
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
Maj1:glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
is_lub (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  (-
   (let (a, _) :=
      lb_to_glb (fun k : nat => Un (n + k)%nat)
        (min_ss Un n pr) in
    - a))
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
  case (lb_to_glb (fun k:nat => Un (n + k)%nat) (min_ss Un n pr)); simpl.
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
Maj1:glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
forall x1 : R,
is_lub (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x1 ->
is_lub (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  (- - x1)
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
  intro; rewrite Ropp_involutive.
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
Maj1:glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
x1:R
is_lub (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x1 ->
is_lub (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x1
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
  trivial.
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
  cut
    (is_lub (EUn (opp_seq (fun k:nat => Un (S n + k)%nat)))
      (- glb (fun k:nat => Un (S n + k)%nat) (min_ss Un (S n) pr))).
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  (-
   glb (fun k : nat => Un (S n + k)%nat)
     (min_ss Un (S n) pr)) ->
glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  (-
   glb (fun k : nat => Un (S n + k)%nat)
     (min_ss Un (S n) pr))
  intro.
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
H1:is_lub
  (EUn
     (opp_seq (fun k : nat => Un (S n + k)%nat)))
  (-
   glb (fun k : nat => Un (S n + k)%nat)
     (min_ss Un (S n) pr))
glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  (-
   glb (fun k : nat => Un (S n + k)%nat)
     (min_ss Un (S n) pr))
  unfold is_lub in p; unfold is_lub in H1.
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x /\
(forall b : R,
 is_upper_bound
   (EUn
      (opp_seq (fun k : nat => Un (S n + k)%nat)))
   b -> x <= b)
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
H1:is_upper_bound
  (EUn
     (opp_seq (fun k : nat => Un (S n + k)%nat)))
  (-
   glb (fun k : nat => Un (S n + k)%nat)
     (min_ss Un (S n) pr)) /\
(forall b : R,
 is_upper_bound
   (EUn
      (opp_seq (fun k : nat => Un (S n + k)%nat)))
   b ->
 -
 glb (fun k : nat => Un (S n + k)%nat)
   (min_ss Un (S n) pr) <= b)
glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  (-
   glb (fun k : nat => Un (S n + k)%nat)
     (min_ss Un (S n) pr))
  elim p; intros; elim H1; intros.
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x /\
(forall b : R,
 is_upper_bound
   (EUn
      (opp_seq (fun k : nat => Un (S n + k)%nat)))
   b -> x <= b)
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
H1:is_upper_bound
  (EUn
     (opp_seq (fun k : nat => Un (S n + k)%nat)))
  (-
   glb (fun k : nat => Un (S n + k)%nat)
     (min_ss Un (S n) pr)) /\
(forall b : R,
 is_upper_bound
   (EUn
      (opp_seq (fun k : nat => Un (S n + k)%nat)))
   b ->
 -
 glb (fun k : nat => Un (S n + k)%nat)
   (min_ss Un (S n) pr) <= b)
H2:is_upper_bound
  (EUn
     (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
H3:forall b : R,
is_upper_bound
  (EUn
     (opp_seq (fun k : nat => Un (S n + k)%nat)))
  b -> x <= b
H4:is_upper_bound
  (EUn
     (opp_seq (fun k : nat => Un (S n + k)%nat)))
  (-
   glb (fun k : nat => Un (S n + k)%nat)
     (min_ss Un (S n) pr))
H5:forall b : R,
is_upper_bound
  (EUn
     (opp_seq (fun k : nat => Un (S n + k)%nat)))
  b ->
-
glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) <= b
glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  (-
   glb (fun k : nat => Un (S n + k)%nat)
     (min_ss Un (S n) pr))
  assert (H6 := H5 x H2).
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x /\
(forall b : R,
 is_upper_bound
   (EUn
      (opp_seq (fun k : nat => Un (S n + k)%nat)))
   b -> x <= b)
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
H1:is_upper_bound
  (EUn
     (opp_seq (fun k : nat => Un (S n + k)%nat)))
  (-
   glb (fun k : nat => Un (S n + k)%nat)
     (min_ss Un (S n) pr)) /\
(forall b : R,
 is_upper_bound
   (EUn
      (opp_seq (fun k : nat => Un (S n + k)%nat)))
   b ->
 -
 glb (fun k : nat => Un (S n + k)%nat)
   (min_ss Un (S n) pr) <= b)
H2:is_upper_bound
  (EUn
     (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
H3:forall b : R,
is_upper_bound
  (EUn
     (opp_seq (fun k : nat => Un (S n + k)%nat)))
  b -> x <= b
H4:is_upper_bound
  (EUn
     (opp_seq (fun k : nat => Un (S n + k)%nat)))
  (-
   glb (fun k : nat => Un (S n + k)%nat)
     (min_ss Un (S n) pr))
H5:forall b : R,
is_upper_bound
  (EUn
     (opp_seq (fun k : nat => Un (S n + k)%nat)))
  b ->
-
glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) <= b
H6:-
glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) <= x
glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  (-
   glb (fun k : nat => Un (S n + k)%nat)
     (min_ss Un (S n) pr))
  assert
    (H7 :=
      H3 (- glb (fun k:nat => Un (S n + k)%nat) (min_ss Un (S n) pr)) H4).
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x /\
(forall b : R,
 is_upper_bound
   (EUn
      (opp_seq (fun k : nat => Un (S n + k)%nat)))
   b -> x <= b)
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
H1:is_upper_bound
  (EUn
     (opp_seq (fun k : nat => Un (S n + k)%nat)))
  (-
   glb (fun k : nat => Un (S n + k)%nat)
     (min_ss Un (S n) pr)) /\
(forall b : R,
 is_upper_bound
   (EUn
      (opp_seq (fun k : nat => Un (S n + k)%nat)))
   b ->
 -
 glb (fun k : nat => Un (S n + k)%nat)
   (min_ss Un (S n) pr) <= b)
H2:is_upper_bound
  (EUn
     (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
H3:forall b : R,
is_upper_bound
  (EUn
     (opp_seq (fun k : nat => Un (S n + k)%nat)))
  b -> x <= b
H4:is_upper_bound
  (EUn
     (opp_seq (fun k : nat => Un (S n + k)%nat)))
  (-
   glb (fun k : nat => Un (S n + k)%nat)
     (min_ss Un (S n) pr))
H5:forall b : R,
is_upper_bound
  (EUn
     (opp_seq (fun k : nat => Un (S n + k)%nat)))
  b ->
-
glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) <= b
H6:-
glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) <= x
H7:x <=
-
glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr)
glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  (-
   glb (fun k : nat => Un (S n + k)%nat)
     (min_ss Un (S n) pr))
  rewrite <-
    (Ropp_involutive
      (glb (fun k:nat => Un (S n + k)%nat) (min_ss Un (S n) pr)))
    .
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x /\
(forall b : R,
 is_upper_bound
   (EUn
      (opp_seq (fun k : nat => Un (S n + k)%nat)))
   b -> x <= b)
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
H1:is_upper_bound
  (EUn
     (opp_seq (fun k : nat => Un (S n + k)%nat)))
  (-
   glb (fun k : nat => Un (S n + k)%nat)
     (min_ss Un (S n) pr)) /\
(forall b : R,
 is_upper_bound
   (EUn
      (opp_seq (fun k : nat => Un (S n + k)%nat)))
   b ->
 -
 glb (fun k : nat => Un (S n + k)%nat)
   (min_ss Un (S n) pr) <= b)
H2:is_upper_bound
  (EUn
     (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
H3:forall b : R,
is_upper_bound
  (EUn
     (opp_seq (fun k : nat => Un (S n + k)%nat)))
  b -> x <= b
H4:is_upper_bound
  (EUn
     (opp_seq (fun k : nat => Un (S n + k)%nat)))
  (-
   glb (fun k : nat => Un (S n + k)%nat)
     (min_ss Un (S n) pr))
H5:forall b : R,
is_upper_bound
  (EUn
     (opp_seq (fun k : nat => Un (S n + k)%nat)))
  b ->
-
glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) <= b
H6:-
glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) <= x
H7:x <=
-
glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr)
-
-
glb (fun k : nat => Un (S n + k)%nat)
  (min_ss Un (S n) pr) = 
- x
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  (-
   glb (fun k : nat => Un (S n + k)%nat)
     (min_ss Un (S n) pr))
  apply Ropp_eq_compat; apply Rle_antisym; assumption.
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  (-
   glb (fun k : nat => Un (S n + k)%nat)
     (min_ss Un (S n) pr))
  unfold glb.
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  (-
   (let (a, _) :=
      lb_to_glb (fun k : nat => Un (S n + k)%nat)
        (min_ss Un (S n) pr) in
    - a))
  case (lb_to_glb (fun k:nat => Un (S n + k)%nat) (min_ss Un (S n) pr)); simpl.
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
forall x1 : R,
is_lub (EUn (opp_seq (fun k : nat => Un (S (n + k)))))
  x1 ->
is_lub (EUn (opp_seq (fun k : nat => Un (S (n + k)))))
  (- - x1)
  intro; rewrite Ropp_involutive.
Un:nat -> R
pr:has_lb Un
n:nat
H:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  l}
H0:{l : R |
is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun k : nat => Un (S n + k)%nat)))
  x
x0:R
p0:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
x1:R
is_lub (EUn (opp_seq (fun k : nat => Un (S (n + k)))))
  x1 ->
is_lub (EUn (opp_seq (fun k : nat => Un (S (n + k)))))
  x1
  trivial.
Qed.

(**********)
Lemma Vn_Un_Wn_order :
  forall (Un:nat -> R) (pr1:has_ub Un) (pr2:has_lb Un)
    (n:nat), sequence_lb Un pr2 n <= Un n <= sequence_ub Un pr1 n.
forall (Un : nat -> R) (pr1 : has_ub Un)
  (pr2 : has_lb Un) (n : nat),
sequence_lb Un pr2 n <= Un n <= sequence_ub Un pr1 n
Proof.
forall (Un : nat -> R) (pr1 : has_ub Un)
  (pr2 : has_lb Un) (n : nat),
sequence_lb Un pr2 n <= Un n <= sequence_ub Un pr1 n
  intros.
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
sequence_lb Un pr2 n <= Un n <= sequence_ub Un pr1 n
  split.
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
sequence_lb Un pr2 n <= Un n
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
Un n <= sequence_ub Un pr1 n
  unfold sequence_lb.
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
glb (fun k : nat => Un (n + k)%nat) (min_ss Un n pr2) <=
Un n
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
Un n <= sequence_ub Un pr1 n
  cut { l:R | is_lub (EUn (opp_seq (fun i:nat => Un (n + i)%nat))) l }.
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
{l : R |
is_lub (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l} ->
glb (fun k : nat => Un (n + k)%nat) (min_ss Un n pr2) <=
Un n
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
{l : R |
is_lub (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
Un n <= sequence_ub Un pr1 n
  intro X.
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
glb (fun k : nat => Un (n + k)%nat) (min_ss Un n pr2) <=
Un n
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
{l : R |
is_lub (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
Un n <= sequence_ub Un pr1 n
  elim X; intros.
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  x
glb (fun k : nat => Un (n + k)%nat) (min_ss Un n pr2) <=
Un n
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
{l : R |
is_lub (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
Un n <= sequence_ub Un pr1 n
  replace (glb (fun k:nat => Un (n + k)%nat) (min_ss Un n pr2)) with (- x).
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  x
- x <= Un n
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  x
- x =
glb (fun k : nat => Un (n + k)%nat) (min_ss Un n pr2)
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
{l : R |
is_lub (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
Un n <= sequence_ub Un pr1 n
  unfold is_lub in p.
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
x:R
p:is_upper_bound
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  x /\
(forall b : R,
 is_upper_bound
   (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
   b -> x <= b)
- x <= Un n
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  x
- x =
glb (fun k : nat => Un (n + k)%nat) (min_ss Un n pr2)
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
{l : R |
is_lub (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
Un n <= sequence_ub Un pr1 n
  elim p; intros.
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
x:R
p:is_upper_bound
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  x /\
(forall b : R,
 is_upper_bound
   (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
   b -> x <= b)
H:is_upper_bound
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  x
H0:forall b : R,
is_upper_bound
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  b -> x <= b
- x <= Un n
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  x
- x =
glb (fun k : nat => Un (n + k)%nat) (min_ss Un n pr2)
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
{l : R |
is_lub (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
Un n <= sequence_ub Un pr1 n
  unfold is_upper_bound in H.
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
x:R
p:is_upper_bound
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  x /\
(forall b : R,
 is_upper_bound
   (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
   b -> x <= b)
H:forall x0 : R,
EUn (opp_seq (fun i : nat => Un (n + i)%nat)) x0 ->
x0 <= x
H0:forall b : R,
is_upper_bound
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  b -> x <= b
- x <= Un n
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  x
- x =
glb (fun k : nat => Un (n + k)%nat) (min_ss Un n pr2)
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
{l : R |
is_lub (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
Un n <= sequence_ub Un pr1 n
  rewrite <- (Ropp_involutive (Un n)).
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
x:R
p:is_upper_bound
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  x /\
(forall b : R,
 is_upper_bound
   (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
   b -> x <= b)
H:forall x0 : R,
EUn (opp_seq (fun i : nat => Un (n + i)%nat)) x0 ->
x0 <= x
H0:forall b : R,
is_upper_bound
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  b -> x <= b
- x <= - - Un n
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  x
- x =
glb (fun k : nat => Un (n + k)%nat) (min_ss Un n pr2)
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
{l : R |
is_lub (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
Un n <= sequence_ub Un pr1 n
  apply Ropp_le_contravar.
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
x:R
p:is_upper_bound
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  x /\
(forall b : R,
 is_upper_bound
   (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
   b -> x <= b)
H:forall x0 : R,
EUn (opp_seq (fun i : nat => Un (n + i)%nat)) x0 ->
x0 <= x
H0:forall b : R,
is_upper_bound
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  b -> x <= b
- Un n <= x
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  x
- x =
glb (fun k : nat => Un (n + k)%nat) (min_ss Un n pr2)
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
{l : R |
is_lub (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
Un n <= sequence_ub Un pr1 n
  apply H.
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
x:R
p:is_upper_bound
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  x /\
(forall b : R,
 is_upper_bound
   (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
   b -> x <= b)
H:forall x0 : R,
EUn (opp_seq (fun i : nat => Un (n + i)%nat)) x0 ->
x0 <= x
H0:forall b : R,
is_upper_bound
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  b -> x <= b
EUn (opp_seq (fun i : nat => Un (n + i)%nat)) (- Un n)
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  x
- x =
glb (fun k : nat => Un (n + k)%nat) (min_ss Un n pr2)
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
{l : R |
is_lub (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
Un n <= sequence_ub Un pr1 n
  exists 0%nat.
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
x:R
p:is_upper_bound
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  x /\
(forall b : R,
 is_upper_bound
   (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
   b -> x <= b)
H:forall x0 : R,
EUn (opp_seq (fun i : nat => Un (n + i)%nat)) x0 ->
x0 <= x
H0:forall b : R,
is_upper_bound
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  b -> x <= b
- Un n = opp_seq (fun i : nat => Un (n + i)%nat) 0
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  x
- x =
glb (fun k : nat => Un (n + k)%nat) (min_ss Un n pr2)
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
{l : R |
is_lub (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
Un n <= sequence_ub Un pr1 n
  unfold opp_seq.
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
x:R
p:is_upper_bound
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  x /\
(forall b : R,
 is_upper_bound
   (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
   b -> x <= b)
H:forall x0 : R,
EUn (opp_seq (fun i : nat => Un (n + i)%nat)) x0 ->
x0 <= x
H0:forall b : R,
is_upper_bound
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  b -> x <= b
- Un n = - Un (n + 0)%nat
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  x
- x =
glb (fun k : nat => Un (n + k)%nat) (min_ss Un n pr2)
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
{l : R |
is_lub (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
Un n <= sequence_ub Un pr1 n
  replace (n + 0)%nat with n; [ reflexivity | ring ].
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  x
- x =
glb (fun k : nat => Un (n + k)%nat) (min_ss Un n pr2)
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
{l : R |
is_lub (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
Un n <= sequence_ub Un pr1 n
  cut
    (is_lub (EUn (opp_seq (fun k:nat => Un (n + k)%nat)))
      (- glb (fun k:nat => Un (n + k)%nat) (min_ss Un n pr2))).
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  x
is_lub (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  (-
   glb (fun k : nat => Un (n + k)%nat)
     (min_ss Un n pr2)) ->
- x =
glb (fun k : nat => Un (n + k)%nat) (min_ss Un n pr2)
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  x
is_lub (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  (-
   glb (fun k : nat => Un (n + k)%nat)
     (min_ss Un n pr2))
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
{l : R |
is_lub (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
Un n <= sequence_ub Un pr1 n
  intro.
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  x
H:is_lub
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  (-
   glb (fun k : nat => Un (n + k)%nat)
     (min_ss Un n pr2))
- x =
glb (fun k : nat => Un (n + k)%nat) (min_ss Un n pr2)
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  x
is_lub (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  (-
   glb (fun k : nat => Un (n + k)%nat)
     (min_ss Un n pr2))
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
{l : R |
is_lub (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
Un n <= sequence_ub Un pr1 n
  unfold is_lub in p; unfold is_lub in H.
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
x:R
p:is_upper_bound
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  x /\
(forall b : R,
 is_upper_bound
   (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
   b -> x <= b)
H:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  (-
   glb (fun k : nat => Un (n + k)%nat)
     (min_ss Un n pr2)) /\
(forall b : R,
 is_upper_bound
   (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
   b ->
 -
 glb (fun k : nat => Un (n + k)%nat)
   (min_ss Un n pr2) <= b)
- x =
glb (fun k : nat => Un (n + k)%nat) (min_ss Un n pr2)
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  x
is_lub (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  (-
   glb (fun k : nat => Un (n + k)%nat)
     (min_ss Un n pr2))
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
{l : R |
is_lub (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
Un n <= sequence_ub Un pr1 n
  elim p; intros; elim H; intros.
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
x:R
p:is_upper_bound
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  x /\
(forall b : R,
 is_upper_bound
   (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
   b -> x <= b)
H:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  (-
   glb (fun k : nat => Un (n + k)%nat)
     (min_ss Un n pr2)) /\
(forall b : R,
 is_upper_bound
   (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
   b ->
 -
 glb (fun k : nat => Un (n + k)%nat)
   (min_ss Un n pr2) <= b)
H0:is_upper_bound
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  x
H1:forall b : R,
is_upper_bound
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  b -> x <= b
H2:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  (-
   glb (fun k : nat => Un (n + k)%nat)
     (min_ss Un n pr2))
H3:forall b : R,
is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  b ->
-
glb (fun k : nat => Un (n + k)%nat)
  (min_ss Un n pr2) <= b
- x =
glb (fun k : nat => Un (n + k)%nat) (min_ss Un n pr2)
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  x
is_lub (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  (-
   glb (fun k : nat => Un (n + k)%nat)
     (min_ss Un n pr2))
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
{l : R |
is_lub (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
Un n <= sequence_ub Un pr1 n
  assert (H4 := H3 x H0).
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
x:R
p:is_upper_bound
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  x /\
(forall b : R,
 is_upper_bound
   (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
   b -> x <= b)
H:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  (-
   glb (fun k : nat => Un (n + k)%nat)
     (min_ss Un n pr2)) /\
(forall b : R,
 is_upper_bound
   (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
   b ->
 -
 glb (fun k : nat => Un (n + k)%nat)
   (min_ss Un n pr2) <= b)
H0:is_upper_bound
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  x
H1:forall b : R,
is_upper_bound
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  b -> x <= b
H2:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  (-
   glb (fun k : nat => Un (n + k)%nat)
     (min_ss Un n pr2))
H3:forall b : R,
is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  b ->
-
glb (fun k : nat => Un (n + k)%nat)
  (min_ss Un n pr2) <= b
H4:-
glb (fun k : nat => Un (n + k)%nat)
  (min_ss Un n pr2) <= x
- x =
glb (fun k : nat => Un (n + k)%nat) (min_ss Un n pr2)
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  x
is_lub (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  (-
   glb (fun k : nat => Un (n + k)%nat)
     (min_ss Un n pr2))
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
{l : R |
is_lub (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
Un n <= sequence_ub Un pr1 n
  assert
    (H5 := H1 (- glb (fun k:nat => Un (n + k)%nat) (min_ss Un n pr2)) H2).
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
x:R
p:is_upper_bound
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  x /\
(forall b : R,
 is_upper_bound
   (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
   b -> x <= b)
H:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  (-
   glb (fun k : nat => Un (n + k)%nat)
     (min_ss Un n pr2)) /\
(forall b : R,
 is_upper_bound
   (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
   b ->
 -
 glb (fun k : nat => Un (n + k)%nat)
   (min_ss Un n pr2) <= b)
H0:is_upper_bound
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  x
H1:forall b : R,
is_upper_bound
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  b -> x <= b
H2:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  (-
   glb (fun k : nat => Un (n + k)%nat)
     (min_ss Un n pr2))
H3:forall b : R,
is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  b ->
-
glb (fun k : nat => Un (n + k)%nat)
  (min_ss Un n pr2) <= b
H4:-
glb (fun k : nat => Un (n + k)%nat)
  (min_ss Un n pr2) <= x
H5:x <=
-
glb (fun k : nat => Un (n + k)%nat)
  (min_ss Un n pr2)
- x =
glb (fun k : nat => Un (n + k)%nat) (min_ss Un n pr2)
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  x
is_lub (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  (-
   glb (fun k : nat => Un (n + k)%nat)
     (min_ss Un n pr2))
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
{l : R |
is_lub (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
Un n <= sequence_ub Un pr1 n
  rewrite <-
    (Ropp_involutive (glb (fun k:nat => Un (n + k)%nat) (min_ss Un n pr2)))
    .
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
x:R
p:is_upper_bound
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  x /\
(forall b : R,
 is_upper_bound
   (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
   b -> x <= b)
H:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  (-
   glb (fun k : nat => Un (n + k)%nat)
     (min_ss Un n pr2)) /\
(forall b : R,
 is_upper_bound
   (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
   b ->
 -
 glb (fun k : nat => Un (n + k)%nat)
   (min_ss Un n pr2) <= b)
H0:is_upper_bound
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  x
H1:forall b : R,
is_upper_bound
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  b -> x <= b
H2:is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  (-
   glb (fun k : nat => Un (n + k)%nat)
     (min_ss Un n pr2))
H3:forall b : R,
is_upper_bound
  (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  b ->
-
glb (fun k : nat => Un (n + k)%nat)
  (min_ss Un n pr2) <= b
H4:-
glb (fun k : nat => Un (n + k)%nat)
  (min_ss Un n pr2) <= x
H5:x <=
-
glb (fun k : nat => Un (n + k)%nat)
  (min_ss Un n pr2)
- x =
-
-
glb (fun k : nat => Un (n + k)%nat) (min_ss Un n pr2)
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  x
is_lub (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  (-
   glb (fun k : nat => Un (n + k)%nat)
     (min_ss Un n pr2))
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
{l : R |
is_lub (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
Un n <= sequence_ub Un pr1 n
  apply Ropp_eq_compat; apply Rle_antisym; assumption.
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  x
is_lub (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  (-
   glb (fun k : nat => Un (n + k)%nat)
     (min_ss Un n pr2))
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
{l : R |
is_lub (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
Un n <= sequence_ub Un pr1 n
  unfold glb.
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  x
is_lub (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  (-
   (let (a, _) :=
      lb_to_glb (fun k : nat => Un (n + k)%nat)
        (min_ss Un n pr2) in
    - a))
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
{l : R |
is_lub (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
Un n <= sequence_ub Un pr1 n
  case (lb_to_glb (fun k:nat => Un (n + k)%nat) (min_ss Un n pr2)); simpl.
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  x
forall x0 : R,
is_lub (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0 ->
is_lub (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  (- - x0)
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
{l : R |
is_lub (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
Un n <= sequence_ub Un pr1 n
  intro; rewrite Ropp_involutive.
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
x:R
p:is_lub
  (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  x
x0:R
is_lub (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0 ->
is_lub (EUn (opp_seq (fun k : nat => Un (n + k)%nat)))
  x0
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
{l : R |
is_lub (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
Un n <= sequence_ub Un pr1 n
  trivial.
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
{l : R |
is_lub (EUn (opp_seq (fun i : nat => Un (n + i)%nat)))
  l}
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
Un n <= sequence_ub Un pr1 n
  apply lb_to_glb.
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
has_lb (fun i : nat => Un (n + i)%nat)
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
Un n <= sequence_ub Un pr1 n
  apply min_ss; assumption.
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
Un n <= sequence_ub Un pr1 n
  unfold sequence_ub.
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
Un n <=
lub (fun k : nat => Un (n + k)%nat) (maj_ss Un n pr1)
  cut { l:R | is_lub (EUn (fun i:nat => Un (n + i)%nat)) l }.
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
{l : R |
is_lub (EUn (fun i : nat => Un (n + i)%nat)) l} ->
Un n <=
lub (fun k : nat => Un (n + k)%nat) (maj_ss Un n pr1)
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
{l : R |
is_lub (EUn (fun i : nat => Un (n + i)%nat)) l}
  intro X.
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub (EUn (fun i : nat => Un (n + i)%nat)) l}
Un n <=
lub (fun k : nat => Un (n + k)%nat) (maj_ss Un n pr1)
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
{l : R |
is_lub (EUn (fun i : nat => Un (n + i)%nat)) l}
  elim X; intros.
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub (EUn (fun i : nat => Un (n + i)%nat)) l}
x:R
p:is_lub (EUn (fun i : nat => Un (n + i)%nat)) x
Un n <=
lub (fun k : nat => Un (n + k)%nat) (maj_ss Un n pr1)
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
{l : R |
is_lub (EUn (fun i : nat => Un (n + i)%nat)) l}
  replace (lub (fun k:nat => Un (n + k)%nat) (maj_ss Un n pr1)) with x.
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub (EUn (fun i : nat => Un (n + i)%nat)) l}
x:R
p:is_lub (EUn (fun i : nat => Un (n + i)%nat)) x
Un n <= x
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub (EUn (fun i : nat => Un (n + i)%nat)) l}
x:R
p:is_lub (EUn (fun i : nat => Un (n + i)%nat)) x
x =
lub (fun k : nat => Un (n + k)%nat) (maj_ss Un n pr1)
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
{l : R |
is_lub (EUn (fun i : nat => Un (n + i)%nat)) l}
  unfold is_lub in p.
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub (EUn (fun i : nat => Un (n + i)%nat)) l}
x:R
p:is_upper_bound
  (EUn (fun i : nat => Un (n + i)%nat)) x /\
(forall b : R,
 is_upper_bound
   (EUn (fun i : nat => Un (n + i)%nat)) b ->
 x <= b)
Un n <= x
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub (EUn (fun i : nat => Un (n + i)%nat)) l}
x:R
p:is_lub (EUn (fun i : nat => Un (n + i)%nat)) x
x =
lub (fun k : nat => Un (n + k)%nat) (maj_ss Un n pr1)
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
{l : R |
is_lub (EUn (fun i : nat => Un (n + i)%nat)) l}
  elim p; intros.
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub (EUn (fun i : nat => Un (n + i)%nat)) l}
x:R
p:is_upper_bound
  (EUn (fun i : nat => Un (n + i)%nat)) x /\
(forall b : R,
 is_upper_bound
   (EUn (fun i : nat => Un (n + i)%nat)) b ->
 x <= b)
H:is_upper_bound
  (EUn (fun i : nat => Un (n + i)%nat)) x
H0:forall b : R,
is_upper_bound
  (EUn (fun i : nat => Un (n + i)%nat)) b ->
x <= b
Un n <= x
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub (EUn (fun i : nat => Un (n + i)%nat)) l}
x:R
p:is_lub (EUn (fun i : nat => Un (n + i)%nat)) x
x =
lub (fun k : nat => Un (n + k)%nat) (maj_ss Un n pr1)
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
{l : R |
is_lub (EUn (fun i : nat => Un (n + i)%nat)) l}
  unfold is_upper_bound in H.
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub (EUn (fun i : nat => Un (n + i)%nat)) l}
x:R
p:is_upper_bound
  (EUn (fun i : nat => Un (n + i)%nat)) x /\
(forall b : R,
 is_upper_bound
   (EUn (fun i : nat => Un (n + i)%nat)) b ->
 x <= b)
H:forall x0 : R,
EUn (fun i : nat => Un (n + i)%nat) x0 -> x0 <= x
H0:forall b : R,
is_upper_bound
  (EUn (fun i : nat => Un (n + i)%nat)) b ->
x <= b
Un n <= x
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub (EUn (fun i : nat => Un (n + i)%nat)) l}
x:R
p:is_lub (EUn (fun i : nat => Un (n + i)%nat)) x
x =
lub (fun k : nat => Un (n + k)%nat) (maj_ss Un n pr1)
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
{l : R |
is_lub (EUn (fun i : nat => Un (n + i)%nat)) l}
  apply H.
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub (EUn (fun i : nat => Un (n + i)%nat)) l}
x:R
p:is_upper_bound
  (EUn (fun i : nat => Un (n + i)%nat)) x /\
(forall b : R,
 is_upper_bound
   (EUn (fun i : nat => Un (n + i)%nat)) b ->
 x <= b)
H:forall x0 : R,
EUn (fun i : nat => Un (n + i)%nat) x0 -> x0 <= x
H0:forall b : R,
is_upper_bound
  (EUn (fun i : nat => Un (n + i)%nat)) b ->
x <= b
EUn (fun i : nat => Un (n + i)%nat) (Un n)
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub (EUn (fun i : nat => Un (n + i)%nat)) l}
x:R
p:is_lub (EUn (fun i : nat => Un (n + i)%nat)) x
x =
lub (fun k : nat => Un (n + k)%nat) (maj_ss Un n pr1)
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
{l : R |
is_lub (EUn (fun i : nat => Un (n + i)%nat)) l}
  exists 0%nat.
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub (EUn (fun i : nat => Un (n + i)%nat)) l}
x:R
p:is_upper_bound
  (EUn (fun i : nat => Un (n + i)%nat)) x /\
(forall b : R,
 is_upper_bound
   (EUn (fun i : nat => Un (n + i)%nat)) b ->
 x <= b)
H:forall x0 : R,
EUn (fun i : nat => Un (n + i)%nat) x0 -> x0 <= x
H0:forall b : R,
is_upper_bound
  (EUn (fun i : nat => Un (n + i)%nat)) b ->
x <= b
Un n = Un (n + 0)%nat
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub (EUn (fun i : nat => Un (n + i)%nat)) l}
x:R
p:is_lub (EUn (fun i : nat => Un (n + i)%nat)) x
x =
lub (fun k : nat => Un (n + k)%nat) (maj_ss Un n pr1)
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
{l : R |
is_lub (EUn (fun i : nat => Un (n + i)%nat)) l}
  replace (n + 0)%nat with n; [ reflexivity | ring ].
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub (EUn (fun i : nat => Un (n + i)%nat)) l}
x:R
p:is_lub (EUn (fun i : nat => Un (n + i)%nat)) x
x =
lub (fun k : nat => Un (n + k)%nat) (maj_ss Un n pr1)
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
{l : R |
is_lub (EUn (fun i : nat => Un (n + i)%nat)) l}
  cut
    (is_lub (EUn (fun k:nat => Un (n + k)%nat))
      (lub (fun k:nat => Un (n + k)%nat) (maj_ss Un n pr1))).
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub (EUn (fun i : nat => Un (n + i)%nat)) l}
x:R
p:is_lub (EUn (fun i : nat => Un (n + i)%nat)) x
is_lub (EUn (fun k : nat => Un (n + k)%nat))
  (lub (fun k : nat => Un (n + k)%nat)
     (maj_ss Un n pr1)) ->
x =
lub (fun k : nat => Un (n + k)%nat) (maj_ss Un n pr1)
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub (EUn (fun i : nat => Un (n + i)%nat)) l}
x:R
p:is_lub (EUn (fun i : nat => Un (n + i)%nat)) x
is_lub (EUn (fun k : nat => Un (n + k)%nat))
  (lub (fun k : nat => Un (n + k)%nat)
     (maj_ss Un n pr1))
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
{l : R |
is_lub (EUn (fun i : nat => Un (n + i)%nat)) l}
  intro.
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub (EUn (fun i : nat => Un (n + i)%nat)) l}
x:R
p:is_lub (EUn (fun i : nat => Un (n + i)%nat)) x
H:is_lub (EUn (fun k : nat => Un (n + k)%nat))
  (lub (fun k : nat => Un (n + k)%nat)
     (maj_ss Un n pr1))
x =
lub (fun k : nat => Un (n + k)%nat) (maj_ss Un n pr1)
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub (EUn (fun i : nat => Un (n + i)%nat)) l}
x:R
p:is_lub (EUn (fun i : nat => Un (n + i)%nat)) x
is_lub (EUn (fun k : nat => Un (n + k)%nat))
  (lub (fun k : nat => Un (n + k)%nat)
     (maj_ss Un n pr1))
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
{l : R |
is_lub (EUn (fun i : nat => Un (n + i)%nat)) l}
  unfold is_lub in p; unfold is_lub in H.
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub (EUn (fun i : nat => Un (n + i)%nat)) l}
x:R
p:is_upper_bound
  (EUn (fun i : nat => Un (n + i)%nat)) x /\
(forall b : R,
 is_upper_bound
   (EUn (fun i : nat => Un (n + i)%nat)) b ->
 x <= b)
H:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat))
  (lub (fun k : nat => Un (n + k)%nat)
     (maj_ss Un n pr1)) /\
(forall b : R,
 is_upper_bound
   (EUn (fun k : nat => Un (n + k)%nat)) b ->
 lub (fun k : nat => Un (n + k)%nat)
   (maj_ss Un n pr1) <= b)
x =
lub (fun k : nat => Un (n + k)%nat) (maj_ss Un n pr1)
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub (EUn (fun i : nat => Un (n + i)%nat)) l}
x:R
p:is_lub (EUn (fun i : nat => Un (n + i)%nat)) x
is_lub (EUn (fun k : nat => Un (n + k)%nat))
  (lub (fun k : nat => Un (n + k)%nat)
     (maj_ss Un n pr1))
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
{l : R |
is_lub (EUn (fun i : nat => Un (n + i)%nat)) l}
  elim p; intros; elim H; intros.
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub (EUn (fun i : nat => Un (n + i)%nat)) l}
x:R
p:is_upper_bound
  (EUn (fun i : nat => Un (n + i)%nat)) x /\
(forall b : R,
 is_upper_bound
   (EUn (fun i : nat => Un (n + i)%nat)) b ->
 x <= b)
H:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat))
  (lub (fun k : nat => Un (n + k)%nat)
     (maj_ss Un n pr1)) /\
(forall b : R,
 is_upper_bound
   (EUn (fun k : nat => Un (n + k)%nat)) b ->
 lub (fun k : nat => Un (n + k)%nat)
   (maj_ss Un n pr1) <= b)
H0:is_upper_bound
  (EUn (fun i : nat => Un (n + i)%nat)) x
H1:forall b : R,
is_upper_bound
  (EUn (fun i : nat => Un (n + i)%nat)) b ->
x <= b
H2:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat))
  (lub (fun k : nat => Un (n + k)%nat)
     (maj_ss Un n pr1))
H3:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
lub (fun k : nat => Un (n + k)%nat)
  (maj_ss Un n pr1) <= b
x =
lub (fun k : nat => Un (n + k)%nat) (maj_ss Un n pr1)
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub (EUn (fun i : nat => Un (n + i)%nat)) l}
x:R
p:is_lub (EUn (fun i : nat => Un (n + i)%nat)) x
is_lub (EUn (fun k : nat => Un (n + k)%nat))
  (lub (fun k : nat => Un (n + k)%nat)
     (maj_ss Un n pr1))
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
{l : R |
is_lub (EUn (fun i : nat => Un (n + i)%nat)) l}
  assert (H4 := H3 x H0).
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub (EUn (fun i : nat => Un (n + i)%nat)) l}
x:R
p:is_upper_bound
  (EUn (fun i : nat => Un (n + i)%nat)) x /\
(forall b : R,
 is_upper_bound
   (EUn (fun i : nat => Un (n + i)%nat)) b ->
 x <= b)
H:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat))
  (lub (fun k : nat => Un (n + k)%nat)
     (maj_ss Un n pr1)) /\
(forall b : R,
 is_upper_bound
   (EUn (fun k : nat => Un (n + k)%nat)) b ->
 lub (fun k : nat => Un (n + k)%nat)
   (maj_ss Un n pr1) <= b)
H0:is_upper_bound
  (EUn (fun i : nat => Un (n + i)%nat)) x
H1:forall b : R,
is_upper_bound
  (EUn (fun i : nat => Un (n + i)%nat)) b ->
x <= b
H2:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat))
  (lub (fun k : nat => Un (n + k)%nat)
     (maj_ss Un n pr1))
H3:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
lub (fun k : nat => Un (n + k)%nat)
  (maj_ss Un n pr1) <= b
H4:lub (fun k : nat => Un (n + k)%nat)
  (maj_ss Un n pr1) <= x
x =
lub (fun k : nat => Un (n + k)%nat) (maj_ss Un n pr1)
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub (EUn (fun i : nat => Un (n + i)%nat)) l}
x:R
p:is_lub (EUn (fun i : nat => Un (n + i)%nat)) x
is_lub (EUn (fun k : nat => Un (n + k)%nat))
  (lub (fun k : nat => Un (n + k)%nat)
     (maj_ss Un n pr1))
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
{l : R |
is_lub (EUn (fun i : nat => Un (n + i)%nat)) l}
  assert
    (H5 := H1 (lub (fun k:nat => Un (n + k)%nat) (maj_ss Un n pr1)) H2).
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub (EUn (fun i : nat => Un (n + i)%nat)) l}
x:R
p:is_upper_bound
  (EUn (fun i : nat => Un (n + i)%nat)) x /\
(forall b : R,
 is_upper_bound
   (EUn (fun i : nat => Un (n + i)%nat)) b ->
 x <= b)
H:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat))
  (lub (fun k : nat => Un (n + k)%nat)
     (maj_ss Un n pr1)) /\
(forall b : R,
 is_upper_bound
   (EUn (fun k : nat => Un (n + k)%nat)) b ->
 lub (fun k : nat => Un (n + k)%nat)
   (maj_ss Un n pr1) <= b)
H0:is_upper_bound
  (EUn (fun i : nat => Un (n + i)%nat)) x
H1:forall b : R,
is_upper_bound
  (EUn (fun i : nat => Un (n + i)%nat)) b ->
x <= b
H2:is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat))
  (lub (fun k : nat => Un (n + k)%nat)
     (maj_ss Un n pr1))
H3:forall b : R,
is_upper_bound
  (EUn (fun k : nat => Un (n + k)%nat)) b ->
lub (fun k : nat => Un (n + k)%nat)
  (maj_ss Un n pr1) <= b
H4:lub (fun k : nat => Un (n + k)%nat)
  (maj_ss Un n pr1) <= x
H5:x <=
lub (fun k : nat => Un (n + k)%nat)
  (maj_ss Un n pr1)
x =
lub (fun k : nat => Un (n + k)%nat) (maj_ss Un n pr1)
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub (EUn (fun i : nat => Un (n + i)%nat)) l}
x:R
p:is_lub (EUn (fun i : nat => Un (n + i)%nat)) x
is_lub (EUn (fun k : nat => Un (n + k)%nat))
  (lub (fun k : nat => Un (n + k)%nat)
     (maj_ss Un n pr1))
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
{l : R |
is_lub (EUn (fun i : nat => Un (n + i)%nat)) l}
  apply Rle_antisym; assumption.
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub (EUn (fun i : nat => Un (n + i)%nat)) l}
x:R
p:is_lub (EUn (fun i : nat => Un (n + i)%nat)) x
is_lub (EUn (fun k : nat => Un (n + k)%nat))
  (lub (fun k : nat => Un (n + k)%nat)
     (maj_ss Un n pr1))
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
{l : R |
is_lub (EUn (fun i : nat => Un (n + i)%nat)) l}
  unfold lub.
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub (EUn (fun i : nat => Un (n + i)%nat)) l}
x:R
p:is_lub (EUn (fun i : nat => Un (n + i)%nat)) x
is_lub (EUn (fun k : nat => Un (n + k)%nat))
  (let (a, _) :=
     ub_to_lub (fun k : nat => Un (n + k)%nat)
       (maj_ss Un n pr1) in
   a)
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
{l : R |
is_lub (EUn (fun i : nat => Un (n + i)%nat)) l}
  case (ub_to_lub (fun k:nat => Un (n + k)%nat) (maj_ss Un n pr1)).
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
X:{l : R |
is_lub (EUn (fun i : nat => Un (n + i)%nat)) l}
x:R
p:is_lub (EUn (fun i : nat => Un (n + i)%nat)) x
forall x0 : R,
is_lub (EUn (fun k : nat => Un (n + k)%nat)) x0 ->
is_lub (EUn (fun k : nat => Un (n + k)%nat)) x0
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
{l : R |
is_lub (EUn (fun i : nat => Un (n + i)%nat)) l}
  intro; trivial.
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
{l : R |
is_lub (EUn (fun i : nat => Un (n + i)%nat)) l}
  apply ub_to_lub.
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
n:nat
has_ub (fun i : nat => Un (n + i)%nat)
  apply maj_ss; assumption.
Qed.

Lemma min_maj :
  forall (Un:nat -> R) (pr1:has_ub Un) (pr2:has_lb Un),
    has_ub (sequence_lb Un pr2).
forall Un : nat -> R,
has_ub Un ->
forall pr2 : has_lb Un, has_ub (sequence_lb Un pr2)
Proof.
forall Un : nat -> R,
has_ub Un ->
forall pr2 : has_lb Un, has_ub (sequence_lb Un pr2)
  intros.
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
has_ub (sequence_lb Un pr2)
  assert (H := Vn_Un_Wn_order Un pr1 pr2).
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
H:forall n : nat,
sequence_lb Un pr2 n <= Un n <=
sequence_ub Un pr1 n
has_ub (sequence_lb Un pr2)
  unfold has_ub.
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
H:forall n : nat,
sequence_lb Un pr2 n <= Un n <=
sequence_ub Un pr1 n
bound (EUn (sequence_lb Un pr2))
  unfold bound.
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
H:forall n : nat,
sequence_lb Un pr2 n <= Un n <=
sequence_ub Un pr1 n
exists m : R,
  is_upper_bound (EUn (sequence_lb Un pr2)) m
  unfold has_ub in pr1.
Un:nat -> R
pr1:bound (EUn Un)
pr2:has_lb Un
H:forall n : nat,
sequence_lb Un pr2 n <= Un n <=
sequence_ub Un pr1 n
exists m : R,
  is_upper_bound (EUn (sequence_lb Un pr2)) m
  unfold bound in pr1.
Un:nat -> R
pr1:exists m : R, is_upper_bound (EUn Un) m
pr2:has_lb Un
H:forall n : nat,
sequence_lb Un pr2 n <= Un n <=
sequence_ub Un pr1 n
exists m : R,
  is_upper_bound (EUn (sequence_lb Un pr2)) m
  elim pr1; intros.
Un:nat -> R
pr1:exists m : R, is_upper_bound (EUn Un) m
pr2:has_lb Un
H:forall n : nat,
sequence_lb Un pr2 n <= Un n <=
sequence_ub Un pr1 n
x:R
H0:is_upper_bound (EUn Un) x
exists m : R,
  is_upper_bound (EUn (sequence_lb Un pr2)) m
  exists x.
Un:nat -> R
pr1:exists m : R, is_upper_bound (EUn Un) m
pr2:has_lb Un
H:forall n : nat,
sequence_lb Un pr2 n <= Un n <=
sequence_ub Un pr1 n
x:R
H0:is_upper_bound (EUn Un) x
is_upper_bound (EUn (sequence_lb Un pr2)) x
  unfold is_upper_bound.
Un:nat -> R
pr1:exists m : R, is_upper_bound (EUn Un) m
pr2:has_lb Un
H:forall n : nat,
sequence_lb Un pr2 n <= Un n <=
sequence_ub Un pr1 n
x:R
H0:is_upper_bound (EUn Un) x
forall x0 : R, EUn (sequence_lb Un pr2) x0 -> x0 <= x
  intros.
Un:nat -> R
pr1:exists m : R, is_upper_bound (EUn Un) m
pr2:has_lb Un
H:forall n : nat,
sequence_lb Un pr2 n <= Un n <=
sequence_ub Un pr1 n
x:R
H0:is_upper_bound (EUn Un) x
x0:R
H1:EUn (sequence_lb Un pr2) x0
x0 <= x
  unfold is_upper_bound in H0.
Un:nat -> R
pr1:exists m : R, is_upper_bound (EUn Un) m
pr2:has_lb Un
H:forall n : nat,
sequence_lb Un pr2 n <= Un n <=
sequence_ub Un pr1 n
x:R
H0:forall x1 : R, EUn Un x1 -> x1 <= x
x0:R
H1:EUn (sequence_lb Un pr2) x0
x0 <= x
  elim H1; intros.
Un:nat -> R
pr1:exists m : R, is_upper_bound (EUn Un) m
pr2:has_lb Un
H:forall n : nat,
sequence_lb Un pr2 n <= Un n <=
sequence_ub Un pr1 n
x:R
H0:forall x2 : R, EUn Un x2 -> x2 <= x
x0:R
H1:EUn (sequence_lb Un pr2) x0
x1:nat
H2:x0 = sequence_lb Un pr2 x1
x0 <= x
  rewrite H2.
Un:nat -> R
pr1:exists m : R, is_upper_bound (EUn Un) m
pr2:has_lb Un
H:forall n : nat,
sequence_lb Un pr2 n <= Un n <=
sequence_ub Un pr1 n
x:R
H0:forall x2 : R, EUn Un x2 -> x2 <= x
x0:R
H1:EUn (sequence_lb Un pr2) x0
x1:nat
H2:x0 = sequence_lb Un pr2 x1
sequence_lb Un pr2 x1 <= x
  apply Rle_trans with (Un x1).
Un:nat -> R
pr1:exists m : R, is_upper_bound (EUn Un) m
pr2:has_lb Un
H:forall n : nat,
sequence_lb Un pr2 n <= Un n <=
sequence_ub Un pr1 n
x:R
H0:forall x2 : R, EUn Un x2 -> x2 <= x
x0:R
H1:EUn (sequence_lb Un pr2) x0
x1:nat
H2:x0 = sequence_lb Un pr2 x1
sequence_lb Un pr2 x1 <= Un x1
Un:nat -> R
pr1:exists m : R, is_upper_bound (EUn Un) m
pr2:has_lb Un
H:forall n : nat,
sequence_lb Un pr2 n <= Un n <=
sequence_ub Un pr1 n
x:R
H0:forall x2 : R, EUn Un x2 -> x2 <= x
x0:R
H1:EUn (sequence_lb Un pr2) x0
x1:nat
H2:x0 = sequence_lb Un pr2 x1
Un x1 <= x
  assert (H3 := H x1); elim H3; intros; assumption.
Un:nat -> R
pr1:exists m : R, is_upper_bound (EUn Un) m
pr2:has_lb Un
H:forall n : nat,
sequence_lb Un pr2 n <= Un n <=
sequence_ub Un pr1 n
x:R
H0:forall x2 : R, EUn Un x2 -> x2 <= x
x0:R
H1:EUn (sequence_lb Un pr2) x0
x1:nat
H2:x0 = sequence_lb Un pr2 x1
Un x1 <= x
  apply H0.
Un:nat -> R
pr1:exists m : R, is_upper_bound (EUn Un) m
pr2:has_lb Un
H:forall n : nat,
sequence_lb Un pr2 n <= Un n <=
sequence_ub Un pr1 n
x:R
H0:forall x2 : R, EUn Un x2 -> x2 <= x
x0:R
H1:EUn (sequence_lb Un pr2) x0
x1:nat
H2:x0 = sequence_lb Un pr2 x1
EUn Un (Un x1)
  exists x1; reflexivity.
Qed.

Lemma maj_min :
  forall (Un:nat -> R) (pr1:has_ub Un) (pr2:has_lb Un),
    has_lb (sequence_ub Un pr1).
forall (Un : nat -> R) (pr1 : has_ub Un),
has_lb Un -> has_lb (sequence_ub Un pr1)
Proof.
forall (Un : nat -> R) (pr1 : has_ub Un),
has_lb Un -> has_lb (sequence_ub Un pr1)
  intros.
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
has_lb (sequence_ub Un pr1)
  assert (H := Vn_Un_Wn_order Un pr1 pr2).
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
H:forall n : nat,
sequence_lb Un pr2 n <= Un n <=
sequence_ub Un pr1 n
has_lb (sequence_ub Un pr1)
  unfold has_lb.
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
H:forall n : nat,
sequence_lb Un pr2 n <= Un n <=
sequence_ub Un pr1 n
bound (EUn (opp_seq (sequence_ub Un pr1)))
  unfold bound.
Un:nat -> R
pr1:has_ub Un
pr2:has_lb Un
H:forall n : nat,
sequence_lb Un pr2 n <= Un n <=
sequence_ub Un pr1 n
exists m : R,
  is_upper_bound (EUn (opp_seq (sequence_ub Un pr1)))
    m
  unfold has_lb in pr2.
Un:nat -> R
pr1:has_ub Un
pr2:bound (EUn (opp_seq Un))
H:forall n : nat,
sequence_lb Un pr2 n <= Un n <=
sequence_ub Un pr1 n
exists m : R,
  is_upper_bound (EUn (opp_seq (sequence_ub Un pr1)))
    m
  unfold bound in pr2.
Un:nat -> R
pr1:has_ub Un
pr2:exists m : R, is_upper_bound (EUn (opp_seq Un)) m
H:forall n : nat,
sequence_lb Un pr2 n <= Un n <=
sequence_ub Un pr1 n
exists m : R,
  is_upper_bound (EUn (opp_seq (sequence_ub Un pr1)))
    m
  elim pr2; intros.
Un:nat -> R
pr1:has_ub Un
pr2:exists m : R, is_upper_bound (EUn (opp_seq Un)) m
H:forall n : nat,
sequence_lb Un pr2 n <= Un n <=
sequence_ub Un pr1 n
x:R
H0:is_upper_bound (EUn (opp_seq Un)) x
exists m : R,
  is_upper_bound (EUn (opp_seq (sequence_ub Un pr1)))
    m
  exists x.
Un:nat -> R
pr1:has_ub Un
pr2:exists m : R, is_upper_bound (EUn (opp_seq Un)) m
H:forall n : nat,
sequence_lb Un pr2 n <= Un n <=
sequence_ub Un pr1 n
x:R
H0:is_upper_bound (EUn (opp_seq Un)) x
is_upper_bound (EUn (opp_seq (sequence_ub Un pr1))) x
  unfold is_upper_bound.
Un:nat -> R
pr1:has_ub Un
pr2:exists m : R, is_upper_bound (EUn (opp_seq Un)) m
H:forall n : nat,
sequence_lb Un pr2 n <= Un n <=
sequence_ub Un pr1 n
x:R
H0:is_upper_bound (EUn (opp_seq Un)) x
forall x0 : R,
EUn (opp_seq (sequence_ub Un pr1)) x0 -> x0 <= x
  intros.
Un:nat -> R
pr1:has_ub Un
pr2:exists m : R, is_upper_bound (EUn (opp_seq Un)) m
H:forall n : nat,
sequence_lb Un pr2 n <= Un n <=
sequence_ub Un pr1 n
x:R
H0:is_upper_bound (EUn (opp_seq Un)) x
x0:R
H1:EUn (opp_seq (sequence_ub Un pr1)) x0
x0 <= x
  unfold is_upper_bound in H0.
Un:nat -> R
pr1:has_ub Un
pr2:exists m : R, is_upper_bound (EUn (opp_seq Un)) m
H:forall n : nat,
sequence_lb Un pr2 n <= Un n <=
sequence_ub Un pr1 n
x:R
H0:forall x1 : R, EUn (opp_seq Un) x1 -> x1 <= x
x0:R
H1:EUn (opp_seq (sequence_ub Un pr1)) x0
x0 <= x
  elim H1; intros.
Un:nat -> R
pr1:has_ub Un
pr2:exists m : R, is_upper_bound (EUn (opp_seq Un)) m
H:forall n : nat,
sequence_lb Un pr2 n <= Un n <=
sequence_ub Un pr1 n
x:R
H0:forall x2 : R, EUn (opp_seq Un) x2 -> x2 <= x
x0:R
H1:EUn (opp_seq (sequence_ub Un pr1)) x0
x1:nat
H2:x0 = opp_seq (sequence_ub Un pr1) x1
x0 <= x
  rewrite H2.
Un:nat -> R
pr1:has_ub Un
pr2:exists m : R, is_upper_bound (EUn (opp_seq Un)) m
H:forall n : nat,
sequence_lb Un pr2 n <= Un n <=
sequence_ub Un pr1 n
x:R
H0:forall x2 : R, EUn (opp_seq Un) x2 -> x2 <= x
x0:R
H1:EUn (opp_seq (sequence_ub Un pr1)) x0
x1:nat
H2:x0 = opp_seq (sequence_ub Un pr1) x1
opp_seq (sequence_ub Un pr1) x1 <= x
  apply Rle_trans with (opp_seq Un x1).
Un:nat -> R
pr1:has_ub Un
pr2:exists m : R, is_upper_bound (EUn (opp_seq Un)) m
H:forall n : nat,
sequence_lb Un pr2 n <= Un n <=
sequence_ub Un pr1 n
x:R
H0:forall x2 : R, EUn (opp_seq Un) x2 -> x2 <= x
x0:R
H1:EUn (opp_seq (sequence_ub Un pr1)) x0
x1:nat
H2:x0 = opp_seq (sequence_ub Un pr1) x1
opp_seq (sequence_ub Un pr1) x1 <= opp_seq Un x1
Un:nat -> R
pr1:has_ub Un
pr2:exists m : R, is_upper_bound (EUn (opp_seq Un)) m
H:forall n : nat,
sequence_lb Un pr2 n <= Un n <=
sequence_ub Un pr1 n
x:R
H0:forall x2 : R, EUn (opp_seq Un) x2 -> x2 <= x
x0:R
H1:EUn (opp_seq (sequence_ub Un pr1)) x0
x1:nat
H2:x0 = opp_seq (sequence_ub Un pr1) x1
opp_seq Un x1 <= x
  assert (H3 := H x1); elim H3; intros.
Un:nat -> R
pr1:has_ub Un
pr2:exists m : R, is_upper_bound (EUn (opp_seq Un)) m
H:forall n : nat,
sequence_lb Un pr2 n <= Un n <=
sequence_ub Un pr1 n
x:R
H0:forall x2 : R, EUn (opp_seq Un) x2 -> x2 <= x
x0:R
H1:EUn (opp_seq (sequence_ub Un pr1)) x0
x1:nat
H2:x0 = opp_seq (sequence_ub Un pr1) x1
H3:sequence_lb Un pr2 x1 <= Un x1 <=
sequence_ub Un pr1 x1
H4:sequence_lb Un pr2 x1 <= Un x1
H5:Un x1 <= sequence_ub Un pr1 x1
opp_seq (sequence_ub Un pr1) x1 <= opp_seq Un x1
Un:nat -> R
pr1:has_ub Un
pr2:exists m : R, is_upper_bound (EUn (opp_seq Un)) m
H:forall n : nat,
sequence_lb Un pr2 n <= Un n <=
sequence_ub Un pr1 n
x:R
H0:forall x2 : R, EUn (opp_seq Un) x2 -> x2 <= x
x0:R
H1:EUn (opp_seq (sequence_ub Un pr1)) x0
x1:nat
H2:x0 = opp_seq (sequence_ub Un pr1) x1
opp_seq Un x1 <= x
  unfold opp_seq; apply Ropp_le_contravar.
Un:nat -> R
pr1:has_ub Un
pr2:exists m : R, is_upper_bound (EUn (opp_seq Un)) m
H:forall n : nat,
sequence_lb Un pr2 n <= Un n <=
sequence_ub Un pr1 n
x:R
H0:forall x2 : R, EUn (opp_seq Un) x2 -> x2 <= x
x0:R
H1:EUn (opp_seq (sequence_ub Un pr1)) x0
x1:nat
H2:x0 = opp_seq (sequence_ub Un pr1) x1
H3:sequence_lb Un pr2 x1 <= Un x1 <=
sequence_ub Un pr1 x1
H4:sequence_lb Un pr2 x1 <= Un x1
H5:Un x1 <= sequence_ub Un pr1 x1
Un x1 <= sequence_ub Un pr1 x1
Un:nat -> R
pr1:has_ub Un
pr2:exists m : R, is_upper_bound (EUn (opp_seq Un)) m
H:forall n : nat,
sequence_lb Un pr2 n <= Un n <=
sequence_ub Un pr1 n
x:R
H0:forall x2 : R, EUn (opp_seq Un) x2 -> x2 <= x
x0:R
H1:EUn (opp_seq (sequence_ub Un pr1)) x0
x1:nat
H2:x0 = opp_seq (sequence_ub Un pr1) x1
opp_seq Un x1 <= x
  assumption.
Un:nat -> R
pr1:has_ub Un
pr2:exists m : R, is_upper_bound (EUn (opp_seq Un)) m
H:forall n : nat,
sequence_lb Un pr2 n <= Un n <=
sequence_ub Un pr1 n
x:R
H0:forall x2 : R, EUn (opp_seq Un) x2 -> x2 <= x
x0:R
H1:EUn (opp_seq (sequence_ub Un pr1)) x0
x1:nat
H2:x0 = opp_seq (sequence_ub Un pr1) x1
opp_seq Un x1 <= x
  apply H0.
Un:nat -> R
pr1:has_ub Un
pr2:exists m : R, is_upper_bound (EUn (opp_seq Un)) m
H:forall n : nat,
sequence_lb Un pr2 n <= Un n <=
sequence_ub Un pr1 n
x:R
H0:forall x2 : R, EUn (opp_seq Un) x2 -> x2 <= x
x0:R
H1:EUn (opp_seq (sequence_ub Un pr1)) x0
x1:nat
H2:x0 = opp_seq (sequence_ub Un pr1) x1
EUn (opp_seq Un) (opp_seq Un x1)
  exists x1; reflexivity.
Qed.

(**********)
Lemma cauchy_maj : forall Un:nat -> R, Cauchy_crit Un -> has_ub Un.
forall Un : nat -> R, Cauchy_crit Un -> has_ub Un
Proof.
forall Un : nat -> R, Cauchy_crit Un -> has_ub Un
  intros.
Un:nat -> R
H:Cauchy_crit Un
has_ub Un
  unfold has_ub.
Un:nat -> R
H:Cauchy_crit Un
bound (EUn Un)
  apply cauchy_bound.
Un:nat -> R
H:Cauchy_crit Un
Cauchy_crit Un
  assumption.
Qed.

(**********)
Lemma cauchy_opp :
  forall Un:nat -> R, Cauchy_crit Un -> Cauchy_crit (opp_seq Un).
forall Un : nat -> R,
Cauchy_crit Un -> Cauchy_crit (opp_seq Un)
Proof.
forall Un : nat -> R,
Cauchy_crit Un -> Cauchy_crit (opp_seq Un)
  intro.
Un:nat -> R
Cauchy_crit Un -> Cauchy_crit (opp_seq Un)
  unfold Cauchy_crit.
Un:nat -> R
(forall eps : R,
 eps > 0 ->
 exists N : nat,
   forall n m : nat,
   (n >= N)%nat ->
   (m >= N)%nat -> R_dist (Un n) (Un m) < eps) ->
forall eps : R,
eps > 0 ->
exists N : nat,
  forall n m : nat,
  (n >= N)%nat ->
  (m >= N)%nat ->
  R_dist (opp_seq Un n) (opp_seq Un m) < eps
  unfold R_dist.
Un:nat -> R
(forall eps : R,
 eps > 0 ->
 exists N : nat,
   forall n m : nat,
   (n >= N)%nat ->
   (m >= N)%nat -> Rabs (Un n - Un m) < eps) ->
forall eps : R,
eps > 0 ->
exists N : nat,
  forall n m : nat,
  (n >= N)%nat ->
  (m >= N)%nat ->
  Rabs (opp_seq Un n - opp_seq Un m) < eps
  intros.
Un:nat -> R
H:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n m : nat,
  (n >= N)%nat ->
  (m >= N)%nat -> Rabs (Un n - Un m) < eps0
eps:R
H0:eps > 0
exists N : nat,
  forall n m : nat,
  (n >= N)%nat ->
  (m >= N)%nat ->
  Rabs (opp_seq Un n - opp_seq Un m) < eps
  elim (H eps H0); intros.
Un:nat -> R
H:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n m : nat,
  (n >= N)%nat ->
  (m >= N)%nat -> Rabs (Un n - Un m) < eps0
eps:R
H0:eps > 0
x:nat
H1:forall n m : nat,
(n >= x)%nat ->
(m >= x)%nat -> Rabs (Un n - Un m) < eps
exists N : nat,
  forall n m : nat,
  (n >= N)%nat ->
  (m >= N)%nat ->
  Rabs (opp_seq Un n - opp_seq Un m) < eps
  exists x; intros.
Un:nat -> R
H:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n0 m0 : nat,
  (n0 >= N)%nat ->
  (m0 >= N)%nat -> Rabs (Un n0 - Un m0) < eps0
eps:R
H0:eps > 0
x:nat
H1:forall n0 m0 : nat,
(n0 >= x)%nat ->
(m0 >= x)%nat -> Rabs (Un n0 - Un m0) < eps
n, m:nat
H2:(n >= x)%nat
H3:(m >= x)%nat
Rabs (opp_seq Un n - opp_seq Un m) < eps
  unfold opp_seq.
Un:nat -> R
H:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n0 m0 : nat,
  (n0 >= N)%nat ->
  (m0 >= N)%nat -> Rabs (Un n0 - Un m0) < eps0
eps:R
H0:eps > 0
x:nat
H1:forall n0 m0 : nat,
(n0 >= x)%nat ->
(m0 >= x)%nat -> Rabs (Un n0 - Un m0) < eps
n, m:nat
H2:(n >= x)%nat
H3:(m >= x)%nat
Rabs (- Un n - - Un m) < eps
  rewrite <- Rabs_Ropp.
Un:nat -> R
H:forall eps0 : R,
eps0 > 0 ->
exists N : nat,
  forall n0 m0 : nat,
  (n0 >= N)%nat ->
  (m0 >= N)%nat -> Rabs (Un n0 - Un m0) < eps0
eps:R
H0:eps > 0
x:nat
H1:forall n0 m0 : nat,
(n0 >= x)%nat ->
(m0 >= x)%nat -> Rabs (Un n0 - Un m0) < eps
n, m:nat
H2:(n >= x)%nat
H3:(m >= x)%nat
Rabs (- (- Un n - - Un m)) < eps
  replace (- (- Un n - - Un m)) with (Un n - Un m);
  [ apply H1; assumption | ring ].
Qed.

(**********)
Lemma cauchy_min : forall Un:nat -> R, Cauchy_crit Un -> has_lb Un.
forall Un : nat -> R, Cauchy_crit Un -> has_lb Un
Proof.
forall Un : nat -> R, Cauchy_crit Un -> has_lb Un
  intros.
Un:nat -> R
H:Cauchy_crit Un
has_lb Un
  unfold has_lb.
Un:nat -> R
H:Cauchy_crit Un
bound (EUn (opp_seq Un))
  assert (H0 := cauchy_opp _ H).
Un:nat -> R
H:Cauchy_crit Un
H0:Cauchy_crit (opp_seq Un)
bound (EUn (opp_seq Un))
  apply cauchy_bound.
Un:nat -> R
H:Cauchy_crit Un
H0:Cauchy_crit (opp_seq Un)
Cauchy_crit (opp_seq Un)
  assumption.
Qed.

(**********)
Lemma maj_cv :
  forall (Un:nat -> R) (pr:Cauchy_crit Un),
    { l:R | Un_cv (sequence_ub Un (cauchy_maj Un pr)) l }.
forall (Un : nat -> R) (pr : Cauchy_crit Un),
{l : R | Un_cv (sequence_ub Un (cauchy_maj Un pr)) l}
Proof.
forall (Un : nat -> R) (pr : Cauchy_crit Un),
{l : R | Un_cv (sequence_ub Un (cauchy_maj Un pr)) l}
  intros.
Un:nat -> R
pr:Cauchy_crit Un
{l : R | Un_cv (sequence_ub Un (cauchy_maj Un pr)) l}
  apply decreasing_cv.
Un:nat -> R
pr:Cauchy_crit Un
Un_decreasing (sequence_ub Un (cauchy_maj Un pr))
Un:nat -> R
pr:Cauchy_crit Un
has_lb (sequence_ub Un (cauchy_maj Un pr))
  apply Wn_decreasing.
Un:nat -> R
pr:Cauchy_crit Un
has_lb (sequence_ub Un (cauchy_maj Un pr))
  apply maj_min.
Un:nat -> R
pr:Cauchy_crit Un
has_lb Un
  apply cauchy_min.
Un:nat -> R
pr:Cauchy_crit Un
Cauchy_crit Un
  assumption.
Qed.

(**********)
Lemma min_cv :
  forall (Un:nat -> R) (pr:Cauchy_crit Un),
    { l:R | Un_cv (sequence_lb Un (cauchy_min Un pr)) l }.
forall (Un : nat -> R) (pr : Cauchy_crit Un),
{l : R | Un_cv (sequence_lb Un (cauchy_min Un pr)) l}
Proof.
forall (Un : nat -> R) (pr : Cauchy_crit Un),
{l : R | Un_cv (sequence_lb Un (cauchy_min Un pr)) l}
  intros.
Un:nat -> R
pr:Cauchy_crit Un
{l : R | Un_cv (sequence_lb Un (cauchy_min Un pr)) l}
  apply growing_cv.
Un:nat -> R
pr:Cauchy_crit Un
Un_growing (sequence_lb Un (cauchy_min Un pr))
Un:nat -> R
pr:Cauchy_crit Un
has_ub (sequence_lb Un (cauchy_min Un pr))
  apply Vn_growing.
Un:nat -> R
pr:Cauchy_crit Un
has_ub (sequence_lb Un (cauchy_min Un pr))
  apply min_maj.
Un:nat -> R
pr:Cauchy_crit Un
has_ub Un
  apply cauchy_maj.
Un:nat -> R
pr:Cauchy_crit Un
Cauchy_crit Un
  assumption.
Qed.

Lemma cond_eq :
  forall x y:R, (forall eps:R, 0 < eps -> Rabs (x - y) < eps) -> x = y.
forall x y : R,
(forall eps : R, 0 < eps -> Rabs (x - y) < eps) ->
x = y
Proof.
forall x y : R,
(forall eps : R, 0 < eps -> Rabs (x - y) < eps) ->
x = y
  intros.
x, y:R
H:forall eps : R, 0 < eps -> Rabs (x - y) < eps
x = y
  destruct (total_order_T x y) as [[Hlt|Heq]|Hgt].
x, y:R
H:forall eps : R, 0 < eps -> Rabs (x - y) < eps
Hlt:x < y
x = y
x, y:R
H:forall eps : R, 0 < eps -> Rabs (x - y) < eps
Heq:x = y
x = y
x, y:R
H:forall eps : R, 0 < eps -> Rabs (x - y) < eps
Hgt:x > y
x = y
  cut (0 < y - x).
x, y:R
H:forall eps : R, 0 < eps -> Rabs (x - y) < eps
Hlt:x < y
0 < y - x -> x = y
x, y:R
H:forall eps : R, 0 < eps -> Rabs (x - y) < eps
Hlt:x < y
0 < y - x
x, y:R
H:forall eps : R, 0 < eps -> Rabs (x - y) < eps
Heq:x = y
x = y
x, y:R
H:forall eps : R, 0 < eps -> Rabs (x - y) < eps
Hgt:x > y
x = y
  intro.
x, y:R
H:forall eps : R, 0 < eps -> Rabs (x - y) < eps
Hlt:x < y
H0:0 < y - x
x = y
x, y:R
H:forall eps : R, 0 < eps -> Rabs (x - y) < eps
Hlt:x < y
0 < y - x
x, y:R
H:forall eps : R, 0 < eps -> Rabs (x - y) < eps
Heq:x = y
x = y
x, y:R
H:forall eps : R, 0 < eps -> Rabs (x - y) < eps
Hgt:x > y
x = y
  assert (H1 := H (y - x) H0).
x, y:R
H:forall eps : R, 0 < eps -> Rabs (x - y) < eps
Hlt:x < y
H0:0 < y - x
H1:Rabs (x - y) < y - x
x = y
x, y:R
H:forall eps : R, 0 < eps -> Rabs (x - y) < eps
Hlt:x < y
0 < y - x
x, y:R
H:forall eps : R, 0 < eps -> Rabs (x - y) < eps
Heq:x = y
x = y
x, y:R
H:forall eps : R, 0 < eps -> Rabs (x - y) < eps
Hgt:x > y
x = y
  rewrite <- Rabs_Ropp in H1.
x, y:R
H:forall eps : R, 0 < eps -> Rabs (x - y) < eps
Hlt:x < y
H0:0 < y - x
H1:Rabs (- (x - y)) < y - x
x = y
x, y:R
H:forall eps : R, 0 < eps -> Rabs (x - y) < eps
Hlt:x < y
0 < y - x
x, y:R
H:forall eps : R, 0 < eps -> Rabs (x - y) < eps
Heq:x = y
x = y
x, y:R
H:forall eps : R, 0 < eps -> Rabs (x - y) < eps
Hgt:x > y
x = y
  cut (- (x - y) = y - x); [ intro; rewrite H2 in H1 | ring ].
x, y:R
H:forall eps : R, 0 < eps -> Rabs (x - y) < eps
Hlt:x < y
H0:0 < y - x
H1:Rabs (y - x) < y - x
H2:- (x - y) = y - x
x = y
x, y:R
H:forall eps : R, 0 < eps -> Rabs (x - y) < eps
Hlt:x < y
0 < y - x
x, y:R
H:forall eps : R, 0 < eps -> Rabs (x - y) < eps
Heq:x = y
x = y
x, y:R
H:forall eps : R, 0 < eps -> Rabs (x - y) < eps
Hgt:x > y
x = y
  rewrite Rabs_right in H1.
x, y:R
H:forall eps : R, 0 < eps -> Rabs (x - y) < eps
Hlt:x < y
H0:0 < y - x
H1:y - x < y - x
H2:- (x - y) = y - x
x = y
x, y:R
H:forall eps : R, 0 < eps -> Rabs (x - y) < eps
Hlt:x < y
H0:0 < y - x
H1:Rabs (y - x) < y - x
H2:- (x - y) = y - x
y - x >= 0
x, y:R
H:forall eps : R, 0 < eps -> Rabs (x - y) < eps
Hlt:x < y
0 < y - x
x, y:R
H:forall eps : R, 0 < eps -> Rabs (x - y) < eps
Heq:x = y
x = y
x, y:R
H:forall eps : R, 0 < eps -> Rabs (x - y) < eps
Hgt:x > y
x = y
  elim (Rlt_irrefl _ H1).
x, y:R
H:forall eps : R, 0 < eps -> Rabs (x - y) < eps
Hlt:x < y
H0:0 < y - x
H1:Rabs (y - x) < y - x
H2:- (x - y) = y - x
y - x >= 0
x, y:R
H:forall eps : R, 0 < eps -> Rabs (x - y) < eps
Hlt:x < y
0 < y - x
x, y:R
H:forall eps : R, 0 < eps -> Rabs (x - y) < eps
Heq:x = y
x = y
x, y:R
H:forall eps : R, 0 < eps -> Rabs (x - y) < eps
Hgt:x > y
x = y
  left; assumption.
x, y:R
H:forall eps : R, 0 < eps -> Rabs (x - y) < eps
Hlt:x < y
0 < y - x
x, y:R
H:forall eps : R, 0 < eps -> Rabs (x - y) < eps
Heq:x = y
x = y
x, y:R
H:forall eps : R, 0 < eps -> Rabs (x - y) < eps
Hgt:x > y
x = y
  apply Rplus_lt_reg_l with x.
x, y:R
H:forall eps : R, 0 < eps -> Rabs (x - y) < eps
Hlt:x < y
x + 0 < x + (y - x)
x, y:R
H:forall eps : R, 0 < eps -> Rabs (x - y) < eps
Heq:x = y
x = y
x, y:R
H:forall eps : R, 0 < eps -> Rabs (x - y) < eps
Hgt:x > y
x = y
  rewrite Rplus_0_r; replace (x + (y - x)) with y; [ assumption | ring ].
x, y:R
H:forall eps : R, 0 < eps -> Rabs (x - y) < eps
Heq:x = y
x = y
x, y:R
H:forall eps : R, 0 < eps -> Rabs (x - y) < eps
Hgt:x > y
x = y
  assumption.
x, y:R
H:forall eps : R, 0 < eps -> Rabs (x - y) < eps
Hgt:x > y
x = y
  cut (0 < x - y).
x, y:R
H:forall eps : R, 0 < eps -> Rabs (x - y) < eps
Hgt:x > y
0 < x - y -> x = y
x, y:R
H:forall eps : R, 0 < eps -> Rabs (x - y) < eps
Hgt:x > y
0 < x - y
  intro.
x, y:R
H:forall eps : R, 0 < eps -> Rabs (x - y) < eps
Hgt:x > y
H0:0 < x - y
x = y
x, y:R
H:forall eps : R, 0 < eps -> Rabs (x - y) < eps
Hgt:x > y
0 < x - y
  assert (H1 := H (x - y) H0).
x, y:R
H:forall eps : R, 0 < eps -> Rabs (x - y) < eps
Hgt:x > y
H0:0 < x - y
H1:Rabs (x - y) < x - y
x = y
x, y:R
H:forall eps : R, 0 < eps -> Rabs (x - y) < eps
Hgt:x > y
0 < x - y
  rewrite Rabs_right in H1.
x, y:R
H:forall eps : R, 0 < eps -> Rabs (x - y) < eps
Hgt:x > y
H0:0 < x - y
H1:x - y < x - y
x = y
x, y:R
H:forall eps : R, 0 < eps -> Rabs (x - y) < eps
Hgt:x > y
H0:0 < x - y
H1:Rabs (x - y) < x - y
x - y >= 0
x, y:R
H:forall eps : R, 0 < eps -> Rabs (x - y) < eps
Hgt:x > y
0 < x - y
  elim (Rlt_irrefl _ H1).
x, y:R
H:forall eps : R, 0 < eps -> Rabs (x - y) < eps
Hgt:x > y
H0:0 < x - y
H1:Rabs (x - y) < x - y
x - y >= 0
x, y:R
H:forall eps : R, 0 < eps -> Rabs (x - y) < eps
Hgt:x > y
0 < x - y
  left; assumption.
x, y:R
H:forall eps : R, 0 < eps -> Rabs (x - y) < eps
Hgt:x > y
0 < x - y
  apply Rplus_lt_reg_l with y.
x, y:R
H:forall eps : R, 0 < eps -> Rabs (x - y) < eps
Hgt:x > y
y + 0 < y + (x - y)
  rewrite Rplus_0_r; replace (y + (x - y)) with x; [ assumption | ring ].
Qed.

Lemma not_Rlt : forall r1 r2:R, ~ r1 < r2 -> r1 >= r2.
forall r1 r2 : R, ~ r1 < r2 -> r1 >= r2
Proof.
forall r1 r2 : R, ~ r1 < r2 -> r1 >= r2
  intros r1 r2; generalize (Rtotal_order r1 r2); unfold Rge.
r1, r2:R
r1 < r2 \/ r1 = r2 \/ r1 > r2 ->
~ r1 < r2 -> r1 > r2 \/ r1 = r2
  tauto.
Qed.

(**********)
Lemma approx_maj :
  forall (Un:nat -> R) (pr:has_ub Un) (eps:R),
    0 < eps ->  exists k : nat, Rabs (lub Un pr - Un k) < eps.
forall (Un : nat -> R) (pr : has_ub Un) (eps : R),
0 < eps ->
exists k : nat, Rabs (lub Un pr - Un k) < eps
Proof.
forall (Un : nat -> R) (pr : has_ub Un) (eps : R),
0 < eps ->
exists k : nat, Rabs (lub Un pr - Un k) < eps
  intros Un pr.
Un:nat -> R
pr:has_ub Un
forall eps : R,
0 < eps ->
exists k : nat, Rabs (lub Un pr - Un k) < eps
  pose (Vn := fix aux n := match n with S n' => if Rle_lt_dec (aux n') (Un n) then Un n else aux n' | O => Un O end).
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
forall eps : R,
0 < eps ->
exists k : nat, Rabs (lub Un pr - Un k) < eps
  pose (In := fix aux n := match n with S n' => if Rle_lt_dec (Vn n) (Un n) then n else aux n' | O => O end).
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
forall eps : R,
0 < eps ->
exists k : nat, Rabs (lub Un pr - Un k) < eps

  assert (VUI: forall n, Vn n = Un (In n)).
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
forall n : nat, Vn n = Un (In n)
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
forall eps : R,
0 < eps ->
exists k : nat, Rabs (lub Un pr - Un k) < eps
  induction n.
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
Vn 0%nat = Un (In 0%nat)
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n0 : nat) : R :=
  match n0 with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n0)
      then Un n0
      else aux n'
  end:nat -> R
In:=fix aux (n0 : nat) : nat :=
  match n0 with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n0) (Un n0)
      then n0
      else aux n'
  end:nat -> nat
n:nat
IHn:Vn n = Un (In n)
Vn (S n) = Un (In (S n))
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
forall eps : R,
0 < eps ->
exists k : nat, Rabs (lub Un pr - Un k) < eps
  easy.
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n0 : nat) : R :=
  match n0 with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n0)
      then Un n0
      else aux n'
  end:nat -> R
In:=fix aux (n0 : nat) : nat :=
  match n0 with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n0) (Un n0)
      then n0
      else aux n'
  end:nat -> nat
n:nat
IHn:Vn n = Un (In n)
Vn (S n) = Un (In (S n))
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
forall eps : R,
0 < eps ->
exists k : nat, Rabs (lub Un pr - Un k) < eps
  simpl.
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n0 : nat) : R :=
  match n0 with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n0)
      then Un n0
      else aux n'
  end:nat -> R
In:=fix aux (n0 : nat) : nat :=
  match n0 with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n0) (Un n0)
      then n0
      else aux n'
  end:nat -> nat
n:nat
IHn:Vn n = Un (In n)
(if Rle_lt_dec (Vn n) (Un (S n))
 then Un (S n)
 else Vn n) =
Un
  (if
    Rle_lt_dec
      (if Rle_lt_dec (Vn n) (Un (S n))
       then Un (S n)
       else Vn n) (Un (S n))
   then S n
   else In n)
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
forall eps : R,
0 < eps ->
exists k : nat, Rabs (lub Un pr - Un k) < eps
  destruct (Rle_lt_dec (Vn n) (Un (S n))) as [H1|H1].
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n0 : nat) : R :=
  match n0 with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n0)
      then Un n0
      else aux n'
  end:nat -> R
In:=fix aux (n0 : nat) : nat :=
  match n0 with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n0) (Un n0)
      then n0
      else aux n'
  end:nat -> nat
n:nat
IHn:Vn n = Un (In n)
H1:Vn n <= Un (S n)
Un (S n) =
Un
  (if Rle_lt_dec (Un (S n)) (Un (S n))
   then S n
   else In n)
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n0 : nat) : R :=
  match n0 with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n0)
      then Un n0
      else aux n'
  end:nat -> R
In:=fix aux (n0 : nat) : nat :=
  match n0 with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n0) (Un n0)
      then n0
      else aux n'
  end:nat -> nat
n:nat
IHn:Vn n = Un (In n)
H1:Un (S n) < Vn n
Vn n =
Un
  (if Rle_lt_dec (Vn n) (Un (S n)) then S n else In n)
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
forall eps : R,
0 < eps ->
exists k : nat, Rabs (lub Un pr - Un k) < eps
  destruct (Rle_lt_dec (Un (S n)) (Un (S n))) as [H2|H2].
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n0 : nat) : R :=
  match n0 with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n0)
      then Un n0
      else aux n'
  end:nat -> R
In:=fix aux (n0 : nat) : nat :=
  match n0 with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n0) (Un n0)
      then n0
      else aux n'
  end:nat -> nat
n:nat
IHn:Vn n = Un (In n)
H1:Vn n <= Un (S n)
H2:Un (S n) <= Un (S n)
Un (S n) = Un (S n)
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n0 : nat) : R :=
  match n0 with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n0)
      then Un n0
      else aux n'
  end:nat -> R
In:=fix aux (n0 : nat) : nat :=
  match n0 with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n0) (Un n0)
      then n0
      else aux n'
  end:nat -> nat
n:nat
IHn:Vn n = Un (In n)
H1:Vn n <= Un (S n)
H2:Un (S n) < Un (S n)
Un (S n) = Un (In n)
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n0 : nat) : R :=
  match n0 with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n0)
      then Un n0
      else aux n'
  end:nat -> R
In:=fix aux (n0 : nat) : nat :=
  match n0 with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n0) (Un n0)
      then n0
      else aux n'
  end:nat -> nat
n:nat
IHn:Vn n = Un (In n)
H1:Un (S n) < Vn n
Vn n =
Un
  (if Rle_lt_dec (Vn n) (Un (S n)) then S n else In n)
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
forall eps : R,
0 < eps ->
exists k : nat, Rabs (lub Un pr - Un k) < eps
  easy.
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n0 : nat) : R :=
  match n0 with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n0)
      then Un n0
      else aux n'
  end:nat -> R
In:=fix aux (n0 : nat) : nat :=
  match n0 with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n0) (Un n0)
      then n0
      else aux n'
  end:nat -> nat
n:nat
IHn:Vn n = Un (In n)
H1:Vn n <= Un (S n)
H2:Un (S n) < Un (S n)
Un (S n) = Un (In n)
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n0 : nat) : R :=
  match n0 with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n0)
      then Un n0
      else aux n'
  end:nat -> R
In:=fix aux (n0 : nat) : nat :=
  match n0 with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n0) (Un n0)
      then n0
      else aux n'
  end:nat -> nat
n:nat
IHn:Vn n = Un (In n)
H1:Un (S n) < Vn n
Vn n =
Un
  (if Rle_lt_dec (Vn n) (Un (S n)) then S n else In n)
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
forall eps : R,
0 < eps ->
exists k : nat, Rabs (lub Un pr - Un k) < eps
  elim (Rlt_irrefl _ H2).
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n0 : nat) : R :=
  match n0 with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n0)
      then Un n0
      else aux n'
  end:nat -> R
In:=fix aux (n0 : nat) : nat :=
  match n0 with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n0) (Un n0)
      then n0
      else aux n'
  end:nat -> nat
n:nat
IHn:Vn n = Un (In n)
H1:Un (S n) < Vn n
Vn n =
Un
  (if Rle_lt_dec (Vn n) (Un (S n)) then S n else In n)
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
forall eps : R,
0 < eps ->
exists k : nat, Rabs (lub Un pr - Un k) < eps
  destruct (Rle_lt_dec (Vn n) (Un (S n))) as [H2|H2].
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n0 : nat) : R :=
  match n0 with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n0)
      then Un n0
      else aux n'
  end:nat -> R
In:=fix aux (n0 : nat) : nat :=
  match n0 with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n0) (Un n0)
      then n0
      else aux n'
  end:nat -> nat
n:nat
IHn:Vn n = Un (In n)
H1:Un (S n) < Vn n
H2:Vn n <= Un (S n)
Vn n = Un (S n)
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n0 : nat) : R :=
  match n0 with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n0)
      then Un n0
      else aux n'
  end:nat -> R
In:=fix aux (n0 : nat) : nat :=
  match n0 with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n0) (Un n0)
      then n0
      else aux n'
  end:nat -> nat
n:nat
IHn:Vn n = Un (In n)
H1, H2:Un (S n) < Vn n
Vn n = Un (In n)
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
forall eps : R,
0 < eps ->
exists k : nat, Rabs (lub Un pr - Un k) < eps
  elim (Rlt_irrefl _ (Rle_lt_trans _ _ _ H2 H1)).
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n0 : nat) : R :=
  match n0 with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n0)
      then Un n0
      else aux n'
  end:nat -> R
In:=fix aux (n0 : nat) : nat :=
  match n0 with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n0) (Un n0)
      then n0
      else aux n'
  end:nat -> nat
n:nat
IHn:Vn n = Un (In n)
H1, H2:Un (S n) < Vn n
Vn n = Un (In n)
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
forall eps : R,
0 < eps ->
exists k : nat, Rabs (lub Un pr - Un k) < eps
  exact IHn.
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
forall eps : R,
0 < eps ->
exists k : nat, Rabs (lub Un pr - Un k) < eps

  assert (HubV : has_ub Vn).
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
has_ub Vn
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
HubV:has_ub Vn
forall eps : R,
0 < eps ->
exists k : nat, Rabs (lub Un pr - Un k) < eps
  destruct pr as (ub, Hub).
Un:nat -> R
ub:R
Hub:is_upper_bound (EUn Un) ub
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
has_ub Vn
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
HubV:has_ub Vn
forall eps : R,
0 < eps ->
exists k : nat, Rabs (lub Un pr - Un k) < eps
  exists ub.
Un:nat -> R
ub:R
Hub:is_upper_bound (EUn Un) ub
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
is_upper_bound (EUn Vn) ub
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
HubV:has_ub Vn
forall eps : R,
0 < eps ->
exists k : nat, Rabs (lub Un pr - Un k) < eps
  intros x (n, Hn).
Un:nat -> R
ub:R
Hub:is_upper_bound (EUn Un) ub
Vn:=fix aux (n0 : nat) : R :=
  match n0 with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n0)
      then Un n0
      else aux n'
  end:nat -> R
In:=fix aux (n0 : nat) : nat :=
  match n0 with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n0) (Un n0)
      then n0
      else aux n'
  end:nat -> nat
VUI:forall n0 : nat, Vn n0 = Un (In n0)
x:R
n:nat
Hn:x = Vn n
x <= ub
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
HubV:has_ub Vn
forall eps : R,
0 < eps ->
exists k : nat, Rabs (lub Un pr - Un k) < eps
  rewrite Hn, VUI.
Un:nat -> R
ub:R
Hub:is_upper_bound (EUn Un) ub
Vn:=fix aux (n0 : nat) : R :=
  match n0 with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n0)
      then Un n0
      else aux n'
  end:nat -> R
In:=fix aux (n0 : nat) : nat :=
  match n0 with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n0) (Un n0)
      then n0
      else aux n'
  end:nat -> nat
VUI:forall n0 : nat, Vn n0 = Un (In n0)
x:R
n:nat
Hn:x = Vn n
Un (In n) <= ub
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
HubV:has_ub Vn
forall eps : R,
0 < eps ->
exists k : nat, Rabs (lub Un pr - Un k) < eps
  apply Hub.
Un:nat -> R
ub:R
Hub:is_upper_bound (EUn Un) ub
Vn:=fix aux (n0 : nat) : R :=
  match n0 with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n0)
      then Un n0
      else aux n'
  end:nat -> R
In:=fix aux (n0 : nat) : nat :=
  match n0 with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n0) (Un n0)
      then n0
      else aux n'
  end:nat -> nat
VUI:forall n0 : nat, Vn n0 = Un (In n0)
x:R
n:nat
Hn:x = Vn n
EUn Un (Un (In n))
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
HubV:has_ub Vn
forall eps : R,
0 < eps ->
exists k : nat, Rabs (lub Un pr - Un k) < eps
  now exists (In n).
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
HubV:has_ub Vn
forall eps : R,
0 < eps ->
exists k : nat, Rabs (lub Un pr - Un k) < eps

  assert (HgrV : Un_growing Vn).
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
HubV:has_ub Vn
Un_growing Vn
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
HubV:has_ub Vn
HgrV:Un_growing Vn
forall eps : R,
0 < eps ->
exists k : nat, Rabs (lub Un pr - Un k) < eps
  intros n.
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n0 : nat) : R :=
  match n0 with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n0)
      then Un n0
      else aux n'
  end:nat -> R
In:=fix aux (n0 : nat) : nat :=
  match n0 with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n0) (Un n0)
      then n0
      else aux n'
  end:nat -> nat
VUI:forall n0 : nat, Vn n0 = Un (In n0)
HubV:has_ub Vn
n:nat
Vn n <= Vn (S n)
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
HubV:has_ub Vn
HgrV:Un_growing Vn
forall eps : R,
0 < eps ->
exists k : nat, Rabs (lub Un pr - Un k) < eps
  induction n.
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
HubV:has_ub Vn
Vn 0%nat <= Vn 1%nat
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n0 : nat) : R :=
  match n0 with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n0)
      then Un n0
      else aux n'
  end:nat -> R
In:=fix aux (n0 : nat) : nat :=
  match n0 with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n0) (Un n0)
      then n0
      else aux n'
  end:nat -> nat
VUI:forall n0 : nat, Vn n0 = Un (In n0)
HubV:has_ub Vn
n:nat
IHn:Vn n <= Vn (S n)
Vn (S n) <= Vn (S (S n))
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
HubV:has_ub Vn
HgrV:Un_growing Vn
forall eps : R,
0 < eps ->
exists k : nat, Rabs (lub Un pr - Un k) < eps
  simpl.
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
HubV:has_ub Vn
Un 0%nat <=
(if Rle_lt_dec (Un 0%nat) (Un 1%nat)
 then Un 1%nat
 else Un 0%nat)
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n0 : nat) : R :=
  match n0 with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n0)
      then Un n0
      else aux n'
  end:nat -> R
In:=fix aux (n0 : nat) : nat :=
  match n0 with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n0) (Un n0)
      then n0
      else aux n'
  end:nat -> nat
VUI:forall n0 : nat, Vn n0 = Un (In n0)
HubV:has_ub Vn
n:nat
IHn:Vn n <= Vn (S n)
Vn (S n) <= Vn (S (S n))
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
HubV:has_ub Vn
HgrV:Un_growing Vn
forall eps : R,
0 < eps ->
exists k : nat, Rabs (lub Un pr - Un k) < eps
  destruct (Rle_lt_dec (Un O) (Un 1%nat)) as [H|_].
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
HubV:has_ub Vn
H:Un 0%nat <= Un 1%nat
Un 0%nat <= Un 1%nat
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
HubV:has_ub Vn
Un 0%nat <= Un 0%nat
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n0 : nat) : R :=
  match n0 with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n0)
      then Un n0
      else aux n'
  end:nat -> R
In:=fix aux (n0 : nat) : nat :=
  match n0 with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n0) (Un n0)
      then n0
      else aux n'
  end:nat -> nat
VUI:forall n0 : nat, Vn n0 = Un (In n0)
HubV:has_ub Vn
n:nat
IHn:Vn n <= Vn (S n)
Vn (S n) <= Vn (S (S n))
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
HubV:has_ub Vn
HgrV:Un_growing Vn
forall eps : R,
0 < eps ->
exists k : nat, Rabs (lub Un pr - Un k) < eps
  exact H.
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
HubV:has_ub Vn
Un 0%nat <= Un 0%nat
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n0 : nat) : R :=
  match n0 with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n0)
      then Un n0
      else aux n'
  end:nat -> R
In:=fix aux (n0 : nat) : nat :=
  match n0 with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n0) (Un n0)
      then n0
      else aux n'
  end:nat -> nat
VUI:forall n0 : nat, Vn n0 = Un (In n0)
HubV:has_ub Vn
n:nat
IHn:Vn n <= Vn (S n)
Vn (S n) <= Vn (S (S n))
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
HubV:has_ub Vn
HgrV:Un_growing Vn
forall eps : R,
0 < eps ->
exists k : nat, Rabs (lub Un pr - Un k) < eps
  apply Rle_refl.
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n0 : nat) : R :=
  match n0 with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n0)
      then Un n0
      else aux n'
  end:nat -> R
In:=fix aux (n0 : nat) : nat :=
  match n0 with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n0) (Un n0)
      then n0
      else aux n'
  end:nat -> nat
VUI:forall n0 : nat, Vn n0 = Un (In n0)
HubV:has_ub Vn
n:nat
IHn:Vn n <= Vn (S n)
Vn (S n) <= Vn (S (S n))
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
HubV:has_ub Vn
HgrV:Un_growing Vn
forall eps : R,
0 < eps ->
exists k : nat, Rabs (lub Un pr - Un k) < eps
  simpl.
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n0 : nat) : R :=
  match n0 with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n0)
      then Un n0
      else aux n'
  end:nat -> R
In:=fix aux (n0 : nat) : nat :=
  match n0 with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n0) (Un n0)
      then n0
      else aux n'
  end:nat -> nat
VUI:forall n0 : nat, Vn n0 = Un (In n0)
HubV:has_ub Vn
n:nat
IHn:Vn n <= Vn (S n)
(if Rle_lt_dec (Vn n) (Un (S n))
 then Un (S n)
 else Vn n) <=
(if
  Rle_lt_dec
    (if Rle_lt_dec (Vn n) (Un (S n))
     then Un (S n)
     else Vn n) (Un (S (S n)))
 then Un (S (S n))
 else
  if Rle_lt_dec (Vn n) (Un (S n))
  then Un (S n)
  else Vn n)
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
HubV:has_ub Vn
HgrV:Un_growing Vn
forall eps : R,
0 < eps ->
exists k : nat, Rabs (lub Un pr - Un k) < eps
  destruct (Rle_lt_dec (Vn n) (Un (S n))) as [H1|H1].
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n0 : nat) : R :=
  match n0 with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n0)
      then Un n0
      else aux n'
  end:nat -> R
In:=fix aux (n0 : nat) : nat :=
  match n0 with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n0) (Un n0)
      then n0
      else aux n'
  end:nat -> nat
VUI:forall n0 : nat, Vn n0 = Un (In n0)
HubV:has_ub Vn
n:nat
IHn:Vn n <= Vn (S n)
H1:Vn n <= Un (S n)
Un (S n) <=
(if Rle_lt_dec (Un (S n)) (Un (S (S n)))
 then Un (S (S n))
 else Un (S n))
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n0 : nat) : R :=
  match n0 with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n0)
      then Un n0
      else aux n'
  end:nat -> R
In:=fix aux (n0 : nat) : nat :=
  match n0 with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n0) (Un n0)
      then n0
      else aux n'
  end:nat -> nat
VUI:forall n0 : nat, Vn n0 = Un (In n0)
HubV:has_ub Vn
n:nat
IHn:Vn n <= Vn (S n)
H1:Un (S n) < Vn n
Vn n <=
(if Rle_lt_dec (Vn n) (Un (S (S n)))
 then Un (S (S n))
 else Vn n)
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
HubV:has_ub Vn
HgrV:Un_growing Vn
forall eps : R,
0 < eps ->
exists k : nat, Rabs (lub Un pr - Un k) < eps
  destruct (Rle_lt_dec (Un (S n)) (Un (S (S n)))) as [H2|H2].
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n0 : nat) : R :=
  match n0 with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n0)
      then Un n0
      else aux n'
  end:nat -> R
In:=fix aux (n0 : nat) : nat :=
  match n0 with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n0) (Un n0)
      then n0
      else aux n'
  end:nat -> nat
VUI:forall n0 : nat, Vn n0 = Un (In n0)
HubV:has_ub Vn
n:nat
IHn:Vn n <= Vn (S n)
H1:Vn n <= Un (S n)
H2:Un (S n) <= Un (S (S n))
Un (S n) <= Un (S (S n))
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n0 : nat) : R :=
  match n0 with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n0)
      then Un n0
      else aux n'
  end:nat -> R
In:=fix aux (n0 : nat) : nat :=
  match n0 with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n0) (Un n0)
      then n0
      else aux n'
  end:nat -> nat
VUI:forall n0 : nat, Vn n0 = Un (In n0)
HubV:has_ub Vn
n:nat
IHn:Vn n <= Vn (S n)
H1:Vn n <= Un (S n)
H2:Un (S (S n)) < Un (S n)
Un (S n) <= Un (S n)
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n0 : nat) : R :=
  match n0 with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n0)
      then Un n0
      else aux n'
  end:nat -> R
In:=fix aux (n0 : nat) : nat :=
  match n0 with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n0) (Un n0)
      then n0
      else aux n'
  end:nat -> nat
VUI:forall n0 : nat, Vn n0 = Un (In n0)
HubV:has_ub Vn
n:nat
IHn:Vn n <= Vn (S n)
H1:Un (S n) < Vn n
Vn n <=
(if Rle_lt_dec (Vn n) (Un (S (S n)))
 then Un (S (S n))
 else Vn n)
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
HubV:has_ub Vn
HgrV:Un_growing Vn
forall eps : R,
0 < eps ->
exists k : nat, Rabs (lub Un pr - Un k) < eps
  exact H2.
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n0 : nat) : R :=
  match n0 with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n0)
      then Un n0
      else aux n'
  end:nat -> R
In:=fix aux (n0 : nat) : nat :=
  match n0 with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n0) (Un n0)
      then n0
      else aux n'
  end:nat -> nat
VUI:forall n0 : nat, Vn n0 = Un (In n0)
HubV:has_ub Vn
n:nat
IHn:Vn n <= Vn (S n)
H1:Vn n <= Un (S n)
H2:Un (S (S n)) < Un (S n)
Un (S n) <= Un (S n)
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n0 : nat) : R :=
  match n0 with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n0)
      then Un n0
      else aux n'
  end:nat -> R
In:=fix aux (n0 : nat) : nat :=
  match n0 with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n0) (Un n0)
      then n0
      else aux n'
  end:nat -> nat
VUI:forall n0 : nat, Vn n0 = Un (In n0)
HubV:has_ub Vn
n:nat
IHn:Vn n <= Vn (S n)
H1:Un (S n) < Vn n
Vn n <=
(if Rle_lt_dec (Vn n) (Un (S (S n)))
 then Un (S (S n))
 else Vn n)
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
HubV:has_ub Vn
HgrV:Un_growing Vn
forall eps : R,
0 < eps ->
exists k : nat, Rabs (lub Un pr - Un k) < eps
  apply Rle_refl.
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n0 : nat) : R :=
  match n0 with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n0)
      then Un n0
      else aux n'
  end:nat -> R
In:=fix aux (n0 : nat) : nat :=
  match n0 with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n0) (Un n0)
      then n0
      else aux n'
  end:nat -> nat
VUI:forall n0 : nat, Vn n0 = Un (In n0)
HubV:has_ub Vn
n:nat
IHn:Vn n <= Vn (S n)
H1:Un (S n) < Vn n
Vn n <=
(if Rle_lt_dec (Vn n) (Un (S (S n)))
 then Un (S (S n))
 else Vn n)
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
HubV:has_ub Vn
HgrV:Un_growing Vn
forall eps : R,
0 < eps ->
exists k : nat, Rabs (lub Un pr - Un k) < eps
  destruct (Rle_lt_dec (Vn n) (Un (S (S n)))) as [H2|H2].
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n0 : nat) : R :=
  match n0 with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n0)
      then Un n0
      else aux n'
  end:nat -> R
In:=fix aux (n0 : nat) : nat :=
  match n0 with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n0) (Un n0)
      then n0
      else aux n'
  end:nat -> nat
VUI:forall n0 : nat, Vn n0 = Un (In n0)
HubV:has_ub Vn
n:nat
IHn:Vn n <= Vn (S n)
H1:Un (S n) < Vn n
H2:Vn n <= Un (S (S n))
Vn n <= Un (S (S n))
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n0 : nat) : R :=
  match n0 with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n0)
      then Un n0
      else aux n'
  end:nat -> R
In:=fix aux (n0 : nat) : nat :=
  match n0 with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n0) (Un n0)
      then n0
      else aux n'
  end:nat -> nat
VUI:forall n0 : nat, Vn n0 = Un (In n0)
HubV:has_ub Vn
n:nat
IHn:Vn n <= Vn (S n)
H1:Un (S n) < Vn n
H2:Un (S (S n)) < Vn n
Vn n <= Vn n
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
HubV:has_ub Vn
HgrV:Un_growing Vn
forall eps : R,
0 < eps ->
exists k : nat, Rabs (lub Un pr - Un k) < eps
  exact H2.
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n0 : nat) : R :=
  match n0 with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n0)
      then Un n0
      else aux n'
  end:nat -> R
In:=fix aux (n0 : nat) : nat :=
  match n0 with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n0) (Un n0)
      then n0
      else aux n'
  end:nat -> nat
VUI:forall n0 : nat, Vn n0 = Un (In n0)
HubV:has_ub Vn
n:nat
IHn:Vn n <= Vn (S n)
H1:Un (S n) < Vn n
H2:Un (S (S n)) < Vn n
Vn n <= Vn n
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
HubV:has_ub Vn
HgrV:Un_growing Vn
forall eps : R,
0 < eps ->
exists k : nat, Rabs (lub Un pr - Un k) < eps
  apply Rle_refl.
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
HubV:has_ub Vn
HgrV:Un_growing Vn
forall eps : R,
0 < eps ->
exists k : nat, Rabs (lub Un pr - Un k) < eps

  destruct (ub_to_lub Vn HubV) as (l, Hl).
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
HubV:has_ub Vn
HgrV:Un_growing Vn
l:R
Hl:is_lub (EUn Vn) l
forall eps : R,
0 < eps ->
exists k : nat, Rabs (lub Un pr - Un k) < eps
  unfold lub.
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
HubV:has_ub Vn
HgrV:Un_growing Vn
l:R
Hl:is_lub (EUn Vn) l
forall eps : R,
0 < eps ->
exists k : nat,
  Rabs ((let (a, _) := ub_to_lub Un pr in a) - Un k) <
  eps
  destruct (ub_to_lub Un pr) as (l', Hl').
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
HubV:has_ub Vn
HgrV:Un_growing Vn
l:R
Hl:is_lub (EUn Vn) l
l':R
Hl':is_lub (EUn Un) l'
forall eps : R,
0 < eps -> exists k : nat, Rabs (l' - Un k) < eps
  replace l' with l.
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
HubV:has_ub Vn
HgrV:Un_growing Vn
l:R
Hl:is_lub (EUn Vn) l
l':R
Hl':is_lub (EUn Un) l'
forall eps : R,
0 < eps -> exists k : nat, Rabs (l - Un k) < eps
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
HubV:has_ub Vn
HgrV:Un_growing Vn
l:R
Hl:is_lub (EUn Vn) l
l':R
Hl':is_lub (EUn Un) l'
l = l'
  intros eps Heps.
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
HubV:has_ub Vn
HgrV:Un_growing Vn
l:R
Hl:is_lub (EUn Vn) l
l':R
Hl':is_lub (EUn Un) l'
eps:R
Heps:0 < eps
exists k : nat, Rabs (l - Un k) < eps
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
HubV:has_ub Vn
HgrV:Un_growing Vn
l:R
Hl:is_lub (EUn Vn) l
l':R
Hl':is_lub (EUn Un) l'
l = l'
  destruct (Un_cv_crit_lub Vn HgrV l Hl eps Heps) as (n, Hn).
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n0 : nat) : R :=
  match n0 with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n0)
      then Un n0
      else aux n'
  end:nat -> R
In:=fix aux (n0 : nat) : nat :=
  match n0 with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n0) (Un n0)
      then n0
      else aux n'
  end:nat -> nat
VUI:forall n0 : nat, Vn n0 = Un (In n0)
HubV:has_ub Vn
HgrV:Un_growing Vn
l:R
Hl:is_lub (EUn Vn) l
l':R
Hl':is_lub (EUn Un) l'
eps:R
Heps:0 < eps
n:nat
Hn:forall n0 : nat,
(n0 >= n)%nat -> R_dist (Vn n0) l < eps
exists k : nat, Rabs (l - Un k) < eps
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
HubV:has_ub Vn
HgrV:Un_growing Vn
l:R
Hl:is_lub (EUn Vn) l
l':R
Hl':is_lub (EUn Un) l'
l = l'
  exists (In n).
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n0 : nat) : R :=
  match n0 with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n0)
      then Un n0
      else aux n'
  end:nat -> R
In:=fix aux (n0 : nat) : nat :=
  match n0 with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n0) (Un n0)
      then n0
      else aux n'
  end:nat -> nat
VUI:forall n0 : nat, Vn n0 = Un (In n0)
HubV:has_ub Vn
HgrV:Un_growing Vn
l:R
Hl:is_lub (EUn Vn) l
l':R
Hl':is_lub (EUn Un) l'
eps:R
Heps:0 < eps
n:nat
Hn:forall n0 : nat,
(n0 >= n)%nat -> R_dist (Vn n0) l < eps
Rabs (l - Un (In n)) < eps
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
HubV:has_ub Vn
HgrV:Un_growing Vn
l:R
Hl:is_lub (EUn Vn) l
l':R
Hl':is_lub (EUn Un) l'
l = l'
  rewrite <- VUI.
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n0 : nat) : R :=
  match n0 with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n0)
      then Un n0
      else aux n'
  end:nat -> R
In:=fix aux (n0 : nat) : nat :=
  match n0 with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n0) (Un n0)
      then n0
      else aux n'
  end:nat -> nat
VUI:forall n0 : nat, Vn n0 = Un (In n0)
HubV:has_ub Vn
HgrV:Un_growing Vn
l:R
Hl:is_lub (EUn Vn) l
l':R
Hl':is_lub (EUn Un) l'
eps:R
Heps:0 < eps
n:nat
Hn:forall n0 : nat,
(n0 >= n)%nat -> R_dist (Vn n0) l < eps
Rabs (l - Vn n) < eps
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
HubV:has_ub Vn
HgrV:Un_growing Vn
l:R
Hl:is_lub (EUn Vn) l
l':R
Hl':is_lub (EUn Un) l'
l = l'
  rewrite Rabs_minus_sym.
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n0 : nat) : R :=
  match n0 with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n0)
      then Un n0
      else aux n'
  end:nat -> R
In:=fix aux (n0 : nat) : nat :=
  match n0 with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n0) (Un n0)
      then n0
      else aux n'
  end:nat -> nat
VUI:forall n0 : nat, Vn n0 = Un (In n0)
HubV:has_ub Vn
HgrV:Un_growing Vn
l:R
Hl:is_lub (EUn Vn) l
l':R
Hl':is_lub (EUn Un) l'
eps:R
Heps:0 < eps
n:nat
Hn:forall n0 : nat,
(n0 >= n)%nat -> R_dist (Vn n0) l < eps
Rabs (Vn n - l) < eps
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
HubV:has_ub Vn
HgrV:Un_growing Vn
l:R
Hl:is_lub (EUn Vn) l
l':R
Hl':is_lub (EUn Un) l'
l = l'
  apply Hn.
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n0 : nat) : R :=
  match n0 with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n0)
      then Un n0
      else aux n'
  end:nat -> R
In:=fix aux (n0 : nat) : nat :=
  match n0 with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n0) (Un n0)
      then n0
      else aux n'
  end:nat -> nat
VUI:forall n0 : nat, Vn n0 = Un (In n0)
HubV:has_ub Vn
HgrV:Un_growing Vn
l:R
Hl:is_lub (EUn Vn) l
l':R
Hl':is_lub (EUn Un) l'
eps:R
Heps:0 < eps
n:nat
Hn:forall n0 : nat,
(n0 >= n)%nat -> R_dist (Vn n0) l < eps
(n >= n)%nat
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
HubV:has_ub Vn
HgrV:Un_growing Vn
l:R
Hl:is_lub (EUn Vn) l
l':R
Hl':is_lub (EUn Un) l'
l = l'
  apply le_refl.
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
HubV:has_ub Vn
HgrV:Un_growing Vn
l:R
Hl:is_lub (EUn Vn) l
l':R
Hl':is_lub (EUn Un) l'
l = l'

  apply Rle_antisym.
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
HubV:has_ub Vn
HgrV:Un_growing Vn
l:R
Hl:is_lub (EUn Vn) l
l':R
Hl':is_lub (EUn Un) l'
l <= l'
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
HubV:has_ub Vn
HgrV:Un_growing Vn
l:R
Hl:is_lub (EUn Vn) l
l':R
Hl':is_lub (EUn Un) l'
l' <= l
  apply Hl.
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
HubV:has_ub Vn
HgrV:Un_growing Vn
l:R
Hl:is_lub (EUn Vn) l
l':R
Hl':is_lub (EUn Un) l'
is_upper_bound (EUn Vn) l'
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
HubV:has_ub Vn
HgrV:Un_growing Vn
l:R
Hl:is_lub (EUn Vn) l
l':R
Hl':is_lub (EUn Un) l'
l' <= l
  intros n (k, Hk).
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n0 : nat) : R :=
  match n0 with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n0)
      then Un n0
      else aux n'
  end:nat -> R
In:=fix aux (n0 : nat) : nat :=
  match n0 with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n0) (Un n0)
      then n0
      else aux n'
  end:nat -> nat
VUI:forall n0 : nat, Vn n0 = Un (In n0)
HubV:has_ub Vn
HgrV:Un_growing Vn
l:R
Hl:is_lub (EUn Vn) l
l':R
Hl':is_lub (EUn Un) l'
n:R
k:nat
Hk:n = Vn k
n <= l'
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
HubV:has_ub Vn
HgrV:Un_growing Vn
l:R
Hl:is_lub (EUn Vn) l
l':R
Hl':is_lub (EUn Un) l'
l' <= l
  rewrite Hk, VUI.
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n0 : nat) : R :=
  match n0 with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n0)
      then Un n0
      else aux n'
  end:nat -> R
In:=fix aux (n0 : nat) : nat :=
  match n0 with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n0) (Un n0)
      then n0
      else aux n'
  end:nat -> nat
VUI:forall n0 : nat, Vn n0 = Un (In n0)
HubV:has_ub Vn
HgrV:Un_growing Vn
l:R
Hl:is_lub (EUn Vn) l
l':R
Hl':is_lub (EUn Un) l'
n:R
k:nat
Hk:n = Vn k
Un (In k) <= l'
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
HubV:has_ub Vn
HgrV:Un_growing Vn
l:R
Hl:is_lub (EUn Vn) l
l':R
Hl':is_lub (EUn Un) l'
l' <= l
  apply Hl'.
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n0 : nat) : R :=
  match n0 with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n0)
      then Un n0
      else aux n'
  end:nat -> R
In:=fix aux (n0 : nat) : nat :=
  match n0 with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n0) (Un n0)
      then n0
      else aux n'
  end:nat -> nat
VUI:forall n0 : nat, Vn n0 = Un (In n0)
HubV:has_ub Vn
HgrV:Un_growing Vn
l:R
Hl:is_lub (EUn Vn) l
l':R
Hl':is_lub (EUn Un) l'
n:R
k:nat
Hk:n = Vn k
EUn Un (Un (In k))
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
HubV:has_ub Vn
HgrV:Un_growing Vn
l:R
Hl:is_lub (EUn Vn) l
l':R
Hl':is_lub (EUn Un) l'
l' <= l
  now exists (In k).
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
HubV:has_ub Vn
HgrV:Un_growing Vn
l:R
Hl:is_lub (EUn Vn) l
l':R
Hl':is_lub (EUn Un) l'
l' <= l
  apply Hl'.
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
In:=fix aux (n : nat) : nat :=
  match n with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n) (Un n)
      then n
      else aux n'
  end:nat -> nat
VUI:forall n : nat, Vn n = Un (In n)
HubV:has_ub Vn
HgrV:Un_growing Vn
l:R
Hl:is_lub (EUn Vn) l
l':R
Hl':is_lub (EUn Un) l'
is_upper_bound (EUn Un) l
  intros n (k, Hk).
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n0 : nat) : R :=
  match n0 with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n0)
      then Un n0
      else aux n'
  end:nat -> R
In:=fix aux (n0 : nat) : nat :=
  match n0 with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n0) (Un n0)
      then n0
      else aux n'
  end:nat -> nat
VUI:forall n0 : nat, Vn n0 = Un (In n0)
HubV:has_ub Vn
HgrV:Un_growing Vn
l:R
Hl:is_lub (EUn Vn) l
l':R
Hl':is_lub (EUn Un) l'
n:R
k:nat
Hk:n = Un k
n <= l
  rewrite Hk.
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n0 : nat) : R :=
  match n0 with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n0)
      then Un n0
      else aux n'
  end:nat -> R
In:=fix aux (n0 : nat) : nat :=
  match n0 with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n0) (Un n0)
      then n0
      else aux n'
  end:nat -> nat
VUI:forall n0 : nat, Vn n0 = Un (In n0)
HubV:has_ub Vn
HgrV:Un_growing Vn
l:R
Hl:is_lub (EUn Vn) l
l':R
Hl':is_lub (EUn Un) l'
n:R
k:nat
Hk:n = Un k
Un k <= l
  apply Rle_trans with (Vn k).
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n0 : nat) : R :=
  match n0 with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n0)
      then Un n0
      else aux n'
  end:nat -> R
In:=fix aux (n0 : nat) : nat :=
  match n0 with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n0) (Un n0)
      then n0
      else aux n'
  end:nat -> nat
VUI:forall n0 : nat, Vn n0 = Un (In n0)
HubV:has_ub Vn
HgrV:Un_growing Vn
l:R
Hl:is_lub (EUn Vn) l
l':R
Hl':is_lub (EUn Un) l'
n:R
k:nat
Hk:n = Un k
Un k <= Vn k
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n0 : nat) : R :=
  match n0 with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n0)
      then Un n0
      else aux n'
  end:nat -> R
In:=fix aux (n0 : nat) : nat :=
  match n0 with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n0) (Un n0)
      then n0
      else aux n'
  end:nat -> nat
VUI:forall n0 : nat, Vn n0 = Un (In n0)
HubV:has_ub Vn
HgrV:Un_growing Vn
l:R
Hl:is_lub (EUn Vn) l
l':R
Hl':is_lub (EUn Un) l'
n:R
k:nat
Hk:n = Un k
Vn k <= l
  clear.
Un:nat -> R
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
k:nat
Un k <= Vn k
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n0 : nat) : R :=
  match n0 with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n0)
      then Un n0
      else aux n'
  end:nat -> R
In:=fix aux (n0 : nat) : nat :=
  match n0 with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n0) (Un n0)
      then n0
      else aux n'
  end:nat -> nat
VUI:forall n0 : nat, Vn n0 = Un (In n0)
HubV:has_ub Vn
HgrV:Un_growing Vn
l:R
Hl:is_lub (EUn Vn) l
l':R
Hl':is_lub (EUn Un) l'
n:R
k:nat
Hk:n = Un k
Vn k <= l
  induction k.
Un:nat -> R
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
Un 0%nat <= Vn 0%nat
Un:nat -> R
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
k:nat
IHk:Un k <= Vn k
Un (S k) <= Vn (S k)
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n0 : nat) : R :=
  match n0 with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n0)
      then Un n0
      else aux n'
  end:nat -> R
In:=fix aux (n0 : nat) : nat :=
  match n0 with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n0) (Un n0)
      then n0
      else aux n'
  end:nat -> nat
VUI:forall n0 : nat, Vn n0 = Un (In n0)
HubV:has_ub Vn
HgrV:Un_growing Vn
l:R
Hl:is_lub (EUn Vn) l
l':R
Hl':is_lub (EUn Un) l'
n:R
k:nat
Hk:n = Un k
Vn k <= l
  apply Rle_refl.
Un:nat -> R
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
k:nat
IHk:Un k <= Vn k
Un (S k) <= Vn (S k)
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n0 : nat) : R :=
  match n0 with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n0)
      then Un n0
      else aux n'
  end:nat -> R
In:=fix aux (n0 : nat) : nat :=
  match n0 with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n0) (Un n0)
      then n0
      else aux n'
  end:nat -> nat
VUI:forall n0 : nat, Vn n0 = Un (In n0)
HubV:has_ub Vn
HgrV:Un_growing Vn
l:R
Hl:is_lub (EUn Vn) l
l':R
Hl':is_lub (EUn Un) l'
n:R
k:nat
Hk:n = Un k
Vn k <= l
  simpl.
Un:nat -> R
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
k:nat
IHk:Un k <= Vn k
Un (S k) <=
(if Rle_lt_dec (Vn k) (Un (S k))
 then Un (S k)
 else Vn k)
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n0 : nat) : R :=
  match n0 with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n0)
      then Un n0
      else aux n'
  end:nat -> R
In:=fix aux (n0 : nat) : nat :=
  match n0 with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n0) (Un n0)
      then n0
      else aux n'
  end:nat -> nat
VUI:forall n0 : nat, Vn n0 = Un (In n0)
HubV:has_ub Vn
HgrV:Un_growing Vn
l:R
Hl:is_lub (EUn Vn) l
l':R
Hl':is_lub (EUn Un) l'
n:R
k:nat
Hk:n = Un k
Vn k <= l
  destruct (Rle_lt_dec (Vn k) (Un (S k))) as [H|H].
Un:nat -> R
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
k:nat
IHk:Un k <= Vn k
H:Vn k <= Un (S k)
Un (S k) <= Un (S k)
Un:nat -> R
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
k:nat
IHk:Un k <= Vn k
H:Un (S k) < Vn k
Un (S k) <= Vn k
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n0 : nat) : R :=
  match n0 with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n0)
      then Un n0
      else aux n'
  end:nat -> R
In:=fix aux (n0 : nat) : nat :=
  match n0 with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n0) (Un n0)
      then n0
      else aux n'
  end:nat -> nat
VUI:forall n0 : nat, Vn n0 = Un (In n0)
HubV:has_ub Vn
HgrV:Un_growing Vn
l:R
Hl:is_lub (EUn Vn) l
l':R
Hl':is_lub (EUn Un) l'
n:R
k:nat
Hk:n = Un k
Vn k <= l
  apply Rle_refl.
Un:nat -> R
Vn:=fix aux (n : nat) : R :=
  match n with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n)
      then Un n
      else aux n'
  end:nat -> R
k:nat
IHk:Un k <= Vn k
H:Un (S k) < Vn k
Un (S k) <= Vn k
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n0 : nat) : R :=
  match n0 with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n0)
      then Un n0
      else aux n'
  end:nat -> R
In:=fix aux (n0 : nat) : nat :=
  match n0 with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n0) (Un n0)
      then n0
      else aux n'
  end:nat -> nat
VUI:forall n0 : nat, Vn n0 = Un (In n0)
HubV:has_ub Vn
HgrV:Un_growing Vn
l:R
Hl:is_lub (EUn Vn) l
l':R
Hl':is_lub (EUn Un) l'
n:R
k:nat
Hk:n = Un k
Vn k <= l
  now apply Rlt_le.
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n0 : nat) : R :=
  match n0 with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n0)
      then Un n0
      else aux n'
  end:nat -> R
In:=fix aux (n0 : nat) : nat :=
  match n0 with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n0) (Un n0)
      then n0
      else aux n'
  end:nat -> nat
VUI:forall n0 : nat, Vn n0 = Un (In n0)
HubV:has_ub Vn
HgrV:Un_growing Vn
l:R
Hl:is_lub (EUn Vn) l
l':R
Hl':is_lub (EUn Un) l'
n:R
k:nat
Hk:n = Un k
Vn k <= l
  apply Hl.
Un:nat -> R
pr:has_ub Un
Vn:=fix aux (n0 : nat) : R :=
  match n0 with
  | 0%nat => Un 0%nat
  | S n' =>
      if Rle_lt_dec (aux n') (Un n0)
      then Un n0
      else aux n'
  end:nat -> R
In:=fix aux (n0 : nat) : nat :=
  match n0 with
  | 0%nat => 0%nat
  | S n' =>
      if Rle_lt_dec (Vn n0) (Un n0)
      then n0
      else aux n'
  end:nat -> nat
VUI:forall n0 : nat, Vn n0 = Un (In n0)
HubV:has_ub Vn
HgrV:Un_growing Vn
l:R
Hl:is_lub (EUn Vn) l
l':R
Hl':is_lub (EUn Un) l'
n:R
k:nat
Hk:n = Un k
EUn Vn (Vn k)
  now exists k.
Qed.

(**********)
Lemma approx_min :
  forall (Un:nat -> R) (pr:has_lb Un) (eps:R),
    0 < eps ->  exists k : nat, Rabs (glb Un pr - Un k) < eps.
forall (Un : nat -> R) (pr : has_lb Un) (eps : R),
0 < eps ->
exists k : nat, Rabs (glb Un pr - Un k) < eps
Proof.
forall (Un : nat -> R) (pr : has_lb Un) (eps : R),
0 < eps ->
exists k : nat, Rabs (glb Un pr - Un k) < eps
  intros Un pr.
Un:nat -> R
pr:has_lb Un
forall eps : R,
0 < eps ->
exists k : nat, Rabs (glb Un pr - Un k) < eps
  unfold glb.
Un:nat -> R
pr:has_lb Un
forall eps : R,
0 < eps ->
exists k : nat,
  Rabs ((let (a, _) := lb_to_glb Un pr in - a) - Un k) <
  eps
  destruct lb_to_glb as (lb, Hlb).
Un:nat -> R
pr:has_lb Un
lb:R
Hlb:is_lub (EUn (opp_seq Un)) lb
forall eps : R,
0 < eps -> exists k : nat, Rabs (- lb - Un k) < eps
  intros eps Heps.
Un:nat -> R
pr:has_lb Un
lb:R
Hlb:is_lub (EUn (opp_seq Un)) lb
eps:R
Heps:0 < eps
exists k : nat, Rabs (- lb - Un k) < eps
  destruct (approx_maj _ pr eps Heps) as (n, Hn).
Un:nat -> R
pr:has_lb Un
lb:R
Hlb:is_lub (EUn (opp_seq Un)) lb
eps:R
Heps:0 < eps
n:nat
Hn:Rabs (lub (opp_seq Un) pr - opp_seq Un n) < eps
exists k : nat, Rabs (- lb - Un k) < eps
  exists n.
Un:nat -> R
pr:has_lb Un
lb:R
Hlb:is_lub (EUn (opp_seq Un)) lb
eps:R
Heps:0 < eps
n:nat
Hn:Rabs (lub (opp_seq Un) pr - opp_seq Un n) < eps
Rabs (- lb - Un n) < eps
  unfold Rminus.
Un:nat -> R
pr:has_lb Un
lb:R
Hlb:is_lub (EUn (opp_seq Un)) lb
eps:R
Heps:0 < eps
n:nat
Hn:Rabs (lub (opp_seq Un) pr - opp_seq Un n) < eps
Rabs (- lb + - Un n) < eps
  rewrite <- Ropp_plus_distr, Rabs_Ropp.
Un:nat -> R
pr:has_lb Un
lb:R
Hlb:is_lub (EUn (opp_seq Un)) lb
eps:R
Heps:0 < eps
n:nat
Hn:Rabs (lub (opp_seq Un) pr - opp_seq Un n) < eps
Rabs (lb + Un n) < eps
  replace lb with (lub (opp_seq Un) pr).
Un:nat -> R
pr:has_lb Un
lb:R
Hlb:is_lub (EUn (opp_seq Un)) lb
eps:R
Heps:0 < eps
n:nat
Hn:Rabs (lub (opp_seq Un) pr - opp_seq Un n) < eps
Rabs (lub (opp_seq Un) pr + Un n) < eps
Un:nat -> R
pr:has_lb Un
lb:R
Hlb:is_lub (EUn (opp_seq Un)) lb
eps:R
Heps:0 < eps
n:nat
Hn:Rabs (lub (opp_seq Un) pr - opp_seq Un n) < eps
lub (opp_seq Un) pr = lb
  now rewrite <- (Ropp_involutive (Un n)).
Un:nat -> R
pr:has_lb Un
lb:R
Hlb:is_lub (EUn (opp_seq Un)) lb
eps:R
Heps:0 < eps
n:nat
Hn:Rabs (lub (opp_seq Un) pr - opp_seq Un n) < eps
lub (opp_seq Un) pr = lb
  unfold lub.
Un:nat -> R
pr:has_lb Un
lb:R
Hlb:is_lub (EUn (opp_seq Un)) lb
eps:R
Heps:0 < eps
n:nat
Hn:Rabs (lub (opp_seq Un) pr - opp_seq Un n) < eps
(let (a, _) := ub_to_lub (opp_seq Un) pr in a) = lb
  destruct ub_to_lub as (ub, Hub).
Un:nat -> R
pr:has_lb Un
lb:R
Hlb:is_lub (EUn (opp_seq Un)) lb
eps:R
Heps:0 < eps
n:nat
Hn:Rabs (lub (opp_seq Un) pr - opp_seq Un n) < eps
ub:R
Hub:is_lub (EUn (opp_seq Un)) ub
ub = lb
  apply Rle_antisym.
Un:nat -> R
pr:has_lb Un
lb:R
Hlb:is_lub (EUn (opp_seq Un)) lb
eps:R
Heps:0 < eps
n:nat
Hn:Rabs (lub (opp_seq Un) pr - opp_seq Un n) < eps
ub:R
Hub:is_lub (EUn (opp_seq Un)) ub
ub <= lb
Un:nat -> R
pr:has_lb Un
lb:R
Hlb:is_lub (EUn (opp_seq Un)) lb
eps:R
Heps:0 < eps
n:nat
Hn:Rabs (lub (opp_seq Un) pr - opp_seq Un n) < eps
ub:R
Hub:is_lub (EUn (opp_seq Un)) ub
lb <= ub
  apply Hub.
Un:nat -> R
pr:has_lb Un
lb:R
Hlb:is_lub (EUn (opp_seq Un)) lb
eps:R
Heps:0 < eps
n:nat
Hn:Rabs (lub (opp_seq Un) pr - opp_seq Un n) < eps
ub:R
Hub:is_lub (EUn (opp_seq Un)) ub
is_upper_bound (EUn (opp_seq Un)) lb
Un:nat -> R
pr:has_lb Un
lb:R
Hlb:is_lub (EUn (opp_seq Un)) lb
eps:R
Heps:0 < eps
n:nat
Hn:Rabs (lub (opp_seq Un) pr - opp_seq Un n) < eps
ub:R
Hub:is_lub (EUn (opp_seq Un)) ub
lb <= ub
  apply Hlb.
Un:nat -> R
pr:has_lb Un
lb:R
Hlb:is_lub (EUn (opp_seq Un)) lb
eps:R
Heps:0 < eps
n:nat
Hn:Rabs (lub (opp_seq Un) pr - opp_seq Un n) < eps
ub:R
Hub:is_lub (EUn (opp_seq Un)) ub
lb <= ub
  apply Hlb.
Un:nat -> R
pr:has_lb Un
lb:R
Hlb:is_lub (EUn (opp_seq Un)) lb
eps:R
Heps:0 < eps
n:nat
Hn:Rabs (lub (opp_seq Un) pr - opp_seq Un n) < eps
ub:R
Hub:is_lub (EUn (opp_seq Un)) ub
is_upper_bound (EUn (opp_seq Un)) ub
  apply Hub.
Qed.