Common — library colibrilib.flocq — module Binary

The binary floats of Flocq, through their encoding

Flocq's IEEE754.BinarySingleNaN floats of prec = mw + 1 bits of significand and the largest exponent emax = 2^(ew-1), with 0 < mw, 0 < ew and prec < emax (the hypotheses of Flocq's IEEE754.Bits), seen through their encoding on mw + ew + 1 bits: b_add mw ew m x y is bits_of_binary_float (Bplus m (binary_float_of_bits x) (binary_float_of_bits y)) (with the conversions between Binary and BinarySingleNaN, and one fixed NaN for the encoding of a NaN result).

The views of an encoding (bnan, binf, bfin, bneg, bval) are defined here on the bits, as Flocq's split_bits. The axioms are proved in Rocq (common/rocq/flocq/Binary.v): each is the definition of the operation in Flocq on the special values, and its theorem B..._correct on the finite values.

97
theory Binary
98
use int.Int
99
use int.Power
100
use int.EuclideanDivision
101
use real.RealInfix
102
use real.FromInt
103
use real.Abs
104
use real.Square
105
use Round

The rounding modes of Flocq (BinarySingleNaN.mode)

109
type
mode
110
constant
rne
: mode
111
constant
rna
: mode
112
constant
rtp
: mode
113
constant
rtn
: mode
114
constant
rtz
: mode
115
116
axiom
mode_distinct
:
117
rne <> rna /\ rne <> rtp /\ rne <> rtn /\ rne <> rtz /\ rna <> rtp /\
118
rna <> rtn /\ rna <> rtz /\ rtp <> rtn /\ rtp <> rtz /\ rtn <> rtz

round radix2 (FLT_exp emin prec) (round_mode m)

121
function
rnd
(prec emin: int) (m: mode) (r: real) : real
122
123
axiom
rnd_modes
: forall prec emin r.
124
rnd prec emin rne r = rnd_ne prec emin r /\
125
rnd prec emin rna r = rnd_na prec emin r /\
126
rnd prec emin rtp r = rnd_up prec emin r /\
127
rnd prec emin rtn r = rnd_dn prec emin r /\
128
rnd prec emin rtz r = rnd_zr prec emin r

round_mode m r: the rounding to an integer (Flocq's round radix2 (FIX_exp 0) (round_mode m) r is its real)

132
function
rnd_int
(m: mode) (r: real) : int
133
134
axiom
rnd_int_dn
: forall r.
135
from_int (rnd_int rtn r) <=. r <. from_int (rnd_int rtn r) +. 1.0
136
axiom
rnd_int_up
: forall r.
137
from_int (rnd_int rtp r) -. 1.0 <. r <=. from_int (rnd_int rtp r)
138
axiom
rnd_int_zr
: forall r.
139
rnd_int rtz r = if 0.0 <=. r then rnd_int rtn r else rnd_int rtp r
140
axiom
rnd_int_ne
: forall r.
141
abs (r -. from_int (rnd_int rne r)) <=. 0.5 /\
142
(abs (r -. from_int (rnd_int rne r)) = 0.5 -> exists q. rnd_int rne r = 2 * q)
143
axiom
rnd_int_na
: forall r.
144
abs (r -. from_int (rnd_int rna r)) <=. 0.5 /\
145
(abs (r -. from_int (rnd_int rna r)) = 0.5 -> abs r <. abs (from_int (rnd_int rna r)))

succ radix2 (FLT_exp emin prec), the next float; Flocq's pred x is - succ (- x)

149
function
succ
(prec emin: int) (x: real) : real
150
151
axiom
succ_spec
: forall prec emin x. 0 < prec -> generic prec emin x ->
152
generic prec emin (succ prec emin x) /\ x <. succ prec emin x /\
153
forall g. generic prec emin g -> x <. g -> succ prec emin x <=. g

The encoding (Flocq's split_bits)

157
function
prec
(mw: int) : int = mw + 1
158
function
emax
(ew: int) : int = power 2 (ew - 1)
159
function
emin
(mw ew: int) : int = 3 - emax ew - prec mw

The formats of Flocq's Bits

162
predicate
valid
(mw ew: int) = 0 < mw /\ 0 < ew /\ prec mw < emax ew
163
164
predicate
in_range
(mw ew b: int) = 0 <= b < power 2 (mw + ew + 1)
165
166
function
bman
(mw b: int) : int = mod b (power 2 mw)
167
function
bexp
(mw ew b: int) : int = mod (div b (power 2 mw)) (power 2 ew)
168
predicate
bneg
(mw ew b: int) = power 2 mw * power 2 ew <= b
169
170
predicate
bnan
(mw ew b: int) = bexp mw ew b = power 2 ew - 1 /\ bman mw b <> 0
171
predicate
binf
(mw ew b: int) = bexp mw ew b = power 2 ew - 1 /\ bman mw b = 0
172
predicate
bfin
(mw ew b: int) = bexp mw ew b <> power 2 ew - 1
173
predicate
bzero
(mw ew b: int) = bexp mw ew b = 0 /\ bman mw b = 0

The magnitude of a finite float

176
function
bmag
(mw ew b: int) : real =
177
if bexp mw ew b = 0 then from_int (bman mw b) *. pow2 (emin mw ew)
178
else from_int (bman mw b + power 2 mw) *. pow2 (bexp mw ew b + emin mw ew - 1)

The value of a finite float (Flocq's B2R)

181
function
bval
(mw ew b: int) : real =
182
if bneg mw ew b then -. bmag mw ew b else bmag mw ew b

The largest finite magnitude

185
function
maxv
(mw ew: int) : real =
186
from_int (power 2 (prec mw) - 1) *. pow2 (emax ew - prec mw)

No overflow: the rounding is below 2^emax

189
predicate
small
(mw ew: int) (m: mode) (r: real) =
190
abs (rnd (prec mw) (emin mw ew) m r) <. pow2 (emax ew)

The rounding of r, finite

193
predicate
rounded
(mw ew: int) (m: mode) (r: real) (z: int) =
194
bfin mw ew z /\ bval mw ew z = rnd (prec mw) (emin mw ew) m r

The overflow (Flocq's binary_overflow), the sign being the one of z

198
predicate
ovf
(mw ew: int) (m: mode) (z: int) =
199
if m = rne \/ m = rna \/ (m = rtp /\ not bneg mw ew z) \/
200
(m = rtn /\ bneg mw ew z)
201
then binf mw ew z
202
else bfin mw ew z /\ bmag mw ew z = maxv mw ew

The operations

206
function
b_neg
(mw ew: int) (x: int) : int
207
function
b_abs
(mw ew: int) (x: int) : int
208
function
b_add
(mw ew: int) (m: mode) (x y: int) : int
209
function
b_sub
(mw ew: int) (m: mode) (x y: int) : int
210
function
b_mul
(mw ew: int) (m: mode) (x y: int) : int
211
function
b_div
(mw ew: int) (m: mode) (x y: int) : int
212
function
b_fma
(mw ew: int) (m: mode) (x y z: int) : int
213
function
b_sqrt
(mw ew: int) (m: mode) (x: int) : int
214
function
b_rti
(mw ew: int) (m: mode) (x: int) : int
215
function
b_succ
(mw ew: int) (x: int) : int
216
function
b_pred
(mw ew: int) (x: int) : int
217
predicate
b_lt
(mw ew: int) (x y: int)
218
predicate
b_le
(mw ew: int) (x y: int)
219
predicate
b_eq
(mw ew: int) (x y: int)

Bopp

222
axiom
neg_spec
: forall mw ew x. valid mw ew -> in_range mw ew x ->
223
let z = b_neg mw ew x in
224
in_range mw ew z /\
225
(bnan mw ew x -> bnan mw ew z) /\
226
(binf mw ew x -> binf mw ew z /\ (bneg mw ew z <-> not bneg mw ew x)) /\
227
(bfin mw ew x -> bfin mw ew z /\ bmag mw ew z = bmag mw ew x /\
228
(bneg mw ew z <-> not bneg mw ew x))

Babs

231
axiom
abs_spec
: forall mw ew x. valid mw ew -> in_range mw ew x ->
232
let z = b_abs mw ew x in
233
in_range mw ew z /\
234
(bnan mw ew x -> bnan mw ew z) /\
235
(binf mw ew x -> binf mw ew z /\ not bneg mw ew z) /\
236
(bfin mw ew x -> bfin mw ew z /\ bmag mw ew z = bmag mw ew x /\
237
not bneg mw ew z)

Bplus

240
axiom
add_spec
: forall mw ew m x y. valid mw ew ->
241
in_range mw ew x -> in_range mw ew y ->
242
let z = b_add mw ew m x y in
243
in_range mw ew z /\
244
(bnan mw ew x \/ bnan mw ew y -> bnan mw ew z) /\
245
(binf mw ew x /\ binf mw ew y ->
246
if bneg mw ew x <-> bneg mw ew y
247
then binf mw ew z /\ (bneg mw ew z <-> bneg mw ew x)
248
else bnan mw ew z) /\
249
(binf mw ew x /\ bfin mw ew y ->
250
binf mw ew z /\ (bneg mw ew z <-> bneg mw ew x)) /\
251
(bfin mw ew x /\ binf mw ew y ->
252
binf mw ew z /\ (bneg mw ew z <-> bneg mw ew y)) /\
253
(bfin mw ew x /\ bfin mw ew y ->
254
let r = bval mw ew x +. bval mw ew y in
255
if small mw ew m r then
256
rounded mw ew m r z /\
257
(bneg mw ew z <-> (r <. 0.0 \/ (r = 0.0 /\
258
(if m = rtn then bneg mw ew x \/ bneg mw ew y
259
else bneg mw ew x /\ bneg mw ew y))))
260
else ovf mw ew m z /\ (bneg mw ew z <-> bneg mw ew x) /\
261
(bneg mw ew x <-> bneg mw ew y))

Bminus

264
axiom
sub_spec
: forall mw ew m x y. valid mw ew ->
265
in_range mw ew x -> in_range mw ew y ->
266
let z = b_sub mw ew m x y in
267
in_range mw ew z /\
268
(bnan mw ew x \/ bnan mw ew y -> bnan mw ew z) /\
269
(binf mw ew x /\ binf mw ew y ->
270
if bneg mw ew x <-> bneg mw ew y then bnan mw ew z
271
else binf mw ew z /\ (bneg mw ew z <-> bneg mw ew x)) /\
272
(binf mw ew x /\ bfin mw ew y ->
273
binf mw ew z /\ (bneg mw ew z <-> bneg mw ew x)) /\
274
(bfin mw ew x /\ binf mw ew y ->
275
binf mw ew z /\ (bneg mw ew z <-> not bneg mw ew y)) /\
276
(bfin mw ew x /\ bfin mw ew y ->
277
let r = bval mw ew x -. bval mw ew y in
278
if small mw ew m r then
279
rounded mw ew m r z /\
280
(bneg mw ew z <-> (r <. 0.0 \/ (r = 0.0 /\
281
(if m = rtn then bneg mw ew x \/ not bneg mw ew y
282
else bneg mw ew x /\ not bneg mw ew y))))
283
else ovf mw ew m z /\ (bneg mw ew z <-> bneg mw ew x) /\
284
(bneg mw ew x <-> not bneg mw ew y))

Bmult

287
axiom
mul_spec
: forall mw ew m x y. valid mw ew ->
288
in_range mw ew x -> in_range mw ew y ->
289
let z = b_mul mw ew m x y in
290
in_range mw ew z /\
291
(bnan mw ew x \/ bnan mw ew y -> bnan mw ew z) /\
292
(binf mw ew x /\ bzero mw ew y \/ bzero mw ew x /\ binf mw ew y ->
293
bnan mw ew z) /\
294
((binf mw ew x \/ binf mw ew y) /\ not bnan mw ew x /\ not bnan mw ew y /\
295
not bzero mw ew x /\ not bzero mw ew y ->
296
binf mw ew z /\ (bneg mw ew z <-> not (bneg mw ew x <-> bneg mw ew y))) /\
297
(bfin mw ew x /\ bfin mw ew y ->
298
let r = bval mw ew x *. bval mw ew y in
299
(if small mw ew m r then rounded mw ew m r z else ovf mw ew m z) /\
300
(bneg mw ew z <-> not (bneg mw ew x <-> bneg mw ew y)))

Bdiv

303
axiom
div_spec
: forall mw ew m x y. valid mw ew ->
304
in_range mw ew x -> in_range mw ew y ->
305
let z = b_div mw ew m x y in
306
in_range mw ew z /\
307
(bnan mw ew x \/ bnan mw ew y -> bnan mw ew z) /\
308
(binf mw ew x /\ binf mw ew y \/ bzero mw ew x /\ bzero mw ew y ->
309
bnan mw ew z) /\
310
(binf mw ew x /\ bfin mw ew y \/
311
bfin mw ew x /\ not bzero mw ew x /\ bzero mw ew y ->
312
binf mw ew z /\ (bneg mw ew z <-> not (bneg mw ew x <-> bneg mw ew y))) /\
313
(bfin mw ew x /\ binf mw ew y ->
314
bzero mw ew z /\ (bneg mw ew z <-> not (bneg mw ew x <-> bneg mw ew y))) /\
315
(bfin mw ew x /\ bfin mw ew y /\ not bzero mw ew y ->
316
let r = bval mw ew x /. bval mw ew y in
317
(if small mw ew m r then rounded mw ew m r z else ovf mw ew m z) /\
318
(bneg mw ew z <-> not (bneg mw ew x <-> bneg mw ew y)))

Bfma

321
axiom
fma_spec
: forall mw ew m x y z. valid mw ew ->
322
in_range mw ew x -> in_range mw ew y -> in_range mw ew z ->
323
let w = b_fma mw ew m x y z in
324
in_range mw ew w /\
325
(bnan mw ew x \/ bnan mw ew y \/ bnan mw ew z -> bnan mw ew w) /\
326
(binf mw ew x /\ bzero mw ew y \/ bzero mw ew x /\ binf mw ew y ->
327
bnan mw ew w) /\
328
((binf mw ew x \/ binf mw ew y) /\ not bnan mw ew x /\ not bnan mw ew y /\
329
not bzero mw ew x /\ not bzero mw ew y /\ not bnan mw ew z ->
330
if binf mw ew z /\ not (bneg mw ew z <-> not (bneg mw ew x <-> bneg mw ew y))
331
then bnan mw ew w
332
else binf mw ew w /\
333
(bneg mw ew w <-> not (bneg mw ew x <-> bneg mw ew y))) /\
334
(bfin mw ew x /\ bfin mw ew y /\ binf mw ew z ->
335
binf mw ew w /\ (bneg mw ew w <-> bneg mw ew z)) /\
336
(bfin mw ew x /\ bfin mw ew y /\ bfin mw ew z ->
337
let r = bval mw ew x *. bval mw ew y +. bval mw ew z in
338
if small mw ew m r then
339
rounded mw ew m r w /\
340
(bneg mw ew w <-> (r <. 0.0 \/ (r = 0.0 /\
341
(if not (bneg mw ew x <-> bneg mw ew y) <-> bneg mw ew z
342
then not (bneg mw ew x <-> bneg mw ew y)
343
else m = rtn))))
344
else ovf mw ew m w /\ (bneg mw ew w <-> r <. 0.0))

Bsqrt

347
axiom
sqrt_spec
: forall mw ew m x. valid mw ew -> in_range mw ew x ->
348
let z = b_sqrt mw ew m x in
349
in_range mw ew z /\
350
(bnan mw ew x -> bnan mw ew z) /\
351
(binf mw ew x ->
352
if bneg mw ew x then bnan mw ew z else binf mw ew z /\ not bneg mw ew z) /\
353
(bfin mw ew x /\ bneg mw ew x /\ not bzero mw ew x -> bnan mw ew z) /\
354
(bfin mw ew x /\ (not bneg mw ew x \/ bzero mw ew x) ->
355
rounded mw ew m (sqrt (bval mw ew x)) z /\ (bneg mw ew z <-> bneg mw ew x))

Bnearbyint

358
axiom
rti_spec
: forall mw ew m x. valid mw ew -> in_range mw ew x ->
359
let z = b_rti mw ew m x in
360
in_range mw ew z /\
361
(bnan mw ew x -> bnan mw ew z) /\
362
(binf mw ew x -> binf mw ew z /\ (bneg mw ew z <-> bneg mw ew x)) /\
363
(bfin mw ew x -> bfin mw ew z /\
364
bval mw ew z = from_int (rnd_int m (bval mw ew x)) /\
365
(bneg mw ew z <-> bneg mw ew x))

Bsucc

368
axiom
succ_b_spec
: forall mw ew x. valid mw ew -> in_range mw ew x ->
369
let z = b_succ mw ew x in
370
in_range mw ew z /\
371
(bnan mw ew x -> bnan mw ew z) /\
372
(binf mw ew x /\ not bneg mw ew x -> binf mw ew z /\ not bneg mw ew z) /\
373
(binf mw ew x /\ bneg mw ew x ->
374
bfin mw ew z /\ bneg mw ew z /\ bmag mw ew z = maxv mw ew) /\
375
(bfin mw ew x ->
376
let s = succ (prec mw) (emin mw ew) (bval mw ew x) in
377
if s <. pow2 (emax ew) then
378
bfin mw ew z /\ bval mw ew z = s /\
379
(bneg mw ew z <-> bneg mw ew x /\ not bzero mw ew x)
380
else binf mw ew z /\ not bneg mw ew z)

Bpred

383
axiom
pred_b_spec
: forall mw ew x. valid mw ew -> in_range mw ew x ->
384
let z = b_pred mw ew x in
385
in_range mw ew z /\
386
(bnan mw ew x -> bnan mw ew z) /\
387
(binf mw ew x /\ bneg mw ew x -> binf mw ew z /\ bneg mw ew z) /\
388
(binf mw ew x /\ not bneg mw ew x ->
389
bfin mw ew z /\ not bneg mw ew z /\ bmag mw ew z = maxv mw ew) /\
390
(bfin mw ew x ->
391
let p = -. succ (prec mw) (emin mw ew) (-. bval mw ew x) in
392
if -. pow2 (emax ew) <. p then
393
bfin mw ew z /\ bval mw ew z = p /\
394
(bneg mw ew z <-> bneg mw ew x \/ bzero mw ew x)
395
else binf mw ew z /\ bneg mw ew z)

Bltb, Bleb, Beqb

398
axiom
lt_spec
: forall mw ew x y. valid mw ew ->
399
in_range mw ew x -> in_range mw ew y ->
400
(b_lt mw ew x y <-> not bnan mw ew x /\ not bnan mw ew y /\
401
((bfin mw ew x /\ bfin mw ew y /\ bval mw ew x <. bval mw ew y) \/
402
(binf mw ew x /\ bneg mw ew x /\ not (binf mw ew y /\ bneg mw ew y)) \/
403
(binf mw ew y /\ not bneg mw ew y /\ not (binf mw ew x /\ not bneg mw ew x))))
404
405
axiom
le_spec
: forall mw ew x y. valid mw ew ->
406
in_range mw ew x -> in_range mw ew y ->
407
(b_le mw ew x y <-> not bnan mw ew x /\ not bnan mw ew y /\
408
((bfin mw ew x /\ bfin mw ew y /\ bval mw ew x <=. bval mw ew y) \/
409
(binf mw ew x /\ bneg mw ew x) \/ (binf mw ew y /\ not bneg mw ew y)))
410
411
axiom
eq_spec
: forall mw ew x y. valid mw ew ->
412
in_range mw ew x -> in_range mw ew y ->
413
(b_eq mw ew x y <-> not bnan mw ew x /\ not bnan mw ew y /\
414
((bfin mw ew x /\ bfin mw ew y /\ bval mw ew x = bval mw ew y) \/
415
(binf mw ew x /\ binf mw ew y /\ (bneg mw ew x <-> bneg mw ew y))))
416
end