Common — library colibrilib.polynome — module Export

What OCaml calls: the contracts of Lin and ModRw, and reduce_cst defensive

905
module Export
906
use int.Int
907
use real.RealInfix
908
use real.Abs
909
use real.FromInt
910
use list.List
911
use option.Option
912
use mach.int.Int63
913
use colibrilib.ring.Atom
914
use colibrilib.stda.StdA as A
915
use colibrilib.q.Real as Real
916
use Assoc
917
use PT
918
use Lin
919
use ModRw
920
use colibrilib.spec.Sound
921
use colibrilib.spec.Eval
922
use colibrilib.spec.EvalOn
923
use colibrilib.spec.Value
924
use colibrilib.spec.Test
925
use colibrilib.spec.Opt
926
Valid (27ms) (colibri2)
927
let
add
(p1 p2:t) : t
928
ensures { denotes2 value (+.) p1 p2 result }
929
= Lin.add p1 p2
930
Valid (28ms) (colibri2)
931
let
add_cst
(p:t) (c:A.t) : t
932
ensures { denotes1 value (fun v -> v +. A.real c) p result }
933
= Lin.add_cst p c
934
Valid (23ms) (colibri2)
935
let
atoms
(p:t) : list binding
936
ensures { value_is (bindings p.poly) result }
937
= Lin.atoms p
938
Valid (26ms) (colibri2)
939
let
classify
(p:t) : kind
940
ensures { match result with
941
| ZERO -> bindings p.poly = Nil /\ A.real p.cst = 0.0
942
| CST -> bindings p.poly = Nil /\ A.real p.cst <> 0.0
943
| VAR -> bindings p.poly <> Nil
944
end }
945
= Lin.classify p
946
Valid (28ms) (colibri2)
947
let
const
(c:A.t) : t
948
ensures { denotes0 value (fun _ -> A.real c) result }
949
= Lin.const c
950
Valid (28ms) (colibri2)
951
let
cx_p_cy
(c1:A.t) (p1:t) (c2:A.t) (p2:t) : t
952
ensures { denotes2 value (fun x y -> A.real c1 *. x +. A.real c2 *. y) p1 p2 result }
953
= Lin.cx_p_cy c1 p1 c2 p2
954
Valid (27ms) (colibri2)
955
let
is_cst
(p:t) : option A.t
956
ensures { match result with
957
| Some c -> bindings p.poly = Nil /\ c = p.cst
958
| None -> bindings p.poly <> Nil
959
end }
960
= Lin.is_cst p
961
Valid (28ms) (colibri2)
962
let
is_one_node
(p:t) : option Atom.t
963
ensures { when_some (is_node p) result }
964
= Lin.is_one_node p
965
Valid (25ms) (colibri2)
966
let
is_pm_node
(p:t) : option Atom.t
967
ensures { when_some (is_abs_node p) result }
968
= Lin.is_pm_node p
969
Valid (18ms) (colibri2)
970
let
is_zero
(p:t) : bool
971
ensures { decides (bindings p.poly = Nil /\ A.real p.cst = 0.0) result }
972
= Lin.is_zero p
973
Valid (26ms) (colibri2)
974
let
monome
(c:A.t) (x:Atom.t) : t
975
ensures { denotes0 value (fun env -> A.real c *. env x) result }
976
= Lin.monome c x
977
Valid (33ms) (colibri2)
978
let
mult_cst
(c:A.t) (p:t) : t
979
ensures { denotes1 value (fun v -> A.real c *. v) p result }
980
= Lin.mult_cst c p
981
Valid (30ms) (colibri2)
982
let
neg
(p:t) : t
983
ensures { denotes1 value (fun v -> -. v) p result }
984
= Lin.neg p
985
Valid (26ms) (colibri2)
986
let
of_list
(c:A.t) (l:list binding) : t
987
ensures { denotes0 value (fun env -> A.real c +. evall env l) result }
988
= Lin.of_list c l
989
Valid (20ms) (colibri2)
990
let
reduce_node
(p:t) (y:Atom.t) : t
991
ensures { same_rem_node y p result }
992
ensures { bindings result.poly = Nil -> A.real result.cst = 0.0 ->
993
forall env d. d <> 0.0 -> abs d = abs (env y) -> Real.mod_e (eval env p) d = 0.0 }
994
= ModRw.reduce_node p y
995
Valid (30ms) (colibri2)
996
let
sub
(p1 p2:t) : t
997
ensures { denotes2 value (-.) p1 p2 result }
998
= Lin.sub p1 p2
999
Valid (27ms) (colibri2)
1000
let
sub_cst
(p:t) (c:A.t) : t
1001
ensures { denotes1 value (fun v -> v -. A.real c) p result }
1002
= Lin.sub_cst p c
1003
Valid (28ms) (colibri2)
1004
let
subst
(p:t) (x:Atom.t) (s:t) : (t, A.t)
1005
returns { (r, q) -> A.real q = coef x p
1006
/\ denotes0 value (fun env -> eval env p +. A.real q *. (eval env s -. env x)) r }
1007
= Lin.subst p x s
1008
Valid (21ms) (colibri2)
1009
let
subst_node
(p:t) (x y:Atom.t) : (t, A.t)
1010
returns { (r, q) -> A.real q = coef x p
1011
/\ denotes0 value (fun env -> eval env p +. A.real q *. (env y -. env x)) r }
1012
= Lin.subst_node p x y
1013
Valid (34ms) (colibri2)
1014
let
x_p_cy
(p1:t) (c:A.t) (p2:t) : t
1015
ensures { denotes2 value (fun x y -> x +. A.real c *. y) p1 p2 result }
1016
= Lin.x_p_cy p1 c p2
1017
Valid (24ms) (colibri2)
1018
let
zero
() : t
1019
ensures { denotes0 value (fun _ -> 0.0) result }
1020
= Lin.zero ()
1021
Valid (24ms) (colibri2)
1022
let
extract
(p:t) : extract
1023
ensures { match result with
1024
| Zero -> bindings p.poly = Nil /\ A.real p.cst = 0.0
1025
| Cst c -> bindings p.poly = Nil /\ c = p.cst /\ A.real c <> 0.0
1026
| Var q x p' -> get x p.poly = Some q /\ not (has x (bindings p'.poly))
1027
/\ denotes0 value (fun env -> A.real q *. env x +. eval env p') p
1028
end }
1029
= Lin.extract p

Raised by reduce_cst for a zero divisor

1032
exception
ZeroDiv
1033
Valid (35ms) (colibri2)
1034
let
reduce_cst
(p:t) (m:A.t) : t
1035
ensures { A.real m <> 0.0 }
1036
ensures { 0.0 <=. A.real result.cst <. abs (A.real m) }
1037
ensures { forall k v. get k result.poly = Some v ->
1038
0.0 <=. A.real v <. abs (A.real m) }
1039
ensures { forall k. has k (bindings result.poly) -> has k (bindings p.poly) }
1040
ensures { same_on (integer_atoms p) (fun v -> Real.mod_e v (A.real m)) value p result }
1041
ensures { bindings result.poly = Nil ->
1042
forall env. integer_atoms p env ->
1043
Real.mod_e (eval env p) (A.real m) = A.real result.cst }
1044
raises { ZeroDiv -> A.real m = 0.0 }
1045
= if A.equal m (A.of_int 0) then raise ZeroDiv else ModRw.reduce_cst p m
1046
end