Common — library colibrilib.product — module Export

What OCaml calls: the contracts of Prod and Solve; none has a requires

1422
module Export
1423
use int.Int
1424
use mach.int.Int63
1425
use real.RealInfix
1426
use real.Abs
1427
use list.List
1428
use option.Option
1429
use colibrilib.ring.Atom
1430
use colibrilib.stdq.StdQ as Q
1431
use colibrilib.stda.StdA as A
1432
use Apow
1433
use QAssoc
1434
use PT
1435
use APow
1436
use Prod
1437
use Solve
1438
use colibrilib.spec.Sound
1439
use colibrilib.spec.Eval
1440
use colibrilib.spec.EvalOn
1441
use colibrilib.spec.Test
1442
use colibrilib.spec.Opt
1443
Valid (20ms) (colibri2)
1444
let partial
classify
(p:t) : kind
1445
ensures { match result with
1446
| CST c -> bindings p.poly = Nil /\ c = p.cst
1447
| NODE c x -> c = p.cst /\ denotes0 value (fun env -> A.real c *. abs (env x)) p
1448
/\ total p
1449
| PRODUCT -> true
1450
end }
1451
= Prod.classify p
1452
Valid (32ms) (colibri2)
1453
let
common
(p1 p2:t) : t
1454
ensures { A.real result.cst = 1.0 }
1455
ensures { forall k. mem k result -> mem k p1 /\ mem k p2
1456
/\ exp k result = exp k p1 /\ exp k result = exp k p2 }
1457
= Prod.common p1 p2
1458
Valid (24ms) (colibri2)
1459
let
const
(c:A.t) : t
1460
ensures { denotes0 value (fun _ -> abs (A.real c)) result /\ total result }
1461
ensures { forall k. not mem k result }
1462
= Prod.const c
1463
Valid (35ms) (colibri2)
1464
let
div
(p1 p2:t) : t
1465
ensures { denotes2_on (ok_div p1 p2) value (/.) p1 p2 result }
1466
ensures { includes valid (ok_div p1 p2) result }
1467
ensures { forall k. mem k result -> mem k p1 \/ mem k p2 }
1468
ensures { A.real p1.cst <> 0.0 -> forall k. exp k result = exp k p1 -. exp k p2 }
1469
ensures { A.real p1.cst <> 0.0 -> A.real result.cst <> 0.0 }
1470
raises { DivZero -> A.real p2.cst = 0.0 }
1471
= Prod.div p1 p2
1472
Valid (34ms) (colibri2)
1473
let
extract
(p:t) : extracted
1474
ensures { match result with
1475
| One -> bindings p.poly = Nil /\ A.real p.cst = 1.0
1476
| Cst c -> bindings p.poly = Nil /\ c = p.cst /\ A.real c <> 1.0
1477
| Var q x r -> exp x p = Q.real q /\ Q.real q <> 0.0 /\ r.cst = p.cst
1478
/\ exact mem (fun k -> mem k p /\ k <> x) r
1479
/\ denotes0 value (fun env -> apow (env x) (Q.real q) *. eval env r) p
1480
/\ includes valid (ok1 p) r
1481
end }
1482
= Prod.extract p
1483
Valid (28ms) (colibri2)
1484
let
filter
(f: Atom.t -> bool) (p:t) : t
1485
ensures { result.cst = p.cst }
1486
ensures { forall k. get k result.poly = if f k then get k p.poly else None }
1487
= Prod.filter f p
1488
Valid (19ms) (colibri2)
1489
let partial
is_one_node
(p:t) : option Atom.t
1490
ensures { when_some (is_abs_node p) result }
1491
= Prod.is_one_node p
1492
Valid (34ms) (colibri2)
1493
let
is_zero
(p:t) : bool
1494
ensures { decides (A.real p.cst = 0.0) result }
1495
ensures { result -> forall env. eval env p = 0.0 }
1496
= Prod.is_zero p
1497
Valid (28ms) (colibri2)
1498
let
monome
(x:Atom.t) (c:Q.t) : t
1499
ensures { denotes0 value (fun env -> apow (env x) (Q.real c)) result }
1500
ensures { exact valid (fun env -> Q.real c <. 0.0 -> env x <> 0.0) result }
1501
ensures { forall k. mem k result -> k = x }
1502
= Prod.monome x c
1503
Valid (29ms) (colibri2)
1504
let
mul
(p1 p2:t) : t
1505
ensures { denotes2_on (ok2 p1 p2) value (*.) p1 p2 result }
1506
ensures { includes valid (ok2 p1 p2) result }
1507
ensures { forall k. mem k result -> mem k p1 \/ mem k p2 }
1508
= Prod.mul p1 p2
1509
Valid (21ms) (colibri2)
1510
let
normalize
(p:t) (f: Atom.t -> t) : t
1511
ensures { denotes1_on (ok_normalize p f) value (fun v -> v) p result }
1512
ensures { includes valid (ok_normalize p f) result }
1513
raises { DivZero -> exists k. exp k p <. 0.0 /\ A.real (f k).cst = 0.0 }
1514
= Prod.normalize p f
1515
Valid (23ms) (colibri2)
1516
let
of_list
(c:A.t) (l:list binding) : t
1517
ensures { denotes0_on (lvalid_at l) value (fun env -> abs (A.real c) *. evp env l) result }
1518
ensures { includes valid (lvalid_at l) result }
1519
= Prod.of_list c l
1520
Valid (22ms) (colibri2)
1521
let
one
() : t
1522
ensures { denotes0 value (fun _ -> 1.0) result /\ total result }
1523
ensures { forall k. not mem k result }
1524
= Prod.one ()
1525
Valid (23ms) (colibri2)
1526
let
power_cst
(c:Q.t) (p:t) : t
1527
ensures { denotes1_on (ok_pow c p) value (fun v -> apow v (Q.real c)) p result }
1528
ensures { includes valid (ok_pow c p) result }
1529
ensures { forall k. mem k result -> mem k p }
1530
ensures { A.real p.cst <> 0.0 -> forall k. exp k result = Q.real c *. exp k p }
1531
raises { DivZero -> Q.real c <. 0.0 /\ A.real p.cst = 0.0 }
1532
= Prod.power_cst c p
1533
Valid (30ms) (colibri2)
1534
let
remove
(n:Atom.t) (p:t) : t
1535
ensures { denotes0 value (fun env -> apow (env n) (exp n p) *. eval env result) p }
1536
ensures { includes valid (ok1 p) result }
1537
ensures { exact mem (fun k -> mem k p /\ k <> n) result }
1538
ensures { forall k. k <> n -> exp k result = exp k p }
1539
ensures { result.cst = p.cst }
1540
= Prod.remove n p
1541
Valid (29ms) (colibri2)
1542
let partial
solve
(unk1:PT.t) (p1:t) (unk2:PT.t) (p2:t) : solved
1543
ensures { solves (fun env -> hyp env unk1 p1 /\ hyp env unk2 p2)
1544
(fun env -> eval env p1 = eval env p2) result }
1545
= Solve.solve unk1 p1 unk2 p2
1546
Valid (26ms) (colibri2)
1547
let
subst
(p:t) (x:Atom.t) (s:t) : option t
1548
ensures { match result with
1549
| None -> not mem x p
1550
| Some r -> mem x p
1551
/\ (forall k. mem k r -> (mem k p /\ k <> x) \/ mem k s)
1552
/\ denotes1_on (ok_subst p x s) value (fun v -> v) p r
1553
/\ includes valid (ok_subst p x s) r
1554
end }
1555
raises { DivZero -> exp x p <. 0.0 /\ A.real s.cst = 0.0 }
1556
= Prod.subst p x s
1557
Valid (19ms) (colibri2)
1558
let
x_m_yc
(p1 p2:t) (c:Q.t) : t
1559
ensures { denotes2_on (ok_mul_pow p1 p2 c) value (fun x y -> x *. apow y (Q.real c)) p1 p2 result }
1560
ensures { includes valid (ok_mul_pow p1 p2 c) result }
1561
ensures { forall k. mem k result -> mem k p1 \/ mem k p2 }
1562
raises { DivZero -> Q.real c <. 0.0 /\ A.real p2.cst = 0.0 }
1563
= Prod.x_m_yc p1 p2 c
1564
Valid (18ms) (colibri2)
1565
let
zero
() : t
1566
ensures { denotes0 value (fun _ -> 0.0) result /\ total result }
1567
ensures { forall k. not mem k result }
1568
= Prod.zero ()
1569
end