From e55e1d35222725807ca2ee8093fec68f92acd7ff Mon Sep 17 00:00:00 2001 From: Raphael Rieu-Helft Date: Tue, 5 Jun 2018 16:53:45 +0200 Subject: [PATCH] Add schoolbook GMP functions to examples and bench --- bench/bench | 3 +- examples/multiprecision/add.mlw | 548 + examples/multiprecision/add/why3session.xml | 1307 ++ examples/multiprecision/add/why3shapes.gz | Bin 0 -> 15032 bytes examples/multiprecision/compare.mlw | 87 + .../multiprecision/compare/why3session.xml | 147 + examples/multiprecision/compare/why3shapes.gz | Bin 0 -> 2057 bytes examples/multiprecision/div.mlw | 4433 +++++++ examples/multiprecision/div/why3session.xml | 10635 ++++++++++++++++ examples/multiprecision/div/why3shapes.gz | Bin 0 -> 118256 bytes examples/multiprecision/lemmas.mlw | 207 + .../multiprecision/lemmas/why3session.xml | 272 + examples/multiprecision/lemmas/why3shapes.gz | Bin 0 -> 3300 bytes examples/multiprecision/lineardecision.mlw | 2105 +++ .../lineardecision/why3session.xml | 4352 +++++++ .../lineardecision/why3shapes.gz | Bin 0 -> 55540 bytes examples/multiprecision/logical.mlw | 389 + .../multiprecision/logical/why3session.xml | 899 ++ examples/multiprecision/logical/why3shapes.gz | Bin 0 -> 10701 bytes examples/multiprecision/mul.mlw | 601 + examples/multiprecision/mul/why3session.xml | 1471 +++ examples/multiprecision/mul/why3shapes.gz | Bin 0 -> 15958 bytes examples/multiprecision/sub.mlw | 546 + examples/multiprecision/sub/why3session.xml | 1261 ++ examples/multiprecision/sub/why3shapes.gz | Bin 0 -> 14208 bytes examples/multiprecision/types.mlw | 14 + examples/multiprecision/types/why3session.xml | 7 + examples/multiprecision/types/why3shapes.gz | Bin 0 -> 20 bytes examples/multiprecision/util.mlw | 65 + examples/multiprecision/util/why3session.xml | 172 + examples/multiprecision/util/why3shapes.gz | Bin 0 -> 1708 bytes examples/multiprecision/wmpn.mlw | 13 + examples/multiprecision/wmpn/why3session.xml | 7 + examples/multiprecision/wmpn/why3shapes.gz | Bin 0 -> 20 bytes 34 files changed, 29540 insertions(+), 1 deletion(-) create mode 100644 examples/multiprecision/add.mlw create mode 100644 examples/multiprecision/add/why3session.xml create mode 100644 examples/multiprecision/add/why3shapes.gz create mode 100644 examples/multiprecision/compare.mlw create mode 100644 examples/multiprecision/compare/why3session.xml create mode 100644 examples/multiprecision/compare/why3shapes.gz create mode 100644 examples/multiprecision/div.mlw create mode 100644 examples/multiprecision/div/why3session.xml create mode 100644 examples/multiprecision/div/why3shapes.gz create mode 100644 examples/multiprecision/lemmas.mlw create mode 100644 examples/multiprecision/lemmas/why3session.xml create mode 100644 examples/multiprecision/lemmas/why3shapes.gz create mode 100644 examples/multiprecision/lineardecision.mlw create mode 100644 examples/multiprecision/lineardecision/why3session.xml create mode 100644 examples/multiprecision/lineardecision/why3shapes.gz create mode 100644 examples/multiprecision/logical.mlw create mode 100644 examples/multiprecision/logical/why3session.xml create mode 100644 examples/multiprecision/logical/why3shapes.gz create mode 100644 examples/multiprecision/mul.mlw create mode 100644 examples/multiprecision/mul/why3session.xml create mode 100644 examples/multiprecision/mul/why3shapes.gz create mode 100644 examples/multiprecision/sub.mlw create mode 100644 examples/multiprecision/sub/why3session.xml create mode 100644 examples/multiprecision/sub/why3shapes.gz create mode 100644 examples/multiprecision/types.mlw create mode 100644 examples/multiprecision/types/why3session.xml create mode 100644 examples/multiprecision/types/why3shapes.gz create mode 100644 examples/multiprecision/util.mlw create mode 100644 examples/multiprecision/util/why3session.xml create mode 100644 examples/multiprecision/util/why3shapes.gz create mode 100644 examples/multiprecision/wmpn.mlw create mode 100644 examples/multiprecision/wmpn/why3session.xml create mode 100644 examples/multiprecision/wmpn/why3shapes.gz diff --git a/bench/bench b/bench/bench index 8c3b007e7..07e4a113e 100755 --- a/bench/bench +++ b/bench/bench @@ -269,8 +269,8 @@ goods examples/avl "-L examples/avl" goods examples/verifythis_2016_matrix_multiplication "-L examples/verifythis_2016_matrix_multiplication" goods examples/double_wp "-L examples/double_wp" goods examples/ring_decision "-L examples/ring_decision" +goods examples/multiprecision "-L examples/multiprecision" goods examples/in_progress -goods examples/in_progress/multiprecision "-L examples/in_progress/multiprecision" echo "" echo "=== Checking replay (no prover) ===" @@ -290,6 +290,7 @@ replay examples/avl "-L examples/avl --merging-only" #replay examples/to_port/verifythis_2016_matrix_multiplication "-L examples/to_port/verifythis_2016_matrix_multiplication --merging-only" replay examples/double_wp "-L examples/double_wp --merging-only" replay examples/ring_decision "-L examples/ring_decision --merging-only" +replay examples/multiprecision "-L examples/multiprecision --merging-only" #replay examples/in_progress --merging-only #replay examples/in_progress/multiprecision "-L examples/in_progress/multiprecision --merging-only" echo "" diff --git a/examples/multiprecision/add.mlw b/examples/multiprecision/add.mlw new file mode 100644 index 000000000..57f19fe3e --- /dev/null +++ b/examples/multiprecision/add.mlw @@ -0,0 +1,548 @@ +module Add + + use import int.Int + use import mach.int.Int32 + use import mach.int.UInt64GMP as Limb + use import int.Power + use import ref.Ref + use import mach.c.C + use import array.Array + use import map.Map + use import types.Types + use import lemmas.Lemmas + + (** [add_limb r x y sz] adds to [x] the value of the limb [y], + writes the result in [r] and returns the carry. [r] and [x] + have size [sz]. This corresponds to the function [mpn_add_1] *) + (* r and x must be separated. This is enforced by Why3 regions in typing *) + let add_limb (r x:t) (y:limb) (sz:int32) : limb + requires { valid x sz } + requires { valid r sz } + requires { sz > 0 } (* ? GMP does the same for 0 and 1*) + ensures { value r sz + (power radix sz) * result = + value x sz + y } + ensures { 0 <= result <= 1 } + ensures { forall j. (j < offset r \/ offset r + sz <= j) + -> (pelts r)[j] = old (pelts r)[j] } + writes { r.data.elts } + = + let limb_zero = Limb.of_int 0 in + let c = ref y in + let lx = ref limb_zero in + let i = ref (Int32.of_int 0) in + while Int32.(<) !i sz && (not (Limb.(=) !c limb_zero)) do + invariant { 0 <= !i <= sz } + invariant { !i > 0 -> 0 <= !c <= 1 } + invariant { value r !i + (power radix !i) * !c = + value x !i + y } + invariant { forall j. (j < offset r \/ offset r + sz <= j) + -> (pelts r)[j] = old (pelts r)[j] } + variant { sz - !i } + label StartLoop in + lx := get_ofs x !i; + let (res, carry) = add_with_carry !lx !c limb_zero in + set_ofs r !i res; + assert { value r !i + (power radix !i) * !c = + value x !i + y }; + c := carry; + value_tail r !i; + value_tail x !i; + assert { value r (!i+1) + (power radix (!i+1)) * !c + = value x (!i+1) + y + (* by + value r !i + (power radix !i) * !c + = value r k + (power radix k) * res + + (power radix !i) * !c + = value r k + (power radix k) * res + + (power radix k) * radix * !c + = value r k + (power radix k) * (res + radix * !c) + = value r k + + (power radix k) * (!lx + (!c at StartLoop)) + = value r k + (power radix k) * (!c at StartLoop) + + (power radix k) * !lx + = value x k + y + (power radix k) * !lx + = value x !i + y*) }; + i := Int32.(+) !i (Int32.of_int 1); + done; + if Int32.(=) !i sz then !c + else begin + while Int32.(<) !i sz do + invariant { !c = 0 } + invariant { 0 <= !i <= sz } + invariant { value r !i + (power radix !i) * !c = + value x !i + y } + invariant { forall j. (j < offset r \/ offset r + sz <= j) + -> (pelts r)[j] = old (pelts r)[j] } + variant { sz - !i } + lx := get_ofs x !i; + set_ofs r !i !lx; + assert { value r !i + (power radix !i) * !c = + value x !i + y }; + let ghost k = p2i !i in + i := Int32.(+) !i (Int32.of_int 1); + value_sub_tail (pelts r) r.offset (r.offset + k); + value_sub_tail (pelts x) x.offset (x.offset + k); + done; + !c + end + + + (** [add_limbs r x y sz] adds [x[0..sz-1]] and [y[0..sz-1]] and writes the result in [r]. + Returns the carry, either [0] or [1]. Corresponds to the function [mpn_add_n]. *) + + let add_limbs (r x y:t) (sz:int32) : limb + requires { valid x sz } + requires { valid y sz } + requires { valid r sz } + ensures { 0 <= result <= 1 } + ensures { value r sz + (power radix sz) * result = + value x sz + value y sz } + ensures { forall j. (j < offset r \/ offset r + sz <= j) + -> (pelts r)[j] = old (pelts r)[j] } + writes { r.data.elts } + = + let limb_zero = Limb.of_int 0 in + let lx = ref limb_zero in + let ly = ref limb_zero in + let c = ref limb_zero in + let i = ref (Int32.of_int 0) in + while Int32.(<) !i sz do + variant { sz - !i } + invariant { 0 <= !i <= sz } + invariant { value r !i + (power radix !i) * !c = + value x !i + value y !i } + invariant { 0 <= !c <= 1 } + invariant { forall j. (j < offset r \/ offset r + sz <= j) + -> (pelts r)[j] = old (pelts r)[j] } + label StartLoop in + lx := get_ofs x !i; + ly := get_ofs y !i; + let res, carry = add_with_carry !lx !ly !c in + set_ofs r !i res; + assert { value r !i + (power radix !i) * !c = + value x !i + value y !i + by value r !i = (value r !i at StartLoop) }; + c := carry; + value_tail r !i; + value_tail x !i; + value_tail y !i; + assert { value r (!i+1) + (power radix (!i+1)) * !c = + value x (!i+1) + value y (!i+1) + (*by + value r !i + (power radix !i) * !c + = value r k + (power radix k) * res + + (power radix !i) * !c + = value r k + (power radix k) * res + + (power radix k) * radix * !c + = value r k + (power radix k) * (res + radix * !c) + = value r k + + (power radix k) * (!lx + !ly + (!c at StartLoop)) + = value r k + (power radix k) * (!c at StartLoop) + + (power radix k) * (!lx + !ly) + = value x k + value y k + + (power radix k) * (!lx + !ly) + = value x k + (power radix k) * !lx + + value y k + (power radix k) * !ly + = value x !i + + value y k + (power radix k) * !ly + = value x !i + + (value y k + (power radix k) * !ly) + = value x !i + value y !i*) }; + i := Int32.(+) !i (Int32.of_int 1); + done; + !c + + (** [add r x y sx sy] adds [(x, sx)] to [(y,sy)] and writes the + result in [(r, sx)]. [sx] must be greater than or equal to + [sy]. Returns carry, either 0 or 1. Corresponds to [mpn_add]. *) + let add (r x y:t) (sx sy:int32) : limb + requires { 0 <= sy <= sx } + requires { valid x sx } + requires { valid y sy } + requires { valid r sx } + ensures { value r sx + (power radix sx) * result = + value x sx + value y sy } + ensures { forall j. (j < offset r \/ offset r + sx <= j) + -> (pelts r)[j] = old (pelts r)[j] } + ensures { 0 <= result <= 1 } + writes { r.data.elts } + = + let limb_zero = Limb.of_int 0 in + let lx = ref limb_zero in + let ly = ref limb_zero in + let c = ref limb_zero in + let i = ref (Int32.of_int 0) in + while Int32.(<) !i sy do + variant { sy - !i } + invariant { 0 <= !i <= sy } + invariant { value r !i + (power radix !i) * !c = + value x !i + value y !i } + invariant { 0 <= !c <= 1 } + invariant { forall j. (j < offset r \/ offset r + sx <= j) + -> (pelts r)[j] = old (pelts r)[j] } + label StartLoop in + lx := get_ofs x !i; + ly := get_ofs y !i; + let res, carry = add_with_carry !lx !ly !c in + set_ofs r !i res; + assert { value r !i + (power radix !i) * !c = + value x !i + value y !i }; + c := carry; + value_tail r !i; + value_tail x !i; + value_tail y !i; + assert { value r (!i+1) + (power radix (!i+1)) * !c = + value x (!i+1) + value y (!i+1) + (*by + value r !i + (power radix !i) * !c + = value r k + (power radix k) * res + + (power radix !i) * !c + = value r k + (power radix k) * res + + (power radix k) * radix * !c + = value r k + (power radix k) * (res + radix * !c) + = value r k + + (power radix k) * (!lx + !ly + (!c at StartLoop)) + = value r k + (power radix k) * (!c at StartLoop) + + (power radix k) * (!lx + !ly) + = value x k + value y k + + (power radix k) * (!lx + !ly) + = value x k + (power radix k) * !lx + + value y k + (power radix k) * !ly + = value x !i + + value y k + (power radix k) * !ly + = value x !i + + (value y k + (power radix k) * !ly) + = value x !i + value y !i*) }; + i := Int32.(+) !i (Int32.of_int 1); + done; + try + begin while Int32.(<) !i sx do + variant { sx - !i } + invariant { sy <= !i <= sx } + invariant { value r !i + (power radix !i) * !c = + value x !i + value y sy } + invariant { 0 <= !c <= 1 } + invariant { forall j. (j < offset r \/ offset r + sx <= j) + -> (pelts r)[j] = old (pelts r)[j] } + (if (Limb.(=) !c (Limb.of_int 0)) then raise Break); + label StartLoop2 in + lx := get_ofs x !i; + let res, carry = add_with_carry !lx limb_zero !c in + set_ofs r !i res; + assert { value r !i + (power radix !i) * !c = + value x !i + value y sy }; + c := carry; + value_tail r !i; + value_tail x !i; + assert { value r (!i+1) + (power radix (!i+1)) * !c = + value x (!i+1) + value y sy + (*by + value r !i + (power radix !i) * !c + = value r k + (power radix k) * res + + (power radix !i) * !c + = value r k + (power radix k) * res + + (power radix k) * radix * !c + = value r k + (power radix k) * (res + radix * !c) + = value r k + + (power radix k) * (!lx + 0 + (!c at StartLoop2)) + = value r k + (power radix k) * (!c at StartLoop2) + + (power radix k) * !lx + = value x k + value y sy + + (power radix k) * !lx + = value x !i + + value y sy*) }; + i := Int32.(+) !i (Int32.of_int 1); + done; + assert { !i = sx } + end + with Break -> assert { !c = 0 } + end; + while Int32.(<) !i sx do + variant { sx - !i } + invariant { sy <= !i <= sx } + invariant { !i = sx \/ !c = 0 } + invariant { value r !i + power radix !i * !c = + value x !i + value y sy } + invariant { forall j. (j < offset r \/ offset r + sx <= j) + -> (pelts r)[j] = old (pelts r)[j] } + assert { !c = 0 by !i < sx }; + lx := get_ofs x !i; + set_ofs r !i !lx; + value_tail r !i; + value_tail x !i; + assert { value r !i = value x !i + value y sy }; (* true with this, should not be needed *) + assert { value r (!i+1) + power radix (!i+1) * !c + = value x (!i+1) + value y sy + (* + by + value r !i + power radix !i * !c + = value r !i + = value r k + power radix k * !lx + so value x !i + = value x k + power radix k * !lx + so value r k + = value r k + power radix k * !c + = value x k + value y sy*) }; + i := Int32.(+) !i (Int32.of_int 1); + done; + !c + + let add_in_place (x y:t) (sx sy:int32) : limb + requires { 0 <= sy <= sx } + requires { valid x sx } + requires { valid y sy } + ensures { value x sx + (power radix sx) * result + = value (old x) sx + value y sy } + ensures { 0 <= result <= 1 } + ensures { forall j. j < x.offset \/ x.offset + sx <= j -> + (pelts x)[j] = (pelts (old x))[j] } + writes { x.data.elts } + = + let ghost ox = { x } in + let limb_zero = Limb.of_int 0 in + let lx = ref limb_zero in + let ly = ref limb_zero in + let c = ref limb_zero in + let i = ref (Int32.of_int 0) in + while Int32.(<) !i sy do + variant { sy - !i } + invariant { 0 <= !i <= sy } + invariant { value x !i + (power radix !i) * !c = + value ox !i + value y !i } + invariant { 0 <= !c <= 1 } + invariant { forall j. !i <= j < sx -> + (pelts x)[x.offset + j] = (pelts ox)[x.offset + j] } + invariant { forall j. j < x.offset \/ x.offset + sx <= j -> + (pelts x)[j] = (pelts (old x))[j] } + label StartLoop in + lx := get_ofs x !i; + assert { !lx = (pelts ox)[ox.offset + !i] }; + ly := get_ofs y !i; + let res, carry = add_with_carry !lx !ly !c in + set_ofs x !i res; + assert { forall j. !i < j < sx -> + (pelts x)[x.offset + j] + = (pelts ox)[x.offset + j] + by (pelts x)[x.offset + j] + = (pelts (x at StartLoop))[x.offset + j] + = (pelts ox)[x.offset + j]}; + assert { value x !i + (power radix !i) * !c = value ox !i + value y !i }; + c := carry; + value_tail x !i; + value_tail ox !i; + value_tail y !i; + assert { value x (!i+1) + (power radix (!i+1)) * !c = + value ox (!i+1) + value y (!i+1) + (*by value ox k + (power radix k) * !lx + = value ox !i + so value x !i + (power radix !i) * !c + = value x k + (power radix k) * res + + (power radix !i) * !c + = value x k + (power radix k) * res + + (power radix k) * radix * !c + = value x k + (power radix k) * (res + radix * !c) + = value x k + + (power radix k) * (!lx + !ly + (!c at StartLoop)) + = value x k + (power radix k) * (!c at StartLoop) + + (power radix k) * (!lx + !ly) + = value ox k + value y k + + (power radix k) * (!lx + !ly) + = (value ox k + (power radix k) * !lx) + + (value y k + (power radix k) * !ly) + = value ox !i + + (value y k + (power radix k) * !ly) + = value ox !i + + (value y k + (power radix k) * !ly) + = value ox !i + value y !i*) }; + i := Int32.(+) !i (Int32.of_int 1); + done; + try + while Int32.(<) !i sx do + variant { sx - !i } + invariant { sy <= !i <= sx } + invariant { value x !i + (power radix !i) * !c = + value ox !i + value y sy } + invariant { 0 <= !c <= 1 } + invariant { forall j. !i <= j < sx -> + (pelts x)[x.offset + j] = (pelts ox) [x.offset + j] } + invariant { forall j. j < x.offset \/ x.offset + sx <= j -> + (pelts x)[j] = (pelts (old x))[j] } + (if (Limb.(=) !c limb_zero) then raise ReturnLimb limb_zero); + label StartLoop2 in + lx := get_ofs x !i; + assert { !lx = (pelts ox)[ox.offset + !i] }; + let res, carry = add_with_carry !lx limb_zero !c in + value_sub_update_no_change (pelts x) (x.offset + p2i !i) + (x.offset + p2i !i + 1) + (x.offset + p2i sx) res; + set_ofs x !i res; + assert { value x !i + (power radix !i) * !c = value ox !i + value y sy }; + c := carry; + assert { forall j. !i < j < sx -> + (pelts x)[x.offset + j] = (pelts ox) [x.offset + j] }; + value_tail ox !i; + value_tail x !i; + assert { value x (!i+1) + (power radix (!i+1)) * !c = + value ox (!i+1) + value y sy + (*by value ox k + (power radix k) * !lx + = value ox !i + so + value x !i + (power radix !i) * !c + = value x k + (power radix k) * res + + (power radix !i) * !c + = value x k + (power radix k) * res + + (power radix k) * radix * !c + = value x k + (power radix k) * (res + radix * !c) + = value x k + + (power radix k) * (!lx + 0 + (!c at StartLoop2)) + = value x k + (power radix k) * (!c at StartLoop2) + + (power radix k) * !lx + = value ox k + value y sy + + (power radix k) * !lx + = value ox !i + + value y sy*) }; + i := Int32.(+) !i (Int32.of_int 1); + done; + assert { !i = sx }; + !c + with ReturnLimb n -> begin + assert { n = 0 = !c }; + assert { forall j. x.offset + !i <= j < x.offset + sx + -> (pelts x)[j] = (pelts ox)[j] + by !i <= j - x.offset < sx + so (pelts x)[x.offset + (j - x.offset)] + = (pelts ox)[x.offset + (j - x.offset)] }; + value_sub_frame (pelts x) (pelts ox) (x.offset + p2i !i) (x.offset + p2i sx); + value_sub_concat (pelts x) x.offset (x.offset + p2i !i) (x.offset + p2i sx); + value_sub_concat (pelts ox) x.offset (x.offset + p2i !i) (x.offset + p2i sx); + assert { value x sx = value (old x) sx + value y sy }; + n + end + end + + use import int.EuclideanDivision + + (** [incr x y sz] adds to [x] the value of the limb [y] in place. + [x] has size [sz]. The addition must not overflow. This corresponds + to [mpn_incr] *) + let incr (x:t) (y:limb) (ghost sz:int32) : unit + requires { valid x sz } + requires { sz > 0 } + requires { value x sz + y < power radix sz } + ensures { value x sz = value (old x) sz + y } + ensures { forall j. j < x.offset \/ x.offset + sz <= j -> + (pelts x)[j] = (pelts (old x))[j] } + writes { x.data.elts } + = + let ghost ox = { x } in + let c = ref y in + let lx : ref limb = ref 0 in + let i : ref int32 = ref 0 in + while not (Limb.(=) !c 0) do + invariant { 0 <= !i <= sz } + invariant { !i = sz -> !c = 0 } + invariant { !i > 0 -> 0 <= !c <= 1 } + invariant { value x !i + (power radix !i) * !c + = value ox !i + y } + invariant { forall j. !i <= j < sz -> + (pelts x)[x.offset + j] = (pelts ox)[x.offset + j] } + invariant { forall j. j < x.offset \/ x.offset + sz <= j -> + (pelts x)[j] = (pelts ox)[j] } + variant { sz - !i } + label StartLoop in + lx := get_ofs x !i; + assert { !lx = (pelts ox)[ox.offset + !i] }; + let (res, carry) = add_with_carry !lx !c 0 in (*TODO*) + assert { res + radix * carry = !lx + !c }; (* TODO remove this *) + value_sub_update_no_change (pelts x) (x.offset + p2i !i) + (x.offset + p2i !i + 1) + (x.offset + p2i sz) res; + set_ofs x !i res; + assert { forall j. !i < j < sz -> + (pelts x)[x.offset + j] + = (pelts ox)[x.offset + j] }; + assert { value x !i + (power radix !i) * !c = value ox !i + y }; + c := carry; + value_tail x !i; + value_tail ox !i; + assert { value x (!i+1) + power radix (!i+1) * !c = + value ox (!i+1) + y }; + i := Int32.(+) !i 1; + assert { !i = sz -> !c = 0 + by value x sz + power radix sz * !c = value ox sz + y + so value ox sz + y < power radix sz + so 0 <= !c <= 1}; + done; + value_concat x !i sz; + value_concat ox !i sz; + assert { forall j. x.offset + !i <= j < x.offset + sz -> + (pelts x)[j] = (pelts ox)[j] + by let k = j - x.offset in + !i <= k < sz + so (pelts x)[x.offset + k] = (pelts ox)[x.offset + k]}; + value_sub_frame (pelts x) (pelts ox) (x.offset + p2i !i) (x.offset + p2i sz) + + (** [incr_1 x sz] adds 1 to [x] in place. + [x] has size [sz]. The addition must not overflow. + This corresponds to [mpn_incr] *) + let incr_1 (x:t) (ghost sz:int32) : unit + requires { valid x sz } + requires { sz > 0 } + requires { value x sz + 1 < power radix sz } + ensures { value x sz = value (old x) sz + 1 } + ensures { forall j. j < x.offset \/ x.offset + sz <= j -> + (pelts x)[j] = (pelts (old x))[j] } + writes { x.data.elts } + = + let ghost ox = { x } in + let r : ref limb = ref 0 in + let ghost c : ref limb = ref 1 in + let lx : ref limb = ref 0 in + let i : ref int32 = ref 0 in + while (Limb.(=) !r 0) do + invariant { 0 <= !i <= sz } + invariant { !i = sz -> !r <> 0 } + invariant { !r <> 0 <-> !c = 0 } + invariant { 0 <= !c <= 1 } + invariant { value x !i + (power radix !i) * !c + = value ox !i + 1 } + invariant { forall j. !i <= j < sz -> + (pelts x)[x.offset + j] = (pelts ox)[x.offset + j] } + invariant { forall j. j < x.offset \/ x.offset + sz <= j -> + (pelts x)[j] = (pelts ox)[j] } + variant { sz - !i } + label StartLoop in + lx := get_ofs x !i; + assert { !lx = (pelts ox)[ox.offset + !i] }; + let res = add_mod !lx 1 in + r := res; + ghost (if Limb.(=) res 0 then c := 1 else c := 0); + assert { res + radix * !c = !lx + 1 }; + value_sub_update_no_change (pelts x) (x.offset + p2i !i) + (x.offset + p2i !i + 1) + (x.offset + p2i sz) res; + set_ofs x !i res; + assert { forall j. !i < j < sz -> + (pelts x)[x.offset + j] + = (pelts ox)[x.offset + j] }; + assert { value x !i + (power radix !i) * (!c at StartLoop) = value ox !i + 1 }; + value_tail x !i; + value_tail ox !i; + assert { value x (!i+1) + power radix (!i+1) * !c = + value ox (!i+1) + 1 }; + i := Int32.(+) !i 1; + assert { !i = sz -> !c = 0 + by value x sz + power radix sz * !c = value ox sz + 1 + so value ox sz + 1 < power radix sz + so 0 <= !c <= 1}; + done; + value_concat x !i sz; + value_concat ox !i sz; + assert { forall j. x.offset + !i <= j < x.offset + sz -> + (pelts x)[j] = (pelts ox)[j] + by let k = j - x.offset in + !i <= k < sz + so (pelts x)[x.offset + k] = (pelts ox)[x.offset + k]}; + value_sub_frame (pelts x) (pelts ox) (x.offset + p2i !i) (x.offset + p2i sz) + +end \ No newline at end of file diff --git a/examples/multiprecision/add/why3session.xml b/examples/multiprecision/add/why3session.xml new file mode 100644 index 000000000..bd1f24338 --- /dev/null +++ b/examples/multiprecision/add/why3session.xml @@ -0,0 +1,1307 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/examples/multiprecision/add/why3shapes.gz b/examples/multiprecision/add/why3shapes.gz new file mode 100644 index 0000000000000000000000000000000000000000..62d04273f3f86547bb4dc5f9a51c1c695bcbd336 GIT binary patch literal 15032 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 O6#pN%&OL3DfdK$1&%Aa3 literal 0 HcmV?d00001 diff --git a/examples/multiprecision/compare.mlw b/examples/multiprecision/compare.mlw new file mode 100644 index 000000000..acbda8e76 --- /dev/null +++ b/examples/multiprecision/compare.mlw @@ -0,0 +1,87 @@ +module Compare + + use import int.Int + use import mach.int.Int32 + use import mach.int.UInt64GMP as Limb + use import int.Power + use import ref.Ref + use import mach.c.C + use import map.Map + use import types.Types + use import lemmas.Lemmas + + function compare_int (x y:int) : int = + if x < y then -1 else if x=y then 0 else 1 + + (** [compare_same_size] compares [x[0..sz-1]] and [y[0..sz-1]] as unsigned integers. It corresponds to [GMPN_CMP]. *) + let compare_same_size (x y:t) (sz:int32) : int32 + requires { valid x sz } + requires { valid y sz } + ensures { result = compare_int (value x sz) (value y sz) } + = + let i = ref sz in + try + while Int32.(>=) !i (Int32.of_int 1) do + variant { p2i !i } + invariant { 0 <= !i <= sz } + invariant { forall j. !i <= j < sz -> + (pelts x)[x.offset+j] = (pelts y)[y.offset+j] } + assert { forall j. 0 <= j < sz - !i -> + let k = !i+j in + !i <= k < sz -> + (pelts x)[x.offset+k] = (pelts y)[y.offset+k] /\ + (pelts x)[!i+x.offset+j] = (pelts y)[!i+y.offset+j] }; + value_sub_frame_shift (pelts x) (pelts y) (p2i !i+x.offset) + (p2i !i+y.offset) ((p2i sz) - (p2i !i)); + let ghost k = p2i !i in + i := Int32.(-) !i (Int32.of_int 1); + + assert { 0 <= !i < sz }; + let lx = get_ofs x !i in + let ly = get_ofs y !i in + if (not (Limb.(=) lx ly)) + then begin + value_sub_concat (pelts x) x.offset (x.offset+k) (x.offset+p2i sz); + value_sub_concat (pelts y) y.offset (y.offset+k) (y.offset+p2i sz); + assert { compare_int (value x sz) + (value y sz) + = compare_int (value x k) (value y k) }; + value_sub_tail (pelts x) x.offset (x.offset+k-1); + value_sub_tail (pelts y) y.offset (y.offset+k-1); + if Limb.(>) lx ly + then begin + value_sub_upper_bound (pelts y) y.offset (y.offset+k-1); + value_sub_lower_bound (pelts x) x.offset (x.offset+k-1); + assert { value x k - value y k = + (l2i lx - ly) * (power radix (k-1)) + - ((value y (k-1)) - (value x (k-1))) + }; + assert { (lx - ly) * (power radix (k-1)) + >= power radix (k-1) + > ((value y (k-1)) - (value x (k-1))) + }; + raise Return32 (Int32.of_int 1) + end + else begin + assert { ly > lx }; + value_sub_upper_bound (pelts x) x.offset (x.offset+k-1); + value_sub_lower_bound (pelts y) y.offset (y.offset+k-1); + assert { value y k - value x k = + (ly - lx) * (power radix (k-1)) + - ((value x (k-1)) - (value y (k-1))) + }; + assert { (ly - lx) * (power radix (k-1)) + >= power radix (k-1) + > ((value x (k-1)) - (value y (k-1))) + }; + raise Return32 (Int32.(-_) (Int32.of_int 1)) + end + end + else () + done; + value_sub_frame_shift (pelts x) (pelts y) x.offset y.offset (p2i sz); + Int32.of_int 0 + with Return32 r -> r + end + +end \ No newline at end of file diff --git a/examples/multiprecision/compare/why3session.xml b/examples/multiprecision/compare/why3session.xml new file mode 100644 index 000000000..fd61f6bc3 --- /dev/null +++ b/examples/multiprecision/compare/why3session.xml @@ -0,0 +1,147 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/examples/multiprecision/compare/why3shapes.gz b/examples/multiprecision/compare/why3shapes.gz new file mode 100644 index 0000000000000000000000000000000000000000..d96164e40957441c3c528c27d1ae5e976946bc0a GIT binary patch literal 2057 zcmV+k2=@0MiwFP!00000|J_vih(Osf85g)zPQECoD398| zkLqMP%9Hy?n)2<8?&V|rUmnx=p^l$Nm-0Q=>TmMdE^e`ECqL;s-92#&od#-EhTXE8 z-aBQuzLJ95Gs#BY39Z}IxYl0LJw4v?e-?GOvwx54 zT>1v-BX!^Ck?-cS7SF)ZS+0tFysW zg;AxFPYmpm?#IuIi+}!W4Z#|-4FIh^XoUNXu+?khTuA%g33f|ceSPy&uyN5B4a%6H zBVcvK2TL`Q7L>9HUci|1?>rq%zVo!+P5$Wk8{WJIB{Kvivqj0AMM<~jy1!xoN(+F8 z!PHo#9FhSEUFWe>TPitHfWe9f*)XEnjHmPQdi|BoYDclfK zxUDJNIa4&MRv#Tl>r{?VbQUl2vBqQ}rpP#YoN}H#l<^BnuOpiE$R5?WgVmApP5Un| z+$;X|8&l~41_hx)UD4kGOrVT(_vMd$ChzA@A?^6EJUTiKy6xirH9SjU=_0LXkh_Y{~AD z(iW#(w%i5oo}OFiP~iRep@(66ar}5DXtKnbc3H%1u_&CBSwvAWOkcom9{5OnpSQS=PzwA{ltVoZO zKX^)0D&yz1TfEf7!S-yZx}=JV>{AjaO3|9^nT;ztie>r~gMlQuaR z5WYsvX@M9dm(8KdzC1J~Ervmb=5#ogoiUJjWoPDleX*N(58QE6whR5Qd%n4OLZ2yC zT{1k^y}zx8c84jY>&pg}^#V#r))lX-u(c98iXOFmqKOAUeSJs!uO-CS%LC6l5t_#b zaIE6yZDG)4Np4mA2q}4?Zpn0>G!$DI6rwIiUn75x`Mpn=HwuKR7XlJeNdQ5-DMKm2 zl_biN;4Dgi0<(NP;%ig_lM^ViIZ|*=R3+%-v#FRUdm8lK_WwBwo1oD;W`>%z#9YOQ zI%(108c++5j~*wp`MwO;d5f&yYo|u*yj_ET7|@%lW0ZVmn2OC51B0zeuqwWA(LwdF z_U?Ulp0Qb-ep*FzMEN!#vN6~yBC@h}Ig1o03Ye5Edgb2?(vw5w>!-xH$r*JnA=n_q z9RqPt4zOzNYcf_?`<#}1E*chF-Lx*qWr7p_YT3{C=QyP z50(|=lq*y;2mx4DD1qX6(fuc|$_L}V#&h+mR7r4)Ak$E5tfG;m%xTN|^tR-yWz8py zzs9Ffu?Qvk$Tb#`13=LTEft3tEuY$w+)!j!55AvD{1|XHu24xjIxNaKo6!nvH7*3V zGa|Otd9`icO>LWg%zL+bej@0Nq%P)Kgs_dt%9esIlBu?a5*EC)JcqPCg;Y3CnPzJu zx_H^&K)u{E-Pzt+?xOzoF?WYvy}j44HI*%84qoY)HH$RLCdsnII&m@FKdvRl7Af$Z zcGUOI0JpC<&%LFqlwn5oKlKJ#<|GeC-s&SN&811+tuNm?GEkNW5>}< z9|@Tb2MsgJspCkU6+p)<&<|{bgq00B3^_{7)l#+MVl)}MpzeGs`M>SJ=_f(9sbn!0 n(T@^lSw#Z`&IJ~kWGY%iXH(ldANl>5pf~>m7GmWGCM^H}S5o~i literal 0 HcmV?d00001 diff --git a/examples/multiprecision/div.mlw b/examples/multiprecision/div.mlw new file mode 100644 index 000000000..5ff4e649d --- /dev/null +++ b/examples/multiprecision/div.mlw @@ -0,0 +1,4433 @@ +module Div + + use import int.Int + use import mach.int.Int32 + use import mach.int.UInt64GMP as Limb + use import int.Power + use import ref.Ref + use import mach.c.C + use import array.Array + use import map.Map + use import types.Types + use import lemmas.Lemmas + use import compare.Compare + use import util.Util + use import add.Add + use import sub.Sub + use import logical.Logical + use import int.EuclideanDivision + + (** Based on Niels Möller and Torbjörn Granlund, “Improved + division by invariant integers” 2010 *) + + use int.MinMax as MM + + predicate reciprocal (v d:limb) = + v = (div (radix*radix - 1) (d)) - radix + + let lemma fact_div (x y z:int) + requires { y > 0 } + ensures { div (x + y * z) y = (div x y) + z } + = + assert { x + y * z = y * (div (x + y * z) y) + mod (x + y * z) y + so mod (x + y * z) y = mod (y * z + x) y = mod x y + so x + y * z = y * (div (x + y * z) y) + mod x y + so + x = y * div x y + mod x y + so x + y * z = y * div x y + mod x y + y * z + so y * (div (x + y * z) y) + mod x y + = y * div x y + mod x y + y * z + so y * (div (x + y * z) y) = y * div x y + y * z + = y * ((div x y) + z) + so y <> 0 + so div (x + y * z) y = div x y + z + } + + let invert_limb (d:limb) : limb + requires { d >= div radix 2 } + ensures { reciprocal result d } + = + let v = div2by1 (Limb.of_int max_uint64) + (Limb.(-) (Limb.of_int max_uint64) d) + d in + fact_div (radix * radix - 1) (l2i d) (- radix); + assert { v = (div (radix*radix - 1) (d)) - radix + by + radix - 1 + radix * (radix - 1 - d) + = radix - 1 + radix * (radix - 1) - radix * d + = radix - 1 + radix * radix - radix - radix * d + = radix * radix - 1 - radix * d + so + radix - 1 + radix * (radix - 1 - d) + = radix * radix - 1 - radix * d + so + v + = div ((radix - 1) + radix * (radix - 1 - d)) (d) + = div (radix * radix - 1 - radix * d) (d) + = div (radix * radix - 1) (d) - radix + }; + v + + (** Divide a two-word integer by a one-word integer given the + reciprocal of the divisor. *) + let div2by1_inv (uh ul d v:limb) : (limb,limb) + requires { d >= div radix 2 } + requires { uh < d } + requires { reciprocal v d } + returns { q, r -> l2i q * d + l2i r = ul + radix * uh } + returns { _q, r -> 0 <= l2i r < d } + = + let zero = Limb.of_int 0 in + let one = Limb.of_int 1 in + let ghost k = radix * radix - (radix + l2i v) * l2i d in + let ghost u = l2i ul + radix * l2i uh in + assert { 1 <= k <= d }; + let l,h = mul_double v uh in + let sl,c = add_with_carry l ul zero in + let (sh,ghost c') = add_with_carry uh h c in (* = + *) + assert { sl + radix * sh + radix * radix * c' + = l + radix * h + ul + radix * uh }; + assert { c' = 0 + by + uh < d + so v * uh <= v * d + so k = radix * radix - (radix + v) * d + = radix * radix - radix * d - v * d + so v * d = radix * radix - radix * d - k + = radix * (radix - d) - k + so k > 0 + so v * d < radix * (radix - d) + so v * uh < radix * (radix - d) + so l + radix * h = v * uh + so l + radix * h < radix * (radix - d) + so uh <= d - 1 + so radix * uh <= radix * (d - 1) = radix * d - radix + so l + radix * h + radix * uh + < radix * (radix - d) + radix * uh + <= radix * (radix - d) + radix * d - radix + <= radix * (radix - d + d) - radix = radix * radix - radix + so ul < radix + so l + radix * h + ul + radix * uh + = l + radix * h + radix * uh + ul + < radix * radix - radix + ul + < radix * radix - radix + radix = radix * radix + so sl + radix * sh + radix * radix * c' + = l + radix * h + ul + radix * uh + < radix * radix + so radix * radix * c' <= sl + radix * sh + radix * radix * c' + so radix * radix * c' < radix * radix + }; + assert { sl + radix * sh = l + radix * h + ul + radix * uh + = v * uh + ul + radix * uh + = ul + (radix + v) * uh }; + let qh = ref (sh:limb) in + let ql = ref sl in + let ghost q0 = l2i !ql in + let ghost cq = l2i sh + 1 in (*candidate quotient*) + let ghost cr = l2i ul - cq * l2i d + radix * l2i uh in (*candidate remainder*) + assert { cq * d + cr = u}; + qh := add_mod !qh one; + assert { !qh = mod cq radix }; + let p = mul_mod !qh d in + let r = ref (sub_mod ul p) in + let ghost r' = !r in + assert { r' = mod cr radix + by + let a = (- div (!qh * d) radix) in + r' = !r + = mod (ul - p) radix + = mod (ul - mod (!qh * d) radix) radix + = mod (radix * a + + ul - mod (!qh * d) radix) radix + = mod (ul - mod (!qh * d) radix + - radix * div (!qh * d) radix) radix + = mod (ul - !qh * d) radix + = mod (ul - mod cq radix * d) radix + = mod (radix * (- (div cq radix)) * d + ul - mod cq radix * d) radix + = mod (ul - (mod cq radix + radix * div cq radix) * d) radix + = mod (ul - cq * d) radix + = mod (radix * uh + ul - cq * d) radix + = mod (ul - cq * d + radix * uh) radix + = mod cr radix }; + assert { radix * cr = uh * k + ul * (radix - d) + q0 * d - radix * d }; + prod_compat_strict_r (l2i ul) radix (radix - l2i d); + prod_compat_strict_r (l2i d) radix (radix - q0); + assert { (* Theorem 2 of Möller&Granlund 2010 *) + (MM.max (radix - d) (q0 + 1)) - radix <= cr < MM.max (radix - d) q0 + by radix * cr = uh * k + ul * (radix - d) + q0 * d - radix * d + so (uh * k + ul * (radix - d) >= 0 + by uh >= 0 /\ k >= 0 /\ ul >= 0 /\ radix - d >= 0) + so radix * cr >= q0 * d - radix * d + so radix * cr >= - radix * d + so cr >= - d + so radix * cr >= q0 * d - radix * d = (q0 - radix) * d + so radix > d + so radix - q0 > 0 + so d * (radix-q0) < radix * (radix - q0) + so (q0 - radix) * d > (q0 - radix) * radix + so radix * cr > (q0 - radix) * radix + so cr > q0 - radix + so (let m = MM.max (radix - d) (q0 +1) in + cr >= m - radix + by (cr + radix >= - d + radix + /\ (cr + radix > q0 so cr + radix >= q0 + 1)) + so cr + radix >= m) + so 0 < k <= d so 0 <= uh < d + so k * uh < k * d <= d * d + so radix * cr < d * d + ul * (radix - d) + q0 * d - radix * d + so ul * (radix - d) < radix * (radix - d) + so radix * cr < d * d + radix * (radix - d) + q0 * d - radix * d + so (radix * cr < (radix - d) * (radix - d) + q0 * d + by + d * d + radix * (radix - d) + q0 * d - radix * d + = radix * (radix - d) + d * d - radix * d + q0 * d + = radix * (radix - d) + (d - radix) * d + q0 * d + = radix * (radix - d) - d * (radix - d) + q0 * d + = (radix - d) * (radix - d) + q0 * d) + so let m = MM.max (radix - d) q0 in + radix - d <= m + so (radix - d) * (radix - d) <= m* (radix - d) + so (q0 * d <= m * d by 0 <= q0 <= m /\ 0 < d) + so radix * cr < (radix - d) * (radix - d) + q0 * d + <= m* (radix - d) + q0 * d + <= m* (radix - d) + m * d + = m * radix + so cr < m + }; + assert { cr >= 0 -> r' = cr }; + assert { cr < 0 -> + ( r' = cr + radix + by cr >= MM.max (radix - d) (q0 + 1) - radix + so cr >= - d + so cr + radix >= radix - d >= 0 + so 0 <= cr + radix < radix + so mod (cr + radix) radix = mod cr radix + so r' = mod (cr + radix) radix ) }; + assert { cr < 0 -> + ( !r > !ql + by MM.max (radix - d) (q0 + 1) >= q0 + 1 > q0 + so cr >= (MM.max (radix - d) (q0 +1)) - radix > q0 - radix + so r' = cr + radix > q0 - radix + radix = q0 ) }; + assert { 1 <= cq <= radix }; + assert { (!qh = cq \/ (!qh = 0 /\ cq = radix) + by (1 <= cq < radix -> !qh = mod cq radix = cq) + so (cq = radix -> !qh = 0) ) }; + assert { cq = radix -> + (cr < 0 + by cq * d + cr = u + so uh <= d - 1 + so 1 + uh <= d + so ul < radix + so u = ul + radix * uh + < radix + radix * uh + = radix * (1 + uh) + <= radix * d + so u < radix * d + so radix * d + cr = u + so radix * d + cr < radix * d + so cr < 0) }; + assert { 1 <= cq < radix -> !qh = cq /\ !qh * d + cr = u }; + if Limb.(>) !r !ql + then + begin + qh := sub_mod !qh one; + r := add_mod !r d; + assert { cr >= 0 -> + (!r = cr + d + by r' = cr + so r' < MM.max (radix - d) q0 + so r' > q0 + so 0 <= r' < radix - d + so d <= r' + d < radix + so !r = mod (r' + d) radix = r' + d) }; + assert { cr >= 0 -> + ( !r >= d + by r' = cr >= 0 + so !r = r' + d >= d ) }; + assert { cr < 0 -> + ( !r = r' + d - radix + by r' = cr + radix < radix + so cr >= MM.max (radix - d) (q0 + 1) - radix + >= radix - d - radix = - d + so r' = cr + radix >= radix - d + so !r = mod (r' + d) radix + so radix + radix >= r' + d >= radix + so !r = mod (r' + d) radix = r' + d - radix ) }; + assert { cr < 0 -> + ( 0 <= !r < d + by r' = cr + radix < radix + so !r = mod (r' + d) radix = r' + d - radix + so !r >= 0 + so !r = r' + d - radix < d ) }; + assert { cq = radix -> + ( !qh * d + !r = u + by cq * d + cr = u + so cr < 0 + so r' = cr + radix + so u = radix * d + cr + = (radix - 1) * d + d + cr + = (radix - 1) * d + d + r' - radix + so r' = cr + radix >= MM.max (radix - d) (q0 + 1) + >= radix - d + so radix + radix >= d + r' >= radix + so !r = mod (d + r') radix = d + r' - radix + so (radix - 1) * d + !r = u + so !qh = mod ((mod cq radix) - 1) radix + = mod (-1) radix + = radix - 1 + so !qh * d + !r = u + ) }; + assert { !r = cr + d by [@case_split] cr >= 0 \/ cr < 0 }; + assert { 1 <= cq <= radix -> + ( !qh * d + !r = u + by cq * d + cr = u + so !qh = cq - 1 + so !qh * d + cr + d = u + so !r = cr + d ) }; + end + else + begin + assert { cr >= 0 }; + assert { 1 <= cq < radix }; + end; + assert { !qh * d + !r = ul + radix * uh + by [@case_split] cq = radix \/ 1 <= cq < radix }; + if Limb.(>=) !r d + then begin + assert { cr >= 0 }; + assert { !qh < radix - 1 + by + !qh * d = ul + radix * uh - !r + so uh <= d - 1 + so ul + radix * uh - !r + <= ul + radix * (d - 1) - !r + = ul + radix * d - radix - !r + = (ul - radix) + radix * d - !r + < radix * d - !r + <= radix * d - d + = (radix - 1) * d + so !qh * d < (radix - 1) * d + so d > 0 + so !qh < radix - 1 }; + qh := Limb.(+) !qh one; + r := Limb.(-) !r d; + assert { 0 <= !r < d }; + assert { !qh * d + !r = ul + radix * uh }; + end; + assert { 0 <= !r < d }; + assert { !qh * d + !r = ul + radix * uh }; + (!qh,!r) + +(** [divmod_1 q x y sz] divides [(x,sz)] by [y], writes the quotient + in [(q, sz)] and returns the remainder. Corresponds to + [mpn_divmod_1]. *) +(* TODO develop further decimal points (qxn) *) +let divmod_1 (q x:t) (y:limb) (sz:int32) : limb + requires { valid x sz } + requires { valid q sz } + requires { 0 < sz } + requires { 0 < y } + ensures { value x sz + = value q sz * y + result } + ensures { result < y } + = + let limb_zero = Limb.of_int 0 in + let zero = Int32.of_int 0 in + let one = Int32.of_int 1 in + let msb = Int32.(-) sz one in + let lx = ref limb_zero in + let i = ref msb in + let r = ref limb_zero in + (*normalize divisor*) + let clz = count_leading_zeros y in + if (Int32.(>) clz zero) + then begin + let ghost mult = power 2 (p2i clz) in + let ry = lsl y (Limb.of_int32 clz) in + assert { ry = mult * y }; + let ghost tlum = power 2 (Limb.length - p2i clz) in + assert { tlum * mult = radix }; + let v = invert_limb ry in + while (Int32.(>=) !i zero) do + variant { p2i !i } + invariant { -1 <= !i <= msb } + invariant { !r < ry } + invariant { mult * value_sub (pelts x) (x.offset + !i + 1) (x.offset + sz) + = value_sub (pelts q) (q.offset + !i + 1) + (q.offset + sz) + * ry + + !r } + invariant { !r <= radix - mult } + invariant { mod (!r) mult = 0 } + assert { !i >= 0 }; + label StartLoop in + lx := C.get_ofs x !i; + (*TODO lshift in place would simplify things*) + let l,h = lsld_ext !lx (Limb.of_int32 clz) in + mod_mult mult (l2i y) 0; + assert { !r + h < ry + by + let drm = div (!r) mult in + let dym = div (ry) mult in + mod (!r) mult = 0 + so !r = mult * drm + so mod (ry) mult + = mod (mult * (y) + 0) mult + = mod 0 mult + = 0 + so ry = mult * dym + so !r < ry + so 0 < ry - !r + = mult * dym - mult * drm + = mult * (dym - drm) + so mult > 0 + so dym - drm > 0 + so dym >= drm + 1 + so h < mult + so !r + h = mult * drm + h + < mult * drm + mult + = mult * (drm + 1) + <= mult * dym = l2i ry }; + assert { !r + h < radix by + !r + h < ry < radix }; + let (qu,rem) = div2by1_inv (Limb.(+) !r h) l ry v in + mod_mult mult (l2i y * l2i qu) (l2i rem); + mod_mult mult (tlum * (l2i !r + l2i h)) (l2i l); + assert { mod (rem) mult = 0 + by + ry * qu + rem + = (radix * (!r + h) + l) + so + mult * y * qu + rem + = (mult * tlum * (!r + h) + l) + so mod (mult * y * qu + rem) mult + = mod (mult * tlum * (!r + h) + l) mult + so mult > 0 + so mod (mult * (y * qu) + rem) mult + = mod (rem) mult + so mod (mult * tlum * (!r + h) + l) mult + = mod (l) mult + = 0 + }; + let ghost mer = div (l2i rem) mult in + assert { rem <= radix - mult + by + mod (rem) mult = 0 + so mult * mer = l2i rem < radix = mult * tlum + so mult > 0 + so 0 < mult * tlum - mult * mer = mult * (tlum - mer) + so tlum - mer > 0 + so mer < tlum + so rem = mult * mer <= mult * (tlum - 1) = radix - mult + }; + r:=rem; + assert { qu * ry + !r = l + radix * h + radix * (!r at StartLoop) }; + (* coerced div2by1 postcondition *) + value_sub_update_no_change (pelts q) (q.offset + p2i !i) + (q.offset + 1 + p2i !i) + (q.offset + p2i sz) qu; + C.set_ofs q !i qu; + assert { mult * value_sub (pelts x) (x.offset + !i + 1) (x.offset + sz) + = value_sub (pelts q) (q.offset + !i + 1) + (q.offset + sz) + * ry + + (!r at StartLoop) }; (* previous invariant is still true *) + value_sub_head (pelts x) (x.offset + int32'int !i) (x.offset + p2i sz); + value_sub_head (pelts q) (q.offset + int32'int !i) (q.offset + p2i sz); + assert { l + radix * h = mult * !lx }; (*lsld_ext postcondition *) + assert { mult * value_sub (pelts x) (x.offset + !i) + (x.offset + sz) + = mult * !lx + + radix * (mult * value_sub (pelts x) (x.offset + !i + 1) + (x.offset + sz)) + by (pelts x)[x.offset + !i] = !lx + so value_sub (pelts x) (x.offset + !i) (x.offset + sz) + = !lx + radix * value_sub (pelts x) (x.offset + !i + 1) + (x.offset + sz) }; (*nonlinear*) + assert { value_sub (pelts q) (q.offset + !i) (q.offset + sz) * ry + = qu * ry + + radix + * (value_sub (pelts q) (q.offset + !i + 1) (q.offset + sz) + * ry) + by (pelts q)[q.offset + !i] = qu + so value_sub (pelts q) (q.offset + !i) (q.offset + sz) + = qu + radix * value_sub (pelts q) (q.offset + !i + 1) + (q.offset + sz) }; (*nonlinear*) + assert { mult * value_sub (pelts x) (x.offset + !i) + (x.offset + sz) + = value_sub (pelts q) (q.offset + !i) (q.offset + sz) + * ry + + !r + (* by + (pelts q)[q.offset + k] = qu + so + (pelts x)[x.offset + k] = !lx + so + l + radix * h = !lx * mult + so + mult * value_sub (pelts x) (x.offset + !i + 1) + (x.offset + sz) + = mult * value_sub (pelts x) (x.offset + k) (x.offset + sz) + = mult * ((pelts x)[x.offset + k] + + radix * value_sub (pelts x) (x.offset + k + 1) + (x.offset + sz)) + = mult * !lx + + mult * radix * value_sub (pelts x) (x.offset + k + 1) + (x.offset + sz) + = l + radix * h + + mult * radix * value_sub (pelts x) (x.offset + k + 1) + (x.offset + sz) + = l + radix * h + + radix * (value_sub (pelts q) (q.offset + k + 1) + (q.offset + sz) + * ry + + (!r at StartLoop)) + = l + radix * h + radix * (!r at StartLoop) + + radix * (value_sub (pelts q) (q.offset + k + 1) + (q.offset + sz) + * ry) + = l + radix * (h + (!r at StartLoop)) + + radix * (value_sub (pelts q) (q.offset + k + 1) + (q.offset + sz) + * ry) + = qu * ry + !r + + radix * value_sub (pelts q) (q.offset + k + 1) + (q.offset + sz) + * ry + = (pelts q)[q.offset + k] * ry + !r + + radix * value_sub (pelts q) (q.offset + k + 1) + (q.offset + sz) + * ry + = ry * ((pelts q)[q.offset + k] + + radix * value_sub (pelts q) (q.offset + k + 1) + (q.offset + sz)) + + !r + = ry * value_sub (pelts q) (q.offset + !i + 1) + (q.offset + sz) + + !r *) + }; + i := Int32.(-) !i one; + done; + let ghost res = lsr !r (Limb.of_int32 clz) in + assert { value x sz = value q sz * y + res + by !r = res * mult + so mult * value x sz + = value q sz * ry + !r + = value q sz * y * mult + !r + = value q sz * y * mult + res * mult + = (value q sz * y + res) * mult }; + lsr !r (Limb.of_int32 clz) end + else begin + let v = invert_limb y in + while (Int32.(>=) !i zero) do + variant { p2i !i } + invariant { -1 <= !i <= msb } + invariant { !r < y } + invariant { value_sub (pelts x) (x.offset + !i + 1) (x.offset + sz) + = value_sub (pelts q) (q.offset + !i + 1) + (q.offset + sz) + * y + + !r } + assert { !i >= 0 }; + label StartLoop in + let ghost k = p2i !i in + lx := C.get_ofs x !i; + let (qu, rem) = div2by1_inv !r !lx y v in + r := rem; + value_sub_update_no_change (pelts q) (q.offset + p2i !i) + (q.offset + 1 + p2i !i) + (q.offset + p2i sz) qu; + C.set_ofs q !i qu; + i := Int32.(-) !i one; + value_sub_head (pelts x) (x.offset + k) (x.offset + p2i sz); + value_sub_head (pelts q) (q.offset + k) (q.offset + p2i sz); + assert { value_sub (pelts x) (x.offset + !i + 1) (x.offset + sz) + = value_sub (pelts q) (q.offset + !i + 1) + (q.offset + sz) + * y + + !r + by (pelts q)[q.offset + k] = qu + so (pelts x)[x.offset + k] = !lx + so value_sub (pelts x) (x.offset + !i + 1) (x.offset + sz) + = value_sub (pelts x) (x.offset + k) (x.offset + sz) + = !lx + radix * value_sub (pelts x) (x.offset + k + 1) + (x.offset + sz) + = !lx + radix * (value_sub (pelts q) (q.offset + k + 1) + (q.offset + sz) + * y + (!r at StartLoop)) + = !lx + radix * (!r at StartLoop) + + radix * (value_sub (pelts q) (q.offset + k + 1) + (q.offset + sz) + * y) + = qu * y + !r + + radix * (value_sub (pelts q) (q.offset + k + 1) + (q.offset + sz) + * y) + = (qu + radix * value_sub (pelts q) (q.offset + k + 1) + (q.offset + sz)) + * y + + !r + = value_sub (pelts q) (q.offset + !i + 1) + (q.offset + sz) + * y + + !r }; + done; + !r + end + + + predicate reciprocal_3by2 (v dh dl:limb) = + v = div (radix*radix*radix -1) (dl + radix * dh) - radix + + let div3by2_inv (uh um ul dh dl v: limb) : (limb,limb,limb) + requires { dh >= div radix 2 } + requires { reciprocal_3by2 v dh dl } + requires { um + radix * uh < dl + radix * dh } + returns { q, rl, rh -> uint64'int q * dl + radix * q * dh + + uint64'int rl + radix * uint64'int rh + = ul + radix * um + radix * radix * uh } + returns { _q, rl, rh -> 0 <= uint64'int rl + radix * uint64'int rh < dl + radix * dh } + = + let ghost d = l2i dl + radix * l2i dh in + let ghost u = l2i ul + radix * (l2i um + radix * l2i uh) in + let zero = Limb.of_int 0 in + let one = Limb.of_int 1 in + let q1 = ref zero in + let r0 = ref zero in + let r1 = ref zero in + let l,h = mul_double v uh in + let sl, c = add_with_carry um l zero in + let sh, ghost c' = add_with_carry uh h c in + assert { sl + radix * sh + radix * radix * c' + = um + radix * uh + v * uh }; + assert { c' = 0 + by + um + radix * uh < d + so radix * uh < d + so radix * (um + radix * uh + v * uh) + < radix * (d + v * uh) + = radix * d + v * radix * uh + <= radix * d + v * d + = (div (radix * radix * radix - 1) d) * d + <= radix * radix * radix - 1 + < radix * radix * radix + so um + radix * uh + v * uh < radix * radix + so sl + radix * sh + radix * radix * c' < radix * radix + so radix * radix * c' < radix * radix + }; + q1 := sh; + let ghost q0 = l2i sl in + let ghost cq = l2i !q1 + 1 in (*candidate quotient*) + q1 := add_mod !q1 one; + assert { !q1 = mod cq radix }; + let p = mul_mod dh sh in + r1 := sub_mod um p; + label CQuot in + let ghost a = div (l2i um - l2i dh * l2i sh) radix in + (*assert { um - dh * sh = a * radix + !r1 + by !r1 = mod (um - dh * sh) radix };*) + let tl, th = mul_double sh dl in + let il, b = sub_with_borrow ul tl zero in + let (ih, ghost b') = sub_with_borrow !r1 th b in + assert { il + radix * ih - radix * radix * b' + = ul + radix * !r1 - sh * dl }; + let bl,b2 = sub_with_borrow il dl zero in + let bh, ghost b2' = sub_with_borrow ih dh b2 in + assert { bl + radix * bh - radix * radix * b2' + = il + radix * ih - dl - radix * dh }; + mod_mult (radix * radix) (l2i b') + (l2i ul + radix * l2i !r1 - l2i sh * l2i dl - l2i dl + - radix * l2i dh); + assert { bl + radix * bh + = mod (ul + radix * !r1 + - sh * dl- dl + - radix * dh) (radix * radix) + by + bl + radix * bh + = mod (il + radix * ih + - dl - radix * dh) (radix * radix) + so il + radix * ih + = radix * radix * b' + ul + radix * !r1 + - sh * dl + so mod (il + radix * ih + - dl - radix * dh) (radix * radix) + = mod (radix * radix * b' + ul + radix * !r1 + - sh * dl - dl - radix * dh) + (radix * radix) + = mod (ul + radix * !r1 + - sh * dl - dl + - radix * dh) (radix * radix) }; + r1 := bh; + r0 := bl; + let ghost r' = l2i !r0 + radix * l2i !r1 in + let ghost cr = u - d * cq in + assert { r' = mod cr(radix * radix) + by + (!r1 at CQuot = mod (um - dh * sh) radix + by let a' = div (dh * sh) radix in + dh * sh = p + radix * a' + so !r1 at CQuot = mod (um - p) radix + = mod (radix * a' + um - dh * sh) radix + = mod (um - dh * sh) radix ) + so um - dh * sh = a * radix + !r1 at CQuot + so !r0 + radix * !r1 + = mod (ul + radix * (!r1 at CQuot) + - sh * dl - dl + - radix * dh) (radix * radix) + so ul + radix * (!r1 at CQuot) + - sh * dl - dl - radix * dh + = ul + radix * (um - dh * sh - a * radix) + - sh * dl - dl - radix * dh + = ul + radix * um - radix * dh * sh + - radix * radix * a - sh * dl - dl + - radix * dh + = ul + radix * um - radix * dh * (sh + 1) + - radix * radix * a - sh * dl - dl + = ul + radix * um - radix * dh * (sh + 1) + - radix * radix * a - dl * (sh + 1) + = ul + radix * um + - (dl + radix * dh) * (sh + 1) + - radix * radix * a + = ul + radix * um - d * cq - radix * radix * a + = u - radix * radix * uh - d * cq - radix * radix * a + = cr + radix * radix * (- a - uh) + so (*let y = - a - uh in*) + mod (ul + radix * (!r1 at CQuot) + - sh * dl - dl + - radix * dh) (radix * radix) + = mod (radix * radix * (-a - uh) + cr) + (radix * radix) + = mod cr (radix*radix) + }; + let ghost m = MM.max (radix * radix - d) (q0 * radix) in + assert { (* Theorem 3 of Moller&Granlund 2010 *) + m - radix * radix <= cr < m + by + let k = radix * radix * radix - (radix + v) * d in + reciprocal_3by2 v dh dl + so let m3 = radix * radix * radix - 1 in + (radix + v) * d = d * div m3 d = m3 - mod m3 d + so (k = 1 + mod m3 d + by k = radix * radix * radix - (radix + v) * d + = m3 + 1 - (radix + v) * d + = m3 + 1 - m3 + mod m3 d + = 1 + mod m3 d) + so 1 <= k <= d + so q0 + radix * sh = (radix + v) * uh + um + so cq = sh + 1 + so radix * cq = radix * sh + radix + = (radix + v) * uh + um - q0 + radix + so (radix * cr = k * uh + (radix * radix - d) * um + + radix * ul + d * q0 - d * radix + by radix * cr = radix * (u - cq * d) + = radix * u + - ((radix + v) * uh + um - q0 + radix) * d + = radix * u - d * (radix + v) * uh + - d * um + d * q0 - d * radix + = radix * u - (radix * radix * radix - k) * uh + - d * um + d * q0 - d * radix + = (radix * radix * radix * uh + radix * radix * um + + radix * ul) - (radix * radix * radix - k) * uh + - d * um + d * q0 - d * radix + = k * uh + radix * radix * um + radix * ul + - d * um + d * q0 - d * radix + = k * uh + (radix * radix - d) * um + radix * ul + + d * q0 - d * radix ) + so (cr >= m - radix * radix + by ( + k >= 0 so radix * radix - d >= 0 + so uh >= 0 so um >= 0 so ul >= 0 + so k * uh + (radix * radix - d) * um + radix * ul + >= 0 + so radix * cr >= d * q0 - d * radix + so q0 >= 0 so d >= 0 + so d * q0 >= 0 + so radix * cr >= - d * radix + so cr >= -d = radix * radix - d - radix * radix + so radix * cr >= d * (q0 - radix) + so ( + (radix - q0) * d < (radix - q0) * radix * radix + by let rq = radix - q0 in let r2 = radix * radix in + rq > 0 /\ d < r2 + so rq * d < rq * r2 + ) + so d * (q0 - radix) > radix * radix * (q0 - radix) + so radix * cr > radix * radix * (q0 - radix) + so cr > radix * (q0 - radix) = radix * q0 - radix * radix + )) + so cr < m + by ( + let bbd = radix * radix - d in + bbd > 0 /\ bbd <= m /\ q0 * radix <= m + so (bbd * bbd <= bbd * m + by [@case_split] + (bbd = m \/ (bbd < m so bbd * bbd < bbd * m))) + so (d*(radix * q0) <= d * m + by [@case_split] + (radix * q0 = m \/ (radix * q0 < m so d > 0 so d * (radix * q0) < d * m))) + so if uh <= dh - 1 + then + let dm = dh - 1 in + uh <= dm + so + k * uh <= k * dm + so (k * dm <= d * dm + by k <= d /\ 0 <= dm + so [@case_split] (k = d \/ dm = 0 \/ + (k < d /\ dm > 0 so k * dm < d * dm))) + so k * uh <= d * dm + so + bbd * um <= bbd * (radix - 1) + so + radix * cr + = k * uh + (radix * radix - d) * um + + radix * ul + d * q0 - radix * d + <= d * dm + bbd * um + + radix * ul + d * q0 - radix * d + <= d * dm + bbd * (radix - 1) + + radix * ul + d * q0 - radix * d + < d * dm + bbd * (radix - 1) + + radix * radix + d * q0 - radix * d + so radix * radix * cr + < radix * (d * dm + bbd * (radix - 1) + + radix * radix + d * q0 - radix * d) + = d * radix * (dh - 1) + bbd * radix * (radix - 1) + + radix * radix * radix + radix * d * q0 - radix * radix * d + = d * radix * dh - d * radix + bbd * radix * (radix - 1) + + radix * radix * radix + radix * d * q0 - radix * radix * d + = d * (d - dl) - d * radix + bbd * radix * (radix - 1) + + radix * radix * radix + radix * d * q0 - radix * radix * d + = d * d - d * radix + bbd * radix * (radix - 1) + + radix * radix * radix + radix * d * q0 - radix * radix * d - d * dl + so (d * dl >= 0 by d >= 0 /\ dl >= 0) + so radix * radix * cr + < d * d - d * radix + bbd * radix * (radix - 1) + + radix * radix * radix + radix * d * q0 - radix * radix * d - d * dl + <= d * d - d * radix + bbd * radix * (radix - 1) + + radix * radix * radix + radix * d * q0 - radix * radix * d + = d * d - d * radix + bbd * (radix * radix - radix) + + radix * radix * radix + radix * d * q0 - radix * radix * d + = d * d - d * radix + bbd * radix * radix - (radix * radix - d) * radix + + radix * radix * radix + radix * d * q0 - radix * radix * d + = d * d - d * radix + bbd * radix * radix + + radix * d - radix * radix * radix + + radix * radix * radix + radix * d * q0 - radix * radix * d + = d * d + bbd * radix * radix - radix * radix * d + radix * d * q0 + = bbd * radix * radix - d * (radix * radix - d) + radix * d * q0 + = bbd * radix * radix - d * bbd + radix * d * q0 + = bbd * bbd + d * (radix * q0) + <= bbd * m + d * (radix * q0) + <= bbd * m + d * m + = radix * radix * m + so cr < m + else + uh = dh + so + (um <= dl - 1 + by um + radix * uh < dl + radix * dh) + so (radix * radix - d) * um <= (radix * radix - d) * (dl - 1) + so + ( radix * radix * cr + < radix * radix * m + - (radix - dl) * (radix * radix * radix - d * (1+ radix)) + by radix * cr + = k * dh + (radix * radix - d) * um + + radix * ul + d * q0 - radix * d + <= d * dh + (radix * radix - d) * um + + radix * ul + d * q0 - radix * d + <= d * dh + (radix * radix - d) * (dl - 1) + + radix * ul + d * q0 - radix * d + < d * dh + (radix * radix - d) * (dl - 1) + + radix * radix + d * q0 - radix * d + so radix * radix * cr + < radix * (d * dh + (radix * radix - d) * (dl - 1) + + radix * radix + d * q0 - radix * d) + = d * radix * dh + + (radix * radix - d) * (dl - 1) * radix + + radix * radix * radix + d * q0 * radix - radix * radix * d + = d * (d - dl) + + (radix * radix - d) * (radix * dl - radix) + + radix * radix * radix + d * q0 * radix - radix * radix * d + = d * d - d * dl + radix * radix * radix * dl + - d * radix * dl + d * radix - radix * radix * radix + + radix * radix * radix + d * q0 * radix - radix * radix * d + = d * d - d * dl + radix * radix * radix * dl + - d * radix * dl + d * radix + d * q0 * radix + - radix * radix * d + = d * d - radix * radix * d + d * radix + d * q0 * radix + + dl * (radix * radix * radix - d - d * radix) + = d * (d - radix * radix) + d * radix + d * q0 * radix + + dl * (radix * radix * radix - d - d * radix) + = bbd * (-d) + d * radix + d * q0 * radix + + dl * (radix * radix * radix - d - d * radix) + = bbd * (bbd - radix * radix) + d * radix + d * q0 * radix + + dl * (radix * radix * radix - d - d * radix) + = bbd * bbd + d * q0 * radix + - bbd * radix * radix + d * radix + + dl * (radix * radix * radix - d * (1 + radix)) + = bbd * bbd + d * q0 * radix + - (radix * radix - d) * radix * radix + d * radix + + dl * (radix * radix * radix - d * (1 + radix)) + = bbd * bbd + d * q0 * radix + - radix * ((radix * radix - d) * radix - d) + + dl * (radix * radix * radix - d * (1 + radix)) + = bbd * bbd + d * q0 * radix + - radix * (radix * radix * radix - d * radix - d) + + dl * (radix * radix * radix - d * (1 + radix)) + = bbd * bbd + d * q0 * radix + - radix * (radix * radix * radix - d * (1+ radix)) + + dl * (radix * radix * radix - d * (1 + radix)) + = bbd * bbd + d * q0 * radix + - (radix - dl) * (radix * radix * radix - d * (1+ radix)) + <= bbd * m + d * q0 * radix + - (radix - dl) * (radix * radix * radix - d * (1+ radix)) + <= bbd * m + d * m + - (radix - dl) * (radix * radix * radix - d * (1+ radix)) + = (bbd + d) * m + - (radix - dl) * (radix * radix * radix - d * (1+ radix)) + = radix * radix * m + - (radix - dl) * (radix * radix * radix - d * (1+ radix)) + ) + so + (cr < m by + if d <= radix * (radix - 1) + then (radix + 1) * d <= radix * (radix - 1) * (radix + 1) + = radix * (radix * radix - 1) + = radix * radix * radix - radix + < radix * radix * radix + so (radix * radix * radix - d * (1+ radix)) > 0 + so radix - dl > 0 + so (radix - dl) * (radix * radix * radix + - d * (1+ radix)) + > 0 + so + radix * radix * cr + < radix * radix * m + - (radix - dl) * (radix * radix * radix + - d * (1+ radix)) + < radix * radix * m + so radix * radix * cr < radix * radix * m + else + dl + radix * dh = d > radix * (radix - 1) + so dl < radix + so dl + radix * dh < radix * (1 + dh) + so radix - 1 < 1 + dh + so dh > radix - 2 + so dh = radix - 1 + so uh = dh + so d >= radix * (radix - 1) +1 + so d * (radix + 1) + >= (radix * (radix - 1) + 1) * (radix +1) + = radix * (radix * radix - 1) + radix + 1 + = radix * radix * radix - radix + radix + 1 + = radix * radix * radix + 1 + so + (d * div (radix * radix * radix - 1) d + <= d * (radix + 1) + by d * div (radix * radix * radix - 1) d + <= radix * radix * radix - 1 + < radix * radix * radix + 1 + <= d * (radix + 1)) + so (let a = div (radix * radix * radix - 1) d in + a < radix + 1 + by d > 0 + so (forall x y z. x * z < y * z /\ z > 0 -> x < y) + so (forall x y. x * d < y * d -> x < y) + so let r = radix + 1 in + a * d < r * d + so a < r) + so v = div (radix * radix * radix - 1) d - radix + < radix + 1 - radix = 1 + so v = 0 + so sh = uh = radix - 1 + so cq = sh + 1 = radix + so cr = u - cq * d + = u - radix * d + = ul + radix * (um + radix * dh) + - radix * (dl + radix * dh) + = ul + radix * (um - dl) + so um <= dl - 1 + so 1 + um - dl <= 0 + so ul < radix + so cr = ul + radix * (um - dl) + < radix + radix * (um - dl) + = radix * (1 + um - dl) <= 0 + so cr < 0 <= m + ) + ) + }; + assert { cr >= 0 -> r' = cr }; + assert { cr < 0 -> r' = radix * radix + cr + by + m >= radix * radix - d + so cr >= m - radix * radix >= -d + so cr + radix * radix >= radix * radix - d >= 0 + so 0 <= cr + radix * radix < radix * radix + so mod (radix * radix + cr) (radix*radix) = mod cr (radix*radix) + so r' = mod (radix * radix + cr) (radix*radix) }; + assert { cr < 0 -> !r1 >= sl + by m >= radix * q0 + so cr >= m - radix * radix >= radix * q0 - radix * radix + so r' = radix * radix + cr >= radix * q0 + so r' = radix * !r1 + !r0 >= radix * q0 + so !r0 < radix + so r' < radix * !r1 + radix = radix * (!r1 + 1) + so radix * q0 < radix * (!r1 + 1) + so sl = q0 < !r1 + 1 }; + assert { 1 <= cq <= radix }; + assert { 1 <= cq < radix -> !q1 = cq so !q1 * d + cr = u }; + assert { cq = radix -> + (cr < 0 + by cq * d + cr = u + so um + radix * uh <= d - 1 + so radix * d + cr = ul + + radix * (um + radix * uh) + <= ul + radix * (d - 1) + = ul - radix + radix * d + < radix * d + ) + }; + label PreCorrections in + if Limb.(>=) !r1 sl + then begin + q1 := sub_mod !q1 one; + assert { !q1 = cq - 1 + by + if cq = radix + then + (!q1 at PreCorrections) + = mod cq radix = mod radix radix= 0 + so !q1 = mod (0 - 1) radix = radix - 1 = cq - 1 + else + 0 <= cq - 1 < radix - 1 + so (!q1 at PreCorrections) = cq + so !q1 = mod (cq - 1) radix = cq - 1 + }; + let rl, c = add_with_carry !r0 dl zero in + let rh, ghost c' = add_with_carry !r1 dh c in + assert { rl + radix * rh = mod (r' + d) (radix * radix) + by radix * radix * c' + rl + radix * rh + = r' + d + so mod (r' + d) (radix * radix) + = mod (radix * radix * c' + rl + radix * rh) + (radix * radix) + = mod (rl + radix * rh) (radix * radix) }; + assert { rl + radix * rh = cr + d + by + if cr >= 0 + then r' = cr + so rl + radix * rh = mod (cr + d) (radix * radix) + so cr < MM.max (radix * radix - d) (q0*radix) + so (cr >= q0 * radix + by + r' = radix * !r1 + !r0 + >= radix * !r1 + >= radix * q0) + so cr < radix * radix - d + so cr + d < radix * radix + so (cr + d >= 0 by cr + d >= cr) + so mod (cr + d) (radix * radix) = cr + d + else + r' = cr + radix * radix + so cr >= m - radix * radix + so r' >= m >= radix * radix - d + so r' + d >= radix * radix + so r' < radix * radix + so d < radix * radix + so r' + d < radix * radix + radix * radix + so mod (r' + d) (radix * radix) + = r' + d - radix * radix + = cr + d + }; + r1 := rh; + r0 := rl; + assert { !q1 * d + !r0 + radix * !r1 = u + by + cq * d + cr = u + so !q1 = cq - 1 + so !r0 + radix * !r1 = cr + d + so !q1 * d + !r0 + radix * !r1 + = (cq - 1) * d + cr + d + = cq * d - d + cr + d + = cq * d + cr }; + end + else assert { !q1 * d + r' = u + by cr >= 0 + so r' = cr + so 1 <= cq < radix + so !q1 * d + cr = u }; + assert { !q1 * d + !r0 + radix * !r1 = u }; + label PreRemAdjust in + if [@ex:unlikely] (Limb.(>) !r1 dh) || (Limb.(=) !r1 dh && Limb.(>=) !r0 dl) + then begin + let bl, b = sub_with_borrow !r0 dl zero in + let bh, ghost b'= sub_with_borrow !r1 dh b in + assert { b' = 0 }; + assert { bl + radix * bh = !r0 + radix * !r1 - d }; + assert { !q1 < radix - 1 + by !q1 * d + !r0 + radix * !r1 = u + so !r0 + radix * !r1 >= d + so um + radix * uh <= d - 1 + so u = ul + radix * (um + radix * uh) + <= ul + radix * (d - 1) + < radix + radix * (d-1) + = radix * d + so (!q1 * d < (radix - 1) * d + by + !q1 * d = u - (!r0 + radix * !r1) + <= u - d + < radix * d - d + = (radix - 1) * d ) + }; + q1 := add_mod !q1 one; + assert { !q1 = (!q1 at PreRemAdjust) + 1 }; + r1 := bh; + r0 := bl; + assert { !q1 * d + !r0 + radix * !r1 = u + by + !q1 * d + !r0 + radix * !r1 + = ((!q1 at PreRemAdjust) + 1) * d + + (!r0 + radix * !r1 at PreRemAdjust) - d + = (!q1 * d + !r0 + radix * !r1 at PreRemAdjust) + }; + end; + assert { 0 <= !r0 + radix * !r1 < d }; + (!q1,!r0,!r1) + + let lemma bounds_imply_rec3by2 (v dh dl:limb) + requires { radix * radix * radix - (dl + radix * dh) + <= (radix + v) * (dl + radix * dh) + < radix * radix * radix } + ensures { reciprocal_3by2 v dh dl } + = () + (*let ghost d = dl + radix * dh in + let ghost w = Limb.of_int (div (radix*radix*radix -1) d - radix) in + assert { reciprocal_3by2 w dh dl }; + let ghost e = v - w in + assert { radix * radix * radix - d + <= (radix + w) * d + < radix * radix * radix }; + assert { e = 0 }*) + + + let reciprocal_word_3by2 (dh dl:limb) : limb + requires { dh >= div radix 2 } + ensures { reciprocal_3by2 result dh dl } + = + let ghost d = l2i dl + radix * l2i dh in + let one = Limb.of_int 1 in + let v = ref (invert_limb dh) in + assert { radix * radix - dh + <= (radix + !v) * dh + < radix * radix + by + radix + !v = div (radix * radix - 1) (dh) }; + let p = ref (mul_mod dh !v) in + assert { (radix + !v) * dh + = radix * (radix-1) + + !p + by + mod ((radix + !v) * dh) radix + = mod (radix * dh + dh * !v) radix + = mod (dh * !v) radix = l2i !p + so + div ((radix + !v) * dh) radix = radix - 1 + so + (radix + !v) * dh + = radix * div ((radix + !v) * dh) radix + + mod (dh * !v) radix + = radix * (radix - 1) + !p + }; + label Estimate in + p := add_mod !p dl; + if Limb.(<) !p dl (* carry out *) + then begin + assert { (!p at Estimate) + dl >= radix }; + assert { (!p at Estimate) + dl = radix + !p }; + assert { !v >= 1 + by + (!p at Estimate) + dl >= radix + so (!p at Estimate) > 0 + }; + assert { (radix + !v) * dh + dl + = radix * (radix - 1) + radix + !p }; + label Carry in + if Limb.(>=) !p dh + then begin + v := Limb.(-) !v one; + p := Limb.(-) !p dh; + assert { (radix + !v) * dh + dl + = radix * (radix - 1) + radix + !p + }; + end; + label Borrow in + v := Limb.(-) !v one; + assert { !p < dh }; + p := sub_mod !p dh; + assert { !p = radix + !p at Borrow - dh }; + end; + assert { (radix + !v) * dh * radix + radix * dl + = radix * radix * (radix - 1) + radix * !p + by (radix + !v) * dh + dl + = radix * (radix - 1) + !p }; + assert { radix * radix - dh + <= (radix + !v) * dh + dl + < radix * radix }; + let tl, th = mul_double !v dl in + label Adjust in + p := add_mod !p th; + if Limb.(<) !p th (* carry out *) + then begin + assert { (!p at Adjust) + th >= radix }; + assert { (!p at Adjust) + th = radix + !p + by (!p at Adjust) + th < radix + radix + so div ((!p at Adjust) + th) radix = 1 + so !p = mod ((!p at Adjust) + th) radix + so (!p at Adjust) + th + = radix * div ((!p at Adjust) + th) radix + + mod ((!p at Adjust) + th) radix + = radix + !p + }; + assert { !v >= 1 + by + th <> 0 + so !v <> 0 + }; + if Limb.(>) !p dh || (Limb.(=) !p dh && Limb.(>=) tl dl) + then begin + assert { tl + radix * !p >= d }; + v := Limb.(-) !v one; + assert { (radix + !v) * dh * radix + radix * dl + + !v * dl + = radix * radix * radix + + radix * !p + tl - d + by + (radix + !v) * dh * radix + radix * dl + + !v * dl + = (radix + !v at Adjust - 1) * dh * radix + + radix * dl + + (!v at Adjust - 1) * dl + = (radix + !v at Adjust) * dh * radix + + radix * dl + + (!v at Adjust) * dl - radix * dh + - dl + = radix * radix * (radix - 1) + radix * (!p at Adjust) + + (!v at Adjust) * dl - radix * dh + - dl + = radix * radix * (radix - 1) + radix * (!p at Adjust) + + radix * th + tl - d + = radix * radix * (radix - 1) + radix * (radix + !p) + + tl - d + = radix * radix * (radix - 1) + radix * radix + radix * !p + + tl - d + = radix * radix * radix + radix * !p + tl - d + }; + end; + assert { radix * radix * radix + <= (radix + !v) * dh * radix + radix * dl + + !v * dl + < radix * radix * radix + d }; + v := Limb.(-) !v one; + end; + bounds_imply_rec3by2 !v dh dl; + !v + + let sub3 (x y z:limb) : (limb,limb) + returns { (r,d) -> x - y - z = l2i r - radix * l2i d + /\ 0 <= d <= 2 } + = + let limb_zero = Limb.of_int 0 in + let u1, b1 = sub_with_borrow x y limb_zero in + let u2, b2 = sub_with_borrow u1 z limb_zero in + (u2, (Limb.(+) b1 b2)) + + (** [submul_limb r x y sz] multiplies [(x, sz)] by [y], substracts the [sz] + least significant limbs from [(r, sz)] and writes the result in [(r,sz)]. + Returns the most significant limb of the product plus the borrow + of the substraction. Corresponds to [mpn_submul_1].*) + let submul_limb (r x:t) (y:limb) (sz:int32):limb + requires { valid x sz } + requires { valid r sz } + ensures { value r sz - (power radix sz) * result + = value (old r) sz + - value x sz * y } + writes { r.data.elts } + ensures { forall j. j < r.offset \/ r.offset + sz <= j -> + (pelts r)[j] = (pelts (old r))[j] } += + let limb_zero = Limb.of_int 0 in + let lx = ref limb_zero in + let lr = ref limb_zero in + let b = ref limb_zero in + let i = ref (Int32.of_int 0) in + while Int32.(<) !i sz do + variant { sz - !i } + invariant { 0 <= !i <= sz } + invariant { value r !i - (power radix !i) * !b + = value (old r) !i + - value x !i * y } + invariant { forall j. !i <= j < sz -> + (pelts (old r)) [r.offset+j] = (pelts r)[r.offset + j] } + invariant { forall j. j < r.offset \/ r.offset + sz <= j -> + (pelts r)[j] = (pelts (old r))[j] } + label StartLoop in + let ghost k = p2i !i in + lx := get_ofs x !i; + lr := get_ofs r !i; + assert { !lr = (pelts (old r))[r.offset + !i] }; + let rl, rh = Limb.mul_double !lx y in + let res, borrow = sub3 !lr rl !b in + value_sub_tail (pelts r) r.offset (r.offset + k); + value_sub_tail (pelts x) x.offset (x.offset + k); + value_sub_update (pelts r) (r.offset + p2i !i) + r.offset (r.offset + p2i !i +1) res; + set_ofs r !i res; + assert { forall j. (!i + 1) <= j < sz -> + (pelts (old r))[r.offset+j] = (pelts r)[r.offset+j] + by + (pelts r)[r.offset+j] = ((pelts r) at StartLoop)[r.offset+j] + = (pelts (old r))[r.offset+j] }; + assert { value r (!i + 1) + = value (r at StartLoop) (!i + 1) + + (power radix !i) * (res - !lr) + }; + assert { rl + radix * rh <= (radix-1)*(radix-1) + by + (!lx * y <= !lx * (radix-1) <= (radix-1)*(radix-1) + by + 0 <= !lx <= radix - 1 /\ 0 <= y <= radix -1) + /\ + rl + radix * rh = !lx * y + }; + assert { rh < radix - 1 + by + rl + radix * rh <= (radix -1) * (radix -1) + so + radix * rh <= (radix -1) * (radix -1) + }; + assert { rh = radix - 2 -> rl <= 1 + by + rl + radix * rh <= (radix-1)*(radix-1) }; + assert { rh = radix - 2 -> borrow <= 1 + by rl <= 1 }; + b := Limb.(+) rh borrow; + i := Int32.(+) !i (Int32.of_int 1); + assert { value r !i - (power radix !i) * !b + = value (old r) !i + - value x !i * y + by + (value r !i - (power radix !i) * !b + = value (r at StartLoop) !i + + (power radix k) * (res - !lr) + - (power radix !i) * !b + = value (r at StartLoop) !i + + (power radix k) * (res - !lr) + - (power radix !i) * (rh + borrow) + = value (r at StartLoop) !i + + (power radix k) * (res - !lr) + - (power radix k) * radix * (rh + borrow) + = value (r at StartLoop) !i + + (power radix k) * (res - !lr + - radix * (rh + borrow)) + = value (r at StartLoop) !i + + (power radix k) * (res - radix * borrow + - !lr - radix * rh) + = value (r at StartLoop) !i + + (power radix k) * (!lr - rl - (!b at StartLoop) + - !lr - radix * rh) + = value (r at StartLoop) !i - + (power radix k) * (rl + radix * rh + (!b at StartLoop)) + = value (r at StartLoop) !i - + (power radix k) * (!lx * y + (!b at StartLoop)) + = value (r at StartLoop) k + + (power radix k) * !lr + - (power radix k) * (!lx * y + (!b at StartLoop)) + = value (r at StartLoop) k + - (power radix k) * (!b at StartLoop) + + (power radix k) * (!lr - !lx * y) + = value (old r) k + - value x k * y + + (power radix k) * (!lr - !lx * y) + = value (old r) k + + (power radix k) * !lr + - (value x k + (power radix k)*(!lx)) * y + = value (old r) !i + - (value x k + (power radix k)*(!lx)) * y + = value (old r) !i + - value x !i * y + by + value (old r) !i = value (old r) k + + (power radix k) * (!lr) + ) + }; + done; + !b + + (* [(x,sz)] is normalized if its most significant bit is set. *) + predicate normalized (x:t) (sz:int32) = + valid x sz + /\ (pelts x)[x.offset + sz - 1] >= div radix 2 + + let div_sb_qr (q x y:t) (sx sy:int32) : limb + requires { 3 <= sy <= sx } + requires { valid x sx } + requires { valid y sy } + requires { valid q (sx - sy) } + requires { normalized y sy } + ensures { value (old x) sx = + (value q (sx - sy) + + power radix (sx - sy) * result) + * value y sy + + value x sy } + ensures { value x sy < value y sy } + ensures { 0 <= result <= 1 } + = + let one = Int32.of_int 1 in + let two = Int32.of_int 2 in + let limb_zero = Limb.of_int 0 in + let zero = Int32.of_int 0 in + let uone = Limb.of_int 1 in + let xp = ref (C.incr x (Int32.(-) sx two)) in + let qp = ref (C.incr q (Int32.(-) sx sy)) in + let dh = C.get_ofs y (Int32.(-) sy one) in + assert { dh >= div radix 2 by normalized y sy }; + let dl = C.get_ofs y (Int32.(-) sy two) in + let v = reciprocal_word_3by2 dh dl in + let i = ref (Int32.(-) sx sy) in + let mdn = Int32.(-) two sy in + let ql = ref limb_zero in + let xd = C.incr !xp mdn in + let ghost vy = value y (p2i sy) in + let x1 = ref limb_zero in + let x0 = ref limb_zero in + let r = compare_same_size xd y sy in + let qh = (*begin + ensures { r >= 0 -> result = 1 } + ensures { r < 0 -> result = 0 }*) + if (Int32.(>=) r zero) + then uone + else limb_zero + (*end*) in + label PreAdjust in + begin + ensures { value (old x) sx = + (value !qp (sx - sy - !i) + + qh * power radix (sx - sy - !i)) + * vy * power radix !i + + value x (sy + !i - 1) + + power radix (sy + !i - 1) * !x1 } + ensures { value_sub (pelts x) (!xp.offset + mdn) + (!xp.offset + mdn + sy - 1) + + power radix (sy - 1) * !x1 + < vy } + ensures { dl + radix * dh + >= (pelts x)[(!xp).offset] + radix * !x1 } + let ghost ox = pelts x in + begin [@vc:sp] + if (not (Limb.(=) qh limb_zero)) + then begin + assert { qh = 1 }; + let ghost b = sub_in_place xd y sy sy in + begin + ensures { value (x at PreAdjust) sx = + (value !qp (sx - sy - !i) + + qh * power radix (sx - sy - !i)) + * vy * power radix !i + + value x sx } + ensures { value_sub (pelts x) (!xp.offset + mdn) + (!xp.offset + mdn + sy) + < vy } + value_sub_upper_bound (pelts x) xd.offset (xd.offset + p2i sy); + assert { b = 0 }; + assert { value (xd at PreAdjust) sy + = value xd sy + vy }; + value_sub_concat (pelts x) x.offset xd.offset (xd.offset + p2i sy); + value_sub_concat ox x.offset xd.offset (xd.offset + p2i sy); + value_sub_frame (pelts x) ox x.offset xd.offset; + assert { value (x at PreAdjust) sx + = value x sx + + power radix (sx - sy) * vy + by + value_sub (pelts (x at PreAdjust)) x.offset xd.offset + = value_sub (pelts x) x.offset xd.offset + so pelts (xd at PreAdjust) = pelts (x at PreAdjust) + so value_sub (pelts (x at PreAdjust)) xd.offset (xd.offset + sy) + = value (xd at PreAdjust) sy + so value (x at PreAdjust) sx + = value_sub (pelts (x at PreAdjust)) x.offset xd.offset + + power radix (sx - sy) + * value_sub (pelts (x at PreAdjust)) xd.offset (xd.offset + sy) + = value_sub (pelts x) x.offset xd.offset + + power radix (sx - sy) + * value (xd at PreAdjust) sy + = value_sub (pelts x) x.offset xd.offset + + power radix (sx - sy) + * (value xd sy + vy) + = value_sub (pelts x) x.offset xd.offset + + power radix (sx - sy) + * (value_sub (pelts x) (xd.offset) (xd.offset + sy) + vy) + = value_sub (pelts x) x.offset xd.offset + + power radix (sx - sy) + * value_sub (pelts x) (xd.offset) (xd.offset + sy) + + power radix (sx - sy) * vy + = value x sx + + power radix (sx - sy) * vy + }; + value_sub_tail (pelts x) x.offset (x.offset + p2i sy + p2i !i - 1); + assert { value (x at PreAdjust) sx = + (value !qp (sx - sy - !i) + + qh * power radix (sx - sy - !i)) + * vy * power radix !i + + value x sx + by + !i = sx - sy + so power radix (sx - sy - !i) = 1 + so value !qp (sx - sy - !i) = 0 }; + value_sub_lower_bound_tight (pelts y) y.offset (y.offset + p2i sy); + assert { value_sub (pelts x) (!xp.offset + mdn) + (!xp.offset + mdn + sy) + < vy + by + value_sub (pelts x) (!xp.offset + mdn) + (!xp.offset + mdn + sy) + = value xd sy + = value (xd at PreAdjust) sy - vy + so value (xd at PreAdjust) sy + < power radix sy + so vy >= dh * power radix (sy - 1) + so 2 * vy >= 2 * dh * power radix (sy - 1) + so 2 * dh >= radix + so 2 * dh * power radix (sy - 1) >= radix * power radix (sy - 1) + so 2 * vy >= radix * power radix (sy - 1) = power radix sy + so value (xd at PreAdjust) sy < 2 * vy + so value (xd at PreAdjust) sy - vy < vy }; + end + end + else begin + assert { value_sub (pelts x) (!xp.offset + mdn) + (!xp.offset + mdn + sy) + < vy + by r < 0 }; + assert { value (x at PreAdjust) sx = + (value !qp (sx - sy - !i) + + qh * power radix (sx - sy - !i)) + * vy * power radix !i + + value x sx + by qh = 0 + so sx - sy - !i = 0 + so (value !qp (sx - sy - !i) + + qh * power radix (sx - sy - !i)) = 0 }; + end + end; + let ghost gx1 = (C.get_ofs !xp one) in + value_sub_tail (pelts y) y.offset (y.offset + p2i sy - 1); + value_sub_upper_bound_tight (pelts y) y.offset (y.offset + p2i sy - 1); + value_sub_tail (pelts x) (!xp.offset) (!xp.offset + p2i sy - 1); + value_sub_lower_bound_tight (pelts x) (!xp.offset) (!xp.offset + p2i sy - 1); + assert { dl + radix * dh + >= (pelts x)[(!xp).offset] + radix * gx1 + by value_sub (pelts x) (!xp.offset + mdn) + (!xp.offset + mdn + sy) + < vy + so value y (sy - 1) < (dl + 1) * power radix (sy - 1 - 1) + so vy = dh * power radix (sy - 1) + + value y (sy - 1) + < dh * power radix (sy - 1) + + (dl + 1) * power radix (sy - 1 - 1) + = power radix (sy - 2) * (dl+1 + radix * dh) + so !xp.offset + mdn + sy - 1 = !xp.offset + 1 + so (pelts x)[!xp.offset + mdn + sy - 1] + = (pelts x)[!xp.offset + 1] = gx1 + so value_sub (pelts x) (!xp.offset + mdn) (!xp.offset + mdn + sy) + = gx1 * power radix (sy - 1) + + value_sub (pelts x) (!xp.offset + mdn) + (!xp.offset + mdn + sy - 1) + >= gx1 * power radix (sy - 1) + + (pelts x)[!xp.offset] * power radix (sy - 1 - 1) + = power radix (sy - 2) + * ((pelts x) [!xp.offset] + radix * gx1) + so power radix (sy - 2) * ((pelts x) [!xp.offset] + radix * gx1) + < power radix (sy - 2) * (dl+1 + radix * dh) + so (pelts x) [!xp.offset] + radix * gx1 + < dl + 1 + radix * dh + }; + value_sub_tail (pelts x) (!xp.offset + p2i mdn) + (!xp.offset + p2i mdn + p2i sy - 1); + value_sub_tail (pelts x) x.offset (x.offset + p2i sy + p2i !i - 1); + + x1 := (C.get_ofs !xp one); + assert { value_sub (pelts x) (!xp.offset + mdn) + (!xp.offset + mdn + sy - 1) + + power radix (sy - 1) * !x1 + < vy + by + !xp.offset + mdn + sy - 1 = !xp.offset + 1 + so value_sub (pelts x) (!xp.offset + mdn) + (!xp.offset + mdn + sy - 1) + + power radix (sy - 1) * !x1 + = value_sub (pelts x) (!xp.offset + mdn) + (!xp.offset + mdn + sy - 1) + + power radix (sy - 1) * (pelts x)[!xp.offset + 1] + = value_sub (pelts x) (!xp.offset + mdn) + (!xp.offset + mdn + sy - 1) + + power radix (sy - 1) + * (pelts x)[!xp.offset + mdn + sy - 1] + = value_sub (pelts x) (!xp.offset + mdn) + (!xp.offset + mdn + sy) + < vy }; + assert { value (x at PreAdjust) sx = + (value !qp (sx - sy - !i) + + qh * power radix (sx - sy - !i)) + * vy * power radix !i + + value x (sy + !i - 1) + + power radix (sy + !i - 1) * !x1 + by value (x at PreAdjust) sx = + (value !qp (sx - sy - !i) + + qh * power radix (sx - sy - !i)) + * vy * power radix !i + + value x sx + so sx = sy + !i + so x.offset + sy + !i - 1 = !xp.offset + 1 + so (pelts x)[x.offset + sy + !i - 1] = + (pelts x)[!xp.offset + 1]= !x1 + so value x sx + = value x (sx - 1) + + power radix (sx -1) * (pelts x)[x.offset + sx - 1] + = value x (sy + !i - 1) + + power radix (sy + !i - 1) * (pelts x)[x.offset + sy + !i - 1] + so value x (sy + !i - 1) + + power radix (sy + !i - 1) * !x1 + = value x sx + }; + end; + while (Int32.(>) !i zero) do + variant { p2i !i } + invariant { 0 <= !i <= sx - sy } + invariant { (!qp).offset = q.offset + !i } + invariant { (!xp).offset = x.offset + sy + !i - 2 } + invariant { plength !qp = plength q } + invariant { !qp.min = q.min } + invariant { !qp.max = q.max } + invariant { plength !xp = plength x } + invariant { !xp.min = x.min } + invariant { !xp.max = x.max } + invariant { pelts !qp = pelts q } + invariant { pelts !xp = pelts x } + invariant { value (old x) sx = + (value !qp (sx - sy - !i) + + qh * power radix (sx - sy - !i)) + * vy * power radix !i + + value x (sy + !i - 1) + + power radix (sy + !i - 1) * !x1 } + invariant { value_sub (pelts x) (!xp.offset + mdn) + (!xp.offset + mdn + sy - 1) + + power radix (sy - 1) * !x1 + < vy } + invariant { dl + radix * dh + >= (pelts x)[(!xp).offset] + radix * !x1 } + label StartLoop in + let ghost k = int32'int !i in + i := Int32.(-) !i one; + let ghost s = int32'int sy + int32'int !i - 1 in + xp.contents <- C.incr !xp (-1); + let xd = C.incr !xp mdn in + let nx0 = C.get_ofs !xp one in + if [@ex:unlikely] (Limb.(=) !x1 dh && Limb.(=) nx0 dl) + then begin + ql := Limb.of_int Limb.max_uint64; + value_sub_concat (pelts x) x.offset xd.offset (xd.offset + p2i sy); + value_sub_tail (pelts xd) xd.offset (xd.offset + p2i sy - 1); + let ghost vlx = value xd (p2i sy - 1) in + assert { value xd sy + = vlx + power radix (sy - 1) * dl + by value xd sy + = vlx + power radix (sy - 1) + * (pelts xd)[xd.offset + sy - 1] + so xd.offset + sy - 1 = !xp.offset + mdn + sy - 1 + = !xp.offset + 1 + so pelts xd = pelts !xp + so (pelts xd)[xd.offset + sy - 1] + = (pelts !xp)[!xp.offset + 1] = dl + }; + value_sub_tail (pelts y) y.offset (y.offset + p2i sy - 1); + value_sub_tail (pelts y) y.offset (y.offset + p2i sy - 2); + let ghost vly = value y (p2i sy - 2) in + assert { vy = vly + power radix (sy - 2) * dl + + power radix (sy - 1) * dh + by (pelts y)[y.offset + sy - 1] = dh + so (pelts y)[y.offset + sy - 2] = dl + so + vy = value y (sy - 1) + + power radix (sy - 1) * dh + = vly + power radix (sy - 2) * dl + + power radix (sy - 1) * dh }; + begin + ensures { value_sub (pelts xd) (xd.offset+1) (xd.offset + p2i sy - 1) + + power radix (sy - 2) * dl + + power radix (sy - 1) * dh + < vy } + value_sub_tail (pelts xd) (xd.offset + 1) (xd.offset + p2i sy - 2); + assert { value_sub (pelts x) (!xp.offset at StartLoop + mdn) + (!xp.offset at StartLoop + mdn + sy - 1) + = value_sub (pelts xd) (xd.offset+1) (xd.offset + p2i sy - 1) + + power radix (sy - 2) * dl + by + pelts x = pelts xd + so !xp.offset at StartLoop + mdn = xd.offset + 1 + so !xp.offset at StartLoop + mdn + sy - 1 = xd.offset + sy + so xd.offset + sy - 1 = !xp.offset + 1 + so pelts xd = pelts !xp + so (pelts xd)[xd.offset + sy - 1] = (pelts !xp)[!xp.offset+1] = dl + so value_sub (pelts x) (!xp.offset at StartLoop + mdn) + (!xp.offset at StartLoop + mdn + sy - 1) + = value_sub (pelts xd) (xd.offset+1) (xd.offset + sy) + = value_sub (pelts xd) (xd.offset+1) (xd.offset + p2i sy - 1) + + power radix (sy - 2) + * (pelts xd)[xd.offset + p2i sy - 1] + = value_sub (pelts xd) (xd.offset+1) (xd.offset + p2i sy - 1) + + power radix (sy - 2) * dl + }; + assert { !x1 = dh }; + end; + label SubMax in + let ghost xc = Array.copy (x.data) in + value_sub_frame (pelts x) xc.elts x.offset (x.offset + p2i !i); + let ghost b = submul_limb xd y !ql sy in + begin + ensures { value x !i + = value (x at SubMax) !i } + assert { forall j. x.offset <= j < x.offset + !i + -> (pelts x)[j] = xc.elts[j] + by + (pelts x)[j] = (pelts x at SubMax)[j] + so + ((pelts x at SubMax)[j] = xc.elts[j] + by + 0 <= j /\ j < xc.Array.length + ) }; + value_sub_frame (pelts x) xc.elts x.offset (x.offset + p2i !i); + end; + value_sub_upper_bound (pelts xd) xd.offset (xd.offset + p2i sy); + value_sub_lower_bound (pelts xd) xd.offset (xd.offset + p2i sy); + value_sub_head (pelts xd) xd.offset (xd.offset + p2i sy - 1); + assert { vlx < radix * vly + by + vlx = value_sub (pelts xd at SubMax) xd.offset + (xd.offset + sy - 1) + = (pelts xd at SubMax)[xd.offset] + + radix * value_sub (pelts xd at SubMax) + (xd.offset + 1) + (xd.offset + sy - 1) + so value_sub (pelts xd at SubMax) (xd.offset + 1) + (xd.offset + sy - 1) + + power radix (sy - 2) * dl + + power radix (sy - 1) * dh + < vy + = vly + power radix (sy - 2) * dl + + power radix (sy - 1) * dh + so value_sub (pelts xd at SubMax) (xd.offset + 1) + (xd.offset + sy - 1) + < vly + so value_sub (pelts xd at SubMax) (xd.offset + 1) + (xd.offset + sy - 1) + <= vly - 1 + so vlx = (pelts xd at SubMax)[xd.offset] + + radix * value_sub (pelts xd at SubMax) + (xd.offset + 1) + (xd.offset + sy - 1) + <= (pelts xd at SubMax)[xd.offset] + + radix * (vly - 1) + < radix + radix * (vly - 1) + = radix * vly + }; + assert { b = dh + by + value xd sy + = value (xd at SubMax) sy + - (!ql) * vy + + power radix sy * b + so !ql = radix - 1 + so 0 <= value xd sy < power radix sy + so radix * power radix (sy - 2) = power radix (sy - 1) + so radix * power radix (sy - 1) = power radix sy + so value xd sy + = power radix (sy - 1) * dl + vlx + - (radix - 1) * vy + + power radix sy * b + = power radix (sy - 1) * dl + vlx + - radix * (vly + power radix (sy - 2) * dl + + power radix (sy - 1) * dh) + + vy + power radix sy * b + = power radix (sy - 1) * dl + vlx + - radix * vly - radix * power radix (sy - 2) * dl + - radix * power radix (sy - 1) * dh + + vy + power radix sy * b + = power radix (sy - 1) * dl + vlx + - radix * vly - power radix (sy - 1) * dl + - power radix sy * dh + + vy + power radix sy * b + = power radix sy * (b - dh) + + vlx - radix * vly + vy + so vlx < radix * vly + so (0 <= vlx - radix * vly + vy < power radix sy + by + vy - radix * vly + = vly + power radix (sy - 2) * dl + + power radix (sy - 1) * dh + - radix * vly + = power radix (sy - 2) * (dl + radix * dh) + - vly * (radix - 1) + so let pr2 = power radix (sy - 2) in + 0 <= vly < pr2 + so 0 <= vly * (radix - 1) < pr2 * (radix - 1) + so vy - radix * vly + >= pr2 * (dl + radix * dh) + - pr2 * (radix - 1) + = pr2 * (dl + radix * dh - (radix - 1)) + so dh + radix * dh - (radix - 1) >= 0 + so pr2 >= 0 + so vy - radix * vly + >= pr2 * (dl + radix * dh - (radix - 1)) >= 0 + so vlx - radix * vly < 0 + so vlx - radix * vly + vy < vy < power radix sy + ) + so - (power radix sy) + < power radix sy * (b - dh) + < power radix sy + so - 1 < b - dh < 1 + }; + value_sub_concat (pelts x) x.offset xd.offset (x.offset + s); + x1 := C.get_ofs !xp one; + qp.contents <- C.incr !qp (-1); + value_sub_update_no_change (pelts q) (!qp).offset + ((!qp).offset + 1) + ((!qp).offset + p2i sx - p2i sy - p2i !i) + !ql; + label QUp in + C.set !qp !ql; + assert { value_sub (pelts q) ((!qp).offset + 1) + ((!qp).offset + sx - sy - !i) + = value (!qp at StartLoop) + (sx - sy - k) + by value_sub (pelts q) ((!qp).offset + 1) + ((!qp).offset + sx - sy - !i) + = value_sub (pelts q at QUp) (!qp.offset + 1) + ((!qp).offset + sx - sy - !i) + = value (!qp at StartLoop) (sx - sy - k) + (* by offset !qp at StartLoop = (!qp).offset + 1 + so offset (!qp at StartLoop) + sx - sy - k + = (!qp).offset + sx - sy - !i + so map_eq_sub_shift (pelts q) (pelts !qp at StartLoop) + ((!qp).offset + 1) ((!qp).offset + 1) (sx + sy - k) *) }; + value_sub_head (pelts q) (!qp).offset + ((!qp).offset + p2i sx - p2i sy - p2i !i); + value_sub_tail (pelts x) x.offset (x.offset + p2i sy + p2i !i - 1); + assert { value xd (sy - 1) + + power radix (sy - 1) * !x1 + = value (xd at SubMax) sy + + power radix sy * (!x1 at StartLoop) + - !ql * vy + by + value xd sy + = value (xd at SubMax) sy + - (!ql) * vy + + power radix sy * b + so b = dh = !x1 at StartLoop + so pelts !xp = pelts x = pelts xd + so ((pelts xd)[xd.offset + sy - 1] = !x1 + by + xd.offset = x.offset + !i + so (!xp).offset = x.offset + !i + sy - 2 + so (!xp).offset + 1 = xd.offset + sy - 1 + so (pelts xd)[xd.offset + sy - 1] + = (pelts !xp)[(!xp).offset + 1] + = !x1 + ) + so value xd sy + = value xd (sy - 1) + + power radix (sy - 1) * (pelts xd)[xd.offset + sy - 1] + = value xd (sy - 1) + + power radix (sy - 1) * !x1 + }; + (* refl *) + assert { value (old x) sx = + (value !qp (sx - sy - !i) + + qh * power radix (sx - sy - !i)) + * vy * power radix !i + + value x (sy + !i - 1) + + power radix (sy + !i - 1) * !x1 + by + pelts !xp = pelts x = pelts xd + so + value xd sy + = value (xd at SubMax) sy + - (!ql) * vy + + power radix sy * b + = value (xd at SubMax) sy + - (!ql) * vy + + power radix sy * dh + so (value x s + = value x !i + + power radix !i + * value xd (sy - 1) + by + xd.offset = x.offset + !i + so x.offset + s = xd.offset + sy - 1 + so value_sub (pelts x) (x.offset + !i) (x.offset + s) + = value xd (sy - 1) + so value x s + = value x !i + + power radix !i + * value_sub (pelts x) (x.offset + !i) + (x.offset + s) + = value x !i + + power radix !i + * value xd (sy - 1)) + so (power radix s + = power radix !i * power radix (sy - 1) + by + let n = !i in + let m = sy - 1 in + let x = radix in + power x s = power x (n + m) + so (power x (n + m) = power x n * power x m + by 0 <= n + so 0 <= m + so forall x:int, n:int, m:int. + 0 <= n -> 0 <= m -> + power x (n + m) = (power x n * power x m))) + so (value x s + power radix s * !x1 + = value x !i + + power radix !i * (value xd sy) + by + value x s + power radix s * !x1 + = value x !i + + power radix !i + * value xd (sy - 1) + + power radix (!i + sy - 1) * !x1 + = value x !i + + power radix !i * + (value xd (sy - 1) + + power radix (sy - 1) * !x1) + = value x !i + + power radix !i * (value xd sy) + ) + so (value (x at StartLoop) (sy + k - 1) + = value (x at SubMax) !i + + power radix !i + * value (xd at SubMax) sy + by + pelts xd at SubMax = pelts x at SubMax + so x.offset at SubMax + !i = xd.offset at SubMax + so + value (x at StartLoop) (sy + k - 1) + = value_sub (pelts x at SubMax) (x at SubMax).offset + (xd.offset at SubMax) + + power radix !i + * value_sub (pelts x at SubMax) + (xd.offset at SubMax) + (xd.offset at SubMax + sy) + so value_sub (pelts x at SubMax) (x at SubMax).offset + (xd at SubMax).offset + = value (x at SubMax) !i + so value_sub (pelts x at SubMax) (xd.offset at SubMax) + (xd.offset at SubMax + sy) + = value (xd at SubMax) sy + ) + so value x !i + = value (x at SubMax) !i + so value x s + power radix s * !x1 + = value (x at StartLoop) (sy + k - 1) + + power radix !i + * (value xd sy + - value (xd at SubMax) sy) + = value (x at StartLoop) (sy + k - 1) + + power radix !i + * (- (!ql) * vy + + power radix sy * b) + = value (x at StartLoop) (sy + k - 1) + + power radix !i + * (- (!ql) * vy + + power radix sy * (!x1 at StartLoop)) + so value !qp (sx - sy - !i) + = !ql + radix * + value_sub (pelts q) ((!qp).offset + 1) + ((!qp).offset + sx - sy - !i) + so (value_sub (pelts q) ((!qp).offset + 1) + ((!qp).offset + sx - sy - !i) + = value (!qp at StartLoop) + (sx - sy - k) + by value (!qp at StartLoop) (sx - sy - k) + = value_sub (pelts q at StartLoop) + (!qp.offset + 1) (!qp.offset + sx - sy - !i)) + so value !qp (sx - sy - !i) + = !ql + radix * value (!qp at StartLoop) + (sx - sy - k) + so power radix (sx - sy - !i) + = radix * power radix (sx - sy - k) + so radix * power radix !i = power radix k + so (power radix !i * power radix sy + = power radix (sy + k - 1) + by !i + sy = sy + k - 1 + so power radix !i * power radix sy + = power radix (!i + sy)) + so (value !qp (sx - sy - !i) + + qh * power radix (sx - sy - !i)) + * vy * power radix !i + + value x (sy + !i - 1) + + power radix (sy + !i - 1) * !x1 + = (!ql + radix * value (!qp at StartLoop) + (sx - sy - k) + + qh * power radix (sx - sy - !i)) + * vy * power radix !i + + value x (sy + !i - 1) + + power radix (sy + !i - 1) * !x1 + = (!ql + radix * value (!qp at StartLoop) + (sx - sy - k) + + radix * qh * power radix (sx - sy - k)) + * vy * power radix !i + + value x (sy + !i - 1) + + power radix (sy + !i - 1) * !x1 + = (!ql + radix * value (!qp at StartLoop) + (sx - sy - k) + + radix * qh * power radix (sx - sy - k)) + * vy * power radix !i + + value x s + + power radix s * !x1 + = !ql * vy * power radix !i + + radix * (value (!qp at StartLoop) + (sx - sy - k) + + qh * power radix (sx - sy - k)) + * vy * power radix !i + + value x s + + power radix s * !x1 + = !ql * vy * power radix !i + + (value (!qp at StartLoop) + (sx - sy - k) + + qh * power radix (sx - sy - k)) + * vy * radix * power radix !i + + value x s + + power radix s * !x1 + = !ql * vy * power radix !i + + (value (!qp at StartLoop) + (sx - sy - k) + + qh * power radix (sx - sy - k)) + * vy * power radix k + + value x s + + power radix s * !x1 + = !ql * vy * power radix !i + + (value (!qp at StartLoop) + (sx - sy - k) + + qh * power radix (sx - sy - k)) + * vy * power radix k + + value (x at StartLoop) (sy + k - 1) + + power radix !i + * (- (!ql) * vy + + power radix sy * (!x1 at StartLoop)) + = (value (!qp at StartLoop) + (sx - sy - k) + + qh * power radix (sx - sy - k)) + * vy * power radix k + + value (x at StartLoop) (sy + k - 1) + + power radix !i * power radix sy + * (!x1 at StartLoop) + = (value (!qp at StartLoop) + (sx - sy - k) + + qh * power radix (sx - sy - k)) + * vy * power radix k + + value (x at StartLoop) (sy + k - 1) + + power radix (sy + k - 1) * (!x1 at StartLoop) + = value (old x) sx + }; + assert { value_sub (pelts x) (!xp.offset + mdn) + (!xp.offset + mdn + sy - 1) + + power radix (sy - 1) * !x1 + < vy + by + pelts x = pelts xd + so xd.offset = !xp.offset + mdn + so !xp.offset + mdn + sy - 1 = xd.offset + sy - 1 + so + value xd (sy - 1) + = value_sub (pelts xd) xd.offset (xd.offset + sy - 1) + = value_sub (pelts x) (!xp.offset + mdn) + (!xp.offset + mdn + sy - 1) + so value_sub (pelts x) (!xp.offset + mdn) + (!xp.offset + mdn + sy - 1) + + power radix (sy - 1) * !x1 + = value (xd at SubMax) sy + + power radix sy * (!x1 at StartLoop) + - !ql * vy + so value (xd at SubMax) sy = + vlx + power radix (sy - 1) * dl + so vlx < radix * vly + so (value (xd at SubMax) sy + + power radix sy * (!x1 at StartLoop) + < radix * vy + by + !x1 at StartLoop = dh + so power radix sy = radix * power radix (sy - 1) + so power radix (sy - 1) = radix * power radix (sy - 2) + so value (xd at SubMax) sy + + power radix sy * (!x1 at StartLoop) + = vlx + power radix (sy - 1) * dl + + power radix sy * dh + < radix * vly + power radix (sy - 1) * dl + + power radix sy * dh + = radix * vly + radix * power radix (sy - 2) * dl + + radix * power radix (sy - 1) * dh + = radix * (vly + power radix (sy - 2) * dl + + power radix (sy - 1) * dh) + = radix * vy + ) + so !ql = radix - 1 + so value (xd at SubMax) sy + + power radix sy * (!x1 at StartLoop) + - !ql * vy + < radix * vy - (radix - 1) * vy + = vy + }; + value_sub_tail (pelts x) (!xp.offset + p2i mdn) (!xp.offset); + value_sub_upper_bound (pelts y) (y.offset) (y.offset + p2i sy - 2); + value_sub_lower_bound (pelts x) (!xp.offset + p2i mdn) (!xp.offset); + assert { dl + radix * dh + >= (pelts x)[(!xp).offset] + radix * !x1 + by + vy = vly + power radix (sy - 2) + * (dl + radix * dh) + so value_sub (pelts x) (!xp.offset + mdn) + (!xp.offset + mdn + sy - 1) + + power radix (sy - 1) * !x1 + < vy + so !xp.offset + mdn + sy - 1 = !xp.offset + 1 + so power radix (sy - 1) = power radix (sy - 2) * radix + so - mdn = sy - 2 + so vy + > value_sub (pelts x) (!xp.offset + mdn) + (!xp.offset + mdn + sy - 1) + + power radix (sy - 1) * !x1 + = value_sub (pelts x) (!xp.offset + mdn) + (!xp.offset + 1) + + power radix (sy - 1) * !x1 + = value_sub (pelts x) (!xp.offset + mdn) (!xp.offset) + + power radix (- mdn) * (pelts x)[(!xp).offset] + + power radix (sy - 1) * !x1 + = value_sub (pelts x) (!xp.offset + mdn) (!xp.offset) + + power radix (sy - 2) * (pelts x)[(!xp).offset] + + power radix (sy - 1) * !x1 + = value_sub (pelts x) (!xp.offset + mdn) (!xp.offset) + + power radix (sy - 2) * (pelts x)[(!xp).offset] + + power radix (sy - 2) * radix * !x1 + = value_sub (pelts x) (!xp.offset + mdn) (!xp.offset) + + power radix (sy - 2) + * ((pelts x)[(!xp).offset] + radix * !x1) + >= power radix (sy - 2) + * ((pelts x)[(!xp).offset] + radix * !x1) + so vly < power radix (sy - 2) + so vy < power radix (sy - 2) + + power radix (sy - 2) + * (dl + radix * dh) + = power radix (sy - 2) + * (1 + dl + radix * dh) + so power radix (sy - 2) + * ((pelts x)[(!xp).offset] + radix * !x1) + < power radix (sy - 2) * (1 + dl + radix * dh) + so power radix (sy - 2) + * ((pelts x)[(!xp).offset] + radix * !x1 + - (1 + dl + radix * dh)) + < 0 + so (pelts x)[(!xp).offset] + radix * !x1 + - (1 + dl + radix * dh) + < 0 + }; + end + else begin + assert { dl + radix * dh + > (pelts x)[(!xp).offset + 1] + radix * !x1 + by + dl + radix * dh + >= (pelts x)[(!xp).offset + 1] + radix * !x1 + so dh >= !x1 + so [@case_split] dh <> !x1 + \/ (dh = !x1 + /\ dl <> (pelts x)[(!xp).offset + 1]) + so + [@case_split] dh > !x1 \/ + (dh = !x1 /\ dl > (pelts x)[(!xp).offset + 1]) + }; + label SmallDiv in + let ghost vlx = value xd (p2i sy - 2) in + let xp0 = C.get !xp in + let xp1 = C.get_ofs !xp one in + begin + ensures { value xd sy = + vlx + + power radix (sy - 2) * (xp0 + radix * xp1) } + value_sub_tail (pelts xd) xd.offset (xd.offset + p2i sy - 1); + value_sub_tail (pelts xd) xd.offset (xd.offset + p2i sy - 2); + value_sub_upper_bound (pelts xd) xd.offset (xd.offset + p2i sy - 2); + assert { value xd sy + = vlx + power radix (sy - 2) + * (xp0 + radix * xp1) + by xd.offset + sy - 2 = !xp.offset + so (pelts xd)[xd.offset + sy - 1] = xp1 + so (pelts xd)[xd.offset + sy - 2] = xp0 + so pelts xd = pelts !xp + so value xd sy + = value xd (sy - 1) + + power radix (sy - 1) + * (pelts xd)[xd.offset + sy - 1] + = value xd (sy - 2) + + power radix (sy - 2) + * (pelts xd)[xd.offset + sy - 2] + + power radix (sy - 1) + * (pelts xd)[xd.offset + sy - 1] + = vlx + + power radix (sy - 2) * xp0 + + power radix (sy - 1) * xp1 + = value xd (sy - 2) + + power radix (sy - 2) * xp0 + + power radix (sy - 2) * radix * xp1 + = vlx + power radix (sy - 2) + * (xp0 + radix * xp1) + }; + end; + let qu, rl, rh = + div3by2_inv !x1 xp1 xp0 dh dl v in + ql := qu; + x1 := rh; + x0 := rl; + label SubProd in + value_sub_concat (pelts x) x.offset xd.offset + (x.offset + p2i sy + k - 1); + let ghost xc = Array.copy (x.data) in + value_sub_frame (pelts x) xc.elts x.offset (x.offset + p2i !i); + let cy = submul_limb xd y !ql (Int32.(-) sy two) in + label PostSub in + begin + ensures { value x !i + = value (x at SubProd) !i } + assert { forall j. x.offset <= j < x.offset + !i + -> (pelts x)[j] = xc.elts[j] + by + (pelts x)[j] = (pelts x at SubProd)[j] + so + ((pelts x at SubProd)[j] = xc.elts[j] + by + 0 <= j /\ j < xc.Array.length + ) }; + value_sub_frame (pelts x) xc.elts x.offset (x.offset + p2i !i); + end; + let cy1 = [@vc:sp] if (Limb.(<) !x0 cy) then uone else limb_zero in + x0 := sub_mod !x0 cy; + let cy2 = [@vc:sp] if (Limb.(<) !x1 cy1) then uone else limb_zero in + x1 := sub_mod !x1 cy1; + assert { 0 <= cy2 <= 1 }; + (* assert { cy2 = 1 -> rh = 0 }; (* and cy > rl *)*) + value_sub_update (pelts x) (!xp).offset xd.offset + (xd.offset + p2i sy - 1) !x0; + value_sub_update_no_change (pelts x) (!xp).offset + x.offset (x.offset + p2i !i) !x0; + value_sub_update_no_change (pelts x) (!xp).offset + xd.offset (xd.offset + p2i sy - 2) !x0; + C.set !xp !x0; + assert { value x !i + = value (x at SubProd) !i + by + value x !i + = value (x at PostSub) !i + = value (x at SubProd) !i }; + value_sub_tail (pelts x) xd.offset (xd.offset + p2i sy - 1); + begin + ensures { value xd (sy - 1) + + power radix (sy - 1) * !x1 + - power radix sy * cy2 + = value (xd at SubProd) sy + + power radix sy * (!x1 at StartLoop) + - !ql * vy } + assert { value xd (sy - 2) + = value (xd at PostSub) (sy - 2) }; + value_sub_tail (pelts y) y.offset (y.offset + p2i sy - 1); + value_sub_tail (pelts y) y.offset (y.offset + p2i sy - 2); + let ghost vly = value y (p2i sy - 2) in + assert { vy = vly + power radix (sy - 2) + * (dl + radix * dh) + by (pelts y)[y.offset + sy - 1] = dh + so (pelts y)[y.offset + sy - 2] = dl + so + vy = value y (sy - 1) + + power radix (sy - 1) * dh + = vly + power radix (sy - 2) * dl + + power radix (sy - 1) * dh + so power radix (sy - 1) + = power radix (sy - 2) * radix }; + assert { value xd (sy - 2) + - power radix (sy - 2) * cy + = vlx - !ql * vly + by + value xd (sy - 2) + - power radix (sy - 2) * cy + = value (xd at PostSub) (sy - 2) + - power radix (sy - 2) * cy + = vlx - !ql * vly + }; + assert { power radix sy + = power radix (sy - 2) * radix * radix }; + assert { xp0 + radix * xp1 + + radix * radix * !x1 at StartLoop + - !ql * (dl + radix * dh) + = rl + radix * rh }; + begin ensures { value (xd at SubProd) sy + + power radix sy * (!x1 at StartLoop) + - !ql * vy + = value xd (sy - 2) + - power radix (sy - 2) * cy + + power radix (sy - 2) * + (rl + radix * rh) } + assert { value (xd at SubProd) sy + = vlx + power radix (sy - 2) * xp0 + + power radix (sy - 1) * xp1 }; (*nonlinear*) + assert { !ql * vy = !ql * vly + + power radix (sy - 2) + * (!ql * (dl + radix * dh)) }; (*nonlinear*) + (*assert { value (xd at SubProd) sy + + power radix sy * (!x1 at StartLoop) + - !ql * vy + = value xd (sy - 2) + - power radix (sy - 2) * cy + + power radix (sy - 2) * (rl + radix * rh) + by + value (xd at SubProd) sy + + power radix sy * (!x1 at StartLoop) + - !ql * vy + = vlx + power radix (sy - 2) + * (xp0 + radix * xp1) + + power radix sy * (!x1 at StartLoop) + - !ql * vy + = vlx + power radix (sy - 2) + * (xp0 + radix * xp1) + + power radix sy * (!x1 at StartLoop) + - !ql * (vly + power radix (sy - 2) + * (dl + radix * dh)) + = vlx + + power radix (sy - 2) + * (xp0 + radix * xp1 + + radix * radix * !x1 at StartLoop) + - !ql * (vly + power radix (sy - 2) + * (dl + radix * dh)) + = vlx + + power radix (sy - 2) + * (xp0 + radix * xp1 + + radix * radix * !x1 at StartLoop) + - !ql * vly + - power radix (sy - 2) + * !ql * (dl + radix * dh) + = vlx - !ql * vly + + power radix (sy - 2) + * (xp0 + radix * xp1 + + radix * radix * !x1 at StartLoop + - !ql * (dl + radix * dh)) + = vlx - !ql * vly + + power radix (sy - 2) * + (rl + radix * rh) + = value xd (sy - 2) + - power radix (sy - 2) * cy + + power radix (sy - 2) * + (rl + radix * rh) + } *) + end; + begin ensures { value xd (sy - 2) + - power radix (sy - 2) * cy + + power radix (sy - 2) * (rl + radix * rh) + = value xd (sy - 1) + + power radix (sy - 1) * !x1 + - power radix sy * cy2 } + value_sub_tail (pelts xd) xd.offset (xd.offset + p2i sy - 2); + assert { value xd (sy - 1) + = value xd (sy - 2) + + power radix (sy - 2) * !x0 + by (pelts xd)[xd.offset + sy - 2] = !x0 + so value xd (sy - 1) + = value_sub (pelts xd) xd.offset (xd.offset + sy - 1) + = value_sub (pelts xd) xd.offset (xd.offset + sy - 2) + + power radix (sy - 2) * !x0 + = value xd (sy - 2) + + power radix (sy - 2) * !x0 }; + assert { rl + radix * rh - cy + = !x0 + radix * !x1 - power radix 2 * cy2 + by + (!x0 - radix * cy1 = rl - cy + by + !x0 = mod (rl - cy) radix + so - radix < rl - cy < radix + so (if rl < cy + then cy1 = 1 + /\ (- radix < rl - cy < 0 + so + div (rl - cy) radix = - 1 + so rl - cy + = radix * div (rl - cy) radix + + mod (rl - cy) radix + = !x0 - radix + = !x0 - radix * cy1) + else cy1 = 0 /\ rl - cy = l2i !x0)) } + (* nonlinear *) + (* refl example *) + (* assert { value xd (sy - 2) + - power radix (sy - 2) * cy + + power radix (sy - 2) * + (rl + radix * rh) + = value xd (sy - 1) + + power radix (sy - 1) * !x1 + - power radix sy * cy2 + by + (rl + radix * rh - cy + = !x0 + radix * !x1 - radix * radix * cy2 + by + (!x0 - radix * cy1 = rl - cy + by + !x0 = mod (rl - cy) radix + so - radix < rl - cy < radix + so (if rl < cy + then cy1 = 1 + /\ (- radix < rl - cy < 0 + so + div (rl - cy) radix = - 1 + so rl - cy + = radix * div (rl - cy) radix + + mod (rl - cy) radix + = !x0 - radix + = !x0 - radix * cy1) + else cy1 = 0 /\ rl - cy = l2i !x0) + ) + so !x1 - radix * cy2 = rh - cy1 + so radix * !x1 - radix * radix * cy2 + = radix * rh - radix * cy1 + so radix * rh + = radix * cy1 + + radix * !x1 - radix * radix * cy2 + so rl + radix * rh - cy + = rl - cy + radix * rh + = !x0 - radix * cy1 + radix * rh + = !x0 - radix * cy1 + + radix * cy1 + + radix * !x1 - radix * radix * cy2 + = !x0 + radix * !x1 - radix * radix * cy2 + ) + so + ( - power radix (sy - 2) * cy + + power radix (sy - 2) * (rl + radix * rh) + = power radix (sy - 2) + * (rl + radix * rh - cy) + = power radix (sy - 2) + * (!x0 + radix * !x1 - radix * radix * cy2) + = power radix (sy - 2) * !x0 + + power radix (sy - 1) * !x1 + - power radix sy * cy2 + by power radix (sy - 2) * radix = power radix (sy - 1) + so power radix (sy - 2) * radix * radix = power radix sy + ) + so value xd (sy - 2) + - power radix (sy - 2) * cy + + power radix (sy - 2) * (rl + radix * rh) + = value xd (sy - 2) + + power radix (sy - 2) * !x0 + + power radix (sy - 1) * !x1 + - power radix sy * cy2 + = value xd (sy - 1) + + power radix (sy - 1) * !x1 + - power radix sy * cy2 + }*) + end; + end; + if [@ex:unlikely] (not (Limb.(=) cy2 limb_zero)) + then begin + label Adjust in + assert { cy2 = 1 }; + begin ensures { !ql > 0 } + value_sub_lower_bound (pelts y) y.offset (y.offset + p2i sy - 1); + value_sub_tail (pelts y) y.offset (y.offset + p2i sy - 1); + value_sub_upper_bound (pelts xd) xd.offset (xd.offset + p2i sy - 1); + assert { !ql > 0 + by + (value xd (sy - 1) + + power radix (sy - 1) * !x1 + - power radix sy * cy2 + < 0 + by + value xd (sy - 1) < power radix (sy - 1) + so !x1 <= radix - 1 + so value xd (sy - 1) + + power radix (sy - 1) * !x1 + < power radix (sy - 1) + + power radix (sy - 1) * !x1 + = power radix (sy - 1) * (1 + !x1) + <= power radix (sy - 1) * radix + = power radix sy + so value xd (sy - 1) + + power radix (sy - 1) * !x1 + - power radix sy * cy2 + < power radix sy - power radix sy * cy2 + = 0 + ) + so value (xd at SubProd) sy + + power radix sy * (!x1 at StartLoop) + - !ql * vy + < 0 + so (value (xd at SubProd) sy + + power radix sy * (!x1 at StartLoop) >= 0 + by value (xd at SubProd) sy >= 0 + so !x1 at StartLoop >= 0 + so power radix sy * (!x1 at StartLoop) >= 0 + ) + so !ql * vy > 0 + so vy = value_sub (pelts y) + y.offset (y.offset + sy - 1) + + power radix (sy - 1) * dh + so dh > 0 + so vy > 0 + }; + end; + value_sub_tail (pelts y) y.offset (y.offset + p2i sy - 1); + value_sub_tail (pelts y) y.offset (y.offset + p2i sy - 2); + let ghost vly = value y (p2i sy - 2) in + assert { vy = vly + power radix (sy - 2) * dl + + power radix (sy - 1) * dh + by (pelts y)[y.offset + sy - 1] = dh + so (pelts y)[y.offset + sy - 2] = dl + so + vy = value y (sy - 1) + + power radix (sy - 1) * dh + = vly + power radix (sy - 2) * dl + + power radix (sy - 1) * dh }; + begin + ensures { value xd (sy - 1) + + power radix (sy - 1) * !x1 + >= power radix sy - vy } + assert { value xd (sy - 1) + + power radix (sy - 1) * !x1 + = power radix sy + value (xd at SubProd) sy + + power radix sy * (!x1 at StartLoop) + - !ql * vy }; + assert { value (xd at SubProd) sy + + power radix sy * (!x1 at StartLoop) + - !ql * vy + >= - vy + by + value (xd at SubProd) sy + = vlx + power radix (sy - 2) * (xp0 + radix * xp1) + so xp0 + radix * xp1 + radix * radix * (!x1 at StartLoop) + = !ql * (dl + radix * dh) + rl + radix * rh + so power radix (sy - 1) = power radix (sy - 2) * radix + so vy = vly + power radix (sy - 2) * (dl + radix * dh) + so (!ql * vly < vy + by + vly <= power radix (sy - 2) + so !ql < radix + so !ql * vly <= !ql * power radix (sy - 2) + < radix * power radix (sy - 2) + = power radix (sy - 1) + so vy = vly + power radix (sy - 2) * (dl + radix * dh) + so dh >= div radix 2 > 1 + so vly >= 0 + so dl >= 0 + so vy >= power radix (sy - 2) * radix * dh + > power radix (sy - 2) * radix * 1 + = power radix (sy - 1) + ) + so - !ql * vly > - vy + so vlx >= 0 + so power radix sy = power radix (sy - 2) * radix * radix + so value (xd at SubProd) sy + + power radix sy * (!x1 at StartLoop) + - !ql * vy + = vlx + power radix (sy - 2) * (xp0 + radix * xp1) + + power radix sy * (!x1 at StartLoop) + - !ql * vy + = vlx + power radix (sy - 2) * (xp0 + radix * xp1) + + power radix (sy - 2) + * radix * radix * (!x1 at StartLoop) + - !ql * vy + = vlx + power radix (sy - 2) + * (xp0 + radix * xp1 + + radix * radix * (!x1 at StartLoop)) + - !ql * vy + = vlx + power radix (sy - 2) * + (!ql * (dl + radix * dh) + rl + radix * rh) + - !ql * vy + = vlx + power radix (sy - 2) * + (!ql * (dl + radix * dh) + rl + radix * rh) + - !ql * (vly + + power radix (sy - 2) * (dl + radix * dh)) + = vlx + power radix (sy - 2) * (rl + radix * rh) + - !ql * vly + >= power radix (sy - 2) * (rl + radix * rh) + - !ql * vly + >= - !ql * vly > - vy + }; + end; + let ghost xc = Array.copy (x.data) in + assert { forall j. x.offset <= j < x.offset + !i + -> (pelts x)[j] = xc.elts[j] + by + 0 <= x.offset <= j /\ j < x.offset + !i <= xc.Array.length + so 0 <= j < xc.Array.length + } ; + value_sub_frame (pelts x) xc.elts x.offset (x.offset + p2i !i); + let c = add_in_place xd y (Int32.(-) sy one) (Int32.(-) sy one) in + begin + ensures { value x !i + = value (x at Adjust) !i } + assert { forall j. x.offset <= j < x.offset + !i + -> (pelts x)[j] = xc.elts[j] + by + pelts (xd at Adjust) = pelts (x at Adjust) + so pelts x = pelts xd + so (pelts x)[j] = (pelts x at Adjust)[j] + so + ((pelts x at Adjust)[j] = xc.elts[j] + by + 0 <= j /\ j < xc.Array.length + ) } ; + value_sub_frame (pelts x) xc.elts x.offset (x.offset + p2i !i); + end; + label MidAdd in + begin + ensures { value xd (sy - 1) + power radix (sy - 1) * !x1 + = value (xd at Adjust) (sy - 1) + + power radix (sy - 1) * (!x1 at Adjust) + + vy + - power radix sy } + assert { 0 <= c <= 1 + by + value xd (sy - 1) + c * power radix (sy - 1) + = value (xd at Adjust) (sy - 1) + + value y (sy - 1) + so + value (xd at Adjust) (sy - 1) + < power radix (sy - 1) + so value y (sy - 1) < power radix (sy - 1) + so value xd (sy - 1) >= 0 + so c * power radix (sy - 1) < 2 * power radix (sy - 1) + so let p = power radix (sy - 1) in + (c < 2 by c * p < 2 * p so p > 0) + }; + let ghost c' = div (l2i !x1 + l2i dh + l2i c) radix in + x1 := add_mod !x1 (add_mod dh c); + assert { !x1 + c' * radix = !x1 at Adjust + dh + c + by + (!x1 = mod (!x1 at Adjust + dh + c) radix + by + !x1 = mod (!x1 at Adjust + (mod (dh + c) radix)) radix + so mod (div (dh + c) radix * radix + !x1 at Adjust + + mod (dh + c) radix) radix + = mod (!x1 at Adjust + (mod (dh + c) radix)) radix + so !x1 = mod (div (dh + c) radix * radix + !x1 at Adjust + + mod (dh + c) radix) radix + = mod (!x1 at Adjust + dh + c) radix + ) + so (!x1 at Adjust) + dh + c + = div (!x1 at Adjust + dh + c) radix * radix + + mod (!x1 at Adjust + dh + c) radix + = c' * radix + !x1 + }; + assert { 0 <= c' <= 1 }; + value_sub_tail (pelts y) y.offset (y.offset + p2i sy - 1); + assert { value xd (sy - 1) + power radix (sy - 1) * !x1 + = value (xd at Adjust) (sy - 1) + + power radix (sy - 1) * (!x1 at Adjust) + + vy + - power radix sy + by + value xd (sy - 1) + power radix (sy - 1) * c + = value (xd at Adjust) (sy - 1) + + value y (sy - 1) + so vy = value y (sy - 1) + + power radix (sy - 1) * dh + so value xd (sy - 1) + power radix (sy - 1) * c + + power radix (sy - 1) * (!x1 at Adjust) + + power radix (sy - 1) * dh + = value (xd at Adjust) (sy - 1) + + value y (sy - 1) + + power radix (sy - 1) * (!x1 at Adjust) + + power radix (sy - 1) * dh + = value (xd at Adjust) (sy - 1) + + power radix (sy - 1) * (!x1 at Adjust) + + vy + so value xd (sy - 1) + power radix (sy - 1) * c + + power radix (sy - 1) * (!x1 at Adjust) + + power radix (sy - 1) * dh + = value xd (sy - 1) + + power radix (sy - 1) * (c + dh + !x1 at Adjust) + = value xd (sy - 1) + + power radix (sy - 1) * (!x1 + radix * c') + = value xd (sy - 1) + + power radix (sy - 1) * !x1 + + power radix sy * c' + so value xd (sy - 1) + + power radix (sy - 1) * !x1 + + power radix sy * c' + = value (xd at Adjust) (sy - 1) + + power radix (sy - 1) * (!x1 at Adjust) + + vy + so value (xd at Adjust) (sy - 1) + + power radix (sy - 1) * (!x1 at Adjust) + >= power radix sy - vy + so value xd (sy - 1) < power radix (sy - 1) + so !x1 <= radix - 1 + so power radix (sy - 1) * !x1 + <= power radix (sy - 1) * (radix - 1) + so value xd (sy - 1) + + power radix (sy - 1) * !x1 + <= value xd (sy - 1) + + power radix (sy - 1) * (radix - 1) + < power radix (sy - 1) + + power radix (sy - 1) * (radix - 1) + = power radix sy + so c' <> 0 + so c' = 1 + }; + end; + ql := Limb.(-) !ql uone; + (* todo refl *) + assert { value xd (sy - 1) + power radix (sy - 1) * !x1 + = value (xd at SubProd) sy + + power radix sy * (!x1 at StartLoop) + - !ql * vy + by + value xd (sy - 1) + power radix (sy - 1) * !x1 + = value (xd at Adjust) (sy - 1) + + power radix (sy - 1) * (!x1 at Adjust) + + vy + - power radix sy + = value (xd at SubProd) sy + + power radix sy * (!x1 at StartLoop) + - (!ql at Adjust) * vy + + vy + = value (xd at SubProd) sy + + power radix sy * (!x1 at StartLoop) + - (!ql + 1) * vy + + vy + = value (xd at SubProd) sy + + power radix sy * (!x1 at StartLoop) + - !ql * vy }; + qp.contents <- C.incr !qp (-1); + value_sub_update_no_change (pelts q) (!qp).offset + ((!qp).offset + 1) + ((!qp).offset + p2i sx - p2i sy - p2i !i) + !ql; + C.set !qp !ql; + value_sub_head (pelts q) (!qp).offset + ((!qp).offset + p2i sx - p2i sy - p2i !i); + value_sub_tail (pelts x) x.offset (x.offset + p2i sy + p2i !i - 1); + value_sub_concat (pelts x) x.offset xd.offset (x.offset + s); + (* todo refl *) + assert { value (old x) sx = + (value !qp (sx - sy - !i) + + qh * power radix (sx - sy - !i)) + * vy * power radix !i + + value x (sy + !i - 1) + + power radix (sy + !i - 1) * !x1 + by + value !qp (sx - sy - !i) + = !ql + radix * + value_sub (pelts q) ((!qp).offset + 1) + ((!qp).offset + sx - sy - !i) + so (value_sub (pelts q) ((!qp).offset + 1) + ((!qp).offset + sx - sy - !i) + = value (!qp at StartLoop) + (sx - sy - k) + by + (!qp at StartLoop).offset = (!qp).offset + 1 + so ((!qp).offset + sx - sy - !i) + - ((!qp).offset + 1) + = sx - sy - k + ) + so value !qp (sx - sy - !i) + = !ql + radix * value (!qp at StartLoop) + (sx - sy - k) + so (value x s + = value x !i + + power radix !i + * value xd (sy - 1) + by + xd.offset = x.offset + !i + so x.offset + s = xd.offset + sy - 1 + so pelts x = pelts xd + so x.offset + s - xd.offset = sy - 1 + so value_sub (pelts x) xd.offset (x.offset + s) + = value xd (sy - 1) + so value x s + = value_sub (pelts x) x.offset xd.offset + + power radix !i * value_sub (pelts x) xd.offset (x.offset + s) + = value x !i + + power radix !i * value xd (sy - 1) + ) + so (power radix s + = power radix !i * power radix (sy - 1) + by + let n = !i in + let m = sy - 1 in + let x = radix in + power x s = power x (n + m) + so (power x (n + m) = power x n * power x m + by 0 <= n + so 0 <= m + so forall x:int, n:int, m:int. + 0 <= n -> 0 <= m -> power x (n + m) = (power x n * power x m))) + so (value x s + power radix s * !x1 + = value x !i + + power radix !i * + (value (xd at SubProd) sy + + power radix sy * (!x1 at StartLoop) + - !ql * vy) + by value xd (sy - 1) + + power radix (sy - 1) * !x1 + = value (xd at SubProd) sy + + power radix sy * (!x1 at StartLoop) + - !ql * vy + so value x s + power radix s * !x1 + = value x !i + + power radix !i + * value xd (sy - 1) + + power radix (!i + sy - 1) * !x1 + = value x !i + + power radix !i + * value xd (sy - 1) + + power radix !i + * power radix (sy - 1) * !x1 + = value x !i + + power radix !i * + (value xd (sy - 1) + + power radix (sy - 1) * !x1) + = value x !i + + power radix !i * + (value (xd at SubProd) sy + + power radix sy * (!x1 at StartLoop) + - !ql * vy) + ) + so (value (x at StartLoop) (sy + k - 1) + = value (x at SubProd) !i + + power radix !i + * value (xd at SubProd) sy + by + value (x at StartLoop) (sy + k - 1) + = value_sub (pelts x at SubProd) (x at SubProd).offset + ((x at SubProd).offset + sy + k - 1) + = value_sub (pelts x at SubProd) (x at SubProd).offset xd.offset + + power radix (xd.offset - (x at SubProd).offset) + * value_sub (pelts x at SubProd) xd.offset + ((x at SubProd).offset + sy + k - 1) + so (x at SubProd).offset = x.offset + so xd.offset = x.offset + !i + so value_sub (pelts x at SubProd) (x at SubProd).offset xd.offset + = value (x at SubProd) !i + so power radix (xd.offset - x.offset) = power radix !i + so x.offset + sy + k - 1 - xd.offset = p2i sy + so value_sub (pelts x at SubProd) xd.offset + (x.offset + sy + k - 1) + = value (xd at SubProd) sy + ) + so (value x !i + = value (x at SubProd) !i + by + value x !i + = value (x at Adjust) !i + = value (x at SubProd) !i + ) + so power radix !i * power radix sy = power radix (!i + sy) + so value x s + power radix s * !x1 + - value (x at StartLoop) (sy + k - 1) + = value x !i + + power radix !i * + (value (xd at SubProd) sy + + power radix sy * (!x1 at StartLoop) + - !ql * vy) + - (value (x at SubProd) !i + + power radix !i + * value (xd at SubProd) sy) + = value x !i + + power radix !i * + (value (xd at SubProd) sy + + power radix sy * (!x1 at StartLoop) + - !ql * vy) + - (value x !i + + power radix !i + * value (xd at SubProd) sy) + = power radix !i + * (power radix sy * (!x1 at StartLoop) + - !ql * vy) + = power radix !i * power radix sy * (!x1 at StartLoop) + - power radix !i * !ql * vy + = power radix (!i + sy) * (!x1 at StartLoop) + - power radix !i * !ql * vy + = power radix (sy + k - 1) * (!x1 at StartLoop) + - power radix !i * !ql * vy + so value x s + power radix s * !x1 + = value (x at StartLoop) (sy + k - 1) + + power radix (sy + k - 1) * (!x1 at StartLoop) + - power radix !i * !ql * vy + so power radix (sx - sy - !i) + = radix * power radix (sx - sy - k) + so radix * power radix !i = power radix k + so (value !qp (sx - sy - !i) + + qh * power radix (sx - sy - !i)) + * vy * power radix !i + + value x (sy + !i - 1) + + power radix (sy + !i - 1) * !x1 + = (!ql + radix * value (!qp at StartLoop) + (sx - sy - k) + + qh * power radix (sx - sy - !i)) + * vy * power radix !i + + value x (sy + !i - 1) + + power radix (sy + !i - 1) * !x1 + = (!ql + radix * value (!qp at StartLoop) + (sx - sy - k) + + qh * radix * power radix (sx - sy - k)) + * vy * power radix !i + + value x (sy + !i - 1) + + power radix (sy + !i - 1) * !x1 + = !ql * vy * power radix !i + + (value (!qp at StartLoop) + (sx - sy - k) + + qh * power radix (sx - sy - k)) + * vy * radix * power radix !i + + value x (sy + !i - 1) + + power radix (sy + !i - 1) * !x1 + = !ql * vy * power radix !i + + (value (!qp at StartLoop) + (sx - sy - k) + + qh * power radix (sx - sy - k)) + * vy * power radix k + + value x (sy + !i - 1) + + power radix (sy + !i - 1) * !x1 + = !ql * vy * power radix !i + + (value (!qp at StartLoop) + (sx - sy - k) + + qh * power radix (sx - sy - k)) + * vy * power radix k + + value x s + + power radix s * !x1 + = !ql * vy * power radix !i + + (value (!qp at StartLoop) + (sx - sy - k) + + qh * power radix (sx - sy - k)) + * vy * power radix k + + value (x at StartLoop) (sy + k - 1) + + power radix (sy + k - 1) * (!x1 at StartLoop) + - power radix !i * !ql * vy + = (value (!qp at StartLoop) + (sx - sy - k) + + qh * power radix (sx - sy - k)) + * vy * power radix k + + value (x at StartLoop) (sy + k - 1) + + power radix (sy + k - 1) * (!x1 at StartLoop) + = value (old x) sx + }; + assert { value_sub (pelts x) (!xp.offset + mdn) + (!xp.offset + mdn + sy - 1) + + power radix (sy - 1) * !x1 + < vy + by + (value xd (sy - 1) + power radix (sy - 1) * !x1 < vy + by + value xd (sy - 1) + power radix (sy - 1) * !x1 + = value (xd at Adjust) (sy - 1) + + power radix (sy - 1) * (!x1 at Adjust) + + vy + - power radix sy + so value (xd at Adjust) (sy - 1) + < power radix (sy - 1) + so 1 + (!x1 at Adjust) <= radix + so value (xd at Adjust) (sy - 1) + + power radix (sy - 1) * (!x1 at Adjust) + + vy + - power radix sy + < power radix (sy - 1) + + power radix (sy - 1) * (!x1 at Adjust) + + vy + - power radix sy + = power radix (sy - 1) * (1 + !x1 at Adjust) + + vy + - power radix sy + <= power radix (sy - 1) * radix + + vy + - power radix sy + = vy + ) + so pelts x = pelts xd + so xd.offset = !xp.offset + mdn + so value xd (sy - 1) + = value_sub (pelts x) (!xp.offset + mdn) + (!xp.offset + mdn + sy - 1) + }; + assert { dl + radix * dh + >= (pelts x)[(!xp).offset] + radix * !x1 + by + vy = vly + power radix (sy - 2) + * (dl + radix * dh) + so value_sub (pelts x) (!xp.offset + mdn) + (!xp.offset + mdn + sy - 1) + + power radix (sy - 1) * !x1 + < vy + so !xp.offset + mdn + sy - 1 = !xp.offset + 1 + so power radix (sy - 1) = power radix (sy - 2) * radix + so - mdn = sy - 2 + so vy + > value_sub (pelts x) (!xp.offset + mdn) + (!xp.offset + mdn + sy - 1) + + power radix (sy - 1) * !x1 + = value_sub (pelts x) (!xp.offset + mdn) + (!xp.offset + 1) + + power radix (sy - 1) * !x1 + = value_sub (pelts x) (!xp.offset + mdn) (!xp.offset) + + power radix (- mdn) * (pelts x)[(!xp).offset] + + power radix (sy - 1) * !x1 + = value_sub (pelts x) (!xp.offset + mdn) (!xp.offset) + + power radix (sy - 2) * (pelts x)[(!xp).offset] + + power radix (sy - 1) * !x1 + = value_sub (pelts x) (!xp.offset + mdn) (!xp.offset) + + power radix (sy - 2) * (pelts x)[(!xp).offset] + + power radix (sy - 2) * radix * !x1 + = value_sub (pelts x) (!xp.offset + mdn) (!xp.offset) + + power radix (sy - 2) + * ((pelts x)[(!xp).offset] + radix * !x1) + >= power radix (sy - 2) + * ((pelts x)[(!xp).offset] + radix * !x1) + so vly < power radix (sy - 2) + so vy < power radix (sy - 2) + + power radix (sy - 2) + * (dl + radix * dh) + = power radix (sy - 2) + * (1 + dl + radix * dh) + so power radix (sy - 2) + * ((pelts x)[(!xp).offset] + radix * !x1) + < power radix (sy - 2) * (1 + dl + radix * dh) + so power radix (sy - 2) + * ((pelts x)[(!xp).offset] + radix * !x1 + - (1 + dl + radix * dh)) + < 0 + so (pelts x)[(!xp).offset] + radix * !x1 + - (1 + dl + radix * dh) + < 0 + }; + end + else begin + qp.contents <- C.incr !qp (-1); + value_sub_update_no_change (pelts q) (!qp).offset + ((!qp).offset + 1) + ((!qp).offset + p2i sx - p2i sy - p2i !i) + !ql; + C.set !qp !ql; + value_sub_head (pelts q) (!qp).offset + ((!qp).offset + p2i sx - p2i sy - p2i !i); + assert { value !qp (sx - sy - !i) * vy + = !ql * vy + radix * + (value_sub (pelts q) ((!qp).offset + 1) + ((!qp).offset + sx - sy - !i) * vy) }; (*nonlinear*) + assert { value_sub (pelts q) ((!qp).offset + 1) + ((!qp).offset + sx - sy - !i) * vy + = (value !qp (sx - sy - !i) * vy at StartLoop) }; (*nonlinear*) + value_tail x (sy + !i - 1); + value_sub_concat (pelts x) x.offset xd.offset (x.offset + s); + (* todo refl *) + assert { cy2 = 0 }; + assert { value x !i = value (x at SubProd) !i }; + assert { value x s = value x !i + power radix !i * value xd (sy-1) + by xd.offset = x.offset + !i + so x.offset + s = xd.offset + sy - 1 + so pelts x = pelts xd + so x.offset + s - xd.offset = sy - 1 + so value_sub (pelts x) xd.offset (x.offset + s) + = value xd (sy - 1) + so value x s + = value_sub (pelts x) x.offset xd.offset + + power radix !i * value_sub (pelts x) xd.offset (x.offset + s) + = value x !i + + power radix !i * value xd (sy - 1)}; (*lifted from assertion*) + assert { (value !qp (sx - sy - !i) + qh * power radix (sx - sy - !i)) + * vy + = value !qp (sx - sy - !i) * vy + + qh * vy * power radix (sx - sy - !i) }; (*nonlinear*) + assert { ((value !qp (sx - sy - !i) + qh * power radix (sx - sy - !i)) + * vy at StartLoop) + = (value !qp (sx - sy - !i) * vy + + qh * vy * power radix (sx - sy - !i) at StartLoop) }; (*nonlinear*) + assert { value x s = value x (sy + !i - 1) }; + assert { value (xd at SmallDiv) sy = + vlx + power radix (sy - 2) * xp0 + + power radix (sy - 1) * xp1 }; (*nonlinear*) + assert { value (x at SubProd) (sy + (!i at StartLoop) - 1) + = value (x at SubProd) !i + power radix !i * value (xd at SubProd) sy }; + assert { value (old x) sx = + (value !qp (sx - sy - !i) + + qh * power radix (sx - sy - !i)) + * vy * power radix !i + + value x (sy + !i - 1) + + power radix (sy + !i - 1) * !x1 + (*by + value !qp (sx - sy - !i) + = !ql + radix * + value_sub (pelts q) ((!qp).offset + 1) + ((!qp).offset + sx - sy - !i) + so (value_sub (pelts q) ((!qp).offset + 1) + ((!qp).offset + sx - sy - !i) + = value (!qp at StartLoop) + (sx - sy - k) + by + (!qp at StartLoop).offset = (!qp).offset + 1 + so ((!qp).offset + sx - sy - !i) + - ((!qp).offset + 1) + = sx - sy - k + ) + so value !qp (sx - sy - !i) + = !ql + radix * value (!qp at StartLoop) + (sx - sy - k) + so (value x s + = value x !i + + power radix !i + * value xd (sy - 1) + by + xd.offset = x.offset + !i + so x.offset + s = xd.offset + sy - 1 + so pelts x = pelts xd + so x.offset + s - xd.offset = sy - 1 + so value_sub (pelts x) xd.offset (x.offset + s) + = value xd (sy - 1) + so value x s + = value_sub (pelts x) x.offset xd.offset + + power radix !i * value_sub (pelts x) xd.offset (x.offset + s) + = value x !i + + power radix !i * value xd (sy - 1) + ) + so (power radix s + = power radix !i * power radix (sy - 1) + by + let n = !i in + let m = sy - 1 in + let x = radix in + power x s = power x (n + m) + so (power x (n + m) = power x n * power x m + by 0 <= n + so 0 <= m + so forall x:int, n:int, m:int. + 0 <= n -> 0 <= m -> power x (n + m) = (power x n * power x m))) + so (value x s + power radix s * !x1 + = value x !i + + power radix !i * + (value (xd at SubProd) sy + + power radix sy * (!x1 at StartLoop) + - !ql * vy) + by + cy2 = 0 + so value xd (sy - 1) + + power radix (sy - 1) * !x1 + = value (xd at SubProd) sy + + power radix sy * (!x1 at StartLoop) + - !ql * vy + so value x s + power radix s * !x1 + = value x !i + + power radix !i + * value xd (sy - 1) + + power radix (!i + sy - 1) * !x1 + = value x !i + + power radix !i + * value xd (sy - 1) + + power radix !i + * power radix (sy - 1) * !x1 + = value x !i + + power radix !i * + (value xd (sy - 1) + + power radix (sy - 1) * !x1) + = value x !i + + power radix !i * + (value (xd at SubProd) sy + + power radix sy * (!x1 at StartLoop) + - !ql * vy) + ) + so (value (x at StartLoop) (sy + k - 1) + = value (x at SubProd) !i + + power radix !i + * value (xd at SubProd) sy + by + value (x at StartLoop) (sy + k - 1) + = value_sub (pelts x at SubProd) (x at SubProd).offset + ((x at SubProd).offset + sy + k - 1) + = value_sub (pelts x at SubProd) (x at SubProd).offset xd.offset + + power radix (xd.offset - (x at SubProd).offset) + * value_sub (pelts x at SubProd) xd.offset + ((x at SubProd).offset + sy + k - 1) + so (x at SubProd).offset = x.offset + so xd.offset = x.offset + !i + so value_sub (pelts x at SubProd) (x at SubProd).offset xd.offset + = value (x at SubProd) !i + so power radix (xd.offset - x.offset) = power radix !i + so x.offset + sy + k - 1 - xd.offset = p2i sy + so value_sub (pelts x at SubProd) xd.offset + (x.offset + sy + k - 1) + = value (xd at SubProd) sy + ) + so (value x !i + = value (x at SubProd) !i + ) + so power radix !i * power radix sy = power radix (!i + sy) + so value x s + power radix s * !x1 + - value (x at StartLoop) (sy + k - 1) + = value x !i + + power radix !i * + (value (xd at SubProd) sy + + power radix sy * (!x1 at StartLoop) + - !ql * vy) + - (value (x at SubProd) !i + + power radix !i + * value (xd at SubProd) sy) + = value x !i + + power radix !i * + (value (xd at SubProd) sy + + power radix sy * (!x1 at StartLoop) + - !ql * vy) + - (value x !i + + power radix !i + * value (xd at SubProd) sy) + = power radix !i + * (power radix sy * (!x1 at StartLoop) + - !ql * vy) + = power radix !i * power radix sy * (!x1 at StartLoop) + - power radix !i * !ql * vy + = power radix (!i + sy) * (!x1 at StartLoop) + - power radix !i * !ql * vy + = power radix (sy + k - 1) * (!x1 at StartLoop) + - power radix !i * !ql * vy + so value x s + power radix s * !x1 + = value (x at StartLoop) (sy + k - 1) + + power radix (sy + k - 1) * (!x1 at StartLoop) + - power radix !i * !ql * vy + so power radix (sx - sy - !i) + = radix * power radix (sx - sy - k) + so radix * power radix !i = power radix k + so (value !qp (sx - sy - !i) + + qh * power radix (sx - sy - !i)) + * vy * power radix !i + + value x (sy + !i - 1) + + power radix (sy + !i - 1) * !x1 + = (!ql + radix * value (!qp at StartLoop) + (sx - sy - k) + + qh * power radix (sx - sy - !i)) + * vy * power radix !i + + value x (sy + !i - 1) + + power radix (sy + !i - 1) * !x1 + = (!ql + radix * value (!qp at StartLoop) + (sx - sy - k) + + qh * radix * power radix (sx - sy - k)) + * vy * power radix !i + + value x (sy + !i - 1) + + power radix (sy + !i - 1) * !x1 + = !ql * vy * power radix !i + + (value (!qp at StartLoop) + (sx - sy - k) + + qh * power radix (sx - sy - k)) + * vy * radix * power radix !i + + value x (sy + !i - 1) + + power radix (sy + !i - 1) * !x1 + = !ql * vy * power radix !i + + (value (!qp at StartLoop) + (sx - sy - k) + + qh * power radix (sx - sy - k)) + * vy * power radix k + + value x (sy + !i - 1) + + power radix (sy + !i - 1) * !x1 + = !ql * vy * power radix !i + + (value (!qp at StartLoop) + (sx - sy - k) + + qh * power radix (sx - sy - k)) + * vy * power radix k + + value x s + + power radix s * !x1 + = !ql * vy * power radix !i + + (value (!qp at StartLoop) + (sx - sy - k) + + qh * power radix (sx - sy - k)) + * vy * power radix k + + value (x at StartLoop) (sy + k - 1) + + power radix (sy + k - 1) * (!x1 at StartLoop) + - power radix !i * !ql * vy + = (value (!qp at StartLoop) + (sx - sy - k) + + qh * power radix (sx - sy - k)) + * vy * power radix k + + value (x at StartLoop) (sy + k - 1) + + power radix (sy + k - 1) * (!x1 at StartLoop) + = value (old x) sx *) + }; + value_sub_tail (pelts y) y.offset (y.offset + p2i sy - 1); + value_sub_tail (pelts y) y.offset (y.offset + p2i sy - 2); + let ghost vly = value y (p2i sy - 2) in + assert { vy = vly + power radix (sy - 2) * dl + + power radix (sy - 1) * dh + by (pelts y)[y.offset + sy - 1] = dh + so (pelts y)[y.offset + sy - 2] = dl + so + vy = value y (sy - 1) + + power radix (sy - 1) * dh + = vly + power radix (sy - 2) * dl + + power radix (sy - 1) * dh }; + assert { value_sub (pelts x) (!xp.offset + mdn) + (!xp.offset + mdn + sy - 1) + + power radix (sy - 1) * !x1 + < vy + by + pelts x = pelts xd + so xd.offset = !xp.offset + mdn + so !xp.offset + mdn + sy - 1 = xd.offset + sy - 1 + so + value xd (sy - 1) + = value_sub (pelts xd) xd.offset (xd.offset + sy - 1) + = value_sub (pelts x) (!xp.offset + mdn) + (!xp.offset + mdn + sy - 1) + so value xd (sy - 1) + + power radix (sy - 1) * !x1 + - power radix sy * cy2 + = value (xd at SubProd) sy + + power radix sy * (!x1 at StartLoop) + - !ql * vy + so cy2 = 0 + so value xd (sy - 1) + + power radix (sy - 1) * !x1 + = value (xd at SubProd) sy + + power radix sy * (!x1 at StartLoop) + - !ql * vy + so !ql * (dl + radix * dh) + + (rl + radix * rh) + = xp0 + + radix * xp1 + + radix * radix * (!x1 at StartLoop) + so vy = vly + power radix (sy - 2) + * (dl + radix * dh) + so !ql * vy + = power radix (sy - 2) * + (xp0 + + radix * xp1 + + radix * radix * (!x1 at StartLoop)) + - power radix (sy - 2) * (rl + radix * rh) + + !ql * vly + so value (xd at SubProd) sy + = vlx + + power radix (sy - 2) * (xp0 + radix * xp1) + so power radix sy + = power radix (sy - 2) * radix * radix + so (value (xd at SubProd) sy + + power radix sy * (!x1 at StartLoop) + - !ql * vy + < vy + by + (!ql * vly >= 0 + by !ql >= 0 so vly >= 0) + so (power radix (sy - 2) * (rl + radix * rh) + <= power radix (sy - 2) + * (dl + radix * dh) + - power radix (sy - 2) + by + rl + radix * rh <= dl + radix * dh - 1 + so power radix (sy - 2) >= 0 + so power radix (sy - 2) * (rl + radix * rh) + <= power radix (sy - 2) + * (dl + radix * dh - 1) + = power radix (sy - 2) + * (dl + radix * dh) + - power radix (sy - 2) + ) + so vlx < power radix (sy - 2) + so value (xd at SubProd) sy + + power radix sy * (!x1 at StartLoop) + - !ql * vy + = vlx + + power radix (sy - 2) * (xp0 + radix * xp1) + + power radix sy * (!x1 at StartLoop) + - !ql * vy + = vlx + + power radix (sy - 2) * + (xp0 + radix * xp1 + + radix * radix * (!x1 at StartLoop)) + - !ql * vy + = vlx + + power radix (sy - 2) * + (xp0 + radix * xp1 + + radix * radix * (!x1 at StartLoop)) + - (power radix (sy - 2) * + (xp0 + + radix * xp1 + + radix * radix * (!x1 at StartLoop)) + - power radix (sy - 2) * (rl + radix * rh) + + !ql * vly) + = vlx + + power radix (sy - 2) * (rl + radix * rh) + - !ql * vly + <= vlx + + power radix (sy - 2) * (rl + radix * rh) + <= vlx + + power radix (sy - 2) + * (dl + radix * dh) + - power radix (sy - 2) + < power radix (sy - 2) + + power radix (sy - 2) + * (dl + radix * dh) + - power radix (sy - 2) + = power radix (sy - 2) * (dl + radix * dh) + = vy - vly <= vy + ) + so value_sub (pelts x) (!xp.offset + mdn) + (!xp.offset + mdn + sy - 1) + + power radix (sy - 1) * !x1 + = value xd (sy - 1) + + power radix (sy - 1) * !x1 + = value (xd at SubProd) sy + + power radix sy * (!x1 at StartLoop) + - !ql * vy + < vy + }; + value_sub_tail (pelts x) (!xp.offset + p2i mdn) (!xp.offset); + value_sub_upper_bound (pelts y) (y.offset) (y.offset + p2i sy - 2); + value_sub_lower_bound (pelts x) (!xp.offset + p2i mdn) (!xp.offset); + assert { dl + radix * dh + >= (pelts x)[(!xp).offset] + radix * !x1 + by + vy = vly + power radix (sy - 2) + * (dl + radix * dh) + so value_sub (pelts x) (!xp.offset + mdn) + (!xp.offset + mdn + sy - 1) + + power radix (sy - 1) * !x1 + < vy + so !xp.offset + mdn + sy - 1 = !xp.offset + 1 + so power radix (sy - 1) = power radix (sy - 2) * radix + so - mdn = sy - 2 + so vy + > value_sub (pelts x) (!xp.offset + mdn) + (!xp.offset + mdn + sy - 1) + + power radix (sy - 1) * !x1 + = value_sub (pelts x) (!xp.offset + mdn) + (!xp.offset + 1) + + power radix (sy - 1) * !x1 + = value_sub (pelts x) (!xp.offset + mdn) (!xp.offset) + + power radix (- mdn) * (pelts x)[(!xp).offset] + + power radix (sy - 1) * !x1 + = value_sub (pelts x) (!xp.offset + mdn) (!xp.offset) + + power radix (sy - 2) * (pelts x)[(!xp).offset] + + power radix (sy - 1) * !x1 + = value_sub (pelts x) (!xp.offset + mdn) (!xp.offset) + + power radix (sy - 2) * (pelts x)[(!xp).offset] + + power radix (sy - 2) * radix * !x1 + = value_sub (pelts x) (!xp.offset + mdn) (!xp.offset) + + power radix (sy - 2) + * ((pelts x)[(!xp).offset] + radix * !x1) + >= power radix (sy - 2) + * ((pelts x)[(!xp).offset] + radix * !x1) + so vly < power radix (sy - 2) + so vy < power radix (sy - 2) + + power radix (sy - 2) + * (dl + radix * dh) + = power radix (sy - 2) + * (1 + dl + radix * dh) + so power radix (sy - 2) + * ((pelts x)[(!xp).offset] + radix * !x1) + < power radix (sy - 2) * (1 + dl + radix * dh) + so power radix (sy - 2) + * ((pelts x)[(!xp).offset] + radix * !x1 + - (1 + dl + radix * dh)) + < 0 + so (pelts x)[(!xp).offset] + radix * !x1 + - (1 + dl + radix * dh) + < 0 + }; + end; + end; + done; + label EndLoop in + assert { !i = 0 }; + assert { !xp.offset = x.offset + sy - 2 }; + value_sub_update_no_change (pelts x) (!xp.offset + 1) + x.offset (!xp.offset) !x1; + C.set_ofs !xp 1 !x1; + assert { value x (sy - 1) = + value (x at EndLoop) (sy - 1) + by pelts x = Map.set (pelts x at EndLoop) (x.offset + sy - 1) !x1 }; + value_sub_tail (pelts x) x.offset (!xp.offset+1); + (* todo refl *) + assert { value (old x) sx = + (value q (sx - sy) + + power radix (sx - sy) * qh) + * value y sy + + value x sy + by + value x sy + = value x (sy - 1) + + power radix (sy - 1) * !x1 + so vy = value y sy + so value (old x) sx + = (value !qp (sx - sy - !i) + + qh * power radix (sx - sy - !i)) + * vy * power radix !i + + value x (sy + !i - 1) + + power radix (sy + !i - 1) * !x1 + = (value !qp (sx - sy) + + qh * power radix (sx - sy)) + * vy * 1 + + value x (sy - 1) + + power radix (sy - 1) * !x1 + = (value !qp (sx - sy) + + qh * power radix (sx - sy)) + * value y sy + + value x sy }; + qh + + let divmod_2 (q x y:t) (sx:int32) : limb + requires { 2 <= sx } + requires { valid x sx } + requires { valid y 2 } + requires { valid q (sx - 2) } + requires { (pelts y)[y.offset + 1] >= div radix 2 } + ensures { value (old x) sx = + (value q (sx - 2) + + power radix (sx - 2) * result) + * value y 2 + + value x 2 } + ensures { value x 2 < value y 2 } + ensures { 0 <= result <= 1 } + = + let one = Int32.of_int 1 in + let zero = Int32.of_int 0 in + let two = Int32.of_int 2 in + let uzero = Limb.of_int 0 in + let uone = Limb.of_int 1 in + let xp = ref (C.incr x (Int32.(-) sx two)) in + let dh = C.get_ofs y one in + let dl = C.get y in + let rh = ref (C.get_ofs !xp one) in + let rl = ref (C.get !xp) in + let qh = ref uzero in + let lx = ref uzero in + assert { value y 2 = dl + radix * dh }; + let i = ref (Int32.(-) sx two) in + let dinv = reciprocal_word_3by2 dh dl in + ([@vc:sp] if (Limb.(>=) !rh dh && ([@vc:sp] Limb.(>) !rh dh || Limb.(>=) !rl dl)) + then + label Adjust in + begin + ensures { value x sx + = (value_sub (pelts q) (q.offset + !i) (q.offset + sx - 2) + + !qh * power radix (sx - 2 - !i)) + * value y 2 * power radix !i + + value x !i + + power radix !i * (!rl + radix * !rh) } + ensures { !rl + radix * !rh < dl + radix * dh } + ensures { !qh = 1 } + let (r0, b) = sub_with_borrow !rl dl uzero in + let (r1, ghost b') = sub_with_borrow !rh dh b in + assert { b' = 0 }; + assert { r0 + radix * r1 = !rl + radix * !rh - (dl + radix * dh) }; + value_sub_tail (pelts x) x.offset (x.offset + p2i sx - 1); + value_sub_tail (pelts x) x.offset (x.offset + p2i sx - 2); + rh := r1; + rl := r0; + qh := uone; + assert { value x sx + = (value_sub (pelts q) (q.offset + !i) (q.offset + sx - 2) + + !qh * power radix (sx - 2 - !i)) + * value y 2 * power radix !i + + value x !i + + power radix !i * (!rl + radix * !rh) + by + value_sub (pelts q) (q.offset + !i) (q.offset + sx - 2) = 0 + so (value_sub (pelts q) (q.offset + !i) (q.offset + sx - 2) + + !qh * power radix (sx - 2 - !i)) + * value y 2 * power radix !i + + value x !i + + power radix !i * (!rl + radix * !rh) + = value y 2 * power radix !i + + value x !i + + power radix !i * (!rl + radix * !rh) + = value x !i + + power radix !i * (dl + radix * dh + !rl + radix * !rh) + = value x !i + + power radix !i * (!rl at Adjust + radix * !rh at Adjust) + = value x !i + + power radix !i * !rl at Adjust + + power radix (!i+1) * !rh at Adjust + = value x sx + }; + end + else + begin + ensures { value x sx + = (value_sub (pelts q) (q.offset + !i) (q.offset + sx - 2) + + !qh * power radix (sx - 2 - !i)) + * value y 2 * power radix !i + + value x !i + + power radix !i * (!rl + radix * !rh) } + ensures { !rl + radix * !rh < dl + radix * dh } + ensures { !qh = 0 } + value_sub_tail (pelts x) x.offset (x.offset + p2i sx - 1); + value_sub_tail (pelts x) x.offset (x.offset + p2i sx - 2); + end); + while (Int32.(>) !i zero) do + variant { p2i !i } + invariant { 0 <= !i <= sx - 2 } + invariant { !xp.offset = x.offset + !i } + invariant { plength !xp = plength x } + invariant { !xp.min = x.min } + invariant { !xp.max = x.max } + invariant { pelts !xp = pelts x } + invariant { value x sx + = (value_sub (pelts q) (q.offset + !i) (q.offset + sx - 2) + + !qh * power radix (sx - 2 - !i)) + * value y 2 * power radix !i + + value x !i + + power radix !i * (!rl + radix * !rh) } + invariant { !rl + radix * !rh < dl + radix * dh } + label StartLoop in + let ghost k = p2i !i in + xp.contents <- C.incr !xp (-1); + lx := C.get !xp; + label Got in + let (qu, r0, r1) = div3by2_inv !rh !rl !lx dh dl dinv in + rh := r1; + rl := r0; + i := Int32.(-) !i one; + C.set_ofs q !i qu; + assert { qu * (dl + radix * dh) + r0 + radix * r1 + = !lx + radix * (!rl at StartLoop) + + radix * radix * (!rh at StartLoop) + by + radix * ((!rl at StartLoop) + radix * (!rh at StartLoop)) + = radix * (!rl at StartLoop) + radix * radix * (!rh at StartLoop) + so + qu * (dl + radix * dh) + r0 + radix * r1 + = !lx + radix * ((!rl at StartLoop) + radix * (!rh at StartLoop)) + = !lx + radix * (!rl at StartLoop) + + radix * radix * (!rh at StartLoop) + }; + value_sub_head (pelts q) (q.offset + p2i !i) (q.offset + p2i sx - 2); + value_sub_tail (pelts x) x.offset (x.offset + p2i !i); + assert { value x sx + = (value_sub (pelts q) (q.offset + !i) (q.offset + sx - 2) + + !qh * power radix (sx - 2 - !i)) + * value y 2 * power radix !i + + value x !i + + power radix !i * (!rl + radix * !rh) + by + value x k = value x !i + power radix !i * !lx + so value_sub (pelts q) (q.offset + !i) (q.offset + sx - 2) + = qu + radix + * value_sub (pelts q) (q.offset + k) (q.offset + sx - 2) + so power radix (sx - 2 - !i) = radix * power radix (sx - 2 - k) + so + (value_sub (pelts q) (q.offset + !i) (q.offset + sx - 2) + + !qh * power radix (sx - 2 - !i)) + = qu + radix + * (value_sub (pelts q) (q.offset + k) (q.offset + sx - 2) + + !qh * power radix (sx - 2 - k)) + so power radix !i * radix = power radix k + so ((value_sub (pelts q) (q.offset + !i) (q.offset + sx - 2) + + !qh * power radix (sx - 2 - !i)) + * value y 2 * power radix !i + = power radix !i * qu * (dl + radix * dh) + + (value_sub (pelts q) (q.offset + k) + (q.offset + sx - 2) + + !qh * power radix (sx - 2 - k)) + * value y 2 * power radix k + by + (value_sub (pelts q) (q.offset + !i) (q.offset + sx - 2) + + !qh * power radix (sx - 2 - !i)) + * value y 2 * power radix !i + = (qu + radix + * (value_sub (pelts q) (q.offset + k) + (q.offset + sx - 2) + + !qh * power radix (sx - 2 - k))) + * value y 2 * power radix !i + = power radix !i * qu * (dl + radix * dh) + + radix * (value_sub (pelts q) (q.offset + k) + (q.offset + sx - 2) + + !qh * power radix (sx - 2 - k)) + * value y 2 * power radix !i + = power radix !i * qu * (dl + radix * dh) + + (value_sub (pelts q) (q.offset + k) + (q.offset + sx - 2) + + !qh * power radix (sx - 2 - k)) + * value y 2 * power radix k) + so (value_sub (pelts q) (q.offset + !i) (q.offset + sx - 2) + + !qh * power radix (sx - 2 - !i)) + * value y 2 * power radix !i + + value x !i + + power radix !i * (!rl + radix * !rh) + = power radix !i * qu * (dl + radix * dh) + + (value_sub (pelts q) (q.offset + k) + (q.offset + sx - 2) + + !qh * power radix (sx - 2 - k)) + * value y 2 * power radix k + + value x !i + + power radix !i * (!rl + radix * !rh) + = (value_sub (pelts q) (q.offset + k) + (q.offset + sx - 2) + + !qh * power radix (sx - 2 - k)) + * value y 2 * power radix k + + value x !i + + power radix !i * (qu * (dl + radix * dh) + + !rl + radix * !rh) + = (value_sub (pelts q) (q.offset + k) + (q.offset + sx - 2) + + !qh * power radix (sx - 2 - k)) + * value y 2 * power radix k + + value x !i + + power radix !i + * (!lx + radix * (!rl at StartLoop) + + radix * radix * (!rh at StartLoop)) + = (value_sub (pelts q) (q.offset + k) + (q.offset + sx - 2) + + !qh * power radix (sx - 2 - k)) + * value y 2 * power radix k + + value x !i + + power radix !i * !lx + + power radix !i * (radix * (!rl at StartLoop + + radix * !rh at StartLoop)) + = (value_sub (pelts q) (q.offset + k) + (q.offset + sx - 2) + + !qh * power radix (sx - 2 - k)) + * value y 2 * power radix k + + value x k + + power radix !i * (radix * (!rl at StartLoop + + radix * !rh at StartLoop)) + = (value_sub (pelts q) (q.offset + k) + (q.offset + sx - 2) + + !qh * power radix (sx - 2 - k)) + * value y 2 * power radix k + + value x k + + power radix k * (!rl at StartLoop + + radix * !rh at StartLoop) + = value x sx + }; + done; + assert { !i = 0 }; + assert { value x sx + = (value_sub (pelts q) q.offset (q.offset + sx - 2) + + !qh * power radix (sx - 2)) + * value y 2 + + !rl + radix * !rh + by power radix !i = 1 }; + C.set_ofs x one !rh; + C.set x !rl; + assert { value x 2 = !rl + radix * !rh + by (pelts x)[x.offset] = !rl + /\ (pelts x)[x.offset + 1] = !rh}; + !qh + + +(* val sub_limb_in_place (x:t) (y:limb) (sz:int32) : limb*) + + (** [div_qr q r x y sx sy] divides [(x,sx)] by [(y,sy)], writes the quotient + in [(q, (sx-sy))] and the remainder in [(r, sy)]. Corresponds to + [mpn_tdiv_qr]. *) + let div_qr (q r x y nx ny:t) (sx sy:int32) : unit + requires { 1 <= sy <= sx <= (Int32.max_int32 - 1) } + requires { valid x sx } + requires { valid y sy } + requires { valid q (sx - sy + 1) } + requires { valid r sy } + requires { valid nx (sx + 1) } + requires { valid ny sy } + requires { (pelts y)[y.offset + sy - 1] > 0 } + ensures { value x sx + = value q (sx - sy + 1) * value y sy + + value r sy } + ensures { value r sy < value y sy } + = + label Start in + let one = Int32.of_int 1 in + let limb_zero = Limb.of_int 0 in + let zero = Int32.of_int 0 in + let two = Int32.of_int 2 in + value_sub_tail (pelts y) y.offset (y.offset + p2i sy - 1); + value_sub_lower_bound (pelts y) y.offset (y.offset + p2i sy - 1); + assert { value y sy >= power radix (sy - 1) }; + if (Int32.(=) sy one) + then + let lr = divmod_1 q x (C.get y) sx in + C.set r lr + else + if (Int32.(=) sy two) + then + let clz = clz_ext (C.get_ofs y (Int32.(-) sy one)) in + let ghost p = power 2 (p2i clz) in + if Int32.(=) clz zero + then begin + copy nx x sx; + value_sub_shift_no_change (pelts x) x.offset (p2i sx) (p2i sx) limb_zero; + C.set_ofs nx sx limb_zero; + value_sub_frame_shift (pelts x) (pelts nx) x.offset nx.offset (p2i sx); + label Div2_ns in + let ghost _qh = divmod_2 q nx y (Int32.(+) sx one) in + copy r nx sy; + assert { value x sx + = value q (sx - sy + 1) * value y sy + + value r sy + by value r sy = value nx sy + so value (nx at Div2_ns) (sx + 1) < power radix sx + so value (nx at Div2_ns) (sx + 1) + = value (nx at Div2_ns) sx + so (_qh = 0 + by + power radix sx + > value (nx at Div2_ns) (sx + 1) + = (value q (sx - 1) + power radix (sx - 1) * _qh) + * value y 2 + + value nx 2 + so value nx 2 >= 0 + so value y 2 >= radix + so value q (sx - 1) >= 0 + so _qh >= 0 + so (value q (sx - 1) + + power radix (sx - 1) * _qh) >= 0 + so (value q (sx - 1) + power radix (sx - 1) * _qh) + * value y 2 + + value nx 2 + >= (value q (sx - 1) + + power radix (sx - 1) * _qh) + * value y 2 + >= (value q (sx - 1) + + power radix (sx - 1) * _qh) + * radix + >= power radix (sx - 1) * _qh * radix + = power radix sx * _qh + so power radix sx > power radix sx * _qh + ) + so value x sx = value (nx at Div2_ns) sx + }; + () + end + else begin + let ghost _c = lshift ny y sy (Limb.of_int32 clz) in + begin + ensures { normalized ny sy } + ensures { value ny sy = power 2 clz * value y sy } + let ghost dh = (pelts y)[y.offset + p2i sy - 1] in + assert { value y sy + = value y (sy - 1) + power radix (sy - 1) * dh }; + value_sub_upper_bound (pelts y) y.offset (y.offset + p2i sy - 1); + value_sub_tail (pelts ny) ny.offset (ny.offset + p2i sy - 1); + value_sub_upper_bound (pelts ny) ny.offset (ny.offset + p2i sy - 1); + let ghost ndh = (pelts ny)[ny.offset + p2i sy - 1] in + assert { normalized ny sy + /\ value ny sy = power 2 clz * value y sy + by + value y sy < (dh + 1) * power radix (sy - 1) + so value ny sy + (power radix sy) * _c + = power 2 clz * value y sy + = power 2 clz + * (value y (sy - 1) + + dh * power radix (sy - 1)) + so power 2 clz * dh <= radix - power 2 clz + so value ny sy + (power radix sy) * _c + = power 2 clz * value y (sy - 1) + + power 2 clz * dh * power radix (sy - 1) + < power 2 clz * power radix (sy - 1) + + power 2 clz * dh * power radix (sy - 1) + <= power 2 clz * power radix (sy - 1) + + (radix - power 2 clz) * power radix (sy - 1) + = radix * power radix (sy - 1) + = power radix sy + so _c = 0 + so value ny sy + = power 2 clz * value y sy + so value y sy >= dh * power radix (sy - 1) + so value ny sy + >= power 2 clz * dh * power radix (sy - 1) + so value ny sy = + value ny (sy - 1) + power radix (sy - 1) * ndh + < power radix (sy - 1) + power radix (sy - 1) * ndh + = power radix (sy - 1) * (ndh + 1) + so power radix (sy - 1) * (ndh + 1) + > power radix (sy - 1) * (power 2 clz * dh) + so ndh + 1 > power 2 clz * dh + so ndh >= power 2 clz * dh + so 2 * power 2 clz * dh >= radix + so 2 * ndh >= radix + so ndh >= div radix 2 + }; + end; + let h = lshift nx x sx (Limb.of_int32 clz) in + C.set_ofs nx sx h; + begin + ensures { value nx (sx + 1) + = p * value x sx } + value_sub_tail (pelts nx) nx.offset (nx.offset + p2i sx); + assert { value nx (sx + 1) + = p * value x sx + by + value nx sx + power radix sx * h + = p * value x sx + so value nx (sx + 1) + = value nx sx + power radix sx * h + } + end; + label Div2_s in + (* TODO don't add 1 when not needed, cf "adjust" in GMP algo *) + let ghost _qh = divmod_2 q nx ny (Int32.(+) sx one) in + let ghost _l = rshift r nx sy (Limb.of_int32 clz) in + begin ensures { value nx 2 = p * value r 2 } + assert { _l = 0 + by + (mod (value nx sy) p = 0 + by + value (nx at Div2_s) (sx + 1) + = (value q (sx - 1) + power radix (sx - 1) * _qh) + * value ny sy + + value nx sy + so value (nx at Div2_s) (sx + 1) + = p * value x sx + so value ny sy = p * value y sy + so value nx sy + = value (nx at Div2_s) (sx + 1) + - (value q (sx - 1) + + power radix (sx - 1) * _qh) + * value ny sy + = p * value x sx + - p * (value q (sx - 1) + + power radix (sx - 1) * _qh) + * value y sy + = p * (value x sx + - (value q (sx - 1) + + power radix (sx - 1) * _qh) + * value y sy) + so let n = (value x sx + - (value q (sx - 1) + + power radix (sx - 1) * _qh) + * value y sy) + in + value nx sy = p * n + so value nx sy >= 0 + so p > 0 + so n >= 0 + so mod (value nx sy) p + = mod (p * n) p + = mod ((p*n)+0) p + = mod 0 p + = 0 + ) + so _l + radix * value r sy + = power 2 (Limb.length - clz) * (value nx sy) + so let a = div (value nx sy) p in + value nx sy = p * a + so power 2 (Limb.length - clz) * p = radix + so power 2 (Limb.length - clz) * (value nx sy) + = power 2 (Limb.length - clz) * (p * a) + = (power 2 (Limb.length - clz) * p) * a + = radix * a + so mod (radix * value r sy + _l) radix + = mod _l radix + so mod (radix * value r sy + _l) radix + = mod (radix * a) radix = 0 + so mod _l radix = 0 + so 0 <= _l < radix + }; + assert { value nx 2 = p * value r 2 + by + radix * value r 2 + = power 2 (Limb.length - clz) * value nx 2 + so p * power 2 (Limb.length - clz) + = radix + so p * radix * value r 2 + = p * power 2 (Limb.length - clz) * value nx 2 + = radix * value nx 2 + so p * value r 2 = value nx 2 + } + end; + assert { value x sx + = value q (sx - sy + 1) * value y sy + + value r sy + by + value (nx at Div2_s) (sx + 1) + = (value q (sx - 1) + power radix (sx - 1) * _qh) + * value ny 2 + + value nx 2 + so value (nx at Div2_s) (sx + 1) + = p * value x sx + so value ny 2 = p * value y 2 + so (_qh = 0 + by + value x sx < power radix sx + so value y 2 >= radix + so value ny 2 >= p * radix + so value q (sx - 1) >= 0 + so value nx 2 >= 0 + so (value q (sx - 1) + power radix (sx - 1) * _qh) + >= 0 + so (value q (sx - 1) + power radix (sx - 1) * _qh) + * value ny 2 + + value nx 2 + >= (value q (sx - 1) + + power radix (sx - 1) * _qh) + * value ny 2 + >= (value q (sx - 1) + + power radix (sx - 1) * _qh) + * (p * radix) + >= power radix (sx - 1) * _qh * p * radix + = power radix sx * p * _qh + so power radix sx * p + > value (nx at Div2_s) (sx + 1) + >= power radix sx * p * _qh + ) + so value nx 2 = p * value r 2 + so p * value x sx + = value q (sx - 1) * p * value y 2 + + p * value r 2 + = p * (value q (sx - 1) * value y 2 + + value r 2) + }; + () + end + else + (* let qn = ref (Int32.(-) (Int32.(+) sx one) sy) in + if (Int32.(>=) (Int32.(+) !qn !qn) sx) + then*) begin + let adjust = + if Limb.(>=) (get_ofs x (Int32.(-) sx one)) + (get_ofs y (Int32.(-) sy one)) + then one + else zero + in + let clz = clz_ext (C.get_ofs y (Int32.(-) sy one)) in + let ghost p = power 2 (p2i clz) in + if Int32.(=) clz zero + then begin + copy nx x sx; + value_sub_shift_no_change (pelts x) x.offset + (p2i sx) (p2i sx) limb_zero; + C.set_ofs nx sx limb_zero; + value_sub_frame_shift (pelts x) (pelts nx) x.offset nx.offset (p2i sx); + assert { value y sy * (power radix (sx - sy + adjust)) + > value nx (sx + adjust) + by + let dh = (pelts y)[y.offset + sy - 1] in + value y sy >= dh * power radix (sy - 1) + so value nx (sx + adjust) = value nx sx = value x sx + so [@case_split] + ((adjust = 1 + so value x sx < power radix sx + so value y sy * power radix (sx - sy + adjust) + >= dh * power radix (sy - 1) + * power radix (sx - sy + adjust) + = dh * power radix ((sy - 1) + (sx - sy + adjust)) + = dh * power radix sx + so dh >= div radix 2 > 1 + so dh * power radix sx > power radix sx ) + \/ + (adjust = 0 + so let ah = (pelts x)[x.offset + sx - 1] in + value x sx < (ah + 1) * power radix (sx - 1) + so ah + 1 <= dh + so value x sx < dh * power radix (sx - 1) + so value y sy * power radix (sx - sy + adjust) + = value y sy * power radix (sx - sy) + >= dh * power radix (sy - 1) + * power radix (sx - sy) + = dh * power radix (sy - 1 + sx - sy) + = dh * power radix (sx - 1))) }; + label Div_ns in + let ghost _qh = div_sb_qr q nx y (Int32.(+) sx adjust) sy in + copy r nx sy; + assert { value x sx + = value q (sx - sy + adjust) * value y sy + + value r sy + by value r sy = value nx sy + so value (nx at Div_ns) (sx + adjust) = value x sx < power radix sx + so value (nx at Div_ns) (sx + adjust) + = value (nx at Div_ns) sx + so (_qh = 0 + by + value (nx at Div_ns) (sx + adjust) + = (value q (sx - sy + adjust) + + power radix (sx - sy + adjust) * _qh) + * value y sy + + value nx sy + so value nx sy >= 0 + so value q (sx - sy + adjust) >= 0 + so _qh >= 0 + so (value q (sx - sy + adjust) + + power radix (sx - sy + adjust) * _qh) >= 0 + so (value q (sx - sy + adjust) + + power radix (sx - sy + adjust) * _qh) + * value y sy + + value nx sy + >= (value q (sx - sy + adjust) + + power radix (sx - sy + adjust) * _qh) + * value y sy + >= power radix (sx - sy + adjust) * _qh * value y sy + so _qh <> 1) + so value x sx = value (nx at Div_ns) sx + }; + label Ret_ns in + begin + ensures { value q (sx - sy + 1) + = value (q at Ret_ns) (sx - sy + adjust) } + if (Int32.(=) adjust zero) + then begin + value_sub_shift_no_change (pelts x) x.offset + (p2i sx) (p2i sx) limb_zero; + set_ofs q (Int32.(-) sx sy) limb_zero; + value_sub_tail (pelts q) q.offset (q.offset + p2i sx - p2i sy); + () + end + end + end + else begin + let ghost _c = lshift ny y sy (Limb.of_int32 clz) in + begin + ensures { normalized ny sy } + ensures { value ny sy + = power 2 clz * value y sy } + let ghost dh = (pelts y)[y.offset + p2i sy - 1] in + assert { value y sy + = value y (sy - 1) + power radix (sy - 1) * dh }; + value_sub_upper_bound (pelts y) y.offset (y.offset + p2i sy - 1); + value_sub_tail (pelts ny) ny.offset (ny.offset + p2i sy - 1); + value_sub_upper_bound (pelts ny) ny.offset (ny.offset + p2i sy - 1); + let ghost ndh = (pelts ny)[ny.offset + p2i sy - 1] in + assert { normalized ny sy + /\ value ny sy + = power 2 clz * value y sy + by + value y sy < (dh + 1) * power radix (sy - 1) + so value ny sy + (power radix sy) * _c + = power 2 clz * value y sy + = power 2 clz + * (value y (sy - 1) + + dh * power radix (sy - 1)) + so power 2 clz * dh <= radix - power 2 clz + so (_c = 0 + by + value ny sy + (power radix sy) * _c + = power 2 clz * value y (sy - 1) + + power 2 clz * dh * power radix (sy - 1) + < power 2 clz * power radix (sy - 1) + + power 2 clz * dh * power radix (sy - 1) + <= power 2 clz * power radix (sy - 1) + + (radix - power 2 clz) * power radix (sy - 1) + = radix * power radix (sy - 1) + = power radix sy + so value ny sy >= 0 + so power radix sy * _c < power radix sy + so power radix sy > 0 + so _c >= 0 + ) + so value ny sy + = power 2 clz * value y sy + so value y sy >= dh * power radix (sy - 1) + so value ny sy + >= power 2 clz * dh * power radix (sy - 1) + so value ny sy = + value ny (sy - 1) + power radix (sy - 1) * ndh + < power radix (sy - 1) + power radix (sy - 1) * ndh + = power radix (sy - 1) * (ndh + 1) + so power radix (sy - 1) * (ndh + 1) + > power radix (sy - 1) * (power 2 clz * dh) + so ndh + 1 > power 2 clz * dh + so ndh >= power 2 clz * dh + so 2 * power 2 clz * dh >= radix + so 2 * ndh >= radix + so ndh >= div radix 2 + }; + end; + let h = lshift nx x sx (Limb.of_int32 clz) in + label Shifted in + C.set_ofs nx sx h; + begin + ensures { value nx (sx + adjust) + = p * value x sx } + if (Int32.(=) adjust one) + then begin + value_sub_tail (pelts nx) nx.offset (nx.offset + p2i sx); + assert { value nx (sx + 1) + = p * value x sx + by + value nx sx + power radix sx * h + = p * value x sx + so value nx (sx + 1) + = value nx sx + power radix sx * h + } end + else begin + assert { adjust = 0 }; + assert { h = 0 + by + let dh = (pelts y)[y.offset + sy - 1] in + let ah = (pelts x)[x.offset + sx - 1] in + p * dh < radix + so 0 <= ah <= dh + so p * ah < radix + so (p * ah <= radix - p + by + let q = power 2 (Limb.length - clz) in + radix = p * q + so p * ah < p * q + so ah < q + so ah <= q - 1 + so p * ah <= p * (q - 1) = radix - p + ) + so p * (ah + 1) <= radix + so let s = power radix (sx - 1) in + value x sx < (ah + 1) * s + so p * value x sx < p * (ah + 1) * s + so (p * (ah + 1) * s + <= radix * s + by + [@case_split] + (p * (ah + 1) = radix + \/ (p * (ah + 1) < radix + so s > 0 + so p * (ah + 1) * s + < radix * s))) + so radix * power radix (sx - 1) = power radix sx + so value (nx at Shifted) sx + power radix sx * h + < power radix sx + so power radix sx * h < power radix sx * 1 + so (h < 1 by power radix sx > 0) + } + end + end; + label Div_s in + assert { value ny sy * (power radix (sx - sy + adjust)) + > value nx (sx + adjust) + by + let dh = (pelts y)[y.offset + sy - 1] in + value ny sy >= p * dh * power radix (sy - 1) + so value nx (sx + adjust) = p * value x sx + so p > 0 + so [@case_split] + ((adjust = 1 + so value x sx < power radix sx + so p * value x sx < p * power radix sx + so value ny sy * power radix (sx - sy + adjust) + >= p * dh * power radix (sy - 1) + * power radix (sx - sy + adjust) + = p * dh * power radix ((sy - 1) + (sx - sy + adjust)) + = p * dh * power radix sx + so dh >= 1 + so p * dh * power radix sx >= p * power radix sx ) + \/ + (adjust = 0 + so let ah = (pelts x)[x.offset + sx - 1] in + value x sx < (ah + 1) * power radix (sx - 1) + so ah + 1 <= dh + so value x sx < dh * power radix (sx - 1) + so p * value x sx < p * dh * power radix (sx - 1) + so value ny sy * power radix (sx - sy + adjust) + = value ny sy * power radix (sx - sy) + >= p * dh * power radix (sy - 1) + * power radix (sx - sy) + = p * dh * power radix (sy - 1 + sx - sy) + = p * dh * power radix (sx - 1))) }; + let ghost _qh = div_sb_qr q nx ny (Int32.(+) sx adjust) sy in + let ghost _l = rshift r nx sy (Limb.of_int32 clz) in + begin ensures { value nx sy = p * value r sy } + assert { _l = 0 + by + (mod (value nx sy) p = 0 + by + value (nx at Div_s) (sx + adjust) + = (value q (sx - sy + adjust) + + power radix (sx - sy + adjust) * _qh) + * value ny sy + + value nx sy + so value (nx at Div_s) (sx + adjust) + = p * value x sx + so value ny sy = p * value y sy + so value nx sy + = value (nx at Div_s) (sx + adjust) + - (value q (sx - sy + adjust) + + power radix (sx - sy + adjust) * _qh) + * value ny sy + = p * value x sx + - p * (value q (sx - sy + adjust) + + power radix (sx - sy + adjust) * _qh) + * value y sy + = p * (value x sx + - (value q (sx - sy + adjust) + + power radix (sx - sy + adjust) * _qh) + * value y sy) + so let n = (value x sx + - (value q (sx - sy + adjust) + + power radix (sx - sy + adjust) * _qh) + * value y sy) + in + value nx sy = p * n + so value nx sy >= 0 + so p > 0 + so n >= 0 + so mod (value nx sy) p + = mod (p * n) p + = mod ((p*n)+0) p + = mod 0 p + = 0 + ) + so _l + radix * value r sy + = power 2 (Limb.length - clz) * (value nx sy) + so let a = div (value nx sy) p in + value nx sy = p * a + so power 2 (Limb.length - clz) * p = radix + so power 2 (Limb.length - clz) * (value nx sy) + = power 2 (Limb.length - clz) * (p * a) + = (power 2 (Limb.length - clz) * p) * a + = radix * a + so mod (radix * value r sy + _l) radix + = mod _l radix + so mod (radix * value r sy + _l) radix + = mod (radix * a) radix = 0 + so mod _l radix = 0 + so 0 <= _l < radix + }; + assert { value nx sy = p * value r sy + by + radix * value r sy + = power 2 (Limb.length - clz) * value nx sy + so p * power 2 (Limb.length - clz) + = radix + so p * radix * value r sy + = p * power 2 (Limb.length - clz) * value nx sy + = radix * value nx sy + so p * value r sy = value nx sy + } + end; + assert { value x sx + = value q (sx - sy + adjust) * value y sy + + value r sy + by + value (nx at Div_s) (sx + adjust) + = (value q (sx - sy + adjust) + + power radix (sx - sy + adjust) * _qh) + * value ny sy + + value nx sy + so value (nx at Div_s) (sx + adjust) + = p * value x sx + so power radix (sx - sy + 1) * power radix (sy - 1) + = power radix sx + so value ny sy = p * value y sy + so (_qh = 0 + by + value (nx at Div_s) (sx + adjust) + = (value q (sx - sy + adjust) + + power radix (sx - sy + adjust) * _qh) + * value ny sy + + value nx sy + so value nx sy >= 0 + so value q (sx - sy + adjust) >= 0 + so _qh >= 0 + so (value q (sx - sy + adjust) + + power radix (sx - sy + adjust) * _qh) >= 0 + so (value q (sx - sy + adjust) + + power radix (sx - sy + adjust) * _qh) + * value ny sy + + value nx sy + >= (value q (sx - sy + adjust) + + power radix (sx - sy + adjust) * _qh) + * value ny sy + >= power radix (sx - sy + adjust) * _qh * value ny sy + so _qh <> 1) + so value nx sy = p * value r sy + so p * value x sx + = value q (sx - sy + adjust) * p * value y sy + + p * value r sy + = p * (value q (sx - sy + adjust) + * value y sy + + value r sy) + }; + label Ret_s in + begin + ensures { value q (sx - sy + 1) + = value (q at Ret_s) (sx - sy + adjust) } + if (Int32.(=) adjust zero) + then begin + value_sub_shift_no_change (pelts x) x.offset + (p2i sx) (p2i sx) limb_zero; + set_ofs q (Int32.(-) sx sy) limb_zero; + value_sub_tail (pelts q) q.offset (q.offset + p2i sx - p2i sy); + assert { value q (sx - sy + 1) = value (q at Ret_s) (sx - sy) + by value q (sx - sy + 1) + = value (q at Ret_s) (sx - sy) + power radix (sx - sy) * 0 + = value (q at Ret_s) (sx - sy) } + end + end; + () + end + end + (* else begin + let dn = Int32.(+) !qn one in + let dqn = Int32.(+) !qn !qn in + let ign = Int32.(-) sy dn in + let ix = C.incr nx (Int32.(-) sx dqn) in + let iy = C.incr y ign in + let clz = clz_ext (C.get_ofs y (Int32.(-) sy one)) in + (*let ghost p = power 2 (p2i clz) in*) + (if Int32.(=) clz zero + then begin + copy nx x sx; + C.set_ofs nx sx limb_zero; + ( + if (Int32.(=) dn two) + then + let _d1 = divmod_2 q ix iy (Int32.(+) dqn one) in () + else + let _s1 = div_sb_qr q ix iy (Int32.(+) dqn one) dn in () + ) + end + else begin + let _ = lshift ny y sy (Limb.of_int32 clz) in + let h = lshift nx x sx (Limb.of_int32 clz) in + C.set_ofs nx sx h; + begin + if (Int32.(=) dn two) + then + let _d2 = divmod_2 q ix (incr ny ign) (Int32.(+) dqn one) in () + else + let _s2 = div_sb_qr q ix (incr ny ign) (Int32.(+) dqn one) dn in () + end + end); + (* we have an estimated q, adjust by at most 1 *) + let dl = ref limb_zero in + let st = Int32.(-) sy one in + let snx = Int32.(+) sx one in + let tp = C.malloc (UInt32.of_int32 st) in + mul tp q ny !qn ign; + let b = sub_in_place nx tp snx st in + (if Limb.(>) b limb_zero + then (* quotient too large *) + let _s = sub_limb_in_place q (Limb.of_int 1) (!qn) in + let _a = add_in_place nx ny snx sy in + () + else ()); + if Int32.(=) clz zero + then begin copy r nx sy end + else let _r = rshift r nx sy (Limb.of_int32 clz) in (); + C.free tp; + () + end*) + + let tdiv_qr (q r x y:t) (sx sy:int32) : unit + requires { 1 <= sy <= sx <= (Int32.max_int32 - 1) } + requires { valid x sx } + requires { valid y sy } + requires { valid q (sx - sy + 1) } + requires { valid r sy } + requires { (pelts y)[y.offset + sy - 1] > 0 } + ensures { value x sx + = value q (sx - sy + 1) * value y sy + + value r sy } + ensures { value r sy < value y sy } + diverges + = + let uone = UInt32.of_int 1 in + let nx = malloc (UInt32.(+) (UInt32.of_int32 sx) uone) in + c_assert (is_not_null nx); + let ny = malloc (UInt32.of_int32 sy) in + c_assert (is_not_null ny); + div_qr q r x y nx ny sx sy; + free nx; + free ny; + +end \ No newline at end of file diff --git a/examples/multiprecision/div/why3session.xml b/examples/multiprecision/div/why3session.xml new file mode 100644 index 000000000..400b55d67 --- /dev/null +++ b/examples/multiprecision/div/why3session.xml @@ -0,0 +1,10635 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/examples/multiprecision/div/why3shapes.gz b/examples/multiprecision/div/why3shapes.gz new file mode 100644 index 0000000000000000000000000000000000000000..0f30d444872710aa0a6ddcdb2a636438b0ca460b GIT binary patch literal 118256 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

$wLG7FAo}W}e$C3c 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

e#{J&Y>wPovH?Qj($tT;gwQ7T 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 x[xi+i] = y[yi+i] + + let lemma map_eq_shift (x y:map int 'a) (xi yi sz k:int) + requires { map_eq_sub_shift x y xi yi sz } + requires { 0 <= k < sz } + ensures { x[xi+k] = y[yi+k] } + = () + + let rec lemma map_eq_shift_zero (x y: map int 'a) (n m: int) + requires { map_eq_sub_shift x y n n (m-n) } + variant { m - n } + ensures { MapEq.map_eq_sub x y n m } + = + if n < m then + begin + assert { forall i. 0 <= i < m-n -> x[n+i] = y[n+i] }; + assert { forall i. n <= i < m -> + let j = i - n in 0 <= j < m-n -> + x[n+j] = y[n+j] -> x[i] = y[i]}; + map_eq_shift_zero x y (n+1) m; + end + else () + + use import mach.int.Int32 + use import ref.Ref + use import mach.int.UInt64GMP as Limb + use import int.Int + use import int.Power + use import mach.c.C + use import types.Types + + meta compute_max_steps 0x100000 + + (** {3 Long integers as arrays of libs} *) + + lemma limb_max_bound: 1 <= max_uint64 + + function l2i (x:limb) : int = Limb.to_int x + + function p2i (i:int32) : int = int32'int i + + let lemma prod_compat_strict_r (a b c:int) + requires { 0 <= a < b } + requires { 0 < c } + ensures { c * a < c * b } + = () + let lemma prod_compat_r (a b c:int) + requires { 0 <= a <= b } + requires { 0 <= c } + ensures { c * a <= c * b } + = () + + (** {3 Integer value of a natural number} *) + + (** [value_sub x n m] denotes the integer represented by + the digits x[n..m-1] with lsb at index n *) + let rec ghost function value_sub (x:map int limb) (n:int) (m:int) : int + variant {m - n} + = + if n < m then + l2i x[n] + radix * value_sub x (n+1) m + else 0 + + let rec lemma value_sub_frame (x y:map int limb) (n m:int) + requires { MapEq.map_eq_sub x y n m } + variant { m - n } + ensures { value_sub x n m = value_sub y n m } + = + if n < m then value_sub_frame x y (n+1) m else () + + let rec lemma value_sub_frame_shift (x y:map int limb) (xi yi sz:int) + requires { map_eq_sub_shift x y xi yi sz } + variant { sz } + ensures { value_sub x xi (xi+sz) = value_sub y yi (yi+sz) } + = + if sz>0 + then begin + map_eq_shift x y xi yi sz 0; + assert { forall i. 0 <= i < sz-1 -> + let j = 1+i in x[xi+j] = y[yi+j] }; + value_sub_frame_shift x y (xi+1) (yi+1) (sz-1) + end + else assert { 1+2 = 3 } + + let rec lemma value_sub_tail (x:map int limb) (n m:int) + requires { n <= m } + variant { m - n } + ensures { + value_sub x n (m+1) = + value_sub x n m + (Map.get x m) * power radix (m-n) } + = [@vc:sp] if n < m then value_sub_tail x (n+1) m else ()(*assert { 1+2=3 }*) + + let rec lemma value_sub_concat (x:map int limb) (n m l:int) + requires { n <= m <= l} + variant { m - n } + ensures { + value_sub x n l = + value_sub x n m + value_sub x m l * power radix (m-n) } + = + if n < m then + begin + assert {n + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/examples/multiprecision/lemmas/why3shapes.gz b/examples/multiprecision/lemmas/why3shapes.gz new file mode 100644 index 0000000000000000000000000000000000000000..189729d2c747f463d41b1ca04c652c36daed6b81 GIT binary patch literal 3300 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 literal 0 HcmV?d00001 diff --git a/examples/multiprecision/lineardecision.mlw b/examples/multiprecision/lineardecision.mlw new file mode 100644 index 000000000..6dae622ca --- /dev/null +++ b/examples/multiprecision/lineardecision.mlw @@ -0,0 +1,2105 @@ +module LinearEquationsCoeffs + +type a +function (+) a a : a +function ( *) a a : a +function (-_) a : a +function azero: a +function aone: a +predicate ale a a + +clone algebra.OrderedUnitaryCommutativeRing as A with type t = a, function (+) = (+), function ( *) = ( *), function (-_) = (-_), constant zero = azero, constant one=aone, predicate (<=) = ale + +function (-) a a : a + +axiom sub_def: forall a1 a2. a1 - a2 = a1 + (- a2) + +type t +type vars = int -> a +type cvars +exception Unknown + +function interp t cvars : a + +val constant czero : t +val constant cone : t + +axiom zero_def: forall y. interp czero y = azero +axiom one_def: forall y. interp cone y = aone + +lemma neg_mul: + forall x y: a. (-x) * y = - (x*y) + +val add (a b: t) : t + ensures { forall v: cvars. interp result v = interp a v + interp b v } + raises { Unknown -> true } + +val mul (a b: t) : t + ensures { forall v: cvars. interp result v = interp a v * interp b v } + raises { Unknown -> true } + +val opp (a:t) : t + ensures { forall v: cvars. interp result v = - (interp a v) } + +val predicate eq (a b:t) + ensures { result -> forall y:cvars. interp a y = interp b y } + +val inv (a:t) : t + requires { not (eq a czero) } + (* ensures { forall v: cvars. interp result v * interp a v = aone } no proof needed, but had better be true *) + ensures { not (eq result czero) } + raises { Unknown -> true } + +end + +module LinearEquationsDecision + +use import int.Int +type coeff + +clone LinearEquationsCoeffs as C with type t = coeff +type vars = C.vars + +type expr = Term coeff int | Add expr expr | Cst coeff + +let rec predicate valid_expr (e:expr) + variant { e } += match e with + | Term _ i -> 0 <= i + | Cst _ -> true + | Add e1 e2 -> valid_expr e1 && valid_expr e2 + end + +let rec predicate expr_bound (e:expr) (b:int) + variant { e } += match e with + | Term _ i -> 0 <= i <= b + | Cst _ -> true + | Add e1 e2 -> expr_bound e1 b && expr_bound e2 b + end + +function interp (e:expr) (y:vars) (z:C.cvars) : C.a += match e with + | Term c v -> C.( *) (C.interp c z) (y v) + | Add e1 e2 -> C.(+) (interp e1 y z) (interp e2 y z) + | Cst c -> C.interp c z + end + +meta rewrite_def function interp + +use import bool.Bool +use import list.List + +type equality = (expr, expr) +type context = list equality + +let predicate valid_eq (eq:equality) += match eq with (e1,e2) -> valid_expr e1 && valid_expr e2 end + +let predicate eq_bound (eq:equality) (b:int) += match eq with (e1,e2) -> expr_bound e1 b && expr_bound e2 b end + +let rec predicate valid_ctx (ctx:context) += match ctx with Nil -> true | Cons eq t -> valid_eq eq && valid_ctx t end + +let rec predicate ctx_bound (ctx:context) (b:int) += match ctx with Nil -> true | Cons eq t -> eq_bound eq b && ctx_bound t b end + +let rec lemma expr_bound_w (e:expr) (b1 b2:int) + requires { b1 <= b2 } + requires { expr_bound e b1 } + ensures { expr_bound e b2 } + variant { e } += match e with + | Add e1 e2 -> expr_bound_w e1 b1 b2; expr_bound_w e2 b1 b2 + | Cst _ -> () + | Term _ _ -> () + end + +lemma eq_bound_w: forall e:equality, b1 b2:int. eq_bound e b1 -> b1 <= b2 -> eq_bound e b2 + +let rec lemma ctx_bound_w (l:context) (b1 b2:int) + requires { ctx_bound l b1 } + requires { b1 <= b2 } + ensures { ctx_bound l b2 } + variant { l } += match l with Nil -> () | Cons _ t -> ctx_bound_w t b1 b2 end + +function interp_eq (g:equality) (y:vars) (z:C.cvars) : bool + = match g with (g1, g2) -> interp g1 y z = interp g2 y z end + +meta rewrite_def function interp_eq + +function interp_ctx (l: context) (g: equality) (y: vars) (z:C.cvars) : bool += match l with + | Nil -> interp_eq g y z + | Cons h t -> (interp_eq h y z) -> (interp_ctx t g y z) + end + +meta rewrite_def function interp_ctx + +use import mach.int.Int63 +use import seq.Seq +use import mach.array.Array63 +use import mach.matrix.Matrix63 + +let apply_r (m: matrix coeff) (v: array coeff) : array coeff + requires { v.length = m.columns } + ensures { result.length = m.rows } + raises { C.Unknown -> true } += let r = Array63.make m.rows C.czero in + for i = 0 to m.rows - 1 do + for j = 0 to m.columns - 1 do + r[i] <- C.add r[i] (C.mul (get m i j) v[j]); + done + done; + r + +let apply_l (v: array coeff) (m: matrix coeff) : array coeff + requires { v.length = m.rows } + ensures { result.length = m.columns } + raises { C.Unknown -> true } += let r = Array63.make m.columns C.czero in + for j = 0 to m.columns - 1 do + for i = 0 to m.rows - 1 do + r[j] <- C.add r[j] (C.mul (get m i j) v[i]); + done + done; + r + +use import ref.Ref + +let sprod (a b: array coeff) : coeff + requires { a.length = b.length } + raises { C.Unknown -> true } += let r = ref C.czero in + for i = 0 to a.length - 1 do + r := C.add !r (C.mul a[i] b[i]); + done; + !r + +let m_append (m: matrix coeff) (v:array coeff) : matrix coeff + requires { m.rows = v.length } + requires { m.columns < int63'maxInt } + ensures { result.rows = m.rows } + ensures { result.columns = m.columns + 1 } + ensures { forall i j. 0 <= i < m.rows -> 0 <= j < m.columns -> + result.elts i j = m.elts i j } + ensures { forall i. 0 <= i < m.rows -> result.elts i m.columns = v[i] } += let r = Matrix63.make m.rows (m.columns + 1) C.czero in + for i = 0 to m.rows - 1 do + invariant { forall k j. 0 <= k < i -> 0 <= j < m.columns -> + r.elts k j = m.elts k j } + invariant { forall k. 0 <= k < i -> r.elts k m.columns = v[k] } + for j = 0 to m.columns - 1 do + invariant { forall k j. 0 <= k < i -> 0 <= j < m.columns -> + r.elts k j = m.elts k j } + invariant { forall k. 0 <= k < i -> r.elts k m.columns = v[k] } + invariant { forall l. 0 <= l < j -> r.elts i l = m.elts i l } + set r i j (get m i j) + done; + set r i m.columns v[i] + done; + r + +let v_append (v: array coeff) (c: coeff) : array coeff + requires { length v < int63'maxInt } + ensures { length result = length v + 1 } + ensures { forall k. 0 <= k < v.length -> result[k] = v[k] } + ensures { result[v.length] = c } += let r = Array63.make (v.length + 1) c in + for i = 0 to v.length - 1 do + invariant { forall k. 0 <= k < i -> r[k] = v[k] } + invariant { r[v.length] = c } + r[i] <- v[i] + done; + r + +let predicate (==) (a b: array coeff) + ensures { result = true -> length a = length b /\ + forall i. 0 <= i < length a -> C.eq a[i] b[i] } += + if length a <> length b then false + else + let r = ref true in + for i = 0 to length a - 1 do + invariant { !r = true -> forall j. 0 <= j < i -> C.eq a[j] b[j] } + if not (C.eq a[i] b[i]) then r := false; + done; + !r + +use import int.MinMax +use import list.Length + +let rec function max_var (e:expr) : int + variant { e } + requires { valid_expr e } + ensures { 0 <= result } + ensures { expr_bound e result } += match e with + | Term _ i -> i + | Cst _ -> 0 + | Add e1 e2 -> max (max_var e1) (max_var e2) + end + +let function max_var_e (e:equality) : int + requires { valid_eq e } + ensures { 0 <= result } + ensures { eq_bound e result } += match e with (e1,e2) -> max (max_var e1) (max_var e2) end + +let rec function max_var_ctx (l:context) : int + variant { l } + requires { valid_ctx l } + ensures { 0 <= result } + ensures { ctx_bound l result } += match l with + | Nil -> 0 + | Cons e t -> max (max_var_e e) (max_var_ctx t) + end + +let rec opp_expr (e:expr) : expr + ensures { forall y z. interp result y z = C.(-_) (interp e y z) } + ensures { valid_expr e -> valid_expr result } + ensures { forall b. expr_bound e b -> expr_bound result b } + variant { e } += match e with + | Cst c -> Cst (C.opp c) + | Term c j -> + let oc = C.opp c in + let r = Term oc j in + assert { forall y z. interp r y z = C.( *) (C.interp oc z) (y j) + = C.( *) (C.(-_) (C.interp c z)) (y j) + = C.(-_) (C.( *) (C.interp c z) (y j)) + = C.(-_) (interp e y z) }; + r + | Add e1 e2 -> + let e1' = opp_expr e1 in + let e2' = opp_expr e2 in + assert { forall a1 a2. C.(+) (C.(-_) a1) (C.(-_) a2) = C.(-_) (C.(+) a1 a2) }; + assert { forall y z. interp (Add e1' e2') y z = C.(-_) (interp e y z) by + interp (Add e1' e2') y z = C.(+) (interp e1' y z) (interp e2' y z) + = C.(+) (C.(-_) (interp e1 y z)) (C.(-_) (interp e2 y