Rounding to odd and its properties, including the equivalence

Require Import Reals Psatz.
Require Import Core Operations.

Definition Zrnd_odd x :=  match Req_EM_T x (IZR (Zfloor x))  with
  | left _   => Zfloor x
  | right _  => match (Z.even (Zfloor x)) with
      | true => Zceil x
      | false => Zfloor x
     end
  end.



Instance valid_rnd_odd : Valid_rnd Zrnd_odd.
Valid_rnd Zrnd_odd
Proof.
Valid_rnd Zrnd_odd
split.
forall x y : R,
(x <= y)%R -> (Zrnd_odd x <= Zrnd_odd y)%Z
forall n : Z, Zrnd_odd (IZR n) = n
(* . *)
intros x y Hxy.
x, y:R
Hxy:(x <= y)%R
(Zrnd_odd x <= Zrnd_odd y)%Z
forall n : Z, Zrnd_odd (IZR n) = n
assert (Zfloor x <= Zrnd_odd y)%Z.
x, y:R
Hxy:(x <= y)%R
(Zfloor x <= Zrnd_odd y)%Z
x, y:R
Hxy:(x <= y)%R
H:(Zfloor x <= Zrnd_odd y)%Z
(Zrnd_odd x <= Zrnd_odd y)%Z
forall n : Z, Zrnd_odd (IZR n) = n
(* .. *)
apply Z.le_trans with (Zfloor y).
x, y:R
Hxy:(x <= y)%R
(Zfloor x <= Zfloor y)%Z
x, y:R
Hxy:(x <= y)%R
(Zfloor y <= Zrnd_odd y)%Z
x, y:R
Hxy:(x <= y)%R
H:(Zfloor x <= Zrnd_odd y)%Z
(Zrnd_odd x <= Zrnd_odd y)%Z
forall n : Z, Zrnd_odd (IZR n) = n
now apply Zfloor_le.
x, y:R
Hxy:(x <= y)%R
(Zfloor y <= Zrnd_odd y)%Z
x, y:R
Hxy:(x <= y)%R
H:(Zfloor x <= Zrnd_odd y)%Z
(Zrnd_odd x <= Zrnd_odd y)%Z
forall n : Z, Zrnd_odd (IZR n) = n
unfold Zrnd_odd; destruct (Req_EM_T  y (IZR (Zfloor y))).
x, y:R
Hxy:(x <= y)%R
e:y = IZR (Zfloor y)
(Zfloor y <= Zfloor y)%Z
x, y:R
Hxy:(x <= y)%R
n:y <> IZR (Zfloor y)
(Zfloor y <=
 (if Z.even (Zfloor y) then Zceil y else Zfloor y))%Z
x, y:R
Hxy:(x <= y)%R
H:(Zfloor x <= Zrnd_odd y)%Z
(Zrnd_odd x <= Zrnd_odd y)%Z
forall n : Z, Zrnd_odd (IZR n) = n
now apply Z.le_refl.
x, y:R
Hxy:(x <= y)%R
n:y <> IZR (Zfloor y)
(Zfloor y <=
 (if Z.even (Zfloor y) then Zceil y else Zfloor y))%Z
x, y:R
Hxy:(x <= y)%R
H:(Zfloor x <= Zrnd_odd y)%Z
(Zrnd_odd x <= Zrnd_odd y)%Z
forall n : Z, Zrnd_odd (IZR n) = n
case (Z.even (Zfloor y)).
x, y:R
Hxy:(x <= y)%R
n:y <> IZR (Zfloor y)
(Zfloor y <= Zceil y)%Z
x, y:R
Hxy:(x <= y)%R
n:y <> IZR (Zfloor y)
(Zfloor y <= Zfloor y)%Z
x, y:R
Hxy:(x <= y)%R
H:(Zfloor x <= Zrnd_odd y)%Z
(Zrnd_odd x <= Zrnd_odd y)%Z
forall n : Z, Zrnd_odd (IZR n) = n
apply le_IZR.
x, y:R
Hxy:(x <= y)%R
n:y <> IZR (Zfloor y)
(IZR (Zfloor y) <= IZR (Zceil y))%R
x, y:R
Hxy:(x <= y)%R
n:y <> IZR (Zfloor y)
(Zfloor y <= Zfloor y)%Z
x, y:R
Hxy:(x <= y)%R
H:(Zfloor x <= Zrnd_odd y)%Z
(Zrnd_odd x <= Zrnd_odd y)%Z
forall n : Z, Zrnd_odd (IZR n) = n
apply Rle_trans with y.
x, y:R
Hxy:(x <= y)%R
n:y <> IZR (Zfloor y)
(IZR (Zfloor y) <= y)%R
x, y:R
Hxy:(x <= y)%R
n:y <> IZR (Zfloor y)
(y <= IZR (Zceil y))%R
x, y:R
Hxy:(x <= y)%R
n:y <> IZR (Zfloor y)
(Zfloor y <= Zfloor y)%Z
x, y:R
Hxy:(x <= y)%R
H:(Zfloor x <= Zrnd_odd y)%Z
(Zrnd_odd x <= Zrnd_odd y)%Z
forall n : Z, Zrnd_odd (IZR n) = n
apply Zfloor_lb.
x, y:R
Hxy:(x <= y)%R
n:y <> IZR (Zfloor y)
(y <= IZR (Zceil y))%R
x, y:R
Hxy:(x <= y)%R
n:y <> IZR (Zfloor y)
(Zfloor y <= Zfloor y)%Z
x, y:R
Hxy:(x <= y)%R
H:(Zfloor x <= Zrnd_odd y)%Z
(Zrnd_odd x <= Zrnd_odd y)%Z
forall n : Z, Zrnd_odd (IZR n) = n
apply Zceil_ub.
x, y:R
Hxy:(x <= y)%R
n:y <> IZR (Zfloor y)
(Zfloor y <= Zfloor y)%Z
x, y:R
Hxy:(x <= y)%R
H:(Zfloor x <= Zrnd_odd y)%Z
(Zrnd_odd x <= Zrnd_odd y)%Z
forall n : Z, Zrnd_odd (IZR n) = n
now apply Z.le_refl.
x, y:R
Hxy:(x <= y)%R
H:(Zfloor x <= Zrnd_odd y)%Z
(Zrnd_odd x <= Zrnd_odd y)%Z
forall n : Z, Zrnd_odd (IZR n) = n
unfold Zrnd_odd at 1.
x, y:R
Hxy:(x <= y)%R
H:(Zfloor x <= Zrnd_odd y)%Z
((if Req_EM_T x (IZR (Zfloor x))
  then Zfloor x
  else if Z.even (Zfloor x) then Zceil x else Zfloor x) <=
 Zrnd_odd y)%Z
forall n : Z, Zrnd_odd (IZR n) = n
(* . *)
destruct (Req_EM_T  x (IZR (Zfloor x))) as [Hx|Hx].
x, y:R
Hxy:(x <= y)%R
H:(Zfloor x <= Zrnd_odd y)%Z
Hx:x = IZR (Zfloor x)
(Zfloor x <= Zrnd_odd y)%Z
x, y:R
Hxy:(x <= y)%R
H:(Zfloor x <= Zrnd_odd y)%Z
Hx:x <> IZR (Zfloor x)
((if Z.even (Zfloor x) then Zceil x else Zfloor x) <=
 Zrnd_odd y)%Z
forall n : Z, Zrnd_odd (IZR n) = n
(* .. *)
apply H.
x, y:R
Hxy:(x <= y)%R
H:(Zfloor x <= Zrnd_odd y)%Z
Hx:x <> IZR (Zfloor x)
((if Z.even (Zfloor x) then Zceil x else Zfloor x) <=
 Zrnd_odd y)%Z
forall n : Z, Zrnd_odd (IZR n) = n
(* .. *)
case_eq (Z.even (Zfloor x)); intros Hx2.
x, y:R
Hxy:(x <= y)%R
H:(Zfloor x <= Zrnd_odd y)%Z
Hx:x <> IZR (Zfloor x)
Hx2:Z.even (Zfloor x) = true
(Zceil x <= Zrnd_odd y)%Z
x, y:R
Hxy:(x <= y)%R
H:(Zfloor x <= Zrnd_odd y)%Z
Hx:x <> IZR (Zfloor x)
Hx2:Z.even (Zfloor x) = false
(Zfloor x <= Zrnd_odd y)%Z
forall n : Z, Zrnd_odd (IZR n) = n
2: apply H.
x, y:R
Hxy:(x <= y)%R
H:(Zfloor x <= Zrnd_odd y)%Z
Hx:x <> IZR (Zfloor x)
Hx2:Z.even (Zfloor x) = true
(Zceil x <= Zrnd_odd y)%Z
forall n : Z, Zrnd_odd (IZR n) = n
unfold Zrnd_odd; destruct (Req_EM_T  y (IZR (Zfloor y))) as [Hy|Hy].
x, y:R
Hxy:(x <= y)%R
H:(Zfloor x <= Zrnd_odd y)%Z
Hx:x <> IZR (Zfloor x)
Hx2:Z.even (Zfloor x) = true
Hy:y = IZR (Zfloor y)
(Zceil x <= Zfloor y)%Z
x, y:R
Hxy:(x <= y)%R
H:(Zfloor x <= Zrnd_odd y)%Z
Hx:x <> IZR (Zfloor x)
Hx2:Z.even (Zfloor x) = true
Hy:y <> IZR (Zfloor y)
(Zceil x <=
 (if Z.even (Zfloor y) then Zceil y else Zfloor y))%Z
forall n : Z, Zrnd_odd (IZR n) = n
apply Zceil_glb.
x, y:R
Hxy:(x <= y)%R
H:(Zfloor x <= Zrnd_odd y)%Z
Hx:x <> IZR (Zfloor x)
Hx2:Z.even (Zfloor x) = true
Hy:y = IZR (Zfloor y)
(x <= IZR (Zfloor y))%R
x, y:R
Hxy:(x <= y)%R
H:(Zfloor x <= Zrnd_odd y)%Z
Hx:x <> IZR (Zfloor x)
Hx2:Z.even (Zfloor x) = true
Hy:y <> IZR (Zfloor y)
(Zceil x <=
 (if Z.even (Zfloor y) then Zceil y else Zfloor y))%Z
forall n : Z, Zrnd_odd (IZR n) = n
now rewrite <- Hy.
x, y:R
Hxy:(x <= y)%R
H:(Zfloor x <= Zrnd_odd y)%Z
Hx:x <> IZR (Zfloor x)
Hx2:Z.even (Zfloor x) = true
Hy:y <> IZR (Zfloor y)
(Zceil x <=
 (if Z.even (Zfloor y) then Zceil y else Zfloor y))%Z
forall n : Z, Zrnd_odd (IZR n) = n
case_eq (Z.even (Zfloor y)); intros Hy2.
x, y:R
Hxy:(x <= y)%R
H:(Zfloor x <= Zrnd_odd y)%Z
Hx:x <> IZR (Zfloor x)
Hx2:Z.even (Zfloor x) = true
Hy:y <> IZR (Zfloor y)
Hy2:Z.even (Zfloor y) = true
(Zceil x <= Zceil y)%Z
x, y:R
Hxy:(x <= y)%R
H:(Zfloor x <= Zrnd_odd y)%Z
Hx:x <> IZR (Zfloor x)
Hx2:Z.even (Zfloor x) = true
Hy:y <> IZR (Zfloor y)
Hy2:Z.even (Zfloor y) = false
(Zceil x <= Zfloor y)%Z
forall n : Z, Zrnd_odd (IZR n) = n
now apply Zceil_le.
x, y:R
Hxy:(x <= y)%R
H:(Zfloor x <= Zrnd_odd y)%Z
Hx:x <> IZR (Zfloor x)
Hx2:Z.even (Zfloor x) = true
Hy:y <> IZR (Zfloor y)
Hy2:Z.even (Zfloor y) = false
(Zceil x <= Zfloor y)%Z
forall n : Z, Zrnd_odd (IZR n) = n
apply Zceil_glb.
x, y:R
Hxy:(x <= y)%R
H:(Zfloor x <= Zrnd_odd y)%Z
Hx:x <> IZR (Zfloor x)
Hx2:Z.even (Zfloor x) = true
Hy:y <> IZR (Zfloor y)
Hy2:Z.even (Zfloor y) = false
(x <= IZR (Zfloor y))%R
forall n : Z, Zrnd_odd (IZR n) = n
assert (H0:(Zfloor x <= Zfloor y)%Z) by now apply Zfloor_le.
x, y:R
Hxy:(x <= y)%R
H:(Zfloor x <= Zrnd_odd y)%Z
Hx:x <> IZR (Zfloor x)
Hx2:Z.even (Zfloor x) = true
Hy:y <> IZR (Zfloor y)
Hy2:Z.even (Zfloor y) = false
H0:(Zfloor x <= Zfloor y)%Z
(x <= IZR (Zfloor y))%R
forall n : Z, Zrnd_odd (IZR n) = n
case (Zle_lt_or_eq _ _  H0); intros H1.
x, y:R
Hxy:(x <= y)%R
H:(Zfloor x <= Zrnd_odd y)%Z
Hx:x <> IZR (Zfloor x)
Hx2:Z.even (Zfloor x) = true
Hy:y <> IZR (Zfloor y)
Hy2:Z.even (Zfloor y) = false
H0:(Zfloor x <= Zfloor y)%Z
H1:(Zfloor x < Zfloor y)%Z
(x <= IZR (Zfloor y))%R
x, y:R
Hxy:(x <= y)%R
H:(Zfloor x <= Zrnd_odd y)%Z
Hx:x <> IZR (Zfloor x)
Hx2:Z.even (Zfloor x) = true
Hy:y <> IZR (Zfloor y)
Hy2:Z.even (Zfloor y) = false
H0:(Zfloor x <= Zfloor y)%Z
H1:Zfloor x = Zfloor y
(x <= IZR (Zfloor y))%R
forall n : Z, Zrnd_odd (IZR n) = n
apply Rle_trans with (1:=Zceil_ub _).
x, y:R
Hxy:(x <= y)%R
H:(Zfloor x <= Zrnd_odd y)%Z
Hx:x <> IZR (Zfloor x)
Hx2:Z.even (Zfloor x) = true
Hy:y <> IZR (Zfloor y)
Hy2:Z.even (Zfloor y) = false
H0:(Zfloor x <= Zfloor y)%Z
H1:(Zfloor x < Zfloor y)%Z
(IZR (Zceil x) <= IZR (Zfloor y))%R
x, y:R
Hxy:(x <= y)%R
H:(Zfloor x <= Zrnd_odd y)%Z
Hx:x <> IZR (Zfloor x)
Hx2:Z.even (Zfloor x) = true
Hy:y <> IZR (Zfloor y)
Hy2:Z.even (Zfloor y) = false
H0:(Zfloor x <= Zfloor y)%Z
H1:Zfloor x = Zfloor y
(x <= IZR (Zfloor y))%R
forall n : Z, Zrnd_odd (IZR n) = n
rewrite Zceil_floor_neq.
x, y:R
Hxy:(x <= y)%R
H:(Zfloor x <= Zrnd_odd y)%Z
Hx:x <> IZR (Zfloor x)
Hx2:Z.even (Zfloor x) = true
Hy:y <> IZR (Zfloor y)
Hy2:Z.even (Zfloor y) = false
H0:(Zfloor x <= Zfloor y)%Z
H1:(Zfloor x < Zfloor y)%Z
(IZR (Zfloor x + 1) <= IZR (Zfloor y))%R
x, y:R
Hxy:(x <= y)%R
H:(Zfloor x <= Zrnd_odd y)%Z
Hx:x <> IZR (Zfloor x)
Hx2:Z.even (Zfloor x) = true
Hy:y <> IZR (Zfloor y)
Hy2:Z.even (Zfloor y) = false
H0:(Zfloor x <= Zfloor y)%Z
H1:(Zfloor x < Zfloor y)%Z
IZR (Zfloor x) <> x
x, y:R
Hxy:(x <= y)%R
H:(Zfloor x <= Zrnd_odd y)%Z
Hx:x <> IZR (Zfloor x)
Hx2:Z.even (Zfloor x) = true
Hy:y <> IZR (Zfloor y)
Hy2:Z.even (Zfloor y) = false
H0:(Zfloor x <= Zfloor y)%Z
H1:Zfloor x = Zfloor y
(x <= IZR (Zfloor y))%R
forall n : Z, Zrnd_odd (IZR n) = n
apply IZR_le; omega.
x, y:R
Hxy:(x <= y)%R
H:(Zfloor x <= Zrnd_odd y)%Z
Hx:x <> IZR (Zfloor x)
Hx2:Z.even (Zfloor x) = true
Hy:y <> IZR (Zfloor y)
Hy2:Z.even (Zfloor y) = false
H0:(Zfloor x <= Zfloor y)%Z
H1:(Zfloor x < Zfloor y)%Z
IZR (Zfloor x) <> x
x, y:R
Hxy:(x <= y)%R
H:(Zfloor x <= Zrnd_odd y)%Z
Hx:x <> IZR (Zfloor x)
Hx2:Z.even (Zfloor x) = true
Hy:y <> IZR (Zfloor y)
Hy2:Z.even (Zfloor y) = false
H0:(Zfloor x <= Zfloor y)%Z
H1:Zfloor x = Zfloor y
(x <= IZR (Zfloor y))%R
forall n : Z, Zrnd_odd (IZR n) = n
now apply sym_not_eq.
x, y:R
Hxy:(x <= y)%R
H:(Zfloor x <= Zrnd_odd y)%Z
Hx:x <> IZR (Zfloor x)
Hx2:Z.even (Zfloor x) = true
Hy:y <> IZR (Zfloor y)
Hy2:Z.even (Zfloor y) = false
H0:(Zfloor x <= Zfloor y)%Z
H1:Zfloor x = Zfloor y
(x <= IZR (Zfloor y))%R
forall n : Z, Zrnd_odd (IZR n) = n
contradict Hy2.
x, y:R
Hxy:(x <= y)%R
H:(Zfloor x <= Zrnd_odd y)%Z
Hx:x <> IZR (Zfloor x)
Hx2:Z.even (Zfloor x) = true
Hy:y <> IZR (Zfloor y)
H0:(Zfloor x <= Zfloor y)%Z
H1:Zfloor x = Zfloor y
Z.even (Zfloor y) <> false
forall n : Z, Zrnd_odd (IZR n) = n
rewrite <- H1, Hx2; discriminate.
forall n : Z, Zrnd_odd (IZR n) = n
(* . *)
intros n; unfold Zrnd_odd.
n:Z
(if Req_EM_T (IZR n) (IZR (Zfloor (IZR n)))
 then Zfloor (IZR n)
 else
  if Z.even (Zfloor (IZR n))
  then Zceil (IZR n)
  else Zfloor (IZR n)) = n
rewrite Zfloor_IZR, Zceil_IZR.
n:Z
(if Req_EM_T (IZR n) (IZR n)
 then n
 else if Z.even n then n else n) = n
destruct (Req_EM_T  (IZR n) (IZR n)); trivial.
n:Z
n0:IZR n <> IZR n
(if Z.even n then n else n) = n
case (Z.even n); trivial.
Qed.



Lemma Zrnd_odd_Zodd: forall x, x <> (IZR (Zfloor x)) ->
  (Z.even (Zrnd_odd x)) = false.
forall x : R,
x <> IZR (Zfloor x) -> Z.even (Zrnd_odd x) = false
Proof.
forall x : R,
x <> IZR (Zfloor x) -> Z.even (Zrnd_odd x) = false
intros x Hx; unfold Zrnd_odd.
x:R
Hx:x <> IZR (Zfloor x)
Z.even
  (if Req_EM_T x (IZR (Zfloor x))
   then Zfloor x
   else
    if Z.even (Zfloor x) then Zceil x else Zfloor x) =
false
destruct (Req_EM_T  x (IZR (Zfloor x))) as [H|H].
x:R
Hx:x <> IZR (Zfloor x)
H:x = IZR (Zfloor x)
Z.even (Zfloor x) = false
x:R
Hx, H:x <> IZR (Zfloor x)
Z.even
  (if Z.even (Zfloor x) then Zceil x else Zfloor x) =
false
now contradict H.
x:R
Hx, H:x <> IZR (Zfloor x)
Z.even
  (if Z.even (Zfloor x) then Zceil x else Zfloor x) =
false
case_eq (Z.even (Zfloor x)).
x:R
Hx, H:x <> IZR (Zfloor x)
Z.even (Zfloor x) = true -> Z.even (Zceil x) = false
x:R
Hx, H:x <> IZR (Zfloor x)
Z.even (Zfloor x) = false -> Z.even (Zfloor x) = false
(* difficult case *)
intros H'.
x:R
Hx, H:x <> IZR (Zfloor x)
H':Z.even (Zfloor x) = true
Z.even (Zceil x) = false
x:R
Hx, H:x <> IZR (Zfloor x)
Z.even (Zfloor x) = false -> Z.even (Zfloor x) = false
rewrite Zceil_floor_neq.
x:R
Hx, H:x <> IZR (Zfloor x)
H':Z.even (Zfloor x) = true
Z.even (Zfloor x + 1) = false
x:R
Hx, H:x <> IZR (Zfloor x)
H':Z.even (Zfloor x) = true
IZR (Zfloor x) <> x
x:R
Hx, H:x <> IZR (Zfloor x)
Z.even (Zfloor x) = false -> Z.even (Zfloor x) = false
rewrite Z.even_add, H'.
x:R
Hx, H:x <> IZR (Zfloor x)
H':Z.even (Zfloor x) = true
Bool.eqb true (Z.even 1) = false
x:R
Hx, H:x <> IZR (Zfloor x)
H':Z.even (Zfloor x) = true
IZR (Zfloor x) <> x
x:R
Hx, H:x <> IZR (Zfloor x)
Z.even (Zfloor x) = false -> Z.even (Zfloor x) = false
reflexivity.
x:R
Hx, H:x <> IZR (Zfloor x)
H':Z.even (Zfloor x) = true
IZR (Zfloor x) <> x
x:R
Hx, H:x <> IZR (Zfloor x)
Z.even (Zfloor x) = false -> Z.even (Zfloor x) = false
now apply sym_not_eq.
x:R
Hx, H:x <> IZR (Zfloor x)
Z.even (Zfloor x) = false -> Z.even (Zfloor x) = false
trivial.
Qed.


Lemma Zfloor_plus: forall (n:Z) y,
  (Zfloor (IZR n+y) = n + Zfloor y)%Z.
forall (n : Z) (y : R),
Zfloor (IZR n + y) = (n + Zfloor y)%Z
Proof.
forall (n : Z) (y : R),
Zfloor (IZR n + y) = (n + Zfloor y)%Z
intros n y; unfold Zfloor.
n:Z
y:R
(up (IZR n + y) - 1)%Z = (n + (up y - 1))%Z
unfold Zminus; rewrite Zplus_assoc; f_equal.
n:Z
y:R
up (IZR n + y) = (n + up y)%Z
apply sym_eq, tech_up.
n:Z
y:R
(IZR n + y < IZR (n + up y))%R
n:Z
y:R
(IZR (n + up y) <= IZR n + y + 1)%R
rewrite plus_IZR.
n:Z
y:R
(IZR n + y < IZR n + IZR (up y))%R
n:Z
y:R
(IZR (n + up y) <= IZR n + y + 1)%R
apply Rplus_lt_compat_l.
n:Z
y:R
(y < IZR (up y))%R
n:Z
y:R
(IZR (n + up y) <= IZR n + y + 1)%R
apply archimed.
n:Z
y:R
(IZR (n + up y) <= IZR n + y + 1)%R
rewrite plus_IZR, Rplus_assoc.
n:Z
y:R
(IZR n + IZR (up y) <= IZR n + (y + 1))%R
apply Rplus_le_compat_l.
n:Z
y:R
(IZR (up y) <= y + 1)%R
apply Rplus_le_reg_r with (-y)%R.
n:Z
y:R
(IZR (up y) + - y <= y + 1 + - y)%R
ring_simplify (y+1+-y)%R.
n:Z
y:R
(IZR (up y) + - y <= 1)%R
apply archimed.
Qed.

Lemma Zceil_plus: forall (n:Z) y,
  (Zceil (IZR n+y) = n + Zceil y)%Z.
forall (n : Z) (y : R),
Zceil (IZR n + y) = (n + Zceil y)%Z
Proof.
forall (n : Z) (y : R),
Zceil (IZR n + y) = (n + Zceil y)%Z
intros n y; unfold Zceil.
n:Z
y:R
(- Zfloor (- (IZR n + y)))%Z = (n + - Zfloor (- y))%Z
rewrite Ropp_plus_distr, <- Ropp_Ropp_IZR.
n:Z
y:R
(- Zfloor (IZR (- n) + - y))%Z =
(n + - Zfloor (- y))%Z
rewrite Zfloor_plus.
n:Z
y:R
(- (- n + Zfloor (- y)))%Z = (n + - Zfloor (- y))%Z
ring.
Qed.


Lemma Zeven_abs: forall z, Z.even (Z.abs z) = Z.even z.
forall z : Z, Z.even (Z.abs z) = Z.even z
Proof.
forall z : Z, Z.even (Z.abs z) = Z.even z
intros z; case (Zle_or_lt z 0); intros H1.
z:Z
H1:(z <= 0)%Z
Z.even (Z.abs z) = Z.even z
z:Z
H1:(0 < z)%Z
Z.even (Z.abs z) = Z.even z
rewrite Z.abs_neq; try assumption.
z:Z
H1:(z <= 0)%Z
Z.even (- z) = Z.even z
z:Z
H1:(0 < z)%Z
Z.even (Z.abs z) = Z.even z
apply Z.even_opp.
z:Z
H1:(0 < z)%Z
Z.even (Z.abs z) = Z.even z
rewrite Z.abs_eq; auto with zarith.
Qed.




Lemma Zrnd_odd_plus: forall x y, (x = IZR (Zfloor x)) ->
    Z.even (Zfloor x) = true ->
   (IZR (Zrnd_odd (x+y)) = x+IZR (Zrnd_odd y))%R.
forall x y : R,
x = IZR (Zfloor x) ->
Z.even (Zfloor x) = true ->
IZR (Zrnd_odd (x + y)) = (x + IZR (Zrnd_odd y))%R
Proof.
forall x y : R,
x = IZR (Zfloor x) ->
Z.even (Zfloor x) = true ->
IZR (Zrnd_odd (x + y)) = (x + IZR (Zrnd_odd y))%R
intros x y Hx H.
x, y:R
Hx:x = IZR (Zfloor x)
H:Z.even (Zfloor x) = true
IZR (Zrnd_odd (x + y)) = (x + IZR (Zrnd_odd y))%R
unfold Zrnd_odd; rewrite Hx, Zfloor_plus.
x, y:R
Hx:x = IZR (Zfloor x)
H:Z.even (Zfloor x) = true
IZR
  (if
    Req_EM_T (IZR (Zfloor x) + y)
      (IZR (Zfloor x + Zfloor y))
   then (Zfloor x + Zfloor y)%Z
   else
    if Z.even (Zfloor x + Zfloor y)
    then Zceil (IZR (Zfloor x) + y)
    else (Zfloor x + Zfloor y)%Z) =
(IZR (Zfloor x) +
 IZR
   (if Req_EM_T y (IZR (Zfloor y))
    then Zfloor y
    else
     if Z.even (Zfloor y) then Zceil y else Zfloor y))%R
case (Req_EM_T y (IZR (Zfloor y))); intros Hy.
x, y:R
Hx:x = IZR (Zfloor x)
H:Z.even (Zfloor x) = true
Hy:y = IZR (Zfloor y)
IZR
  (if
    Req_EM_T (IZR (Zfloor x) + y)
      (IZR (Zfloor x + Zfloor y))
   then (Zfloor x + Zfloor y)%Z
   else
    if Z.even (Zfloor x + Zfloor y)
    then Zceil (IZR (Zfloor x) + y)
    else (Zfloor x + Zfloor y)%Z) =
(IZR (Zfloor x) + IZR (Zfloor y))%R
x, y:R
Hx:x = IZR (Zfloor x)
H:Z.even (Zfloor x) = true
Hy:y <> IZR (Zfloor y)
IZR
  (if
    Req_EM_T (IZR (Zfloor x) + y)
      (IZR (Zfloor x + Zfloor y))
   then (Zfloor x + Zfloor y)%Z
   else
    if Z.even (Zfloor x + Zfloor y)
    then Zceil (IZR (Zfloor x) + y)
    else (Zfloor x + Zfloor y)%Z) =
(IZR (Zfloor x) +
 IZR (if Z.even (Zfloor y) then Zceil y else Zfloor y))%R
rewrite Hy; repeat rewrite <- plus_IZR.
x, y:R
Hx:x = IZR (Zfloor x)
H:Z.even (Zfloor x) = true
Hy:y = IZR (Zfloor y)
IZR
  (if
    Req_EM_T (IZR (Zfloor x + Zfloor y))
      (IZR (Zfloor x + Zfloor (IZR (Zfloor y))))
   then (Zfloor x + Zfloor (IZR (Zfloor y)))%Z
   else
    if Z.even (Zfloor x + Zfloor (IZR (Zfloor y)))
    then Zceil (IZR (Zfloor x + Zfloor y))
    else (Zfloor x + Zfloor (IZR (Zfloor y)))%Z) =
IZR (Zfloor x + Zfloor (IZR (Zfloor y)))
x, y:R
Hx:x = IZR (Zfloor x)
H:Z.even (Zfloor x) = true
Hy:y <> IZR (Zfloor y)
IZR
  (if
    Req_EM_T (IZR (Zfloor x) + y)
      (IZR (Zfloor x + Zfloor y))
   then (Zfloor x + Zfloor y)%Z
   else
    if Z.even (Zfloor x + Zfloor y)
    then Zceil (IZR (Zfloor x) + y)
    else (Zfloor x + Zfloor y)%Z) =
(IZR (Zfloor x) +
 IZR (if Z.even (Zfloor y) then Zceil y else Zfloor y))%R
repeat rewrite Zfloor_IZR.
x, y:R
Hx:x = IZR (Zfloor x)
H:Z.even (Zfloor x) = true
Hy:y = IZR (Zfloor y)
IZR
  (if
    Req_EM_T (IZR (Zfloor x + Zfloor y))
      (IZR (Zfloor x + Zfloor y))
   then (Zfloor x + Zfloor y)%Z
   else
    if Z.even (Zfloor x + Zfloor y)
    then Zceil (IZR (Zfloor x + Zfloor y))
    else (Zfloor x + Zfloor y)%Z) =
IZR (Zfloor x + Zfloor y)
x, y:R
Hx:x = IZR (Zfloor x)
H:Z.even (Zfloor x) = true
Hy:y <> IZR (Zfloor y)
IZR
  (if
    Req_EM_T (IZR (Zfloor x) + y)
      (IZR (Zfloor x + Zfloor y))
   then (Zfloor x + Zfloor y)%Z
   else
    if Z.even (Zfloor x + Zfloor y)
    then Zceil (IZR (Zfloor x) + y)
    else (Zfloor x + Zfloor y)%Z) =
(IZR (Zfloor x) +
 IZR (if Z.even (Zfloor y) then Zceil y else Zfloor y))%R
case (Req_EM_T _ _); intros K; easy.
x, y:R
Hx:x = IZR (Zfloor x)
H:Z.even (Zfloor x) = true
Hy:y <> IZR (Zfloor y)
IZR
  (if
    Req_EM_T (IZR (Zfloor x) + y)
      (IZR (Zfloor x + Zfloor y))
   then (Zfloor x + Zfloor y)%Z
   else
    if Z.even (Zfloor x + Zfloor y)
    then Zceil (IZR (Zfloor x) + y)
    else (Zfloor x + Zfloor y)%Z) =
(IZR (Zfloor x) +
 IZR (if Z.even (Zfloor y) then Zceil y else Zfloor y))%R
case (Req_EM_T _ _); intros K.
x, y:R
Hx:x = IZR (Zfloor x)
H:Z.even (Zfloor x) = true
Hy:y <> IZR (Zfloor y)
K:(IZR (Zfloor x) + y)%R = IZR (Zfloor x + Zfloor y)
IZR (Zfloor x + Zfloor y) =
(IZR (Zfloor x) +
 IZR (if Z.even (Zfloor y) then Zceil y else Zfloor y))%R
x, y:R
Hx:x = IZR (Zfloor x)
H:Z.even (Zfloor x) = true
Hy:y <> IZR (Zfloor y)
K:(IZR (Zfloor x) + y)%R <>
IZR (Zfloor x + Zfloor y)
IZR
  (if Z.even (Zfloor x + Zfloor y)
   then Zceil (IZR (Zfloor x) + y)
   else (Zfloor x + Zfloor y)%Z) =
(IZR (Zfloor x) +
 IZR (if Z.even (Zfloor y) then Zceil y else Zfloor y))%R
contradict Hy.
x, y:R
Hx:x = IZR (Zfloor x)
H:Z.even (Zfloor x) = true
K:(IZR (Zfloor x) + y)%R = IZR (Zfloor x + Zfloor y)
y = IZR (Zfloor y)
x, y:R
Hx:x = IZR (Zfloor x)
H:Z.even (Zfloor x) = true
Hy:y <> IZR (Zfloor y)
K:(IZR (Zfloor x) + y)%R <>
IZR (Zfloor x + Zfloor y)
IZR
  (if Z.even (Zfloor x + Zfloor y)
   then Zceil (IZR (Zfloor x) + y)
   else (Zfloor x + Zfloor y)%Z) =
(IZR (Zfloor x) +
 IZR (if Z.even (Zfloor y) then Zceil y else Zfloor y))%R
apply Rplus_eq_reg_l with (IZR (Zfloor x)).
x, y:R
Hx:x = IZR (Zfloor x)
H:Z.even (Zfloor x) = true
K:(IZR (Zfloor x) + y)%R = IZR (Zfloor x + Zfloor y)
(IZR (Zfloor x) + y)%R =
(IZR (Zfloor x) + IZR (Zfloor y))%R
x, y:R
Hx:x = IZR (Zfloor x)
H:Z.even (Zfloor x) = true
Hy:y <> IZR (Zfloor y)
K:(IZR (Zfloor x) + y)%R <>
IZR (Zfloor x + Zfloor y)
IZR
  (if Z.even (Zfloor x + Zfloor y)
   then Zceil (IZR (Zfloor x) + y)
   else (Zfloor x + Zfloor y)%Z) =
(IZR (Zfloor x) +
 IZR (if Z.even (Zfloor y) then Zceil y else Zfloor y))%R
now rewrite K, plus_IZR.
x, y:R
Hx:x = IZR (Zfloor x)
H:Z.even (Zfloor x) = true
Hy:y <> IZR (Zfloor y)
K:(IZR (Zfloor x) + y)%R <>
IZR (Zfloor x + Zfloor y)
IZR
  (if Z.even (Zfloor x + Zfloor y)
   then Zceil (IZR (Zfloor x) + y)
   else (Zfloor x + Zfloor y)%Z) =
(IZR (Zfloor x) +
 IZR (if Z.even (Zfloor y) then Zceil y else Zfloor y))%R
rewrite Z.even_add, H; simpl.
x, y:R
Hx:x = IZR (Zfloor x)
H:Z.even (Zfloor x) = true
Hy:y <> IZR (Zfloor y)
K:(IZR (Zfloor x) + y)%R <>
IZR (Zfloor x + Zfloor y)
IZR
  (if if Z.even (Zfloor y) then true else false
   then Zceil (IZR (Zfloor x) + y)
   else (Zfloor x + Zfloor y)%Z) =
(IZR (Zfloor x) +
 IZR (if Z.even (Zfloor y) then Zceil y else Zfloor y))%R
case (Z.even (Zfloor y)).
x, y:R
Hx:x = IZR (Zfloor x)
H:Z.even (Zfloor x) = true
Hy:y <> IZR (Zfloor y)
K:(IZR (Zfloor x) + y)%R <>
IZR (Zfloor x + Zfloor y)
IZR (Zceil (IZR (Zfloor x) + y)) =
(IZR (Zfloor x) + IZR (Zceil y))%R
x, y:R
Hx:x = IZR (Zfloor x)
H:Z.even (Zfloor x) = true
Hy:y <> IZR (Zfloor y)
K:(IZR (Zfloor x) + y)%R <>
IZR (Zfloor x + Zfloor y)
IZR (Zfloor x + Zfloor y) =
(IZR (Zfloor x) + IZR (Zfloor y))%R
now rewrite Zceil_plus, plus_IZR.
x, y:R
Hx:x = IZR (Zfloor x)
H:Z.even (Zfloor x) = true
Hy:y <> IZR (Zfloor y)
K:(IZR (Zfloor x) + y)%R <>
IZR (Zfloor x + Zfloor y)
IZR (Zfloor x + Zfloor y) =
(IZR (Zfloor x) + IZR (Zfloor y))%R
now rewrite plus_IZR.
Qed.


Section Fcore_rnd_odd.

Variable beta : radix.

Notation bpow e := (bpow beta e).

Variable fexp : Z -> Z.

Context { valid_exp : Valid_exp fexp }.
Context { exists_NE_ : Exists_NE beta fexp }.

Notation format := (generic_format beta fexp).
Notation canonical := (canonical beta fexp).
Notation cexp := (cexp beta fexp).


Definition Rnd_odd_pt (x f : R) :=
  format f /\ ((f = x)%R \/
    ((Rnd_DN_pt format x f \/ Rnd_UP_pt format x f) /\
    exists g : float beta, f = F2R g /\ canonical g /\ Z.even (Fnum g) = false)).

Definition Rnd_odd (rnd : R -> R) :=
  forall x : R, Rnd_odd_pt x (rnd x).

Theorem Rnd_odd_pt_opp_inv :   forall x f : R,
  Rnd_odd_pt (-x) (-f) -> Rnd_odd_pt x f.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
forall x f : R,
Rnd_odd_pt (- x) (- f) -> Rnd_odd_pt x f
Proof with auto with typeclass_instances.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
forall x f : R,
Rnd_odd_pt (- x) (- f) -> Rnd_odd_pt x f
intros x f (H1,H2).
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f:R
H1:format (- f)
H2:(- f)%R = (- x)%R \/
(Rnd_DN_pt format (- x) (- f) \/
 Rnd_UP_pt format (- x) (- f)) /\
(exists g : float beta,
   (- f)%R = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
Rnd_odd_pt x f
split.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f:R
H1:format (- f)
H2:(- f)%R = (- x)%R \/
(Rnd_DN_pt format (- x) (- f) \/
 Rnd_UP_pt format (- x) (- f)) /\
(exists g : float beta,
   (- f)%R = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
format f
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f:R
H1:format (- f)
H2:(- f)%R = (- x)%R \/
(Rnd_DN_pt format (- x) (- f) \/
 Rnd_UP_pt format (- x) (- f)) /\
(exists g : float beta,
   (- f)%R = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
f = x \/
(Rnd_DN_pt format x f \/ Rnd_UP_pt format x f) /\
(exists g : float beta,
   f = F2R g /\ canonical g /\ Z.even (Fnum g) = false)
replace f with (-(-f))%R by ring.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f:R
H1:format (- f)
H2:(- f)%R = (- x)%R \/
(Rnd_DN_pt format (- x) (- f) \/
 Rnd_UP_pt format (- x) (- f)) /\
(exists g : float beta,
   (- f)%R = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
format (- - f)
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f:R
H1:format (- f)
H2:(- f)%R = (- x)%R \/
(Rnd_DN_pt format (- x) (- f) \/
 Rnd_UP_pt format (- x) (- f)) /\
(exists g : float beta,
   (- f)%R = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
f = x \/
(Rnd_DN_pt format x f \/ Rnd_UP_pt format x f) /\
(exists g : float beta,
   f = F2R g /\ canonical g /\ Z.even (Fnum g) = false)
now apply generic_format_opp.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f:R
H1:format (- f)
H2:(- f)%R = (- x)%R \/
(Rnd_DN_pt format (- x) (- f) \/
 Rnd_UP_pt format (- x) (- f)) /\
(exists g : float beta,
   (- f)%R = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
f = x \/
(Rnd_DN_pt format x f \/ Rnd_UP_pt format x f) /\
(exists g : float beta,
   f = F2R g /\ canonical g /\ Z.even (Fnum g) = false)
destruct H2.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f:R
H1:format (- f)
H:(- f)%R = (- x)%R
f = x \/
(Rnd_DN_pt format x f \/ Rnd_UP_pt format x f) /\
(exists g : float beta,
   f = F2R g /\ canonical g /\ Z.even (Fnum g) = false)
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f:R
H1:format (- f)
H:(Rnd_DN_pt format (- x) (- f) \/
 Rnd_UP_pt format (- x) (- f)) /\
(exists g : float beta,
   (- f)%R = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
f = x \/
(Rnd_DN_pt format x f \/ Rnd_UP_pt format x f) /\
(exists g : float beta,
   f = F2R g /\ canonical g /\ Z.even (Fnum g) = false)
left.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f:R
H1:format (- f)
H:(- f)%R = (- x)%R
f = x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f:R
H1:format (- f)
H:(Rnd_DN_pt format (- x) (- f) \/
 Rnd_UP_pt format (- x) (- f)) /\
(exists g : float beta,
   (- f)%R = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
f = x \/
(Rnd_DN_pt format x f \/ Rnd_UP_pt format x f) /\
(exists g : float beta,
   f = F2R g /\ canonical g /\ Z.even (Fnum g) = false)
replace f with (-(-f))%R by ring.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f:R
H1:format (- f)
H:(- f)%R = (- x)%R
(- - f)%R = x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f:R
H1:format (- f)
H:(Rnd_DN_pt format (- x) (- f) \/
 Rnd_UP_pt format (- x) (- f)) /\
(exists g : float beta,
   (- f)%R = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
f = x \/
(Rnd_DN_pt format x f \/ Rnd_UP_pt format x f) /\
(exists g : float beta,
   f = F2R g /\ canonical g /\ Z.even (Fnum g) = false)
rewrite H; ring.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f:R
H1:format (- f)
H:(Rnd_DN_pt format (- x) (- f) \/
 Rnd_UP_pt format (- x) (- f)) /\
(exists g : float beta,
   (- f)%R = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
f = x \/
(Rnd_DN_pt format x f \/ Rnd_UP_pt format x f) /\
(exists g : float beta,
   f = F2R g /\ canonical g /\ Z.even (Fnum g) = false)
right.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f:R
H1:format (- f)
H:(Rnd_DN_pt format (- x) (- f) \/
 Rnd_UP_pt format (- x) (- f)) /\
(exists g : float beta,
   (- f)%R = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
(Rnd_DN_pt format x f \/ Rnd_UP_pt format x f) /\
(exists g : float beta,
   f = F2R g /\ canonical g /\ Z.even (Fnum g) = false)
destruct H as (H2,(g,(Hg1,(Hg2,Hg3)))).
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f:R
H1:format (- f)
H2:Rnd_DN_pt format (- x) (- f) \/
Rnd_UP_pt format (- x) (- f)
g:float beta
Hg1:(- f)%R = F2R g
Hg2:canonical g
Hg3:Z.even (Fnum g) = false
(Rnd_DN_pt format x f \/ Rnd_UP_pt format x f) /\
(exists g0 : float beta,
   f = F2R g0 /\
   canonical g0 /\ Z.even (Fnum g0) = false)
split.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f:R
H1:format (- f)
H2:Rnd_DN_pt format (- x) (- f) \/
Rnd_UP_pt format (- x) (- f)
g:float beta
Hg1:(- f)%R = F2R g
Hg2:canonical g
Hg3:Z.even (Fnum g) = false
Rnd_DN_pt format x f \/ Rnd_UP_pt format x f
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f:R
H1:format (- f)
H2:Rnd_DN_pt format (- x) (- f) \/
Rnd_UP_pt format (- x) (- f)
g:float beta
Hg1:(- f)%R = F2R g
Hg2:canonical g
Hg3:Z.even (Fnum g) = false
exists g0 : float beta,
  f = F2R g0 /\
  canonical g0 /\ Z.even (Fnum g0) = false
destruct H2.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f:R
H1:format (- f)
H:Rnd_DN_pt format (- x) (- f)
g:float beta
Hg1:(- f)%R = F2R g
Hg2:canonical g
Hg3:Z.even (Fnum g) = false
Rnd_DN_pt format x f \/ Rnd_UP_pt format x f
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f:R
H1:format (- f)
H:Rnd_UP_pt format (- x) (- f)
g:float beta
Hg1:(- f)%R = F2R g
Hg2:canonical g
Hg3:Z.even (Fnum g) = false
Rnd_DN_pt format x f \/ Rnd_UP_pt format x f
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f:R
H1:format (- f)
H2:Rnd_DN_pt format (- x) (- f) \/
Rnd_UP_pt format (- x) (- f)
g:float beta
Hg1:(- f)%R = F2R g
Hg2:canonical g
Hg3:Z.even (Fnum g) = false
exists g0 : float beta,
  f = F2R g0 /\
  canonical g0 /\ Z.even (Fnum g0) = false
right.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f:R
H1:format (- f)
H:Rnd_DN_pt format (- x) (- f)
g:float beta
Hg1:(- f)%R = F2R g
Hg2:canonical g
Hg3:Z.even (Fnum g) = false
Rnd_UP_pt format x f
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f:R
H1:format (- f)
H:Rnd_UP_pt format (- x) (- f)
g:float beta
Hg1:(- f)%R = F2R g
Hg2:canonical g
Hg3:Z.even (Fnum g) = false
Rnd_DN_pt format x f \/ Rnd_UP_pt format x f
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f:R
H1:format (- f)
H2:Rnd_DN_pt format (- x) (- f) \/
Rnd_UP_pt format (- x) (- f)
g:float beta
Hg1:(- f)%R = F2R g
Hg2:canonical g
Hg3:Z.even (Fnum g) = false
exists g0 : float beta,
  f = F2R g0 /\
  canonical g0 /\ Z.even (Fnum g0) = false
replace f with (-(-f))%R by ring.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f:R
H1:format (- f)
H:Rnd_DN_pt format (- x) (- f)
g:float beta
Hg1:(- f)%R = F2R g
Hg2:canonical g
Hg3:Z.even (Fnum g) = false
Rnd_UP_pt format x (- - f)
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f:R
H1:format (- f)
H:Rnd_UP_pt format (- x) (- f)
g:float beta
Hg1:(- f)%R = F2R g
Hg2:canonical g
Hg3:Z.even (Fnum g) = false
Rnd_DN_pt format x f \/ Rnd_UP_pt format x f
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f:R
H1:format (- f)
H2:Rnd_DN_pt format (- x) (- f) \/
Rnd_UP_pt format (- x) (- f)
g:float beta
Hg1:(- f)%R = F2R g
Hg2:canonical g
Hg3:Z.even (Fnum g) = false
exists g0 : float beta,
  f = F2R g0 /\
  canonical g0 /\ Z.even (Fnum g0) = false
replace x with (-(-x))%R by ring.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f:R
H1:format (- f)
H:Rnd_DN_pt format (- x) (- f)
g:float beta
Hg1:(- f)%R = F2R g
Hg2:canonical g
Hg3:Z.even (Fnum g) = false
Rnd_UP_pt format (- - x) (- - f)
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f:R
H1:format (- f)
H:Rnd_UP_pt format (- x) (- f)
g:float beta
Hg1:(- f)%R = F2R g
Hg2:canonical g
Hg3:Z.even (Fnum g) = false
Rnd_DN_pt format x f \/ Rnd_UP_pt format x f
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f:R
H1:format (- f)
H2:Rnd_DN_pt format (- x) (- f) \/
Rnd_UP_pt format (- x) (- f)
g:float beta
Hg1:(- f)%R = F2R g
Hg2:canonical g
Hg3:Z.even (Fnum g) = false
exists g0 : float beta,
  f = F2R g0 /\
  canonical g0 /\ Z.even (Fnum g0) = false
apply Rnd_UP_pt_opp...
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f:R
H1:format (- f)
H:Rnd_DN_pt format (- x) (- f)
g:float beta
Hg1:(- f)%R = F2R g
Hg2:canonical g
Hg3:Z.even (Fnum g) = false
forall x0 : R, format x0 -> format (- x0)
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f:R
H1:format (- f)
H:Rnd_UP_pt format (- x) (- f)
g:float beta
Hg1:(- f)%R = F2R g
Hg2:canonical g
Hg3:Z.even (Fnum g) = false
Rnd_DN_pt format x f \/ Rnd_UP_pt format x f
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f:R
H1:format (- f)
H2:Rnd_DN_pt format (- x) (- f) \/
Rnd_UP_pt format (- x) (- f)
g:float beta
Hg1:(- f)%R = F2R g
Hg2:canonical g
Hg3:Z.even (Fnum g) = false
exists g0 : float beta,
  f = F2R g0 /\
  canonical g0 /\ Z.even (Fnum g0) = false
apply generic_format_opp.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f:R
H1:format (- f)
H:Rnd_UP_pt format (- x) (- f)
g:float beta
Hg1:(- f)%R = F2R g
Hg2:canonical g
Hg3:Z.even (Fnum g) = false
Rnd_DN_pt format x f \/ Rnd_UP_pt format x f
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f:R
H1:format (- f)
H2:Rnd_DN_pt format (- x) (- f) \/
Rnd_UP_pt format (- x) (- f)
g:float beta
Hg1:(- f)%R = F2R g
Hg2:canonical g
Hg3:Z.even (Fnum g) = false
exists g0 : float beta,
  f = F2R g0 /\
  canonical g0 /\ Z.even (Fnum g0) = false
left.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f:R
H1:format (- f)
H:Rnd_UP_pt format (- x) (- f)
g:float beta
Hg1:(- f)%R = F2R g
Hg2:canonical g
Hg3:Z.even (Fnum g) = false
Rnd_DN_pt format x f
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f:R
H1:format (- f)
H2:Rnd_DN_pt format (- x) (- f) \/
Rnd_UP_pt format (- x) (- f)
g:float beta
Hg1:(- f)%R = F2R g
Hg2:canonical g
Hg3:Z.even (Fnum g) = false
exists g0 : float beta,
  f = F2R g0 /\
  canonical g0 /\ Z.even (Fnum g0) = false
replace f with (-(-f))%R by ring.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f:R
H1:format (- f)
H:Rnd_UP_pt format (- x) (- f)
g:float beta
Hg1:(- f)%R = F2R g
Hg2:canonical g
Hg3:Z.even (Fnum g) = false
Rnd_DN_pt format x (- - f)
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f:R
H1:format (- f)
H2:Rnd_DN_pt format (- x) (- f) \/
Rnd_UP_pt format (- x) (- f)
g:float beta
Hg1:(- f)%R = F2R g
Hg2:canonical g
Hg3:Z.even (Fnum g) = false
exists g0 : float beta,
  f = F2R g0 /\
  canonical g0 /\ Z.even (Fnum g0) = false
replace x with (-(-x))%R by ring.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f:R
H1:format (- f)
H:Rnd_UP_pt format (- x) (- f)
g:float beta
Hg1:(- f)%R = F2R g
Hg2:canonical g
Hg3:Z.even (Fnum g) = false
Rnd_DN_pt format (- - x) (- - f)
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f:R
H1:format (- f)
H2:Rnd_DN_pt format (- x) (- f) \/
Rnd_UP_pt format (- x) (- f)
g:float beta
Hg1:(- f)%R = F2R g
Hg2:canonical g
Hg3:Z.even (Fnum g) = false
exists g0 : float beta,
  f = F2R g0 /\
  canonical g0 /\ Z.even (Fnum g0) = false
apply Rnd_DN_pt_opp...
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f:R
H1:format (- f)
H:Rnd_UP_pt format (- x) (- f)
g:float beta
Hg1:(- f)%R = F2R g
Hg2:canonical g
Hg3:Z.even (Fnum g) = false
forall x0 : R, format x0 -> format (- x0)
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f:R
H1:format (- f)
H2:Rnd_DN_pt format (- x) (- f) \/
Rnd_UP_pt format (- x) (- f)
g:float beta
Hg1:(- f)%R = F2R g
Hg2:canonical g
Hg3:Z.even (Fnum g) = false
exists g0 : float beta,
  f = F2R g0 /\
  canonical g0 /\ Z.even (Fnum g0) = false
apply generic_format_opp.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f:R
H1:format (- f)
H2:Rnd_DN_pt format (- x) (- f) \/
Rnd_UP_pt format (- x) (- f)
g:float beta
Hg1:(- f)%R = F2R g
Hg2:canonical g
Hg3:Z.even (Fnum g) = false
exists g0 : float beta,
  f = F2R g0 /\
  canonical g0 /\ Z.even (Fnum g0) = false
exists (Float beta (-Fnum g) (Fexp g)).
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f:R
H1:format (- f)
H2:Rnd_DN_pt format (- x) (- f) \/
Rnd_UP_pt format (- x) (- f)
g:float beta
Hg1:(- f)%R = F2R g
Hg2:canonical g
Hg3:Z.even (Fnum g) = false
f = F2R {| Fnum := - Fnum g; Fexp := Fexp g |} /\
canonical {| Fnum := - Fnum g; Fexp := Fexp g |} /\
Z.even (Fnum {| Fnum := - Fnum g; Fexp := Fexp g |}) =
false
split.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f:R
H1:format (- f)
H2:Rnd_DN_pt format (- x) (- f) \/
Rnd_UP_pt format (- x) (- f)
g:float beta
Hg1:(- f)%R = F2R g
Hg2:canonical g
Hg3:Z.even (Fnum g) = false
f = F2R {| Fnum := - Fnum g; Fexp := Fexp g |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f:R
H1:format (- f)
H2:Rnd_DN_pt format (- x) (- f) \/
Rnd_UP_pt format (- x) (- f)
g:float beta
Hg1:(- f)%R = F2R g
Hg2:canonical g
Hg3:Z.even (Fnum g) = false
canonical {| Fnum := - Fnum g; Fexp := Fexp g |} /\
Z.even (Fnum {| Fnum := - Fnum g; Fexp := Fexp g |}) =
false
rewrite F2R_Zopp.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f:R
H1:format (- f)
H2:Rnd_DN_pt format (- x) (- f) \/
Rnd_UP_pt format (- x) (- f)
g:float beta
Hg1:(- f)%R = F2R g
Hg2:canonical g
Hg3:Z.even (Fnum g) = false
f = (- F2R {| Fnum := Fnum g; Fexp := Fexp g |})%R
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f:R
H1:format (- f)
H2:Rnd_DN_pt format (- x) (- f) \/
Rnd_UP_pt format (- x) (- f)
g:float beta
Hg1:(- f)%R = F2R g
Hg2:canonical g
Hg3:Z.even (Fnum g) = false
canonical {| Fnum := - Fnum g; Fexp := Fexp g |} /\
Z.even (Fnum {| Fnum := - Fnum g; Fexp := Fexp g |}) =
false
replace f with (-(-f))%R by ring.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f:R
H1:format (- f)
H2:Rnd_DN_pt format (- x) (- f) \/
Rnd_UP_pt format (- x) (- f)
g:float beta
Hg1:(- f)%R = F2R g
Hg2:canonical g
Hg3:Z.even (Fnum g) = false
(- - f)%R =
(- F2R {| Fnum := Fnum g; Fexp := Fexp g |})%R
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f:R
H1:format (- f)
H2:Rnd_DN_pt format (- x) (- f) \/
Rnd_UP_pt format (- x) (- f)
g:float beta
Hg1:(- f)%R = F2R g
Hg2:canonical g
Hg3:Z.even (Fnum g) = false
canonical {| Fnum := - Fnum g; Fexp := Fexp g |} /\
Z.even (Fnum {| Fnum := - Fnum g; Fexp := Fexp g |}) =
false
rewrite Hg1; reflexivity.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f:R
H1:format (- f)
H2:Rnd_DN_pt format (- x) (- f) \/
Rnd_UP_pt format (- x) (- f)
g:float beta
Hg1:(- f)%R = F2R g
Hg2:canonical g
Hg3:Z.even (Fnum g) = false
canonical {| Fnum := - Fnum g; Fexp := Fexp g |} /\
Z.even (Fnum {| Fnum := - Fnum g; Fexp := Fexp g |}) =
false
split.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f:R
H1:format (- f)
H2:Rnd_DN_pt format (- x) (- f) \/
Rnd_UP_pt format (- x) (- f)
g:float beta
Hg1:(- f)%R = F2R g
Hg2:canonical g
Hg3:Z.even (Fnum g) = false
canonical {| Fnum := - Fnum g; Fexp := Fexp g |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f:R
H1:format (- f)
H2:Rnd_DN_pt format (- x) (- f) \/
Rnd_UP_pt format (- x) (- f)
g:float beta
Hg1:(- f)%R = F2R g
Hg2:canonical g
Hg3:Z.even (Fnum g) = false
Z.even (Fnum {| Fnum := - Fnum g; Fexp := Fexp g |}) =
false
now apply canonical_opp.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f:R
H1:format (- f)
H2:Rnd_DN_pt format (- x) (- f) \/
Rnd_UP_pt format (- x) (- f)
g:float beta
Hg1:(- f)%R = F2R g
Hg2:canonical g
Hg3:Z.even (Fnum g) = false
Z.even (Fnum {| Fnum := - Fnum g; Fexp := Fexp g |}) =
false
simpl.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f:R
H1:format (- f)
H2:Rnd_DN_pt format (- x) (- f) \/
Rnd_UP_pt format (- x) (- f)
g:float beta
Hg1:(- f)%R = F2R g
Hg2:canonical g
Hg3:Z.even (Fnum g) = false
Z.even (- Fnum g) = false
now rewrite Z.even_opp.
Qed.


Theorem round_odd_opp :
  forall x,
  round beta fexp Zrnd_odd (-x) = (- round beta fexp Zrnd_odd x)%R.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
forall x : R,
round beta fexp Zrnd_odd (- x) =
(- round beta fexp Zrnd_odd x)%R
Proof.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
forall x : R,
round beta fexp Zrnd_odd (- x) =
(- round beta fexp Zrnd_odd x)%R
intros x; unfold round.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
F2R
  {|
  Fnum := Zrnd_odd (scaled_mantissa beta fexp (- x));
  Fexp := cexp (- x) |} =
(-
 F2R
   {|
   Fnum := Zrnd_odd (scaled_mantissa beta fexp x);
   Fexp := cexp x |})%R
rewrite <- F2R_Zopp.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
F2R
  {|
  Fnum := Zrnd_odd (scaled_mantissa beta fexp (- x));
  Fexp := cexp (- x) |} =
F2R
  {|
  Fnum := - Zrnd_odd (scaled_mantissa beta fexp x);
  Fexp := cexp x |}
unfold F2R; simpl.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
(IZR (Zrnd_odd (scaled_mantissa beta fexp (- x))) *
 bpow (cexp (- x)))%R =
(IZR (- Zrnd_odd (scaled_mantissa beta fexp x)) *
 bpow (cexp x))%R
apply f_equal2; apply f_equal.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Zrnd_odd (scaled_mantissa beta fexp (- x)) =
(- Zrnd_odd (scaled_mantissa beta fexp x))%Z
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
cexp (- x) = cexp x
rewrite scaled_mantissa_opp.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Zrnd_odd (- scaled_mantissa beta fexp x) =
(- Zrnd_odd (scaled_mantissa beta fexp x))%Z
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
cexp (- x) = cexp x
generalize (scaled_mantissa beta fexp x); intros r.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
Zrnd_odd (- r) = (- Zrnd_odd r)%Z
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
cexp (- x) = cexp x
unfold Zrnd_odd.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
(if Req_EM_T (- r) (IZR (Zfloor (- r)))
 then Zfloor (- r)
 else
  if Z.even (Zfloor (- r))
  then Zceil (- r)
  else Zfloor (- r)) =
(-
 (if Req_EM_T r (IZR (Zfloor r))
  then Zfloor r
  else if Z.even (Zfloor r) then Zceil r else Zfloor r))%Z
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
cexp (- x) = cexp x
case (Req_EM_T (- r) (IZR (Zfloor (- r)))).
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
(- r)%R = IZR (Zfloor (- r)) ->
Zfloor (- r) =
(-
 (if Req_EM_T r (IZR (Zfloor r))
  then Zfloor r
  else if Z.even (Zfloor r) then Zceil r else Zfloor r))%Z
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
(- r)%R <> IZR (Zfloor (- r)) ->
(if Z.even (Zfloor (- r))
 then Zceil (- r)
 else Zfloor (- r)) =
(-
 (if Req_EM_T r (IZR (Zfloor r))
  then Zfloor r
  else if Z.even (Zfloor r) then Zceil r else Zfloor r))%Z
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
cexp (- x) = cexp x
case (Req_EM_T r (IZR (Zfloor r))).
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
r = IZR (Zfloor r) ->
(- r)%R = IZR (Zfloor (- r)) ->
Zfloor (- r) = (- Zfloor r)%Z
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
r <> IZR (Zfloor r) ->
(- r)%R = IZR (Zfloor (- r)) ->
Zfloor (- r) =
(- (if Z.even (Zfloor r) then Zceil r else Zfloor r))%Z
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
(- r)%R <> IZR (Zfloor (- r)) ->
(if Z.even (Zfloor (- r))
 then Zceil (- r)
 else Zfloor (- r)) =
(-
 (if Req_EM_T r (IZR (Zfloor r))
  then Zfloor r
  else if Z.even (Zfloor r) then Zceil r else Zfloor r))%Z
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
cexp (- x) = cexp x
intros Y1 Y2.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
Y1:r = IZR (Zfloor r)
Y2:(- r)%R = IZR (Zfloor (- r))
Zfloor (- r) = (- Zfloor r)%Z
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
r <> IZR (Zfloor r) ->
(- r)%R = IZR (Zfloor (- r)) ->
Zfloor (- r) =
(- (if Z.even (Zfloor r) then Zceil r else Zfloor r))%Z
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
(- r)%R <> IZR (Zfloor (- r)) ->
(if Z.even (Zfloor (- r))
 then Zceil (- r)
 else Zfloor (- r)) =
(-
 (if Req_EM_T r (IZR (Zfloor r))
  then Zfloor r
  else if Z.even (Zfloor r) then Zceil r else Zfloor r))%Z
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
cexp (- x) = cexp x
apply eq_IZR.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
Y1:r = IZR (Zfloor r)
Y2:(- r)%R = IZR (Zfloor (- r))
IZR (Zfloor (- r)) = IZR (- Zfloor r)
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
r <> IZR (Zfloor r) ->
(- r)%R = IZR (Zfloor (- r)) ->
Zfloor (- r) =
(- (if Z.even (Zfloor r) then Zceil r else Zfloor r))%Z
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
(- r)%R <> IZR (Zfloor (- r)) ->
(if Z.even (Zfloor (- r))
 then Zceil (- r)
 else Zfloor (- r)) =
(-
 (if Req_EM_T r (IZR (Zfloor r))
  then Zfloor r
  else if Z.even (Zfloor r) then Zceil r else Zfloor r))%Z
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
cexp (- x) = cexp x
now rewrite opp_IZR, <- Y1, <-Y2.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
r <> IZR (Zfloor r) ->
(- r)%R = IZR (Zfloor (- r)) ->
Zfloor (- r) =
(- (if Z.even (Zfloor r) then Zceil r else Zfloor r))%Z
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
(- r)%R <> IZR (Zfloor (- r)) ->
(if Z.even (Zfloor (- r))
 then Zceil (- r)
 else Zfloor (- r)) =
(-
 (if Req_EM_T r (IZR (Zfloor r))
  then Zfloor r
  else if Z.even (Zfloor r) then Zceil r else Zfloor r))%Z
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
cexp (- x) = cexp x
intros Y1 Y2.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
Y1:r <> IZR (Zfloor r)
Y2:(- r)%R = IZR (Zfloor (- r))
Zfloor (- r) =
(- (if Z.even (Zfloor r) then Zceil r else Zfloor r))%Z
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
(- r)%R <> IZR (Zfloor (- r)) ->
(if Z.even (Zfloor (- r))
 then Zceil (- r)
 else Zfloor (- r)) =
(-
 (if Req_EM_T r (IZR (Zfloor r))
  then Zfloor r
  else if Z.even (Zfloor r) then Zceil r else Zfloor r))%Z
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
cexp (- x) = cexp x
absurd (r=IZR (Zfloor r)); trivial.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
Y1:r <> IZR (Zfloor r)
Y2:(- r)%R = IZR (Zfloor (- r))
r = IZR (Zfloor r)
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
(- r)%R <> IZR (Zfloor (- r)) ->
(if Z.even (Zfloor (- r))
 then Zceil (- r)
 else Zfloor (- r)) =
(-
 (if Req_EM_T r (IZR (Zfloor r))
  then Zfloor r
  else if Z.even (Zfloor r) then Zceil r else Zfloor r))%Z
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
cexp (- x) = cexp x
pattern r at 2; replace r with (-(-r))%R by ring.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
Y1:r <> IZR (Zfloor r)
Y2:(- r)%R = IZR (Zfloor (- r))
r = IZR (Zfloor (- - r))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
(- r)%R <> IZR (Zfloor (- r)) ->
(if Z.even (Zfloor (- r))
 then Zceil (- r)
 else Zfloor (- r)) =
(-
 (if Req_EM_T r (IZR (Zfloor r))
  then Zfloor r
  else if Z.even (Zfloor r) then Zceil r else Zfloor r))%Z
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
cexp (- x) = cexp x
rewrite Y2, <- opp_IZR.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
Y1:r <> IZR (Zfloor r)
Y2:(- r)%R = IZR (Zfloor (- r))
r = IZR (Zfloor (IZR (- Zfloor (- r))))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
(- r)%R <> IZR (Zfloor (- r)) ->
(if Z.even (Zfloor (- r))
 then Zceil (- r)
 else Zfloor (- r)) =
(-
 (if Req_EM_T r (IZR (Zfloor r))
  then Zfloor r
  else if Z.even (Zfloor r) then Zceil r else Zfloor r))%Z
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
cexp (- x) = cexp x
rewrite Zfloor_IZR.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
Y1:r <> IZR (Zfloor r)
Y2:(- r)%R = IZR (Zfloor (- r))
r = IZR (- Zfloor (- r))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
(- r)%R <> IZR (Zfloor (- r)) ->
(if Z.even (Zfloor (- r))
 then Zceil (- r)
 else Zfloor (- r)) =
(-
 (if Req_EM_T r (IZR (Zfloor r))
  then Zfloor r
  else if Z.even (Zfloor r) then Zceil r else Zfloor r))%Z
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
cexp (- x) = cexp x
rewrite opp_IZR, <- Y2.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
Y1:r <> IZR (Zfloor r)
Y2:(- r)%R = IZR (Zfloor (- r))
r = (- - r)%R
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
(- r)%R <> IZR (Zfloor (- r)) ->
(if Z.even (Zfloor (- r))
 then Zceil (- r)
 else Zfloor (- r)) =
(-
 (if Req_EM_T r (IZR (Zfloor r))
  then Zfloor r
  else if Z.even (Zfloor r) then Zceil r else Zfloor r))%Z
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
cexp (- x) = cexp x
ring.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
(- r)%R <> IZR (Zfloor (- r)) ->
(if Z.even (Zfloor (- r))
 then Zceil (- r)
 else Zfloor (- r)) =
(-
 (if Req_EM_T r (IZR (Zfloor r))
  then Zfloor r
  else if Z.even (Zfloor r) then Zceil r else Zfloor r))%Z
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
cexp (- x) = cexp x
case (Req_EM_T r (IZR (Zfloor r))).
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
r = IZR (Zfloor r) ->
(- r)%R <> IZR (Zfloor (- r)) ->
(if Z.even (Zfloor (- r))
 then Zceil (- r)
 else Zfloor (- r)) = (- Zfloor r)%Z
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
r <> IZR (Zfloor r) ->
(- r)%R <> IZR (Zfloor (- r)) ->
(if Z.even (Zfloor (- r))
 then Zceil (- r)
 else Zfloor (- r)) =
(- (if Z.even (Zfloor r) then Zceil r else Zfloor r))%Z
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
cexp (- x) = cexp x
intros Y1 Y2.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
Y1:r = IZR (Zfloor r)
Y2:(- r)%R <> IZR (Zfloor (- r))
(if Z.even (Zfloor (- r))
 then Zceil (- r)
 else Zfloor (- r)) = (- Zfloor r)%Z
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
r <> IZR (Zfloor r) ->
(- r)%R <> IZR (Zfloor (- r)) ->
(if Z.even (Zfloor (- r))
 then Zceil (- r)
 else Zfloor (- r)) =
(- (if Z.even (Zfloor r) then Zceil r else Zfloor r))%Z
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
cexp (- x) = cexp x
absurd (-r=IZR (Zfloor (-r)))%R; trivial.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
Y1:r = IZR (Zfloor r)
Y2:(- r)%R <> IZR (Zfloor (- r))
(- r)%R = IZR (Zfloor (- r))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
r <> IZR (Zfloor r) ->
(- r)%R <> IZR (Zfloor (- r)) ->
(if Z.even (Zfloor (- r))
 then Zceil (- r)
 else Zfloor (- r)) =
(- (if Z.even (Zfloor r) then Zceil r else Zfloor r))%Z
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
cexp (- x) = cexp x
pattern r at 2; rewrite Y1.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
Y1:r = IZR (Zfloor r)
Y2:(- r)%R <> IZR (Zfloor (- r))
(- r)%R = IZR (Zfloor (- IZR (Zfloor r)))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
r <> IZR (Zfloor r) ->
(- r)%R <> IZR (Zfloor (- r)) ->
(if Z.even (Zfloor (- r))
 then Zceil (- r)
 else Zfloor (- r)) =
(- (if Z.even (Zfloor r) then Zceil r else Zfloor r))%Z
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
cexp (- x) = cexp x
rewrite <- opp_IZR, Zfloor_IZR.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
Y1:r = IZR (Zfloor r)
Y2:(- r)%R <> IZR (Zfloor (- r))
(- r)%R = IZR (- Zfloor r)
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
r <> IZR (Zfloor r) ->
(- r)%R <> IZR (Zfloor (- r)) ->
(if Z.even (Zfloor (- r))
 then Zceil (- r)
 else Zfloor (- r)) =
(- (if Z.even (Zfloor r) then Zceil r else Zfloor r))%Z
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
cexp (- x) = cexp x
now rewrite opp_IZR, <- Y1.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
r <> IZR (Zfloor r) ->
(- r)%R <> IZR (Zfloor (- r)) ->
(if Z.even (Zfloor (- r))
 then Zceil (- r)
 else Zfloor (- r)) =
(- (if Z.even (Zfloor r) then Zceil r else Zfloor r))%Z
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
cexp (- x) = cexp x
intros Y1 Y2.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
Y1:r <> IZR (Zfloor r)
Y2:(- r)%R <> IZR (Zfloor (- r))
(if Z.even (Zfloor (- r))
 then Zceil (- r)
 else Zfloor (- r)) =
(- (if Z.even (Zfloor r) then Zceil r else Zfloor r))%Z
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
cexp (- x) = cexp x
unfold Zceil; rewrite Ropp_involutive.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
Y1:r <> IZR (Zfloor r)
Y2:(- r)%R <> IZR (Zfloor (- r))
(if Z.even (Zfloor (- r))
 then (- Zfloor r)%Z
 else Zfloor (- r)) =
(-
 (if Z.even (Zfloor r)
  then - Zfloor (- r)
  else Zfloor r))%Z
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
cexp (- x) = cexp x
replace  (Z.even (Zfloor (- r))) with (negb (Z.even (Zfloor r))).
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
Y1:r <> IZR (Zfloor r)
Y2:(- r)%R <> IZR (Zfloor (- r))
(if negb (Z.even (Zfloor r))
 then (- Zfloor r)%Z
 else Zfloor (- r)) =
(-
 (if Z.even (Zfloor r)
  then - Zfloor (- r)
  else Zfloor r))%Z
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
Y1:r <> IZR (Zfloor r)
Y2:(- r)%R <> IZR (Zfloor (- r))
negb (Z.even (Zfloor r)) = Z.even (Zfloor (- r))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
cexp (- x) = cexp x
case (Z.even (Zfloor r));  simpl; ring.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
Y1:r <> IZR (Zfloor r)
Y2:(- r)%R <> IZR (Zfloor (- r))
negb (Z.even (Zfloor r)) = Z.even (Zfloor (- r))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
cexp (- x) = cexp x
apply trans_eq with (Z.even (Zceil r)).
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
Y1:r <> IZR (Zfloor r)
Y2:(- r)%R <> IZR (Zfloor (- r))
negb (Z.even (Zfloor r)) = Z.even (Zceil r)
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
Y1:r <> IZR (Zfloor r)
Y2:(- r)%R <> IZR (Zfloor (- r))
Z.even (Zceil r) = Z.even (Zfloor (- r))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
cexp (- x) = cexp x
rewrite Zceil_floor_neq.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
Y1:r <> IZR (Zfloor r)
Y2:(- r)%R <> IZR (Zfloor (- r))
negb (Z.even (Zfloor r)) = Z.even (Zfloor r + 1)
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
Y1:r <> IZR (Zfloor r)
Y2:(- r)%R <> IZR (Zfloor (- r))
IZR (Zfloor r) <> r
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
Y1:r <> IZR (Zfloor r)
Y2:(- r)%R <> IZR (Zfloor (- r))
Z.even (Zceil r) = Z.even (Zfloor (- r))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
cexp (- x) = cexp x
rewrite Z.even_add.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
Y1:r <> IZR (Zfloor r)
Y2:(- r)%R <> IZR (Zfloor (- r))
negb (Z.even (Zfloor r)) =
Bool.eqb (Z.even (Zfloor r)) (Z.even 1)
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
Y1:r <> IZR (Zfloor r)
Y2:(- r)%R <> IZR (Zfloor (- r))
IZR (Zfloor r) <> r
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
Y1:r <> IZR (Zfloor r)
Y2:(- r)%R <> IZR (Zfloor (- r))
Z.even (Zceil r) = Z.even (Zfloor (- r))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
cexp (- x) = cexp x
destruct (Z.even (Zfloor r)); reflexivity.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
Y1:r <> IZR (Zfloor r)
Y2:(- r)%R <> IZR (Zfloor (- r))
IZR (Zfloor r) <> r
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
Y1:r <> IZR (Zfloor r)
Y2:(- r)%R <> IZR (Zfloor (- r))
Z.even (Zceil r) = Z.even (Zfloor (- r))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
cexp (- x) = cexp x
now apply sym_not_eq.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
Y1:r <> IZR (Zfloor r)
Y2:(- r)%R <> IZR (Zfloor (- r))
Z.even (Zceil r) = Z.even (Zfloor (- r))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
cexp (- x) = cexp x
rewrite <- (Z.even_opp (Zfloor (- r))).
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, r:R
Y1:r <> IZR (Zfloor r)
Y2:(- r)%R <> IZR (Zfloor (- r))
Z.even (Zceil r) = Z.even (- Zfloor (- r))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
cexp (- x) = cexp x
reflexivity.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
cexp (- x) = cexp x
apply cexp_opp.
Qed.



Theorem round_odd_pt :
  forall x,
  Rnd_odd_pt x (round beta fexp Zrnd_odd x).
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
forall x : R,
Rnd_odd_pt x (round beta fexp Zrnd_odd x)
Proof with auto with typeclass_instances.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
forall x : R,
Rnd_odd_pt x (round beta fexp Zrnd_odd x)
cut (forall x : R, (0 < x)%R -> Rnd_odd_pt x (round beta fexp Zrnd_odd x)).
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
(forall x : R,
 (0 < x)%R ->
 Rnd_odd_pt x (round beta fexp Zrnd_odd x)) ->
forall x : R,
Rnd_odd_pt x (round beta fexp Zrnd_odd x)
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
forall x : R,
(0 < x)%R -> Rnd_odd_pt x (round beta fexp Zrnd_odd x)
intros H x; case (Rle_or_lt 0 x).
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
H:forall x0 : R,
(0 < x0)%R ->
Rnd_odd_pt x0 (round beta fexp Zrnd_odd x0)
x:R
(0 <= x)%R ->
Rnd_odd_pt x (round beta fexp Zrnd_odd x)
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
H:forall x0 : R,
(0 < x0)%R ->
Rnd_odd_pt x0 (round beta fexp Zrnd_odd x0)
x:R
(x < 0)%R -> Rnd_odd_pt x (round beta fexp Zrnd_odd x)
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
forall x : R,
(0 < x)%R -> Rnd_odd_pt x (round beta fexp Zrnd_odd x)
intros H1; destruct H1.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
H:forall x0 : R,
(0 < x0)%R ->
Rnd_odd_pt x0 (round beta fexp Zrnd_odd x0)
x:R
H0:(0 < x)%R
Rnd_odd_pt x (round beta fexp Zrnd_odd x)
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
H:forall x0 : R,
(0 < x0)%R ->
Rnd_odd_pt x0 (round beta fexp Zrnd_odd x0)
x:R
H0:0%R = x
Rnd_odd_pt x (round beta fexp Zrnd_odd x)
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
H:forall x0 : R,
(0 < x0)%R ->
Rnd_odd_pt x0 (round beta fexp Zrnd_odd x0)
x:R
(x < 0)%R -> Rnd_odd_pt x (round beta fexp Zrnd_odd x)
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
forall x : R,
(0 < x)%R -> Rnd_odd_pt x (round beta fexp Zrnd_odd x)
now apply H.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
H:forall x0 : R,
(0 < x0)%R ->
Rnd_odd_pt x0 (round beta fexp Zrnd_odd x0)
x:R
H0:0%R = x
Rnd_odd_pt x (round beta fexp Zrnd_odd x)
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
H:forall x0 : R,
(0 < x0)%R ->
Rnd_odd_pt x0 (round beta fexp Zrnd_odd x0)
x:R
(x < 0)%R -> Rnd_odd_pt x (round beta fexp Zrnd_odd x)
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
forall x : R,
(0 < x)%R -> Rnd_odd_pt x (round beta fexp Zrnd_odd x)
rewrite <- H0.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
H:forall x0 : R,
(0 < x0)%R ->
Rnd_odd_pt x0 (round beta fexp Zrnd_odd x0)
x:R
H0:0%R = x
Rnd_odd_pt 0 (round beta fexp Zrnd_odd 0)
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
H:forall x0 : R,
(0 < x0)%R ->
Rnd_odd_pt x0 (round beta fexp Zrnd_odd x0)
x:R
(x < 0)%R -> Rnd_odd_pt x (round beta fexp Zrnd_odd x)
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
forall x : R,
(0 < x)%R -> Rnd_odd_pt x (round beta fexp Zrnd_odd x)
rewrite round_0...
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
H:forall x0 : R,
(0 < x0)%R ->
Rnd_odd_pt x0 (round beta fexp Zrnd_odd x0)
x:R
H0:0%R = x
Rnd_odd_pt 0 0
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
H:forall x0 : R,
(0 < x0)%R ->
Rnd_odd_pt x0 (round beta fexp Zrnd_odd x0)
x:R
(x < 0)%R -> Rnd_odd_pt x (round beta fexp Zrnd_odd x)
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
forall x : R,
(0 < x)%R -> Rnd_odd_pt x (round beta fexp Zrnd_odd x)
split.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
H:forall x0 : R,
(0 < x0)%R ->
Rnd_odd_pt x0 (round beta fexp Zrnd_odd x0)
x:R
H0:0%R = x
format 0
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
H:forall x0 : R,
(0 < x0)%R ->
Rnd_odd_pt x0 (round beta fexp Zrnd_odd x0)
x:R
H0:0%R = x
0%R = 0%R \/
(Rnd_DN_pt format 0 0 \/ Rnd_UP_pt format 0 0) /\
(exists g : float beta,
   0%R = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
H:forall x0 : R,
(0 < x0)%R ->
Rnd_odd_pt x0 (round beta fexp Zrnd_odd x0)
x:R
(x < 0)%R -> Rnd_odd_pt x (round beta fexp Zrnd_odd x)
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
forall x : R,
(0 < x)%R -> Rnd_odd_pt x (round beta fexp Zrnd_odd x)
apply generic_format_0.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
H:forall x0 : R,
(0 < x0)%R ->
Rnd_odd_pt x0 (round beta fexp Zrnd_odd x0)
x:R
H0:0%R = x
0%R = 0%R \/
(Rnd_DN_pt format 0 0 \/ Rnd_UP_pt format 0 0) /\
(exists g : float beta,
   0%R = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
H:forall x0 : R,
(0 < x0)%R ->
Rnd_odd_pt x0 (round beta fexp Zrnd_odd x0)
x:R
(x < 0)%R -> Rnd_odd_pt x (round beta fexp Zrnd_odd x)
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
forall x : R,
(0 < x)%R -> Rnd_odd_pt x (round beta fexp Zrnd_odd x)
now left.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
H:forall x0 : R,
(0 < x0)%R ->
Rnd_odd_pt x0 (round beta fexp Zrnd_odd x0)
x:R
(x < 0)%R -> Rnd_odd_pt x (round beta fexp Zrnd_odd x)
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
forall x : R,
(0 < x)%R -> Rnd_odd_pt x (round beta fexp Zrnd_odd x)
intros Hx; apply Rnd_odd_pt_opp_inv.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
H:forall x0 : R,
(0 < x0)%R ->
Rnd_odd_pt x0 (round beta fexp Zrnd_odd x0)
x:R
Hx:(x < 0)%R
Rnd_odd_pt (- x) (- round beta fexp Zrnd_odd x)
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
forall x : R,
(0 < x)%R -> Rnd_odd_pt x (round beta fexp Zrnd_odd x)
rewrite <- round_odd_opp.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
H:forall x0 : R,
(0 < x0)%R ->
Rnd_odd_pt x0 (round beta fexp Zrnd_odd x0)
x:R
Hx:(x < 0)%R
Rnd_odd_pt (- x) (round beta fexp Zrnd_odd (- x))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
forall x : R,
(0 < x)%R -> Rnd_odd_pt x (round beta fexp Zrnd_odd x)
apply H.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
H:forall x0 : R,
(0 < x0)%R ->
Rnd_odd_pt x0 (round beta fexp Zrnd_odd x0)
x:R
Hx:(x < 0)%R
(0 < - x)%R
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
forall x : R,
(0 < x)%R -> Rnd_odd_pt x (round beta fexp Zrnd_odd x)
auto with real.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
forall x : R,
(0 < x)%R -> Rnd_odd_pt x (round beta fexp Zrnd_odd x)
(* *)
intros x Hxp.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
Rnd_odd_pt x (round beta fexp Zrnd_odd x)
generalize (generic_format_round beta fexp Zrnd_odd x).
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
format (round beta fexp Zrnd_odd x) ->
Rnd_odd_pt x (round beta fexp Zrnd_odd x)
set (o:=round beta fexp Zrnd_odd x).
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
format o -> Rnd_odd_pt x o
intros Ho.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Rnd_odd_pt x o
split.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
format o
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
o = x \/
(Rnd_DN_pt format x o \/ Rnd_UP_pt format x o) /\
(exists g : float beta,
   o = F2R g /\ canonical g /\ Z.even (Fnum g) = false)
assumption.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
o = x \/
(Rnd_DN_pt format x o \/ Rnd_UP_pt format x o) /\
(exists g : float beta,
   o = F2R g /\ canonical g /\ Z.even (Fnum g) = false)
(* *)
case (Req_dec o x); intros Hx.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o = x
o = x \/
(Rnd_DN_pt format x o \/ Rnd_UP_pt format x o) /\
(exists g : float beta,
   o = F2R g /\ canonical g /\ Z.even (Fnum g) = false)
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
o = x \/
(Rnd_DN_pt format x o \/ Rnd_UP_pt format x o) /\
(exists g : float beta,
   o = F2R g /\ canonical g /\ Z.even (Fnum g) = false)
now left.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
o = x \/
(Rnd_DN_pt format x o \/ Rnd_UP_pt format x o) /\
(exists g : float beta,
   o = F2R g /\ canonical g /\ Z.even (Fnum g) = false)
right.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
(Rnd_DN_pt format x o \/ Rnd_UP_pt format x o) /\
(exists g : float beta,
   o = F2R g /\ canonical g /\ Z.even (Fnum g) = false)
assert (o=round beta fexp Zfloor x \/ o=round beta fexp Zceil x).
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
(Rnd_DN_pt format x o \/ Rnd_UP_pt format x o) /\
(exists g : float beta,
   o = F2R g /\ canonical g /\ Z.even (Fnum g) = false)
unfold o, round, F2R;simpl.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
(IZR (Zrnd_odd (scaled_mantissa beta fexp x)) *
 bpow (cexp x))%R =
(IZR (Zfloor (scaled_mantissa beta fexp x)) *
 bpow (cexp x))%R \/
(IZR (Zrnd_odd (scaled_mantissa beta fexp x)) *
 bpow (cexp x))%R =
(IZR (Zceil (scaled_mantissa beta fexp x)) *
 bpow (cexp x))%R
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
(Rnd_DN_pt format x o \/ Rnd_UP_pt format x o) /\
(exists g : float beta,
   o = F2R g /\ canonical g /\ Z.even (Fnum g) = false)
case (Zrnd_DN_or_UP Zrnd_odd  (scaled_mantissa beta fexp x))...
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
Zrnd_odd (scaled_mantissa beta fexp x) =
Zfloor (scaled_mantissa beta fexp x) ->
(IZR (Zrnd_odd (scaled_mantissa beta fexp x)) *
 bpow (cexp x))%R =
(IZR (Zfloor (scaled_mantissa beta fexp x)) *
 bpow (cexp x))%R \/
(IZR (Zrnd_odd (scaled_mantissa beta fexp x)) *
 bpow (cexp x))%R =
(IZR (Zceil (scaled_mantissa beta fexp x)) *
 bpow (cexp x))%R
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
Zrnd_odd (scaled_mantissa beta fexp x) =
Zceil (scaled_mantissa beta fexp x) ->
(IZR (Zrnd_odd (scaled_mantissa beta fexp x)) *
 bpow (cexp x))%R =
(IZR (Zfloor (scaled_mantissa beta fexp x)) *
 bpow (cexp x))%R \/
(IZR (Zrnd_odd (scaled_mantissa beta fexp x)) *
 bpow (cexp x))%R =
(IZR (Zceil (scaled_mantissa beta fexp x)) *
 bpow (cexp x))%R
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
(Rnd_DN_pt format x o \/ Rnd_UP_pt format x o) /\
(exists g : float beta,
   o = F2R g /\ canonical g /\ Z.even (Fnum g) = false)
intros H; rewrite H; now left.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
Zrnd_odd (scaled_mantissa beta fexp x) =
Zceil (scaled_mantissa beta fexp x) ->
(IZR (Zrnd_odd (scaled_mantissa beta fexp x)) *
 bpow (cexp x))%R =
(IZR (Zfloor (scaled_mantissa beta fexp x)) *
 bpow (cexp x))%R \/
(IZR (Zrnd_odd (scaled_mantissa beta fexp x)) *
 bpow (cexp x))%R =
(IZR (Zceil (scaled_mantissa beta fexp x)) *
 bpow (cexp x))%R
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
(Rnd_DN_pt format x o \/ Rnd_UP_pt format x o) /\
(exists g : float beta,
   o = F2R g /\ canonical g /\ Z.even (Fnum g) = false)
intros H; rewrite H; now right.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
(Rnd_DN_pt format x o \/ Rnd_UP_pt format x o) /\
(exists g : float beta,
   o = F2R g /\ canonical g /\ Z.even (Fnum g) = false)
split.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
Rnd_DN_pt format x o \/ Rnd_UP_pt format x o
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
exists g : float beta,
  o = F2R g /\ canonical g /\ Z.even (Fnum g) = false
destruct H; rewrite H.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x
Rnd_DN_pt format x (round beta fexp Zfloor x) \/
Rnd_UP_pt format x (round beta fexp Zfloor x)
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zceil x
Rnd_DN_pt format x (round beta fexp Zceil x) \/
Rnd_UP_pt format x (round beta fexp Zceil x)
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
exists g : float beta,
  o = F2R g /\ canonical g /\ Z.even (Fnum g) = false
left; apply round_DN_pt...
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zceil x
Rnd_DN_pt format x (round beta fexp Zceil x) \/
Rnd_UP_pt format x (round beta fexp Zceil x)
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
exists g : float beta,
  o = F2R g /\ canonical g /\ Z.even (Fnum g) = false
right; apply round_UP_pt...
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
exists g : float beta,
  o = F2R g /\ canonical g /\ Z.even (Fnum g) = false
(* *)
unfold o, Zrnd_odd, round.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
exists g : float beta,
  F2R
    {|
    Fnum := if
             Req_EM_T (scaled_mantissa beta fexp x)
               (IZR
                  (Zfloor
                     (scaled_mantissa beta fexp x)))
            then Zfloor (scaled_mantissa beta fexp x)
            else
             if
              Z.even
                (Zfloor (scaled_mantissa beta fexp x))
             then Zceil (scaled_mantissa beta fexp x)
             else Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
case (Req_EM_T (scaled_mantissa beta fexp x)
     (IZR (Zfloor (scaled_mantissa beta fexp x)))).
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
scaled_mantissa beta fexp x =
IZR (Zfloor (scaled_mantissa beta fexp x)) ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x)) ->
exists g : float beta,
  F2R
    {|
    Fnum := if
             Z.even
               (Zfloor (scaled_mantissa beta fexp x))
            then Zceil (scaled_mantissa beta fexp x)
            else Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
intros T.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
T:scaled_mantissa beta fexp x =
IZR (Zfloor (scaled_mantissa beta fexp x))
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x)) ->
exists g : float beta,
  F2R
    {|
    Fnum := if
             Z.even
               (Zfloor (scaled_mantissa beta fexp x))
            then Zceil (scaled_mantissa beta fexp x)
            else Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
absurd (o=x); trivial.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
T:scaled_mantissa beta fexp x =
IZR (Zfloor (scaled_mantissa beta fexp x))
o = x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x)) ->
exists g : float beta,
  F2R
    {|
    Fnum := if
             Z.even
               (Zfloor (scaled_mantissa beta fexp x))
            then Zceil (scaled_mantissa beta fexp x)
            else Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
apply round_generic...
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
T:scaled_mantissa beta fexp x =
IZR (Zfloor (scaled_mantissa beta fexp x))
format x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x)) ->
exists g : float beta,
  F2R
    {|
    Fnum := if
             Z.even
               (Zfloor (scaled_mantissa beta fexp x))
            then Zceil (scaled_mantissa beta fexp x)
            else Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
unfold generic_format, F2R; simpl.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
T:scaled_mantissa beta fexp x =
IZR (Zfloor (scaled_mantissa beta fexp x))
x =
(IZR (Ztrunc (scaled_mantissa beta fexp x)) *
 bpow (cexp x))%R
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x)) ->
exists g : float beta,
  F2R
    {|
    Fnum := if
             Z.even
               (Zfloor (scaled_mantissa beta fexp x))
            then Zceil (scaled_mantissa beta fexp x)
            else Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
rewrite <- (scaled_mantissa_mult_bpow beta fexp) at 1.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
T:scaled_mantissa beta fexp x =
IZR (Zfloor (scaled_mantissa beta fexp x))
(scaled_mantissa beta fexp x * bpow (cexp x))%R =
(IZR (Ztrunc (scaled_mantissa beta fexp x)) *
 bpow (cexp x))%R
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x)) ->
exists g : float beta,
  F2R
    {|
    Fnum := if
             Z.even
               (Zfloor (scaled_mantissa beta fexp x))
            then Zceil (scaled_mantissa beta fexp x)
            else Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
apply f_equal2; trivial; rewrite T at 1.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
T:scaled_mantissa beta fexp x =
IZR (Zfloor (scaled_mantissa beta fexp x))
IZR (Zfloor (scaled_mantissa beta fexp x)) =
IZR (Ztrunc (scaled_mantissa beta fexp x))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x)) ->
exists g : float beta,
  F2R
    {|
    Fnum := if
             Z.even
               (Zfloor (scaled_mantissa beta fexp x))
            then Zceil (scaled_mantissa beta fexp x)
            else Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
apply f_equal, sym_eq, Ztrunc_floor.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
T:scaled_mantissa beta fexp x =
IZR (Zfloor (scaled_mantissa beta fexp x))
(0 <= scaled_mantissa beta fexp x)%R
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x)) ->
exists g : float beta,
  F2R
    {|
    Fnum := if
             Z.even
               (Zfloor (scaled_mantissa beta fexp x))
            then Zceil (scaled_mantissa beta fexp x)
            else Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
apply Rmult_le_pos.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
T:scaled_mantissa beta fexp x =
IZR (Zfloor (scaled_mantissa beta fexp x))
(0 <= x)%R
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
T:scaled_mantissa beta fexp x =
IZR (Zfloor (scaled_mantissa beta fexp x))
(0 <= bpow (- cexp x))%R
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x)) ->
exists g : float beta,
  F2R
    {|
    Fnum := if
             Z.even
               (Zfloor (scaled_mantissa beta fexp x))
            then Zceil (scaled_mantissa beta fexp x)
            else Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
now left.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
T:scaled_mantissa beta fexp x =
IZR (Zfloor (scaled_mantissa beta fexp x))
(0 <= bpow (- cexp x))%R
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x)) ->
exists g : float beta,
  F2R
    {|
    Fnum := if
             Z.even
               (Zfloor (scaled_mantissa beta fexp x))
            then Zceil (scaled_mantissa beta fexp x)
            else Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
apply bpow_ge_0.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x)) ->
exists g : float beta,
  F2R
    {|
    Fnum := if
             Z.even
               (Zfloor (scaled_mantissa beta fexp x))
            then Zceil (scaled_mantissa beta fexp x)
            else Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
intros L.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
exists g : float beta,
  F2R
    {|
    Fnum := if
             Z.even
               (Zfloor (scaled_mantissa beta fexp x))
            then Zceil (scaled_mantissa beta fexp x)
            else Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
case_eq (Z.even (Zfloor (scaled_mantissa beta fexp x))).
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = true ->
exists g : float beta,
  F2R
    {|
    Fnum := Zceil (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
(* . *)
generalize (generic_format_round beta fexp Zceil x).
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
format (round beta fexp Zceil x) ->
Z.even (Zfloor (scaled_mantissa beta fexp x)) = true ->
exists g : float beta,
  F2R
    {|
    Fnum := Zceil (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
unfold generic_format.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
round beta fexp Zceil x =
F2R
  {|
  Fnum := Ztrunc
            (scaled_mantissa beta fexp
               (round beta fexp Zceil x));
  Fexp := cexp (round beta fexp Zceil x) |} ->
Z.even (Zfloor (scaled_mantissa beta fexp x)) = true ->
exists g : float beta,
  F2R
    {|
    Fnum := Zceil (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
set (f:=round beta fexp Zceil x).
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
f =
F2R
  {|
  Fnum := Ztrunc (scaled_mantissa beta fexp f);
  Fexp := cexp f |} ->
Z.even (Zfloor (scaled_mantissa beta fexp x)) = true ->
exists g : float beta,
  F2R
    {|
    Fnum := Zceil (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
set (ef := cexp f).
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
f =
F2R
  {|
  Fnum := Ztrunc (scaled_mantissa beta fexp f);
  Fexp := ef |} ->
Z.even (Zfloor (scaled_mantissa beta fexp x)) = true ->
exists g : float beta,
  F2R
    {|
    Fnum := Zceil (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
set (mf := Ztrunc (scaled_mantissa beta fexp f)).
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
f = F2R {| Fnum := mf; Fexp := ef |} ->
Z.even (Zfloor (scaled_mantissa beta fexp x)) = true ->
exists g : float beta,
  F2R
    {|
    Fnum := Zceil (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
exists (Float beta mf ef).
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
F2R
  {|
  Fnum := Zceil (scaled_mantissa beta fexp x);
  Fexp := cexp x |} = F2R {| Fnum := mf; Fexp := ef |} /\
canonical {| Fnum := mf; Fexp := ef |} /\
Z.even (Fnum {| Fnum := mf; Fexp := ef |}) = false
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
unfold canonical.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
F2R
  {|
  Fnum := Zceil (scaled_mantissa beta fexp x);
  Fexp := cexp x |} = F2R {| Fnum := mf; Fexp := ef |} /\
Fexp {| Fnum := mf; Fexp := ef |} =
cexp (F2R {| Fnum := mf; Fexp := ef |}) /\
Z.even (Fnum {| Fnum := mf; Fexp := ef |}) = false
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
rewrite <- H0.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
F2R
  {|
  Fnum := Zceil (scaled_mantissa beta fexp x);
  Fexp := cexp x |} = f /\
Fexp {| Fnum := mf; Fexp := ef |} = cexp f /\
Z.even (Fnum {| Fnum := mf; Fexp := ef |}) = false
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
repeat split; try assumption.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Z.even (Fnum {| Fnum := mf; Fexp := ef |}) = false
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
apply trans_eq with (negb (Z.even (Zfloor (scaled_mantissa beta fexp x)))).
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Z.even (Fnum {| Fnum := mf; Fexp := ef |}) =
negb (Z.even (Zfloor (scaled_mantissa beta fexp x)))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
negb (Z.even (Zfloor (scaled_mantissa beta fexp x))) =
false
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
2: rewrite H1; reflexivity.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Z.even (Fnum {| Fnum := mf; Fexp := ef |}) =
negb (Z.even (Zfloor (scaled_mantissa beta fexp x)))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
apply trans_eq with (negb (Z.even (Fnum
  (Float beta  (Zfloor (scaled_mantissa beta fexp x)) (cexp x))))).
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Z.even (Fnum {| Fnum := mf; Fexp := ef |}) =
negb
  (Z.even
     (Fnum
        {|
        Fnum := Zfloor (scaled_mantissa beta fexp x);
        Fexp := cexp x |}))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
negb
  (Z.even
     (Fnum
        {|
        Fnum := Zfloor (scaled_mantissa beta fexp x);
        Fexp := cexp x |})) =
negb (Z.even (Zfloor (scaled_mantissa beta fexp x)))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
2: reflexivity.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Z.even (Fnum {| Fnum := mf; Fexp := ef |}) =
negb
  (Z.even
     (Fnum
        {|
        Fnum := Zfloor (scaled_mantissa beta fexp x);
        Fexp := cexp x |}))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
case (Rle_lt_or_eq_dec 0 (round beta fexp Zfloor x)).
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
(0 <= round beta fexp Zfloor x)%R
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
(0 < round beta fexp Zfloor x)%R ->
Z.even (Fnum {| Fnum := mf; Fexp := ef |}) =
negb
  (Z.even
     (Fnum
        {|
        Fnum := Zfloor (scaled_mantissa beta fexp x);
        Fexp := cexp x |}))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
0%R = round beta fexp Zfloor x ->
Z.even (Fnum {| Fnum := mf; Fexp := ef |}) =
negb
  (Z.even
     (Fnum
        {|
        Fnum := Zfloor (scaled_mantissa beta fexp x);
        Fexp := cexp x |}))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
rewrite <- round_0 with beta fexp Zfloor...
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
(round beta fexp Zfloor 0 <= round beta fexp Zfloor x)%R
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
(0 < round beta fexp Zfloor x)%R ->
Z.even (Fnum {| Fnum := mf; Fexp := ef |}) =
negb
  (Z.even
     (Fnum
        {|
        Fnum := Zfloor (scaled_mantissa beta fexp x);
        Fexp := cexp x |}))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
0%R = round beta fexp Zfloor x ->
Z.even (Fnum {| Fnum := mf; Fexp := ef |}) =
negb
  (Z.even
     (Fnum
        {|
        Fnum := Zfloor (scaled_mantissa beta fexp x);
        Fexp := cexp x |}))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
apply round_le...
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
(0 <= x)%R
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
(0 < round beta fexp Zfloor x)%R ->
Z.even (Fnum {| Fnum := mf; Fexp := ef |}) =
negb
  (Z.even
     (Fnum
        {|
        Fnum := Zfloor (scaled_mantissa beta fexp x);
        Fexp := cexp x |}))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
0%R = round beta fexp Zfloor x ->
Z.even (Fnum {| Fnum := mf; Fexp := ef |}) =
negb
  (Z.even
     (Fnum
        {|
        Fnum := Zfloor (scaled_mantissa beta fexp x);
        Fexp := cexp x |}))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
now left.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
(0 < round beta fexp Zfloor x)%R ->
Z.even (Fnum {| Fnum := mf; Fexp := ef |}) =
negb
  (Z.even
     (Fnum
        {|
        Fnum := Zfloor (scaled_mantissa beta fexp x);
        Fexp := cexp x |}))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
0%R = round beta fexp Zfloor x ->
Z.even (Fnum {| Fnum := mf; Fexp := ef |}) =
negb
  (Z.even
     (Fnum
        {|
        Fnum := Zfloor (scaled_mantissa beta fexp x);
        Fexp := cexp x |}))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
intros Y.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
Z.even (Fnum {| Fnum := mf; Fexp := ef |}) =
negb
  (Z.even
     (Fnum
        {|
        Fnum := Zfloor (scaled_mantissa beta fexp x);
        Fexp := cexp x |}))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
0%R = round beta fexp Zfloor x ->
Z.even (Fnum {| Fnum := mf; Fexp := ef |}) =
negb
  (Z.even
     (Fnum
        {|
        Fnum := Zfloor (scaled_mantissa beta fexp x);
        Fexp := cexp x |}))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
generalize (DN_UP_parity_generic beta fexp)...
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
DN_UP_parity_prop beta fexp ->
Z.even (Fnum {| Fnum := mf; Fexp := ef |}) =
negb
  (Z.even
     (Fnum
        {|
        Fnum := Zfloor (scaled_mantissa beta fexp x);
        Fexp := cexp x |}))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
0%R = round beta fexp Zfloor x ->
Z.even (Fnum {| Fnum := mf; Fexp := ef |}) =
negb
  (Z.even
     (Fnum
        {|
        Fnum := Zfloor (scaled_mantissa beta fexp x);
        Fexp := cexp x |}))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
unfold DN_UP_parity_prop.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
(forall (x0 : R) (xd xu : float beta),
 ~ format x0 ->
 canonical xd ->
 canonical xu ->
 F2R xd = round beta fexp Zfloor x0 ->
 F2R xu = round beta fexp Zceil x0 ->
 Z.even (Fnum xu) = negb (Z.even (Fnum xd))) ->
Z.even (Fnum {| Fnum := mf; Fexp := ef |}) =
negb
  (Z.even
     (Fnum
        {|
        Fnum := Zfloor (scaled_mantissa beta fexp x);
        Fexp := cexp x |}))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
0%R = round beta fexp Zfloor x ->
Z.even (Fnum {| Fnum := mf; Fexp := ef |}) =
negb
  (Z.even
     (Fnum
        {|
        Fnum := Zfloor (scaled_mantissa beta fexp x);
        Fexp := cexp x |}))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
intros T; apply T with x; clear T.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
~ format x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
canonical
  {|
  Fnum := Zfloor (scaled_mantissa beta fexp x);
  Fexp := cexp x |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
canonical {| Fnum := mf; Fexp := ef |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
F2R
  {|
  Fnum := Zfloor (scaled_mantissa beta fexp x);
  Fexp := cexp x |} = round beta fexp Zfloor x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
F2R {| Fnum := mf; Fexp := ef |} =
round beta fexp Zceil x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
0%R = round beta fexp Zfloor x ->
Z.even (Fnum {| Fnum := mf; Fexp := ef |}) =
negb
  (Z.even
     (Fnum
        {|
        Fnum := Zfloor (scaled_mantissa beta fexp x);
        Fexp := cexp x |}))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
unfold generic_format.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
x <>
F2R
  {|
  Fnum := Ztrunc (scaled_mantissa beta fexp x);
  Fexp := cexp x |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
canonical
  {|
  Fnum := Zfloor (scaled_mantissa beta fexp x);
  Fexp := cexp x |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
canonical {| Fnum := mf; Fexp := ef |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
F2R
  {|
  Fnum := Zfloor (scaled_mantissa beta fexp x);
  Fexp := cexp x |} = round beta fexp Zfloor x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
F2R {| Fnum := mf; Fexp := ef |} =
round beta fexp Zceil x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
0%R = round beta fexp Zfloor x ->
Z.even (Fnum {| Fnum := mf; Fexp := ef |}) =
negb
  (Z.even
     (Fnum
        {|
        Fnum := Zfloor (scaled_mantissa beta fexp x);
        Fexp := cexp x |}))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
rewrite <- (scaled_mantissa_mult_bpow beta fexp x) at 1.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
(scaled_mantissa beta fexp x * bpow (cexp x))%R <>
F2R
  {|
  Fnum := Ztrunc (scaled_mantissa beta fexp x);
  Fexp := cexp x |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
canonical
  {|
  Fnum := Zfloor (scaled_mantissa beta fexp x);
  Fexp := cexp x |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
canonical {| Fnum := mf; Fexp := ef |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
F2R
  {|
  Fnum := Zfloor (scaled_mantissa beta fexp x);
  Fexp := cexp x |} = round beta fexp Zfloor x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
F2R {| Fnum := mf; Fexp := ef |} =
round beta fexp Zceil x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
0%R = round beta fexp Zfloor x ->
Z.even (Fnum {| Fnum := mf; Fexp := ef |}) =
negb
  (Z.even
     (Fnum
        {|
        Fnum := Zfloor (scaled_mantissa beta fexp x);
        Fexp := cexp x |}))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
unfold F2R; simpl.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
(scaled_mantissa beta fexp x * bpow (cexp x))%R <>
(IZR (Ztrunc (scaled_mantissa beta fexp x)) *
 bpow (cexp x))%R
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
canonical
  {|
  Fnum := Zfloor (scaled_mantissa beta fexp x);
  Fexp := cexp x |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
canonical {| Fnum := mf; Fexp := ef |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
F2R
  {|
  Fnum := Zfloor (scaled_mantissa beta fexp x);
  Fexp := cexp x |} = round beta fexp Zfloor x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
F2R {| Fnum := mf; Fexp := ef |} =
round beta fexp Zceil x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
0%R = round beta fexp Zfloor x ->
Z.even (Fnum {| Fnum := mf; Fexp := ef |}) =
negb
  (Z.even
     (Fnum
        {|
        Fnum := Zfloor (scaled_mantissa beta fexp x);
        Fexp := cexp x |}))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
apply Rmult_neq_compat_r.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
bpow (cexp x) <> 0%R
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
scaled_mantissa beta fexp x <>
IZR (Ztrunc (scaled_mantissa beta fexp x))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
canonical
  {|
  Fnum := Zfloor (scaled_mantissa beta fexp x);
  Fexp := cexp x |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
canonical {| Fnum := mf; Fexp := ef |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
F2R
  {|
  Fnum := Zfloor (scaled_mantissa beta fexp x);
  Fexp := cexp x |} = round beta fexp Zfloor x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
F2R {| Fnum := mf; Fexp := ef |} =
round beta fexp Zceil x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
0%R = round beta fexp Zfloor x ->
Z.even (Fnum {| Fnum := mf; Fexp := ef |}) =
negb
  (Z.even
     (Fnum
        {|
        Fnum := Zfloor (scaled_mantissa beta fexp x);
        Fexp := cexp x |}))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
apply Rgt_not_eq, bpow_gt_0.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
scaled_mantissa beta fexp x <>
IZR (Ztrunc (scaled_mantissa beta fexp x))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
canonical
  {|
  Fnum := Zfloor (scaled_mantissa beta fexp x);
  Fexp := cexp x |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
canonical {| Fnum := mf; Fexp := ef |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
F2R
  {|
  Fnum := Zfloor (scaled_mantissa beta fexp x);
  Fexp := cexp x |} = round beta fexp Zfloor x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
F2R {| Fnum := mf; Fexp := ef |} =
round beta fexp Zceil x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
0%R = round beta fexp Zfloor x ->
Z.even (Fnum {| Fnum := mf; Fexp := ef |}) =
negb
  (Z.even
     (Fnum
        {|
        Fnum := Zfloor (scaled_mantissa beta fexp x);
        Fexp := cexp x |}))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
rewrite Ztrunc_floor.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
(0 <= scaled_mantissa beta fexp x)%R
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
canonical
  {|
  Fnum := Zfloor (scaled_mantissa beta fexp x);
  Fexp := cexp x |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
canonical {| Fnum := mf; Fexp := ef |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
F2R
  {|
  Fnum := Zfloor (scaled_mantissa beta fexp x);
  Fexp := cexp x |} = round beta fexp Zfloor x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
F2R {| Fnum := mf; Fexp := ef |} =
round beta fexp Zceil x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
0%R = round beta fexp Zfloor x ->
Z.even (Fnum {| Fnum := mf; Fexp := ef |}) =
negb
  (Z.even
     (Fnum
        {|
        Fnum := Zfloor (scaled_mantissa beta fexp x);
        Fexp := cexp x |}))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
assumption.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
(0 <= scaled_mantissa beta fexp x)%R
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
canonical
  {|
  Fnum := Zfloor (scaled_mantissa beta fexp x);
  Fexp := cexp x |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
canonical {| Fnum := mf; Fexp := ef |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
F2R
  {|
  Fnum := Zfloor (scaled_mantissa beta fexp x);
  Fexp := cexp x |} = round beta fexp Zfloor x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
F2R {| Fnum := mf; Fexp := ef |} =
round beta fexp Zceil x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
0%R = round beta fexp Zfloor x ->
Z.even (Fnum {| Fnum := mf; Fexp := ef |}) =
negb
  (Z.even
     (Fnum
        {|
        Fnum := Zfloor (scaled_mantissa beta fexp x);
        Fexp := cexp x |}))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
apply Rmult_le_pos.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
(0 <= x)%R
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
(0 <= bpow (- cexp x))%R
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
canonical
  {|
  Fnum := Zfloor (scaled_mantissa beta fexp x);
  Fexp := cexp x |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
canonical {| Fnum := mf; Fexp := ef |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
F2R
  {|
  Fnum := Zfloor (scaled_mantissa beta fexp x);
  Fexp := cexp x |} = round beta fexp Zfloor x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
F2R {| Fnum := mf; Fexp := ef |} =
round beta fexp Zceil x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
0%R = round beta fexp Zfloor x ->
Z.even (Fnum {| Fnum := mf; Fexp := ef |}) =
negb
  (Z.even
     (Fnum
        {|
        Fnum := Zfloor (scaled_mantissa beta fexp x);
        Fexp := cexp x |}))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
now left.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
(0 <= bpow (- cexp x))%R
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
canonical
  {|
  Fnum := Zfloor (scaled_mantissa beta fexp x);
  Fexp := cexp x |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
canonical {| Fnum := mf; Fexp := ef |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
F2R
  {|
  Fnum := Zfloor (scaled_mantissa beta fexp x);
  Fexp := cexp x |} = round beta fexp Zfloor x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
F2R {| Fnum := mf; Fexp := ef |} =
round beta fexp Zceil x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
0%R = round beta fexp Zfloor x ->
Z.even (Fnum {| Fnum := mf; Fexp := ef |}) =
negb
  (Z.even
     (Fnum
        {|
        Fnum := Zfloor (scaled_mantissa beta fexp x);
        Fexp := cexp x |}))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
apply bpow_ge_0.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
canonical
  {|
  Fnum := Zfloor (scaled_mantissa beta fexp x);
  Fexp := cexp x |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
canonical {| Fnum := mf; Fexp := ef |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
F2R
  {|
  Fnum := Zfloor (scaled_mantissa beta fexp x);
  Fexp := cexp x |} = round beta fexp Zfloor x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
F2R {| Fnum := mf; Fexp := ef |} =
round beta fexp Zceil x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
0%R = round beta fexp Zfloor x ->
Z.even (Fnum {| Fnum := mf; Fexp := ef |}) =
negb
  (Z.even
     (Fnum
        {|
        Fnum := Zfloor (scaled_mantissa beta fexp x);
        Fexp := cexp x |}))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
unfold canonical.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
Fexp
  {|
  Fnum := Zfloor (scaled_mantissa beta fexp x);
  Fexp := cexp x |} =
cexp
  (F2R
     {|
     Fnum := Zfloor (scaled_mantissa beta fexp x);
     Fexp := cexp x |})
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
canonical {| Fnum := mf; Fexp := ef |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
F2R
  {|
  Fnum := Zfloor (scaled_mantissa beta fexp x);
  Fexp := cexp x |} = round beta fexp Zfloor x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
F2R {| Fnum := mf; Fexp := ef |} =
round beta fexp Zceil x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
0%R = round beta fexp Zfloor x ->
Z.even (Fnum {| Fnum := mf; Fexp := ef |}) =
negb
  (Z.even
     (Fnum
        {|
        Fnum := Zfloor (scaled_mantissa beta fexp x);
        Fexp := cexp x |}))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
simpl.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
cexp x =
cexp
  (F2R
     {|
     Fnum := Zfloor (scaled_mantissa beta fexp x);
     Fexp := cexp x |})
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
canonical {| Fnum := mf; Fexp := ef |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
F2R
  {|
  Fnum := Zfloor (scaled_mantissa beta fexp x);
  Fexp := cexp x |} = round beta fexp Zfloor x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
F2R {| Fnum := mf; Fexp := ef |} =
round beta fexp Zceil x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
0%R = round beta fexp Zfloor x ->
Z.even (Fnum {| Fnum := mf; Fexp := ef |}) =
negb
  (Z.even
     (Fnum
        {|
        Fnum := Zfloor (scaled_mantissa beta fexp x);
        Fexp := cexp x |}))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
apply sym_eq, cexp_DN...
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
canonical {| Fnum := mf; Fexp := ef |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
F2R
  {|
  Fnum := Zfloor (scaled_mantissa beta fexp x);
  Fexp := cexp x |} = round beta fexp Zfloor x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
F2R {| Fnum := mf; Fexp := ef |} =
round beta fexp Zceil x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
0%R = round beta fexp Zfloor x ->
Z.even (Fnum {| Fnum := mf; Fexp := ef |}) =
negb
  (Z.even
     (Fnum
        {|
        Fnum := Zfloor (scaled_mantissa beta fexp x);
        Fexp := cexp x |}))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
unfold canonical.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
Fexp {| Fnum := mf; Fexp := ef |} =
cexp (F2R {| Fnum := mf; Fexp := ef |})
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
F2R
  {|
  Fnum := Zfloor (scaled_mantissa beta fexp x);
  Fexp := cexp x |} = round beta fexp Zfloor x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
F2R {| Fnum := mf; Fexp := ef |} =
round beta fexp Zceil x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
0%R = round beta fexp Zfloor x ->
Z.even (Fnum {| Fnum := mf; Fexp := ef |}) =
negb
  (Z.even
     (Fnum
        {|
        Fnum := Zfloor (scaled_mantissa beta fexp x);
        Fexp := cexp x |}))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
rewrite <- H0; reflexivity.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
F2R
  {|
  Fnum := Zfloor (scaled_mantissa beta fexp x);
  Fexp := cexp x |} = round beta fexp Zfloor x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
F2R {| Fnum := mf; Fexp := ef |} =
round beta fexp Zceil x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
0%R = round beta fexp Zfloor x ->
Z.even (Fnum {| Fnum := mf; Fexp := ef |}) =
negb
  (Z.even
     (Fnum
        {|
        Fnum := Zfloor (scaled_mantissa beta fexp x);
        Fexp := cexp x |}))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
reflexivity.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
F2R {| Fnum := mf; Fexp := ef |} =
round beta fexp Zceil x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
0%R = round beta fexp Zfloor x ->
Z.even (Fnum {| Fnum := mf; Fexp := ef |}) =
negb
  (Z.even
     (Fnum
        {|
        Fnum := Zfloor (scaled_mantissa beta fexp x);
        Fexp := cexp x |}))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
apply trans_eq with (round beta fexp Ztrunc (round beta fexp Zceil x)).
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
F2R {| Fnum := mf; Fexp := ef |} =
round beta fexp Ztrunc (round beta fexp Zceil x)
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
round beta fexp Ztrunc (round beta fexp Zceil x) =
round beta fexp Zceil x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
0%R = round beta fexp Zfloor x ->
Z.even (Fnum {| Fnum := mf; Fexp := ef |}) =
negb
  (Z.even
     (Fnum
        {|
        Fnum := Zfloor (scaled_mantissa beta fexp x);
        Fexp := cexp x |}))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
reflexivity.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:(0 < round beta fexp Zfloor x)%R
round beta fexp Ztrunc (round beta fexp Zceil x) =
round beta fexp Zceil x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
0%R = round beta fexp Zfloor x ->
Z.even (Fnum {| Fnum := mf; Fexp := ef |}) =
negb
  (Z.even
     (Fnum
        {|
        Fnum := Zfloor (scaled_mantissa beta fexp x);
        Fexp := cexp x |}))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
apply round_generic...
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
0%R = round beta fexp Zfloor x ->
Z.even (Fnum {| Fnum := mf; Fexp := ef |}) =
negb
  (Z.even
     (Fnum
        {|
        Fnum := Zfloor (scaled_mantissa beta fexp x);
        Fexp := cexp x |}))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
intros Y.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
Z.even (Fnum {| Fnum := mf; Fexp := ef |}) =
negb
  (Z.even
     (Fnum
        {|
        Fnum := Zfloor (scaled_mantissa beta fexp x);
        Fexp := cexp x |}))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
replace  (Fnum {| Fnum := Zfloor (scaled_mantissa beta fexp x); Fexp := cexp x |})
   with (Fnum (Float beta 0 (fexp (mag beta 0)))).
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
Z.even (Fnum {| Fnum := mf; Fexp := ef |}) =
negb
  (Z.even
     (Fnum {| Fnum := 0; Fexp := fexp (mag beta 0) |}))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
Fnum {| Fnum := 0; Fexp := fexp (mag beta 0) |} =
Fnum
  {|
  Fnum := Zfloor (scaled_mantissa beta fexp x);
  Fexp := cexp x |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
generalize (DN_UP_parity_generic beta fexp)...
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
DN_UP_parity_prop beta fexp ->
Z.even (Fnum {| Fnum := mf; Fexp := ef |}) =
negb
  (Z.even
     (Fnum {| Fnum := 0; Fexp := fexp (mag beta 0) |}))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
Fnum {| Fnum := 0; Fexp := fexp (mag beta 0) |} =
Fnum
  {|
  Fnum := Zfloor (scaled_mantissa beta fexp x);
  Fexp := cexp x |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
unfold DN_UP_parity_prop.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
(forall (x0 : R) (xd xu : float beta),
 ~ format x0 ->
 canonical xd ->
 canonical xu ->
 F2R xd = round beta fexp Zfloor x0 ->
 F2R xu = round beta fexp Zceil x0 ->
 Z.even (Fnum xu) = negb (Z.even (Fnum xd))) ->
Z.even (Fnum {| Fnum := mf; Fexp := ef |}) =
negb
  (Z.even
     (Fnum {| Fnum := 0; Fexp := fexp (mag beta 0) |}))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
Fnum {| Fnum := 0; Fexp := fexp (mag beta 0) |} =
Fnum
  {|
  Fnum := Zfloor (scaled_mantissa beta fexp x);
  Fexp := cexp x |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
intros T; apply T with x; clear T.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
~ format x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
canonical {| Fnum := 0; Fexp := fexp (mag beta 0) |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
canonical {| Fnum := mf; Fexp := ef |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
F2R {| Fnum := 0; Fexp := fexp (mag beta 0) |} =
round beta fexp Zfloor x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
F2R {| Fnum := mf; Fexp := ef |} =
round beta fexp Zceil x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
Fnum {| Fnum := 0; Fexp := fexp (mag beta 0) |} =
Fnum
  {|
  Fnum := Zfloor (scaled_mantissa beta fexp x);
  Fexp := cexp x |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
unfold generic_format.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
x <>
F2R
  {|
  Fnum := Ztrunc (scaled_mantissa beta fexp x);
  Fexp := cexp x |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
canonical {| Fnum := 0; Fexp := fexp (mag beta 0) |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
canonical {| Fnum := mf; Fexp := ef |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
F2R {| Fnum := 0; Fexp := fexp (mag beta 0) |} =
round beta fexp Zfloor x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
F2R {| Fnum := mf; Fexp := ef |} =
round beta fexp Zceil x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
Fnum {| Fnum := 0; Fexp := fexp (mag beta 0) |} =
Fnum
  {|
  Fnum := Zfloor (scaled_mantissa beta fexp x);
  Fexp := cexp x |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
rewrite <- (scaled_mantissa_mult_bpow beta fexp x) at 1.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
(scaled_mantissa beta fexp x * bpow (cexp x))%R <>
F2R
  {|
  Fnum := Ztrunc (scaled_mantissa beta fexp x);
  Fexp := cexp x |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
canonical {| Fnum := 0; Fexp := fexp (mag beta 0) |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
canonical {| Fnum := mf; Fexp := ef |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
F2R {| Fnum := 0; Fexp := fexp (mag beta 0) |} =
round beta fexp Zfloor x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
F2R {| Fnum := mf; Fexp := ef |} =
round beta fexp Zceil x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
Fnum {| Fnum := 0; Fexp := fexp (mag beta 0) |} =
Fnum
  {|
  Fnum := Zfloor (scaled_mantissa beta fexp x);
  Fexp := cexp x |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
unfold F2R; simpl.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
(scaled_mantissa beta fexp x * bpow (cexp x))%R <>
(IZR (Ztrunc (scaled_mantissa beta fexp x)) *
 bpow (cexp x))%R
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
canonical {| Fnum := 0; Fexp := fexp (mag beta 0) |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
canonical {| Fnum := mf; Fexp := ef |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
F2R {| Fnum := 0; Fexp := fexp (mag beta 0) |} =
round beta fexp Zfloor x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
F2R {| Fnum := mf; Fexp := ef |} =
round beta fexp Zceil x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
Fnum {| Fnum := 0; Fexp := fexp (mag beta 0) |} =
Fnum
  {|
  Fnum := Zfloor (scaled_mantissa beta fexp x);
  Fexp := cexp x |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
apply Rmult_neq_compat_r.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
bpow (cexp x) <> 0%R
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
scaled_mantissa beta fexp x <>
IZR (Ztrunc (scaled_mantissa beta fexp x))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
canonical {| Fnum := 0; Fexp := fexp (mag beta 0) |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
canonical {| Fnum := mf; Fexp := ef |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
F2R {| Fnum := 0; Fexp := fexp (mag beta 0) |} =
round beta fexp Zfloor x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
F2R {| Fnum := mf; Fexp := ef |} =
round beta fexp Zceil x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
Fnum {| Fnum := 0; Fexp := fexp (mag beta 0) |} =
Fnum
  {|
  Fnum := Zfloor (scaled_mantissa beta fexp x);
  Fexp := cexp x |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
apply Rgt_not_eq, bpow_gt_0.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
scaled_mantissa beta fexp x <>
IZR (Ztrunc (scaled_mantissa beta fexp x))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
canonical {| Fnum := 0; Fexp := fexp (mag beta 0) |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
canonical {| Fnum := mf; Fexp := ef |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
F2R {| Fnum := 0; Fexp := fexp (mag beta 0) |} =
round beta fexp Zfloor x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
F2R {| Fnum := mf; Fexp := ef |} =
round beta fexp Zceil x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
Fnum {| Fnum := 0; Fexp := fexp (mag beta 0) |} =
Fnum
  {|
  Fnum := Zfloor (scaled_mantissa beta fexp x);
  Fexp := cexp x |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
rewrite Ztrunc_floor.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
(0 <= scaled_mantissa beta fexp x)%R
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
canonical {| Fnum := 0; Fexp := fexp (mag beta 0) |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
canonical {| Fnum := mf; Fexp := ef |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
F2R {| Fnum := 0; Fexp := fexp (mag beta 0) |} =
round beta fexp Zfloor x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
F2R {| Fnum := mf; Fexp := ef |} =
round beta fexp Zceil x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
Fnum {| Fnum := 0; Fexp := fexp (mag beta 0) |} =
Fnum
  {|
  Fnum := Zfloor (scaled_mantissa beta fexp x);
  Fexp := cexp x |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
assumption.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
(0 <= scaled_mantissa beta fexp x)%R
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
canonical {| Fnum := 0; Fexp := fexp (mag beta 0) |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
canonical {| Fnum := mf; Fexp := ef |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
F2R {| Fnum := 0; Fexp := fexp (mag beta 0) |} =
round beta fexp Zfloor x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
F2R {| Fnum := mf; Fexp := ef |} =
round beta fexp Zceil x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
Fnum {| Fnum := 0; Fexp := fexp (mag beta 0) |} =
Fnum
  {|
  Fnum := Zfloor (scaled_mantissa beta fexp x);
  Fexp := cexp x |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
apply Rmult_le_pos.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
(0 <= x)%R
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
(0 <= bpow (- cexp x))%R
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
canonical {| Fnum := 0; Fexp := fexp (mag beta 0) |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
canonical {| Fnum := mf; Fexp := ef |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
F2R {| Fnum := 0; Fexp := fexp (mag beta 0) |} =
round beta fexp Zfloor x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
F2R {| Fnum := mf; Fexp := ef |} =
round beta fexp Zceil x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
Fnum {| Fnum := 0; Fexp := fexp (mag beta 0) |} =
Fnum
  {|
  Fnum := Zfloor (scaled_mantissa beta fexp x);
  Fexp := cexp x |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
now left.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
(0 <= bpow (- cexp x))%R
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
canonical {| Fnum := 0; Fexp := fexp (mag beta 0) |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
canonical {| Fnum := mf; Fexp := ef |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
F2R {| Fnum := 0; Fexp := fexp (mag beta 0) |} =
round beta fexp Zfloor x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
F2R {| Fnum := mf; Fexp := ef |} =
round beta fexp Zceil x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
Fnum {| Fnum := 0; Fexp := fexp (mag beta 0) |} =
Fnum
  {|
  Fnum := Zfloor (scaled_mantissa beta fexp x);
  Fexp := cexp x |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
apply bpow_ge_0.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
canonical {| Fnum := 0; Fexp := fexp (mag beta 0) |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
canonical {| Fnum := mf; Fexp := ef |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
F2R {| Fnum := 0; Fexp := fexp (mag beta 0) |} =
round beta fexp Zfloor x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
F2R {| Fnum := mf; Fexp := ef |} =
round beta fexp Zceil x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
Fnum {| Fnum := 0; Fexp := fexp (mag beta 0) |} =
Fnum
  {|
  Fnum := Zfloor (scaled_mantissa beta fexp x);
  Fexp := cexp x |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
apply canonical_0.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
canonical {| Fnum := mf; Fexp := ef |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
F2R {| Fnum := 0; Fexp := fexp (mag beta 0) |} =
round beta fexp Zfloor x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
F2R {| Fnum := mf; Fexp := ef |} =
round beta fexp Zceil x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
Fnum {| Fnum := 0; Fexp := fexp (mag beta 0) |} =
Fnum
  {|
  Fnum := Zfloor (scaled_mantissa beta fexp x);
  Fexp := cexp x |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
unfold canonical.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
Fexp {| Fnum := mf; Fexp := ef |} =
cexp (F2R {| Fnum := mf; Fexp := ef |})
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
F2R {| Fnum := 0; Fexp := fexp (mag beta 0) |} =
round beta fexp Zfloor x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
F2R {| Fnum := mf; Fexp := ef |} =
round beta fexp Zceil x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
Fnum {| Fnum := 0; Fexp := fexp (mag beta 0) |} =
Fnum
  {|
  Fnum := Zfloor (scaled_mantissa beta fexp x);
  Fexp := cexp x |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
rewrite <- H0; reflexivity.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
F2R {| Fnum := 0; Fexp := fexp (mag beta 0) |} =
round beta fexp Zfloor x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
F2R {| Fnum := mf; Fexp := ef |} =
round beta fexp Zceil x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
Fnum {| Fnum := 0; Fexp := fexp (mag beta 0) |} =
Fnum
  {|
  Fnum := Zfloor (scaled_mantissa beta fexp x);
  Fexp := cexp x |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
rewrite <- Y; unfold F2R; simpl; ring.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
F2R {| Fnum := mf; Fexp := ef |} =
round beta fexp Zceil x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
Fnum {| Fnum := 0; Fexp := fexp (mag beta 0) |} =
Fnum
  {|
  Fnum := Zfloor (scaled_mantissa beta fexp x);
  Fexp := cexp x |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
apply trans_eq with (round beta fexp Ztrunc (round beta fexp Zceil x)).
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
F2R {| Fnum := mf; Fexp := ef |} =
round beta fexp Ztrunc (round beta fexp Zceil x)
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
round beta fexp Ztrunc (round beta fexp Zceil x) =
round beta fexp Zceil x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
Fnum {| Fnum := 0; Fexp := fexp (mag beta 0) |} =
Fnum
  {|
  Fnum := Zfloor (scaled_mantissa beta fexp x);
  Fexp := cexp x |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
reflexivity.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
round beta fexp Ztrunc (round beta fexp Zceil x) =
round beta fexp Zceil x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
Fnum {| Fnum := 0; Fexp := fexp (mag beta 0) |} =
Fnum
  {|
  Fnum := Zfloor (scaled_mantissa beta fexp x);
  Fexp := cexp x |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
apply round_generic...
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
Fnum {| Fnum := 0; Fexp := fexp (mag beta 0) |} =
Fnum
  {|
  Fnum := Zfloor (scaled_mantissa beta fexp x);
  Fexp := cexp x |}
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
simpl.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
0%Z = Zfloor (scaled_mantissa beta fexp x)
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
apply eq_IZR, Rmult_eq_reg_r with (bpow (cexp x)).
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
(0 * bpow (cexp x))%R =
(IZR (Zfloor (scaled_mantissa beta fexp x)) *
 bpow (cexp x))%R
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
bpow (cexp x) <> 0%R
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
unfold round, F2R in Y; simpl in Y; rewrite <- Y.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R =
(IZR (Zfloor (scaled_mantissa beta fexp x)) *
 bpow (cexp x))%R
(0 * bpow (cexp x))%R = 0%R
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
bpow (cexp x) <> 0%R
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
simpl; ring.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
f:=round beta fexp Zceil x:R
ef:=cexp f:Z
mf:=Ztrunc (scaled_mantissa beta fexp f):Z
H0:f = F2R {| Fnum := mf; Fexp := ef |}
H1:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
true
Y:0%R = round beta fexp Zfloor x
bpow (cexp x) <> 0%R
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
apply Rgt_not_eq, bpow_gt_0.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Z.even (Zfloor (scaled_mantissa beta fexp x)) = false ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
(* . *)
intros Y.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Y:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
false
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
case (Rle_lt_or_eq_dec 0 (round beta fexp Zfloor x)).
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Y:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
false
(0 <= round beta fexp Zfloor x)%R
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Y:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
false
(0 < round beta fexp Zfloor x)%R ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Y:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
false
0%R = round beta fexp Zfloor x ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
rewrite <- round_0 with beta fexp Zfloor...
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Y:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
false
(round beta fexp Zfloor 0 <= round beta fexp Zfloor x)%R
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Y:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
false
(0 < round beta fexp Zfloor x)%R ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Y:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
false
0%R = round beta fexp Zfloor x ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
apply round_le...
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Y:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
false
(0 <= x)%R
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Y:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
false
(0 < round beta fexp Zfloor x)%R ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Y:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
false
0%R = round beta fexp Zfloor x ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
now left.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Y:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
false
(0 < round beta fexp Zfloor x)%R ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Y:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
false
0%R = round beta fexp Zfloor x ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
intros Hrx.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Y:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
false
Hrx:(0 < round beta fexp Zfloor x)%R
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Y:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
false
0%R = round beta fexp Zfloor x ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
set (ef := cexp x).
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Y:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
false
Hrx:(0 < round beta fexp Zfloor x)%R
ef:=cexp x:Z
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := ef |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Y:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
false
0%R = round beta fexp Zfloor x ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
set (mf := Zfloor (scaled_mantissa beta fexp x)).
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Y:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
false
Hrx:(0 < round beta fexp Zfloor x)%R
ef:=cexp x:Z
mf:=Zfloor (scaled_mantissa beta fexp x):Z
exists g : float beta,
  F2R {| Fnum := mf; Fexp := ef |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Y:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
false
0%R = round beta fexp Zfloor x ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
exists (Float beta mf ef).
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Y:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
false
Hrx:(0 < round beta fexp Zfloor x)%R
ef:=cexp x:Z
mf:=Zfloor (scaled_mantissa beta fexp x):Z
F2R {| Fnum := mf; Fexp := ef |} =
F2R {| Fnum := mf; Fexp := ef |} /\
canonical {| Fnum := mf; Fexp := ef |} /\
Z.even (Fnum {| Fnum := mf; Fexp := ef |}) = false
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Y:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
false
0%R = round beta fexp Zfloor x ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
unfold canonical.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Y:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
false
Hrx:(0 < round beta fexp Zfloor x)%R
ef:=cexp x:Z
mf:=Zfloor (scaled_mantissa beta fexp x):Z
F2R {| Fnum := mf; Fexp := ef |} =
F2R {| Fnum := mf; Fexp := ef |} /\
Fexp {| Fnum := mf; Fexp := ef |} =
cexp (F2R {| Fnum := mf; Fexp := ef |}) /\
Z.even (Fnum {| Fnum := mf; Fexp := ef |}) = false
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Y:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
false
0%R = round beta fexp Zfloor x ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
repeat split; try assumption.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Y:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
false
Hrx:(0 < round beta fexp Zfloor x)%R
ef:=cexp x:Z
mf:=Zfloor (scaled_mantissa beta fexp x):Z
Fexp {| Fnum := mf; Fexp := ef |} =
cexp (F2R {| Fnum := mf; Fexp := ef |})
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Y:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
false
0%R = round beta fexp Zfloor x ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
simpl.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Y:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
false
Hrx:(0 < round beta fexp Zfloor x)%R
ef:=cexp x:Z
mf:=Zfloor (scaled_mantissa beta fexp x):Z
ef = cexp (F2R {| Fnum := mf; Fexp := ef |})
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Y:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
false
0%R = round beta fexp Zfloor x ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
apply trans_eq with (cexp (round beta fexp Zfloor x )).
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Y:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
false
Hrx:(0 < round beta fexp Zfloor x)%R
ef:=cexp x:Z
mf:=Zfloor (scaled_mantissa beta fexp x):Z
ef = cexp (round beta fexp Zfloor x)
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Y:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
false
Hrx:(0 < round beta fexp Zfloor x)%R
ef:=cexp x:Z
mf:=Zfloor (scaled_mantissa beta fexp x):Z
cexp (round beta fexp Zfloor x) =
cexp (F2R {| Fnum := mf; Fexp := ef |})
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Y:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
false
0%R = round beta fexp Zfloor x ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
apply sym_eq, cexp_DN...
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Y:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
false
Hrx:(0 < round beta fexp Zfloor x)%R
ef:=cexp x:Z
mf:=Zfloor (scaled_mantissa beta fexp x):Z
cexp (round beta fexp Zfloor x) =
cexp (F2R {| Fnum := mf; Fexp := ef |})
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Y:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
false
0%R = round beta fexp Zfloor x ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
reflexivity.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Y:Z.even (Zfloor (scaled_mantissa beta fexp x)) =
false
0%R = round beta fexp Zfloor x ->
exists g : float beta,
  F2R
    {|
    Fnum := Zfloor (scaled_mantissa beta fexp x);
    Fexp := cexp x |} = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
intros Hrx; contradict Y.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Hrx:0%R = round beta fexp Zfloor x
Z.even (Zfloor (scaled_mantissa beta fexp x)) <> false
replace (Zfloor (scaled_mantissa beta fexp x)) with 0%Z.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Hrx:0%R = round beta fexp Zfloor x
Z.even 0 <> false
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Hrx:0%R = round beta fexp Zfloor x
0%Z = Zfloor (scaled_mantissa beta fexp x)
simpl; discriminate.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Hrx:0%R = round beta fexp Zfloor x
0%Z = Zfloor (scaled_mantissa beta fexp x)
apply eq_IZR, Rmult_eq_reg_r with (bpow (cexp x)).
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Hrx:0%R = round beta fexp Zfloor x
(0 * bpow (cexp x))%R =
(IZR (Zfloor (scaled_mantissa beta fexp x)) *
 bpow (cexp x))%R
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Hrx:0%R = round beta fexp Zfloor x
bpow (cexp x) <> 0%R
unfold round, F2R in Hrx; simpl in Hrx; rewrite <- Hrx.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Hrx:0%R =
(IZR (Zfloor (scaled_mantissa beta fexp x)) *
 bpow (cexp x))%R
(0 * bpow (cexp x))%R = 0%R
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Hrx:0%R = round beta fexp Zfloor x
bpow (cexp x) <> 0%R
simpl; ring.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x:R
Hxp:(0 < x)%R
o:=round beta fexp Zrnd_odd x:R
Ho:format o
Hx:o <> x
H:o = round beta fexp Zfloor x \/
o = round beta fexp Zceil x
L:scaled_mantissa beta fexp x <>
IZR (Zfloor (scaled_mantissa beta fexp x))
Hrx:0%R = round beta fexp Zfloor x
bpow (cexp x) <> 0%R
apply Rgt_not_eq, bpow_gt_0.
Qed.

Theorem Rnd_odd_pt_unique :
  forall x f1 f2 : R,
  Rnd_odd_pt x f1 -> Rnd_odd_pt x f2 ->
  f1 = f2.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
forall x f1 f2 : R,
Rnd_odd_pt x f1 -> Rnd_odd_pt x f2 -> f1 = f2
Proof.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
forall x f1 f2 : R,
Rnd_odd_pt x f1 -> Rnd_odd_pt x f2 -> f1 = f2
intros x f1 f2 (Ff1,H1) (Ff2,H2).
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:f1 = x \/
(Rnd_DN_pt format x f1 \/ Rnd_UP_pt format x f1) /\
(exists g : float beta,
   f1 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
Ff2:format f2
H2:f2 = x \/
(Rnd_DN_pt format x f2 \/ Rnd_UP_pt format x f2) /\
(exists g : float beta,
   f2 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
f1 = f2
(* *)
case (generic_format_EM beta fexp x); intros L.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:f1 = x \/
(Rnd_DN_pt format x f1 \/ Rnd_UP_pt format x f1) /\
(exists g : float beta,
   f1 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
Ff2:format f2
H2:f2 = x \/
(Rnd_DN_pt format x f2 \/ Rnd_UP_pt format x f2) /\
(exists g : float beta,
   f2 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
L:format x
f1 = f2
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:f1 = x \/
(Rnd_DN_pt format x f1 \/ Rnd_UP_pt format x f1) /\
(exists g : float beta,
   f1 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
Ff2:format f2
H2:f2 = x \/
(Rnd_DN_pt format x f2 \/ Rnd_UP_pt format x f2) /\
(exists g : float beta,
   f2 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
L:~ format x
f1 = f2
apply trans_eq with x.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:f1 = x \/
(Rnd_DN_pt format x f1 \/ Rnd_UP_pt format x f1) /\
(exists g : float beta,
   f1 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
Ff2:format f2
H2:f2 = x \/
(Rnd_DN_pt format x f2 \/ Rnd_UP_pt format x f2) /\
(exists g : float beta,
   f2 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
L:format x
f1 = x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:f1 = x \/
(Rnd_DN_pt format x f1 \/ Rnd_UP_pt format x f1) /\
(exists g : float beta,
   f1 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
Ff2:format f2
H2:f2 = x \/
(Rnd_DN_pt format x f2 \/ Rnd_UP_pt format x f2) /\
(exists g : float beta,
   f2 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
L:format x
x = f2
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:f1 = x \/
(Rnd_DN_pt format x f1 \/ Rnd_UP_pt format x f1) /\
(exists g : float beta,
   f1 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
Ff2:format f2
H2:f2 = x \/
(Rnd_DN_pt format x f2 \/ Rnd_UP_pt format x f2) /\
(exists g : float beta,
   f2 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
L:~ format x
f1 = f2
case H1; try easy.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:f1 = x \/
(Rnd_DN_pt format x f1 \/ Rnd_UP_pt format x f1) /\
(exists g : float beta,
   f1 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
Ff2:format f2
H2:f2 = x \/
(Rnd_DN_pt format x f2 \/ Rnd_UP_pt format x f2) /\
(exists g : float beta,
   f2 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
L:format x
(Rnd_DN_pt format x f1 \/ Rnd_UP_pt format x f1) /\
(exists g : float beta,
   f1 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false) -> f1 = x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:f1 = x \/
(Rnd_DN_pt format x f1 \/ Rnd_UP_pt format x f1) /\
(exists g : float beta,
   f1 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
Ff2:format f2
H2:f2 = x \/
(Rnd_DN_pt format x f2 \/ Rnd_UP_pt format x f2) /\
(exists g : float beta,
   f2 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
L:format x
x = f2
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:f1 = x \/
(Rnd_DN_pt format x f1 \/ Rnd_UP_pt format x f1) /\
(exists g : float beta,
   f1 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
Ff2:format f2
H2:f2 = x \/
(Rnd_DN_pt format x f2 \/ Rnd_UP_pt format x f2) /\
(exists g : float beta,
   f2 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
L:~ format x
f1 = f2
intros (J,_); case J; intros J'.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:f1 = x \/
(Rnd_DN_pt format x f1 \/ Rnd_UP_pt format x f1) /\
(exists g : float beta,
   f1 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
Ff2:format f2
H2:f2 = x \/
(Rnd_DN_pt format x f2 \/ Rnd_UP_pt format x f2) /\
(exists g : float beta,
   f2 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
L:format x
J:Rnd_DN_pt format x f1 \/ Rnd_UP_pt format x f1
J':Rnd_DN_pt format x f1
f1 = x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:f1 = x \/
(Rnd_DN_pt format x f1 \/ Rnd_UP_pt format x f1) /\
(exists g : float beta,
   f1 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
Ff2:format f2
H2:f2 = x \/
(Rnd_DN_pt format x f2 \/ Rnd_UP_pt format x f2) /\
(exists g : float beta,
   f2 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
L:format x
J:Rnd_DN_pt format x f1 \/ Rnd_UP_pt format x f1
J':Rnd_UP_pt format x f1
f1 = x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:f1 = x \/
(Rnd_DN_pt format x f1 \/ Rnd_UP_pt format x f1) /\
(exists g : float beta,
   f1 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
Ff2:format f2
H2:f2 = x \/
(Rnd_DN_pt format x f2 \/ Rnd_UP_pt format x f2) /\
(exists g : float beta,
   f2 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
L:format x
x = f2
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:f1 = x \/
(Rnd_DN_pt format x f1 \/ Rnd_UP_pt format x f1) /\
(exists g : float beta,
   f1 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
Ff2:format f2
H2:f2 = x \/
(Rnd_DN_pt format x f2 \/ Rnd_UP_pt format x f2) /\
(exists g : float beta,
   f2 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
L:~ format x
f1 = f2
apply Rnd_DN_pt_idempotent with format; assumption.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:f1 = x \/
(Rnd_DN_pt format x f1 \/ Rnd_UP_pt format x f1) /\
(exists g : float beta,
   f1 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
Ff2:format f2
H2:f2 = x \/
(Rnd_DN_pt format x f2 \/ Rnd_UP_pt format x f2) /\
(exists g : float beta,
   f2 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
L:format x
J:Rnd_DN_pt format x f1 \/ Rnd_UP_pt format x f1
J':Rnd_UP_pt format x f1
f1 = x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:f1 = x \/
(Rnd_DN_pt format x f1 \/ Rnd_UP_pt format x f1) /\
(exists g : float beta,
   f1 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
Ff2:format f2
H2:f2 = x \/
(Rnd_DN_pt format x f2 \/ Rnd_UP_pt format x f2) /\
(exists g : float beta,
   f2 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
L:format x
x = f2
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:f1 = x \/
(Rnd_DN_pt format x f1 \/ Rnd_UP_pt format x f1) /\
(exists g : float beta,
   f1 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
Ff2:format f2
H2:f2 = x \/
(Rnd_DN_pt format x f2 \/ Rnd_UP_pt format x f2) /\
(exists g : float beta,
   f2 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
L:~ format x
f1 = f2
apply Rnd_UP_pt_idempotent with format; assumption.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:f1 = x \/
(Rnd_DN_pt format x f1 \/ Rnd_UP_pt format x f1) /\
(exists g : float beta,
   f1 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
Ff2:format f2
H2:f2 = x \/
(Rnd_DN_pt format x f2 \/ Rnd_UP_pt format x f2) /\
(exists g : float beta,
   f2 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
L:format x
x = f2
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:f1 = x \/
(Rnd_DN_pt format x f1 \/ Rnd_UP_pt format x f1) /\
(exists g : float beta,
   f1 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
Ff2:format f2
H2:f2 = x \/
(Rnd_DN_pt format x f2 \/ Rnd_UP_pt format x f2) /\
(exists g : float beta,
   f2 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
L:~ format x
f1 = f2
case H2; try easy.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:f1 = x \/
(Rnd_DN_pt format x f1 \/ Rnd_UP_pt format x f1) /\
(exists g : float beta,
   f1 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
Ff2:format f2
H2:f2 = x \/
(Rnd_DN_pt format x f2 \/ Rnd_UP_pt format x f2) /\
(exists g : float beta,
   f2 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
L:format x
(Rnd_DN_pt format x f2 \/ Rnd_UP_pt format x f2) /\
(exists g : float beta,
   f2 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false) -> x = f2
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:f1 = x \/
(Rnd_DN_pt format x f1 \/ Rnd_UP_pt format x f1) /\
(exists g : float beta,
   f1 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
Ff2:format f2
H2:f2 = x \/
(Rnd_DN_pt format x f2 \/ Rnd_UP_pt format x f2) /\
(exists g : float beta,
   f2 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
L:~ format x
f1 = f2
intros (J,_); case J; intros J'; apply sym_eq.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:f1 = x \/
(Rnd_DN_pt format x f1 \/ Rnd_UP_pt format x f1) /\
(exists g : float beta,
   f1 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
Ff2:format f2
H2:f2 = x \/
(Rnd_DN_pt format x f2 \/ Rnd_UP_pt format x f2) /\
(exists g : float beta,
   f2 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
L:format x
J:Rnd_DN_pt format x f2 \/ Rnd_UP_pt format x f2
J':Rnd_DN_pt format x f2
f2 = x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:f1 = x \/
(Rnd_DN_pt format x f1 \/ Rnd_UP_pt format x f1) /\
(exists g : float beta,
   f1 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
Ff2:format f2
H2:f2 = x \/
(Rnd_DN_pt format x f2 \/ Rnd_UP_pt format x f2) /\
(exists g : float beta,
   f2 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
L:format x
J:Rnd_DN_pt format x f2 \/ Rnd_UP_pt format x f2
J':Rnd_UP_pt format x f2
f2 = x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:f1 = x \/
(Rnd_DN_pt format x f1 \/ Rnd_UP_pt format x f1) /\
(exists g : float beta,
   f1 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
Ff2:format f2
H2:f2 = x \/
(Rnd_DN_pt format x f2 \/ Rnd_UP_pt format x f2) /\
(exists g : float beta,
   f2 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
L:~ format x
f1 = f2
apply Rnd_DN_pt_idempotent with format; assumption.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:f1 = x \/
(Rnd_DN_pt format x f1 \/ Rnd_UP_pt format x f1) /\
(exists g : float beta,
   f1 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
Ff2:format f2
H2:f2 = x \/
(Rnd_DN_pt format x f2 \/ Rnd_UP_pt format x f2) /\
(exists g : float beta,
   f2 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
L:format x
J:Rnd_DN_pt format x f2 \/ Rnd_UP_pt format x f2
J':Rnd_UP_pt format x f2
f2 = x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:f1 = x \/
(Rnd_DN_pt format x f1 \/ Rnd_UP_pt format x f1) /\
(exists g : float beta,
   f1 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
Ff2:format f2
H2:f2 = x \/
(Rnd_DN_pt format x f2 \/ Rnd_UP_pt format x f2) /\
(exists g : float beta,
   f2 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
L:~ format x
f1 = f2
apply Rnd_UP_pt_idempotent with format; assumption.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:f1 = x \/
(Rnd_DN_pt format x f1 \/ Rnd_UP_pt format x f1) /\
(exists g : float beta,
   f1 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
Ff2:format f2
H2:f2 = x \/
(Rnd_DN_pt format x f2 \/ Rnd_UP_pt format x f2) /\
(exists g : float beta,
   f2 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
L:~ format x
f1 = f2
(* *)
destruct H1 as [H1|(H1,H1')].
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:f1 = x
Ff2:format f2
H2:f2 = x \/
(Rnd_DN_pt format x f2 \/ Rnd_UP_pt format x f2) /\
(exists g : float beta,
   f2 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
L:~ format x
f1 = f2
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_DN_pt format x f1 \/ Rnd_UP_pt format x f1
H1':exists g : float beta,
  f1 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
Ff2:format f2
H2:f2 = x \/
(Rnd_DN_pt format x f2 \/ Rnd_UP_pt format x f2) /\
(exists g : float beta,
   f2 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
L:~ format x
f1 = f2
contradict L; now rewrite <- H1.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_DN_pt format x f1 \/ Rnd_UP_pt format x f1
H1':exists g : float beta,
  f1 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
Ff2:format f2
H2:f2 = x \/
(Rnd_DN_pt format x f2 \/ Rnd_UP_pt format x f2) /\
(exists g : float beta,
   f2 = F2R g /\
   canonical g /\ Z.even (Fnum g) = false)
L:~ format x
f1 = f2
destruct H2 as [H2|(H2,H2')].
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_DN_pt format x f1 \/ Rnd_UP_pt format x f1
H1':exists g : float beta,
  f1 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
Ff2:format f2
H2:f2 = x
L:~ format x
f1 = f2
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_DN_pt format x f1 \/ Rnd_UP_pt format x f1
H1':exists g : float beta,
  f1 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
Ff2:format f2
H2:Rnd_DN_pt format x f2 \/ Rnd_UP_pt format x f2
H2':exists g : float beta,
  f2 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
L:~ format x
f1 = f2
contradict L; now rewrite <- H2.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_DN_pt format x f1 \/ Rnd_UP_pt format x f1
H1':exists g : float beta,
  f1 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
Ff2:format f2
H2:Rnd_DN_pt format x f2 \/ Rnd_UP_pt format x f2
H2':exists g : float beta,
  f2 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
L:~ format x
f1 = f2
destruct H1 as [H1|H1]; destruct H2 as [H2|H2].
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_DN_pt format x f1
H1':exists g : float beta,
  f1 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
Ff2:format f2
H2:Rnd_DN_pt format x f2
H2':exists g : float beta,
  f2 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
L:~ format x
f1 = f2
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_DN_pt format x f1
H1':exists g : float beta,
  f1 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
Ff2:format f2
H2:Rnd_UP_pt format x f2
H2':exists g : float beta,
  f2 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
L:~ format x
f1 = f2
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
H1':exists g : float beta,
  f1 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
Ff2:format f2
H2:Rnd_DN_pt format x f2
H2':exists g : float beta,
  f2 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
L:~ format x
f1 = f2
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
H1':exists g : float beta,
  f1 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
Ff2:format f2
H2:Rnd_UP_pt format x f2
H2':exists g : float beta,
  f2 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
L:~ format x
f1 = f2
apply Rnd_DN_pt_unique with format x; assumption.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_DN_pt format x f1
H1':exists g : float beta,
  f1 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
Ff2:format f2
H2:Rnd_UP_pt format x f2
H2':exists g : float beta,
  f2 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
L:~ format x
f1 = f2
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
H1':exists g : float beta,
  f1 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
Ff2:format f2
H2:Rnd_DN_pt format x f2
H2':exists g : float beta,
  f2 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
L:~ format x
f1 = f2
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
H1':exists g : float beta,
  f1 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
Ff2:format f2
H2:Rnd_UP_pt format x f2
H2':exists g : float beta,
  f2 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
L:~ format x
f1 = f2
destruct H1' as (ff,(K1,(K2,K3))).
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_DN_pt format x f1
ff:float beta
K1:f1 = F2R ff
K2:canonical ff
K3:Z.even (Fnum ff) = false
Ff2:format f2
H2:Rnd_UP_pt format x f2
H2':exists g : float beta,
  f2 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
L:~ format x
f1 = f2
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
H1':exists g : float beta,
  f1 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
Ff2:format f2
H2:Rnd_DN_pt format x f2
H2':exists g : float beta,
  f2 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
L:~ format x
f1 = f2
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
H1':exists g : float beta,
  f1 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
Ff2:format f2
H2:Rnd_UP_pt format x f2
H2':exists g : float beta,
  f2 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
L:~ format x
f1 = f2
destruct H2' as (gg,(L1,(L2,L3))).
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_DN_pt format x f1
ff:float beta
K1:f1 = F2R ff
K2:canonical ff
K3:Z.even (Fnum ff) = false
Ff2:format f2
H2:Rnd_UP_pt format x f2
gg:float beta
L1:f2 = F2R gg
L2:canonical gg
L3:Z.even (Fnum gg) = false
L:~ format x
f1 = f2
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
H1':exists g : float beta,
  f1 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
Ff2:format f2
H2:Rnd_DN_pt format x f2
H2':exists g : float beta,
  f2 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
L:~ format x
f1 = f2
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
H1':exists g : float beta,
  f1 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
Ff2:format f2
H2:Rnd_UP_pt format x f2
H2':exists g : float beta,
  f2 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
L:~ format x
f1 = f2
absurd (true = false); try discriminate.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_DN_pt format x f1
ff:float beta
K1:f1 = F2R ff
K2:canonical ff
K3:Z.even (Fnum ff) = false
Ff2:format f2
H2:Rnd_UP_pt format x f2
gg:float beta
L1:f2 = F2R gg
L2:canonical gg
L3:Z.even (Fnum gg) = false
L:~ format x
true = false
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
H1':exists g : float beta,
  f1 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
Ff2:format f2
H2:Rnd_DN_pt format x f2
H2':exists g : float beta,
  f2 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
L:~ format x
f1 = f2
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
H1':exists g : float beta,
  f1 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
Ff2:format f2
H2:Rnd_UP_pt format x f2
H2':exists g : float beta,
  f2 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
L:~ format x
f1 = f2
rewrite <- L3.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_DN_pt format x f1
ff:float beta
K1:f1 = F2R ff
K2:canonical ff
K3:Z.even (Fnum ff) = false
Ff2:format f2
H2:Rnd_UP_pt format x f2
gg:float beta
L1:f2 = F2R gg
L2:canonical gg
L3:Z.even (Fnum gg) = false
L:~ format x
true = Z.even (Fnum gg)
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
H1':exists g : float beta,
  f1 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
Ff2:format f2
H2:Rnd_DN_pt format x f2
H2':exists g : float beta,
  f2 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
L:~ format x
f1 = f2
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
H1':exists g : float beta,
  f1 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
Ff2:format f2
H2:Rnd_UP_pt format x f2
H2':exists g : float beta,
  f2 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
L:~ format x
f1 = f2
apply trans_eq with (negb (Z.even (Fnum ff))).
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_DN_pt format x f1
ff:float beta
K1:f1 = F2R ff
K2:canonical ff
K3:Z.even (Fnum ff) = false
Ff2:format f2
H2:Rnd_UP_pt format x f2
gg:float beta
L1:f2 = F2R gg
L2:canonical gg
L3:Z.even (Fnum gg) = false
L:~ format x
true = negb (Z.even (Fnum ff))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_DN_pt format x f1
ff:float beta
K1:f1 = F2R ff
K2:canonical ff
K3:Z.even (Fnum ff) = false
Ff2:format f2
H2:Rnd_UP_pt format x f2
gg:float beta
L1:f2 = F2R gg
L2:canonical gg
L3:Z.even (Fnum gg) = false
L:~ format x
negb (Z.even (Fnum ff)) = Z.even (Fnum gg)
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
H1':exists g : float beta,
  f1 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
Ff2:format f2
H2:Rnd_DN_pt format x f2
H2':exists g : float beta,
  f2 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
L:~ format x
f1 = f2
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
H1':exists g : float beta,
  f1 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
Ff2:format f2
H2:Rnd_UP_pt format x f2
H2':exists g : float beta,
  f2 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
L:~ format x
f1 = f2
rewrite K3; easy.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_DN_pt format x f1
ff:float beta
K1:f1 = F2R ff
K2:canonical ff
K3:Z.even (Fnum ff) = false
Ff2:format f2
H2:Rnd_UP_pt format x f2
gg:float beta
L1:f2 = F2R gg
L2:canonical gg
L3:Z.even (Fnum gg) = false
L:~ format x
negb (Z.even (Fnum ff)) = Z.even (Fnum gg)
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
H1':exists g : float beta,
  f1 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
Ff2:format f2
H2:Rnd_DN_pt format x f2
H2':exists g : float beta,
  f2 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
L:~ format x
f1 = f2
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
H1':exists g : float beta,
  f1 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
Ff2:format f2
H2:Rnd_UP_pt format x f2
H2':exists g : float beta,
  f2 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
L:~ format x
f1 = f2
apply sym_eq.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_DN_pt format x f1
ff:float beta
K1:f1 = F2R ff
K2:canonical ff
K3:Z.even (Fnum ff) = false
Ff2:format f2
H2:Rnd_UP_pt format x f2
gg:float beta
L1:f2 = F2R gg
L2:canonical gg
L3:Z.even (Fnum gg) = false
L:~ format x
Z.even (Fnum gg) = negb (Z.even (Fnum ff))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
H1':exists g : float beta,
  f1 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
Ff2:format f2
H2:Rnd_DN_pt format x f2
H2':exists g : float beta,
  f2 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
L:~ format x
f1 = f2
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
H1':exists g : float beta,
  f1 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
Ff2:format f2
H2:Rnd_UP_pt format x f2
H2':exists g : float beta,
  f2 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
L:~ format x
f1 = f2
generalize (DN_UP_parity_generic beta fexp).
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_DN_pt format x f1
ff:float beta
K1:f1 = F2R ff
K2:canonical ff
K3:Z.even (Fnum ff) = false
Ff2:format f2
H2:Rnd_UP_pt format x f2
gg:float beta
L1:f2 = F2R gg
L2:canonical gg
L3:Z.even (Fnum gg) = false
L:~ format x
DN_UP_parity_prop beta fexp ->
Z.even (Fnum gg) = negb (Z.even (Fnum ff))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
H1':exists g : float beta,
  f1 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
Ff2:format f2
H2:Rnd_DN_pt format x f2
H2':exists g : float beta,
  f2 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
L:~ format x
f1 = f2
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
H1':exists g : float beta,
  f1 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
Ff2:format f2
H2:Rnd_UP_pt format x f2
H2':exists g : float beta,
  f2 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
L:~ format x
f1 = f2
unfold DN_UP_parity_prop; intros T; apply (T x); clear T; try assumption...
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_DN_pt format x f1
ff:float beta
K1:f1 = F2R ff
K2:canonical ff
K3:Z.even (Fnum ff) = false
Ff2:format f2
H2:Rnd_UP_pt format x f2
gg:float beta
L1:f2 = F2R gg
L2:canonical gg
L3:Z.even (Fnum gg) = false
L:~ format x
F2R ff = round beta fexp Zfloor x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_DN_pt format x f1
ff:float beta
K1:f1 = F2R ff
K2:canonical ff
K3:Z.even (Fnum ff) = false
Ff2:format f2
H2:Rnd_UP_pt format x f2
gg:float beta
L1:f2 = F2R gg
L2:canonical gg
L3:Z.even (Fnum gg) = false
L:~ format x
F2R gg = round beta fexp Zceil x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
H1':exists g : float beta,
  f1 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
Ff2:format f2
H2:Rnd_DN_pt format x f2
H2':exists g : float beta,
  f2 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
L:~ format x
f1 = f2
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
H1':exists g : float beta,
  f1 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
Ff2:format f2
H2:Rnd_UP_pt format x f2
H2':exists g : float beta,
  f2 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
L:~ format x
f1 = f2
rewrite <- K1; apply Rnd_DN_pt_unique with (generic_format beta fexp) x; try easy...
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_DN_pt format x f1
ff:float beta
K1:f1 = F2R ff
K2:canonical ff
K3:Z.even (Fnum ff) = false
Ff2:format f2
H2:Rnd_UP_pt format x f2
gg:float beta
L1:f2 = F2R gg
L2:canonical gg
L3:Z.even (Fnum gg) = false
L:~ format x
Rnd_DN_pt format x (round beta fexp Zfloor x)
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_DN_pt format x f1
ff:float beta
K1:f1 = F2R ff
K2:canonical ff
K3:Z.even (Fnum ff) = false
Ff2:format f2
H2:Rnd_UP_pt format x f2
gg:float beta
L1:f2 = F2R gg
L2:canonical gg
L3:Z.even (Fnum gg) = false
L:~ format x
F2R gg = round beta fexp Zceil x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
H1':exists g : float beta,
  f1 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
Ff2:format f2
H2:Rnd_DN_pt format x f2
H2':exists g : float beta,
  f2 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
L:~ format x
f1 = f2
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
H1':exists g : float beta,
  f1 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
Ff2:format f2
H2:Rnd_UP_pt format x f2
H2':exists g : float beta,
  f2 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
L:~ format x
f1 = f2
now apply round_DN_pt...
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_DN_pt format x f1
ff:float beta
K1:f1 = F2R ff
K2:canonical ff
K3:Z.even (Fnum ff) = false
Ff2:format f2
H2:Rnd_UP_pt format x f2
gg:float beta
L1:f2 = F2R gg
L2:canonical gg
L3:Z.even (Fnum gg) = false
L:~ format x
F2R gg = round beta fexp Zceil x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
H1':exists g : float beta,
  f1 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
Ff2:format f2
H2:Rnd_DN_pt format x f2
H2':exists g : float beta,
  f2 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
L:~ format x
f1 = f2
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
H1':exists g : float beta,
  f1 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
Ff2:format f2
H2:Rnd_UP_pt format x f2
H2':exists g : float beta,
  f2 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
L:~ format x
f1 = f2
rewrite <- L1; apply Rnd_UP_pt_unique with (generic_format beta fexp) x; try easy...
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_DN_pt format x f1
ff:float beta
K1:f1 = F2R ff
K2:canonical ff
K3:Z.even (Fnum ff) = false
Ff2:format f2
H2:Rnd_UP_pt format x f2
gg:float beta
L1:f2 = F2R gg
L2:canonical gg
L3:Z.even (Fnum gg) = false
L:~ format x
Rnd_UP_pt format x (round beta fexp Zceil x)
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
H1':exists g : float beta,
  f1 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
Ff2:format f2
H2:Rnd_DN_pt format x f2
H2':exists g : float beta,
  f2 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
L:~ format x
f1 = f2
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
H1':exists g : float beta,
  f1 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
Ff2:format f2
H2:Rnd_UP_pt format x f2
H2':exists g : float beta,
  f2 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
L:~ format x
f1 = f2
now apply round_UP_pt...
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
H1':exists g : float beta,
  f1 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
Ff2:format f2
H2:Rnd_DN_pt format x f2
H2':exists g : float beta,
  f2 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
L:~ format x
f1 = f2
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
H1':exists g : float beta,
  f1 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
Ff2:format f2
H2:Rnd_UP_pt format x f2
H2':exists g : float beta,
  f2 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
L:~ format x
f1 = f2
(* *)
destruct H1' as (ff,(K1,(K2,K3))).
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
ff:float beta
K1:f1 = F2R ff
K2:canonical ff
K3:Z.even (Fnum ff) = false
Ff2:format f2
H2:Rnd_DN_pt format x f2
H2':exists g : float beta,
  f2 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
L:~ format x
f1 = f2
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
H1':exists g : float beta,
  f1 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
Ff2:format f2
H2:Rnd_UP_pt format x f2
H2':exists g : float beta,
  f2 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
L:~ format x
f1 = f2
destruct H2' as (gg,(L1,(L2,L3))).
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
ff:float beta
K1:f1 = F2R ff
K2:canonical ff
K3:Z.even (Fnum ff) = false
Ff2:format f2
H2:Rnd_DN_pt format x f2
gg:float beta
L1:f2 = F2R gg
L2:canonical gg
L3:Z.even (Fnum gg) = false
L:~ format x
f1 = f2
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
H1':exists g : float beta,
  f1 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
Ff2:format f2
H2:Rnd_UP_pt format x f2
H2':exists g : float beta,
  f2 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
L:~ format x
f1 = f2
absurd (true = false); try discriminate.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
ff:float beta
K1:f1 = F2R ff
K2:canonical ff
K3:Z.even (Fnum ff) = false
Ff2:format f2
H2:Rnd_DN_pt format x f2
gg:float beta
L1:f2 = F2R gg
L2:canonical gg
L3:Z.even (Fnum gg) = false
L:~ format x
true = false
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
H1':exists g : float beta,
  f1 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
Ff2:format f2
H2:Rnd_UP_pt format x f2
H2':exists g : float beta,
  f2 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
L:~ format x
f1 = f2
rewrite <- K3.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
ff:float beta
K1:f1 = F2R ff
K2:canonical ff
K3:Z.even (Fnum ff) = false
Ff2:format f2
H2:Rnd_DN_pt format x f2
gg:float beta
L1:f2 = F2R gg
L2:canonical gg
L3:Z.even (Fnum gg) = false
L:~ format x
true = Z.even (Fnum ff)
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
H1':exists g : float beta,
  f1 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
Ff2:format f2
H2:Rnd_UP_pt format x f2
H2':exists g : float beta,
  f2 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
L:~ format x
f1 = f2
apply trans_eq with (negb (Z.even (Fnum gg))).
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
ff:float beta
K1:f1 = F2R ff
K2:canonical ff
K3:Z.even (Fnum ff) = false
Ff2:format f2
H2:Rnd_DN_pt format x f2
gg:float beta
L1:f2 = F2R gg
L2:canonical gg
L3:Z.even (Fnum gg) = false
L:~ format x
true = negb (Z.even (Fnum gg))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
ff:float beta
K1:f1 = F2R ff
K2:canonical ff
K3:Z.even (Fnum ff) = false
Ff2:format f2
H2:Rnd_DN_pt format x f2
gg:float beta
L1:f2 = F2R gg
L2:canonical gg
L3:Z.even (Fnum gg) = false
L:~ format x
negb (Z.even (Fnum gg)) = Z.even (Fnum ff)
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
H1':exists g : float beta,
  f1 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
Ff2:format f2
H2:Rnd_UP_pt format x f2
H2':exists g : float beta,
  f2 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
L:~ format x
f1 = f2
rewrite L3; easy.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
ff:float beta
K1:f1 = F2R ff
K2:canonical ff
K3:Z.even (Fnum ff) = false
Ff2:format f2
H2:Rnd_DN_pt format x f2
gg:float beta
L1:f2 = F2R gg
L2:canonical gg
L3:Z.even (Fnum gg) = false
L:~ format x
negb (Z.even (Fnum gg)) = Z.even (Fnum ff)
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
H1':exists g : float beta,
  f1 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
Ff2:format f2
H2:Rnd_UP_pt format x f2
H2':exists g : float beta,
  f2 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
L:~ format x
f1 = f2
apply sym_eq.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
ff:float beta
K1:f1 = F2R ff
K2:canonical ff
K3:Z.even (Fnum ff) = false
Ff2:format f2
H2:Rnd_DN_pt format x f2
gg:float beta
L1:f2 = F2R gg
L2:canonical gg
L3:Z.even (Fnum gg) = false
L:~ format x
Z.even (Fnum ff) = negb (Z.even (Fnum gg))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
H1':exists g : float beta,
  f1 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
Ff2:format f2
H2:Rnd_UP_pt format x f2
H2':exists g : float beta,
  f2 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
L:~ format x
f1 = f2
generalize (DN_UP_parity_generic beta fexp).
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
ff:float beta
K1:f1 = F2R ff
K2:canonical ff
K3:Z.even (Fnum ff) = false
Ff2:format f2
H2:Rnd_DN_pt format x f2
gg:float beta
L1:f2 = F2R gg
L2:canonical gg
L3:Z.even (Fnum gg) = false
L:~ format x
DN_UP_parity_prop beta fexp ->
Z.even (Fnum ff) = negb (Z.even (Fnum gg))
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
H1':exists g : float beta,
  f1 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
Ff2:format f2
H2:Rnd_UP_pt format x f2
H2':exists g : float beta,
  f2 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
L:~ format x
f1 = f2
unfold DN_UP_parity_prop; intros T; apply (T x); clear T; try assumption...
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
ff:float beta
K1:f1 = F2R ff
K2:canonical ff
K3:Z.even (Fnum ff) = false
Ff2:format f2
H2:Rnd_DN_pt format x f2
gg:float beta
L1:f2 = F2R gg
L2:canonical gg
L3:Z.even (Fnum gg) = false
L:~ format x
F2R gg = round beta fexp Zfloor x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
ff:float beta
K1:f1 = F2R ff
K2:canonical ff
K3:Z.even (Fnum ff) = false
Ff2:format f2
H2:Rnd_DN_pt format x f2
gg:float beta
L1:f2 = F2R gg
L2:canonical gg
L3:Z.even (Fnum gg) = false
L:~ format x
F2R ff = round beta fexp Zceil x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
H1':exists g : float beta,
  f1 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
Ff2:format f2
H2:Rnd_UP_pt format x f2
H2':exists g : float beta,
  f2 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
L:~ format x
f1 = f2
rewrite <- L1; apply Rnd_DN_pt_unique with (generic_format beta fexp) x; try easy...
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
ff:float beta
K1:f1 = F2R ff
K2:canonical ff
K3:Z.even (Fnum ff) = false
Ff2:format f2
H2:Rnd_DN_pt format x f2
gg:float beta
L1:f2 = F2R gg
L2:canonical gg
L3:Z.even (Fnum gg) = false
L:~ format x
Rnd_DN_pt format x (round beta fexp Zfloor x)
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
ff:float beta
K1:f1 = F2R ff
K2:canonical ff
K3:Z.even (Fnum ff) = false
Ff2:format f2
H2:Rnd_DN_pt format x f2
gg:float beta
L1:f2 = F2R gg
L2:canonical gg
L3:Z.even (Fnum gg) = false
L:~ format x
F2R ff = round beta fexp Zceil x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
H1':exists g : float beta,
  f1 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
Ff2:format f2
H2:Rnd_UP_pt format x f2
H2':exists g : float beta,
  f2 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
L:~ format x
f1 = f2
now apply round_DN_pt...
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
ff:float beta
K1:f1 = F2R ff
K2:canonical ff
K3:Z.even (Fnum ff) = false
Ff2:format f2
H2:Rnd_DN_pt format x f2
gg:float beta
L1:f2 = F2R gg
L2:canonical gg
L3:Z.even (Fnum gg) = false
L:~ format x
F2R ff = round beta fexp Zceil x
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
H1':exists g : float beta,
  f1 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
Ff2:format f2
H2:Rnd_UP_pt format x f2
H2':exists g : float beta,
  f2 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
L:~ format x
f1 = f2
rewrite <- K1; apply Rnd_UP_pt_unique with (generic_format beta fexp) x; try easy...
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
ff:float beta
K1:f1 = F2R ff
K2:canonical ff
K3:Z.even (Fnum ff) = false
Ff2:format f2
H2:Rnd_DN_pt format x f2
gg:float beta
L1:f2 = F2R gg
L2:canonical gg
L3:Z.even (Fnum gg) = false
L:~ format x
Rnd_UP_pt format x (round beta fexp Zceil x)
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
H1':exists g : float beta,
  f1 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
Ff2:format f2
H2:Rnd_UP_pt format x f2
H2':exists g : float beta,
  f2 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
L:~ format x
f1 = f2
now apply round_UP_pt...
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, f1, f2:R
Ff1:format f1
H1:Rnd_UP_pt format x f1
H1':exists g : float beta,
  f1 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
Ff2:format f2
H2:Rnd_UP_pt format x f2
H2':exists g : float beta,
  f2 = F2R g /\
  canonical g /\ Z.even (Fnum g) = false
L:~ format x
f1 = f2
apply Rnd_UP_pt_unique with format x; assumption.
Qed.

Theorem Rnd_odd_pt_monotone :
  round_pred_monotone (Rnd_odd_pt).
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
round_pred_monotone Rnd_odd_pt
Proof with auto with typeclass_instances.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
round_pred_monotone Rnd_odd_pt
intros x y f g H1 H2 Hxy.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, y, f, g:R
H1:Rnd_odd_pt x f
H2:Rnd_odd_pt y g
Hxy:(x <= y)%R
(f <= g)%R
apply Rle_trans with (round beta fexp Zrnd_odd x).
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, y, f, g:R
H1:Rnd_odd_pt x f
H2:Rnd_odd_pt y g
Hxy:(x <= y)%R
(f <= round beta fexp Zrnd_odd x)%R
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, y, f, g:R
H1:Rnd_odd_pt x f
H2:Rnd_odd_pt y g
Hxy:(x <= y)%R
(round beta fexp Zrnd_odd x <= g)%R
right; apply Rnd_odd_pt_unique with x; try assumption.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, y, f, g:R
H1:Rnd_odd_pt x f
H2:Rnd_odd_pt y g
Hxy:(x <= y)%R
Rnd_odd_pt x (round beta fexp Zrnd_odd x)
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, y, f, g:R
H1:Rnd_odd_pt x f
H2:Rnd_odd_pt y g
Hxy:(x <= y)%R
(round beta fexp Zrnd_odd x <= g)%R
apply round_odd_pt.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, y, f, g:R
H1:Rnd_odd_pt x f
H2:Rnd_odd_pt y g
Hxy:(x <= y)%R
(round beta fexp Zrnd_odd x <= g)%R
apply Rle_trans with (round beta fexp Zrnd_odd y).
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, y, f, g:R
H1:Rnd_odd_pt x f
H2:Rnd_odd_pt y g
Hxy:(x <= y)%R
(round beta fexp Zrnd_odd x <=
 round beta fexp Zrnd_odd y)%R
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, y, f, g:R
H1:Rnd_odd_pt x f
H2:Rnd_odd_pt y g
Hxy:(x <= y)%R
(round beta fexp Zrnd_odd y <= g)%R
apply round_le...
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, y, f, g:R
H1:Rnd_odd_pt x f
H2:Rnd_odd_pt y g
Hxy:(x <= y)%R
(round beta fexp Zrnd_odd y <= g)%R
right; apply Rnd_odd_pt_unique with y; try assumption.
beta:radix
fexp:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
x, y, f, g:R
H1:Rnd_odd_pt x f
H2:Rnd_odd_pt y g
Hxy:(x <= y)%R
Rnd_odd_pt y (round beta fexp Zrnd_odd y)
apply round_odd_pt.
Qed.

End Fcore_rnd_odd.

Section Odd_prop_aux.

Variable beta : radix.
Hypothesis Even_beta: Z.even (radix_val beta)=true.

Notation bpow e := (bpow beta e).

Variable fexp : Z -> Z.
Variable fexpe : Z -> Z.

Context { valid_exp : Valid_exp fexp }.
Context { exists_NE_ : Exists_NE beta fexp }. (* for underflow reason *)
Context { valid_expe : Valid_exp fexpe }.
Context { exists_NE_e : Exists_NE beta fexpe }. (* for defining rounding to odd *)

Hypothesis fexpe_fexp: forall e, (fexpe e <= fexp e -2)%Z.


Lemma generic_format_fexpe_fexp: forall x,
 generic_format beta fexp x ->  generic_format beta fexpe x.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
forall x : R,
generic_format beta fexp x ->
generic_format beta fexpe x
Proof.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
forall x : R,
generic_format beta fexp x ->
generic_format beta fexpe x
intros x Hx.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
Hx:generic_format beta fexp x
generic_format beta fexpe x
apply generic_inclusion_mag with fexp; trivial; intros Hx2.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
Hx:generic_format beta fexp x
Hx2:x <> 0%R
(fexpe (mag beta x) <= fexp (mag beta x))%Z
generalize (fexpe_fexp (mag beta x)).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
Hx:generic_format beta fexp x
Hx2:x <> 0%R
(fexpe (mag beta x) <= fexp (mag beta x) - 2)%Z ->
(fexpe (mag beta x) <= fexp (mag beta x))%Z
omega.
Qed.



Lemma exists_even_fexp_lt: forall (c:Z->Z), forall (x:R),
      (exists f:float beta, F2R f = x /\ (c (mag beta x) < Fexp f)%Z) ->
      exists f:float beta, F2R f =x /\ canonical beta c f /\ Z.even (Fnum f) = true.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
forall (c : Z -> Z) (x : R),
(exists f : float beta,
   F2R f = x /\ (c (mag beta x) < Fexp f)%Z) ->
exists f : float beta,
  F2R f = x /\
  canonical beta c f /\ Z.even (Fnum f) = true
Proof with auto with typeclass_instances.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
forall (c : Z -> Z) (x : R),
(exists f : float beta,
   F2R f = x /\ (c (mag beta x) < Fexp f)%Z) ->
exists f : float beta,
  F2R f = x /\
  canonical beta c f /\ Z.even (Fnum f) = true
intros c x (g,(Hg1,Hg2)).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
c:Z -> Z
x:R
g:float beta
Hg1:F2R g = x
Hg2:(c (mag beta x) < Fexp g)%Z
exists f : float beta,
  F2R f = x /\
  canonical beta c f /\ Z.even (Fnum f) = true
exists (Float beta
     (Fnum g*Z.pow (radix_val beta) (Fexp g - c (mag beta x)))
     (c (mag beta x))).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
c:Z -> Z
x:R
g:float beta
Hg1:F2R g = x
Hg2:(c (mag beta x) < Fexp g)%Z
F2R
  {|
  Fnum := Fnum g * beta ^ (Fexp g - c (mag beta x));
  Fexp := c (mag beta x) |} = x /\
canonical beta c
  {|
  Fnum := Fnum g * beta ^ (Fexp g - c (mag beta x));
  Fexp := c (mag beta x) |} /\
Z.even
  (Fnum
     {|
     Fnum := Fnum g * beta ^ (Fexp g - c (mag beta x));
     Fexp := c (mag beta x) |}) = true
assert (F2R (Float beta
     (Fnum g*Z.pow (radix_val beta) (Fexp g - c (mag beta x)))
     (c (mag beta x))) = x).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
c:Z -> Z
x:R
g:float beta
Hg1:F2R g = x
Hg2:(c (mag beta x) < Fexp g)%Z
F2R
  {|
  Fnum := Fnum g * beta ^ (Fexp g - c (mag beta x));
  Fexp := c (mag beta x) |} = x
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
c:Z -> Z
x:R
g:float beta
Hg1:F2R g = x
Hg2:(c (mag beta x) < Fexp g)%Z
H:F2R
  {|
  Fnum := Fnum g *
          beta ^ (Fexp g - c (mag beta x));
  Fexp := c (mag beta x) |} = x
F2R
  {|
  Fnum := Fnum g * beta ^ (Fexp g - c (mag beta x));
  Fexp := c (mag beta x) |} = x /\
canonical beta c
  {|
  Fnum := Fnum g * beta ^ (Fexp g - c (mag beta x));
  Fexp := c (mag beta x) |} /\
Z.even
  (Fnum
     {|
     Fnum := Fnum g * beta ^ (Fexp g - c (mag beta x));
     Fexp := c (mag beta x) |}) = true
unfold F2R; simpl.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
c:Z -> Z
x:R
g:float beta
Hg1:F2R g = x
Hg2:(c (mag beta x) < Fexp g)%Z
(IZR (Fnum g * beta ^ (Fexp g - c (mag beta x))) *
 bpow (c (mag beta x)))%R = x
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
c:Z -> Z
x:R
g:float beta
Hg1:F2R g = x
Hg2:(c (mag beta x) < Fexp g)%Z
H:F2R
  {|
  Fnum := Fnum g *
          beta ^ (Fexp g - c (mag beta x));
  Fexp := c (mag beta x) |} = x
F2R
  {|
  Fnum := Fnum g * beta ^ (Fexp g - c (mag beta x));
  Fexp := c (mag beta x) |} = x /\
canonical beta c
  {|
  Fnum := Fnum g * beta ^ (Fexp g - c (mag beta x));
  Fexp := c (mag beta x) |} /\
Z.even
  (Fnum
     {|
     Fnum := Fnum g * beta ^ (Fexp g - c (mag beta x));
     Fexp := c (mag beta x) |}) = true
rewrite mult_IZR, IZR_Zpower.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
c:Z -> Z
x:R
g:float beta
Hg1:F2R g = x
Hg2:(c (mag beta x) < Fexp g)%Z
(IZR (Fnum g) * bpow (Fexp g - c (mag beta x)) *
 bpow (c (mag beta x)))%R = x
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
c:Z -> Z
x:R
g:float beta
Hg1:F2R g = x
Hg2:(c (mag beta x) < Fexp g)%Z
(0 <= Fexp g - c (mag beta x))%Z
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
c:Z -> Z
x:R
g:float beta
Hg1:F2R g = x
Hg2:(c (mag beta x) < Fexp g)%Z
H:F2R
  {|
  Fnum := Fnum g *
          beta ^ (Fexp g - c (mag beta x));
  Fexp := c (mag beta x) |} = x
F2R
  {|
  Fnum := Fnum g * beta ^ (Fexp g - c (mag beta x));
  Fexp := c (mag beta x) |} = x /\
canonical beta c
  {|
  Fnum := Fnum g * beta ^ (Fexp g - c (mag beta x));
  Fexp := c (mag beta x) |} /\
Z.even
  (Fnum
     {|
     Fnum := Fnum g * beta ^ (Fexp g - c (mag beta x));
     Fexp := c (mag beta x) |}) = true
rewrite Rmult_assoc, <- bpow_plus.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
c:Z -> Z
x:R
g:float beta
Hg1:F2R g = x
Hg2:(c (mag beta x) < Fexp g)%Z
(IZR (Fnum g) *
 bpow (Fexp g - c (mag beta x) + c (mag beta x)))%R =
x
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
c:Z -> Z
x:R
g:float beta
Hg1:F2R g = x
Hg2:(c (mag beta x) < Fexp g)%Z
(0 <= Fexp g - c (mag beta x))%Z
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
c:Z -> Z
x:R
g:float beta
Hg1:F2R g = x
Hg2:(c (mag beta x) < Fexp g)%Z
H:F2R
  {|
  Fnum := Fnum g *
          beta ^ (Fexp g - c (mag beta x));
  Fexp := c (mag beta x) |} = x
F2R
  {|
  Fnum := Fnum g * beta ^ (Fexp g - c (mag beta x));
  Fexp := c (mag beta x) |} = x /\
canonical beta c
  {|
  Fnum := Fnum g * beta ^ (Fexp g - c (mag beta x));
  Fexp := c (mag beta x) |} /\
Z.even
  (Fnum
     {|
     Fnum := Fnum g * beta ^ (Fexp g - c (mag beta x));
     Fexp := c (mag beta x) |}) = true
rewrite <- Hg1; unfold F2R.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
c:Z -> Z
x:R
g:float beta
Hg1:F2R g = x
Hg2:(c (mag beta x) < Fexp g)%Z
(IZR (Fnum g) *
 bpow
   (Fexp g -
    c (mag beta (IZR (Fnum g) * bpow (Fexp g))) +
    c (mag beta (IZR (Fnum g) * bpow (Fexp g)))))%R =
(IZR (Fnum g) * bpow (Fexp g))%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
c:Z -> Z
x:R
g:float beta
Hg1:F2R g = x
Hg2:(c (mag beta x) < Fexp g)%Z
(0 <= Fexp g - c (mag beta x))%Z
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
c:Z -> Z
x:R
g:float beta
Hg1:F2R g = x
Hg2:(c (mag beta x) < Fexp g)%Z
H:F2R
  {|
  Fnum := Fnum g *
          beta ^ (Fexp g - c (mag beta x));
  Fexp := c (mag beta x) |} = x
F2R
  {|
  Fnum := Fnum g * beta ^ (Fexp g - c (mag beta x));
  Fexp := c (mag beta x) |} = x /\
canonical beta c
  {|
  Fnum := Fnum g * beta ^ (Fexp g - c (mag beta x));
  Fexp := c (mag beta x) |} /\
Z.even
  (Fnum
     {|
     Fnum := Fnum g * beta ^ (Fexp g - c (mag beta x));
     Fexp := c (mag beta x) |}) = true
apply f_equal, f_equal.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
c:Z -> Z
x:R
g:float beta
Hg1:F2R g = x
Hg2:(c (mag beta x) < Fexp g)%Z
(Fexp g - c (mag beta (IZR (Fnum g) * bpow (Fexp g))) +
 c (mag beta (IZR (Fnum g) * bpow (Fexp g))))%Z =
Fexp g
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
c:Z -> Z
x:R
g:float beta
Hg1:F2R g = x
Hg2:(c (mag beta x) < Fexp g)%Z
(0 <= Fexp g - c (mag beta x))%Z
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
c:Z -> Z
x:R
g:float beta
Hg1:F2R g = x
Hg2:(c (mag beta x) < Fexp g)%Z
H:F2R
  {|
  Fnum := Fnum g *
          beta ^ (Fexp g - c (mag beta x));
  Fexp := c (mag beta x) |} = x
F2R
  {|
  Fnum := Fnum g * beta ^ (Fexp g - c (mag beta x));
  Fexp := c (mag beta x) |} = x /\
canonical beta c
  {|
  Fnum := Fnum g * beta ^ (Fexp g - c (mag beta x));
  Fexp := c (mag beta x) |} /\
Z.even
  (Fnum
     {|
     Fnum := Fnum g * beta ^ (Fexp g - c (mag beta x));
     Fexp := c (mag beta x) |}) = true
ring.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
c:Z -> Z
x:R
g:float beta
Hg1:F2R g = x
Hg2:(c (mag beta x) < Fexp g)%Z
(0 <= Fexp g - c (mag beta x))%Z
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
c:Z -> Z
x:R
g:float beta
Hg1:F2R g = x
Hg2:(c (mag beta x) < Fexp g)%Z
H:F2R
  {|
  Fnum := Fnum g *
          beta ^ (Fexp g - c (mag beta x));
  Fexp := c (mag beta x) |} = x
F2R
  {|
  Fnum := Fnum g * beta ^ (Fexp g - c (mag beta x));
  Fexp := c (mag beta x) |} = x /\
canonical beta c
  {|
  Fnum := Fnum g * beta ^ (Fexp g - c (mag beta x));
  Fexp := c (mag beta x) |} /\
Z.even
  (Fnum
     {|
     Fnum := Fnum g * beta ^ (Fexp g - c (mag beta x));
     Fexp := c (mag beta x) |}) = true
omega.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
c:Z -> Z
x:R
g:float beta
Hg1:F2R g = x
Hg2:(c (mag beta x) < Fexp g)%Z
H:F2R
  {|
  Fnum := Fnum g *
          beta ^ (Fexp g - c (mag beta x));
  Fexp := c (mag beta x) |} = x
F2R
  {|
  Fnum := Fnum g * beta ^ (Fexp g - c (mag beta x));
  Fexp := c (mag beta x) |} = x /\
canonical beta c
  {|
  Fnum := Fnum g * beta ^ (Fexp g - c (mag beta x));
  Fexp := c (mag beta x) |} /\
Z.even
  (Fnum
     {|
     Fnum := Fnum g * beta ^ (Fexp g - c (mag beta x));
     Fexp := c (mag beta x) |}) = true
split; trivial.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
c:Z -> Z
x:R
g:float beta
Hg1:F2R g = x
Hg2:(c (mag beta x) < Fexp g)%Z
H:F2R
  {|
  Fnum := Fnum g *
          beta ^ (Fexp g - c (mag beta x));
  Fexp := c (mag beta x) |} = x
canonical beta c
  {|
  Fnum := Fnum g * beta ^ (Fexp g - c (mag beta x));
  Fexp := c (mag beta x) |} /\
Z.even
  (Fnum
     {|
     Fnum := Fnum g * beta ^ (Fexp g - c (mag beta x));
     Fexp := c (mag beta x) |}) = true
split.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
c:Z -> Z
x:R
g:float beta
Hg1:F2R g = x
Hg2:(c (mag beta x) < Fexp g)%Z
H:F2R
  {|
  Fnum := Fnum g *
          beta ^ (Fexp g - c (mag beta x));
  Fexp := c (mag beta x) |} = x
canonical beta c
  {|
  Fnum := Fnum g * beta ^ (Fexp g - c (mag beta x));
  Fexp := c (mag beta x) |}
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
c:Z -> Z
x:R
g:float beta
Hg1:F2R g = x
Hg2:(c (mag beta x) < Fexp g)%Z
H:F2R
  {|
  Fnum := Fnum g *
          beta ^ (Fexp g - c (mag beta x));
  Fexp := c (mag beta x) |} = x
Z.even
  (Fnum
     {|
     Fnum := Fnum g * beta ^ (Fexp g - c (mag beta x));
     Fexp := c (mag beta x) |}) = true
unfold canonical, cexp.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
c:Z -> Z
x:R
g:float beta
Hg1:F2R g = x
Hg2:(c (mag beta x) < Fexp g)%Z
H:F2R
  {|
  Fnum := Fnum g *
          beta ^ (Fexp g - c (mag beta x));
  Fexp := c (mag beta x) |} = x
Fexp
  {|
  Fnum := Fnum g * beta ^ (Fexp g - c (mag beta x));
  Fexp := c (mag beta x) |} =
c
  (mag beta
     (F2R
        {|
        Fnum := Fnum g *
                beta ^ (Fexp g - c (mag beta x));
        Fexp := c (mag beta x) |}))
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
c:Z -> Z
x:R
g:float beta
Hg1:F2R g = x
Hg2:(c (mag beta x) < Fexp g)%Z
H:F2R
  {|
  Fnum := Fnum g *
          beta ^ (Fexp g - c (mag beta x));
  Fexp := c (mag beta x) |} = x
Z.even
  (Fnum
     {|
     Fnum := Fnum g * beta ^ (Fexp g - c (mag beta x));
     Fexp := c (mag beta x) |}) = true
now rewrite H.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
c:Z -> Z
x:R
g:float beta
Hg1:F2R g = x
Hg2:(c (mag beta x) < Fexp g)%Z
H:F2R
  {|
  Fnum := Fnum g *
          beta ^ (Fexp g - c (mag beta x));
  Fexp := c (mag beta x) |} = x
Z.even
  (Fnum
     {|
     Fnum := Fnum g * beta ^ (Fexp g - c (mag beta x));
     Fexp := c (mag beta x) |}) = true
simpl.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
c:Z -> Z
x:R
g:float beta
Hg1:F2R g = x
Hg2:(c (mag beta x) < Fexp g)%Z
H:F2R
  {|
  Fnum := Fnum g *
          beta ^ (Fexp g - c (mag beta x));
  Fexp := c (mag beta x) |} = x
Z.even (Fnum g * beta ^ (Fexp g - c (mag beta x))) =
true
rewrite Z.even_mul.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
c:Z -> Z
x:R
g:float beta
Hg1:F2R g = x
Hg2:(c (mag beta x) < Fexp g)%Z
H:F2R
  {|
  Fnum := Fnum g *
          beta ^ (Fexp g - c (mag beta x));
  Fexp := c (mag beta x) |} = x
(Z.even (Fnum g)
 || Z.even (beta ^ (Fexp g - c (mag beta x))))%bool =
true
rewrite Z.even_pow.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
c:Z -> Z
x:R
g:float beta
Hg1:F2R g = x
Hg2:(c (mag beta x) < Fexp g)%Z
H:F2R
  {|
  Fnum := Fnum g *
          beta ^ (Fexp g - c (mag beta x));
  Fexp := c (mag beta x) |} = x
(Z.even (Fnum g) || Z.even beta)%bool = true
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
c:Z -> Z
x:R
g:float beta
Hg1:F2R g = x
Hg2:(c (mag beta x) < Fexp g)%Z
H:F2R
  {|
  Fnum := Fnum g *
          beta ^ (Fexp g - c (mag beta x));
  Fexp := c (mag beta x) |} = x
(0 < Fexp g - c (mag beta x))%Z
rewrite Even_beta.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
c:Z -> Z
x:R
g:float beta
Hg1:F2R g = x
Hg2:(c (mag beta x) < Fexp g)%Z
H:F2R
  {|
  Fnum := Fnum g *
          beta ^ (Fexp g - c (mag beta x));
  Fexp := c (mag beta x) |} = x
(Z.even (Fnum g) || true)%bool = true
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
c:Z -> Z
x:R
g:float beta
Hg1:F2R g = x
Hg2:(c (mag beta x) < Fexp g)%Z
H:F2R
  {|
  Fnum := Fnum g *
          beta ^ (Fexp g - c (mag beta x));
  Fexp := c (mag beta x) |} = x
(0 < Fexp g - c (mag beta x))%Z
apply Bool.orb_true_intro.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
c:Z -> Z
x:R
g:float beta
Hg1:F2R g = x
Hg2:(c (mag beta x) < Fexp g)%Z
H:F2R
  {|
  Fnum := Fnum g *
          beta ^ (Fexp g - c (mag beta x));
  Fexp := c (mag beta x) |} = x
Z.even (Fnum g) = true \/ true = true
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
c:Z -> Z
x:R
g:float beta
Hg1:F2R g = x
Hg2:(c (mag beta x) < Fexp g)%Z
H:F2R
  {|
  Fnum := Fnum g *
          beta ^ (Fexp g - c (mag beta x));
  Fexp := c (mag beta x) |} = x
(0 < Fexp g - c (mag beta x))%Z
now right.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
c:Z -> Z
x:R
g:float beta
Hg1:F2R g = x
Hg2:(c (mag beta x) < Fexp g)%Z
H:F2R
  {|
  Fnum := Fnum g *
          beta ^ (Fexp g - c (mag beta x));
  Fexp := c (mag beta x) |} = x
(0 < Fexp g - c (mag beta x))%Z
omega.
Qed.


Variable choice:Z->bool.
Variable x:R.


Variable d u: float beta.
Hypothesis Hd: Rnd_DN_pt (generic_format beta fexp) x (F2R d).
Hypothesis Cd: canonical beta fexp d.
Hypothesis Hu: Rnd_UP_pt (generic_format beta fexp) x (F2R u).
Hypothesis Cu: canonical beta fexp u.

Hypothesis xPos: (0 < x)%R.


Let m:= ((F2R d+F2R u)/2)%R.


Lemma d_eq: F2R d= round beta fexp Zfloor x.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
F2R d = round beta fexp Zfloor x
Proof with auto with typeclass_instances.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
F2R d = round beta fexp Zfloor x
apply Rnd_DN_pt_unique with (generic_format beta fexp) x...
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Rnd_DN_pt (generic_format beta fexp) x
  (round beta fexp Zfloor x)
apply round_DN_pt...
Qed.


Lemma u_eq: F2R u= round beta fexp Zceil x.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
F2R u = round beta fexp Zceil x
Proof with auto with typeclass_instances.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
F2R u = round beta fexp Zceil x
apply Rnd_UP_pt_unique with (generic_format beta fexp) x...
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Rnd_UP_pt (generic_format beta fexp) x
  (round beta fexp Zceil x)
apply round_UP_pt...
Qed.


Lemma d_ge_0: (0 <= F2R d)%R.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
(0 <= F2R d)%R
Proof with auto with typeclass_instances.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
(0 <= F2R d)%R
rewrite d_eq; apply round_ge_generic...
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
generic_format beta fexp 0
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
(0 <= x)%R
apply generic_format_0.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
(0 <= x)%R
now left.
Qed.



Lemma mag_d:  (0< F2R d)%R ->
    (mag beta (F2R d) = mag beta x :>Z).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
(0 < F2R d)%R -> mag beta (F2R d) = mag beta x
Proof with auto with typeclass_instances.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
(0 < F2R d)%R -> mag beta (F2R d) = mag beta x
intros Y.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
mag beta (F2R d) = mag beta x
rewrite d_eq; apply mag_DN...
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
(0 < round beta fexp Zfloor x)%R
now rewrite <- d_eq.
Qed.


Lemma Fexp_d: (0 < F2R d)%R -> Fexp d =fexp (mag beta x).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
(0 < F2R d)%R -> Fexp d = fexp (mag beta x)
Proof with auto with typeclass_instances.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
(0 < F2R d)%R -> Fexp d = fexp (mag beta x)
intros Y.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
Fexp d = fexp (mag beta x)
now rewrite Cd, <- mag_d.
Qed.



Lemma format_bpow_x: (0 < F2R d)%R
    -> generic_format beta fexp  (bpow (mag beta x)).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
(0 < F2R d)%R ->
generic_format beta fexp (bpow (mag beta x))
Proof with auto with typeclass_instances.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
(0 < F2R d)%R ->
generic_format beta fexp (bpow (mag beta x))
intros Y.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
generic_format beta fexp (bpow (mag beta x))
apply generic_format_bpow.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
(fexp (mag beta x + 1) <= mag beta x)%Z
apply valid_exp.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
(fexp (mag beta x) < mag beta x)%Z
rewrite <- Fexp_d; trivial.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
(Fexp d < mag beta x)%Z
apply Z.lt_le_trans with  (mag beta (F2R d))%Z.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
(Fexp d < mag beta (F2R d))%Z
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
(mag beta (F2R d) <= mag beta x)%Z
rewrite Cd; apply mag_generic_gt...
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
F2R d <> 0%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
generic_format beta fexp (F2R d)
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
(mag beta (F2R d) <= mag beta x)%Z
now apply Rgt_not_eq.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
generic_format beta fexp (F2R d)
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
(mag beta (F2R d) <= mag beta x)%Z
apply Hd.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
(mag beta (F2R d) <= mag beta x)%Z
apply mag_le; trivial.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
(F2R d <= x)%R
apply Hd.
Qed.


Lemma format_bpow_d: (0 < F2R d)%R ->
  generic_format beta fexp (bpow (mag beta (F2R d))).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
(0 < F2R d)%R ->
generic_format beta fexp (bpow (mag beta (F2R d)))
Proof with auto with typeclass_instances.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
(0 < F2R d)%R ->
generic_format beta fexp (bpow (mag beta (F2R d)))
intros Y; apply generic_format_bpow.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
(fexp (mag beta (F2R d) + 1) <= mag beta (F2R d))%Z
apply valid_exp.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
(fexp (mag beta (F2R d)) < mag beta (F2R d))%Z
apply mag_generic_gt...
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
F2R d <> 0%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
generic_format beta fexp (F2R d)
now apply Rgt_not_eq.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
generic_format beta fexp (F2R d)
now apply generic_format_canonical.
Qed.


Lemma d_le_m: (F2R d <= m)%R.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
(F2R d <= m)%R
Proof.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
(F2R d <= m)%R
assert (F2R d <= F2R u)%R.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
(F2R d <= F2R u)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
H:(F2R d <= F2R u)%R
(F2R d <= m)%R
  apply Rle_trans with x.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
(F2R d <= x)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
(x <= F2R u)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
H:(F2R d <= F2R u)%R
(F2R d <= m)%R
  apply Hd.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
(x <= F2R u)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
H:(F2R d <= F2R u)%R
(F2R d <= m)%R
  apply Hu.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
H:(F2R d <= F2R u)%R
(F2R d <= m)%R
unfold m.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
H:(F2R d <= F2R u)%R
(F2R d <= (F2R d + F2R u) / 2)%R
lra.
Qed.

Lemma m_le_u: (m <= F2R u)%R.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
(m <= F2R u)%R
Proof.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
(m <= F2R u)%R
assert (F2R d <= F2R u)%R.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
(F2R d <= F2R u)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
H:(F2R d <= F2R u)%R
(m <= F2R u)%R
  apply Rle_trans with x.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
(F2R d <= x)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
(x <= F2R u)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
H:(F2R d <= F2R u)%R
(m <= F2R u)%R
  apply Hd.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
(x <= F2R u)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
H:(F2R d <= F2R u)%R
(m <= F2R u)%R
  apply Hu.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
H:(F2R d <= F2R u)%R
(m <= F2R u)%R
unfold m.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
H:(F2R d <= F2R u)%R
((F2R d + F2R u) / 2 <= F2R u)%R
lra.
Qed.

Lemma mag_m: (0 < F2R d)%R -> (mag beta m =mag beta (F2R d) :>Z).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
(0 < F2R d)%R -> mag beta m = mag beta (F2R d)
Proof with auto with typeclass_instances.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
(0 < F2R d)%R -> mag beta m = mag beta (F2R d)
intros dPos; apply mag_unique_pos.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
(bpow (mag beta (F2R d) - 1) <= m <
 bpow (mag beta (F2R d)))%R
split.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
(bpow (mag beta (F2R d) - 1) <= m)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
(m < bpow (mag beta (F2R d)))%R
apply Rle_trans with (F2R d).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
(bpow (mag beta (F2R d) - 1) <= F2R d)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
(F2R d <= m)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
(m < bpow (mag beta (F2R d)))%R
destruct (mag beta (F2R d)) as (e,He).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
e:Z
He:F2R d <> 0%R ->
(bpow (e - 1) <= Rabs (F2R d) < bpow e)%R
(bpow (Build_mag_prop beta (F2R d) e He - 1) <= F2R d)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
(F2R d <= m)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
(m < bpow (mag beta (F2R d)))%R
simpl.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
e:Z
He:F2R d <> 0%R ->
(bpow (e - 1) <= Rabs (F2R d) < bpow e)%R
(bpow (e - 1) <= F2R d)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
(F2R d <= m)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
(m < bpow (mag beta (F2R d)))%R
rewrite Rabs_right in He.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
e:Z
He:F2R d <> 0%R ->
(bpow (e - 1) <= F2R d < bpow e)%R
(bpow (e - 1) <= F2R d)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
e:Z
He:F2R d <> 0%R ->
(bpow (e - 1) <= Rabs (F2R d) < bpow e)%R
(F2R d >= 0)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
(F2R d <= m)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
(m < bpow (mag beta (F2R d)))%R
apply He.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
e:Z
He:F2R d <> 0%R ->
(bpow (e - 1) <= F2R d < bpow e)%R
F2R d <> 0%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
e:Z
He:F2R d <> 0%R ->
(bpow (e - 1) <= Rabs (F2R d) < bpow e)%R
(F2R d >= 0)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
(F2R d <= m)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
(m < bpow (mag beta (F2R d)))%R
now apply Rgt_not_eq.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
e:Z
He:F2R d <> 0%R ->
(bpow (e - 1) <= Rabs (F2R d) < bpow e)%R
(F2R d >= 0)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
(F2R d <= m)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
(m < bpow (mag beta (F2R d)))%R
apply Rle_ge; now left.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
(F2R d <= m)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
(m < bpow (mag beta (F2R d)))%R
apply d_le_m.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
(m < bpow (mag beta (F2R d)))%R
case m_le_u; intros H.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:(m < F2R u)%R
(m < bpow (mag beta (F2R d)))%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:m = F2R u
(m < bpow (mag beta (F2R d)))%R
apply Rlt_le_trans with (1:=H).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:(m < F2R u)%R
(F2R u <= bpow (mag beta (F2R d)))%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:m = F2R u
(m < bpow (mag beta (F2R d)))%R
rewrite u_eq.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:(m < F2R u)%R
(round beta fexp Zceil x <= bpow (mag beta (F2R d)))%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:m = F2R u
(m < bpow (mag beta (F2R d)))%R
apply round_le_generic...
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:(m < F2R u)%R
generic_format beta fexp (bpow (mag beta (F2R d)))
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:(m < F2R u)%R
(x <= bpow (mag beta (F2R d)))%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:m = F2R u
(m < bpow (mag beta (F2R d)))%R
apply generic_format_bpow.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:(m < F2R u)%R
(fexp (mag beta (F2R d) + 1) <= mag beta (F2R d))%Z
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:(m < F2R u)%R
(x <= bpow (mag beta (F2R d)))%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:m = F2R u
(m < bpow (mag beta (F2R d)))%R
apply valid_exp.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:(m < F2R u)%R
(fexp (mag beta (F2R d)) < mag beta (F2R d))%Z
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:(m < F2R u)%R
(x <= bpow (mag beta (F2R d)))%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:m = F2R u
(m < bpow (mag beta (F2R d)))%R
apply mag_generic_gt...
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:(m < F2R u)%R
F2R d <> 0%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:(m < F2R u)%R
generic_format beta fexp (F2R d)
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:(m < F2R u)%R
(x <= bpow (mag beta (F2R d)))%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:m = F2R u
(m < bpow (mag beta (F2R d)))%R
now apply Rgt_not_eq.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:(m < F2R u)%R
generic_format beta fexp (F2R d)
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:(m < F2R u)%R
(x <= bpow (mag beta (F2R d)))%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:m = F2R u
(m < bpow (mag beta (F2R d)))%R
now apply generic_format_canonical.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:(m < F2R u)%R
(x <= bpow (mag beta (F2R d)))%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:m = F2R u
(m < bpow (mag beta (F2R d)))%R
case (Rle_or_lt x (bpow (mag beta (F2R d)))); trivial; intros Z.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:BinNums.Z -> BinNums.Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : BinNums.Z,
(fexpe e <= fexp e - 2)%Z
choice:BinNums.Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:(m < F2R u)%R
Z:(bpow (mag beta (F2R d)) < x)%R
(x <= bpow (mag beta (F2R d)))%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:m = F2R u
(m < bpow (mag beta (F2R d)))%R
absurd ((bpow (mag beta (F2R d)) <= (F2R d)))%R.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:BinNums.Z -> BinNums.Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : BinNums.Z,
(fexpe e <= fexp e - 2)%Z
choice:BinNums.Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:(m < F2R u)%R
Z:(bpow (mag beta (F2R d)) < x)%R
~ (bpow (mag beta (F2R d)) <= F2R d)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:BinNums.Z -> BinNums.Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : BinNums.Z,
(fexpe e <= fexp e - 2)%Z
choice:BinNums.Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:(m < F2R u)%R
Z:(bpow (mag beta (F2R d)) < x)%R
(bpow (mag beta (F2R d)) <= F2R d)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:m = F2R u
(m < bpow (mag beta (F2R d)))%R
apply Rlt_not_le.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:BinNums.Z -> BinNums.Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : BinNums.Z,
(fexpe e <= fexp e - 2)%Z
choice:BinNums.Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:(m < F2R u)%R
Z:(bpow (mag beta (F2R d)) < x)%R
(F2R d < bpow (mag beta (F2R d)))%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:BinNums.Z -> BinNums.Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : BinNums.Z,
(fexpe e <= fexp e - 2)%Z
choice:BinNums.Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:(m < F2R u)%R
Z:(bpow (mag beta (F2R d)) < x)%R
(bpow (mag beta (F2R d)) <= F2R d)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:m = F2R u
(m < bpow (mag beta (F2R d)))%R
destruct  (mag beta (F2R d)) as (e,He).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:BinNums.Z -> BinNums.Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : BinNums.Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:BinNums.Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:(m < F2R u)%R
e:BinNums.Z
He:F2R d <> 0%R ->
(bpow (e - 1) <= Rabs (F2R d) < bpow e)%R
Z:(bpow (Build_mag_prop beta (F2R d) e He) < x)%R
(F2R d < bpow (Build_mag_prop beta (F2R d) e He))%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:BinNums.Z -> BinNums.Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : BinNums.Z,
(fexpe e <= fexp e - 2)%Z
choice:BinNums.Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:(m < F2R u)%R
Z:(bpow (mag beta (F2R d)) < x)%R
(bpow (mag beta (F2R d)) <= F2R d)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:m = F2R u
(m < bpow (mag beta (F2R d)))%R
simpl in *; rewrite Rabs_right in He.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:BinNums.Z -> BinNums.Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : BinNums.Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:BinNums.Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:(m < F2R u)%R
e:BinNums.Z
He:F2R d <> 0%R ->
(bpow (e - 1) <= F2R d < bpow e)%R
Z:(bpow e < x)%R
(F2R d < bpow e)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:BinNums.Z -> BinNums.Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : BinNums.Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:BinNums.Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:(m < F2R u)%R
e:BinNums.Z
He:F2R d <> 0%R ->
(bpow (e - 1) <= Rabs (F2R d) < bpow e)%R
Z:(bpow e < x)%R
(F2R d >= 0)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:BinNums.Z -> BinNums.Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : BinNums.Z,
(fexpe e <= fexp e - 2)%Z
choice:BinNums.Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:(m < F2R u)%R
Z:(bpow (mag beta (F2R d)) < x)%R
(bpow (mag beta (F2R d)) <= F2R d)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:m = F2R u
(m < bpow (mag beta (F2R d)))%R
apply He.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:BinNums.Z -> BinNums.Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : BinNums.Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:BinNums.Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:(m < F2R u)%R
e:BinNums.Z
He:F2R d <> 0%R ->
(bpow (e - 1) <= F2R d < bpow e)%R
Z:(bpow e < x)%R
F2R d <> 0%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:BinNums.Z -> BinNums.Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : BinNums.Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:BinNums.Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:(m < F2R u)%R
e:BinNums.Z
He:F2R d <> 0%R ->
(bpow (e - 1) <= Rabs (F2R d) < bpow e)%R
Z:(bpow e < x)%R
(F2R d >= 0)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:BinNums.Z -> BinNums.Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : BinNums.Z,
(fexpe e <= fexp e - 2)%Z
choice:BinNums.Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:(m < F2R u)%R
Z:(bpow (mag beta (F2R d)) < x)%R
(bpow (mag beta (F2R d)) <= F2R d)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:m = F2R u
(m < bpow (mag beta (F2R d)))%R
now apply Rgt_not_eq.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:BinNums.Z -> BinNums.Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : BinNums.Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:BinNums.Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:(m < F2R u)%R
e:BinNums.Z
He:F2R d <> 0%R ->
(bpow (e - 1) <= Rabs (F2R d) < bpow e)%R
Z:(bpow e < x)%R
(F2R d >= 0)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:BinNums.Z -> BinNums.Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : BinNums.Z,
(fexpe e <= fexp e - 2)%Z
choice:BinNums.Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:(m < F2R u)%R
Z:(bpow (mag beta (F2R d)) < x)%R
(bpow (mag beta (F2R d)) <= F2R d)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:m = F2R u
(m < bpow (mag beta (F2R d)))%R
apply Rle_ge; now left.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:BinNums.Z -> BinNums.Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : BinNums.Z,
(fexpe e <= fexp e - 2)%Z
choice:BinNums.Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:(m < F2R u)%R
Z:(bpow (mag beta (F2R d)) < x)%R
(bpow (mag beta (F2R d)) <= F2R d)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:m = F2R u
(m < bpow (mag beta (F2R d)))%R
apply Rle_trans with (round beta fexp Zfloor x).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:BinNums.Z -> BinNums.Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : BinNums.Z,
(fexpe e <= fexp e - 2)%Z
choice:BinNums.Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:(m < F2R u)%R
Z:(bpow (mag beta (F2R d)) < x)%R
(bpow (mag beta (F2R d)) <= round beta fexp Zfloor x)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:BinNums.Z -> BinNums.Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : BinNums.Z,
(fexpe e <= fexp e - 2)%Z
choice:BinNums.Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:(m < F2R u)%R
Z:(bpow (mag beta (F2R d)) < x)%R
(round beta fexp Zfloor x <= F2R d)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:m = F2R u
(m < bpow (mag beta (F2R d)))%R
2: right; apply sym_eq, d_eq.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:BinNums.Z -> BinNums.Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : BinNums.Z,
(fexpe e <= fexp e - 2)%Z
choice:BinNums.Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:(m < F2R u)%R
Z:(bpow (mag beta (F2R d)) < x)%R
(bpow (mag beta (F2R d)) <= round beta fexp Zfloor x)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:m = F2R u
(m < bpow (mag beta (F2R d)))%R
apply round_ge_generic...
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:BinNums.Z -> BinNums.Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : BinNums.Z,
(fexpe e <= fexp e - 2)%Z
choice:BinNums.Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:(m < F2R u)%R
Z:(bpow (mag beta (F2R d)) < x)%R
generic_format beta fexp (bpow (mag beta (F2R d)))
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:BinNums.Z -> BinNums.Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : BinNums.Z,
(fexpe e <= fexp e - 2)%Z
choice:BinNums.Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:(m < F2R u)%R
Z:(bpow (mag beta (F2R d)) < x)%R
(bpow (mag beta (F2R d)) <= x)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:m = F2R u
(m < bpow (mag beta (F2R d)))%R
apply generic_format_bpow.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:BinNums.Z -> BinNums.Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : BinNums.Z,
(fexpe e <= fexp e - 2)%Z
choice:BinNums.Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:(m < F2R u)%R
Z:(bpow (mag beta (F2R d)) < x)%R
(fexp (mag beta (F2R d) + 1) <= mag beta (F2R d))%Z
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:BinNums.Z -> BinNums.Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : BinNums.Z,
(fexpe e <= fexp e - 2)%Z
choice:BinNums.Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:(m < F2R u)%R
Z:(bpow (mag beta (F2R d)) < x)%R
(bpow (mag beta (F2R d)) <= x)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:m = F2R u
(m < bpow (mag beta (F2R d)))%R
apply valid_exp.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:BinNums.Z -> BinNums.Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : BinNums.Z,
(fexpe e <= fexp e - 2)%Z
choice:BinNums.Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:(m < F2R u)%R
Z:(bpow (mag beta (F2R d)) < x)%R
(fexp (mag beta (F2R d)) < mag beta (F2R d))%Z
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:BinNums.Z -> BinNums.Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : BinNums.Z,
(fexpe e <= fexp e - 2)%Z
choice:BinNums.Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:(m < F2R u)%R
Z:(bpow (mag beta (F2R d)) < x)%R
(bpow (mag beta (F2R d)) <= x)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:m = F2R u
(m < bpow (mag beta (F2R d)))%R
apply mag_generic_gt...
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:BinNums.Z -> BinNums.Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : BinNums.Z,
(fexpe e <= fexp e - 2)%Z
choice:BinNums.Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:(m < F2R u)%R
Z:(bpow (mag beta (F2R d)) < x)%R
F2R d <> 0%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:BinNums.Z -> BinNums.Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : BinNums.Z,
(fexpe e <= fexp e - 2)%Z
choice:BinNums.Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:(m < F2R u)%R
Z:(bpow (mag beta (F2R d)) < x)%R
generic_format beta fexp (F2R d)
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:BinNums.Z -> BinNums.Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : BinNums.Z,
(fexpe e <= fexp e - 2)%Z
choice:BinNums.Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:(m < F2R u)%R
Z:(bpow (mag beta (F2R d)) < x)%R
(bpow (mag beta (F2R d)) <= x)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:m = F2R u
(m < bpow (mag beta (F2R d)))%R
now apply Rgt_not_eq.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:BinNums.Z -> BinNums.Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : BinNums.Z,
(fexpe e <= fexp e - 2)%Z
choice:BinNums.Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:(m < F2R u)%R
Z:(bpow (mag beta (F2R d)) < x)%R
generic_format beta fexp (F2R d)
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:BinNums.Z -> BinNums.Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : BinNums.Z,
(fexpe e <= fexp e - 2)%Z
choice:BinNums.Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:(m < F2R u)%R
Z:(bpow (mag beta (F2R d)) < x)%R
(bpow (mag beta (F2R d)) <= x)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:m = F2R u
(m < bpow (mag beta (F2R d)))%R
now apply generic_format_canonical.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:BinNums.Z -> BinNums.Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : BinNums.Z,
(fexpe e <= fexp e - 2)%Z
choice:BinNums.Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:(m < F2R u)%R
Z:(bpow (mag beta (F2R d)) < x)%R
(bpow (mag beta (F2R d)) <= x)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:m = F2R u
(m < bpow (mag beta (F2R d)))%R
now left.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:m = F2R u
(m < bpow (mag beta (F2R d)))%R
replace m with (F2R d).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:m = F2R u
(F2R d < bpow (mag beta (F2R d)))%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:m = F2R u
F2R d = m
destruct (mag beta (F2R d)) as (e,He).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:m = F2R u
e:Z
He:F2R d <> 0%R ->
(bpow (e - 1) <= Rabs (F2R d) < bpow e)%R
(F2R d < bpow (Build_mag_prop beta (F2R d) e He))%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:m = F2R u
F2R d = m
simpl in *; rewrite Rabs_right in He.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:m = F2R u
e:Z
He:F2R d <> 0%R ->
(bpow (e - 1) <= F2R d < bpow e)%R
(F2R d < bpow e)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:m = F2R u
e:Z
He:F2R d <> 0%R ->
(bpow (e - 1) <= Rabs (F2R d) < bpow e)%R
(F2R d >= 0)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:m = F2R u
F2R d = m
apply He.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:m = F2R u
e:Z
He:F2R d <> 0%R ->
(bpow (e - 1) <= F2R d < bpow e)%R
F2R d <> 0%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:m = F2R u
e:Z
He:F2R d <> 0%R ->
(bpow (e - 1) <= Rabs (F2R d) < bpow e)%R
(F2R d >= 0)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:m = F2R u
F2R d = m
now apply Rgt_not_eq.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:m = F2R u
e:Z
He:F2R d <> 0%R ->
(bpow (e - 1) <= Rabs (F2R d) < bpow e)%R
(F2R d >= 0)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:m = F2R u
F2R d = m
apply Rle_ge; now left.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:m = F2R u
F2R d = m
unfold m in H |- *.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
dPos:(0 < F2R d)%R
H:((F2R d + F2R u) / 2)%R = F2R u
F2R d = ((F2R d + F2R u) / 2)%R
lra.
Qed.


Lemma mag_m_0: (0 = F2R d)%R
    -> (mag beta m =mag beta (F2R u)-1:>Z)%Z.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
0%R = F2R d -> mag beta m = (mag beta (F2R u) - 1)%Z
Proof with auto with typeclass_instances.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
0%R = F2R d -> mag beta m = (mag beta (F2R u) - 1)%Z
intros Y.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
mag beta m = (mag beta (F2R u) - 1)%Z
apply mag_unique_pos.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
(bpow (mag beta (F2R u) - 1 - 1) <= m <
 bpow (mag beta (F2R u) - 1))%R
unfold m; rewrite <- Y, Rplus_0_l.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
(bpow (mag beta (F2R u) - 1 - 1) <= F2R u / 2 <
 bpow (mag beta (F2R u) - 1))%R
rewrite u_eq.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
(bpow (mag beta (round beta fexp Zceil x) - 1 - 1) <=
 round beta fexp Zceil x / 2 <
 bpow (mag beta (round beta fexp Zceil x) - 1))%R
destruct (mag beta x) as (e,He).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= Rabs x < bpow e)%R
(bpow (mag beta (round beta fexp Zceil x) - 1 - 1) <=
 round beta fexp Zceil x / 2 <
 bpow (mag beta (round beta fexp Zceil x) - 1))%R
rewrite Rabs_pos_eq in He by now apply Rlt_le.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(bpow (mag beta (round beta fexp Zceil x) - 1 - 1) <=
 round beta fexp Zceil x / 2 <
 bpow (mag beta (round beta fexp Zceil x) - 1))%R
rewrite round_UP_small_pos with (ex:=e).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(bpow (mag beta (bpow (fexp e)) - 1 - 1) <=
 bpow (fexp e) / 2 <
 bpow (mag beta (bpow (fexp e)) - 1))%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(bpow (e - 1) <= x < bpow e)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(e <= fexp e)%Z
rewrite mag_bpow.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(bpow (fexp e + 1 - 1 - 1) <= bpow (fexp e) / 2 <
 bpow (fexp e + 1 - 1))%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(bpow (e - 1) <= x < bpow e)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(e <= fexp e)%Z
ring_simplify (fexp e + 1 - 1)%Z.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(bpow (fexp e - 1) <= bpow (fexp e) / 2 <
 bpow (fexp e))%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(bpow (e - 1) <= x < bpow e)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(e <= fexp e)%Z
split.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(bpow (fexp e - 1) <= bpow (fexp e) / 2)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(bpow (fexp e) / 2 < bpow (fexp e))%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(bpow (e - 1) <= x < bpow e)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(e <= fexp e)%Z
unfold Zminus; rewrite bpow_plus.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(bpow (fexp e) * bpow (- (1)) <= bpow (fexp e) / 2)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(bpow (fexp e) / 2 < bpow (fexp e))%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(bpow (e - 1) <= x < bpow e)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(e <= fexp e)%Z
unfold Rdiv; apply Rmult_le_compat_l.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(0 <= bpow (fexp e))%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(bpow (- (1)) <= / 2)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(bpow (fexp e) / 2 < bpow (fexp e))%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(bpow (e - 1) <= x < bpow e)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(e <= fexp e)%Z
apply bpow_ge_0.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(bpow (- (1)) <= / 2)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(bpow (fexp e) / 2 < bpow (fexp e))%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(bpow (e - 1) <= x < bpow e)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(e <= fexp e)%Z
simpl; unfold Z.pow_pos; simpl.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(/ IZR (beta * 1) <= / 2)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(bpow (fexp e) / 2 < bpow (fexp e))%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(bpow (e - 1) <= x < bpow e)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(e <= fexp e)%Z
rewrite Zmult_1_r; apply Rinv_le.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(0 < 2)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(2 <= IZR beta)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(bpow (fexp e) / 2 < bpow (fexp e))%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(bpow (e - 1) <= x < bpow e)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(e <= fexp e)%Z
exact Rlt_0_2.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(2 <= IZR beta)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(bpow (fexp e) / 2 < bpow (fexp e))%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(bpow (e - 1) <= x < bpow e)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(e <= fexp e)%Z
apply IZR_le.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(2 <= beta)%Z
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(bpow (fexp e) / 2 < bpow (fexp e))%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(bpow (e - 1) <= x < bpow e)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(e <= fexp e)%Z
specialize (radix_gt_1 beta).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(1 < beta)%Z -> (2 <= beta)%Z
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(bpow (fexp e) / 2 < bpow (fexp e))%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(bpow (e - 1) <= x < bpow e)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(e <= fexp e)%Z
omega.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(bpow (fexp e) / 2 < bpow (fexp e))%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(bpow (e - 1) <= x < bpow e)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(e <= fexp e)%Z
apply Rlt_le_trans with (bpow (fexp e)*1)%R.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(bpow (fexp e) / 2 < bpow (fexp e) * 1)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(bpow (fexp e) * 1 <= bpow (fexp e))%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(bpow (e - 1) <= x < bpow e)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(e <= fexp e)%Z
2: right; ring.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(bpow (fexp e) / 2 < bpow (fexp e) * 1)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(bpow (e - 1) <= x < bpow e)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(e <= fexp e)%Z
unfold Rdiv; apply Rmult_lt_compat_l.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(0 < bpow (fexp e))%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(/ 2 < 1)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(bpow (e - 1) <= x < bpow e)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(e <= fexp e)%Z
apply bpow_gt_0.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(/ 2 < 1)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(bpow (e - 1) <= x < bpow e)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(e <= fexp e)%Z
lra.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(bpow (e - 1) <= x < bpow e)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(e <= fexp e)%Z
now apply He, Rgt_not_eq.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(e <= fexp e)%Z
apply exp_small_round_0_pos with beta (Zfloor) x...
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(bpow (e - 1) <= x < bpow e)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
round beta fexp Zfloor x = 0%R
now apply He, Rgt_not_eq.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
round beta fexp Zfloor x = 0%R
now rewrite <- d_eq, Y.
Qed.





Lemma u'_eq:  (0 < F2R d)%R -> exists f:float beta, F2R f = F2R u /\ (Fexp f = Fexp d)%Z.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
(0 < F2R d)%R ->
exists f : float beta,
  F2R f = F2R u /\ Fexp f = Fexp d
Proof with auto with typeclass_instances.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
(0 < F2R d)%R ->
exists f : float beta,
  F2R f = F2R u /\ Fexp f = Fexp d
intros Y.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
exists f : float beta,
  F2R f = F2R u /\ Fexp f = Fexp d
rewrite u_eq; unfold round.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
exists f : float beta,
  F2R f =
  F2R
    {|
    Fnum := Zceil (scaled_mantissa beta fexp x);
    Fexp := cexp beta fexp x |} /\ Fexp f = Fexp d
eexists; repeat split.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
Fexp
  {|
  Fnum := Zceil (scaled_mantissa beta fexp x);
  Fexp := cexp beta fexp x |} = Fexp d
simpl; now rewrite Fexp_d.
Qed.


Lemma m_eq :
  (0 < F2R d)%R ->
  exists f:float beta,
  F2R f = m /\ (Fexp f = fexp (mag beta x) - 1)%Z.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
(0 < F2R d)%R ->
exists f : float beta,
  F2R f = m /\ Fexp f = (fexp (mag beta x) - 1)%Z
Proof with auto with typeclass_instances.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
(0 < F2R d)%R ->
exists f : float beta,
  F2R f = m /\ Fexp f = (fexp (mag beta x) - 1)%Z
intros Y.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
exists f : float beta,
  F2R f = m /\ Fexp f = (fexp (mag beta x) - 1)%Z
specialize (Zeven_ex (radix_val beta)); rewrite Even_beta.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
(exists p : Z, beta = (2 * p + 0)%Z) ->
exists f : float beta,
  F2R f = m /\ Fexp f = (fexp (mag beta x) - 1)%Z
intros (b, Hb); rewrite Zplus_0_r in Hb.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
b:Z
Hb:beta = (2 * b)%Z
exists f : float beta,
  F2R f = m /\ Fexp f = (fexp (mag beta x) - 1)%Z
destruct u'_eq as (u', (Hu'1,Hu'2)); trivial.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
b:Z
Hb:beta = (2 * b)%Z
u':float beta
Hu'1:F2R u' = F2R u
Hu'2:Fexp u' = Fexp d
exists f : float beta,
  F2R f = m /\ Fexp f = (fexp (mag beta x) - 1)%Z
exists (Fmult (Float beta b (-1)) (Fplus d u'))%R.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
b:Z
Hb:beta = (2 * b)%Z
u':float beta
Hu'1:F2R u' = F2R u
Hu'2:Fexp u' = Fexp d
F2R (Fmult {| Fnum := b; Fexp := -1 |} (Fplus d u')) =
m /\
Fexp (Fmult {| Fnum := b; Fexp := -1 |} (Fplus d u')) =
(fexp (mag beta x) - 1)%Z
split.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
b:Z
Hb:beta = (2 * b)%Z
u':float beta
Hu'1:F2R u' = F2R u
Hu'2:Fexp u' = Fexp d
F2R (Fmult {| Fnum := b; Fexp := -1 |} (Fplus d u')) =
m
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
b:Z
Hb:beta = (2 * b)%Z
u':float beta
Hu'1:F2R u' = F2R u
Hu'2:Fexp u' = Fexp d
Fexp (Fmult {| Fnum := b; Fexp := -1 |} (Fplus d u')) =
(fexp (mag beta x) - 1)%Z
rewrite F2R_mult, F2R_plus, Hu'1.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
b:Z
Hb:beta = (2 * b)%Z
u':float beta
Hu'1:F2R u' = F2R u
Hu'2:Fexp u' = Fexp d
(F2R {| Fnum := b; Fexp := -1 |} * (F2R d + F2R u))%R =
m
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
b:Z
Hb:beta = (2 * b)%Z
u':float beta
Hu'1:F2R u' = F2R u
Hu'2:Fexp u' = Fexp d
Fexp (Fmult {| Fnum := b; Fexp := -1 |} (Fplus d u')) =
(fexp (mag beta x) - 1)%Z
unfold m; rewrite Rmult_comm.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
b:Z
Hb:beta = (2 * b)%Z
u':float beta
Hu'1:F2R u' = F2R u
Hu'2:Fexp u' = Fexp d
((F2R d + F2R u) * F2R {| Fnum := b; Fexp := -1 |})%R =
((F2R d + F2R u) / 2)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
b:Z
Hb:beta = (2 * b)%Z
u':float beta
Hu'1:F2R u' = F2R u
Hu'2:Fexp u' = Fexp d
Fexp (Fmult {| Fnum := b; Fexp := -1 |} (Fplus d u')) =
(fexp (mag beta x) - 1)%Z
unfold Rdiv; apply f_equal.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
b:Z
Hb:beta = (2 * b)%Z
u':float beta
Hu'1:F2R u' = F2R u
Hu'2:Fexp u' = Fexp d
F2R {| Fnum := b; Fexp := -1 |} = (/ 2)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
b:Z
Hb:beta = (2 * b)%Z
u':float beta
Hu'1:F2R u' = F2R u
Hu'2:Fexp u' = Fexp d
Fexp (Fmult {| Fnum := b; Fexp := -1 |} (Fplus d u')) =
(fexp (mag beta x) - 1)%Z
unfold F2R; simpl; unfold Z.pow_pos; simpl.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
b:Z
Hb:beta = (2 * b)%Z
u':float beta
Hu'1:F2R u' = F2R u
Hu'2:Fexp u' = Fexp d
(IZR b * / IZR (beta * 1))%R = (/ 2)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
b:Z
Hb:beta = (2 * b)%Z
u':float beta
Hu'1:F2R u' = F2R u
Hu'2:Fexp u' = Fexp d
Fexp (Fmult {| Fnum := b; Fexp := -1 |} (Fplus d u')) =
(fexp (mag beta x) - 1)%Z
rewrite Zmult_1_r, Hb, mult_IZR.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
b:Z
Hb:beta = (2 * b)%Z
u':float beta
Hu'1:F2R u' = F2R u
Hu'2:Fexp u' = Fexp d
(IZR b * / (2 * IZR b))%R = (/ 2)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
b:Z
Hb:beta = (2 * b)%Z
u':float beta
Hu'1:F2R u' = F2R u
Hu'2:Fexp u' = Fexp d
Fexp (Fmult {| Fnum := b; Fexp := -1 |} (Fplus d u')) =
(fexp (mag beta x) - 1)%Z
simpl; field.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
b:Z
Hb:beta = (2 * b)%Z
u':float beta
Hu'1:F2R u' = F2R u
Hu'2:Fexp u' = Fexp d
IZR b <> 0%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
b:Z
Hb:beta = (2 * b)%Z
u':float beta
Hu'1:F2R u' = F2R u
Hu'2:Fexp u' = Fexp d
Fexp (Fmult {| Fnum := b; Fexp := -1 |} (Fplus d u')) =
(fexp (mag beta x) - 1)%Z
apply Rgt_not_eq, Rmult_lt_reg_l with (1 := Rlt_0_2).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
b:Z
Hb:beta = (2 * b)%Z
u':float beta
Hu'1:F2R u' = F2R u
Hu'2:Fexp u' = Fexp d
(2 * 0 < 2 * IZR b)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
b:Z
Hb:beta = (2 * b)%Z
u':float beta
Hu'1:F2R u' = F2R u
Hu'2:Fexp u' = Fexp d
Fexp (Fmult {| Fnum := b; Fexp := -1 |} (Fplus d u')) =
(fexp (mag beta x) - 1)%Z
rewrite Rmult_0_r, <- (mult_IZR 2), <-Hb.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
b:Z
Hb:beta = (2 * b)%Z
u':float beta
Hu'1:F2R u' = F2R u
Hu'2:Fexp u' = Fexp d
(0 < IZR beta)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
b:Z
Hb:beta = (2 * b)%Z
u':float beta
Hu'1:F2R u' = F2R u
Hu'2:Fexp u' = Fexp d
Fexp (Fmult {| Fnum := b; Fexp := -1 |} (Fplus d u')) =
(fexp (mag beta x) - 1)%Z
apply radix_pos.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
b:Z
Hb:beta = (2 * b)%Z
u':float beta
Hu'1:F2R u' = F2R u
Hu'2:Fexp u' = Fexp d
Fexp (Fmult {| Fnum := b; Fexp := -1 |} (Fplus d u')) =
(fexp (mag beta x) - 1)%Z
apply trans_eq with (-1+Fexp (Fplus d u'))%Z.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
b:Z
Hb:beta = (2 * b)%Z
u':float beta
Hu'1:F2R u' = F2R u
Hu'2:Fexp u' = Fexp d
Fexp (Fmult {| Fnum := b; Fexp := -1 |} (Fplus d u')) =
(-1 + Fexp (Fplus d u'))%Z
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
b:Z
Hb:beta = (2 * b)%Z
u':float beta
Hu'1:F2R u' = F2R u
Hu'2:Fexp u' = Fexp d
(-1 + Fexp (Fplus d u'))%Z = (fexp (mag beta x) - 1)%Z
unfold Fmult.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
b:Z
Hb:beta = (2 * b)%Z
u':float beta
Hu'1:F2R u' = F2R u
Hu'2:Fexp u' = Fexp d
Fexp
  (let
   '{| Fnum := m2; Fexp := e2 |} := Fplus d u' in
    {| Fnum := b * m2; Fexp := -1 + e2 |}) =
(-1 + Fexp (Fplus d u'))%Z
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
b:Z
Hb:beta = (2 * b)%Z
u':float beta
Hu'1:F2R u' = F2R u
Hu'2:Fexp u' = Fexp d
(-1 + Fexp (Fplus d u'))%Z = (fexp (mag beta x) - 1)%Z
destruct  (Fplus d u'); reflexivity.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
b:Z
Hb:beta = (2 * b)%Z
u':float beta
Hu'1:F2R u' = F2R u
Hu'2:Fexp u' = Fexp d
(-1 + Fexp (Fplus d u'))%Z = (fexp (mag beta x) - 1)%Z
rewrite Zplus_comm; unfold Zminus; apply f_equal2.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
b:Z
Hb:beta = (2 * b)%Z
u':float beta
Hu'1:F2R u' = F2R u
Hu'2:Fexp u' = Fexp d
Fexp (Fplus d u') = fexp (mag beta x)
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
b:Z
Hb:beta = (2 * b)%Z
u':float beta
Hu'1:F2R u' = F2R u
Hu'2:Fexp u' = Fexp d
(-1)%Z = (- (1))%Z
2: reflexivity.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
b:Z
Hb:beta = (2 * b)%Z
u':float beta
Hu'1:F2R u' = F2R u
Hu'2:Fexp u' = Fexp d
Fexp (Fplus d u') = fexp (mag beta x)
rewrite Fexp_Fplus.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
b:Z
Hb:beta = (2 * b)%Z
u':float beta
Hu'1:F2R u' = F2R u
Hu'2:Fexp u' = Fexp d
Z.min (Fexp d) (Fexp u') = fexp (mag beta x)
rewrite Z.min_l.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
b:Z
Hb:beta = (2 * b)%Z
u':float beta
Hu'1:F2R u' = F2R u
Hu'2:Fexp u' = Fexp d
Fexp d = fexp (mag beta x)
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
b:Z
Hb:beta = (2 * b)%Z
u':float beta
Hu'1:F2R u' = F2R u
Hu'2:Fexp u' = Fexp d
(Fexp d <= Fexp u')%Z
now rewrite Fexp_d.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
b:Z
Hb:beta = (2 * b)%Z
u':float beta
Hu'1:F2R u' = F2R u
Hu'2:Fexp u' = Fexp d
(Fexp d <= Fexp u')%Z
rewrite Hu'2; omega.
Qed.

Lemma m_eq_0: (0 = F2R d)%R ->  exists f:float beta,
   F2R f = m /\ (Fexp f = fexp (mag beta (F2R u)) -1)%Z.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
0%R = F2R d ->
exists f : float beta,
  F2R f = m /\
  Fexp f = (fexp (mag beta (F2R u)) - 1)%Z
Proof with auto with typeclass_instances.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
0%R = F2R d ->
exists f : float beta,
  F2R f = m /\
  Fexp f = (fexp (mag beta (F2R u)) - 1)%Z
intros Y.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
exists f : float beta,
  F2R f = m /\
  Fexp f = (fexp (mag beta (F2R u)) - 1)%Z
specialize (Zeven_ex (radix_val beta)); rewrite Even_beta.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
(exists p : Z, beta = (2 * p + 0)%Z) ->
exists f : float beta,
  F2R f = m /\
  Fexp f = (fexp (mag beta (F2R u)) - 1)%Z
intros (b, Hb); rewrite Zplus_0_r in Hb.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
b:Z
Hb:beta = (2 * b)%Z
exists f : float beta,
  F2R f = m /\
  Fexp f = (fexp (mag beta (F2R u)) - 1)%Z
exists (Fmult (Float beta b (-1)) u)%R.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
b:Z
Hb:beta = (2 * b)%Z
F2R (Fmult {| Fnum := b; Fexp := -1 |} u) = m /\
Fexp (Fmult {| Fnum := b; Fexp := -1 |} u) =
(fexp (mag beta (F2R u)) - 1)%Z
split.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
b:Z
Hb:beta = (2 * b)%Z
F2R (Fmult {| Fnum := b; Fexp := -1 |} u) = m
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
b:Z
Hb:beta = (2 * b)%Z
Fexp (Fmult {| Fnum := b; Fexp := -1 |} u) =
(fexp (mag beta (F2R u)) - 1)%Z
rewrite F2R_mult; unfold m; rewrite <- Y, Rplus_0_l.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
b:Z
Hb:beta = (2 * b)%Z
(F2R {| Fnum := b; Fexp := -1 |} * F2R u)%R =
(F2R u / 2)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
b:Z
Hb:beta = (2 * b)%Z
Fexp (Fmult {| Fnum := b; Fexp := -1 |} u) =
(fexp (mag beta (F2R u)) - 1)%Z
rewrite Rmult_comm.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
b:Z
Hb:beta = (2 * b)%Z
(F2R u * F2R {| Fnum := b; Fexp := -1 |})%R =
(F2R u / 2)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
b:Z
Hb:beta = (2 * b)%Z
Fexp (Fmult {| Fnum := b; Fexp := -1 |} u) =
(fexp (mag beta (F2R u)) - 1)%Z
unfold Rdiv; apply f_equal.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
b:Z
Hb:beta = (2 * b)%Z
F2R {| Fnum := b; Fexp := -1 |} = (/ 2)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
b:Z
Hb:beta = (2 * b)%Z
Fexp (Fmult {| Fnum := b; Fexp := -1 |} u) =
(fexp (mag beta (F2R u)) - 1)%Z
unfold F2R; simpl; unfold Z.pow_pos; simpl.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
b:Z
Hb:beta = (2 * b)%Z
(IZR b * / IZR (beta * 1))%R = (/ 2)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
b:Z
Hb:beta = (2 * b)%Z
Fexp (Fmult {| Fnum := b; Fexp := -1 |} u) =
(fexp (mag beta (F2R u)) - 1)%Z
rewrite Zmult_1_r, Hb, mult_IZR.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
b:Z
Hb:beta = (2 * b)%Z
(IZR b * / (2 * IZR b))%R = (/ 2)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
b:Z
Hb:beta = (2 * b)%Z
Fexp (Fmult {| Fnum := b; Fexp := -1 |} u) =
(fexp (mag beta (F2R u)) - 1)%Z
simpl; field.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
b:Z
Hb:beta = (2 * b)%Z
IZR b <> 0%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
b:Z
Hb:beta = (2 * b)%Z
Fexp (Fmult {| Fnum := b; Fexp := -1 |} u) =
(fexp (mag beta (F2R u)) - 1)%Z
apply Rgt_not_eq, Rmult_lt_reg_l with (1 := Rlt_0_2).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
b:Z
Hb:beta = (2 * b)%Z
(2 * 0 < 2 * IZR b)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
b:Z
Hb:beta = (2 * b)%Z
Fexp (Fmult {| Fnum := b; Fexp := -1 |} u) =
(fexp (mag beta (F2R u)) - 1)%Z
rewrite Rmult_0_r, <- (mult_IZR 2), <-Hb.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
b:Z
Hb:beta = (2 * b)%Z
(0 < IZR beta)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
b:Z
Hb:beta = (2 * b)%Z
Fexp (Fmult {| Fnum := b; Fexp := -1 |} u) =
(fexp (mag beta (F2R u)) - 1)%Z
apply radix_pos.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
b:Z
Hb:beta = (2 * b)%Z
Fexp (Fmult {| Fnum := b; Fexp := -1 |} u) =
(fexp (mag beta (F2R u)) - 1)%Z
apply trans_eq with (-1+Fexp u)%Z.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
b:Z
Hb:beta = (2 * b)%Z
Fexp (Fmult {| Fnum := b; Fexp := -1 |} u) =
(-1 + Fexp u)%Z
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
b:Z
Hb:beta = (2 * b)%Z
(-1 + Fexp u)%Z = (fexp (mag beta (F2R u)) - 1)%Z
unfold Fmult.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
b:Z
Hb:beta = (2 * b)%Z
Fexp
  (let
   '{| Fnum := m2; Fexp := e2 |} := u in
    {| Fnum := b * m2; Fexp := -1 + e2 |}) =
(-1 + Fexp u)%Z
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
b:Z
Hb:beta = (2 * b)%Z
(-1 + Fexp u)%Z = (fexp (mag beta (F2R u)) - 1)%Z
destruct u; reflexivity.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
b:Z
Hb:beta = (2 * b)%Z
(-1 + Fexp u)%Z = (fexp (mag beta (F2R u)) - 1)%Z
rewrite Zplus_comm, Cu; unfold Zminus; now apply f_equal2.
Qed.

Lemma fexp_m_eq_0:  (0 = F2R d)%R ->
  (fexp (mag beta (F2R u)-1) < fexp (mag beta (F2R u))+1)%Z.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
0%R = F2R d ->
(fexp (mag beta (F2R u) - 1) <
 fexp (mag beta (F2R u)) + 1)%Z
Proof with auto with typeclass_instances.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
0%R = F2R d ->
(fexp (mag beta (F2R u) - 1) <
 fexp (mag beta (F2R u)) + 1)%Z
intros Y.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
(fexp (mag beta (F2R u) - 1) <
 fexp (mag beta (F2R u)) + 1)%Z
assert ((fexp (mag beta (F2R u) - 1) <= fexp (mag beta (F2R u))))%Z.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
(fexp (mag beta (F2R u) - 1) <=
 fexp (mag beta (F2R u)))%Z
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
H:(fexp (mag beta (F2R u) - 1) <=
 fexp (mag beta (F2R u)))%Z
(fexp (mag beta (F2R u) - 1) <
 fexp (mag beta (F2R u)) + 1)%Z
2: omega.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
(fexp (mag beta (F2R u) - 1) <=
 fexp (mag beta (F2R u)))%Z
destruct (mag beta x) as (e,He).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= Rabs x < bpow e)%R
(fexp (mag beta (F2R u) - 1) <=
 fexp (mag beta (F2R u)))%Z
rewrite Rabs_right in He.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(fexp (mag beta (F2R u) - 1) <=
 fexp (mag beta (F2R u)))%Z
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= Rabs x < bpow e)%R
(x >= 0)%R
2: now left.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(fexp (mag beta (F2R u) - 1) <=
 fexp (mag beta (F2R u)))%Z
assert (e <= fexp e)%Z.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(e <= fexp e)%Z
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
H:(e <= fexp e)%Z
(fexp (mag beta (F2R u) - 1) <=
 fexp (mag beta (F2R u)))%Z
apply exp_small_round_0_pos with beta (Zfloor) x...
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
(bpow (e - 1) <= x < bpow e)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
round beta fexp Zfloor x = 0%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
H:(e <= fexp e)%Z
(fexp (mag beta (F2R u) - 1) <=
 fexp (mag beta (F2R u)))%Z
now apply He, Rgt_not_eq.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
round beta fexp Zfloor x = 0%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
H:(e <= fexp e)%Z
(fexp (mag beta (F2R u) - 1) <=
 fexp (mag beta (F2R u)))%Z
now rewrite <- d_eq, Y.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
H:(e <= fexp e)%Z
(fexp (mag beta (F2R u) - 1) <=
 fexp (mag beta (F2R u)))%Z
rewrite u_eq, round_UP_small_pos with (ex:=e); trivial.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
H:(e <= fexp e)%Z
(fexp (mag beta (bpow (fexp e)) - 1) <=
 fexp (mag beta (bpow (fexp e))))%Z
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
H:(e <= fexp e)%Z
(bpow (e - 1) <= x < bpow e)%R
2: now apply He, Rgt_not_eq.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
H:(e <= fexp e)%Z
(fexp (mag beta (bpow (fexp e)) - 1) <=
 fexp (mag beta (bpow (fexp e))))%Z
rewrite mag_bpow.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
H:(e <= fexp e)%Z
(fexp (fexp e + 1 - 1) <= fexp (fexp e + 1))%Z
ring_simplify (fexp e + 1 - 1)%Z.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
H:(e <= fexp e)%Z
(fexp (fexp e) <= fexp (fexp e + 1))%Z
replace (fexp (fexp e)) with (fexp e).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
H:(e <= fexp e)%Z
(fexp e <= fexp (fexp e + 1))%Z
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
H:(e <= fexp e)%Z
fexp e = fexp (fexp e)
case exists_NE_; intros V.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
H:(e <= fexp e)%Z
V:Z.even beta = false
(fexp e <= fexp (fexp e + 1))%Z
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
H:(e <= fexp e)%Z
V:forall e0 : Z,
((fexp e0 < e0)%Z -> (fexp (e0 + 1) < e0)%Z) /\
((e0 <= fexp e0)%Z -> fexp (fexp e0 + 1) = fexp e0)
(fexp e <= fexp (fexp e + 1))%Z
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
H:(e <= fexp e)%Z
fexp e = fexp (fexp e)
contradict V; rewrite Even_beta; discriminate.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
H:(e <= fexp e)%Z
V:forall e0 : Z,
((fexp e0 < e0)%Z -> (fexp (e0 + 1) < e0)%Z) /\
((e0 <= fexp e0)%Z -> fexp (fexp e0 + 1) = fexp e0)
(fexp e <= fexp (fexp e + 1))%Z
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
H:(e <= fexp e)%Z
fexp e = fexp (fexp e)
rewrite (proj2 (V e)); omega.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e0 : Z,
(fexpe e0 <= fexp e0 - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
e:Z
He:x <> 0%R -> (bpow (e - 1) <= x < bpow e)%R
H:(e <= fexp e)%Z
fexp e = fexp (fexp e)
apply sym_eq, valid_exp; omega.
Qed.

Lemma Fm:  generic_format beta fexpe m.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
generic_format beta fexpe m
Proof.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
generic_format beta fexpe m
case (d_ge_0); intros Y.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
generic_format beta fexpe m
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
generic_format beta fexpe m
(* *)
destruct m_eq as (g,(Hg1,Hg2)); trivial.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
g:float beta
Hg1:F2R g = m
Hg2:Fexp g = (fexp (mag beta x) - 1)%Z
generic_format beta fexpe m
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
generic_format beta fexpe m
apply generic_format_F2R' with g.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
g:float beta
Hg1:F2R g = m
Hg2:Fexp g = (fexp (mag beta x) - 1)%Z
F2R g = m
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
g:float beta
Hg1:F2R g = m
Hg2:Fexp g = (fexp (mag beta x) - 1)%Z
m <> 0%R -> (cexp beta fexpe m <= Fexp g)%Z
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
generic_format beta fexpe m
now apply sym_eq.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
g:float beta
Hg1:F2R g = m
Hg2:Fexp g = (fexp (mag beta x) - 1)%Z
m <> 0%R -> (cexp beta fexpe m <= Fexp g)%Z
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
generic_format beta fexpe m
intros H; unfold cexp; rewrite Hg2.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
g:float beta
Hg1:F2R g = m
Hg2:Fexp g = (fexp (mag beta x) - 1)%Z
H:m <> 0%R
(fexpe (mag beta m) <= fexp (mag beta x) - 1)%Z
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
generic_format beta fexpe m
rewrite mag_m; trivial.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
g:float beta
Hg1:F2R g = m
Hg2:Fexp g = (fexp (mag beta x) - 1)%Z
H:m <> 0%R
(fexpe (mag beta (F2R d)) <= fexp (mag beta x) - 1)%Z
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
generic_format beta fexpe m
rewrite <- Fexp_d; trivial.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
g:float beta
Hg1:F2R g = m
Hg2:Fexp g = (fexp (mag beta x) - 1)%Z
H:m <> 0%R
(fexpe (mag beta (F2R d)) <= Fexp d - 1)%Z
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
generic_format beta fexpe m
rewrite Cd.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
g:float beta
Hg1:F2R g = m
Hg2:Fexp g = (fexp (mag beta x) - 1)%Z
H:m <> 0%R
(fexpe (mag beta (F2R d)) <=
 cexp beta fexp (F2R d) - 1)%Z
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
generic_format beta fexpe m
unfold cexp.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
g:float beta
Hg1:F2R g = m
Hg2:Fexp g = (fexp (mag beta x) - 1)%Z
H:m <> 0%R
(fexpe (mag beta (F2R d)) <=
 fexp (mag beta (F2R d)) - 1)%Z
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
generic_format beta fexpe m
generalize (fexpe_fexp (mag beta (F2R d))).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
g:float beta
Hg1:F2R g = m
Hg2:Fexp g = (fexp (mag beta x) - 1)%Z
H:m <> 0%R
(fexpe (mag beta (F2R d)) <=
 fexp (mag beta (F2R d)) - 2)%Z ->
(fexpe (mag beta (F2R d)) <=
 fexp (mag beta (F2R d)) - 1)%Z
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
generic_format beta fexpe m
omega.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
generic_format beta fexpe m
(* *)
destruct m_eq_0 as (g,(Hg1,Hg2)); trivial.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
g:float beta
Hg1:F2R g = m
Hg2:Fexp g = (fexp (mag beta (F2R u)) - 1)%Z
generic_format beta fexpe m
apply generic_format_F2R' with g.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
g:float beta
Hg1:F2R g = m
Hg2:Fexp g = (fexp (mag beta (F2R u)) - 1)%Z
F2R g = m
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
g:float beta
Hg1:F2R g = m
Hg2:Fexp g = (fexp (mag beta (F2R u)) - 1)%Z
m <> 0%R -> (cexp beta fexpe m <= Fexp g)%Z
assumption.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
g:float beta
Hg1:F2R g = m
Hg2:Fexp g = (fexp (mag beta (F2R u)) - 1)%Z
m <> 0%R -> (cexp beta fexpe m <= Fexp g)%Z
intros H; unfold cexp; rewrite Hg2.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
g:float beta
Hg1:F2R g = m
Hg2:Fexp g = (fexp (mag beta (F2R u)) - 1)%Z
H:m <> 0%R
(fexpe (mag beta m) <= fexp (mag beta (F2R u)) - 1)%Z
rewrite mag_m_0; try assumption.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
g:float beta
Hg1:F2R g = m
Hg2:Fexp g = (fexp (mag beta (F2R u)) - 1)%Z
H:m <> 0%R
(fexpe (mag beta (F2R u) - 1) <=
 fexp (mag beta (F2R u)) - 1)%Z
apply Z.le_trans with (1:=fexpe_fexp _).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
g:float beta
Hg1:F2R g = m
Hg2:Fexp g = (fexp (mag beta (F2R u)) - 1)%Z
H:m <> 0%R
(fexp (mag beta (F2R u) - 1) - 2 <=
 fexp (mag beta (F2R u)) - 1)%Z
generalize (fexp_m_eq_0 Y).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
g:float beta
Hg1:F2R g = m
Hg2:Fexp g = (fexp (mag beta (F2R u)) - 1)%Z
H:m <> 0%R
(fexp (mag beta (F2R u) - 1) <
 fexp (mag beta (F2R u)) + 1)%Z ->
(fexp (mag beta (F2R u) - 1) - 2 <=
 fexp (mag beta (F2R u)) - 1)%Z
omega.
Qed.



Lemma Zm:
   exists g : float beta, F2R g = m /\ canonical beta fexpe g /\ Z.even (Fnum g) = true.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
exists g : float beta,
  F2R g = m /\
  canonical beta fexpe g /\ Z.even (Fnum g) = true
Proof with auto with typeclass_instances.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
exists g : float beta,
  F2R g = m /\
  canonical beta fexpe g /\ Z.even (Fnum g) = true
case (d_ge_0); intros Y.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
exists g : float beta,
  F2R g = m /\
  canonical beta fexpe g /\ Z.even (Fnum g) = true
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
exists g : float beta,
  F2R g = m /\
  canonical beta fexpe g /\ Z.even (Fnum g) = true
(* *)
destruct m_eq as (g,(Hg1,Hg2)); trivial.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
g:float beta
Hg1:F2R g = m
Hg2:Fexp g = (fexp (mag beta x) - 1)%Z
exists g0 : float beta,
  F2R g0 = m /\
  canonical beta fexpe g0 /\ Z.even (Fnum g0) = true
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
exists g : float beta,
  F2R g = m /\
  canonical beta fexpe g /\ Z.even (Fnum g) = true
apply exists_even_fexp_lt.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
g:float beta
Hg1:F2R g = m
Hg2:Fexp g = (fexp (mag beta x) - 1)%Z
exists f : float beta,
  F2R f = m /\ (fexpe (mag beta m) < Fexp f)%Z
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
exists g : float beta,
  F2R g = m /\
  canonical beta fexpe g /\ Z.even (Fnum g) = true
exists g; split; trivial.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
g:float beta
Hg1:F2R g = m
Hg2:Fexp g = (fexp (mag beta x) - 1)%Z
(fexpe (mag beta m) < Fexp g)%Z
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
exists g : float beta,
  F2R g = m /\
  canonical beta fexpe g /\ Z.even (Fnum g) = true
rewrite Hg2.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
g:float beta
Hg1:F2R g = m
Hg2:Fexp g = (fexp (mag beta x) - 1)%Z
(fexpe (mag beta m) < fexp (mag beta x) - 1)%Z
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
exists g : float beta,
  F2R g = m /\
  canonical beta fexpe g /\ Z.even (Fnum g) = true
rewrite mag_m; trivial.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
g:float beta
Hg1:F2R g = m
Hg2:Fexp g = (fexp (mag beta x) - 1)%Z
(fexpe (mag beta (F2R d)) < fexp (mag beta x) - 1)%Z
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
exists g : float beta,
  F2R g = m /\
  canonical beta fexpe g /\ Z.even (Fnum g) = true
rewrite <- Fexp_d; trivial.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
g:float beta
Hg1:F2R g = m
Hg2:Fexp g = (fexp (mag beta x) - 1)%Z
(fexpe (mag beta (F2R d)) < Fexp d - 1)%Z
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
exists g : float beta,
  F2R g = m /\
  canonical beta fexpe g /\ Z.even (Fnum g) = true
rewrite Cd.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
g:float beta
Hg1:F2R g = m
Hg2:Fexp g = (fexp (mag beta x) - 1)%Z
(fexpe (mag beta (F2R d)) < cexp beta fexp (F2R d) - 1)%Z
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
exists g : float beta,
  F2R g = m /\
  canonical beta fexpe g /\ Z.even (Fnum g) = true
unfold cexp.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
g:float beta
Hg1:F2R g = m
Hg2:Fexp g = (fexp (mag beta x) - 1)%Z
(fexpe (mag beta (F2R d)) <
 fexp (mag beta (F2R d)) - 1)%Z
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
exists g : float beta,
  F2R g = m /\
  canonical beta fexpe g /\ Z.even (Fnum g) = true
generalize (fexpe_fexp  (mag beta (F2R d))).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:(0 < F2R d)%R
g:float beta
Hg1:F2R g = m
Hg2:Fexp g = (fexp (mag beta x) - 1)%Z
(fexpe (mag beta (F2R d)) <=
 fexp (mag beta (F2R d)) - 2)%Z ->
(fexpe (mag beta (F2R d)) <
 fexp (mag beta (F2R d)) - 1)%Z
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
exists g : float beta,
  F2R g = m /\
  canonical beta fexpe g /\ Z.even (Fnum g) = true
omega.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
exists g : float beta,
  F2R g = m /\
  canonical beta fexpe g /\ Z.even (Fnum g) = true
(* *)
destruct m_eq_0 as (g,(Hg1,Hg2)); trivial.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
g:float beta
Hg1:F2R g = m
Hg2:Fexp g = (fexp (mag beta (F2R u)) - 1)%Z
exists g0 : float beta,
  F2R g0 = m /\
  canonical beta fexpe g0 /\ Z.even (Fnum g0) = true
apply exists_even_fexp_lt.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
g:float beta
Hg1:F2R g = m
Hg2:Fexp g = (fexp (mag beta (F2R u)) - 1)%Z
exists f : float beta,
  F2R f = m /\ (fexpe (mag beta m) < Fexp f)%Z
exists g; split; trivial.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
g:float beta
Hg1:F2R g = m
Hg2:Fexp g = (fexp (mag beta (F2R u)) - 1)%Z
(fexpe (mag beta m) < Fexp g)%Z
rewrite Hg2.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
g:float beta
Hg1:F2R g = m
Hg2:Fexp g = (fexp (mag beta (F2R u)) - 1)%Z
(fexpe (mag beta m) < fexp (mag beta (F2R u)) - 1)%Z
rewrite mag_m_0; trivial.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
g:float beta
Hg1:F2R g = m
Hg2:Fexp g = (fexp (mag beta (F2R u)) - 1)%Z
(fexpe (mag beta (F2R u) - 1) <
 fexp (mag beta (F2R u)) - 1)%Z
apply Z.le_lt_trans with (1:=fexpe_fexp _).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
g:float beta
Hg1:F2R g = m
Hg2:Fexp g = (fexp (mag beta (F2R u)) - 1)%Z
(fexp (mag beta (F2R u) - 1) - 2 <
 fexp (mag beta (F2R u)) - 1)%Z
generalize (fexp_m_eq_0 Y).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
Y:0%R = F2R d
g:float beta
Hg1:F2R g = m
Hg2:Fexp g = (fexp (mag beta (F2R u)) - 1)%Z
(fexp (mag beta (F2R u) - 1) <
 fexp (mag beta (F2R u)) + 1)%Z ->
(fexp (mag beta (F2R u) - 1) - 2 <
 fexp (mag beta (F2R u)) - 1)%Z
omega.
Qed.


Lemma DN_odd_d_aux :
  forall z, (F2R d <= z < F2R u)%R ->
  Rnd_DN_pt (generic_format beta fexp) z (F2R d).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
forall z : R,
(F2R d <= z < F2R u)%R ->
Rnd_DN_pt (generic_format beta fexp) z (F2R d)
Proof with auto with typeclass_instances.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
forall z : R,
(F2R d <= z < F2R u)%R ->
Rnd_DN_pt (generic_format beta fexp) z (F2R d)
intros z Hz1.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
z:R
Hz1:(F2R d <= z < F2R u)%R
Rnd_DN_pt (generic_format beta fexp) z (F2R d)
replace (F2R d) with (round beta fexp Zfloor z).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
z:R
Hz1:(F2R d <= z < F2R u)%R
Rnd_DN_pt (generic_format beta fexp) z
  (round beta fexp Zfloor z)
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
z:R
Hz1:(F2R d <= z < F2R u)%R
round beta fexp Zfloor z = F2R d
apply round_DN_pt...
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
z:R
Hz1:(F2R d <= z < F2R u)%R
round beta fexp Zfloor z = F2R d
case (Rnd_DN_UP_pt_split _ _ _ _ Hd Hu (round beta fexp Zfloor z)).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
z:R
Hz1:(F2R d <= z < F2R u)%R
generic_format beta fexp (round beta fexp Zfloor z)
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
z:R
Hz1:(F2R d <= z < F2R u)%R
(round beta fexp Zfloor z <= F2R d)%R ->
round beta fexp Zfloor z = F2R d
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
z:R
Hz1:(F2R d <= z < F2R u)%R
(F2R u <= round beta fexp Zfloor z)%R ->
round beta fexp Zfloor z = F2R d
apply generic_format_round...
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
z:R
Hz1:(F2R d <= z < F2R u)%R
(round beta fexp Zfloor z <= F2R d)%R ->
round beta fexp Zfloor z = F2R d
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
z:R
Hz1:(F2R d <= z < F2R u)%R
(F2R u <= round beta fexp Zfloor z)%R ->
round beta fexp Zfloor z = F2R d
intros Y; apply Rle_antisym; trivial.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
z:R
Hz1:(F2R d <= z < F2R u)%R
Y:(round beta fexp Zfloor z <= F2R d)%R
(F2R d <= round beta fexp Zfloor z)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
z:R
Hz1:(F2R d <= z < F2R u)%R
(F2R u <= round beta fexp Zfloor z)%R ->
round beta fexp Zfloor z = F2R d
apply round_DN_pt...
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
z:R
Hz1:(F2R d <= z < F2R u)%R
Y:(round beta fexp Zfloor z <= F2R d)%R
generic_format beta fexp (F2R d)
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
z:R
Hz1:(F2R d <= z < F2R u)%R
Y:(round beta fexp Zfloor z <= F2R d)%R
(F2R d <= z)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
z:R
Hz1:(F2R d <= z < F2R u)%R
(F2R u <= round beta fexp Zfloor z)%R ->
round beta fexp Zfloor z = F2R d
apply Hd.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
z:R
Hz1:(F2R d <= z < F2R u)%R
Y:(round beta fexp Zfloor z <= F2R d)%R
(F2R d <= z)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
z:R
Hz1:(F2R d <= z < F2R u)%R
(F2R u <= round beta fexp Zfloor z)%R ->
round beta fexp Zfloor z = F2R d
apply Hz1.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
z:R
Hz1:(F2R d <= z < F2R u)%R
(F2R u <= round beta fexp Zfloor z)%R ->
round beta fexp Zfloor z = F2R d
intros Y ; elim (Rlt_irrefl z).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
z:R
Hz1:(F2R d <= z < F2R u)%R
Y:(F2R u <= round beta fexp Zfloor z)%R
(z < z)%R
apply Rlt_le_trans with (1:=proj2 Hz1), Rle_trans with (1:=Y).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
z:R
Hz1:(F2R d <= z < F2R u)%R
Y:(F2R u <= round beta fexp Zfloor z)%R
(round beta fexp Zfloor z <= z)%R
apply round_DN_pt...
Qed.

Lemma UP_odd_d_aux :
  forall z, (F2R d < z <= F2R u)%R ->
  Rnd_UP_pt (generic_format beta fexp) z (F2R u).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
forall z : R,
(F2R d < z <= F2R u)%R ->
Rnd_UP_pt (generic_format beta fexp) z (F2R u)
Proof with auto with typeclass_instances.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
forall z : R,
(F2R d < z <= F2R u)%R ->
Rnd_UP_pt (generic_format beta fexp) z (F2R u)
intros z Hz1.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
z:R
Hz1:(F2R d < z <= F2R u)%R
Rnd_UP_pt (generic_format beta fexp) z (F2R u)
replace (F2R u) with (round beta fexp Zceil z).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
z:R
Hz1:(F2R d < z <= F2R u)%R
Rnd_UP_pt (generic_format beta fexp) z
  (round beta fexp Zceil z)
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
z:R
Hz1:(F2R d < z <= F2R u)%R
round beta fexp Zceil z = F2R u
apply round_UP_pt...
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
z:R
Hz1:(F2R d < z <= F2R u)%R
round beta fexp Zceil z = F2R u
case (Rnd_DN_UP_pt_split _ _ _ _ Hd Hu (round beta fexp Zceil z)).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
z:R
Hz1:(F2R d < z <= F2R u)%R
generic_format beta fexp (round beta fexp Zceil z)
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
z:R
Hz1:(F2R d < z <= F2R u)%R
(round beta fexp Zceil z <= F2R d)%R ->
round beta fexp Zceil z = F2R u
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
z:R
Hz1:(F2R d < z <= F2R u)%R
(F2R u <= round beta fexp Zceil z)%R ->
round beta fexp Zceil z = F2R u
apply generic_format_round...
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
z:R
Hz1:(F2R d < z <= F2R u)%R
(round beta fexp Zceil z <= F2R d)%R ->
round beta fexp Zceil z = F2R u
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
z:R
Hz1:(F2R d < z <= F2R u)%R
(F2R u <= round beta fexp Zceil z)%R ->
round beta fexp Zceil z = F2R u
intros Y ; elim (Rlt_irrefl z).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
z:R
Hz1:(F2R d < z <= F2R u)%R
Y:(round beta fexp Zceil z <= F2R d)%R
(z < z)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
z:R
Hz1:(F2R d < z <= F2R u)%R
(F2R u <= round beta fexp Zceil z)%R ->
round beta fexp Zceil z = F2R u
apply Rle_lt_trans with (2:=proj1 Hz1), Rle_trans with (2:=Y).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
z:R
Hz1:(F2R d < z <= F2R u)%R
Y:(round beta fexp Zceil z <= F2R d)%R
(z <= round beta fexp Zceil z)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
z:R
Hz1:(F2R d < z <= F2R u)%R
(F2R u <= round beta fexp Zceil z)%R ->
round beta fexp Zceil z = F2R u
apply round_UP_pt...
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
z:R
Hz1:(F2R d < z <= F2R u)%R
(F2R u <= round beta fexp Zceil z)%R ->
round beta fexp Zceil z = F2R u
intros Y; apply Rle_antisym; trivial.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
z:R
Hz1:(F2R d < z <= F2R u)%R
Y:(F2R u <= round beta fexp Zceil z)%R
(round beta fexp Zceil z <= F2R u)%R
apply round_UP_pt...
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
z:R
Hz1:(F2R d < z <= F2R u)%R
Y:(F2R u <= round beta fexp Zceil z)%R
generic_format beta fexp (F2R u)
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
z:R
Hz1:(F2R d < z <= F2R u)%R
Y:(F2R u <= round beta fexp Zceil z)%R
(z <= F2R u)%R
apply Hu.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
z:R
Hz1:(F2R d < z <= F2R u)%R
Y:(F2R u <= round beta fexp Zceil z)%R
(z <= F2R u)%R
apply Hz1.
Qed.


Lemma round_N_odd_pos :
  round beta fexp (Znearest choice) (round beta fexpe Zrnd_odd x) =
               round beta fexp (Znearest choice) x.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
round beta fexp (Znearest choice)
  (round beta fexpe Zrnd_odd x) =
round beta fexp (Znearest choice) x
Proof with auto with typeclass_instances.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
round beta fexp (Znearest choice)
  (round beta fexpe Zrnd_odd x) =
round beta fexp (Znearest choice) x
set (o:=round beta fexpe Zrnd_odd x).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
case (generic_format_EM beta fexp x); intros Hx.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:generic_format beta fexp x
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
replace o with x; trivial.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:generic_format beta fexp x
x = o
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
unfold o; apply sym_eq, round_generic...
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:generic_format beta fexp x
generic_format beta fexpe x
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
now apply generic_format_fexpe_fexp.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
assert (K1:(F2R d <= o)%R).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
(F2R d <= o)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
apply round_ge_generic...
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
generic_format beta fexpe (F2R d)
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
(F2R d <= x)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
apply generic_format_fexpe_fexp, Hd.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
(F2R d <= x)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
apply Hd.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
assert (K2:(o <= F2R u)%R).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
(o <= F2R u)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
apply round_le_generic...
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
generic_format beta fexpe (F2R u)
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
(x <= F2R u)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
apply generic_format_fexpe_fexp, Hu.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
(x <= F2R u)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
apply Hu.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
assert (P:(x <> m -> o=m -> (forall P:Prop, P))).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
x <> m -> o = m -> forall P : Prop, P
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
intros Y1 Y2.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
Y1:x <> m
Y2:o = m
forall P : Prop, P
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
assert (H:(Rnd_odd_pt beta fexpe x o)).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
Y1:x <> m
Y2:o = m
Rnd_odd_pt beta fexpe x o
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
Y1:x <> m
Y2:o = m
H:Rnd_odd_pt beta fexpe x o
forall P : Prop, P
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
apply round_odd_pt...
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
Y1:x <> m
Y2:o = m
H:Rnd_odd_pt beta fexpe x o
forall P : Prop, P
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
destruct H as (_,H); destruct H.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
Y1:x <> m
Y2:o = m
H:o = x
forall P : Prop, P
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
Y1:x <> m
Y2:o = m
H:(Rnd_DN_pt (generic_format beta fexpe) x o \/
 Rnd_UP_pt (generic_format beta fexpe) x o) /\
(exists g : float beta,
   o = F2R g /\
   canonical beta fexpe g /\
   Z.even (Fnum g) = false)
forall P : Prop, P
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
absurd (x=m)%R; try trivial.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
Y1:x <> m
Y2:o = m
H:o = x
x = m
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
Y1:x <> m
Y2:o = m
H:(Rnd_DN_pt (generic_format beta fexpe) x o \/
 Rnd_UP_pt (generic_format beta fexpe) x o) /\
(exists g : float beta,
   o = F2R g /\
   canonical beta fexpe g /\
   Z.even (Fnum g) = false)
forall P : Prop, P
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
now rewrite <- Y2, H.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
Y1:x <> m
Y2:o = m
H:(Rnd_DN_pt (generic_format beta fexpe) x o \/
 Rnd_UP_pt (generic_format beta fexpe) x o) /\
(exists g : float beta,
   o = F2R g /\
   canonical beta fexpe g /\
   Z.even (Fnum g) = false)
forall P : Prop, P
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
destruct H as (_,(k,(Hk1,(Hk2,Hk3)))).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
Y1:x <> m
Y2:o = m
k:float beta
Hk1:o = F2R k
Hk2:canonical beta fexpe k
Hk3:Z.even (Fnum k) = false
forall P : Prop, P
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
destruct Zm as (k',(Hk'1,(Hk'2,Hk'3))).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
Y1:x <> m
Y2:o = m
k:float beta
Hk1:o = F2R k
Hk2:canonical beta fexpe k
Hk3:Z.even (Fnum k) = false
k':float beta
Hk'1:F2R k' = m
Hk'2:canonical beta fexpe k'
Hk'3:Z.even (Fnum k') = true
forall P : Prop, P
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
absurd (true=false).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
Y1:x <> m
Y2:o = m
k:float beta
Hk1:o = F2R k
Hk2:canonical beta fexpe k
Hk3:Z.even (Fnum k) = false
k':float beta
Hk'1:F2R k' = m
Hk'2:canonical beta fexpe k'
Hk'3:Z.even (Fnum k') = true
true <> false
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
Y1:x <> m
Y2:o = m
k:float beta
Hk1:o = F2R k
Hk2:canonical beta fexpe k
Hk3:Z.even (Fnum k) = false
k':float beta
Hk'1:F2R k' = m
Hk'2:canonical beta fexpe k'
Hk'3:Z.even (Fnum k') = true
true = false
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
discriminate.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
Y1:x <> m
Y2:o = m
k:float beta
Hk1:o = F2R k
Hk2:canonical beta fexpe k
Hk3:Z.even (Fnum k) = false
k':float beta
Hk'1:F2R k' = m
Hk'2:canonical beta fexpe k'
Hk'3:Z.even (Fnum k') = true
true = false
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
rewrite <- Hk3, <- Hk'3.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
Y1:x <> m
Y2:o = m
k:float beta
Hk1:o = F2R k
Hk2:canonical beta fexpe k
Hk3:Z.even (Fnum k) = false
k':float beta
Hk'1:F2R k' = m
Hk'2:canonical beta fexpe k'
Hk'3:Z.even (Fnum k') = true
Z.even (Fnum k') = Z.even (Fnum k)
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
apply f_equal, f_equal.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
Y1:x <> m
Y2:o = m
k:float beta
Hk1:o = F2R k
Hk2:canonical beta fexpe k
Hk3:Z.even (Fnum k) = false
k':float beta
Hk'1:F2R k' = m
Hk'2:canonical beta fexpe k'
Hk'3:Z.even (Fnum k') = true
k' = k
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
apply canonical_unique with fexpe...
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
Y1:x <> m
Y2:o = m
k:float beta
Hk1:o = F2R k
Hk2:canonical beta fexpe k
Hk3:Z.even (Fnum k) = false
k':float beta
Hk'1:F2R k' = m
Hk'2:canonical beta fexpe k'
Hk'3:Z.even (Fnum k') = true
F2R k' = F2R k
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
now rewrite Hk'1, <- Y2.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
assert (generic_format beta fexp o -> (forall P:Prop, P)).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
generic_format beta fexp o -> forall P0 : Prop, P0
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
intros Y.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
Y:generic_format beta fexp o
forall P0 : Prop, P0
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
assert (H:(Rnd_odd_pt beta fexpe x o)).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
Y:generic_format beta fexp o
Rnd_odd_pt beta fexpe x o
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
Y:generic_format beta fexp o
H:Rnd_odd_pt beta fexpe x o
forall P0 : Prop, P0
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
apply round_odd_pt...
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
Y:generic_format beta fexp o
H:Rnd_odd_pt beta fexpe x o
forall P0 : Prop, P0
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
destruct H as (_,H); destruct H.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
Y:generic_format beta fexp o
H:o = x
forall P0 : Prop, P0
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
Y:generic_format beta fexp o
H:(Rnd_DN_pt (generic_format beta fexpe) x o \/
 Rnd_UP_pt (generic_format beta fexpe) x o) /\
(exists g : float beta,
   o = F2R g /\
   canonical beta fexpe g /\
   Z.even (Fnum g) = false)
forall P0 : Prop, P0
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
absurd (generic_format beta fexp x); trivial.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
Y:generic_format beta fexp o
H:o = x
generic_format beta fexp x
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
Y:generic_format beta fexp o
H:(Rnd_DN_pt (generic_format beta fexpe) x o \/
 Rnd_UP_pt (generic_format beta fexpe) x o) /\
(exists g : float beta,
   o = F2R g /\
   canonical beta fexpe g /\
   Z.even (Fnum g) = false)
forall P0 : Prop, P0
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
now rewrite <- H.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
Y:generic_format beta fexp o
H:(Rnd_DN_pt (generic_format beta fexpe) x o \/
 Rnd_UP_pt (generic_format beta fexpe) x o) /\
(exists g : float beta,
   o = F2R g /\
   canonical beta fexpe g /\
   Z.even (Fnum g) = false)
forall P0 : Prop, P0
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
destruct H as (_,(k,(Hk1,(Hk2,Hk3)))).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
Y:generic_format beta fexp o
k:float beta
Hk1:o = F2R k
Hk2:canonical beta fexpe k
Hk3:Z.even (Fnum k) = false
forall P0 : Prop, P0
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
destruct (exists_even_fexp_lt fexpe o) as (k',(Hk'1,(Hk'2,Hk'3))).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
Y:generic_format beta fexp o
k:float beta
Hk1:o = F2R k
Hk2:canonical beta fexpe k
Hk3:Z.even (Fnum k) = false
exists f : float beta,
  F2R f = o /\ (fexpe (mag beta o) < Fexp f)%Z
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
Y:generic_format beta fexp o
k:float beta
Hk1:o = F2R k
Hk2:canonical beta fexpe k
Hk3:Z.even (Fnum k) = false
k':float beta
Hk'1:F2R k' = o
Hk'2:canonical beta fexpe k'
Hk'3:Z.even (Fnum k') = true
forall P0 : Prop, P0
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
eexists; split.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
Y:generic_format beta fexp o
k:float beta
Hk1:o = F2R k
Hk2:canonical beta fexpe k
Hk3:Z.even (Fnum k) = false
F2R ?f = o
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
Y:generic_format beta fexp o
k:float beta
Hk1:o = F2R k
Hk2:canonical beta fexpe k
Hk3:Z.even (Fnum k) = false
(fexpe (mag beta o) < Fexp ?f)%Z
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
Y:generic_format beta fexp o
k:float beta
Hk1:o = F2R k
Hk2:canonical beta fexpe k
Hk3:Z.even (Fnum k) = false
k':float beta
Hk'1:F2R k' = o
Hk'2:canonical beta fexpe k'
Hk'3:Z.even (Fnum k') = true
forall P0 : Prop, P0
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
apply sym_eq, Y.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
Y:generic_format beta fexp o
k:float beta
Hk1:o = F2R k
Hk2:canonical beta fexpe k
Hk3:Z.even (Fnum k) = false
(fexpe (mag beta o) <
 Fexp
   {|
   Fnum := Ztrunc (scaled_mantissa beta fexp o);
   Fexp := cexp beta fexp o |})%Z
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
Y:generic_format beta fexp o
k:float beta
Hk1:o = F2R k
Hk2:canonical beta fexpe k
Hk3:Z.even (Fnum k) = false
k':float beta
Hk'1:F2R k' = o
Hk'2:canonical beta fexpe k'
Hk'3:Z.even (Fnum k') = true
forall P0 : Prop, P0
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
simpl; unfold cexp.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
Y:generic_format beta fexp o
k:float beta
Hk1:o = F2R k
Hk2:canonical beta fexpe k
Hk3:Z.even (Fnum k) = false
(fexpe (mag beta o) < fexp (mag beta o))%Z
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
Y:generic_format beta fexp o
k:float beta
Hk1:o = F2R k
Hk2:canonical beta fexpe k
Hk3:Z.even (Fnum k) = false
k':float beta
Hk'1:F2R k' = o
Hk'2:canonical beta fexpe k'
Hk'3:Z.even (Fnum k') = true
forall P0 : Prop, P0
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
apply Z.le_lt_trans with (1:=fexpe_fexp _).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
Y:generic_format beta fexp o
k:float beta
Hk1:o = F2R k
Hk2:canonical beta fexpe k
Hk3:Z.even (Fnum k) = false
(fexp (mag beta o) - 2 < fexp (mag beta o))%Z
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
Y:generic_format beta fexp o
k:float beta
Hk1:o = F2R k
Hk2:canonical beta fexpe k
Hk3:Z.even (Fnum k) = false
k':float beta
Hk'1:F2R k' = o
Hk'2:canonical beta fexpe k'
Hk'3:Z.even (Fnum k') = true
forall P0 : Prop, P0
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
omega.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
Y:generic_format beta fexp o
k:float beta
Hk1:o = F2R k
Hk2:canonical beta fexpe k
Hk3:Z.even (Fnum k) = false
k':float beta
Hk'1:F2R k' = o
Hk'2:canonical beta fexpe k'
Hk'3:Z.even (Fnum k') = true
forall P0 : Prop, P0
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
absurd (true=false).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
Y:generic_format beta fexp o
k:float beta
Hk1:o = F2R k
Hk2:canonical beta fexpe k
Hk3:Z.even (Fnum k) = false
k':float beta
Hk'1:F2R k' = o
Hk'2:canonical beta fexpe k'
Hk'3:Z.even (Fnum k') = true
true <> false
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
Y:generic_format beta fexp o
k:float beta
Hk1:o = F2R k
Hk2:canonical beta fexpe k
Hk3:Z.even (Fnum k) = false
k':float beta
Hk'1:F2R k' = o
Hk'2:canonical beta fexpe k'
Hk'3:Z.even (Fnum k') = true
true = false
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
discriminate.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
Y:generic_format beta fexp o
k:float beta
Hk1:o = F2R k
Hk2:canonical beta fexpe k
Hk3:Z.even (Fnum k) = false
k':float beta
Hk'1:F2R k' = o
Hk'2:canonical beta fexpe k'
Hk'3:Z.even (Fnum k') = true
true = false
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
rewrite <- Hk3, <- Hk'3.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
Y:generic_format beta fexp o
k:float beta
Hk1:o = F2R k
Hk2:canonical beta fexpe k
Hk3:Z.even (Fnum k) = false
k':float beta
Hk'1:F2R k' = o
Hk'2:canonical beta fexpe k'
Hk'3:Z.even (Fnum k') = true
Z.even (Fnum k') = Z.even (Fnum k)
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
apply f_equal, f_equal.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
Y:generic_format beta fexp o
k:float beta
Hk1:o = F2R k
Hk2:canonical beta fexpe k
Hk3:Z.even (Fnum k) = false
k':float beta
Hk'1:F2R k' = o
Hk'2:canonical beta fexpe k'
Hk'3:Z.even (Fnum k') = true
k' = k
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
apply canonical_unique with fexpe...
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
Y:generic_format beta fexp o
k:float beta
Hk1:o = F2R k
Hk2:canonical beta fexpe k
Hk3:Z.even (Fnum k) = false
k':float beta
Hk'1:F2R k' = o
Hk'2:canonical beta fexpe k'
Hk'3:Z.even (Fnum k') = true
F2R k' = F2R k
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
now rewrite Hk'1, <- Hk1.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K1:(F2R d <= o)%R
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
case K1; clear K1; intros K1.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:F2R d = o
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
2: apply H; rewrite <- K1; apply Hd.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
K2:(o <= F2R u)%R
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
case K2; clear K2; intros K2.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:o = F2R u
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
2: apply H; rewrite K2; apply Hu.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
case (Rle_or_lt  x m); intros Y;[destruct Y|idtac].
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
H0:(x < m)%R
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
H0:x = m
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
Y:(m < x)%R
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
(* . *)
apply trans_eq with (F2R d).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
H0:(x < m)%R
round beta fexp (Znearest choice) o = F2R d
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
H0:(x < m)%R
F2R d = round beta fexp (Znearest choice) x
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
H0:x = m
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
Y:(m < x)%R
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
apply round_N_eq_DN_pt with (F2R u)...
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
H0:(x < m)%R
Rnd_DN_pt (generic_format beta fexp) o (F2R d)
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
H0:(x < m)%R
Rnd_UP_pt (generic_format beta fexp) o (F2R u)
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
H0:(x < m)%R
(o < (F2R d + F2R u) / 2)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
H0:(x < m)%R
F2R d = round beta fexp (Znearest choice) x
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
H0:x = m
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
Y:(m < x)%R
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
apply DN_odd_d_aux; split; try left; assumption.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
H0:(x < m)%R
Rnd_UP_pt (generic_format beta fexp) o (F2R u)
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
H0:(x < m)%R
(o < (F2R d + F2R u) / 2)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
H0:(x < m)%R
F2R d = round beta fexp (Znearest choice) x
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
H0:x = m
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
Y:(m < x)%R
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
apply UP_odd_d_aux; split; try left; assumption.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
H0:(x < m)%R
(o < (F2R d + F2R u) / 2)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
H0:(x < m)%R
F2R d = round beta fexp (Znearest choice) x
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
H0:x = m
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
Y:(m < x)%R
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
assert (o <= (F2R d + F2R u) / 2)%R.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
H0:(x < m)%R
(o <= (F2R d + F2R u) / 2)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
H0:(x < m)%R
H1:(o <= (F2R d + F2R u) / 2)%R
(o < (F2R d + F2R u) / 2)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
H0:(x < m)%R
F2R d = round beta fexp (Znearest choice) x
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
H0:x = m
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
Y:(m < x)%R
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
apply round_le_generic...
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
H0:(x < m)%R
generic_format beta fexpe ((F2R d + F2R u) / 2)
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
H0:(x < m)%R
(x <= (F2R d + F2R u) / 2)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
H0:(x < m)%R
H1:(o <= (F2R d + F2R u) / 2)%R
(o < (F2R d + F2R u) / 2)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
H0:(x < m)%R
F2R d = round beta fexp (Znearest choice) x
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
H0:x = m
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
Y:(m < x)%R
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
apply Fm.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
H0:(x < m)%R
(x <= (F2R d + F2R u) / 2)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
H0:(x < m)%R
H1:(o <= (F2R d + F2R u) / 2)%R
(o < (F2R d + F2R u) / 2)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
H0:(x < m)%R
F2R d = round beta fexp (Znearest choice) x
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
H0:x = m
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
Y:(m < x)%R
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
now left.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
H0:(x < m)%R
H1:(o <= (F2R d + F2R u) / 2)%R
(o < (F2R d + F2R u) / 2)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
H0:(x < m)%R
F2R d = round beta fexp (Znearest choice) x
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
H0:x = m
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
Y:(m < x)%R
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
destruct H1; trivial.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
H0:(x < m)%R
H1:o = ((F2R d + F2R u) / 2)%R
(o < (F2R d + F2R u) / 2)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
H0:(x < m)%R
F2R d = round beta fexp (Znearest choice) x
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
H0:x = m
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
Y:(m < x)%R
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
apply P.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
H0:(x < m)%R
H1:o = ((F2R d + F2R u) / 2)%R
x <> m
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
H0:(x < m)%R
H1:o = ((F2R d + F2R u) / 2)%R
o = m
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
H0:(x < m)%R
F2R d = round beta fexp (Znearest choice) x
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
H0:x = m
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
Y:(m < x)%R
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
now apply Rlt_not_eq.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
H0:(x < m)%R
H1:o = ((F2R d + F2R u) / 2)%R
o = m
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
H0:(x < m)%R
F2R d = round beta fexp (Znearest choice) x
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
H0:x = m
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
Y:(m < x)%R
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
trivial.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
H0:(x < m)%R
F2R d = round beta fexp (Znearest choice) x
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
H0:x = m
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
Y:(m < x)%R
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
apply sym_eq, round_N_eq_DN_pt with (F2R u)...
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
H0:x = m
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
Y:(m < x)%R
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
(* . *)
replace o with x.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
H0:x = m
round beta fexp (Znearest choice) x =
round beta fexp (Znearest choice) x
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
H0:x = m
x = o
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
Y:(m < x)%R
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
reflexivity.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
H0:x = m
x = o
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
Y:(m < x)%R
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
apply sym_eq, round_generic...
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
H0:x = m
generic_format beta fexpe x
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
Y:(m < x)%R
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
rewrite H0; apply Fm.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
Y:(m < x)%R
round beta fexp (Znearest choice) o =
round beta fexp (Znearest choice) x
(* . *)
apply trans_eq with (F2R u).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
Y:(m < x)%R
round beta fexp (Znearest choice) o = F2R u
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
Y:(m < x)%R
F2R u = round beta fexp (Znearest choice) x
apply round_N_eq_UP_pt with (F2R d)...
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
Y:(m < x)%R
Rnd_DN_pt (generic_format beta fexp) o (F2R d)
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
Y:(m < x)%R
Rnd_UP_pt (generic_format beta fexp) o (F2R u)
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
Y:(m < x)%R
((F2R d + F2R u) / 2 < o)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
Y:(m < x)%R
F2R u = round beta fexp (Znearest choice) x
apply DN_odd_d_aux; split; try left; assumption.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
Y:(m < x)%R
Rnd_UP_pt (generic_format beta fexp) o (F2R u)
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
Y:(m < x)%R
((F2R d + F2R u) / 2 < o)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
Y:(m < x)%R
F2R u = round beta fexp (Znearest choice) x
apply UP_odd_d_aux; split; try left; assumption.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
Y:(m < x)%R
((F2R d + F2R u) / 2 < o)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
Y:(m < x)%R
F2R u = round beta fexp (Znearest choice) x
assert ((F2R d + F2R u) / 2 <= o)%R.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
Y:(m < x)%R
((F2R d + F2R u) / 2 <= o)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
Y:(m < x)%R
H0:((F2R d + F2R u) / 2 <= o)%R
((F2R d + F2R u) / 2 < o)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
Y:(m < x)%R
F2R u = round beta fexp (Znearest choice) x
apply round_ge_generic...
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
Y:(m < x)%R
generic_format beta fexpe ((F2R d + F2R u) / 2)
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
Y:(m < x)%R
((F2R d + F2R u) / 2 <= x)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
Y:(m < x)%R
H0:((F2R d + F2R u) / 2 <= o)%R
((F2R d + F2R u) / 2 < o)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
Y:(m < x)%R
F2R u = round beta fexp (Znearest choice) x
apply Fm.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
Y:(m < x)%R
((F2R d + F2R u) / 2 <= x)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
Y:(m < x)%R
H0:((F2R d + F2R u) / 2 <= o)%R
((F2R d + F2R u) / 2 < o)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
Y:(m < x)%R
F2R u = round beta fexp (Znearest choice) x
now left.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
Y:(m < x)%R
H0:((F2R d + F2R u) / 2 <= o)%R
((F2R d + F2R u) / 2 < o)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
Y:(m < x)%R
F2R u = round beta fexp (Znearest choice) x
destruct H0; trivial.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
Y:(m < x)%R
H0:((F2R d + F2R u) / 2)%R = o
((F2R d + F2R u) / 2 < o)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
Y:(m < x)%R
F2R u = round beta fexp (Znearest choice) x
apply P.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
Y:(m < x)%R
H0:((F2R d + F2R u) / 2)%R = o
x <> m
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
Y:(m < x)%R
H0:((F2R d + F2R u) / 2)%R = o
o = m
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
Y:(m < x)%R
F2R u = round beta fexp (Znearest choice) x
now apply Rgt_not_eq.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
Y:(m < x)%R
H0:((F2R d + F2R u) / 2)%R = o
o = m
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
Y:(m < x)%R
F2R u = round beta fexp (Znearest choice) x
rewrite <- H0; trivial.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
choice:Z -> bool
x:R
d, u:float beta
Hd:Rnd_DN_pt (generic_format beta fexp) x (F2R d)
Cd:canonical beta fexp d
Hu:Rnd_UP_pt (generic_format beta fexp) x (F2R u)
Cu:canonical beta fexp u
xPos:(0 < x)%R
m:=((F2R d + F2R u) / 2)%R:R
o:=round beta fexpe Zrnd_odd x:R
Hx:~ generic_format beta fexp x
P:x <> m -> o = m -> forall P0 : Prop, P0
H:generic_format beta fexp o -> forall P0 : Prop, P0
K1:(F2R d < o)%R
K2:(o < F2R u)%R
Y:(m < x)%R
F2R u = round beta fexp (Znearest choice) x
apply sym_eq, round_N_eq_UP_pt with (F2R d)...
Qed.


End Odd_prop_aux.

Section Odd_prop.

Variable beta : radix.
Hypothesis Even_beta: Z.even (radix_val beta)=true.

Variable fexp : Z -> Z.
Variable fexpe : Z -> Z.
Variable choice:Z->bool.

Context { valid_exp : Valid_exp fexp }.
Context { exists_NE_ : Exists_NE beta fexp }. (* for underflow reason *)
Context { valid_expe : Valid_exp fexpe }.
Context { exists_NE_e : Exists_NE beta fexpe }. (* for defining rounding to odd *)

Hypothesis fexpe_fexp: forall e, (fexpe e <= fexp e -2)%Z.

Theorem round_N_odd :
  forall x,
  round beta fexp (Znearest choice) (round beta fexpe Zrnd_odd x) =
               round beta fexp (Znearest choice) x.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
forall x : R,
round beta fexp (Znearest choice)
  (round beta fexpe Zrnd_odd x) =
round beta fexp (Znearest choice) x
Proof with auto with typeclass_instances.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
forall x : R,
round beta fexp (Znearest choice)
  (round beta fexpe Zrnd_odd x) =
round beta fexp (Znearest choice) x
intros x.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
round beta fexp (Znearest choice)
  (round beta fexpe Zrnd_odd x) =
round beta fexp (Znearest choice) x
case (total_order_T x 0); intros H; [case H; clear H; intros H | idtac].
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
H:(x < 0)%R
round beta fexp (Znearest choice)
  (round beta fexpe Zrnd_odd x) =
round beta fexp (Znearest choice) x
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
H:x = 0%R
round beta fexp (Znearest choice)
  (round beta fexpe Zrnd_odd x) =
round beta fexp (Znearest choice) x
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
H:(x > 0)%R
round beta fexp (Znearest choice)
  (round beta fexpe Zrnd_odd x) =
round beta fexp (Znearest choice) x
rewrite <- (Ropp_involutive x).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
H:(x < 0)%R
round beta fexp (Znearest choice)
  (round beta fexpe Zrnd_odd (- - x)) =
round beta fexp (Znearest choice) (- - x)
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
H:x = 0%R
round beta fexp (Znearest choice)
  (round beta fexpe Zrnd_odd x) =
round beta fexp (Znearest choice) x
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
H:(x > 0)%R
round beta fexp (Znearest choice)
  (round beta fexpe Zrnd_odd x) =
round beta fexp (Znearest choice) x
rewrite round_odd_opp.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
H:(x < 0)%R
round beta fexp (Znearest choice)
  (- round beta fexpe Zrnd_odd (- x)) =
round beta fexp (Znearest choice) (- - x)
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
H:x = 0%R
round beta fexp (Znearest choice)
  (round beta fexpe Zrnd_odd x) =
round beta fexp (Znearest choice) x
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
H:(x > 0)%R
round beta fexp (Znearest choice)
  (round beta fexpe Zrnd_odd x) =
round beta fexp (Znearest choice) x
rewrite 2!round_N_opp.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
H:(x < 0)%R
(-
 round beta fexp
   (Znearest (fun t : Z => negb (choice (- (t + 1)))))
   (round beta fexpe Zrnd_odd (- x)))%R =
(-
 round beta fexp
   (Znearest (fun t : Z => negb (choice (- (t + 1)))))
   (- x))%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
H:x = 0%R
round beta fexp (Znearest choice)
  (round beta fexpe Zrnd_odd x) =
round beta fexp (Znearest choice) x
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
H:(x > 0)%R
round beta fexp (Znearest choice)
  (round beta fexpe Zrnd_odd x) =
round beta fexp (Znearest choice) x
apply f_equal.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
H:(x < 0)%R
round beta fexp
  (Znearest (fun t : Z => negb (choice (- (t + 1)))))
  (round beta fexpe Zrnd_odd (- x)) =
round beta fexp
  (Znearest (fun t : Z => negb (choice (- (t + 1)))))
  (- x)
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
H:x = 0%R
round beta fexp (Znearest choice)
  (round beta fexpe Zrnd_odd x) =
round beta fexp (Znearest choice) x
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
H:(x > 0)%R
round beta fexp (Znearest choice)
  (round beta fexpe Zrnd_odd x) =
round beta fexp (Znearest choice) x
destruct (canonical_generic_format beta fexp (round beta fexp Zfloor (-x))) as (d,(Hd1,Hd2)).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
H:(x < 0)%R
generic_format beta fexp
  (round beta fexp Zfloor (- x))
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
H:(x < 0)%R
d:float beta
Hd1:round beta fexp Zfloor (- x) = F2R d
Hd2:canonical beta fexp d
round beta fexp
  (Znearest (fun t : Z => negb (choice (- (t + 1)))))
  (round beta fexpe Zrnd_odd (- x)) =
round beta fexp
  (Znearest (fun t : Z => negb (choice (- (t + 1)))))
  (- x)
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
H:x = 0%R
round beta fexp (Znearest choice)
  (round beta fexpe Zrnd_odd x) =
round beta fexp (Znearest choice) x
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
H:(x > 0)%R
round beta fexp (Znearest choice)
  (round beta fexpe Zrnd_odd x) =
round beta fexp (Znearest choice) x
apply generic_format_round...
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
H:(x < 0)%R
d:float beta
Hd1:round beta fexp Zfloor (- x) = F2R d
Hd2:canonical beta fexp d
round beta fexp
  (Znearest (fun t : Z => negb (choice (- (t + 1)))))
  (round beta fexpe Zrnd_odd (- x)) =
round beta fexp
  (Znearest (fun t : Z => negb (choice (- (t + 1)))))
  (- x)
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
H:x = 0%R
round beta fexp (Znearest choice)
  (round beta fexpe Zrnd_odd x) =
round beta fexp (Znearest choice) x
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
H:(x > 0)%R
round beta fexp (Znearest choice)
  (round beta fexpe Zrnd_odd x) =
round beta fexp (Znearest choice) x
destruct (canonical_generic_format beta fexp (round beta fexp Zceil (-x))) as (u,(Hu1,Hu2)).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
H:(x < 0)%R
d:float beta
Hd1:round beta fexp Zfloor (- x) = F2R d
Hd2:canonical beta fexp d
generic_format beta fexp (round beta fexp Zceil (- x))
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
H:(x < 0)%R
d:float beta
Hd1:round beta fexp Zfloor (- x) = F2R d
Hd2:canonical beta fexp d
u:float beta
Hu1:round beta fexp Zceil (- x) = F2R u
Hu2:canonical beta fexp u
round beta fexp
  (Znearest (fun t : Z => negb (choice (- (t + 1)))))
  (round beta fexpe Zrnd_odd (- x)) =
round beta fexp
  (Znearest (fun t : Z => negb (choice (- (t + 1)))))
  (- x)
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
H:x = 0%R
round beta fexp (Znearest choice)
  (round beta fexpe Zrnd_odd x) =
round beta fexp (Znearest choice) x
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
H:(x > 0)%R
round beta fexp (Znearest choice)
  (round beta fexpe Zrnd_odd x) =
round beta fexp (Znearest choice) x
apply generic_format_round...
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
H:(x < 0)%R
d:float beta
Hd1:round beta fexp Zfloor (- x) = F2R d
Hd2:canonical beta fexp d
u:float beta
Hu1:round beta fexp Zceil (- x) = F2R u
Hu2:canonical beta fexp u
round beta fexp
  (Znearest (fun t : Z => negb (choice (- (t + 1)))))
  (round beta fexpe Zrnd_odd (- x)) =
round beta fexp
  (Znearest (fun t : Z => negb (choice (- (t + 1)))))
  (- x)
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
H:x = 0%R
round beta fexp (Znearest choice)
  (round beta fexpe Zrnd_odd x) =
round beta fexp (Znearest choice) x
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
H:(x > 0)%R
round beta fexp (Znearest choice)
  (round beta fexpe Zrnd_odd x) =
round beta fexp (Znearest choice) x
apply round_N_odd_pos with d u...
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
H:(x < 0)%R
d:float beta
Hd1:round beta fexp Zfloor (- x) = F2R d
Hd2:canonical beta fexp d
u:float beta
Hu1:round beta fexp Zceil (- x) = F2R u
Hu2:canonical beta fexp u
Rnd_DN_pt (generic_format beta fexp) (- x) (F2R d)
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
H:(x < 0)%R
d:float beta
Hd1:round beta fexp Zfloor (- x) = F2R d
Hd2:canonical beta fexp d
u:float beta
Hu1:round beta fexp Zceil (- x) = F2R u
Hu2:canonical beta fexp u
Rnd_UP_pt (generic_format beta fexp) (- x) (F2R u)
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
H:(x < 0)%R
d:float beta
Hd1:round beta fexp Zfloor (- x) = F2R d
Hd2:canonical beta fexp d
u:float beta
Hu1:round beta fexp Zceil (- x) = F2R u
Hu2:canonical beta fexp u
(0 < - x)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
H:x = 0%R
round beta fexp (Znearest choice)
  (round beta fexpe Zrnd_odd x) =
round beta fexp (Znearest choice) x
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
H:(x > 0)%R
round beta fexp (Znearest choice)
  (round beta fexpe Zrnd_odd x) =
round beta fexp (Znearest choice) x
rewrite <- Hd1; apply round_DN_pt...
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
H:(x < 0)%R
d:float beta
Hd1:round beta fexp Zfloor (- x) = F2R d
Hd2:canonical beta fexp d
u:float beta
Hu1:round beta fexp Zceil (- x) = F2R u
Hu2:canonical beta fexp u
Rnd_UP_pt (generic_format beta fexp) (- x) (F2R u)
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
H:(x < 0)%R
d:float beta
Hd1:round beta fexp Zfloor (- x) = F2R d
Hd2:canonical beta fexp d
u:float beta
Hu1:round beta fexp Zceil (- x) = F2R u
Hu2:canonical beta fexp u
(0 < - x)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
H:x = 0%R
round beta fexp (Znearest choice)
  (round beta fexpe Zrnd_odd x) =
round beta fexp (Znearest choice) x
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
H:(x > 0)%R
round beta fexp (Znearest choice)
  (round beta fexpe Zrnd_odd x) =
round beta fexp (Znearest choice) x
rewrite <- Hu1; apply round_UP_pt...
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
H:(x < 0)%R
d:float beta
Hd1:round beta fexp Zfloor (- x) = F2R d
Hd2:canonical beta fexp d
u:float beta
Hu1:round beta fexp Zceil (- x) = F2R u
Hu2:canonical beta fexp u
(0 < - x)%R
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
H:x = 0%R
round beta fexp (Znearest choice)
  (round beta fexpe Zrnd_odd x) =
round beta fexp (Znearest choice) x
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
H:(x > 0)%R
round beta fexp (Znearest choice)
  (round beta fexpe Zrnd_odd x) =
round beta fexp (Znearest choice) x
auto with real.
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
H:x = 0%R
round beta fexp (Znearest choice)
  (round beta fexpe Zrnd_odd x) =
round beta fexp (Znearest choice) x
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
H:(x > 0)%R
round beta fexp (Znearest choice)
  (round beta fexpe Zrnd_odd x) =
round beta fexp (Znearest choice) x
(* . *)
rewrite H; repeat rewrite round_0...
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
H:(x > 0)%R
round beta fexp (Znearest choice)
  (round beta fexpe Zrnd_odd x) =
round beta fexp (Znearest choice) x
(* . *)
destruct (canonical_generic_format beta fexp (round beta fexp Zfloor x)) as (d,(Hd1,Hd2)).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
H:(x > 0)%R
generic_format beta fexp (round beta fexp Zfloor x)
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
H:(x > 0)%R
d:float beta
Hd1:round beta fexp Zfloor x = F2R d
Hd2:canonical beta fexp d
round beta fexp (Znearest choice)
  (round beta fexpe Zrnd_odd x) =
round beta fexp (Znearest choice) x
apply generic_format_round...
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
H:(x > 0)%R
d:float beta
Hd1:round beta fexp Zfloor x = F2R d
Hd2:canonical beta fexp d
round beta fexp (Znearest choice)
  (round beta fexpe Zrnd_odd x) =
round beta fexp (Znearest choice) x
destruct (canonical_generic_format beta fexp (round beta fexp Zceil x)) as (u,(Hu1,Hu2)).
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
H:(x > 0)%R
d:float beta
Hd1:round beta fexp Zfloor x = F2R d
Hd2:canonical beta fexp d
generic_format beta fexp (round beta fexp Zceil x)
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
H:(x > 0)%R
d:float beta
Hd1:round beta fexp Zfloor x = F2R d
Hd2:canonical beta fexp d
u:float beta
Hu1:round beta fexp Zceil x = F2R u
Hu2:canonical beta fexp u
round beta fexp (Znearest choice)
  (round beta fexpe Zrnd_odd x) =
round beta fexp (Znearest choice) x
apply generic_format_round...
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
H:(x > 0)%R
d:float beta
Hd1:round beta fexp Zfloor x = F2R d
Hd2:canonical beta fexp d
u:float beta
Hu1:round beta fexp Zceil x = F2R u
Hu2:canonical beta fexp u
round beta fexp (Znearest choice)
  (round beta fexpe Zrnd_odd x) =
round beta fexp (Znearest choice) x
apply round_N_odd_pos with d u...
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
H:(x > 0)%R
d:float beta
Hd1:round beta fexp Zfloor x = F2R d
Hd2:canonical beta fexp d
u:float beta
Hu1:round beta fexp Zceil x = F2R u
Hu2:canonical beta fexp u
Rnd_DN_pt (generic_format beta fexp) x (F2R d)
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
H:(x > 0)%R
d:float beta
Hd1:round beta fexp Zfloor x = F2R d
Hd2:canonical beta fexp d
u:float beta
Hu1:round beta fexp Zceil x = F2R u
Hu2:canonical beta fexp u
Rnd_UP_pt (generic_format beta fexp) x (F2R u)
rewrite <- Hd1; apply round_DN_pt...
beta:radix
Even_beta:Z.even beta = true
fexp, fexpe:Z -> Z
choice:Z -> bool
valid_exp:Valid_exp fexp
exists_NE_:Exists_NE beta fexp
valid_expe:Valid_exp fexpe
exists_NE_e:Exists_NE beta fexpe
fexpe_fexp:forall e : Z, (fexpe e <= fexp e - 2)%Z
x:R
H:(x > 0)%R
d:float beta
Hd1:round beta fexp Zfloor x = F2R d
Hd2:canonical beta fexp d
u:float beta
Hu1:round beta fexp Zceil x = F2R u
Hu2:canonical beta fexp u
Rnd_UP_pt (generic_format beta fexp) x (F2R u)
rewrite <- Hu1; apply round_UP_pt...
Qed.

End Odd_prop.


Section Odd_propbis.

Variable beta : radix.
Hypothesis Even_beta: Z.even (radix_val beta)=true.

Variable emin prec:Z.
Variable choice:Z->bool.

Hypothesis prec_gt_1: (1 < prec)%Z.


Notation format := (generic_format beta (FLT_exp emin prec)).
Notation round_flt :=(round beta (FLT_exp emin prec) (Znearest choice)).
Notation cexp_flt := (cexp beta (FLT_exp emin prec)).
Notation fexpe k := (FLT_exp (emin-k) (prec+k)).



Lemma Zrnd_odd_plus': forall x y,
  (exists n:Z, exists e:Z, (x = IZR n*bpow beta e)%R /\ (1 <= e)%Z) ->
   (IZR (Zrnd_odd (x+y)) = x+IZR (Zrnd_odd y))%R.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
forall x y : R,
(exists n e : Z,
   x = (IZR n * bpow beta e)%R /\ (1 <= e)%Z) ->
IZR (Zrnd_odd (x + y)) = (x + IZR (Zrnd_odd y))%R
Proof.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
forall x y : R,
(exists n e : Z,
   x = (IZR n * bpow beta e)%R /\ (1 <= e)%Z) ->
IZR (Zrnd_odd (x + y)) = (x + IZR (Zrnd_odd y))%R
intros x y (n,(e,(H1,H2))).
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x, y:R
n, e:Z
H1:x = (IZR n * bpow beta e)%R
H2:(1 <= e)%Z
IZR (Zrnd_odd (x + y)) = (x + IZR (Zrnd_odd y))%R
apply Zrnd_odd_plus.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x, y:R
n, e:Z
H1:x = (IZR n * bpow beta e)%R
H2:(1 <= e)%Z
x = IZR (Zfloor x)
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x, y:R
n, e:Z
H1:x = (IZR n * bpow beta e)%R
H2:(1 <= e)%Z
Z.even (Zfloor x) = true
rewrite H1.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x, y:R
n, e:Z
H1:x = (IZR n * bpow beta e)%R
H2:(1 <= e)%Z
(IZR n * bpow beta e)%R =
IZR (Zfloor (IZR n * bpow beta e))
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x, y:R
n, e:Z
H1:x = (IZR n * bpow beta e)%R
H2:(1 <= e)%Z
Z.even (Zfloor x) = true
rewrite <- IZR_Zpower.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x, y:R
n, e:Z
H1:x = (IZR n * bpow beta e)%R
H2:(1 <= e)%Z
(IZR n * IZR (beta ^ e))%R =
IZR (Zfloor (IZR n * IZR (beta ^ e)))
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x, y:R
n, e:Z
H1:x = (IZR n * bpow beta e)%R
H2:(1 <= e)%Z
(0 <= e)%Z
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x, y:R
n, e:Z
H1:x = (IZR n * bpow beta e)%R
H2:(1 <= e)%Z
Z.even (Zfloor x) = true
2: auto with zarith.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x, y:R
n, e:Z
H1:x = (IZR n * bpow beta e)%R
H2:(1 <= e)%Z
(IZR n * IZR (beta ^ e))%R =
IZR (Zfloor (IZR n * IZR (beta ^ e)))
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x, y:R
n, e:Z
H1:x = (IZR n * bpow beta e)%R
H2:(1 <= e)%Z
Z.even (Zfloor x) = true
now rewrite <- mult_IZR, Zfloor_IZR.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x, y:R
n, e:Z
H1:x = (IZR n * bpow beta e)%R
H2:(1 <= e)%Z
Z.even (Zfloor x) = true
rewrite H1, <- IZR_Zpower.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x, y:R
n, e:Z
H1:x = (IZR n * bpow beta e)%R
H2:(1 <= e)%Z
Z.even (Zfloor (IZR n * IZR (beta ^ e))) = true
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x, y:R
n, e:Z
H1:x = (IZR n * bpow beta e)%R
H2:(1 <= e)%Z
(0 <= e)%Z
2: auto with zarith.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x, y:R
n, e:Z
H1:x = (IZR n * bpow beta e)%R
H2:(1 <= e)%Z
Z.even (Zfloor (IZR n * IZR (beta ^ e))) = true
rewrite <- mult_IZR, Zfloor_IZR.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x, y:R
n, e:Z
H1:x = (IZR n * bpow beta e)%R
H2:(1 <= e)%Z
Z.even (n * beta ^ e) = true
rewrite Z.even_mul.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x, y:R
n, e:Z
H1:x = (IZR n * bpow beta e)%R
H2:(1 <= e)%Z
(Z.even n || Z.even (beta ^ e))%bool = true
rewrite Z.even_pow.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x, y:R
n, e:Z
H1:x = (IZR n * bpow beta e)%R
H2:(1 <= e)%Z
(Z.even n || Z.even beta)%bool = true
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x, y:R
n, e:Z
H1:x = (IZR n * bpow beta e)%R
H2:(1 <= e)%Z
(0 < e)%Z
2: auto with zarith.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x, y:R
n, e:Z
H1:x = (IZR n * bpow beta e)%R
H2:(1 <= e)%Z
(Z.even n || Z.even beta)%bool = true
rewrite Even_beta.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x, y:R
n, e:Z
H1:x = (IZR n * bpow beta e)%R
H2:(1 <= e)%Z
(Z.even n || true)%bool = true
apply Bool.orb_true_iff; now right.
Qed.



Theorem mag_round_odd: forall (x:R),
 (emin < mag beta x)%Z ->
  (mag_val beta _ (mag beta (round beta (FLT_exp emin prec) Zrnd_odd x))
      = mag_val beta x (mag beta x))%Z.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
forall x : R,
(emin < mag beta x)%Z ->
mag beta (round beta (FLT_exp emin prec) Zrnd_odd x) =
mag beta x
Proof with auto with typeclass_instances.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
forall x : R,
(emin < mag beta x)%Z ->
mag beta (round beta (FLT_exp emin prec) Zrnd_odd x) =
mag beta x
intros x.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
(emin < mag beta x)%Z ->
mag beta (round beta (FLT_exp emin prec) Zrnd_odd x) =
mag beta x
assert (T:Prec_gt_0 prec).
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
Prec_gt_0 prec
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
(emin < mag beta x)%Z ->
mag beta (round beta (FLT_exp emin prec) Zrnd_odd x) =
mag beta x
unfold Prec_gt_0; auto with zarith.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
(emin < mag beta x)%Z ->
mag beta (round beta (FLT_exp emin prec) Zrnd_odd x) =
mag beta x
case (Req_dec x 0); intros Zx.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x = 0%R
(emin < mag beta x)%Z ->
mag beta (round beta (FLT_exp emin prec) Zrnd_odd x) =
mag beta x
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
(emin < mag beta x)%Z ->
mag beta (round beta (FLT_exp emin prec) Zrnd_odd x) =
mag beta x
intros _; rewrite Zx, round_0...
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
(emin < mag beta x)%Z ->
mag beta (round beta (FLT_exp emin prec) Zrnd_odd x) =
mag beta x
destruct (mag beta x) as (e,He); simpl; intros H.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
mag beta (round beta (FLT_exp emin prec) Zrnd_odd x) =
e
apply mag_unique; split.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
(bpow beta (e - 1) <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <
 bpow beta e)%R
apply abs_round_ge_generic...
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
format (bpow beta (e - 1))
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
(bpow beta (e - 1) <= Rabs x)%R
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <
 bpow beta e)%R
apply generic_format_FLT_bpow...
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
(emin <= e - 1)%Z
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
(bpow beta (e - 1) <= Rabs x)%R
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <
 bpow beta e)%R
now apply Z.lt_le_pred.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
(bpow beta (e - 1) <= Rabs x)%R
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <
 bpow beta e)%R
now apply He.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <
 bpow beta e)%R
assert (V:
  (Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <= bpow beta e)%R).
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <
 bpow beta e)%R
apply abs_round_le_generic...
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
format (bpow beta e)
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
(Rabs x <= bpow beta e)%R
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <
 bpow beta e)%R
apply generic_format_FLT_bpow...
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
(emin <= e)%Z
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
(Rabs x <= bpow beta e)%R
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <
 bpow beta e)%R
now apply Zlt_le_weak.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
(Rabs x <= bpow beta e)%R
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <
 bpow beta e)%R
left; now apply He.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <
 bpow beta e)%R
case V; try easy; intros K.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <
 bpow beta e)%R
assert (H0:Rnd_odd_pt beta (FLT_exp emin prec) x (round beta (FLT_exp emin prec) Zrnd_odd x)).
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
Rnd_odd_pt beta (FLT_exp emin prec) x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_odd_pt beta (FLT_exp emin prec) x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <
 bpow beta e)%R
apply round_odd_pt...
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_odd_pt beta (FLT_exp emin prec) x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <
 bpow beta e)%R
destruct H0 as (_,HH); destruct HH as [H0|(H0,(g,(Hg1,(Hg2,Hg3))))].
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:round beta (FLT_exp emin prec) Zrnd_odd x = x
(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <
 bpow beta e)%R
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <
 bpow beta e)%R
absurd (Rabs x < bpow beta e)%R.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:round beta (FLT_exp emin prec) Zrnd_odd x = x
~ (Rabs x < bpow beta e)%R
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:round beta (FLT_exp emin prec) Zrnd_odd x = x
(Rabs x < bpow beta e)%R
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <
 bpow beta e)%R
apply Rle_not_lt; right.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:round beta (FLT_exp emin prec) Zrnd_odd x = x
bpow beta e = Rabs x
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:round beta (FLT_exp emin prec) Zrnd_odd x = x
(Rabs x < bpow beta e)%R
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <
 bpow beta e)%R
now rewrite <- H0,K.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:round beta (FLT_exp emin prec) Zrnd_odd x = x
(Rabs x < bpow beta e)%R
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <
 bpow beta e)%R
now apply He.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <
 bpow beta e)%R
pose (gg:=Float beta (Zpower beta (e-FLT_exp emin prec (e+1))) (FLT_exp emin prec (e+1))).
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
gg:={|
Fnum := beta ^ (e - FLT_exp emin prec (e + 1));
Fexp := FLT_exp emin prec (e + 1) |}:float beta
(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <
 bpow beta e)%R
assert (Y1: F2R gg = bpow beta e).
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
gg:={|
Fnum := beta ^ (e - FLT_exp emin prec (e + 1));
Fexp := FLT_exp emin prec (e + 1) |}:float beta
F2R gg = bpow beta e
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
gg:={|
Fnum := beta ^ (e - FLT_exp emin prec (e + 1));
Fexp := FLT_exp emin prec (e + 1) |}:float beta
Y1:F2R gg = bpow beta e
(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <
 bpow beta e)%R
unfold F2R; simpl.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
gg:={|
Fnum := beta ^ (e - FLT_exp emin prec (e + 1));
Fexp := FLT_exp emin prec (e + 1) |}:float beta
(IZR (beta ^ (e - FLT_exp emin prec (e + 1))) *
 bpow beta (FLT_exp emin prec (e + 1)))%R =
bpow beta e
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
gg:={|
Fnum := beta ^ (e - FLT_exp emin prec (e + 1));
Fexp := FLT_exp emin prec (e + 1) |}:float beta
Y1:F2R gg = bpow beta e
(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <
 bpow beta e)%R
rewrite IZR_Zpower.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
gg:={|
Fnum := beta ^ (e - FLT_exp emin prec (e + 1));
Fexp := FLT_exp emin prec (e + 1) |}:float beta
(bpow beta (e - FLT_exp emin prec (e + 1)) *
 bpow beta (FLT_exp emin prec (e + 1)))%R =
bpow beta e
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
gg:={|
Fnum := beta ^ (e - FLT_exp emin prec (e + 1));
Fexp := FLT_exp emin prec (e + 1) |}:float beta
(0 <= e - FLT_exp emin prec (e + 1))%Z
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
gg:={|
Fnum := beta ^ (e - FLT_exp emin prec (e + 1));
Fexp := FLT_exp emin prec (e + 1) |}:float beta
Y1:F2R gg = bpow beta e
(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <
 bpow beta e)%R
rewrite <- bpow_plus.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
gg:={|
Fnum := beta ^ (e - FLT_exp emin prec (e + 1));
Fexp := FLT_exp emin prec (e + 1) |}:float beta
bpow beta
  (e - FLT_exp emin prec (e + 1) +
   FLT_exp emin prec (e + 1)) = bpow beta e
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
gg:={|
Fnum := beta ^ (e - FLT_exp emin prec (e + 1));
Fexp := FLT_exp emin prec (e + 1) |}:float beta
(0 <= e - FLT_exp emin prec (e + 1))%Z
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
gg:={|
Fnum := beta ^ (e - FLT_exp emin prec (e + 1));
Fexp := FLT_exp emin prec (e + 1) |}:float beta
Y1:F2R gg = bpow beta e
(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <
 bpow beta e)%R
f_equal; ring.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
gg:={|
Fnum := beta ^ (e - FLT_exp emin prec (e + 1));
Fexp := FLT_exp emin prec (e + 1) |}:float beta
(0 <= e - FLT_exp emin prec (e + 1))%Z
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
gg:={|
Fnum := beta ^ (e - FLT_exp emin prec (e + 1));
Fexp := FLT_exp emin prec (e + 1) |}:float beta
Y1:F2R gg = bpow beta e
(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <
 bpow beta e)%R
assert (FLT_exp emin prec (e+1) <= e)%Z; [idtac|auto with zarith].
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
gg:={|
Fnum := beta ^ (e - FLT_exp emin prec (e + 1));
Fexp := FLT_exp emin prec (e + 1) |}:float beta
(FLT_exp emin prec (e + 1) <= e)%Z
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
gg:={|
Fnum := beta ^ (e - FLT_exp emin prec (e + 1));
Fexp := FLT_exp emin prec (e + 1) |}:float beta
Y1:F2R gg = bpow beta e
(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <
 bpow beta e)%R
unfold FLT_exp.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
gg:={|
Fnum := beta ^ (e - FLT_exp emin prec (e + 1));
Fexp := FLT_exp emin prec (e + 1) |}:float beta
(Z.max (e + 1 - prec) emin <= e)%Z
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
gg:={|
Fnum := beta ^ (e - FLT_exp emin prec (e + 1));
Fexp := FLT_exp emin prec (e + 1) |}:float beta
Y1:F2R gg = bpow beta e
(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <
 bpow beta e)%R
apply Z.max_case_strong; auto with zarith.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
gg:={|
Fnum := beta ^ (e - FLT_exp emin prec (e + 1));
Fexp := FLT_exp emin prec (e + 1) |}:float beta
Y1:F2R gg = bpow beta e
(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <
 bpow beta e)%R
assert (Y2: canonical beta (FLT_exp emin prec) gg).
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
gg:={|
Fnum := beta ^ (e - FLT_exp emin prec (e + 1));
Fexp := FLT_exp emin prec (e + 1) |}:float beta
Y1:F2R gg = bpow beta e
canonical beta (FLT_exp emin prec) gg
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
gg:={|
Fnum := beta ^ (e - FLT_exp emin prec (e + 1));
Fexp := FLT_exp emin prec (e + 1) |}:float beta
Y1:F2R gg = bpow beta e
Y2:canonical beta (FLT_exp emin prec) gg
(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <
 bpow beta e)%R
unfold canonical; rewrite Y1; unfold gg; simpl.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
gg:={|
Fnum := beta ^ (e - FLT_exp emin prec (e + 1));
Fexp := FLT_exp emin prec (e + 1) |}:float beta
Y1:F2R gg = bpow beta e
FLT_exp emin prec (e + 1) = cexp_flt (bpow beta e)
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
gg:={|
Fnum := beta ^ (e - FLT_exp emin prec (e + 1));
Fexp := FLT_exp emin prec (e + 1) |}:float beta
Y1:F2R gg = bpow beta e
Y2:canonical beta (FLT_exp emin prec) gg
(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <
 bpow beta e)%R
unfold cexp; now rewrite mag_bpow.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
gg:={|
Fnum := beta ^ (e - FLT_exp emin prec (e + 1));
Fexp := FLT_exp emin prec (e + 1) |}:float beta
Y1:F2R gg = bpow beta e
Y2:canonical beta (FLT_exp emin prec) gg
(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <
 bpow beta e)%R
assert (Y3: Fnum gg = Z.abs (Fnum g)).
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
gg:={|
Fnum := beta ^ (e - FLT_exp emin prec (e + 1));
Fexp := FLT_exp emin prec (e + 1) |}:float beta
Y1:F2R gg = bpow beta e
Y2:canonical beta (FLT_exp emin prec) gg
Fnum gg = Z.abs (Fnum g)
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
gg:={|
Fnum := beta ^ (e - FLT_exp emin prec (e + 1));
Fexp := FLT_exp emin prec (e + 1) |}:float beta
Y1:F2R gg = bpow beta e
Y2:canonical beta (FLT_exp emin prec) gg
Y3:Fnum gg = Z.abs (Fnum g)
(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <
 bpow beta e)%R
apply trans_eq with (Fnum (Fabs g)).
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
gg:={|
Fnum := beta ^ (e - FLT_exp emin prec (e + 1));
Fexp := FLT_exp emin prec (e + 1) |}:float beta
Y1:F2R gg = bpow beta e
Y2:canonical beta (FLT_exp emin prec) gg
Fnum gg = Fnum (Fabs g)
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
gg:={|
Fnum := beta ^ (e - FLT_exp emin prec (e + 1));
Fexp := FLT_exp emin prec (e + 1) |}:float beta
Y1:F2R gg = bpow beta e
Y2:canonical beta (FLT_exp emin prec) gg
Fnum (Fabs g) = Z.abs (Fnum g)
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
gg:={|
Fnum := beta ^ (e - FLT_exp emin prec (e + 1));
Fexp := FLT_exp emin prec (e + 1) |}:float beta
Y1:F2R gg = bpow beta e
Y2:canonical beta (FLT_exp emin prec) gg
Y3:Fnum gg = Z.abs (Fnum g)
(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <
 bpow beta e)%R
2: destruct g; unfold Fabs; now simpl.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
gg:={|
Fnum := beta ^ (e - FLT_exp emin prec (e + 1));
Fexp := FLT_exp emin prec (e + 1) |}:float beta
Y1:F2R gg = bpow beta e
Y2:canonical beta (FLT_exp emin prec) gg
Fnum gg = Fnum (Fabs g)
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
gg:={|
Fnum := beta ^ (e - FLT_exp emin prec (e + 1));
Fexp := FLT_exp emin prec (e + 1) |}:float beta
Y1:F2R gg = bpow beta e
Y2:canonical beta (FLT_exp emin prec) gg
Y3:Fnum gg = Z.abs (Fnum g)
(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <
 bpow beta e)%R
f_equal.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
gg:={|
Fnum := beta ^ (e - FLT_exp emin prec (e + 1));
Fexp := FLT_exp emin prec (e + 1) |}:float beta
Y1:F2R gg = bpow beta e
Y2:canonical beta (FLT_exp emin prec) gg
gg = Fabs g
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
gg:={|
Fnum := beta ^ (e - FLT_exp emin prec (e + 1));
Fexp := FLT_exp emin prec (e + 1) |}:float beta
Y1:F2R gg = bpow beta e
Y2:canonical beta (FLT_exp emin prec) gg
Y3:Fnum gg = Z.abs (Fnum g)
(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <
 bpow beta e)%R
apply canonical_unique with (FLT_exp emin prec); try assumption.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
gg:={|
Fnum := beta ^ (e - FLT_exp emin prec (e + 1));
Fexp := FLT_exp emin prec (e + 1) |}:float beta
Y1:F2R gg = bpow beta e
Y2:canonical beta (FLT_exp emin prec) gg
canonical beta (FLT_exp emin prec) (Fabs g)
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
gg:={|
Fnum := beta ^ (e - FLT_exp emin prec (e + 1));
Fexp := FLT_exp emin prec (e + 1) |}:float beta
Y1:F2R gg = bpow beta e
Y2:canonical beta (FLT_exp emin prec) gg
F2R gg = F2R (Fabs g)
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
gg:={|
Fnum := beta ^ (e - FLT_exp emin prec (e + 1));
Fexp := FLT_exp emin prec (e + 1) |}:float beta
Y1:F2R gg = bpow beta e
Y2:canonical beta (FLT_exp emin prec) gg
Y3:Fnum gg = Z.abs (Fnum g)
(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <
 bpow beta e)%R
destruct g; unfold Fabs; apply canonical_abs; easy.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
gg:={|
Fnum := beta ^ (e - FLT_exp emin prec (e + 1));
Fexp := FLT_exp emin prec (e + 1) |}:float beta
Y1:F2R gg = bpow beta e
Y2:canonical beta (FLT_exp emin prec) gg
F2R gg = F2R (Fabs g)
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
gg:={|
Fnum := beta ^ (e - FLT_exp emin prec (e + 1));
Fexp := FLT_exp emin prec (e + 1) |}:float beta
Y1:F2R gg = bpow beta e
Y2:canonical beta (FLT_exp emin prec) gg
Y3:Fnum gg = Z.abs (Fnum g)
(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <
 bpow beta e)%R
now rewrite Y1, F2R_abs, <- Hg1,K.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
gg:={|
Fnum := beta ^ (e - FLT_exp emin prec (e + 1));
Fexp := FLT_exp emin prec (e + 1) |}:float beta
Y1:F2R gg = bpow beta e
Y2:canonical beta (FLT_exp emin prec) gg
Y3:Fnum gg = Z.abs (Fnum g)
(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <
 bpow beta e)%R
assert (Y4: Z.even (Fnum gg) = true).
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
gg:={|
Fnum := beta ^ (e - FLT_exp emin prec (e + 1));
Fexp := FLT_exp emin prec (e + 1) |}:float beta
Y1:F2R gg = bpow beta e
Y2:canonical beta (FLT_exp emin prec) gg
Y3:Fnum gg = Z.abs (Fnum g)
Z.even (Fnum gg) = true
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
gg:={|
Fnum := beta ^ (e - FLT_exp emin prec (e + 1));
Fexp := FLT_exp emin prec (e + 1) |}:float beta
Y1:F2R gg = bpow beta e
Y2:canonical beta (FLT_exp emin prec) gg
Y3:Fnum gg = Z.abs (Fnum g)
Y4:Z.even (Fnum gg) = true
(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <
 bpow beta e)%R
unfold gg; simpl.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
gg:={|
Fnum := beta ^ (e - FLT_exp emin prec (e + 1));
Fexp := FLT_exp emin prec (e + 1) |}:float beta
Y1:F2R gg = bpow beta e
Y2:canonical beta (FLT_exp emin prec) gg
Y3:Fnum gg = Z.abs (Fnum g)
Z.even (beta ^ (e - FLT_exp emin prec (e + 1))) = true
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
gg:={|
Fnum := beta ^ (e - FLT_exp emin prec (e + 1));
Fexp := FLT_exp emin prec (e + 1) |}:float beta
Y1:F2R gg = bpow beta e
Y2:canonical beta (FLT_exp emin prec) gg
Y3:Fnum gg = Z.abs (Fnum g)
Y4:Z.even (Fnum gg) = true
(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <
 bpow beta e)%R
rewrite Z.even_pow; try assumption.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
gg:={|
Fnum := beta ^ (e - FLT_exp emin prec (e + 1));
Fexp := FLT_exp emin prec (e + 1) |}:float beta
Y1:F2R gg = bpow beta e
Y2:canonical beta (FLT_exp emin prec) gg
Y3:Fnum gg = Z.abs (Fnum g)
(0 < e - FLT_exp emin prec (e + 1))%Z
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
gg:={|
Fnum := beta ^ (e - FLT_exp emin prec (e + 1));
Fexp := FLT_exp emin prec (e + 1) |}:float beta
Y1:F2R gg = bpow beta e
Y2:canonical beta (FLT_exp emin prec) gg
Y3:Fnum gg = Z.abs (Fnum g)
Y4:Z.even (Fnum gg) = true
(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <
 bpow beta e)%R
assert (FLT_exp emin prec (e+1) < e)%Z; [idtac|auto with zarith].
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
gg:={|
Fnum := beta ^ (e - FLT_exp emin prec (e + 1));
Fexp := FLT_exp emin prec (e + 1) |}:float beta
Y1:F2R gg = bpow beta e
Y2:canonical beta (FLT_exp emin prec) gg
Y3:Fnum gg = Z.abs (Fnum g)
(FLT_exp emin prec (e + 1) < e)%Z
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
gg:={|
Fnum := beta ^ (e - FLT_exp emin prec (e + 1));
Fexp := FLT_exp emin prec (e + 1) |}:float beta
Y1:F2R gg = bpow beta e
Y2:canonical beta (FLT_exp emin prec) gg
Y3:Fnum gg = Z.abs (Fnum g)
Y4:Z.even (Fnum gg) = true
(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <
 bpow beta e)%R
unfold FLT_exp.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
gg:={|
Fnum := beta ^ (e - FLT_exp emin prec (e + 1));
Fexp := FLT_exp emin prec (e + 1) |}:float beta
Y1:F2R gg = bpow beta e
Y2:canonical beta (FLT_exp emin prec) gg
Y3:Fnum gg = Z.abs (Fnum g)
(Z.max (e + 1 - prec) emin < e)%Z
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
gg:={|
Fnum := beta ^ (e - FLT_exp emin prec (e + 1));
Fexp := FLT_exp emin prec (e + 1) |}:float beta
Y1:F2R gg = bpow beta e
Y2:canonical beta (FLT_exp emin prec) gg
Y3:Fnum gg = Z.abs (Fnum g)
Y4:Z.even (Fnum gg) = true
(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <
 bpow beta e)%R
apply Z.max_case_strong; auto with zarith.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
gg:={|
Fnum := beta ^ (e - FLT_exp emin prec (e + 1));
Fexp := FLT_exp emin prec (e + 1) |}:float beta
Y1:F2R gg = bpow beta e
Y2:canonical beta (FLT_exp emin prec) gg
Y3:Fnum gg = Z.abs (Fnum g)
Y4:Z.even (Fnum gg) = true
(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <
 bpow beta e)%R
absurd (true = false).
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
gg:={|
Fnum := beta ^ (e - FLT_exp emin prec (e + 1));
Fexp := FLT_exp emin prec (e + 1) |}:float beta
Y1:F2R gg = bpow beta e
Y2:canonical beta (FLT_exp emin prec) gg
Y3:Fnum gg = Z.abs (Fnum g)
Y4:Z.even (Fnum gg) = true
true <> false
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
gg:={|
Fnum := beta ^ (e - FLT_exp emin prec (e + 1));
Fexp := FLT_exp emin prec (e + 1) |}:float beta
Y1:F2R gg = bpow beta e
Y2:canonical beta (FLT_exp emin prec) gg
Y3:Fnum gg = Z.abs (Fnum g)
Y4:Z.even (Fnum gg) = true
true = false
discriminate.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
gg:={|
Fnum := beta ^ (e - FLT_exp emin prec (e + 1));
Fexp := FLT_exp emin prec (e + 1) |}:float beta
Y1:F2R gg = bpow beta e
Y2:canonical beta (FLT_exp emin prec) gg
Y3:Fnum gg = Z.abs (Fnum g)
Y4:Z.even (Fnum gg) = true
true = false
rewrite <- Hg3.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
gg:={|
Fnum := beta ^ (e - FLT_exp emin prec (e + 1));
Fexp := FLT_exp emin prec (e + 1) |}:float beta
Y1:F2R gg = bpow beta e
Y2:canonical beta (FLT_exp emin prec) gg
Y3:Fnum gg = Z.abs (Fnum g)
Y4:Z.even (Fnum gg) = true
true = Z.even (Fnum g)
rewrite <- Zeven_abs.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
T:Prec_gt_0 prec
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(emin < e)%Z
V:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta e)%R
K:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta e
H0:Rnd_DN_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x) \/
Rnd_UP_pt format x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
gg:={|
Fnum := beta ^ (e - FLT_exp emin prec (e + 1));
Fexp := FLT_exp emin prec (e + 1) |}:float beta
Y1:F2R gg = bpow beta e
Y2:canonical beta (FLT_exp emin prec) gg
Y3:Fnum gg = Z.abs (Fnum g)
Y4:Z.even (Fnum gg) = true
true = Z.even (Z.abs (Fnum g))
now rewrite <- Y3.
Qed.

Theorem fexp_round_odd: forall (x:R),
  (cexp_flt (round beta (FLT_exp emin prec) Zrnd_odd x)
      = cexp_flt x)%Z.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
forall x : R,
cexp_flt (round beta (FLT_exp emin prec) Zrnd_odd x) =
cexp_flt x
Proof with auto with typeclass_instances.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
forall x : R,
cexp_flt (round beta (FLT_exp emin prec) Zrnd_odd x) =
cexp_flt x
intros x.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
cexp_flt (round beta (FLT_exp emin prec) Zrnd_odd x) =
cexp_flt x
assert (G0:Valid_exp (FLT_exp emin prec)).
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
Valid_exp (FLT_exp emin prec)
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
cexp_flt (round beta (FLT_exp emin prec) Zrnd_odd x) =
cexp_flt x
apply FLT_exp_valid; unfold Prec_gt_0; auto with zarith.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
cexp_flt (round beta (FLT_exp emin prec) Zrnd_odd x) =
cexp_flt x
case (Req_dec x 0); intros Zx.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x = 0%R
cexp_flt (round beta (FLT_exp emin prec) Zrnd_odd x) =
cexp_flt x
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
cexp_flt (round beta (FLT_exp emin prec) Zrnd_odd x) =
cexp_flt x
rewrite Zx, round_0...
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
cexp_flt (round beta (FLT_exp emin prec) Zrnd_odd x) =
cexp_flt x
case (Zle_or_lt (mag beta x) emin).
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
(mag beta x <= emin)%Z ->
cexp_flt (round beta (FLT_exp emin prec) Zrnd_odd x) =
cexp_flt x
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
(emin < mag beta x)%Z ->
cexp_flt (round beta (FLT_exp emin prec) Zrnd_odd x) =
cexp_flt x
unfold cexp; destruct (mag beta x) as (e,He); simpl.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
(e <= emin)%Z ->
FLT_exp emin prec
  (mag beta
     (round beta (FLT_exp emin prec) Zrnd_odd x)) =
FLT_exp emin prec e
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
(emin < mag beta x)%Z ->
cexp_flt (round beta (FLT_exp emin prec) Zrnd_odd x) =
cexp_flt x
intros H; unfold FLT_exp at 4.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
FLT_exp emin prec
  (mag beta
     (round beta (FLT_exp emin prec) Zrnd_odd x)) =
Z.max (e - prec) emin
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
(emin < mag beta x)%Z ->
cexp_flt (round beta (FLT_exp emin prec) Zrnd_odd x) =
cexp_flt x
rewrite Z.max_r.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
FLT_exp emin prec
  (mag beta
     (round beta (FLT_exp emin prec) Zrnd_odd x)) =
emin
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
(e - prec <= emin)%Z
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
(emin < mag beta x)%Z ->
cexp_flt (round beta (FLT_exp emin prec) Zrnd_odd x) =
cexp_flt x
2: auto with zarith.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
FLT_exp emin prec
  (mag beta
     (round beta (FLT_exp emin prec) Zrnd_odd x)) =
emin
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
(emin < mag beta x)%Z ->
cexp_flt (round beta (FLT_exp emin prec) Zrnd_odd x) =
cexp_flt x
apply Z.max_r.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
(mag beta (round beta (FLT_exp emin prec) Zrnd_odd x) -
 prec <= emin)%Z
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
(emin < mag beta x)%Z ->
cexp_flt (round beta (FLT_exp emin prec) Zrnd_odd x) =
cexp_flt x
assert (G: Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) = bpow beta emin).
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
(mag beta (round beta (FLT_exp emin prec) Zrnd_odd x) -
 prec <= emin)%Z
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
(emin < mag beta x)%Z ->
cexp_flt (round beta (FLT_exp emin prec) Zrnd_odd x) =
cexp_flt x
assert (G1: (Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <= bpow beta emin)%R).
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
(mag beta (round beta (FLT_exp emin prec) Zrnd_odd x) -
 prec <= emin)%Z
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
(emin < mag beta x)%Z ->
cexp_flt (round beta (FLT_exp emin prec) Zrnd_odd x) =
cexp_flt x
apply abs_round_le_generic...
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
format (bpow beta emin)
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
(Rabs x <= bpow beta emin)%R
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
(mag beta (round beta (FLT_exp emin prec) Zrnd_odd x) -
 prec <= emin)%Z
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
(emin < mag beta x)%Z ->
cexp_flt (round beta (FLT_exp emin prec) Zrnd_odd x) =
cexp_flt x
apply generic_format_bpow'...
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
(FLT_exp emin prec emin <= emin)%Z
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
(Rabs x <= bpow beta emin)%R
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
(mag beta (round beta (FLT_exp emin prec) Zrnd_odd x) -
 prec <= emin)%Z
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
(emin < mag beta x)%Z ->
cexp_flt (round beta (FLT_exp emin prec) Zrnd_odd x) =
cexp_flt x
unfold FLT_exp; rewrite Z.max_r; auto with zarith.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
(Rabs x <= bpow beta emin)%R
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
(mag beta (round beta (FLT_exp emin prec) Zrnd_odd x) -
 prec <= emin)%Z
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
(emin < mag beta x)%Z ->
cexp_flt (round beta (FLT_exp emin prec) Zrnd_odd x) =
cexp_flt x
left; apply Rlt_le_trans with (bpow beta e).
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
(Rabs x < bpow beta e)%R
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
(bpow beta e <= bpow beta emin)%R
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
(mag beta (round beta (FLT_exp emin prec) Zrnd_odd x) -
 prec <= emin)%Z
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
(emin < mag beta x)%Z ->
cexp_flt (round beta (FLT_exp emin prec) Zrnd_odd x) =
cexp_flt x
now apply He.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
(bpow beta e <= bpow beta emin)%R
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
(mag beta (round beta (FLT_exp emin prec) Zrnd_odd x) -
 prec <= emin)%Z
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
(emin < mag beta x)%Z ->
cexp_flt (round beta (FLT_exp emin prec) Zrnd_odd x) =
cexp_flt x
now apply bpow_le.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
(mag beta (round beta (FLT_exp emin prec) Zrnd_odd x) -
 prec <= emin)%Z
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
(emin < mag beta x)%Z ->
cexp_flt (round beta (FLT_exp emin prec) Zrnd_odd x) =
cexp_flt x
assert (G2: (0 <= Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R).
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
(0 <= Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
(mag beta (round beta (FLT_exp emin prec) Zrnd_odd x) -
 prec <= emin)%Z
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
(emin < mag beta x)%Z ->
cexp_flt (round beta (FLT_exp emin prec) Zrnd_odd x) =
cexp_flt x
apply Rabs_pos.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
(mag beta (round beta (FLT_exp emin prec) Zrnd_odd x) -
 prec <= emin)%Z
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
(emin < mag beta x)%Z ->
cexp_flt (round beta (FLT_exp emin prec) Zrnd_odd x) =
cexp_flt x
assert (G3: (Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <> 0)%R).
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <>
0%R
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
G3:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <>
0%R
Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
(mag beta (round beta (FLT_exp emin prec) Zrnd_odd x) -
 prec <= emin)%Z
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
(emin < mag beta x)%Z ->
cexp_flt (round beta (FLT_exp emin prec) Zrnd_odd x) =
cexp_flt x
assert (H0:Rnd_odd_pt beta (FLT_exp emin prec) x
    (round beta (FLT_exp emin prec) Zrnd_odd x)).
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
Rnd_odd_pt beta (FLT_exp emin prec) x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
H0:Rnd_odd_pt beta (FLT_exp emin prec) x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <>
0%R
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
G3:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <>
0%R
Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
(mag beta (round beta (FLT_exp emin prec) Zrnd_odd x) -
 prec <= emin)%Z
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
(emin < mag beta x)%Z ->
cexp_flt (round beta (FLT_exp emin prec) Zrnd_odd x) =
cexp_flt x
apply round_odd_pt...
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
H0:Rnd_odd_pt beta (FLT_exp emin prec) x
  (round beta (FLT_exp emin prec) Zrnd_odd x)
Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <>
0%R
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
G3:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <>
0%R
Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
(mag beta (round beta (FLT_exp emin prec) Zrnd_odd x) -
 prec <= emin)%Z
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
(emin < mag beta x)%Z ->
cexp_flt (round beta (FLT_exp emin prec) Zrnd_odd x) =
cexp_flt x
destruct H0 as (_,H0); destruct H0 as [H0|(_,(g,(Hg1,(Hg2,Hg3))))].
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
H0:round beta (FLT_exp emin prec) Zrnd_odd x = x
Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <>
0%R
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <>
0%R
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
G3:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <>
0%R
Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
(mag beta (round beta (FLT_exp emin prec) Zrnd_odd x) -
 prec <= emin)%Z
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
(emin < mag beta x)%Z ->
cexp_flt (round beta (FLT_exp emin prec) Zrnd_odd x) =
cexp_flt x
apply Rgt_not_eq; rewrite H0.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
H0:round beta (FLT_exp emin prec) Zrnd_odd x = x
(Rabs x > 0)%R
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <>
0%R
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
G3:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <>
0%R
Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
(mag beta (round beta (FLT_exp emin prec) Zrnd_odd x) -
 prec <= emin)%Z
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
(emin < mag beta x)%Z ->
cexp_flt (round beta (FLT_exp emin prec) Zrnd_odd x) =
cexp_flt x
apply Rlt_le_trans with (bpow beta (e-1)).
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
H0:round beta (FLT_exp emin prec) Zrnd_odd x = x
(0 < bpow beta (e - 1))%R
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
H0:round beta (FLT_exp emin prec) Zrnd_odd x = x
(bpow beta (e - 1) <= Rabs x)%R
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <>
0%R
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
G3:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <>
0%R
Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
(mag beta (round beta (FLT_exp emin prec) Zrnd_odd x) -
 prec <= emin)%Z
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
(emin < mag beta x)%Z ->
cexp_flt (round beta (FLT_exp emin prec) Zrnd_odd x) =
cexp_flt x
apply bpow_gt_0.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
H0:round beta (FLT_exp emin prec) Zrnd_odd x = x
(bpow beta (e - 1) <= Rabs x)%R
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <>
0%R
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
G3:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <>
0%R
Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
(mag beta (round beta (FLT_exp emin prec) Zrnd_odd x) -
 prec <= emin)%Z
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
(emin < mag beta x)%Z ->
cexp_flt (round beta (FLT_exp emin prec) Zrnd_odd x) =
cexp_flt x
now apply He.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <>
0%R
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
G3:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <>
0%R
Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
(mag beta (round beta (FLT_exp emin prec) Zrnd_odd x) -
 prec <= emin)%Z
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
(emin < mag beta x)%Z ->
cexp_flt (round beta (FLT_exp emin prec) Zrnd_odd x) =
cexp_flt x
rewrite Hg1; intros K.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
Hg3:Z.even (Fnum g) = false
K:Rabs (F2R g) = 0%R
False
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
G3:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <>
0%R
Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
(mag beta (round beta (FLT_exp emin prec) Zrnd_odd x) -
 prec <= emin)%Z
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
(emin < mag beta x)%Z ->
cexp_flt (round beta (FLT_exp emin prec) Zrnd_odd x) =
cexp_flt x
contradict Hg3.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
K:Rabs (F2R g) = 0%R
Z.even (Fnum g) <> false
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
G3:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <>
0%R
Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
(mag beta (round beta (FLT_exp emin prec) Zrnd_odd x) -
 prec <= emin)%Z
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
(emin < mag beta x)%Z ->
cexp_flt (round beta (FLT_exp emin prec) Zrnd_odd x) =
cexp_flt x
replace (Fnum g) with 0%Z.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
K:Rabs (F2R g) = 0%R
Z.even 0 <> false
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
K:Rabs (F2R g) = 0%R
0%Z = Fnum g
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
G3:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <>
0%R
Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
(mag beta (round beta (FLT_exp emin prec) Zrnd_odd x) -
 prec <= emin)%Z
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
(emin < mag beta x)%Z ->
cexp_flt (round beta (FLT_exp emin prec) Zrnd_odd x) =
cexp_flt x
easy.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
K:Rabs (F2R g) = 0%R
0%Z = Fnum g
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
G3:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <>
0%R
Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
(mag beta (round beta (FLT_exp emin prec) Zrnd_odd x) -
 prec <= emin)%Z
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
(emin < mag beta x)%Z ->
cexp_flt (round beta (FLT_exp emin prec) Zrnd_odd x) =
cexp_flt x
case (Z.eq_dec (Fnum g) Z0); intros W; try easy.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
K:Rabs (F2R g) = 0%R
W:Fnum g <> 0%Z
0%Z = Fnum g
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
G3:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <>
0%R
Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
(mag beta (round beta (FLT_exp emin prec) Zrnd_odd x) -
 prec <= emin)%Z
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
(emin < mag beta x)%Z ->
cexp_flt (round beta (FLT_exp emin prec) Zrnd_odd x) =
cexp_flt x
contradict K.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
W:Fnum g <> 0%Z
Rabs (F2R g) <> 0%R
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
G3:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <>
0%R
Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
(mag beta (round beta (FLT_exp emin prec) Zrnd_odd x) -
 prec <= emin)%Z
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
(emin < mag beta x)%Z ->
cexp_flt (round beta (FLT_exp emin prec) Zrnd_odd x) =
cexp_flt x
apply Rabs_no_R0.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
g:float beta
Hg1:round beta (FLT_exp emin prec) Zrnd_odd x =
F2R g
Hg2:canonical beta (FLT_exp emin prec) g
W:Fnum g <> 0%Z
F2R g <> 0%R
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
G3:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <>
0%R
Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
(mag beta (round beta (FLT_exp emin prec) Zrnd_odd x) -
 prec <= emin)%Z
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
(emin < mag beta x)%Z ->
cexp_flt (round beta (FLT_exp emin prec) Zrnd_odd x) =
cexp_flt x
now apply F2R_neq_0.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
G3:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <>
0%R
Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
(mag beta (round beta (FLT_exp emin prec) Zrnd_odd x) -
 prec <= emin)%Z
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
(emin < mag beta x)%Z ->
cexp_flt (round beta (FLT_exp emin prec) Zrnd_odd x) =
cexp_flt x
apply Rle_antisym; try assumption.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
G3:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <>
0%R
(bpow beta emin <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
(mag beta (round beta (FLT_exp emin prec) Zrnd_odd x) -
 prec <= emin)%Z
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
(emin < mag beta x)%Z ->
cexp_flt (round beta (FLT_exp emin prec) Zrnd_odd x) =
cexp_flt x
apply Rle_trans with (succ beta (FLT_exp emin prec) 0).
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
G3:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <>
0%R
(bpow beta emin <= succ beta (FLT_exp emin prec) 0)%R
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
G3:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <>
0%R
(succ beta (FLT_exp emin prec) 0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
(mag beta (round beta (FLT_exp emin prec) Zrnd_odd x) -
 prec <= emin)%Z
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
(emin < mag beta x)%Z ->
cexp_flt (round beta (FLT_exp emin prec) Zrnd_odd x) =
cexp_flt x
right; rewrite succ_0.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
G3:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <>
0%R
bpow beta emin = ulp beta (FLT_exp emin prec) 0
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
G3:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <>
0%R
(succ beta (FLT_exp emin prec) 0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
(mag beta (round beta (FLT_exp emin prec) Zrnd_odd x) -
 prec <= emin)%Z
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
(emin < mag beta x)%Z ->
cexp_flt (round beta (FLT_exp emin prec) Zrnd_odd x) =
cexp_flt x
rewrite ulp_FLT_small; try easy.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
G3:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <>
0%R
Prec_gt_0 prec
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
G3:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <>
0%R
(Rabs 0 < bpow beta (emin + prec))%R
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
G3:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <>
0%R
(succ beta (FLT_exp emin prec) 0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
(mag beta (round beta (FLT_exp emin prec) Zrnd_odd x) -
 prec <= emin)%Z
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
(emin < mag beta x)%Z ->
cexp_flt (round beta (FLT_exp emin prec) Zrnd_odd x) =
cexp_flt x
unfold Prec_gt_0; auto with zarith.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
G3:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <>
0%R
(Rabs 0 < bpow beta (emin + prec))%R
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
G3:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <>
0%R
(succ beta (FLT_exp emin prec) 0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
(mag beta (round beta (FLT_exp emin prec) Zrnd_odd x) -
 prec <= emin)%Z
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
(emin < mag beta x)%Z ->
cexp_flt (round beta (FLT_exp emin prec) Zrnd_odd x) =
cexp_flt x
rewrite Rabs_R0; apply bpow_gt_0.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
G3:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <>
0%R
(succ beta (FLT_exp emin prec) 0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
(mag beta (round beta (FLT_exp emin prec) Zrnd_odd x) -
 prec <= emin)%Z
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
(emin < mag beta x)%Z ->
cexp_flt (round beta (FLT_exp emin prec) Zrnd_odd x) =
cexp_flt x
apply succ_le_lt...
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
G3:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <>
0%R
format 0
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
G3:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <>
0%R
format
  (Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
G3:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <>
0%R
(0 < Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
(mag beta (round beta (FLT_exp emin prec) Zrnd_odd x) -
 prec <= emin)%Z
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
(emin < mag beta x)%Z ->
cexp_flt (round beta (FLT_exp emin prec) Zrnd_odd x) =
cexp_flt x
apply generic_format_0.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
G3:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <>
0%R
format
  (Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
G3:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <>
0%R
(0 < Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
(mag beta (round beta (FLT_exp emin prec) Zrnd_odd x) -
 prec <= emin)%Z
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
(emin < mag beta x)%Z ->
cexp_flt (round beta (FLT_exp emin prec) Zrnd_odd x) =
cexp_flt x
apply generic_format_abs; apply generic_format_round...
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G1:(Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <=
 bpow beta emin)%R
G2:(0 <=
 Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
G3:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) <>
0%R
(0 < Rabs (round beta (FLT_exp emin prec) Zrnd_odd x))%R
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
(mag beta (round beta (FLT_exp emin prec) Zrnd_odd x) -
 prec <= emin)%Z
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
(emin < mag beta x)%Z ->
cexp_flt (round beta (FLT_exp emin prec) Zrnd_odd x) =
cexp_flt x
case G2; [easy|intros; now contradict G3].
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
(mag beta (round beta (FLT_exp emin prec) Zrnd_odd x) -
 prec <= emin)%Z
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
(emin < mag beta x)%Z ->
cexp_flt (round beta (FLT_exp emin prec) Zrnd_odd x) =
cexp_flt x
rewrite <- mag_abs.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
e:Z
He:x <> 0%R ->
(bpow beta (e - 1) <= Rabs x < bpow beta e)%R
H:(e <= emin)%Z
G:Rabs (round beta (FLT_exp emin prec) Zrnd_odd x) =
bpow beta emin
(mag beta
   (Rabs (round beta (FLT_exp emin prec) Zrnd_odd x)) -
 prec <= emin)%Z
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
(emin < mag beta x)%Z ->
cexp_flt (round beta (FLT_exp emin prec) Zrnd_odd x) =
cexp_flt x
rewrite G, mag_bpow; auto with zarith.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
(emin < mag beta x)%Z ->
cexp_flt (round beta (FLT_exp emin prec) Zrnd_odd x) =
cexp_flt x
intros H; unfold cexp.
beta:radix
Even_beta:Z.even beta = true
emin, prec:Z
choice:Z -> bool
prec_gt_1:(1 < prec)%Z
x:R
G0:Valid_exp (FLT_exp emin prec)
Zx:x <> 0%R
H:(emin < mag beta x)%Z
FLT_exp emin prec
  (mag beta
     (round beta (FLT_exp emin prec) Zrnd_odd x)) =
FLT_exp emin prec (mag beta x)
now rewrite mag_round_odd.
Qed.




End Odd_propbis.