Common — library colibrilib.fbin_ieee — module Bits

The operations of fbin.mlw are the ones of Flocq

For 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.

386
module Bits
387
use int.Int
388
use int.Power
389
use int.EuclideanDivision
390
use real.RealInfix
391
use real.FromInt
392
use real.Abs
393
use colibrilib.fp.Widen
394
use real.Truncate
395
use real.Square as S
396
use colibrilib.fp.Ereal
397
use colibrilib.fbin.Pow2r
398
use colibrilib.fbin.Format
399
use colibrilib.fbin.Float
400
use colibrilib.fbin.Round
401
use colibrilib.fbin.Impl
402
use colibrilib.flocq.Round as F
403
use colibrilib.flocq.Binary as B
404
use Equiv

The format of Bits: mw bits of significand, ew of exponent

407
function
mw
(fm: format) : int = sb fm - 1
408
function
ew
(fm: format) : int = eb fm
409
410
predicate
std
(fm: format) = B.valid (mw fm) (ew fm)
411
412
function
bmode
(m: mode) : B.mode =
413
match m with
414
| RNE -> B.rne | RNA -> B.rna | RTP -> B.rtp | RTN -> B.rtn | RTZ -> B.rtz
415
end

The magnitude of the encoding b

418
function
kof
(fm: format) (b: int) : int =
419
if half_bits fm <= b then b - half_bits fm else b
420
Valid (410ms) (colibri2 27) (split_vc 7) (depth 2)
421
let ghost
bits_k
(fm: format) (b: int) : unit
422
requires { 0 <= b < 2 * half_bits fm }
423
ensures { half_bits fm = power 2 (mw fm) * power 2 (ew fm) }
424
ensures { B.in_range (mw fm) (ew fm) b }
425
ensures { 0 <= kof fm b < half_bits fm }
426
ensures { B.bneg (mw fm) (ew fm) b <-> half_bits fm <= b }
427
ensures { B.bman (mw fm) b = mod (kof fm b) (binade fm) }
428
ensures { B.bexp (mw fm) (ew fm) b = div (kof fm b) (binade fm) }
429
ensures { nb_sign fm - 1 = (power 2 (ew fm) - 1) * binade fm }
430
ensures { B.emin (mw fm) (ew fm) = qmin fm /\ B.prec (mw fm) = sb fm }
431
ensures { B.emax (ew fm) = emax fm }
432
ensures { B.bmag (mw fm) (ew fm) b = vom fm (kof fm b) }
433
= {proof…}
434
let p = power 2 (mw fm) in
435
let q = power 2 (ew fm) in
436
let h = half_bits fm in
437
let k = kof fm b in
438
assert { h = p * q by power 2 (mw fm + ew fm) = p * q };
439
assert { power 2 (mw fm + ew fm + 1) = 2 * h };
440
assert { 0 < p /\ 0 < q };
441
assert { 0 <= k < h };
442
assert { b = k \/ b = k + q * p };
443
assert { mod (p * q + k) p = mod k p /\ div (p * q + k) p = q + div k p };
444
assert { mod b p = mod k p by b = k \/ b = p * q + k };
445
assert { 0 <= div k p };
446
if pure { div k p >= q } then assert { p * div k p >= p * q };
447
assert { div k p < q };
448
assert { div b p = div k p \/ div b p = div k p + q by b = k \/ b = p * q + k };
449
assert { mod (div b p) q = div k p
450
by mod (div k p) q = div k p /\
451
mod (q * 1 + div k p) q = mod (div k p) q };
452
pow2_pow2r (qmin fm);
453
pow2_pow2r (pure { div k p + qmin fm - 1 })
454
{qed}

The views of the encoding are the ones of its float

  Valid (4.3s) (colibri2 13) (cvc5 28) (split_vc 17) (depth 4)
456
let ghost
of_bits_views
(fm: format) (b: int) : unit
457
requires { B.in_range (mw fm) (ew fm) b }
458
ensures { let x = of_bits fm b in
459
x.fmt = fm /\
460
(B.bnan (mw fm) (ew fm) b <-> x.value = NaN) /\
461
(B.binf (mw fm) (ew fm) b /\ not B.bneg (mw fm) (ew fm) b <-> x.value = PlusInf) /\
462
(B.binf (mw fm) (ew fm) b /\ B.bneg (mw fm) (ew fm) b <-> x.value = MinusInf) /\
463
(B.bfin (mw fm) (ew fm) b <-> is_finite x) /\
464
(B.bzero (mw fm) (ew fm) b <-> is_zero x) /\
465
(B.bfin (mw fm) (ew fm) b ->
466
to_real x = B.bval (mw fm) (ew fm) b /\
467
(B.bneg (mw fm) (ew fm) b <-> not is_positive x)) }
468
= {proof…}
469
let h = half_bits fm in
470
assert { power 2 (mw fm + ew fm + 1) = 2 * h
471
by power 2 (mw fm + ew fm + 1) = 2 * power 2 (mw fm + ew fm) };
472
bits_k fm b;
473
assert { mod b (2 * h) = b };
474
let k = kof fm b in
475
let p = binade fm in
476
let q = power 2 (ew fm) in
477
let d = pure { div k p } in
478
let r = pure { mod k p } in
479
assert { k = p * d + r /\ 0 <= r < p /\ 0 <= d < q };
480
let n1 = pure { nb_sign fm - 1 } in
481
assert { n1 = p * (q - 1) };
482
if d < q - 1 then assert { k < n1 by k < p * d + p = p * (d + 1) <= p * (q - 1) }
483
else begin
484
assert { d = q - 1 };
485
if r = 0 then assert { k = n1 } else assert { k > n1 }
486
end;
487
assert { d = 0 /\ r = 0 <-> k = 0 }
488
{qed}

Two floats of a format with the same views are equal

  Valid (782ms) (cvc5)
490
let ghost
views_eq
(x y: t) : unit
491
requires { x.fmt = y.fmt }
492
requires { x.value = NaN <-> y.value = NaN }
493
requires { x.value = PlusInf <-> y.value = PlusInf }
494
requires { x.value = MinusInf <-> y.value = MinusInf }
495
requires { is_finite x -> is_finite y }
496
requires { is_finite x ->
497
to_real x = to_real y /\ (is_positive x <-> is_positive y) }
498
ensures { x = y }
499
= {proof…}
500
match x.value, y.value with
501
| Finite nx kx, Finite ny ky ->
502
assert { nx = ny };
503
assert { vom x.fmt kx = vom x.fmt ky };
504
if kx < ky then vom_lt x.fmt kx ky
505
else if ky < kx then vom_lt x.fmt ky kx;
506
t_ext x y
507
| _ -> t_ext x y
508
end
509
{qed}

The largest finite magnitude

  Valid (73ms) (colibri2 10) (split_vc) (depth 1)
512
let ghost
maxv_vom
(fm: format) : unit
513
ensures { B.maxv (mw fm) (ew fm) = vom fm (nb_sign fm - 2) }
514
= {proof…}
515
let p = binade fm in
516
binade_2 fm; binade_ge_2 fm;
517
let u = pure { emax fm - sb fm } in
518
assert { power 2 (eb fm) = 2 * power 2 (eb fm - 1)
519
by power 2 (eb fm) = power 2 ((eb fm - 1) + 1) };
520
assert { 2 <= power 2 (eb fm - 1)
521
by power 2 (eb fm - 1) = 2 * power 2 (eb fm - 2)
522
by power 2 (eb fm - 1) = power 2 ((eb fm - 2) + 1) };
523
assert { u - qmin fm = power 2 (eb fm) - 3 };
524
assert { qmin fm < u };
525
vom_s fm u (2 * p - 1);
526
assert { (u - qmin fm) * p = (power 2 (eb fm) - 3) * p };
527
assert { (power 2 (eb fm) - 3) * p + 2 * p = (power 2 (eb fm) - 1) * p };
528
assert { (u - qmin fm) * p + (2 * p - 1) = nb_sign fm - 2 };
529
pow2_pow2r u
530
{qed}

The rounding of Flocq in the mode bmode m

  Valid (3.2s) (colibri2 3) (split_vc) (depth 1)
533
let ghost
rnd_flocq
(fm: format) (m: mode) (r: real) : unit
534
ensures { B.rnd (B.prec (mw fm)) (B.emin (mw fm) (ew fm)) (bmode m) r = flocq fm m r }
535
ensures { F.pow2 (B.emax (ew fm)) = pow2r (emax fm) }
536
= {proof…}
537
bits_k fm 0; pow2_pow2r (emax fm)
538
{qed}

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)
543
let ghost
round_bits
(fm: format) (m: mode) (zn sgn: bool) (r: real) (bz: int)
544
requires { std fm /\ B.in_range (mw fm) (ew fm) bz }
545
requires { B.small (mw fm) (ew fm) (bmode m) r ->
546
B.rounded (mw fm) (ew fm) (bmode m) r bz /\
547
(B.bneg (mw fm) (ew fm) bz <-> sgn) }
548
requires { not B.small (mw fm) (ew fm) (bmode m) r ->
549
B.ovf (mw fm) (ew fm) (bmode m) bz /\
550
(B.bneg (mw fm) (ew fm) bz <-> r <. 0.0) }
551
requires { flocq fm m r = 0.0 -> (sgn <-> zn) }
552
requires { flocq fm m r <> 0.0 -> (sgn <-> r <. 0.0) }
553
ensures { of_bits fm bz = round_fin fm m zn r }
554
= {proof…}
555
let mw = mw fm in
556
let ew = ew fm in
557
of_bits_views fm bz;
558
rnd_flocq fm m r;
559
round_fin_flocq fm m zn r;
560
vom_zero fm;
561
maxv_vom fm;
562
let x = of_bits fm bz in
563
let y = round_fin fm m zn r in
564
if pure { B.small mw ew (bmode m) r } then begin
565
assert { is_finite y /\ to_real y = flocq fm m r };
566
assert { is_finite x /\ to_real x = flocq fm m r };
567
match y.value with
568
| Finite ny ky ->
569
if ky = 0 then assert { ny = zn }
570
else begin
571
vom_lt fm 0 ky;
572
assert { flocq fm m r <> 0.0 };
573
if pure { 0.0 <=. r } then begin
574
let k = pure { round_mag fm m r } in
575
assert { k <> 0 /\ y = of_mag fm m false k };
576
assert { not ny }
577
end else begin
578
let k = pure { round_mag fm (mirror m) (-. r) } in
579
assert { k <> 0 /\ y = of_mag fm (mirror m) true k };
580
assert { ny }
581
end
582
end
583
| _ -> absurd
584
end;
585
views_eq x y
586
end else begin
587
assert { y.value = overflow fm m (r <. 0.0) };
588
match m with
589
| RTZ ->
590
assert { B.bfin mw ew bz /\ B.bmag mw ew bz = B.maxv mw ew };
591
match x.value with
592
| Finite _ k ->
593
bits_k fm bz;
594
assert { vom fm k = vom fm (nb_sign fm - 2) };
595
if k < nb_sign fm - 2 then vom_lt fm k (nb_sign fm - 2)
596
else if nb_sign fm - 2 < k then vom_lt fm (nb_sign fm - 2) k
597
| _ -> absurd
598
end
599
| RTN ->
600
if pure { r <. 0.0 } then () else begin
601
assert { B.bfin mw ew bz /\ B.bmag mw ew bz = B.maxv mw ew };
602
match x.value with
603
| Finite _ k ->
604
bits_k fm bz;
605
assert { vom fm k = vom fm (nb_sign fm - 2) };
606
if k < nb_sign fm - 2 then vom_lt fm k (nb_sign fm - 2)
607
else if nb_sign fm - 2 < k then vom_lt fm (nb_sign fm - 2) k
608
| _ -> absurd
609
end
610
end
611
| RTP ->
612
if pure { r <. 0.0 } then begin
613
assert { B.bfin mw ew bz /\ B.bmag mw ew bz = B.maxv mw ew };
614
match x.value with
615
| Finite _ k ->
616
bits_k fm bz;
617
assert { vom fm k = vom fm (nb_sign fm - 2) };
618
if k < nb_sign fm - 2 then vom_lt fm k (nb_sign fm - 2)
619
else if nb_sign fm - 2 < k then vom_lt fm (nb_sign fm - 2) k
620
| _ -> absurd
621
end
622
end
623
| _ -> ()
624
end;
625
t_ext x y
626
end
627
{qed}

The finite values are multiples of 2^qmin

  Valid (390ms) (colibri2 5) (cvc5) (split_vc 3) (depth 3)
629
let ghost
real_mult
(x: t) : int
630
requires { is_finite x }
631
ensures { to_real x = from_int result *. pow2r (qmin x.fmt) }
632
= {proof…}
633
match x.value with
634
| Finite ng k ->
635
let fm = x.fmt in
636
vom_dec fm k;
637
let e = pure { uexp fm k - qmin fm } in
638
pow2r_add (qmin fm) e; pow2r_int e;
639
let n = pure { sig fm k * power 2 e } in
640
assert { vom fm k = from_int n *. pow2r (qmin fm) };
641
if ng then - n else n
642
| _ -> absurd
643
end
644
{qed}

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)
647
let ghost
round_nonzero
(fm: format) (m: mode) (n: int) (r: real) : unit
648
requires { n <> 0 /\ r = from_int n *. pow2r (qmin fm) }
649
ensures { flocq fm m r <> 0.0 }
650
= {proof…}
651
binade_ge_2 fm;
652
vom_s fm (qmin fm) 1;
653
assert { vom fm 1 = pow2r (qmin fm) };
654
pow2r_pos (qmin fm);
655
vom_zero fm;
656
round_fin_flocq fm m false r;
657
let y = pure { round_fin fm m false r } in
658
if pure { Abs.abs (flocq fm m r) <. pow2r (emax fm) } then begin
659
if pure { 0.0 <=. r } then begin
660
assert { 1 <= n };
661
assert { vom fm 1 <=. r };
662
round_mag_mono fm m (vom fm 1) r; round_mag_exact fm m 1;
663
let k = pure { round_mag fm m r } in
664
assert { 1 <= k /\ y = of_mag fm m false k };
665
assert { y = of_mag fm m false k }
666
end else begin
667
assert { n <= -1 };
668
assert { -. r = from_int (- n) *. pow2r (qmin fm) };
669
assert { vom fm 1 <=. -. r };
670
round_mag_mono fm (mirror m) (vom fm 1) (-. r); round_mag_exact fm (mirror m) 1;
671
let k = pure { round_mag fm (mirror m) (-. r) } in
672
assert { 1 <= k /\ y = of_mag fm (mirror m) true k }
673
end;
674
vom_max fm;
675
match y.value with
676
| Finite _ k' -> assert { 1 <= k' }; vom_lt fm 0 k'
677
| _ -> ()
678
end
679
end else pow2r_pos (emax fm)
680
{qed}
Valid (1.9s) (colibri2 3) (cvc5 5) (split_vc 2) (depth 2)
681
let ghost
flocq_zero
(fm: format) (m: mode) : unit
682
ensures { flocq fm m 0.0 = 0.0 }
683
= {proof…}
684
vom_zero fm; vom_generic fm 0;
685
assert { F.generic (sb fm) (qmin fm) 0.0 };
686
binade_ge_2 fm;
687
assert { 1 < sb fm };
688
match m with
689
| RNE -> assert { F.nearest (sb fm) (qmin fm) 0.0 (flocq fm m 0.0) }
690
| RNA -> assert { F.nearest (sb fm) (qmin fm) 0.0 (flocq fm m 0.0) }
691
| _ -> ()
692
end
693
{qed}
694
Valid (88ms) (colibri2)
695
let ghost
bmag_pos
(fm: format) (b: int) : unit
696
requires { B.in_range (mw fm) (ew fm) b }
697
ensures { 0.0 <=. B.bmag (mw fm) (ew fm) b }
698
ensures { B.bneg (mw fm) (ew fm) b -> B.bval (mw fm) (ew fm) b <=. 0.0 }
699
ensures { not B.bneg (mw fm) (ew fm) b -> 0.0 <=. B.bval (mw fm) (ew fm) b }
700
= {proof…}
701
assert { power 2 (mw fm + ew fm + 1) = 2 * half_bits fm
702
by power 2 (mw fm + ew fm + 1) = 2 * power 2 (mw fm + ew fm) };
703
bits_k fm b; vom_zero fm; vom_mono fm 0 (kof fm b)
704
{qed}

A finite encoding is a float below 2^emax

  Valid (809ms) (colibri2 5) (cvc5 3) (split_vc) (depth 1)
707
let ghost
fin_small
(fm: format) (b: int) : unit
708
requires { B.in_range (mw fm) (ew fm) b /\ B.bfin (mw fm) (ew fm) b }
709
ensures { Abs.abs (B.bval (mw fm) (ew fm) b) <. pow2r (emax fm) }
710
ensures { F.generic (sb fm) (qmin fm) (B.bval (mw fm) (ew fm) b) }
711
= {proof…}
712
of_bits_views fm b;
713
vom_max fm;
714
match (of_bits fm b).value with
715
| Finite ng k ->
716
vom_lt fm k (nb_sign fm - 1); vom_generic fm k; vom_zero fm; vom_mono fm 0 k;
717
if ng then generic_neg (sb fm) (qmin fm) (vom fm k)
718
| _ -> absurd
719
end
720
{qed}

The rounding to an integer of Flocq is round_int

  Valid (726ms) (colibri2 16) (cvc4 3) (cvc5 6) (split_vc) (depth 1)
723
let ghost
rnd_int_round
(m: mode) (r: real) : unit
724
ensures { B.rnd_int (bmode m) r = round_int m r }
725
= {proof…}
726
let f = Truncate.floor r in
727
let d = pure { r -. from_int f } in
728
assert { 0.0 <=. d <. 1.0 };
729
let n = B.rnd_int (bmode m) r in
730
match m with
731
| RTN -> assert { n <= f /\ f <= n }
732
| RTP -> if pure { d = 0.0 } then assert { n = f } else assert { n = f + 1 }
733
| RTZ ->
734
let nn = B.rnd_int B.rtn r in
735
let np = B.rnd_int B.rtp r in
736
assert { nn = f };
737
if pure { d = 0.0 } then assert { np = f } else assert { np = f + 1 }
738
| RNE ->
739
assert { f <= n <= f + 1 };
740
if pure { d <. 0.5 } then assert { n = f }
741
else if pure { 0.5 <. d } then assert { n = f + 1 }
742
else begin
743
assert { Abs.abs (r -. from_int n) = 0.5 };
744
let q = any int ensures { n = 2 * result } in
745
if mod f 2 = 0 then begin
746
assert { f = 2 * div f 2 };
747
if n = f + 1 then assert { 2 * q = 2 * div f 2 + 1 }
748
end else begin
749
assert { f = 2 * div f 2 + 1 };
750
if n = f then assert { 2 * q = 2 * div f 2 + 1 }
751
end
752
end
753
| RNA ->
754
assert { f <= n <= f + 1 };
755
if pure { d <. 0.5 } then assert { n = f }
756
else if pure { 0.5 <. d } then assert { n = f + 1 }
757
else begin
758
assert { Abs.abs (r -. from_int n) = 0.5 };
759
assert { Abs.abs r <. Abs.abs (from_int n) };
760
if pure { 0.0 <=. r } then assert { n = f + 1 } else assert { n = f }
761
end
762
end
763
{qed}

The operations

  Valid (2.2s) (colibri2 9) (cvc4 3) (cvc5 9) (split_vc 8) (depth 2)
767
let ghost
neg_bits
(fm: format) (bx: int) : unit
768
requires { std fm /\ B.in_range (mw fm) (ew fm) bx }
769
ensures { of_bits fm (B.b_neg (mw fm) (ew fm) bx) = neg (of_bits fm bx) }
770
= {proof…}
771
let bz = B.b_neg (mw fm) (ew fm) bx in
772
of_bits_views fm bx; of_bits_views fm bz;
773
bits_k fm bx; bits_k fm bz;
774
let mw = mw fm in
775
let ew = ew fm in
776
assert { B.bfin mw ew bx -> B.bfin mw ew bz /\ B.bmag mw ew bz = B.bmag mw ew bx /\
777
(B.bneg mw ew bz <-> not B.bneg mw ew bx) };
778
assert { B.bfin mw ew bx -> B.bval mw ew bz = -. B.bval mw ew bx };
779
views_eq (of_bits fm bz) (neg (of_bits fm bx))
780
{qed}
781
Valid (7.4s) (colibri2 12) (cvc4 2) (cvc5 6) (split_vc 8) (depth 2)
782
let ghost
abs_bits
(fm: format) (bx: int) : unit
783
requires { std fm /\ B.in_range (mw fm) (ew fm) bx }
784
ensures { of_bits fm (B.b_abs (mw fm) (ew fm) bx) = abs (of_bits fm bx) }
785
= {proof…}
786
let bz = B.b_abs (mw fm) (ew fm) bx in
787
of_bits_views fm bx; of_bits_views fm bz;
788
bits_k fm bx; bits_k fm bz;
789
let mw = mw fm in
790
let ew = ew fm in
791
assert { B.bfin mw ew bx -> B.bfin mw ew bz /\ B.bmag mw ew bz = B.bmag mw ew bx /\
792
not B.bneg mw ew bz };
793
assert { B.bfin mw ew bx -> B.bval mw ew bz = B.bmag mw ew bx };
794
views_eq (of_bits fm bz) (abs (of_bits fm bx))
795
{qed}

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)
798
let ghost
add_bits
(fm: format) (m: mode) (bx bw: int) : unit
799
requires { std fm }
800
requires { B.in_range (mw fm) (ew fm) bx /\ B.in_range (mw fm) (ew fm) bw }
801
ensures { of_bits fm (B.b_add (mw fm) (ew fm) (bmode m) bx bw) =
802
fp_add m (of_bits fm bx) (of_bits fm bw) }
803
= {proof…}
804
let mw = mw fm in
805
let ew = ew fm in
806
let bz = B.b_add mw ew (bmode m) bx bw in
807
of_bits_views fm bx; of_bits_views fm bw; of_bits_views fm bz;
808
let x = of_bits fm bx in
809
let y = of_bits fm bw in
810
let z = of_bits fm bz in
811
let f = fp_add m x y in
812
if pure { is_finite x /\ is_finite y } then begin
813
let r = pure { to_real x +. to_real y } in
814
assert { r = B.bval mw ew bx +. B.bval mw ew bw };
815
assert { f = round_fin fm m (add_zneg m x y) r };
816
let nx = real_mult x in
817
let ny = real_mult y in
818
assert { r = from_int (nx + ny) *. pow2r (qmin fm) };
819
if pure { r <> 0.0 } then round_nonzero fm m (nx + ny) r;
820
flocq_zero fm m; rnd_flocq fm m r; pow2r_pos (emax fm);
821
bmag_pos fm bx; bmag_pos fm bw;
822
assert { bmode m = B.rtn <-> m = RTN };
823
assert { add_zneg m x y <-> (if m = RTN then B.bneg mw ew bx \/ B.bneg mw ew bw
824
else B.bneg mw ew bx /\ B.bneg mw ew bw) };
825
round_bits fm m (add_zneg m x y) (pure { B.bneg mw ew bz }) r bz
826
end else views_eq z f
827
{qed}

The real of the opposite

  Valid (1.8s) (cvc4)
830
let ghost
neg_real
(x: t) : unit
831
ensures { to_real (neg x) = -. to_real x }
832
= ()

Bminus is the addition of the opposite

  Valid (3.3s) (colibri2 28) (cvc4 13) (cvc5 33) (split_vc 22) (depth 4)
835
let ghost
sub_bits
(fm: format) (m: mode) (bx bw: int) : unit
836
requires { std fm }
837
requires { B.in_range (mw fm) (ew fm) bx /\ B.in_range (mw fm) (ew fm) bw }
838
ensures { of_bits fm (B.b_sub (mw fm) (ew fm) (bmode m) bx bw) =
839
fp_add m (of_bits fm bx) (neg (of_bits fm bw)) }
840
= {proof…}
841
let mw = mw fm in
842
let ew = ew fm in
843
let bz = B.b_sub mw ew (bmode m) bx bw in
844
of_bits_views fm bx; of_bits_views fm bw; of_bits_views fm bz;
845
let x = of_bits fm bx in
846
let y = neg (of_bits fm bw) in
847
let z = of_bits fm bz in
848
let f = fp_add m x y in
849
let w = of_bits fm bw in
850
match w.value with
851
| NaN -> assert { y = w }
852
| PlusInf -> assert { y.value = MinusInf }
853
| MinusInf -> assert { y.value = PlusInf }
854
| Finite b k -> assert { y.value = Finite (not b) k }
855
end;
856
assert { y.fmt = fm };
857
assert { is_nan y <-> is_nan w };
858
assert { y.value = PlusInf <-> w.value = MinusInf };
859
assert { y.value = MinusInf <-> w.value = PlusInf };
860
assert { is_finite y <-> is_finite w };
861
if pure { is_finite x /\ is_finite y } then begin
862
neg_real w;
863
assert { y.fmt = fm /\ is_finite w /\ to_real y = -. to_real w /\
864
(is_positive y <-> not is_positive w) };
865
let r = pure { to_real x +. to_real y } in
866
assert { r = B.bval mw ew bx -. B.bval mw ew bw };
867
assert { f = round_fin fm m (add_zneg m x y) r };
868
let nx = real_mult x in
869
let ny = real_mult y in
870
assert { r = from_int (nx + ny) *. pow2r (qmin fm) };
871
if pure { r <> 0.0 } then round_nonzero fm m (nx + ny) r;
872
flocq_zero fm m; rnd_flocq fm m r; pow2r_pos (emax fm);
873
bmag_pos fm bx; bmag_pos fm bw;
874
assert { bmode m = B.rtn <-> m = RTN };
875
assert { add_zneg m x y <-> (if m = RTN then B.bneg mw ew bx \/ not B.bneg mw ew bw
876
else B.bneg mw ew bx /\ not B.bneg mw ew bw) };
877
round_bits fm m (add_zneg m x y) (pure { B.bneg mw ew bz }) r bz
878
end else views_eq z f
879
{qed}
Valid (1.9s) (colibri2 11) (cvc4) (cvc5 11) (split_vc 2) (depth 2)
880
let ghost
mul_bits
(fm: format) (m: mode) (bx bw: int) : unit
881
requires { std fm }
882
requires { B.in_range (mw fm) (ew fm) bx /\ B.in_range (mw fm) (ew fm) bw }
883
ensures { of_bits fm (B.b_mul (mw fm) (ew fm) (bmode m) bx bw) =
884
fp_mul m (of_bits fm bx) (of_bits fm bw) }
885
= {proof…}
886
let mw = mw fm in
887
let ew = ew fm in
888
let bz = B.b_mul mw ew (bmode m) bx bw in
889
of_bits_views fm bx; of_bits_views fm bw; of_bits_views fm bz;
890
let x = of_bits fm bx in
891
let y = of_bits fm bw in
892
let z = of_bits fm bz in
893
let f = fp_mul m x y in
894
bmag_pos fm bx; bmag_pos fm bw;
895
finite_sign x; finite_sign y;
896
if pure { is_finite x /\ is_finite y } then begin
897
let r = pure { to_real x *. to_real y } in
898
assert { r = B.bval mw ew bx *. B.bval mw ew bw };
899
assert { f = round_fin fm m (mul_zneg x y) r };
900
assert { mul_zneg x y <-> not (B.bneg mw ew bx <-> B.bneg mw ew bw) };
901
flocq_zero fm m; rnd_flocq fm m r; pow2r_pos (emax fm);
902
if pure { r <> 0.0 } then begin
903
assert { to_real x <> 0.0 /\ to_real y <> 0.0 };
904
assert { r <. 0.0 <-> not (B.bneg mw ew bx <-> B.bneg mw ew bw) }
905
end;
906
round_bits fm m (mul_zneg x y) (pure { B.bneg mw ew bz }) r bz
907
end else views_eq z f
908
{qed}
909
Valid (9.7s) (colibri2 23) (cvc4 3) (cvc5 25) (split_vc 6) (depth 2)
910
let ghost
div_bits
(fm: format) (m: mode) (bx bw: int) : unit
911
requires { std fm }
912
requires { B.in_range (mw fm) (ew fm) bx /\ B.in_range (mw fm) (ew fm) bw }
913
ensures { of_bits fm (B.b_div (mw fm) (ew fm) (bmode m) bx bw) =
914
fp_div m (of_bits fm bx) (of_bits fm bw) }
915
= {proof…}
916
let mw = mw fm in
917
let ew = ew fm in
918
let bz = B.b_div mw ew (bmode m) bx bw in
919
of_bits_views fm bx; of_bits_views fm bw; of_bits_views fm bz;
920
let x = of_bits fm bx in
921
let y = of_bits fm bw in
922
let z = of_bits fm bz in
923
let f = fp_div m x y in
924
bmag_pos fm bx; bmag_pos fm bw;
925
finite_sign x; finite_sign y;
926
if pure { is_finite x /\ is_finite y /\ not is_zero y } then begin
927
let r = pure { to_real x /. to_real y } in
928
assert { to_real y <> 0.0 };
929
assert { r = B.bval mw ew bx /. B.bval mw ew bw };
930
assert { r = to_real x *. (1.0 /. to_real y) };
931
assert { f = round_fin fm m (mul_zneg x y) r };
932
assert { mul_zneg x y <-> not (B.bneg mw ew bx <-> B.bneg mw ew bw) };
933
flocq_zero fm m; rnd_flocq fm m r; pow2r_pos (emax fm);
934
if pure { r <> 0.0 } then begin
935
assert { to_real x <> 0.0 };
936
assert { r <. 0.0 <-> not (B.bneg mw ew bx <-> B.bneg mw ew bw) }
937
end;
938
round_bits fm m (mul_zneg x y) (pure { B.bneg mw ew bz }) r bz
939
end else if pure { is_finite x /\ is_infinity y } then begin
940
round_zero fm m (mul_zneg x y);
941
assert { f = round_fin fm m (mul_zneg x y) 0.0 };
942
views_eq z f
943
end else if pure { is_infinity x /\ is_finite y /\ not is_zero y } then begin
944
assert { to_real y <. 0.0 -> 1.0 /. to_real y <. 0.0 };
945
assert { 0.0 <. to_real y -> 0.0 <. 1.0 /. to_real y };
946
assert { to_real y <. 0.0 <-> B.bneg mw ew bw };
947
assert { x.value = PlusInf <-> not B.bneg mw ew bx };
948
assert { B.binf mw ew bz /\ (B.bneg mw ew bz <-> not (B.bneg mw ew bx <-> B.bneg mw ew bw)) };
949
assert { f = round_f fm m (mul_zneg x y) (ediv (ext x) (ext y)) };
950
if pure { to_real y <. 0.0 } then
951
(if pure { x.value = PlusInf } then begin
952
assert { ext x = PInf /\ ediv (ext x) (ext y) = MInf };
953
assert { f.value = MinusInf /\ z.value = MinusInf } end
954
else assert { f.value = PlusInf /\ z.value = PlusInf })
955
else
956
(if pure { x.value = PlusInf } then assert { f.value = PlusInf /\ z.value = PlusInf }
957
else assert { f.value = MinusInf /\ z.value = MinusInf });
958
views_eq z f
959
end else views_eq z f
960
{qed}
Valid (2.0s) (colibri2 13) (cvc4 8) (cvc5 33) (split_vc 5) (depth 2)
961
let ghost
fma_bits
(fm: format) (m: mode) (bx bw bu: int) : unit
962
requires { std fm }
963
requires { B.in_range (mw fm) (ew fm) bx /\ B.in_range (mw fm) (ew fm) bw /\
964
B.in_range (mw fm) (ew fm) bu }
965
ensures { of_bits fm (B.b_fma (mw fm) (ew fm) (bmode m) bx bw bu) =
966
fp_fma m (of_bits fm bx) (of_bits fm bw) (of_bits fm bu) }
967
= {proof…}
968
let mw = mw fm in
969
let ew = ew fm in
970
let bz = B.b_fma mw ew (bmode m) bx bw bu in
971
of_bits_views fm bx; of_bits_views fm bw; of_bits_views fm bu; of_bits_views fm bz;
972
let x = of_bits fm bx in
973
let y = of_bits fm bw in
974
let u = of_bits fm bu in
975
let z = of_bits fm bz in
976
let f = fp_fma m x y u in
977
bmag_pos fm bx; bmag_pos fm bw; bmag_pos fm bu;
978
finite_sign x; finite_sign y; finite_sign u;
979
if pure { is_finite x /\ is_finite y /\ is_finite u } then begin
980
let r = pure { to_real x *. to_real y +. to_real u } in
981
assert { r = B.bval mw ew bx *. B.bval mw ew bw +. B.bval mw ew bu };
982
assert { ext x = Fin (to_real x) /\ ext y = Fin (to_real y) /\ ext u = Fin (to_real u) };
983
assert { eadd (emul (ext x) (ext y)) (ext u) = Fin r };
984
assert { f = round_fin fm m (fma_zneg m x y u (Fin r)) r };
985
B.fma_spec mw ew (bmode m) bx bw bu;
986
assert { mul_zneg x y <-> not (B.bneg mw ew bx <-> B.bneg mw ew bw) };
987
assert { is_positive u <-> not B.bneg mw ew bu };
988
assert { bmode m = B.rtn <-> m = RTN };
989
flocq_zero fm m; rnd_flocq fm m r; pow2r_pos (emax fm);
990
round_bits fm m (fma_zneg m x y u (Fin r)) (pure { B.bneg mw ew bz }) r bz
991
end else if pure { is_finite x /\ is_finite y /\ is_infinity u } then begin
992
assert { emul (ext x) (ext y) = Fin (to_real x *. to_real y) };
993
views_eq z f
994
end else begin
995
if pure { (is_infinity x \/ is_infinity y) /\ not is_nan x /\ not is_nan y /\
996
not is_zero x /\ not is_zero y } then begin
997
assert { is_finite x -> (to_real x <. 0.0 <-> B.bneg mw ew bx) };
998
assert { is_finite y -> (to_real y <. 0.0 <-> B.bneg mw ew bw) };
999
assert { emul (ext x) (ext y) =
1000
if mul_zneg x y then MInf else PInf };
1001
assert { mul_zneg x y <-> not (B.bneg mw ew bx <-> B.bneg mw ew bw) };
1002
let e = pure { emul (ext x) (ext y) } in
1003
B.fma_spec mw ew (bmode m) bx bw bu;
1004
if pure { not is_nan u } then begin
1005
assert { opposite e (ext u) <->
1006
B.binf mw ew bu /\ not (B.bneg mw ew bu <-> mul_zneg x y) };
1007
if pure { not opposite e (ext u) } then begin
1008
assert { eadd e (ext u) = e /\ f = round_f fm m false e };
1009
assert { B.binf mw ew bz /\ (B.bneg mw ew bz <-> mul_zneg x y) };
1010
if mul_zneg x y then assert { f.value = MinusInf /\ z.value = MinusInf }
1011
else assert { f.value = PlusInf /\ z.value = PlusInf }
1012
end
1013
end
1014
end;
1015
views_eq z f
1016
end
1017
{qed}
Valid (1.9s) (cvc4)
1018
let ghost
sqrt_bits
(fm: format) (m: mode) (bx: int) : unit
1019
requires { std fm /\ B.in_range (mw fm) (ew fm) bx }
1020
ensures { of_bits fm (B.b_sqrt (mw fm) (ew fm) (bmode m) bx) =
1021
fp_sqrt m (of_bits fm bx) }
1022
= {proof…}
1023
let mw = mw fm in
1024
let ew = ew fm in
1025
let bz = B.b_sqrt mw ew (bmode m) bx in
1026
of_bits_views fm bx; of_bits_views fm bz;
1027
let x = of_bits fm bx in
1028
let z = of_bits fm bz in
1029
let f = fp_sqrt m x in
1030
bmag_pos fm bx;
1031
finite_sign x;
1032
if pure { is_finite x /\ (is_positive x \/ is_zero x) } then begin
1033
let r = pure { S.sqrt (to_real x) } in
1034
assert { 0.0 <=. to_real x };
1035
assert { S.sqrt 0.0 = 0.0 by S.sqrt (0.0 *. 0.0) = 0.0 };
1036
assert { 0.0 <=. r };
1037
assert { r = S.sqrt (B.bval mw ew bx) };
1038
assert { f = round_fin fm m (not is_positive x) r };
1039
assert { is_positive x <-> not B.bneg mw ew bx };
1040
flocq_zero fm m; rnd_flocq fm m r;
1041
fin_small fm bz;
1042
assert { B.small mw ew (bmode m) r };
1043
round_bits fm m (not is_positive x) (pure { B.bneg mw ew bz }) r bz
1044
end else views_eq z f
1045
{qed}
1046
Valid (2.6s) (colibri2 15) (cvc4 2) (cvc5 9) (split_vc 3) (depth 3)
1047
let ghost
rti_bits
(fm: format) (m: mode) (bx: int) : unit
1048
requires { std fm /\ B.in_range (mw fm) (ew fm) bx }
1049
ensures { of_bits fm (B.b_rti (mw fm) (ew fm) (bmode m) bx) =
1050
fp_rti m (of_bits fm bx) }
1051
= {proof…}
1052
let mw = mw fm in
1053
let ew = ew fm in
1054
let bz = B.b_rti mw ew (bmode m) bx in
1055
of_bits_views fm bx; of_bits_views fm bz;
1056
let x = of_bits fm bx in
1057
let z = of_bits fm bz in
1058
let f = fp_rti m x in
1059
bmag_pos fm bx;
1060
finite_sign x;
1061
if pure { is_finite x } then begin
1062
rnd_int_round m (to_real x);
1063
let n = round_int m (to_real x) in
1064
let r = pure { from_int n } in
1065
assert { r = B.bval mw ew bz };
1066
assert { f = round_fin fm m (not is_positive x) r };
1067
assert { is_positive x <-> not B.bneg mw ew bx };
1068
fin_small fm bz;
1069
flocq_exact fm m r;
1070
rnd_flocq fm m r;
1071
assert { B.small mw ew (bmode m) r };
1072
if pure { 0.0 <=. to_real x } then round_int_monotonic m 0.0 (to_real x)
1073
else round_int_monotonic m (to_real x) 0.0;
1074
assert { round_int m 0.0 = 0 by Truncate.floor 0.0 = 0 };
1075
round_bits fm m (not is_positive x) (pure { B.bneg mw ew bz }) r bz
1076
end else views_eq z f
1077
{qed}

Flocq's succ on the values of the magnitudes

  Valid (768ms) (cvc4)
1079
let ghost
succ_pos
(fm: format) (k: int) : unit
1080
requires { 0 <= k }
1081
ensures { B.succ (sb fm) (qmin fm) (vom fm k) = vom fm (k + 1) }
1082
= {proof…}
1083
binade_ge_2 fm;
1084
vom_generic fm k; vom_generic fm (k + 1); vom_lt fm k (k + 1);
1085
vom_zero fm; vom_mono fm 0 k;
1086
let s = B.succ (sb fm) (qmin fm) (vom fm k) in
1087
assert { F.generic (sb fm) (qmin fm) s /\ vom fm k <. s /\ s <=. vom fm (k + 1) };
1088
let j = generic_vom fm s in
1089
if j <= k then vom_mono fm j k;
1090
vom_mono fm (k + 1) j
1091
{qed}
1092
Valid (1.9s) (colibri2 12) (cvc5 3) (split_vc 2) (depth 2)
1093
let ghost
succ_neg
(fm: format) (k: int) : unit
1094
requires { 1 <= k }
1095
ensures { B.succ (sb fm) (qmin fm) (-. vom fm k) = -. vom fm (k - 1) }
1096
= {proof…}
1097
binade_ge_2 fm;
1098
vom_generic fm k; vom_generic fm (k - 1); vom_lt fm (k - 1) k;
1099
generic_neg (sb fm) (qmin fm) (vom fm k);
1100
generic_neg (sb fm) (qmin fm) (vom fm (k - 1));
1101
vom_zero fm; vom_mono fm 0 (k - 1);
1102
let s = B.succ (sb fm) (qmin fm) (-. vom fm k) in
1103
assert { F.generic (sb fm) (qmin fm) s /\ -. vom fm k <. s /\ s <=. -. vom fm (k - 1) };
1104
if pure { s <. 0.0 } then begin
1105
generic_neg (sb fm) (qmin fm) s;
1106
let j = generic_vom fm (-. s) in
1107
if k <= j then vom_mono fm k j;
1108
vom_mono fm j (k - 1)
1109
end else begin
1110
if 1 < k then vom_lt fm 0 (k - 1)
1111
end
1112
{qed}

next_up and next_down of fbin.Impl, as functions

1115
function
next_up_f
(x: t) : t =
1116
if is_nan x \/ is_plus_infinity x then x else of_index x.fmt (next_up_index (index x))
1117
function
next_down_f
(x: t) : t =
1118
if is_nan x \/ is_minus_infinity x then x else of_index x.fmt (next_down_index (index x))
1119
Valid (2.3s) (colibri2 25) (cvc4 19) (cvc5 32) (split_vc 13) (depth 2)
1120
let ghost
succ_bits
(fm: format) (bx: int) : unit
1121
requires { std fm /\ B.in_range (mw fm) (ew fm) bx }
1122
ensures { of_bits fm (B.b_succ (mw fm) (ew fm) bx) = next_up_f (of_bits fm bx) }
1123
= {proof…}
1124
let mw = mw fm in
1125
let ew = ew fm in
1126
let bz = B.b_succ mw ew bx in
1127
of_bits_views fm bx; of_bits_views fm bz;
1128
bits_k fm bz;
1129
let x = of_bits fm bx in
1130
let z = of_bits fm bz in
1131
let f = next_up_f x in
1132
vom_max fm; maxv_vom fm; vom_zero fm; rnd_flocq fm RNE 0.0;
1133
pow2_pow2r (emax fm);
1134
let n1 = pure { nb_sign fm - 1 } in
1135
match x.value with
1136
| Finite ng k ->
1137
let v = to_real x in
1138
assert { v = B.bval mw ew bx };
1139
B.succ_b_spec mw ew bx;
1140
assert { valid x.fmt x.value /\ 0 <= k < n1 };
1141
if not ng then begin
1142
succ_pos fm k;
1143
assert { index x = k };
1144
of_index_range fm (k + 1);
1145
assert { f = of_index fm (k + 1) };
1146
if k + 1 < n1 then begin
1147
vom_lt fm (k + 1) n1;
1148
assert { f.value = Finite false (k + 1) };
1149
assert { B.succ (B.prec mw) (B.emin mw ew) v = vom fm (k + 1) };
1150
assert { B.bfin mw ew bz /\ B.bval mw ew bz = vom fm (k + 1) }
1151
end else begin
1152
assert { f.value = PlusInf };
1153
assert { B.succ (B.prec mw) (B.emin mw ew) v = pow2r (emax fm) };
1154
assert { B.binf mw ew bz /\ not B.bneg mw ew bz }
1155
end;
1156
views_eq z f
1157
end else if k = 0 then begin
1158
succ_pos fm 0;
1159
assert { v = vom fm 0 /\ index x = -1 };
1160
assert { next_up_index (index x) = 1 /\ f = of_index fm 1 };
1161
vom_lt fm 1 n1;
1162
of_index_range fm 1;
1163
assert { f.value = Finite false 1 };
1164
assert { B.succ (B.prec mw) (B.emin mw ew) v = vom fm 1 };
1165
assert { B.bfin mw ew bz /\ B.bval mw ew bz = vom fm 1 };
1166
views_eq z f
1167
end else begin
1168
succ_neg fm k;
1169
assert { index x = -1 - k /\ next_up_index (index x) = -k };
1170
assert { k < n1 /\ f = of_index fm (-k) };
1171
assert { - nb_sign fm < -k < 0 };
1172
of_index_range fm (-k);
1173
assert { f.value = Finite true (-1 - (-k)) };
1174
assert { B.succ (B.prec mw) (B.emin mw ew) v = -. vom fm (k - 1) };
1175
vom_mono fm 0 (k - 1); pow2r_pos (emax fm);
1176
assert { B.bfin mw ew bz /\ B.bval mw ew bz = -. vom fm (k - 1) };
1177
views_eq z f
1178
end
1179
| MinusInf ->
1180
assert { index x = - nb_sign fm /\ f = of_index fm (1 - nb_sign fm) };
1181
of_index_range fm (1 - nb_sign fm);
1182
assert { f.value = Finite true (-1 - (1 - nb_sign fm)) };
1183
views_eq z f
1184
| _ -> views_eq z f
1185
end
1186
{qed}
1187
Valid (2.2s) (colibri2 35) (cvc4 11) (cvc5 39) (split_vc 13) (depth 2)
1188
let ghost
pred_bits
(fm: format) (bx: int) : unit
1189
requires { std fm /\ B.in_range (mw fm) (ew fm) bx }
1190
ensures { of_bits fm (B.b_pred (mw fm) (ew fm) bx) = next_down_f (of_bits fm bx) }
1191
= {proof…}
1192
let mw = mw fm in
1193
let ew = ew fm in
1194
let bz = B.b_pred mw ew bx in
1195
of_bits_views fm bx; of_bits_views fm bz;
1196
bits_k fm bz;
1197
let x = of_bits fm bx in
1198
let z = of_bits fm bz in
1199
let f = next_down_f x in
1200
vom_max fm; maxv_vom fm; vom_zero fm;
1201
pow2_pow2r (emax fm);
1202
let n1 = pure { nb_sign fm - 1 } in
1203
match x.value with
1204
| Finite ng k ->
1205
let v = to_real x in
1206
assert { v = B.bval mw ew bx };
1207
B.pred_b_spec mw ew bx;
1208
assert { valid x.fmt x.value /\ 0 <= k < n1 };
1209
if ng then begin
1210
succ_pos fm k;
1211
assert { -. v = vom fm k /\ index x = -1 - k };
1212
assert { next_down_index (index x) = -2 - k };
1213
assert { f = of_index fm (-2 - k) };
1214
if k + 1 < n1 then begin
1215
vom_lt fm (k + 1) n1;
1216
assert { - nb_sign fm < -2 - k < 0 };
1217
of_index_range fm (-2 - k);
1218
assert { f.value = Finite true (-1 - (-2 - k)) };
1219
assert { -. B.succ (B.prec mw) (B.emin mw ew) (-. v) = -. vom fm (k + 1) };
1220
vom_mono fm 0 (k + 1);
1221
assert { -. F.pow2 (B.emax ew) <. -. vom fm (k + 1) };
1222
assert { B.bfin mw ew bz /\ B.bval mw ew bz = -. vom fm (k + 1) }
1223
end else begin
1224
assert { -2 - k = - nb_sign fm };
1225
of_index_range fm (-2 - k);
1226
assert { f.value = MinusInf };
1227
assert { -. B.succ (B.prec mw) (B.emin mw ew) (-. v) = -. pow2r (emax fm) };
1228
assert { B.binf mw ew bz /\ B.bneg mw ew bz }
1229
end;
1230
views_eq z f
1231
end else if k = 0 then begin
1232
succ_pos fm 0;
1233
assert { -. v = vom fm 0 /\ index x = 0 };
1234
assert { f = of_index fm (-2) };
1235
assert { - nb_sign fm < -2 < 0 };
1236
of_index_range fm (-2);
1237
assert { f.value = Finite true 1 };
1238
assert { -. B.succ (B.prec mw) (B.emin mw ew) (-. v) = -. vom fm 1 };
1239
vom_lt fm 1 n1;
1240
assert { -. F.pow2 (B.emax ew) <. -. vom fm 1 };
1241
assert { B.bfin mw ew bz /\ B.bval mw ew bz = -. vom fm 1 };
1242
views_eq z f
1243
end else begin
1244
succ_neg fm k;
1245
assert { index x = k /\ next_down_index (index x) = k - 1 };
1246
assert { k < n1 /\ f = of_index fm (k - 1) };
1247
of_index_range fm (k - 1);
1248
assert { f.value = Finite false (k - 1) };
1249
assert { -. B.succ (B.prec mw) (B.emin mw ew) (-. v) = vom fm (k - 1) };
1250
vom_mono fm 0 (k - 1); pow2r_pos (emax fm);
1251
assert { -. F.pow2 (B.emax ew) <. vom fm (k - 1) };
1252
assert { B.bfin mw ew bz /\ B.bval mw ew bz = vom fm (k - 1) };
1253
views_eq z f
1254
end
1255
| PlusInf ->
1256
assert { index x = n1 /\ f = of_index fm (n1 - 1) };
1257
of_index_range fm (n1 - 1);
1258
assert { f.value = Finite false (n1 - 1) };
1259
B.pred_b_spec mw ew bx;
1260
assert { B.bfin mw ew bz /\ not B.bneg mw ew bz /\ B.bval mw ew bz = vom fm (n1 - 1) };
1261
views_eq z f
1262
| _ -> views_eq z f
1263
end
1264
{qed}

The comparisons

The comparisons of IEEE 754 are the order of the extended reals

  Valid (188ms) (colibri2)
1268
let ghost
ieee_ext
(x y: t) : unit
1269
requires { x.fmt = y.fmt /\ not is_nan x /\ not is_nan y }
1270
ensures { ieee_lt x y <-> not ele (ext y) (ext x) }
1271
ensures { ieee_le x y <-> ele (ext x) (ext y) }
1272
ensures { ieee_eq x y <-> ext x = ext y }
1273
= {proof…}
1274
ext_zero x; ext_zero y;
1275
if index x < index y then begin
1276
ext_le x y;
1277
if not (pure { is_zero x /\ is_zero y }) then ext_lt x y
1278
end else if index y < index x then begin
1279
ext_le y x;
1280
if not (pure { is_zero x /\ is_zero y }) then ext_lt y x
1281
end else begin
1282
index_inj x; index_inj y;
1283
assert { x = y }
1284
end
1285
{qed}

The extended real of an encoding

  Valid (606ms) (cvc5)
1288
let ghost
ext_bits
(fm: format) (b: int) : unit
1289
requires { B.in_range (mw fm) (ew fm) b }
1290
ensures { let x = of_bits fm b in
1291
(B.bfin (mw fm) (ew fm) b -> ext x = Fin (B.bval (mw fm) (ew fm) b)) /\
1292
(B.binf (mw fm) (ew fm) b /\ B.bneg (mw fm) (ew fm) b -> ext x = MInf) /\
1293
(B.binf (mw fm) (ew fm) b /\ not B.bneg (mw fm) (ew fm) b -> ext x = PInf) }
1294
= of_bits_views fm b
1295
Valid (1.5s) (cvc5)
1296
let ghost
lt_bits
(fm: format) (bx bw: int) : unit
1297
requires { std fm }
1298
requires { B.in_range (mw fm) (ew fm) bx /\ B.in_range (mw fm) (ew fm) bw }
1299
ensures { B.b_lt (mw fm) (ew fm) bx bw <-> ieee_lt (of_bits fm bx) (of_bits fm bw) }
1300
= {proof…}
1301
of_bits_views fm bx; of_bits_views fm bw; ext_bits fm bx; ext_bits fm bw;
1302
if pure { not is_nan (of_bits fm bx) /\ not is_nan (of_bits fm bw) } then
1303
ieee_ext (of_bits fm bx) (of_bits fm bw)
1304
{qed}
1305
Valid (2.0s) (colibri2)
1306
let ghost
le_bits
(fm: format) (bx bw: int) : unit
1307
requires { std fm }
1308
requires { B.in_range (mw fm) (ew fm) bx /\ B.in_range (mw fm) (ew fm) bw }
1309
ensures { B.b_le (mw fm) (ew fm) bx bw <-> ieee_le (of_bits fm bx) (of_bits fm bw) }
1310
= {proof…}
1311
of_bits_views fm bx; of_bits_views fm bw; ext_bits fm bx; ext_bits fm bw;
1312
if pure { not is_nan (of_bits fm bx) /\ not is_nan (of_bits fm bw) } then
1313
ieee_ext (of_bits fm bx) (of_bits fm bw)
1314
{qed}
1315
Valid (773ms) (cvc5)
1316
let ghost
eq_bits
(fm: format) (bx bw: int) : unit
1317
requires { std fm }
1318
requires { B.in_range (mw fm) (ew fm) bx /\ B.in_range (mw fm) (ew fm) bw }
1319
ensures { B.b_eq (mw fm) (ew fm) bx bw <-> ieee_eq (of_bits fm bx) (of_bits fm bw) }
1320
= {proof…}
1321
of_bits_views fm bx; of_bits_views fm bw; ext_bits fm bx; ext_bits fm bw;
1322
if pure { not is_nan (of_bits fm bx) /\ not is_nan (of_bits fm bw) } then
1323
ieee_ext (of_bits fm bx) (of_bits fm bw)
1324
{qed}
1325
end