Common — library colibrilib.fp_conv — module Conv

The waits and the converter

5430
module Conv
5431
use list.List
5432
use colibrilib.ring.Atom
5433
use colibrilib.fbin.Fp
5434
use int.Int
5435
use int.Power
5436
use real.RealInfix
5437
use real.FromInt
5438
use mach.int.Int63
5439
use option.Option
5440
use colibrilib.stda.StdA as A
5441
use colibrilib.pow2r.Pow2r
5442
use Env
5443
use colibrilib.fp_interval.Intervals
5444
use colibrilib.fp_interval.FpInterval
5445
use RealConv
5446
use BvConv
5447
use Rules
5448
use GTerm
5449
use Dolmen as D

The waits of colibri2 (DaemonWithKey.Register, on the class of n): run d p is called when the domain (the value) of n changes, in an environment with the same model, until it returns true; the term g is the origin of the daemon (for the learning of colibri2)

The waits on the domains of the propagators Rel schedule them only when may_change (on the read–only environment of the event), as wait_rdom_dy

5458
val
wait_dom
(d: env) (g: ground) (n: Atom.t) (p: reg) : unit
5459
writes { d.state }
5460
5461
val
wait_value
(d: env) (g: ground) (n: Atom.t) (p: reg) : unit
5462
writes { d.state }

On the value of the Boolean node n

5465
val
wait_bool
(d: env) (g: ground) (n: Atom.t) (p: reg) : unit
5466
writes { d.state }

On the domain of the real node n (Dom_interval.events_attach_dom of the LRA theory, which schedules run d p)

5470
val
wait_rdom
(d: env) (g: ground) (n: Atom.t) (p: reg) : unit
5471
writes { d.state }

As wait_rdom, but run d p is scheduled only when n has a congruence class that is not a singleton and whose dyadic domain (D.congr, as in Rules.getdr_r; every node of sort Int has the class ℤ) is not already included in the dyadic domain of n, and one of the nodes ns has a dyadic domain (Rules.has_dy: without it run d p does nothing)

5479
val
wait_rdom_dy
(d: env) (g: ground) (n: Atom.t) (ns: list Atom.t) (p: reg) : unit
5480
writes { d.state }

On the dyadic domain of the real node n only

5483
val
wait_ddom
(d: env) (g: ground) (n: Atom.t) (p: reg) : unit
5484
writes { d.state }

On the terms fp.neg b of the class of n (its Info domain)

5487
val
wait_negs
(d: env) (g: ground) (n: Atom.t) (p: reg) : unit
5488
writes { d.state }

On the relations between a and b (colibri's update_deltas, keyed by the pair): run d p is called when the relation database (Env.updrel) changes the relation of the classes of a and b

5493
val
wait_rel
(d: env) (g: ground) (a b: Atom.t) (p: reg) : unit
5494
writes { d.state }

The propagator Mono of the term g: run d p is called (when may_change) when the relation database changes the relation between two of its siblings' arguments, or between two terms of its class and of a sibling (kept in a backtrackable table keyed by g)

5500
val
wait_mono
(d: env) (g: ground) (p: reg) : unit
5501
writes { d.state }

On the terms fp.div m c n of the class of n (its Info domain)

5504
val
wait_divs
(d: env) (g: ground) (n: Atom.t) (p: reg) : unit
5505
writes { d.state }

On the representative of the class of n (a merge)

5508
val
wait_repr
(d: env) (g: ground) (n: Atom.t) (p: reg) : unit
5509
writes { d.state }

The node c is the float 2 of the format fm, in every model

5512
predicate
two_node
(fm: format) (c: Atom.t) =
5513
(forall d: env. live d -> is_two fm (d.mf c)) /\
5514
(forall d: envp ro. live d -> is_two fm (d.mf c))
5515
5516
val
node
(g: ground) : Atom.t
5517
ensures { result = gnode g }
5518
5519
exception
NoFormat

The format of a Dolmen builtin

  Valid (78ms) (colibri2)
5522
let
fmt_ep
(e p: int63) : format
5523
ensures { D.isfmt result e p }
5524
raises { NoFormat -> not (1 < to_int e /\ 1 < to_int p) }
5525
= match mk_format_o (to_int e) (to_int p) with
5526
| Some fm -> fm
5527
| None -> raise NoFormat
5528
end

The float 2 of a format

  Valid (56ms) (colibri2)
5531
let
two
(fm: format) : t
5532
ensures { is_two fm result }
5533
= {proof…} two_exact fm; {qed}
5534
Fp.of_int fm RNE false 2

The integer node of a bit–vector node x of n bits, registered

  Valid (73ms) (colibri2)
5537
let
bv_int
(d: env) (n: int63) (s: bool) (x: Atom.t) : Atom.t
5538
requires { D.bvsize x = to_int n }
5539
ensures { D.means (D.Bitv_to_int n s) result (Cons x Nil) }
5540
= let i = D.apply d (D.cst_bv_to_int n s) (Cons x Nil) in
5541
register d i; i

SMT–LIB: fp s x y is to_fp of the concatenation, whose integer is s 2^(e+p-1) + x 2^(p-1) + y (the real node of a bit–vector is its unsigned integer); the constant node when the three are known in the e–graph (a fact of the branch of d)

  Valid (215ms) (colibri2 10) (split_vc) (depth 1)
5547
let
concat_int
(d: env) (e p: int) (s x y: Atom.t) : Atom.t
5548
requires { 0 <= e /\ 1 <= p }
5549
writes { d.state }
5550
ensures { live d -> forall d': env. model_of d' = model_of d ->
5551
d'.mr result = d'.mr s *. from_int (power 2 (e + p - 1)) +.
5552
d'.mr x *. from_int (power 2 (p - 1)) +. d'.mr y }
5553
ensures { live d -> forall d': envp ro. model_of d' = model_of d ->
5554
d'.mr result = d'.mr s *. from_int (power 2 (e + p - 1)) +.
5555
d'.mr x *. from_int (power 2 (p - 1)) +. d'.mr y }
5556
= let k1 = a_pow2 (e + p - 1) in
5557
let k2 = a_pow2 (p - 1) in
5558
{proof…}
5559
assert { pow2r (e + p - 1) = from_int (power 2 (e + p - 1)) };
5560
assert { pow2r (p - 1) = from_int (power 2 (p - 1)) };
5561
{qed}
5562
let n = match D.real_value d s, D.real_value d x, D.real_value d y with
5563
| Some vs, Some vx, Some vy ->
5564
(* a literal: the constant node *)
5565
D.real_cst (A.add (A.mul vs k1) (A.add (A.mul vx k2) vy))
5566
| _ ->
5567
D.real_lin d (Cons (s, k1) (Cons (x, k2) (Cons (y, A.of_bigint 1) Nil)))
5568
end in
5569
register d n; n

to_fp of a signed (s) or unsigned bit–vector x of n bits, as the conversion of its integer node, often exact

  Valid (4.6s) (colibri2 12) (split_vc 3) (depth 2)
5573
let
exact_int
(d: env) (fm: format) (bi: D.builtin) (n e p: int63) (s: bool)
5574
(r m x: Atom.t) : (builtin, list Atom.t)
5575
requires { D.means bi r (Cons m (Cons x Nil)) }
5576
requires { bi = if s then D.Sbv_to_fp n e p else D.Ubv_to_fp n e p }
5577
requires { D.isfmt fm e p }
5578
writes { d.state }
5579
ensures { match result with
5580
| (FpExactInt fm', Cons a (Cons t (Cons c Nil))) ->
5581
valid (ExactInt fm' r a t) /\ (forall d: env. live d -> d.mf r = d.mf c)
5582
| _ -> false end }
5583
= {proof…} D.means_at d bi r (Cons m (Cons x Nil)); {qed}
5584
register d m; register d x;
5585
let ai = bv_int d n s x in
5586
let tr = D.apply d (D.cst_to_real e p) (Cons r Nil) in
5587
register d tr;
5588
(* `to_fp` of a real of its integer node *)
5589
let c = D.apply d (D.cst_real_to_fp e p) (Cons m (Cons ai Nil)) in
5590
register d c;
5591
{proof…}
5592
D.valid_of d bi r (Cons m (Cons x Nil)) (D.Bitv_to_int n s) ai (Cons x Nil)
5593
(D.To_real e p) tr (Cons r Nil) (ExactInt fm r ai tr);
5594
assert { forall d: env. live d -> d.mf r = d.mf c
5595
by D.sem_in d bi r (Cons m (Cons x Nil)) /\
5596
D.sem_in d (D.Bitv_to_int n s) ai (Cons x Nil) /\
5597
D.sem_in d (D.Real_to_fp e p) c (Cons m (Cons ai Nil)) };
5598
{qed}
5599
(FpExactInt fm, Cons ai (Cons tr (Cons c Nil)))

fp.to_sbv (s) or fp.to_ubv of n bits: the integer node of the result is the real of the rounding to an integral float, when it is finite and in the range of the bit–vectors

  Valid (2.4s) (colibri2 12) (split_vc 3) (depth 2)
5604
let
to_bv
(d: env) (fm: format) (bi: D.builtin) (e p n: int63) (s: bool)
5605
(r m x: Atom.t) : (builtin, list Atom.t)
5606
requires { D.means bi r (Cons m (Cons x Nil)) }
5607
requires { bi = if s then D.To_sbv e p n else D.To_ubv e p n }
5608
requires { D.isfmt fm e p }
5609
writes { d.state }
5610
ensures { match result with
5611
| (FpToRealIn fm' lo hi, Cons ri (Cons t Nil)) -> valid (ToRealIn fm' ri t lo hi)
5612
| (Other, Nil) -> true
5613
| _ -> false end }
5614
= {proof…} D.means_at d bi r (Cons m (Cons x Nil)); {qed}
5615
if 1 <= to_int n then begin
5616
register d m; register d x;
5617
let t = D.apply d (D.cst_rti e p) (Cons m (Cons x Nil)) in
5618
register d t;
5619
let (lo, hi) =
5620
if s then let h = pow2 (to_int n - 1) in (- h, h - 1)
5621
else (0, pow2 (to_int n) - 1) in
5622
let ri = bv_int d n s r in
5623
{proof…}
5624
D.valid_of d bi r (Cons m (Cons x Nil)) (D.Bitv_to_int n s) ri (Cons r Nil)
5625
(D.Fp_roundToIntegral e p) t (Cons m (Cons x Nil)) (ToRealIn fm ri t lo hi);
5626
{qed}
5627
(FpToRealIn fm lo hi, Cons ri (Cons t Nil))
5628
end else (Other, Nil)

The operator and the arguments of a ground term: its value is the value of its interpretation in every model (Dolmen.sem). It may create and register the nodes of the arguments (the integer of a bit–vector, fp.to_real, fp.roundToIntegral), read as in SMT–LIB. FpCvt gives the conversion and the exact conversion (to a wider format)

  Valid (3.6s) (colibri2 203) (cvc5) (split_vc 19) (depth 2)
5636
let
view
(d: env) (g: ground) : (builtin, list Atom.t)
5637
writes { d.state }
5638
ensures { match result with
5639
| (FpBin o fm, Cons m (Cons a (Cons b Nil))) ->
5640
valid (Bin o fm (gnode g) m a b)
5641
| (FpAdd fm, Cons m (Cons a (Cons b (Cons c (Cons t Nil))))) ->
5642
valid (Bin OAdd fm (gnode g) m a b) /\ valid (Bin OMul fm t m c a) /\
5643
two_node fm c
5644
| (FpUn o fm, Cons m (Cons a Nil)) ->
5645
valid (Un o fm (gnode g) m a)
5646
| (FpCvt fm fm', Cons m (Cons a (Cons tr (Cons ta Nil)))) ->
5647
valid (Cvt fm fm' (gnode g) m a) /\
5648
valid (ExactCvt fm fm' (gnode g) a tr ta)
5649
| (FpAbs fm, Cons a Nil) ->
5650
valid (Abs fm (gnode g) a)
5651
| (FpNeg, Cons a Nil) ->
5652
valid (Neg (gnode g) a)
5653
| (FpChoice, Cons a (Cons b Nil)) ->
5654
valid (Choice (gnode g) a b)
5655
| (FpCmp o fm, Cons a (Cons b Nil)) ->
5656
valid (Cmp o fm (gnode g) a b)
5657
| (FpIs o fm, Cons a Nil) ->
5658
valid (Is o fm (gnode g) a)
5659
| (FpToReal fm, Cons a Nil) ->
5660
valid (ToReal fm (gnode g) a)
5661
| (FpOfReal fm, Cons m (Cons a Nil)) ->
5662
valid (OfReal fm (gnode g) m a)
5663
| (FpOfBits fm back, Cons a Nil) ->
5664
valid_at (model_of d) (live d) (OfBits fm (gnode g) a back)
5665
| (FpExactInt fm, Cons a (Cons t (Cons c Nil))) ->
5666
valid (ExactInt fm (gnode g) a t) /\
5667
(forall d: env. live d -> d.mf (gnode g) = d.mf c)
5668
| (FpRw, Cons t Nil) ->
5669
forall d: env. live d -> d.mf (gnode g) = d.mf t
5670
| (FpToRealIn fm lo hi, Cons r (Cons a Nil)) ->
5671
valid (ToRealIn fm r a lo hi)
5672
| (RealBin o, Cons a (Cons b Nil)) ->
5673
valid (RBin o (gnode g) a b)
5674
| (RealNeg, Cons a Nil) ->
5675
valid (RNeg (gnode g) a)
5676
| _ -> true
5677
end }
5678
= let r = node g in
5679
match D.sem g with
5680
| None -> (Other, Nil)
5681
| Some (bi, l) ->
5682
{proof…} D.means_at d bi r l; {qed}
5683
try
5684
match bi, l with
5685
| D.Fp_add e p, Cons m (Cons a (Cons b Nil)) ->
5686
(* with the float 2 and the term `2 * a`, merged when `a = b` *)
5687
let fm = fmt_ep e p in
5688
let c = D.float_node fm (two fm) in
5689
let t = D.apply d (D.cst_mul e p) (Cons m (Cons c (Cons a Nil))) in
5690
{proof…}
5691
D.valid_of d bi r l bi r l bi r l (Bin OAdd fm r m a b);
5692
D.valid_of d (D.Fp_mul e p) t (Cons m (Cons c (Cons a Nil)))
5693
(D.Fp_mul e p) t (Cons m (Cons c (Cons a Nil)))
5694
(D.Fp_mul e p) t (Cons m (Cons c (Cons a Nil))) (Bin OMul fm t m c a);
5695
{qed}
5696
(FpAdd fm, Cons m (Cons a (Cons b (Cons c (Cons t Nil)))))
5697
| D.Fp_mul e p, Cons m (Cons a (Cons b Nil)) ->
5698
let fm = fmt_ep e p in
5699
{proof…} D.valid_of d bi r l bi r l bi r l (Bin OMul fm r m a b); {qed}
5700
(FpBin OMul fm, l)
5701
| D.Fp_sub e p, Cons m (Cons a (Cons b Nil)) ->
5702
(* `fp.sub m a b` is `fp.add m a (fp.neg b)` *)
5703
let fm = fmt_ep e p in
5704
register d m; register d a; register d b;
5705
let t1 = D.apply d (D.cst_neg e p) (Cons b Nil) in
5706
{proof…}
5707
D.means_at d (D.Fp_neg e p) t1 (Cons b Nil);
5708
assert { fmt_of a = fm /\ fmt_of b = fm /\ fmt_of t1 = fm };
5709
{qed}
5710
register d t1;
5711
let t2 = D.apply d (D.cst_add e p) (Cons m (Cons a (Cons t1 Nil))) in
5712
{proof…}
5713
assert { forall d: env. live d -> d.mf r = d.mf t2
5714
by D.sem_in d bi r l /\ D.sem_in d (D.Fp_neg e p) t1 (Cons b Nil) /\
5715
D.sem_in d (D.Fp_add e p) t2 (Cons m (Cons a (Cons t1 Nil))) };
5716
{qed}
5717
(FpRw, Cons t2 Nil)
5718
| D.Fp_div e p, Cons m (Cons a (Cons b Nil)) ->
5719
let fm = fmt_ep e p in
5720
{proof…} D.valid_of d bi r l bi r l bi r l (Bin ODiv fm r m a b); {qed}
5721
(FpBin ODiv fm, l)
5722
| D.Fp_sqrt e p, Cons m (Cons a Nil) ->
5723
let fm = fmt_ep e p in
5724
{proof…} D.valid_of d bi r l bi r l bi r l (Un USqrt fm r m a); {qed}
5725
(FpUn USqrt fm, l)
5726
| D.Fp_roundToIntegral e p, Cons m (Cons a Nil) ->
5727
let fm = fmt_ep e p in
5728
{proof…} D.valid_of d bi r l bi r l bi r l (Un URti fm r m a); {qed}
5729
(FpUn URti fm, l)
5730
| D.Fp_to_fp e p e' p', Cons m (Cons a Nil) ->
5731
(* with the exact conversion: `fp.to_real r = fp.to_real a` *)
5732
let fm = fmt_ep e p in
5733
let fm' = fmt_ep e' p' in
5734
{proof…}
5735
assert { D.sp d (Cvt fm fm' r m a) };
5736
assert { fmt_of r = fm' /\ fmt_of a = fm };
5737
{qed}
5738
let tr = D.apply d (D.cst_to_real e' p') (Cons r Nil) in
5739
let ta = D.apply d (D.cst_to_real e p) (Cons a Nil) in
5740
register d tr; register d ta;
5741
{proof…}
5742
D.valid_of d bi r l bi r l bi r l (Cvt fm fm' r m a);
5743
D.valid_of d bi r l (D.To_real e' p') tr (Cons r Nil)
5744
(D.To_real e p) ta (Cons a Nil) (ExactCvt fm fm' r a tr ta);
5745
{qed}
5746
(FpCvt fm fm', Cons m (Cons a (Cons tr (Cons ta Nil))))
5747
| D.Ieee_format_to_fp e p, Cons x Nil ->
5748
let fm = fmt_ep e p in
5749
if to_int e <= 0x100000 && to_int p <= 0x100000 then begin
5750
register d x;
5751
let n = e + p in
5752
let i = bv_int d n false x in
5753
{proof…}
5754
assert { power 2 (eb fm + sb fm) = 2 * half_bits fm };
5755
D.valid_of d bi r l (D.Bitv_to_int n false) i (Cons x Nil)
5756
bi r l (OfBits fm r i true);
5757
{qed}
5758
(FpOfBits fm true, Cons i Nil)
5759
end else (Other, Nil)
5760
| D.Fp e p, Cons s (Cons x (Cons y Nil)) ->
5762
(* without the update of the integer of the concatenation, a linear term: costly in the LRA theory *)
5763
let fm = fmt_ep e p in
5764
register d s; register d x; register d y;
5765
let n = concat_int d (to_int e) (to_int p) s x y in
5766
{proof…}
5767
D.concat_valid d fm (to_int e) (to_int p) bi r s x y n;
5768
{qed}
5769
(FpOfBits fm false, Cons n Nil)
5770
| D.Sbv_to_fp n e p, Cons m (Cons x Nil) ->
5771
(* the conversion of an integer is often exact: `fp.to_real r = a` *)
5772
let fm = fmt_ep e p in
5773
exact_int d fm bi n e p true r m x
5774
| D.Ubv_to_fp n e p, Cons m (Cons x Nil) ->
5775
let fm = fmt_ep e p in
5776
exact_int d fm bi n e p false r m x
5777
| D.To_sbv e p n, Cons m (Cons x Nil) ->
5778
let fm = fmt_ep e p in
5779
to_bv d fm bi e p n true r m x
5780
| D.To_ubv e p n, Cons m (Cons x Nil) ->
5781
let fm = fmt_ep e p in
5782
to_bv d fm bi e p n false r m x
5783
| D.Fp_abs e p, Cons a Nil ->
5784
let fm = fmt_ep e p in
5785
{proof…} D.valid_of d bi r l bi r l bi r l (Abs fm r a); {qed}
5786
(FpAbs fm, l)
5787
| D.Fp_neg _ _, Cons a Nil ->
5788
{proof…} D.valid_of d bi r l bi r l bi r l (Neg r a); {qed}
5789
(FpNeg, l)
5790
| D.Fp_min _ _, Cons a (Cons b Nil)
5791
| D.Fp_max _ _, Cons a (Cons b Nil) ->
5792
{proof…} D.valid_of d bi r l bi r l bi r l (Choice r a b); {qed}
5793
(FpChoice, l)
5794
| D.Fp_leq e p, Cons a (Cons b Nil) ->
5795
let fm = fmt_ep e p in
5796
{proof…} D.valid_of d bi r l bi r l bi r l (Cmp CLe fm r a b); {qed}
5797
(FpCmp CLe fm, l)
5798
| D.Fp_lt e p, Cons a (Cons b Nil) ->
5799
let fm = fmt_ep e p in
5800
{proof…} D.valid_of d bi r l bi r l bi r l (Cmp CLt fm r a b); {qed}
5801
(FpCmp CLt fm, l)
5802
| D.Fp_eq e p, Cons a (Cons b Nil) ->
5803
let fm = fmt_ep e p in
5804
{proof…} D.valid_of d bi r l bi r l bi r l (Cmp CEq fm r a b); {qed}
5805
(FpCmp CEq fm, l)
5806
(* `a >= b` is `b <= a`, `a > b` is `b < a` *)
5807
| D.Fp_geq e p, Cons a (Cons b Nil) ->
5808
let fm = fmt_ep e p in
5809
{proof…} D.valid_of d bi r l bi r l bi r l (Cmp CLe fm r b a); {qed}
5810
(FpCmp CLe fm, Cons b (Cons a Nil))
5811
| D.Fp_gt e p, Cons a (Cons b Nil) ->
5812
let fm = fmt_ep e p in
5813
{proof…} D.valid_of d bi r l bi r l bi r l (Cmp CLt fm r b a); {qed}
5814
(FpCmp CLt fm, Cons b (Cons a Nil))
5815
| D.Fp_isNaN e p, Cons a Nil ->
5816
let fm = fmt_ep e p in
5817
{proof…} D.valid_of d bi r l bi r l bi r l (Is INaN fm r a); {qed}
5818
(FpIs INaN fm, l)
5819
| D.Fp_isNormal e p, Cons a Nil ->
5820
let fm = fmt_ep e p in
5821
{proof…} D.valid_of d bi r l bi r l bi r l (Is INormal fm r a); {qed}
5822
(FpIs INormal fm, l)
5823
| D.Fp_isSubnormal e p, Cons a Nil ->
5824
let fm = fmt_ep e p in
5825
{proof…} D.valid_of d bi r l bi r l bi r l (Is ISubnormal fm r a); {qed}
5826
(FpIs ISubnormal fm, l)
5827
| D.Fp_isZero e p, Cons a Nil ->
5828
let fm = fmt_ep e p in
5829
{proof…} D.valid_of d bi r l bi r l bi r l (Is IZero fm r a); {qed}
5830
(FpIs IZero fm, l)
5831
| D.Fp_isInfinite e p, Cons a Nil ->
5832
let fm = fmt_ep e p in
5833
{proof…} D.valid_of d bi r l bi r l bi r l (Is IInf fm r a); {qed}
5834
(FpIs IInf fm, l)
5835
| D.Fp_isNegative e p, Cons a Nil ->
5836
let fm = fmt_ep e p in
5837
{proof…} D.valid_of d bi r l bi r l bi r l (Is INeg fm r a); {qed}
5838
(FpIs INeg fm, l)
5839
| D.Fp_isPositive e p, Cons a Nil ->
5840
let fm = fmt_ep e p in
5841
{proof…} D.valid_of d bi r l bi r l bi r l (Is IPos fm r a); {qed}
5842
(FpIs IPos fm, l)
5843
| D.Fp_isFinite e p, Cons a Nil ->
5844
let fm = fmt_ep e p in
5845
{proof…} D.valid_of d bi r l bi r l bi r l (Is IFinite fm r a); {qed}
5846
(FpIs IFinite fm, l)
5847
| D.To_real e p, Cons a Nil ->
5848
let fm = fmt_ep e p in
5849
{proof…} D.valid_of d bi r l bi r l bi r l (ToReal fm r a); {qed}
5850
(FpToReal fm, l)
5851
| D.Real_to_fp e p, Cons m (Cons a Nil) ->
5852
let fm = fmt_ep e p in
5853
{proof…} D.valid_of d bi r l bi r l bi r l (OfReal fm r m a); {qed}
5854
(FpOfReal fm, l)
5855
(* the terms of the LRA theory, for the dyadic domain of the reals *)
5856
| D.Add _, Cons a (Cons b Nil) ->
5857
{proof…} D.valid_of d bi r l bi r l bi r l (RBin RAdd r a b); {qed}
5858
(RealBin RAdd, l)
5859
| D.Sub _, Cons a (Cons b Nil) ->
5860
{proof…} D.valid_of d bi r l bi r l bi r l (RBin RSub r a b); {qed}
5861
(RealBin RSub, l)
5862
| D.Mul _, Cons a (Cons b Nil) ->
5863
{proof…} D.valid_of d bi r l bi r l bi r l (RBin RMul r a b); {qed}
5864
(RealBin RMul, l)
5865
| D.Minus _, Cons a Nil ->
5866
{proof…} D.valid_of d bi r l bi r l bi r l (RNeg r a); {qed}
5867
(RealNeg, l)
5868
| _ -> (Other, Nil)
5869
end
5870
with NoFormat -> (Other, Nil)
5871
end
5872
end

The propagators of the term g; false when it is not handled here

  Valid (1.2s) (colibri2 61) (split_vc) (depth 1)
5875
let
convert
(d: env) (g: ground) : bool
5876
= let r = node g in
5877
match view d g with
5878
| (FpBin o fm, Cons m (Cons a (Cons b Nil))) ->
5879
register d m; register d a; register d b;
5880
let p = mk_reg d (Bin o fm r m a b) in
5881
wait_value d g m p; wait_dom d g a p; wait_dom d g b p; wait_dom d g r p;
5882
let _ = run_reg d p in
5883
(* the rules on the sign and the magnitude *)
5884
let p = mk_reg d (Rule o fm r m a b) in
5885
wait_dom d g a p; wait_dom d g b p;
5886
let _ = run_reg d p in
5887
(* the relations between the arguments *)
5888
match o with
5889
| ODiv ->
5890
let p = mk_reg d (Rel o fm r m a b) in
5891
wait_dom d g b p; wait_dom d g r p; wait_rel d g a b p;
5892
let _ = run_reg d p in
5893
(* the monotonicity in the numerator *)
5894
let p = mk_reg d (Mono o fm r m a b false) in
5895
wait_dom d g b p; wait_mono d g p;
5896
let _ = run_reg d p in ()
5897
| OMul ->
5898
let p = mk_reg d (Mono o fm r m a b false) in
5899
wait_dom d g a p; wait_mono d g p;
5900
let _ = run_reg d p in
5901
let p = mk_reg d (Mono o fm r m a b true) in
5902
wait_dom d g b p; wait_mono d g p;
5903
let _ = run_reg d p in ()
5904
| OAdd -> ()
5905
end;
5906
true
5907
| (FpAdd fm, Cons m (Cons a (Cons b (Cons c (Cons t Nil))))) ->
5908
register d m; register d a; register d b;
5909
let p = mk_reg d (Bin OAdd fm r m a b) in
5910
wait_value d g m p; wait_dom d g a p; wait_dom d g b p; wait_dom d g r p;
5911
let _ = run_reg d p in
5912
let p = mk_reg d (Rule OAdd fm r m a b) in
5913
wait_dom d g a p; wait_dom d g b p;
5914
let _ = run_reg d p in
5915
let p = mk_reg d (Rel OAdd fm r m a b) in
5916
wait_dom d g a p; wait_dom d g b p; wait_dom d g r p; wait_rel d g a b p; wait_divs d g r p;
5917
let _ = run_reg d p in
5918
let p = mk_reg d (Mono OAdd fm r m a b false) in
5919
wait_mono d g p;
5920
let _ = run_reg d p in
5921
let p = mk_reg d (Mono OAdd fm r m a b true) in
5922
wait_mono d g p;
5923
let _ = run_reg d p in
5924
let p = mk_reg d (AddOpp fm r m a b) in
5925
wait_value d g m p; wait_negs d g a p; wait_negs d g b p;
5926
wait_repr d g a p; wait_repr d g b p;
5927
let _ = run_reg d p in
5928
(* `x + x` is `2 * x` *)
5929
let q = mk_reg d (AddSelf r a b t) in
5930
wait_repr d g a q; wait_repr d g b q;
5931
let _ = run_reg d q in
5932
true
5933
| (FpUn o fm, Cons m (Cons a Nil)) ->
5934
register d m; register d a;
5935
let p = mk_reg d (Un o fm r m a) in
5936
wait_value d g m p; wait_dom d g a p; wait_dom d g r p;
5937
let _ = run_reg d p in
5938
true
5939
| (FpCvt fm fm', Cons m (Cons a (Cons tr (Cons ta Nil)))) ->
5940
register d m; register d a;
5941
let p = mk_reg d (Cvt fm fm' r m a) in
5942
wait_value d g m p; wait_dom d g a p; wait_dom d g r p;
5943
let _ = run_reg d p in
5944
let p = mk_reg d (ExactCvt fm fm' r a tr ta) in
5945
wait_dom d g a p;
5946
let _ = run_reg d p in
5947
true
5948
| (FpOfBits fm back, Cons a Nil) ->
5949
register d a;
5950
let p = mk_reg d (OfBits fm r a back) in
5951
wait_rdom d g a p; if back then wait_dom d g r p;
5952
let _ = run_reg d p in
5953
true
5954
| (FpExactInt fm, Cons a (Cons t (Cons c Nil))) ->
5955
register d c; mergef d r c;
5956
register d a;
5957
let p = mk_reg d (ExactInt fm r a t) in
5958
wait_rdom d g a p; wait_ddom d g a p;
5959
let _ = run_reg d p in
5960
true
5961
| (FpToRealIn fm lo hi, Cons ri (Cons a Nil)) ->
5962
register d a; register d ri;
5963
let p = mk_reg d (ToRealIn fm ri a lo hi) in
5964
wait_dom d g a p; wait_rdom d g ri p;
5965
let _ = run_reg d p in
5966
true
5967
| (FpAbs fm, Cons a Nil) ->
5968
register d a;
5969
let p = mk_reg d (Abs fm r a) in
5970
wait_dom d g a p; wait_dom d g r p;
5971
let _ = run_reg d p in
5972
true
5973
| (FpNeg, Cons a Nil) ->
5974
register d a;
5975
let p = mk_reg d (Neg r a) in
5976
wait_dom d g a p; wait_dom d g r p;
5977
let _ = run_reg d p in
5978
let p = mk_reg d (NegInv r a) in
5979
wait_negs d g a p; wait_negs d g r p;
5980
let _ = run_reg d p in
5981
true
5982
| (FpChoice, Cons a (Cons b Nil)) ->
5983
register d a; register d b;
5984
let p = mk_reg d (Choice r a b) in
5985
wait_dom d g a p; wait_dom d g b p;
5986
let _ = run_reg d p in
5987
true
5988
| (FpCmp o fm, Cons a (Cons b Nil)) ->
5989
register d a; register d b;
5990
let p = mk_reg d (Cmp o fm r a b) in
5991
wait_bool d g r p; wait_dom d g a p; wait_dom d g b p;
5992
wait_rel d g a b p;
5993
let _ = run_reg d p in
5994
true
5995
| (FpIs o fm, Cons a Nil) ->
5996
register d a;
5997
let p = mk_reg d (Is o fm r a) in
5998
wait_bool d g r p; wait_dom d g a p;
5999
let _ = run_reg d p in
6000
true
6001
| (FpToReal fm, Cons a Nil) ->
6002
register d a;
6003
let p = mk_reg d (ToReal fm r a) in
6004
wait_dom d g a p; wait_rdom d g r p; wait_ddom d g r p;
6005
let _ = run_reg d p in
6006
true
6007
| (FpOfReal fm, Cons m (Cons a Nil)) ->
6008
register d m; register d a;
6009
let p = mk_reg d (OfReal fm r m a) in
6010
wait_value d g m p; wait_rdom d g a p; wait_dom d g r p;
6011
let _ = run_reg d p in
6012
true
6013
| (RealBin o, Cons a (Cons b Nil)) ->
6014
register d a; register d b;
6015
let p = mk_reg d (RBin o r a b) in
6016
wait_ddom d g a p; wait_ddom d g b p; wait_ddom d g r p;
6017
let ns = Cons a (Cons b (Cons r Nil)) in
6018
wait_rdom_dy d g a ns p; wait_rdom_dy d g b ns p; wait_rdom_dy d g r ns p;
6019
let _ = run_reg d p in
6020
true
6021
| (RealNeg, Cons a Nil) ->
6022
register d a;
6023
let p = mk_reg d (RNeg r a) in
6024
wait_ddom d g a p; wait_ddom d g r p;
6025
let ns = Cons a (Cons r Nil) in
6026
wait_rdom_dy d g a ns p; wait_rdom_dy d g r ns p;
6027
let _ = run_reg d p in
6028
true
6029
| (FpRw, Cons t Nil) ->
6030
register d t; mergef d r t;
6031
true
6032
| _ -> false
6033
end
6034
end