library colibrilib.fbin_ieee — module Bitsfbin.mlw are the ones of FlocqFor the formats of Flocq's Bits (std fm: sb fm < 2^(eb fm - 1), which excludes only some formats with 2 or 3 bits of exponent), the float of the encoding of Flocq's result (colibrilib.flocq.Binary, realized in Rocq) is the result of the operation of fbin.Impl, NaNs, infinities and the signs of zeros included.
module Bits386use int.Int387use int.Power388use int.EuclideanDivision389use real.RealInfix390use real.FromInt391use real.Abs392use colibrilib.fp.Widen393use real.Truncate394use real.Square as S395use colibrilib.fp.Ereal396use colibrilib.fbin.Pow2r397use colibrilib.fbin.Format398use colibrilib.fbin.Float399use colibrilib.fbin.Round400use colibrilib.fbin.Impl401use colibrilib.flocq.Round as F402use colibrilib.flocq.Binary as B403use Equiv404
The format of Bits: mw bits of significand, ew of exponent
function mw (fm: format) : int = sb fm - 1407function ew (fm: format) : int = eb fm408409predicate std (fm: format) = B.valid (mw fm) (ew fm)410411function bmode (m: mode) : B.mode =412match m with413| RNE -> B.rne | RNA -> B.rna | RTP -> B.rtp | RTN -> B.rtn | RTZ -> B.rtz414end415
The magnitude of the encoding b
function kof (fm: format) (b: int) : int =418if half_bits fm <= b then b - half_bits fm else b419Valid (410ms) (colibri2 27) (split_vc 7) (depth 2)420let ghost bits_k (fm: format) (b: int) : unit421requires { 0 <= b < 2 * half_bits fm }422ensures { half_bits fm = power 2 (mw fm) * power 2 (ew fm) }423ensures { B.in_range (mw fm) (ew fm) b }424ensures { 0 <= kof fm b < half_bits fm }425ensures { B.bneg (mw fm) (ew fm) b <-> half_bits fm <= b }426ensures { B.bman (mw fm) b = mod (kof fm b) (binade fm) }427ensures { B.bexp (mw fm) (ew fm) b = div (kof fm b) (binade fm) }428ensures { nb_sign fm - 1 = (power 2 (ew fm) - 1) * binade fm }429ensures { B.emin (mw fm) (ew fm) = qmin fm /\ B.prec (mw fm) = sb fm }430ensures { B.emax (ew fm) = emax fm }431ensures { B.bmag (mw fm) (ew fm) b = vom fm (kof fm b) }432= {proof…}433let p = power 2 (mw fm) in434let q = power 2 (ew fm) in435let h = half_bits fm in436let k = kof fm b in437assert { h = p * q by power 2 (mw fm + ew fm) = p * q };438assert { power 2 (mw fm + ew fm + 1) = 2 * h };439assert { 0 < p /\ 0 < q };440assert { 0 <= k < h };441assert { b = k \/ b = k + q * p };442assert { mod (p * q + k) p = mod k p /\ div (p * q + k) p = q + div k p };443assert { mod b p = mod k p by b = k \/ b = p * q + k };444assert { 0 <= div k p };445if pure { div k p >= q } then assert { p * div k p >= p * q };446assert { div k p < q };447assert { div b p = div k p \/ div b p = div k p + q by b = k \/ b = p * q + k };448assert { mod (div b p) q = div k p449by mod (div k p) q = div k p /\450mod (q * 1 + div k p) q = mod (div k p) q };451pow2_pow2r (qmin fm);452pow2_pow2r (pure { div k p + qmin fm - 1 })453{qed}454
The views of the encoding are the ones of its float
Valid (4.3s) (colibri2 13) (cvc5 28) (split_vc 17) (depth 4)let ghost of_bits_views (fm: format) (b: int) : unit456requires { B.in_range (mw fm) (ew fm) b }457ensures { let x = of_bits fm b in458x.fmt = fm /\459(B.bnan (mw fm) (ew fm) b <-> x.value = NaN) /\460(B.binf (mw fm) (ew fm) b /\ not B.bneg (mw fm) (ew fm) b <-> x.value = PlusInf) /\461(B.binf (mw fm) (ew fm) b /\ B.bneg (mw fm) (ew fm) b <-> x.value = MinusInf) /\462(B.bfin (mw fm) (ew fm) b <-> is_finite x) /\463(B.bzero (mw fm) (ew fm) b <-> is_zero x) /\464(B.bfin (mw fm) (ew fm) b ->465to_real x = B.bval (mw fm) (ew fm) b /\466(B.bneg (mw fm) (ew fm) b <-> not is_positive x)) }467= {proof…}468let h = half_bits fm in469assert { power 2 (mw fm + ew fm + 1) = 2 * h470by power 2 (mw fm + ew fm + 1) = 2 * power 2 (mw fm + ew fm) };471bits_k fm b;472assert { mod b (2 * h) = b };473let k = kof fm b in474let p = binade fm in475let q = power 2 (ew fm) in476let d = pure { div k p } in477let r = pure { mod k p } in478assert { k = p * d + r /\ 0 <= r < p /\ 0 <= d < q };479let n1 = pure { nb_sign fm - 1 } in480assert { n1 = p * (q - 1) };481if d < q - 1 then assert { k < n1 by k < p * d + p = p * (d + 1) <= p * (q - 1) }482else begin483assert { d = q - 1 };484if r = 0 then assert { k = n1 } else assert { k > n1 }485end;486assert { d = 0 /\ r = 0 <-> k = 0 }487{qed}488
Two floats of a format with the same views are equal
Valid (782ms) (cvc5)let ghost views_eq (x y: t) : unit490requires { x.fmt = y.fmt }491requires { x.value = NaN <-> y.value = NaN }492requires { x.value = PlusInf <-> y.value = PlusInf }493requires { x.value = MinusInf <-> y.value = MinusInf }494requires { is_finite x -> is_finite y }495requires { is_finite x ->496to_real x = to_real y /\ (is_positive x <-> is_positive y) }497ensures { x = y }498= {proof…}499match x.value, y.value with500| Finite nx kx, Finite ny ky ->501assert { nx = ny };502assert { vom x.fmt kx = vom x.fmt ky };503if kx < ky then vom_lt x.fmt kx ky504else if ky < kx then vom_lt x.fmt ky kx;505t_ext x y506| _ -> t_ext x y507end508{qed}509
The largest finite magnitude
Valid (73ms) (colibri2 10) (split_vc) (depth 1)let ghost maxv_vom (fm: format) : unit512ensures { B.maxv (mw fm) (ew fm) = vom fm (nb_sign fm - 2) }513= {proof…}514let p = binade fm in515binade_2 fm; binade_ge_2 fm;516let u = pure { emax fm - sb fm } in517assert { power 2 (eb fm) = 2 * power 2 (eb fm - 1)518by power 2 (eb fm) = power 2 ((eb fm - 1) + 1) };519assert { 2 <= power 2 (eb fm - 1)520by power 2 (eb fm - 1) = 2 * power 2 (eb fm - 2)521by power 2 (eb fm - 1) = power 2 ((eb fm - 2) + 1) };522assert { u - qmin fm = power 2 (eb fm) - 3 };523assert { qmin fm < u };524vom_s fm u (2 * p - 1);525assert { (u - qmin fm) * p = (power 2 (eb fm) - 3) * p };526assert { (power 2 (eb fm) - 3) * p + 2 * p = (power 2 (eb fm) - 1) * p };527assert { (u - qmin fm) * p + (2 * p - 1) = nb_sign fm - 2 };528pow2_pow2r u529{qed}530
The rounding of Flocq in the mode bmode m
Valid (3.2s) (colibri2 3) (split_vc) (depth 1)let ghost rnd_flocq (fm: format) (m: mode) (r: real) : unit533ensures { B.rnd (B.prec (mw fm)) (B.emin (mw fm) (ew fm)) (bmode m) r = flocq fm m r }534ensures { F.pow2 (B.emax (ew fm)) = pow2r (emax fm) }535= {proof…}536bits_k fm 0; pow2_pow2r (emax fm)537{qed}538
The encoding of the rounding of Flocq, with the sign sgn of a finite result, is the rounding round_fin, when sgn is the sign of r for a non–zero result and zn for a zero result
Valid (2.9s) (colibri2 29) (cvc4 7) (cvc5 13) (split_vc 13) (depth 5)let ghost round_bits (fm: format) (m: mode) (zn sgn: bool) (r: real) (bz: int)543requires { std fm /\ B.in_range (mw fm) (ew fm) bz }544requires { B.small (mw fm) (ew fm) (bmode m) r ->545B.rounded (mw fm) (ew fm) (bmode m) r bz /\546(B.bneg (mw fm) (ew fm) bz <-> sgn) }547requires { not B.small (mw fm) (ew fm) (bmode m) r ->548B.ovf (mw fm) (ew fm) (bmode m) bz /\549(B.bneg (mw fm) (ew fm) bz <-> r <. 0.0) }550requires { flocq fm m r = 0.0 -> (sgn <-> zn) }551requires { flocq fm m r <> 0.0 -> (sgn <-> r <. 0.0) }552ensures { of_bits fm bz = round_fin fm m zn r }553= {proof…}554let mw = mw fm in555let ew = ew fm in556of_bits_views fm bz;557rnd_flocq fm m r;558round_fin_flocq fm m zn r;559vom_zero fm;560maxv_vom fm;561let x = of_bits fm bz in562let y = round_fin fm m zn r in563if pure { B.small mw ew (bmode m) r } then begin564assert { is_finite y /\ to_real y = flocq fm m r };565assert { is_finite x /\ to_real x = flocq fm m r };566match y.value with567| Finite ny ky ->568if ky = 0 then assert { ny = zn }569else begin570vom_lt fm 0 ky;571assert { flocq fm m r <> 0.0 };572if pure { 0.0 <=. r } then begin573let k = pure { round_mag fm m r } in574assert { k <> 0 /\ y = of_mag fm m false k };575assert { not ny }576end else begin577let k = pure { round_mag fm (mirror m) (-. r) } in578assert { k <> 0 /\ y = of_mag fm (mirror m) true k };579assert { ny }580end581end582| _ -> absurd583end;584views_eq x y585end else begin586assert { y.value = overflow fm m (r <. 0.0) };587match m with588| RTZ ->589assert { B.bfin mw ew bz /\ B.bmag mw ew bz = B.maxv mw ew };590match x.value with591| Finite _ k ->592bits_k fm bz;593assert { vom fm k = vom fm (nb_sign fm - 2) };594if k < nb_sign fm - 2 then vom_lt fm k (nb_sign fm - 2)595else if nb_sign fm - 2 < k then vom_lt fm (nb_sign fm - 2) k596| _ -> absurd597end598| RTN ->599if pure { r <. 0.0 } then () else begin600assert { B.bfin mw ew bz /\ B.bmag mw ew bz = B.maxv mw ew };601match x.value with602| Finite _ k ->603bits_k fm bz;604assert { vom fm k = vom fm (nb_sign fm - 2) };605if k < nb_sign fm - 2 then vom_lt fm k (nb_sign fm - 2)606else if nb_sign fm - 2 < k then vom_lt fm (nb_sign fm - 2) k607| _ -> absurd608end609end610| RTP ->611if pure { r <. 0.0 } then begin612assert { B.bfin mw ew bz /\ B.bmag mw ew bz = B.maxv mw ew };613match x.value with614| Finite _ k ->615bits_k fm bz;616assert { vom fm k = vom fm (nb_sign fm - 2) };617if k < nb_sign fm - 2 then vom_lt fm k (nb_sign fm - 2)618else if nb_sign fm - 2 < k then vom_lt fm (nb_sign fm - 2) k619| _ -> absurd620end621end622| _ -> ()623end;624t_ext x y625end626{qed}627
The finite values are multiples of 2^qmin
Valid (390ms) (colibri2 5) (cvc5) (split_vc 3) (depth 3)let ghost real_mult (x: t) : int629requires { is_finite x }630ensures { to_real x = from_int result *. pow2r (qmin x.fmt) }631= {proof…}632match x.value with633| Finite ng k ->634let fm = x.fmt in635vom_dec fm k;636let e = pure { uexp fm k - qmin fm } in637pow2r_add (qmin fm) e; pow2r_int e;638let n = pure { sig fm k * power 2 e } in639assert { vom fm k = from_int n *. pow2r (qmin fm) };640if ng then - n else n641| _ -> absurd642end643{qed}644
A non–zero multiple of 2^qmin does not round to zero
Valid (1.7s) (colibri2 15) (cvc4 3) (cvc5) (split_vc 2) (depth 2)let ghost round_nonzero (fm: format) (m: mode) (n: int) (r: real) : unit647requires { n <> 0 /\ r = from_int n *. pow2r (qmin fm) }648ensures { flocq fm m r <> 0.0 }649= {proof…}650binade_ge_2 fm;651vom_s fm (qmin fm) 1;652assert { vom fm 1 = pow2r (qmin fm) };653pow2r_pos (qmin fm);654vom_zero fm;655round_fin_flocq fm m false r;656let y = pure { round_fin fm m false r } in657if pure { Abs.abs (flocq fm m r) <. pow2r (emax fm) } then begin658if pure { 0.0 <=. r } then begin659assert { 1 <= n };660assert { vom fm 1 <=. r };661round_mag_mono fm m (vom fm 1) r; round_mag_exact fm m 1;662let k = pure { round_mag fm m r } in663assert { 1 <= k /\ y = of_mag fm m false k };664assert { y = of_mag fm m false k }665end else begin666assert { n <= -1 };667assert { -. r = from_int (- n) *. pow2r (qmin fm) };668assert { vom fm 1 <=. -. r };669round_mag_mono fm (mirror m) (vom fm 1) (-. r); round_mag_exact fm (mirror m) 1;670let k = pure { round_mag fm (mirror m) (-. r) } in671assert { 1 <= k /\ y = of_mag fm (mirror m) true k }672end;673vom_max fm;674match y.value with675| Finite _ k' -> assert { 1 <= k' }; vom_lt fm 0 k'676| _ -> ()677end678end else pow2r_pos (emax fm)679{qed} Valid (1.9s) (colibri2 3) (cvc5 5) (split_vc 2) (depth 2)680let ghost flocq_zero (fm: format) (m: mode) : unit681ensures { flocq fm m 0.0 = 0.0 }682= {proof…}683vom_zero fm; vom_generic fm 0;684assert { F.generic (sb fm) (qmin fm) 0.0 };685binade_ge_2 fm;686assert { 1 < sb fm };687match m with688| RNE -> assert { F.nearest (sb fm) (qmin fm) 0.0 (flocq fm m 0.0) }689| RNA -> assert { F.nearest (sb fm) (qmin fm) 0.0 (flocq fm m 0.0) }690| _ -> ()691end692{qed}693Valid (88ms) (colibri2)694let ghost bmag_pos (fm: format) (b: int) : unit695requires { B.in_range (mw fm) (ew fm) b }696ensures { 0.0 <=. B.bmag (mw fm) (ew fm) b }697ensures { B.bneg (mw fm) (ew fm) b -> B.bval (mw fm) (ew fm) b <=. 0.0 }698ensures { not B.bneg (mw fm) (ew fm) b -> 0.0 <=. B.bval (mw fm) (ew fm) b }699= {proof…}700assert { power 2 (mw fm + ew fm + 1) = 2 * half_bits fm701by power 2 (mw fm + ew fm + 1) = 2 * power 2 (mw fm + ew fm) };702bits_k fm b; vom_zero fm; vom_mono fm 0 (kof fm b)703{qed}704
A finite encoding is a float below 2^emax
Valid (809ms) (colibri2 5) (cvc5 3) (split_vc) (depth 1)let ghost fin_small (fm: format) (b: int) : unit707requires { B.in_range (mw fm) (ew fm) b /\ B.bfin (mw fm) (ew fm) b }708ensures { Abs.abs (B.bval (mw fm) (ew fm) b) <. pow2r (emax fm) }709ensures { F.generic (sb fm) (qmin fm) (B.bval (mw fm) (ew fm) b) }710= {proof…}711of_bits_views fm b;712vom_max fm;713match (of_bits fm b).value with714| Finite ng k ->715vom_lt fm k (nb_sign fm - 1); vom_generic fm k; vom_zero fm; vom_mono fm 0 k;716if ng then generic_neg (sb fm) (qmin fm) (vom fm k)717| _ -> absurd718end719{qed}720
The rounding to an integer of Flocq is round_int
Valid (726ms) (colibri2 16) (cvc4 3) (cvc5 6) (split_vc) (depth 1)let ghost rnd_int_round (m: mode) (r: real) : unit723ensures { B.rnd_int (bmode m) r = round_int m r }724= {proof…}725let f = Truncate.floor r in726let d = pure { r -. from_int f } in727assert { 0.0 <=. d <. 1.0 };728let n = B.rnd_int (bmode m) r in729match m with730| RTN -> assert { n <= f /\ f <= n }731| RTP -> if pure { d = 0.0 } then assert { n = f } else assert { n = f + 1 }732| RTZ ->733let nn = B.rnd_int B.rtn r in734let np = B.rnd_int B.rtp r in735assert { nn = f };736if pure { d = 0.0 } then assert { np = f } else assert { np = f + 1 }737| RNE ->738assert { f <= n <= f + 1 };739if pure { d <. 0.5 } then assert { n = f }740else if pure { 0.5 <. d } then assert { n = f + 1 }741else begin742assert { Abs.abs (r -. from_int n) = 0.5 };743let q = any int ensures { n = 2 * result } in744if mod f 2 = 0 then begin745assert { f = 2 * div f 2 };746if n = f + 1 then assert { 2 * q = 2 * div f 2 + 1 }747end else begin748assert { f = 2 * div f 2 + 1 };749if n = f then assert { 2 * q = 2 * div f 2 + 1 }750end751end752| RNA ->753assert { f <= n <= f + 1 };754if pure { d <. 0.5 } then assert { n = f }755else if pure { 0.5 <. d } then assert { n = f + 1 }756else begin757assert { Abs.abs (r -. from_int n) = 0.5 };758assert { Abs.abs r <. Abs.abs (from_int n) };759if pure { 0.0 <=. r } then assert { n = f + 1 } else assert { n = f }760end761end762{qed}763
Valid (2.2s) (colibri2 9) (cvc4 3) (cvc5 9) (split_vc 8) (depth 2)let ghost neg_bits (fm: format) (bx: int) : unit767requires { std fm /\ B.in_range (mw fm) (ew fm) bx }768ensures { of_bits fm (B.b_neg (mw fm) (ew fm) bx) = neg (of_bits fm bx) }769= {proof…}770let bz = B.b_neg (mw fm) (ew fm) bx in771of_bits_views fm bx; of_bits_views fm bz;772bits_k fm bx; bits_k fm bz;773let mw = mw fm in774let ew = ew fm in775assert { B.bfin mw ew bx -> B.bfin mw ew bz /\ B.bmag mw ew bz = B.bmag mw ew bx /\776(B.bneg mw ew bz <-> not B.bneg mw ew bx) };777assert { B.bfin mw ew bx -> B.bval mw ew bz = -. B.bval mw ew bx };778views_eq (of_bits fm bz) (neg (of_bits fm bx))779{qed}780Valid (7.4s) (colibri2 12) (cvc4 2) (cvc5 6) (split_vc 8) (depth 2)781let ghost abs_bits (fm: format) (bx: int) : unit782requires { std fm /\ B.in_range (mw fm) (ew fm) bx }783ensures { of_bits fm (B.b_abs (mw fm) (ew fm) bx) = abs (of_bits fm bx) }784= {proof…}785let bz = B.b_abs (mw fm) (ew fm) bx in786of_bits_views fm bx; of_bits_views fm bz;787bits_k fm bx; bits_k fm bz;788let mw = mw fm in789let ew = ew fm in790assert { B.bfin mw ew bx -> B.bfin mw ew bz /\ B.bmag mw ew bz = B.bmag mw ew bx /\791not B.bneg mw ew bz };792assert { B.bfin mw ew bx -> B.bval mw ew bz = B.bmag mw ew bx };793views_eq (of_bits fm bz) (abs (of_bits fm bx))794{qed}795
The sign of an exact zero sum is the one of IEEE 754 §6.3, in both
Valid (3.1s) (colibri2 11) (cvc4 3) (cvc5 20) (split_vc 8) (depth 3)let ghost add_bits (fm: format) (m: mode) (bx bw: int) : unit798requires { std fm }799requires { B.in_range (mw fm) (ew fm) bx /\ B.in_range (mw fm) (ew fm) bw }800ensures { of_bits fm (B.b_add (mw fm) (ew fm) (bmode m) bx bw) =801fp_add m (of_bits fm bx) (of_bits fm bw) }802= {proof…}803let mw = mw fm in804let ew = ew fm in805let bz = B.b_add mw ew (bmode m) bx bw in806of_bits_views fm bx; of_bits_views fm bw; of_bits_views fm bz;807let x = of_bits fm bx in808let y = of_bits fm bw in809let z = of_bits fm bz in810let f = fp_add m x y in811if pure { is_finite x /\ is_finite y } then begin812let r = pure { to_real x +. to_real y } in813assert { r = B.bval mw ew bx +. B.bval mw ew bw };814assert { f = round_fin fm m (add_zneg m x y) r };815let nx = real_mult x in816let ny = real_mult y in817assert { r = from_int (nx + ny) *. pow2r (qmin fm) };818if pure { r <> 0.0 } then round_nonzero fm m (nx + ny) r;819flocq_zero fm m; rnd_flocq fm m r; pow2r_pos (emax fm);820bmag_pos fm bx; bmag_pos fm bw;821assert { bmode m = B.rtn <-> m = RTN };822assert { add_zneg m x y <-> (if m = RTN then B.bneg mw ew bx \/ B.bneg mw ew bw823else B.bneg mw ew bx /\ B.bneg mw ew bw) };824round_bits fm m (add_zneg m x y) (pure { B.bneg mw ew bz }) r bz825end else views_eq z f826{qed}827
The real of the opposite
Valid (1.8s) (cvc4)let ghost neg_real (x: t) : unit830ensures { to_real (neg x) = -. to_real x }831= ()832
Bminus is the addition of the opposite
Valid (3.3s) (colibri2 28) (cvc4 13) (cvc5 33) (split_vc 22) (depth 4)let ghost sub_bits (fm: format) (m: mode) (bx bw: int) : unit835requires { std fm }836requires { B.in_range (mw fm) (ew fm) bx /\ B.in_range (mw fm) (ew fm) bw }837ensures { of_bits fm (B.b_sub (mw fm) (ew fm) (bmode m) bx bw) =838fp_add m (of_bits fm bx) (neg (of_bits fm bw)) }839= {proof…}840let mw = mw fm in841let ew = ew fm in842let bz = B.b_sub mw ew (bmode m) bx bw in843of_bits_views fm bx; of_bits_views fm bw; of_bits_views fm bz;844let x = of_bits fm bx in845let y = neg (of_bits fm bw) in846let z = of_bits fm bz in847let f = fp_add m x y in848let w = of_bits fm bw in849match w.value with850| NaN -> assert { y = w }851| PlusInf -> assert { y.value = MinusInf }852| MinusInf -> assert { y.value = PlusInf }853| Finite b k -> assert { y.value = Finite (not b) k }854end;855assert { y.fmt = fm };856assert { is_nan y <-> is_nan w };857assert { y.value = PlusInf <-> w.value = MinusInf };858assert { y.value = MinusInf <-> w.value = PlusInf };859assert { is_finite y <-> is_finite w };860if pure { is_finite x /\ is_finite y } then begin861neg_real w;862assert { y.fmt = fm /\ is_finite w /\ to_real y = -. to_real w /\863(is_positive y <-> not is_positive w) };864let r = pure { to_real x +. to_real y } in865assert { r = B.bval mw ew bx -. B.bval mw ew bw };866assert { f = round_fin fm m (add_zneg m x y) r };867let nx = real_mult x in868let ny = real_mult y in869assert { r = from_int (nx + ny) *. pow2r (qmin fm) };870if pure { r <> 0.0 } then round_nonzero fm m (nx + ny) r;871flocq_zero fm m; rnd_flocq fm m r; pow2r_pos (emax fm);872bmag_pos fm bx; bmag_pos fm bw;873assert { bmode m = B.rtn <-> m = RTN };874assert { add_zneg m x y <-> (if m = RTN then B.bneg mw ew bx \/ not B.bneg mw ew bw875else B.bneg mw ew bx /\ not B.bneg mw ew bw) };876round_bits fm m (add_zneg m x y) (pure { B.bneg mw ew bz }) r bz877end else views_eq z f878{qed} Valid (1.9s) (colibri2 11) (cvc4) (cvc5 11) (split_vc 2) (depth 2)879let ghost mul_bits (fm: format) (m: mode) (bx bw: int) : unit880requires { std fm }881requires { B.in_range (mw fm) (ew fm) bx /\ B.in_range (mw fm) (ew fm) bw }882ensures { of_bits fm (B.b_mul (mw fm) (ew fm) (bmode m) bx bw) =883fp_mul m (of_bits fm bx) (of_bits fm bw) }884= {proof…}885let mw = mw fm in886let ew = ew fm in887let bz = B.b_mul mw ew (bmode m) bx bw in888of_bits_views fm bx; of_bits_views fm bw; of_bits_views fm bz;889let x = of_bits fm bx in890let y = of_bits fm bw in891let z = of_bits fm bz in892let f = fp_mul m x y in893bmag_pos fm bx; bmag_pos fm bw;894finite_sign x; finite_sign y;895if pure { is_finite x /\ is_finite y } then begin896let r = pure { to_real x *. to_real y } in897assert { r = B.bval mw ew bx *. B.bval mw ew bw };898assert { f = round_fin fm m (mul_zneg x y) r };899assert { mul_zneg x y <-> not (B.bneg mw ew bx <-> B.bneg mw ew bw) };900flocq_zero fm m; rnd_flocq fm m r; pow2r_pos (emax fm);901if pure { r <> 0.0 } then begin902assert { to_real x <> 0.0 /\ to_real y <> 0.0 };903assert { r <. 0.0 <-> not (B.bneg mw ew bx <-> B.bneg mw ew bw) }904end;905round_bits fm m (mul_zneg x y) (pure { B.bneg mw ew bz }) r bz906end else views_eq z f907{qed}908Valid (9.7s) (colibri2 23) (cvc4 3) (cvc5 25) (split_vc 6) (depth 2)909let ghost div_bits (fm: format) (m: mode) (bx bw: int) : unit910requires { std fm }911requires { B.in_range (mw fm) (ew fm) bx /\ B.in_range (mw fm) (ew fm) bw }912ensures { of_bits fm (B.b_div (mw fm) (ew fm) (bmode m) bx bw) =913fp_div m (of_bits fm bx) (of_bits fm bw) }914= {proof…}915let mw = mw fm in916let ew = ew fm in917let bz = B.b_div mw ew (bmode m) bx bw in918of_bits_views fm bx; of_bits_views fm bw; of_bits_views fm bz;919let x = of_bits fm bx in920let y = of_bits fm bw in921let z = of_bits fm bz in922let f = fp_div m x y in923bmag_pos fm bx; bmag_pos fm bw;924finite_sign x; finite_sign y;925if pure { is_finite x /\ is_finite y /\ not is_zero y } then begin926let r = pure { to_real x /. to_real y } in927assert { to_real y <> 0.0 };928assert { r = B.bval mw ew bx /. B.bval mw ew bw };929assert { r = to_real x *. (1.0 /. to_real y) };930assert { f = round_fin fm m (mul_zneg x y) r };931assert { mul_zneg x y <-> not (B.bneg mw ew bx <-> B.bneg mw ew bw) };932flocq_zero fm m; rnd_flocq fm m r; pow2r_pos (emax fm);933if pure { r <> 0.0 } then begin934assert { to_real x <> 0.0 };935assert { r <. 0.0 <-> not (B.bneg mw ew bx <-> B.bneg mw ew bw) }936end;937round_bits fm m (mul_zneg x y) (pure { B.bneg mw ew bz }) r bz938end else if pure { is_finite x /\ is_infinity y } then begin939round_zero fm m (mul_zneg x y);940assert { f = round_fin fm m (mul_zneg x y) 0.0 };941views_eq z f942end else if pure { is_infinity x /\ is_finite y /\ not is_zero y } then begin943assert { to_real y <. 0.0 -> 1.0 /. to_real y <. 0.0 };944assert { 0.0 <. to_real y -> 0.0 <. 1.0 /. to_real y };945assert { to_real y <. 0.0 <-> B.bneg mw ew bw };946assert { x.value = PlusInf <-> not B.bneg mw ew bx };947assert { B.binf mw ew bz /\ (B.bneg mw ew bz <-> not (B.bneg mw ew bx <-> B.bneg mw ew bw)) };948assert { f = round_f fm m (mul_zneg x y) (ediv (ext x) (ext y)) };949if pure { to_real y <. 0.0 } then950(if pure { x.value = PlusInf } then begin951assert { ext x = PInf /\ ediv (ext x) (ext y) = MInf };952assert { f.value = MinusInf /\ z.value = MinusInf } end953else assert { f.value = PlusInf /\ z.value = PlusInf })954else955(if pure { x.value = PlusInf } then assert { f.value = PlusInf /\ z.value = PlusInf }956else assert { f.value = MinusInf /\ z.value = MinusInf });957views_eq z f958end else views_eq z f959{qed} Valid (2.0s) (colibri2 13) (cvc4 8) (cvc5 33) (split_vc 5) (depth 2)960let ghost fma_bits (fm: format) (m: mode) (bx bw bu: int) : unit961requires { std fm }962requires { B.in_range (mw fm) (ew fm) bx /\ B.in_range (mw fm) (ew fm) bw /\963B.in_range (mw fm) (ew fm) bu }964ensures { of_bits fm (B.b_fma (mw fm) (ew fm) (bmode m) bx bw bu) =965fp_fma m (of_bits fm bx) (of_bits fm bw) (of_bits fm bu) }966= {proof…}967let mw = mw fm in968let ew = ew fm in969let bz = B.b_fma mw ew (bmode m) bx bw bu in970of_bits_views fm bx; of_bits_views fm bw; of_bits_views fm bu; of_bits_views fm bz;971let x = of_bits fm bx in972let y = of_bits fm bw in973let u = of_bits fm bu in974let z = of_bits fm bz in975let f = fp_fma m x y u in976bmag_pos fm bx; bmag_pos fm bw; bmag_pos fm bu;977finite_sign x; finite_sign y; finite_sign u;978if pure { is_finite x /\ is_finite y /\ is_finite u } then begin979let r = pure { to_real x *. to_real y +. to_real u } in980assert { r = B.bval mw ew bx *. B.bval mw ew bw +. B.bval mw ew bu };981assert { ext x = Fin (to_real x) /\ ext y = Fin (to_real y) /\ ext u = Fin (to_real u) };982assert { eadd (emul (ext x) (ext y)) (ext u) = Fin r };983assert { f = round_fin fm m (fma_zneg m x y u (Fin r)) r };984B.fma_spec mw ew (bmode m) bx bw bu;985assert { mul_zneg x y <-> not (B.bneg mw ew bx <-> B.bneg mw ew bw) };986assert { is_positive u <-> not B.bneg mw ew bu };987assert { bmode m = B.rtn <-> m = RTN };988flocq_zero fm m; rnd_flocq fm m r; pow2r_pos (emax fm);989round_bits fm m (fma_zneg m x y u (Fin r)) (pure { B.bneg mw ew bz }) r bz990end else if pure { is_finite x /\ is_finite y /\ is_infinity u } then begin991assert { emul (ext x) (ext y) = Fin (to_real x *. to_real y) };992views_eq z f993end else begin994if pure { (is_infinity x \/ is_infinity y) /\ not is_nan x /\ not is_nan y /\995not is_zero x /\ not is_zero y } then begin996assert { is_finite x -> (to_real x <. 0.0 <-> B.bneg mw ew bx) };997assert { is_finite y -> (to_real y <. 0.0 <-> B.bneg mw ew bw) };998assert { emul (ext x) (ext y) =999if mul_zneg x y then MInf else PInf };1000assert { mul_zneg x y <-> not (B.bneg mw ew bx <-> B.bneg mw ew bw) };1001let e = pure { emul (ext x) (ext y) } in1002B.fma_spec mw ew (bmode m) bx bw bu;1003if pure { not is_nan u } then begin1004assert { opposite e (ext u) <->1005B.binf mw ew bu /\ not (B.bneg mw ew bu <-> mul_zneg x y) };1006if pure { not opposite e (ext u) } then begin1007assert { eadd e (ext u) = e /\ f = round_f fm m false e };1008assert { B.binf mw ew bz /\ (B.bneg mw ew bz <-> mul_zneg x y) };1009if mul_zneg x y then assert { f.value = MinusInf /\ z.value = MinusInf }1010else assert { f.value = PlusInf /\ z.value = PlusInf }1011end1012end1013end;1014views_eq z f1015end1016{qed} Valid (1.9s) (cvc4)1017let ghost sqrt_bits (fm: format) (m: mode) (bx: int) : unit1018requires { std fm /\ B.in_range (mw fm) (ew fm) bx }1019ensures { of_bits fm (B.b_sqrt (mw fm) (ew fm) (bmode m) bx) =1020fp_sqrt m (of_bits fm bx) }1021= {proof…}1022let mw = mw fm in1023let ew = ew fm in1024let bz = B.b_sqrt mw ew (bmode m) bx in1025of_bits_views fm bx; of_bits_views fm bz;1026let x = of_bits fm bx in1027let z = of_bits fm bz in1028let f = fp_sqrt m x in1029bmag_pos fm bx;1030finite_sign x;1031if pure { is_finite x /\ (is_positive x \/ is_zero x) } then begin1032let r = pure { S.sqrt (to_real x) } in1033assert { 0.0 <=. to_real x };1034assert { S.sqrt 0.0 = 0.0 by S.sqrt (0.0 *. 0.0) = 0.0 };1035assert { 0.0 <=. r };1036assert { r = S.sqrt (B.bval mw ew bx) };1037assert { f = round_fin fm m (not is_positive x) r };1038assert { is_positive x <-> not B.bneg mw ew bx };1039flocq_zero fm m; rnd_flocq fm m r;1040fin_small fm bz;1041assert { B.small mw ew (bmode m) r };1042round_bits fm m (not is_positive x) (pure { B.bneg mw ew bz }) r bz1043end else views_eq z f1044{qed}1045Valid (2.6s) (colibri2 15) (cvc4 2) (cvc5 9) (split_vc 3) (depth 3)1046let ghost rti_bits (fm: format) (m: mode) (bx: int) : unit1047requires { std fm /\ B.in_range (mw fm) (ew fm) bx }1048ensures { of_bits fm (B.b_rti (mw fm) (ew fm) (bmode m) bx) =1049fp_rti m (of_bits fm bx) }1050= {proof…}1051let mw = mw fm in1052let ew = ew fm in1053let bz = B.b_rti mw ew (bmode m) bx in1054of_bits_views fm bx; of_bits_views fm bz;1055let x = of_bits fm bx in1056let z = of_bits fm bz in1057let f = fp_rti m x in1058bmag_pos fm bx;1059finite_sign x;1060if pure { is_finite x } then begin1061rnd_int_round m (to_real x);1062let n = round_int m (to_real x) in1063let r = pure { from_int n } in1064assert { r = B.bval mw ew bz };1065assert { f = round_fin fm m (not is_positive x) r };1066assert { is_positive x <-> not B.bneg mw ew bx };1067fin_small fm bz;1068flocq_exact fm m r;1069rnd_flocq fm m r;1070assert { B.small mw ew (bmode m) r };1071if pure { 0.0 <=. to_real x } then round_int_monotonic m 0.0 (to_real x)1072else round_int_monotonic m (to_real x) 0.0;1073assert { round_int m 0.0 = 0 by Truncate.floor 0.0 = 0 };1074round_bits fm m (not is_positive x) (pure { B.bneg mw ew bz }) r bz1075end else views_eq z f1076{qed}1077
Flocq's succ on the values of the magnitudes
Valid (768ms) (cvc4)let ghost succ_pos (fm: format) (k: int) : unit1079requires { 0 <= k }1080ensures { B.succ (sb fm) (qmin fm) (vom fm k) = vom fm (k + 1) }1081= {proof…}1082binade_ge_2 fm;1083vom_generic fm k; vom_generic fm (k + 1); vom_lt fm k (k + 1);1084vom_zero fm; vom_mono fm 0 k;1085let s = B.succ (sb fm) (qmin fm) (vom fm k) in1086assert { F.generic (sb fm) (qmin fm) s /\ vom fm k <. s /\ s <=. vom fm (k + 1) };1087let j = generic_vom fm s in1088if j <= k then vom_mono fm j k;1089vom_mono fm (k + 1) j1090{qed}1091Valid (1.9s) (colibri2 12) (cvc5 3) (split_vc 2) (depth 2)1092let ghost succ_neg (fm: format) (k: int) : unit1093requires { 1 <= k }1094ensures { B.succ (sb fm) (qmin fm) (-. vom fm k) = -. vom fm (k - 1) }1095= {proof…}1096binade_ge_2 fm;1097vom_generic fm k; vom_generic fm (k - 1); vom_lt fm (k - 1) k;1098generic_neg (sb fm) (qmin fm) (vom fm k);1099generic_neg (sb fm) (qmin fm) (vom fm (k - 1));1100vom_zero fm; vom_mono fm 0 (k - 1);1101let s = B.succ (sb fm) (qmin fm) (-. vom fm k) in1102assert { F.generic (sb fm) (qmin fm) s /\ -. vom fm k <. s /\ s <=. -. vom fm (k - 1) };1103if pure { s <. 0.0 } then begin1104generic_neg (sb fm) (qmin fm) s;1105let j = generic_vom fm (-. s) in1106if k <= j then vom_mono fm k j;1107vom_mono fm j (k - 1)1108end else begin1109if 1 < k then vom_lt fm 0 (k - 1)1110end1111{qed}1112
next_up and next_down of fbin.Impl, as functions
function next_up_f (x: t) : t =1115if is_nan x \/ is_plus_infinity x then x else of_index x.fmt (next_up_index (index x))1116function next_down_f (x: t) : t =1117if is_nan x \/ is_minus_infinity x then x else of_index x.fmt (next_down_index (index x))1118Valid (2.3s) (colibri2 25) (cvc4 19) (cvc5 32) (split_vc 13) (depth 2)1119let ghost succ_bits (fm: format) (bx: int) : unit1120requires { std fm /\ B.in_range (mw fm) (ew fm) bx }1121ensures { of_bits fm (B.b_succ (mw fm) (ew fm) bx) = next_up_f (of_bits fm bx) }1122= {proof…}1123let mw = mw fm in1124let ew = ew fm in1125let bz = B.b_succ mw ew bx in1126of_bits_views fm bx; of_bits_views fm bz;1127bits_k fm bz;1128let x = of_bits fm bx in1129let z = of_bits fm bz in1130let f = next_up_f x in1131vom_max fm; maxv_vom fm; vom_zero fm; rnd_flocq fm RNE 0.0;1132pow2_pow2r (emax fm);1133let n1 = pure { nb_sign fm - 1 } in1134match x.value with1135| Finite ng k ->1136let v = to_real x in1137assert { v = B.bval mw ew bx };1138B.succ_b_spec mw ew bx;1139assert { valid x.fmt x.value /\ 0 <= k < n1 };1140if not ng then begin1141succ_pos fm k;1142assert { index x = k };1143of_index_range fm (k + 1);1144assert { f = of_index fm (k + 1) };1145if k + 1 < n1 then begin1146vom_lt fm (k + 1) n1;1147assert { f.value = Finite false (k + 1) };1148assert { B.succ (B.prec mw) (B.emin mw ew) v = vom fm (k + 1) };1149assert { B.bfin mw ew bz /\ B.bval mw ew bz = vom fm (k + 1) }1150end else begin1151assert { f.value = PlusInf };1152assert { B.succ (B.prec mw) (B.emin mw ew) v = pow2r (emax fm) };1153assert { B.binf mw ew bz /\ not B.bneg mw ew bz }1154end;1155views_eq z f1156end else if k = 0 then begin1157succ_pos fm 0;1158assert { v = vom fm 0 /\ index x = -1 };1159assert { next_up_index (index x) = 1 /\ f = of_index fm 1 };1160vom_lt fm 1 n1;1161of_index_range fm 1;1162assert { f.value = Finite false 1 };1163assert { B.succ (B.prec mw) (B.emin mw ew) v = vom fm 1 };1164assert { B.bfin mw ew bz /\ B.bval mw ew bz = vom fm 1 };1165views_eq z f1166end else begin1167succ_neg fm k;1168assert { index x = -1 - k /\ next_up_index (index x) = -k };1169assert { k < n1 /\ f = of_index fm (-k) };1170assert { - nb_sign fm < -k < 0 };1171of_index_range fm (-k);1172assert { f.value = Finite true (-1 - (-k)) };1173assert { B.succ (B.prec mw) (B.emin mw ew) v = -. vom fm (k - 1) };1174vom_mono fm 0 (k - 1); pow2r_pos (emax fm);1175assert { B.bfin mw ew bz /\ B.bval mw ew bz = -. vom fm (k - 1) };1176views_eq z f1177end1178| MinusInf ->1179assert { index x = - nb_sign fm /\ f = of_index fm (1 - nb_sign fm) };1180of_index_range fm (1 - nb_sign fm);1181assert { f.value = Finite true (-1 - (1 - nb_sign fm)) };1182views_eq z f1183| _ -> views_eq z f1184end1185{qed}1186Valid (2.2s) (colibri2 35) (cvc4 11) (cvc5 39) (split_vc 13) (depth 2)1187let ghost pred_bits (fm: format) (bx: int) : unit1188requires { std fm /\ B.in_range (mw fm) (ew fm) bx }1189ensures { of_bits fm (B.b_pred (mw fm) (ew fm) bx) = next_down_f (of_bits fm bx) }1190= {proof…}1191let mw = mw fm in1192let ew = ew fm in1193let bz = B.b_pred mw ew bx in1194of_bits_views fm bx; of_bits_views fm bz;1195bits_k fm bz;1196let x = of_bits fm bx in1197let z = of_bits fm bz in1198let f = next_down_f x in1199vom_max fm; maxv_vom fm; vom_zero fm;1200pow2_pow2r (emax fm);1201let n1 = pure { nb_sign fm - 1 } in1202match x.value with1203| Finite ng k ->1204let v = to_real x in1205assert { v = B.bval mw ew bx };1206B.pred_b_spec mw ew bx;1207assert { valid x.fmt x.value /\ 0 <= k < n1 };1208if ng then begin1209succ_pos fm k;1210assert { -. v = vom fm k /\ index x = -1 - k };1211assert { next_down_index (index x) = -2 - k };1212assert { f = of_index fm (-2 - k) };1213if k + 1 < n1 then begin1214vom_lt fm (k + 1) n1;1215assert { - nb_sign fm < -2 - k < 0 };1216of_index_range fm (-2 - k);1217assert { f.value = Finite true (-1 - (-2 - k)) };1218assert { -. B.succ (B.prec mw) (B.emin mw ew) (-. v) = -. vom fm (k + 1) };1219vom_mono fm 0 (k + 1);1220assert { -. F.pow2 (B.emax ew) <. -. vom fm (k + 1) };1221assert { B.bfin mw ew bz /\ B.bval mw ew bz = -. vom fm (k + 1) }1222end else begin1223assert { -2 - k = - nb_sign fm };1224of_index_range fm (-2 - k);1225assert { f.value = MinusInf };1226assert { -. B.succ (B.prec mw) (B.emin mw ew) (-. v) = -. pow2r (emax fm) };1227assert { B.binf mw ew bz /\ B.bneg mw ew bz }1228end;1229views_eq z f1230end else if k = 0 then begin1231succ_pos fm 0;1232assert { -. v = vom fm 0 /\ index x = 0 };1233assert { f = of_index fm (-2) };1234assert { - nb_sign fm < -2 < 0 };1235of_index_range fm (-2);1236assert { f.value = Finite true 1 };1237assert { -. B.succ (B.prec mw) (B.emin mw ew) (-. v) = -. vom fm 1 };1238vom_lt fm 1 n1;1239assert { -. F.pow2 (B.emax ew) <. -. vom fm 1 };1240assert { B.bfin mw ew bz /\ B.bval mw ew bz = -. vom fm 1 };1241views_eq z f1242end else begin1243succ_neg fm k;1244assert { index x = k /\ next_down_index (index x) = k - 1 };1245assert { k < n1 /\ f = of_index fm (k - 1) };1246of_index_range fm (k - 1);1247assert { f.value = Finite false (k - 1) };1248assert { -. B.succ (B.prec mw) (B.emin mw ew) (-. v) = vom fm (k - 1) };1249vom_mono fm 0 (k - 1); pow2r_pos (emax fm);1250assert { -. F.pow2 (B.emax ew) <. vom fm (k - 1) };1251assert { B.bfin mw ew bz /\ B.bval mw ew bz = vom fm (k - 1) };1252views_eq z f1253end1254| PlusInf ->1255assert { index x = n1 /\ f = of_index fm (n1 - 1) };1256of_index_range fm (n1 - 1);1257assert { f.value = Finite false (n1 - 1) };1258B.pred_b_spec mw ew bx;1259assert { B.bfin mw ew bz /\ not B.bneg mw ew bz /\ B.bval mw ew bz = vom fm (n1 - 1) };1260views_eq z f1261| _ -> views_eq z f1262end1263{qed}1264
The comparisons of IEEE 754 are the order of the extended reals
Valid (188ms) (colibri2)let ghost ieee_ext (x y: t) : unit1268requires { x.fmt = y.fmt /\ not is_nan x /\ not is_nan y }1269ensures { ieee_lt x y <-> not ele (ext y) (ext x) }1270ensures { ieee_le x y <-> ele (ext x) (ext y) }1271ensures { ieee_eq x y <-> ext x = ext y }1272= {proof…}1273ext_zero x; ext_zero y;1274if index x < index y then begin1275ext_le x y;1276if not (pure { is_zero x /\ is_zero y }) then ext_lt x y1277end else if index y < index x then begin1278ext_le y x;1279if not (pure { is_zero x /\ is_zero y }) then ext_lt y x1280end else begin1281index_inj x; index_inj y;1282assert { x = y }1283end1284{qed}1285
The extended real of an encoding
Valid (606ms) (cvc5)let ghost ext_bits (fm: format) (b: int) : unit1288requires { B.in_range (mw fm) (ew fm) b }1289ensures { let x = of_bits fm b in1290(B.bfin (mw fm) (ew fm) b -> ext x = Fin (B.bval (mw fm) (ew fm) b)) /\1291(B.binf (mw fm) (ew fm) b /\ B.bneg (mw fm) (ew fm) b -> ext x = MInf) /\1292(B.binf (mw fm) (ew fm) b /\ not B.bneg (mw fm) (ew fm) b -> ext x = PInf) }1293= of_bits_views fm b1294Valid (1.5s) (cvc5)1295let ghost lt_bits (fm: format) (bx bw: int) : unit1296requires { std fm }1297requires { B.in_range (mw fm) (ew fm) bx /\ B.in_range (mw fm) (ew fm) bw }1298ensures { B.b_lt (mw fm) (ew fm) bx bw <-> ieee_lt (of_bits fm bx) (of_bits fm bw) }1299= {proof…}1300of_bits_views fm bx; of_bits_views fm bw; ext_bits fm bx; ext_bits fm bw;1301if pure { not is_nan (of_bits fm bx) /\ not is_nan (of_bits fm bw) } then1302ieee_ext (of_bits fm bx) (of_bits fm bw)1303{qed}1304Valid (2.0s) (colibri2)1305let ghost le_bits (fm: format) (bx bw: int) : unit1306requires { std fm }1307requires { B.in_range (mw fm) (ew fm) bx /\ B.in_range (mw fm) (ew fm) bw }1308ensures { B.b_le (mw fm) (ew fm) bx bw <-> ieee_le (of_bits fm bx) (of_bits fm bw) }1309= {proof…}1310of_bits_views fm bx; of_bits_views fm bw; ext_bits fm bx; ext_bits fm bw;1311if pure { not is_nan (of_bits fm bx) /\ not is_nan (of_bits fm bw) } then1312ieee_ext (of_bits fm bx) (of_bits fm bw)1313{qed}1314Valid (773ms) (cvc5)1315let ghost eq_bits (fm: format) (bx bw: int) : unit1316requires { std fm }1317requires { B.in_range (mw fm) (ew fm) bx /\ B.in_range (mw fm) (ew fm) bw }1318ensures { B.b_eq (mw fm) (ew fm) bx bw <-> ieee_eq (of_bits fm bx) (of_bits fm bw) }1319= {proof…}1320of_bits_views fm bx; of_bits_views fm bw; ext_bits fm bx; ext_bits fm bw;1321if pure { not is_nan (of_bits fm bx) /\ not is_nan (of_bits fm bw) } then1322ieee_ext (of_bits fm bx) (of_bits fm bw)1323{qed}1324end1325