ensures { forall v: vars. interp result v = interp a v + interp b v }
ensures { result = add_f a b }
raises { Unknown -> true }
val mul (a b: t) : t
ensures { forall v: vars. interp result v = interp a v * interp b v }
ensures { result = mul_f a b }
val opp (a:t) : t
ensures { forall v: vars. interp result v = - (interp a v) }
ensures { result = opp_f a }
val predicate eq (a b:t)
ensures { result <-> forall y:vars. interp a y = interp b y }
...
...
@@ -47,37 +46,40 @@ val solve (a b:t) : t
*)
val inv (a:t) : t
requires { not (eq a zero) }
ensures { mul_f result a = one }
ensures { not (eq result zero) }
requires { not (eq a czero) }
ensures { forall v: vars. interp result v * interp a v = one }
ensures { not (eq result czero) }
raises { Unknown -> true }
val le (a b:t) : bool
ensures { result <-> a <= b }
ensures { result -> forall y:vars. Int.(<=) (interp a y) (interp b y) }
ensures { result -> forall y:vars. Real.(<=) (interp a y) (interp b y) }
raises { Unknown -> true }
clone export algebra.OrderedField with type t, function (+) = add_f, function (-_) = opp_f, function ( *) = mul_f, function inv = inv_f, constant zero = zero, constant one = one, predicate (<=) = (<=)
(*FIXME equality test ? *)
(*
clone export algebra.OrderedField with type t, function (+) = add_f, function (-_) = opp_f, function (*) = mul_f, function inv = inv_f, constant zero = zero, constant one = one, predicate (<=) = (<=)
*)
(*FIXME equality test, extensionality, specs for le and eq ? *)
end
module LinearEquationsDecision
use import int.Int
use import real.RealInfix
type coeff
clone LinearEquationsCoeffs as C with type t = coeff
type var = int
type expr = Term coeff var | Add expr expr | Cst coeff
type expr = Term coeff int | Add expr expr | Cst coeff | UTerm int
let rec predicate valid_expr (e:expr)
variant { e }
= match e with
| Term _ i -> 0 <= i
| Term _ i | UTerm i -> 0 <= i
| Cst _ -> true
| Add e1 e2 -> valid_expr e1 && valid_expr e2
end
...
...
@@ -85,17 +87,18 @@ let rec predicate valid_expr (e:expr)
let rec predicate expr_bound (e:expr) (b:int)
variant { e }
= match e with
| Term _ i -> 0 <= i <= b
| Term _ i | UTerm i -> 0 <= i <= b
| Cst _ -> true
| Add e1 e2 -> expr_bound e1 b && expr_bound e2 b
end
type vars = var -> int
type vars = int -> real
function interp (e:expr) (y: vars) (z:C.vars) : int
function interp (e:expr) (y: vars) (z:C.vars) : real
(* forall eq in list interp_eq est vraie -> interp_eq (toute combinaison linéaire) est vraie *)
end
module RealCoeffs
use export real.Real
type vars = int -> real
let constant rzero = 0.0
let constant rone = 1.0
function interp (r:real) (v:vars) : real = r
let radd a b = a+b
let rmul a b = a*b
let ropp a = - a
let predicate req a b = a=b
let rinv a
requires { a <> rzero }
ensures { result = rone/a }
= rone/a
let rle a b = a <= b
clone export LinearEquationsCoeffs with type t = real, type vars = vars, function interp,val czero=rzero, val cone=rone, lemma zero_def, lemma one_def, val add=radd, val mul=rmul, val opp=ropp, val eq=req, val inv=rinv, lemma eq_def, predicate (<=), val le=rle
end
module LinearDecisionReal
use import RealCoeffs
clone export LinearEquationsDecision with type coeff = real, type C.vars = vars, function C.interp=interp, val C.czero=rzero, val C.cone=rone, lemma C.zero_def, lemma C.one_def, val C.add=radd, val C.mul=rmul, val C.opp=ropp, val C.eq=req, val C.inv=rinv, lemma C.eq_def, predicate C.(<=)=(<=), val C.le=rle
end
module RationalCoeffs
use import int.Int
use import real.RealInfix
use import real.FromInt
use import int.Abs
meta coercion function from_int
type t = (int, int)
type rvars = int -> real
function of_int (n:int) : t = (n,1)
(*meta coercion function of_int*)
let constant rzero = (0,1)
let constant rone = (1,1)
function rinterp (t:t) (v:rvars) : real
= match t with
| (n,d) -> from_int n /. from_int d
end
use import int.ComputerDivision
use import ref.Ref
use import number.Gcd
let gcd (x:int) (y:int)
requires { x >= 0 /\ y >= 0 }
ensures { result = gcd x y }
=
let x = ref x in let y = ref y in
label Pre in
while (!y > 0) do
invariant { !x >= 0 /\ !y >= 0 }
invariant { gcd !x !y = gcd (!x at Pre) (!y at Pre) }
variant { !y }
let r = mod !x !y in let ghost q = div !x !y in
assert { r = !x - q * !y };
x := !y; y := r;
done;
!x
let simp (t:t) : t
ensures { forall v:rvars. rinterp result v = rinterp t v }
