file_name
stringlengths 5
52
| name
stringlengths 4
95
| original_source_type
stringlengths 0
23k
| source_type
stringlengths 9
23k
| source_definition
stringlengths 9
57.9k
| source
dict | source_range
dict | file_context
stringlengths 0
721k
| dependencies
dict | opens_and_abbrevs
listlengths 2
94
| vconfig
dict | interleaved
bool 1
class | verbose_type
stringlengths 1
7.42k
| effect
stringclasses 118
values | effect_flags
sequencelengths 0
2
| mutual_with
sequencelengths 0
11
| ideal_premises
sequencelengths 0
236
| proof_features
sequencelengths 0
1
| is_simple_lemma
bool 2
classes | is_div
bool 2
classes | is_proof
bool 2
classes | is_simply_typed
bool 2
classes | is_type
bool 2
classes | partial_definition
stringlengths 5
3.99k
| completed_definiton
stringlengths 1
1.63M
| isa_cross_project_example
bool 1
class |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Steel.Reference.fst | Steel.Reference.ghost_share_gen_pt | val ghost_share_gen_pt (#a:Type) (#u:_)
(#p:perm)
(#x:erased a)
(r:ghost_ref a)
(p1 p2: perm)
: SteelGhost unit u
(ghost_pts_to r p x)
(fun _ -> ghost_pts_to r p1 x `star`
ghost_pts_to r p2 x)
(fun _ -> p == p1 `sum_perm` p2)
(fun _ _ _ -> True) | val ghost_share_gen_pt (#a:Type) (#u:_)
(#p:perm)
(#x:erased a)
(r:ghost_ref a)
(p1 p2: perm)
: SteelGhost unit u
(ghost_pts_to r p x)
(fun _ -> ghost_pts_to r p1 x `star`
ghost_pts_to r p2 x)
(fun _ -> p == p1 `sum_perm` p2)
(fun _ _ _ -> True) | let ghost_share_gen_pt
#_ #_ #_ #x r p1 p2
= H.ghost_share_gen #_ #_ #_ #(raise_erased x) r p1 p2 | {
"file_name": "lib/steel/Steel.Reference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 54,
"end_line": 404,
"start_col": 0,
"start_line": 402
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.Reference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module Mem = Steel.Memory
module H = Steel.HigherReference
module U = FStar.Universe
#set-options "--ide_id_info_off"
let ref a = H.ref (U.raise_t a)
let null #a = H.null #(U.raise_t a)
let is_null #a r = H.is_null #(U.raise_t a) r
let pts_to_sl r p v = H.pts_to_sl r p (U.raise_val v)
val raise_val_inj (#a:Type) (x y:a) : Lemma
(requires U.raise_val x == U.raise_val y)
(ensures x == y)
let raise_val_inj x y =
U.downgrade_val_raise_val x;
U.downgrade_val_raise_val y
let pts_to_ref_injective
(#a: Type u#0)
(r: ref a)
(p0 p1:perm)
(v0 v1:a)
(m:mem)
: Lemma
(requires
interp (pts_to_sl r p0 v0 `Mem.star` pts_to_sl r p1 v1) m)
(ensures v0 == v1)
= let v0' = U.raise_val v0 in
let v1' = U.raise_val v1 in
H.pts_to_ref_injective r p0 p1 v0' v1' m;
raise_val_inj v0 v1
let pts_to_not_null (#a:Type u#0)
(x:ref a)
(p:perm)
(v:a)
(m:mem)
: Lemma (requires interp (pts_to_sl x p v) m)
(ensures x =!= null)
= let v = U.raise_val v in
H.pts_to_not_null #(U.raise_t a) x p v m
// let pts_to_not_null' (#a:Type u#0)
// (x:ref a)
// (p:perm)
// (v: erased a)
// (m:mem)
// (m1:mem{disjoint m m1})
// : Lemma (requires interp (pts_to_sl x p v) m)
// (ensures interp (pts_to_sl x p v) (Mem.join m m1))
// = ()
let pts_to_witinv (#a:Type) (r:ref a) (p:perm) : Lemma (is_witness_invariant (pts_to_sl r p)) =
let aux (x y : a) (m:mem)
: Lemma (requires (interp (pts_to_sl r p x) m /\ interp (pts_to_sl r p y) m))
(ensures (x == y))
= H.pts_to_witinv r p;
raise_val_inj x y
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
let pts_to_injective_eq #a #opened #p0 #p1 #v0 #v1 r =
extract_info_raw (pts_to r p0 v0 `star` pts_to r p1 v1) (v0 == v1)
(fun m -> pts_to_ref_injective r p0 p1 v0 v1 m);
rewrite_slprop (pts_to r p1 v1) (pts_to r p1 v0) (fun _ -> ())
let pts_to_perm
r
= H.pts_to_perm r
let alloc_pt x =
let r = H.alloc (U.raise_val x) in
rewrite_slprop (H.pts_to r full_perm (U.raise_val x)) (pts_to r full_perm x) (fun _ -> ());
return r
let read_pt #a #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
let x = H.read r in
let v':a = U.downgrade_val x in
rewrite_slprop (H.pts_to r p (hide x)) (pts_to r p v') (fun _ -> ());
return v'
let read_refine_pt #a #p q r =
Classical.forall_intro_2 reveal_equiv;
lift_exists (fun (v:a) -> pts_to r p v `star` q v);
exists_cong (fun (v:U.raise_t a) -> pts_to r p (U.downgrade_val v) `star` q (U.downgrade_val v))
(fun (v:U.raise_t a) -> H.pts_to r p v `star` U.lift_dom q v);
let x = H.read_refine (U.lift_dom q) r in
rewrite_slprop
(H.pts_to r p (hide x) `star` U.lift_dom q x)
(pts_to r p (U.downgrade_val x) `star` q (U.downgrade_val x)) (fun _ -> ());
return (U.downgrade_val x)
let write_pt #a #v r x =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
let x' = U.raise_val x in
H.write r x';
rewrite_slprop (H.pts_to r full_perm (hide x')) (pts_to r full_perm x) (fun _ -> ())
let free_pt #a #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
H.free r
let share_gen_pt #a #uses #p #v r p1 p2 =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
H.share_gen r p1 p2;
rewrite_slprop (H.pts_to r p1 v') (pts_to r p1 v) (fun _ -> ());
rewrite_slprop (H.pts_to r p2 v') (pts_to r p2 v) (fun _ -> ())
let share_pt #a #uses #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
H.share r;
rewrite_slprop (H.pts_to r (half_perm p) v') (pts_to r (half_perm p) v) (fun _ -> ());
rewrite_slprop (H.pts_to r (half_perm p) v') (pts_to r (half_perm p) v) (fun _ -> ())
let hide_raise_reveal (#a:Type) (v0:erased a) (v1:erased a)
: Lemma (hide (U.raise_val (reveal v0)) == hide (U.raise_val (reveal v1)) <==>
v0 == v1)
[SMTPat (hide (U.raise_val (reveal v0)));
SMTPat (hide (U.raise_val (reveal v1)))]
= let u0 = hide (U.raise_val (reveal v0)) in
let u1 = hide (U.raise_val (reveal v1)) in
assert (U.downgrade_val (U.raise_val (reveal v0)) == U.downgrade_val (U.raise_val (reveal v1)) <==>
v0 == v1)
let gather_pt #a #uses #p0 #p1 #v0 #v1 r =
let v0' = Ghost.hide (U.raise_val (Ghost.reveal v0)) in
let v1' = Ghost.hide (U.raise_val (Ghost.reveal v1)) in
rewrite_slprop (pts_to r p0 v0) (H.pts_to r p0 v0') (fun _ -> ());
rewrite_slprop (pts_to r p1 v1) (H.pts_to r p1 v1') (fun _ -> ());
let (u:unit{v0' == v1'}) = H.gather #_ #_ #p0 #p1 #v0' #v1' r in
rewrite_slprop (H.pts_to r (sum_perm p0 p1) v0') (pts_to r (sum_perm p0 p1) v0) (fun _ -> ());
u
let raise_equiv (#t:Type) (x y:t)
: Lemma (U.raise_val x == U.raise_val y <==>
x == y)
= assert (U.downgrade_val (U.raise_val x) == x);
assert (U.downgrade_val (U.raise_val y) == y)
let downgrade_equiv (#t:Type) (x y:U.raise_t t)
: Lemma (U.downgrade_val x == U.downgrade_val y <==>
x == y)
= assert (U.raise_val (U.downgrade_val x) == x);
assert (U.raise_val (U.downgrade_val y) == y)
let lift_eq (#t:eqtype) (x y:U.raise_t t)
: b:bool{b <==> x==y}
= downgrade_equiv x y; U.downgrade_val x = U.downgrade_val y
let cas_action (#t:eqtype)
(#uses:inames)
(r:ref t)
(v:Ghost.erased t)
(v_old:t)
(v_new:t)
(frame:slprop)
: MstTot (b:bool{b <==> (Ghost.reveal v == v_old)})
uses
(pts_to_sl r full_perm v)
(fun b -> if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v)
frame
(fun _ -> True)
(fun _ _ _ -> True)
= let hv = (Ghost.hide (U.raise_val (Ghost.reveal v))) in
let b = H.cas_action #(U.raise_t t)
(lift_eq #t)
#uses
r
hv
(U.raise_val v_old)
(U.raise_val v_new)
frame
in
assert (b <==> (Ghost.reveal hv == U.raise_val v_old));
assert (b <==> U.raise_val (Ghost.reveal v) == U.raise_val v_old);
raise_equiv (Ghost.reveal v) v_old;
b
let atomic_read_pt_u32 #_ #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
let x = H.atomic_read r in
let v':U32.t = U.downgrade_val x in
rewrite_slprop (H.pts_to r p (hide x)) (pts_to r p v') (fun _ -> ());
return v'
let atomic_write_pt_u32 #_ #v r x =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
let x' = U.raise_val x in
H.atomic_write r x';
rewrite_slprop (H.pts_to r full_perm (hide x')) (pts_to r full_perm x) (fun _ -> ())
let cas_pt_u32 #uses r v v_old v_new =
let b = as_atomic_action (cas_action #U32.t #uses r v v_old v_new) in
rewrite_slprop (to_vprop (if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v))
(if b then pts_to r full_perm v_new else pts_to r full_perm v)
(fun _ -> ());
return b
let cas_pt_bool #uses r v v_old v_new =
let b = as_atomic_action (cas_action #bool #uses r v v_old v_new) in
rewrite_slprop (to_vprop (if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v))
(if b then pts_to r full_perm v_new else pts_to r full_perm v)
(fun _ -> ());
return b
(* Library for references with fractional permissions.
Permissions need to be an index of the vprop ptr.
It cannot be part of a selector, as it is not invariant when joining with a disjoint memory
Using the value of the ref as a selector is ok because refs with fractional permissions
all share the same value.
Refs on PCM are more complicated, and likely not usable with selectors
*)
let ptrp r p = Mem.h_exists (pts_to_sl r p)
val ptr_sel' (#a:Type0) (r: ref a) (p: perm) : selector' a (ptrp r p)
let ptr_sel' #a r p = fun h -> id_elim_exists #a (pts_to_sl r p) h
let ptr_sel_depends_only_on (#a:Type0) (r:ref a)
(p: perm)
(m0:Mem.hmem (ptrp r p)) (m1:mem{disjoint m0 m1})
: Lemma (ptr_sel' r p m0 == ptr_sel' r p (Mem.join m0 m1))
= let x = reveal (id_elim_exists #a (pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (pts_to_sl r p) (Mem.join m0 m1)) in
pts_to_witinv r p;
elim_wi (pts_to_sl r p) x y (Mem.join m0 m1)
let ptr_sel_depends_only_on_core (#a:Type0) (r:ref a)
(p: perm) (m0:Mem.hmem (ptrp r p))
: Lemma (ptr_sel' r p m0 == ptr_sel' r p (core_mem m0))
= let x = reveal (id_elim_exists #a (pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (pts_to_sl r p) (core_mem m0)) in
pts_to_witinv r p;
elim_wi (pts_to_sl r p) x y (core_mem m0)
let ptrp_sel r p =
Classical.forall_intro_2 (ptr_sel_depends_only_on r p);
Classical.forall_intro (ptr_sel_depends_only_on_core r p);
ptr_sel' r p
let ptrp_sel_interp #a r p m = pts_to_witinv r p
let intro_ptrp_interp r p v m = intro_h_exists (reveal v) (pts_to_sl r p) m
let intro_vptr_lemma (#a:Type) (r:ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (pts_to_sl r p v) m)
(ensures interp (ptrp r p) m /\ ptrp_sel r p m == reveal v)
= Mem.intro_h_exists (reveal v) (pts_to_sl r p) m;
pts_to_witinv r p
let elim_vptr_lemma (#a:Type) (r:ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (ptrp r p) m /\ ptrp_sel r p m == reveal v)
(ensures interp (pts_to_sl r p v) m)
= Mem.elim_h_exists (pts_to_sl r p) m;
pts_to_witinv r p
let intro_vptr (#a:Type) (#opened:inames) (r:ref a) (p: perm) (v:erased a)
: SteelGhost unit opened (pts_to r p v) (fun _ -> vptrp r p)
(requires fun _ -> True)
(ensures fun _ _ h1 -> h1 (vptrp r p) == reveal v)
= change_slprop_2 (pts_to r p v) (vptrp r p) v (intro_vptr_lemma r p v)
let elim_vptr (#a:Type) (#opened:inames) (r:ref a) (p: perm)
: SteelGhost (erased a) opened (vptrp r p) (fun v -> pts_to r p v)
(requires fun _ -> True)
(ensures fun h0 v _ -> reveal v == h0 (vptrp r p))
= let v = gget (vptrp r p) in
change_slprop (vptrp r p) (pts_to r p v) v () (elim_vptr_lemma r p v);
v
let malloc x =
let r = alloc_pt x in
intro_vptr r _ (hide x);
return r
let free r =
let _ = elim_vptr r _ in
free_pt r
let readp r _ =
let _ = elim_vptr r _ in
let x = read_pt r in
intro_vptr r _ x;
return x
let write r x =
let _ = elim_vptr r _ in
write_pt r x;
intro_vptr r _ x
let share #a #_ #p r =
let x = elim_vptr r p in
share_pt r;
intro_vptr r _ x;
intro_vptr r _ x
let gather_gen #a #_ r p0 p1 =
let x1 = elim_vptr r p1 in
let x0 = elim_vptr r p0 in
gather_pt #_ #_ #p0 #p1 #x0 #x1 r;
intro_vptr r (sum_perm p0 p1) x0;
sum_perm p0 p1
let gather (#a: Type0) (#uses: _) (#p: perm) (r: ref a)
: SteelGhost unit uses
(vptrp r (half_perm p) `star` vptrp r (half_perm p))
(fun _ -> vptrp r p)
(fun _ -> True)
(fun h _ h' ->
h' (vptrp r p) == h (vptrp r (half_perm p))
)
= let _ = gather_gen r _ _ in
change_equal_slprop
(vptrp r _)
(vptrp r p)
(*** Lemmas on references *)
let vptrp_not_null
#opened #a r
p
= change_slprop_rel
(vptrp r p)
(vptrp r p)
(fun x y -> x == y /\ is_null r == false)
(fun m -> pts_to_not_null r p (ptrp_sel r p m) m)
(*** Ghost pointers *)
(*** GHOST REFERENCES ***)
let ghost_ref a = H.ghost_ref (U.raise_t a)
let dummy_ghost_ref a =
H.reveal_ghost_ref (U.raise_t a);
coerce_eq () (Ghost.hide (H.null #(U.raise_t a)))
[@__reduce__]
let ghost_pts_to_sl #a r p x = H.ghost_pts_to_sl #(U.raise_t a) r p (U.raise_val x)
let ghost_pts_to_witinv (#a:Type) (r:ghost_ref a) (p:perm) : Lemma (is_witness_invariant (ghost_pts_to_sl r p)) =
let aux (x y : a) (m:mem)
: Lemma (requires (interp (ghost_pts_to_sl r p x) m /\ interp (ghost_pts_to_sl r p y) m))
(ensures (x == y))
= H.ghost_pts_to_witinv r p;
raise_val_inj x y
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
[@@__reduce__]
let raise_erased (#a:Type0) (x:erased a)
: erased (U.raise_t u#0 u#1 a)
= Ghost.hide (U.raise_val (Ghost.reveal x))
let ghost_alloc_pt (#a:Type) (#u:_) (x:erased a)
: SteelGhostT (ghost_ref a) u
emp
(fun r -> ghost_pts_to r full_perm x)
= H.ghost_alloc (raise_erased x)
let ghost_free_pt r = H.ghost_free r | {
"checked_file": "/",
"dependencies": [
"Steel.Memory.fsti.checked",
"Steel.HigherReference.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Reference.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "Steel.HigherReference",
"short_module": "H"
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
r: Steel.Reference.ghost_ref a ->
p1: Steel.FractionalPermission.perm ->
p2: Steel.FractionalPermission.perm
-> Steel.Effect.Atomic.SteelGhost Prims.unit | Steel.Effect.Atomic.SteelGhost | [] | [] | [
"Steel.Memory.inames",
"Steel.FractionalPermission.perm",
"FStar.Ghost.erased",
"Steel.Reference.ghost_ref",
"Steel.HigherReference.ghost_share_gen",
"FStar.Universe.raise_t",
"Steel.Reference.raise_erased",
"Prims.unit"
] | [] | false | true | false | false | false | let ghost_share_gen_pt #_ #_ #_ #x r p1 p2 =
| H.ghost_share_gen #_ #_ #_ #(raise_erased x) r p1 p2 | false |
Hacl.Bignum.Addition.fst | Hacl.Bignum.Addition.bn_sub_eq_len_st | val bn_sub_eq_len_st : t: Hacl.Bignum.Definitions.limb_t -> aLen: Lib.IntTypes.size_t -> Type0 | let bn_sub_eq_len_st (t:limb_t) (aLen:size_t) =
a:lbignum t aLen
-> b:lbignum t aLen
-> res:lbignum t aLen ->
Stack (carry t)
(requires fun h ->
live h a /\ live h b /\ live h res /\
eq_or_disjoint a b /\ eq_or_disjoint a res /\ eq_or_disjoint b res)
(ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\
(let c, r = SL.generate_elems (v aLen) (v aLen) (S.bn_sub_f (as_seq h0 a) (as_seq h0 b)) (uint #t 0) in
c_out == c /\ as_seq h1 res == r)) | {
"file_name": "code/bignum/Hacl.Bignum.Addition.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 38,
"end_line": 72,
"start_col": 0,
"start_line": 62
} | module Hacl.Bignum.Addition
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Hacl.Bignum.Definitions
open Hacl.Bignum.Base
open Hacl.Impl.Lib
open Lib.IntTypes
open Lib.Buffer
module ST = FStar.HyperStack.ST
module B = LowStar.Buffer
module S = Hacl.Spec.Bignum.Addition
module LSeq = Lib.Sequence
module SL = Hacl.Spec.Lib
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val bn_sub_carry:
#t:limb_t
-> aLen:size_t
-> a:lbignum t aLen
-> c_in:carry t
-> res:lbignum t aLen ->
Stack (carry t)
(requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res)
(ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\
(let c, r = S.bn_sub_carry (as_seq h0 a) c_in in
c_out == c /\ as_seq h1 res == r))
let bn_sub_carry #t aLen a c_in res =
push_frame ();
let c = create 1ul c_in in
[@inline_let]
let refl h i = LSeq.index (as_seq h c) 0 in
[@inline_let]
let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\
B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in
[@inline_let]
let spec h = S.bn_sub_carry_f (as_seq h a) in
let h0 = ST.get () in
fill_elems4 h0 aLen res refl footprint spec
(fun i ->
let h1 = ST.get () in
let t1 = a.(i) in
let res_i = sub res i 1ul in
c.(0ul) <- subborrow_st c.(0ul) t1 (uint #t 0) res_i;
lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1
);
let res = c.(0ul) in
pop_frame ();
res | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Addition.fst.checked",
"Hacl.Impl.Lib.fst.checked",
"Hacl.Bignum.Definitions.fst.checked",
"Hacl.Bignum.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Bignum.Addition.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Lib",
"short_module": "SL"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Addition",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | t: Hacl.Bignum.Definitions.limb_t -> aLen: Lib.IntTypes.size_t -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Hacl.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_t",
"Hacl.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Base.carry",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"Lib.Buffer.live",
"Lib.Buffer.MUT",
"Hacl.Bignum.Definitions.limb",
"Lib.Buffer.eq_or_disjoint",
"Lib.Buffer.modifies",
"Lib.Buffer.loc",
"Lib.Sequence.seq",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.eq2",
"Prims.nat",
"Lib.Sequence.length",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Prims.l_or",
"FStar.Seq.Base.length",
"Lib.Buffer.as_seq",
"Prims.logical",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.Lib.generate_elems",
"Hacl.Spec.Bignum.Addition.bn_sub_f",
"Lib.IntTypes.uint",
"Lib.IntTypes.SEC"
] | [] | false | false | false | true | true | let bn_sub_eq_len_st (t: limb_t) (aLen: size_t) =
| a: lbignum t aLen -> b: lbignum t aLen -> res: lbignum t aLen
-> Stack (carry t)
(requires
fun h ->
live h a /\ live h b /\ live h res /\ eq_or_disjoint a b /\ eq_or_disjoint a res /\
eq_or_disjoint b res)
(ensures
fun h0 c_out h1 ->
modifies (loc res) h0 h1 /\
(let c, r =
SL.generate_elems (v aLen)
(v aLen)
(S.bn_sub_f (as_seq h0 a) (as_seq h0 b))
(uint #t 0)
in
c_out == c /\ as_seq h1 res == r)) | false |
|
Spec.Agile.HKDF.fst | Spec.Agile.HKDF.expand | val expand:
a: fixed_len_alg ->
prk: bytes ->
info: bytes ->
len: nat ->
Pure (lbytes len)
(requires
hash_length a <= Seq.length prk /\
HMAC.keysized a (Seq.length prk) /\
expand_info_length_pred a (Seq.length info) /\
expand_output_length_pred a len)
(ensures fun _ -> True) | val expand:
a: fixed_len_alg ->
prk: bytes ->
info: bytes ->
len: nat ->
Pure (lbytes len)
(requires
hash_length a <= Seq.length prk /\
HMAC.keysized a (Seq.length prk) /\
expand_info_length_pred a (Seq.length info) /\
expand_output_length_pred a len)
(ensures fun _ -> True) | let expand a prk info len =
let open Spec.Agile.HMAC in
let tlen = hash_length a in
let n = len / tlen in
let tag, output =
Seq.generate_blocks tlen n n (a_spec a) (expand_loop a prk info n) FStar.Seq.empty
in
if n * tlen < len then
let t = hmac a prk (tag @| info @| Seq.create 1 (u8 (n + 1))) in
output @| Seq.sub #_ #tlen t 0 (len - (n * tlen))
else
output | {
"file_name": "specs/Spec.Agile.HKDF.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 10,
"end_line": 72,
"start_col": 0,
"start_line": 61
} | module Spec.Agile.HKDF
open FStar.Integers
open Spec.Hash.Definitions
/// FUNCTIONAL SPECIFICATION:
///
/// * extraction is just HMAC using the salt as key and the input
/// keying materials as text.
///
/// * expansion does its own formatting of input key materials.
open FStar.Seq
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 50"
let extract = Spec.Agile.HMAC.hmac
module Seq = Lib.Sequence
open Lib.IntTypes
/// HKDF-Expand(PRK, info, L)
///
/// N = ceil(L/HashLen)
/// T = T(1) | T(2) | T(3) | ... | T(N)
/// OKM = first L octets of T
///
/// where:
/// T(0) = empty string (zero length)
/// T(1) = HMAC-Hash(PRK, T(0) | info | 0x01)
/// T(2) = HMAC-Hash(PRK, T(1) | info | 0x02)
/// T(3) = HMAC-Hash(PRK, T(2) | info | 0x03)
///
/// See https://tools.ietf.org/html/rfc5869#section-2.3
/// The type of T(i) is [a_spec a i]
let a_spec (a:fixed_len_alg) (i:nat) =
Seq.lseq uint8 (if i = 0 then 0 else hash_length a)
/// The main loop that computes T(i)
val expand_loop:
a:fixed_len_alg
-> prk:bytes
-> info:bytes
-> n:nat
-> i:nat{i < n}
-> a_spec a i
-> Pure (a_spec a (i + 1) & Seq.lseq uint8 (hash_length a))
(requires
hash_length a <= Seq.length prk /\
HMAC.keysized a (Seq.length prk) /\
(hash_length a + Seq.length info + 1 + block_length a) `less_than_max_input_length` a /\
n <= 255)
(ensures fun _ -> True)
let expand_loop a prk info n i tag =
let t = Spec.Agile.HMAC.hmac a prk (tag @| info @| Seq.create 1 (u8 (i + 1))) in
t, t
/// Expands first computes T(0) | T(1) | ... | T(floor(L/HashLen)) in a loop and then | {
"checked_file": "/",
"dependencies": [
"Spec.Hash.Definitions.fst.checked",
"Spec.Agile.HMAC.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Integers.fst.checked"
],
"interface_file": true,
"source_file": "Spec.Agile.HKDF.fst"
} | [
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Agile",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Agile",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Spec.Hash.Definitions.fixed_len_alg ->
prk: Spec.Hash.Definitions.bytes ->
info: Spec.Hash.Definitions.bytes ->
len: FStar.Integers.nat
-> Prims.Pure (Spec.Agile.HKDF.lbytes len) | Prims.Pure | [] | [] | [
"Spec.Hash.Definitions.fixed_len_alg",
"Spec.Hash.Definitions.bytes",
"FStar.Integers.nat",
"Spec.Agile.HKDF.a_spec",
"Lib.Sequence.seq",
"Lib.IntTypes.uint8",
"Prims.eq2",
"Prims.int",
"Lib.Sequence.length",
"FStar.Mul.op_Star",
"FStar.Integers.op_Less",
"FStar.Integers.Signed",
"FStar.Integers.Winfinite",
"FStar.Integers.op_Star",
"FStar.Seq.Base.op_At_Bar",
"Lib.Sequence.sub",
"FStar.Integers.op_Subtraction",
"Spec.Agile.HMAC.lbytes",
"Spec.Hash.Definitions.hash_length",
"Spec.Agile.HMAC.hmac",
"Lib.Sequence.create",
"Lib.IntTypes.u8",
"FStar.Integers.op_Plus",
"Prims.bool",
"Spec.Agile.HKDF.lbytes",
"FStar.Pervasives.Native.tuple2",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Prims.op_Multiply",
"Lib.Sequence.generate_blocks",
"Spec.Agile.HKDF.expand_loop",
"FStar.Seq.Base.empty",
"FStar.Integers.int_t",
"FStar.Integers.op_Slash",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Subtraction",
"Prims.pow2",
"Prims.op_GreaterThan"
] | [] | false | false | false | false | false | let expand a prk info len =
| let open Spec.Agile.HMAC in
let tlen = hash_length a in
let n = len / tlen in
let tag, output =
Seq.generate_blocks tlen n n (a_spec a) (expand_loop a prk info n) FStar.Seq.empty
in
if n * tlen < len
then
let t = hmac a prk (tag @| info @| Seq.create 1 (u8 (n + 1))) in
output @| Seq.sub #_ #tlen t 0 (len - (n * tlen))
else output | false |
Steel.Reference.fst | Steel.Reference.free_pt | val free_pt (#a:Type0) (#v:erased a) (r:ref a)
: SteelT unit (pts_to r full_perm v) (fun _ -> emp) | val free_pt (#a:Type0) (#v:erased a) (r:ref a)
: SteelT unit (pts_to r full_perm v) (fun _ -> emp) | let free_pt #a #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
H.free r | {
"file_name": "lib/steel/Steel.Reference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 10,
"end_line": 134,
"start_col": 0,
"start_line": 131
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.Reference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module Mem = Steel.Memory
module H = Steel.HigherReference
module U = FStar.Universe
#set-options "--ide_id_info_off"
let ref a = H.ref (U.raise_t a)
let null #a = H.null #(U.raise_t a)
let is_null #a r = H.is_null #(U.raise_t a) r
let pts_to_sl r p v = H.pts_to_sl r p (U.raise_val v)
val raise_val_inj (#a:Type) (x y:a) : Lemma
(requires U.raise_val x == U.raise_val y)
(ensures x == y)
let raise_val_inj x y =
U.downgrade_val_raise_val x;
U.downgrade_val_raise_val y
let pts_to_ref_injective
(#a: Type u#0)
(r: ref a)
(p0 p1:perm)
(v0 v1:a)
(m:mem)
: Lemma
(requires
interp (pts_to_sl r p0 v0 `Mem.star` pts_to_sl r p1 v1) m)
(ensures v0 == v1)
= let v0' = U.raise_val v0 in
let v1' = U.raise_val v1 in
H.pts_to_ref_injective r p0 p1 v0' v1' m;
raise_val_inj v0 v1
let pts_to_not_null (#a:Type u#0)
(x:ref a)
(p:perm)
(v:a)
(m:mem)
: Lemma (requires interp (pts_to_sl x p v) m)
(ensures x =!= null)
= let v = U.raise_val v in
H.pts_to_not_null #(U.raise_t a) x p v m
// let pts_to_not_null' (#a:Type u#0)
// (x:ref a)
// (p:perm)
// (v: erased a)
// (m:mem)
// (m1:mem{disjoint m m1})
// : Lemma (requires interp (pts_to_sl x p v) m)
// (ensures interp (pts_to_sl x p v) (Mem.join m m1))
// = ()
let pts_to_witinv (#a:Type) (r:ref a) (p:perm) : Lemma (is_witness_invariant (pts_to_sl r p)) =
let aux (x y : a) (m:mem)
: Lemma (requires (interp (pts_to_sl r p x) m /\ interp (pts_to_sl r p y) m))
(ensures (x == y))
= H.pts_to_witinv r p;
raise_val_inj x y
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
let pts_to_injective_eq #a #opened #p0 #p1 #v0 #v1 r =
extract_info_raw (pts_to r p0 v0 `star` pts_to r p1 v1) (v0 == v1)
(fun m -> pts_to_ref_injective r p0 p1 v0 v1 m);
rewrite_slprop (pts_to r p1 v1) (pts_to r p1 v0) (fun _ -> ())
let pts_to_perm
r
= H.pts_to_perm r
let alloc_pt x =
let r = H.alloc (U.raise_val x) in
rewrite_slprop (H.pts_to r full_perm (U.raise_val x)) (pts_to r full_perm x) (fun _ -> ());
return r
let read_pt #a #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
let x = H.read r in
let v':a = U.downgrade_val x in
rewrite_slprop (H.pts_to r p (hide x)) (pts_to r p v') (fun _ -> ());
return v'
let read_refine_pt #a #p q r =
Classical.forall_intro_2 reveal_equiv;
lift_exists (fun (v:a) -> pts_to r p v `star` q v);
exists_cong (fun (v:U.raise_t a) -> pts_to r p (U.downgrade_val v) `star` q (U.downgrade_val v))
(fun (v:U.raise_t a) -> H.pts_to r p v `star` U.lift_dom q v);
let x = H.read_refine (U.lift_dom q) r in
rewrite_slprop
(H.pts_to r p (hide x) `star` U.lift_dom q x)
(pts_to r p (U.downgrade_val x) `star` q (U.downgrade_val x)) (fun _ -> ());
return (U.downgrade_val x)
let write_pt #a #v r x =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
let x' = U.raise_val x in
H.write r x';
rewrite_slprop (H.pts_to r full_perm (hide x')) (pts_to r full_perm x) (fun _ -> ()) | {
"checked_file": "/",
"dependencies": [
"Steel.Memory.fsti.checked",
"Steel.HigherReference.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Reference.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "Steel.HigherReference",
"short_module": "H"
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | r: Steel.Reference.ref a -> Steel.Effect.SteelT Prims.unit | Steel.Effect.SteelT | [] | [] | [
"FStar.Ghost.erased",
"Steel.Reference.ref",
"Steel.HigherReference.free",
"FStar.Universe.raise_t",
"Prims.unit",
"Steel.Effect.Atomic.rewrite_slprop",
"FStar.Ghost.hide",
"FStar.Set.set",
"Steel.Memory.iname",
"FStar.Set.empty",
"Steel.Reference.pts_to",
"Steel.FractionalPermission.full_perm",
"FStar.Ghost.reveal",
"Steel.HigherReference.pts_to",
"Steel.Memory.mem",
"FStar.Universe.raise_val"
] | [] | false | true | false | false | false | let free_pt #a #v r =
| let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
H.free r | false |
Steel.Reference.fst | Steel.Reference.free | val free (#a:Type0) (r:ref a) : Steel unit
(vptr r) (fun _ -> emp)
(requires fun _ -> True)
(ensures fun _ _ _ -> True) | val free (#a:Type0) (r:ref a) : Steel unit
(vptr r) (fun _ -> emp)
(requires fun _ -> True)
(ensures fun _ _ _ -> True) | let free r =
let _ = elim_vptr r _ in
free_pt r | {
"file_name": "lib/steel/Steel.Reference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 11,
"end_line": 317,
"start_col": 0,
"start_line": 315
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.Reference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module Mem = Steel.Memory
module H = Steel.HigherReference
module U = FStar.Universe
#set-options "--ide_id_info_off"
let ref a = H.ref (U.raise_t a)
let null #a = H.null #(U.raise_t a)
let is_null #a r = H.is_null #(U.raise_t a) r
let pts_to_sl r p v = H.pts_to_sl r p (U.raise_val v)
val raise_val_inj (#a:Type) (x y:a) : Lemma
(requires U.raise_val x == U.raise_val y)
(ensures x == y)
let raise_val_inj x y =
U.downgrade_val_raise_val x;
U.downgrade_val_raise_val y
let pts_to_ref_injective
(#a: Type u#0)
(r: ref a)
(p0 p1:perm)
(v0 v1:a)
(m:mem)
: Lemma
(requires
interp (pts_to_sl r p0 v0 `Mem.star` pts_to_sl r p1 v1) m)
(ensures v0 == v1)
= let v0' = U.raise_val v0 in
let v1' = U.raise_val v1 in
H.pts_to_ref_injective r p0 p1 v0' v1' m;
raise_val_inj v0 v1
let pts_to_not_null (#a:Type u#0)
(x:ref a)
(p:perm)
(v:a)
(m:mem)
: Lemma (requires interp (pts_to_sl x p v) m)
(ensures x =!= null)
= let v = U.raise_val v in
H.pts_to_not_null #(U.raise_t a) x p v m
// let pts_to_not_null' (#a:Type u#0)
// (x:ref a)
// (p:perm)
// (v: erased a)
// (m:mem)
// (m1:mem{disjoint m m1})
// : Lemma (requires interp (pts_to_sl x p v) m)
// (ensures interp (pts_to_sl x p v) (Mem.join m m1))
// = ()
let pts_to_witinv (#a:Type) (r:ref a) (p:perm) : Lemma (is_witness_invariant (pts_to_sl r p)) =
let aux (x y : a) (m:mem)
: Lemma (requires (interp (pts_to_sl r p x) m /\ interp (pts_to_sl r p y) m))
(ensures (x == y))
= H.pts_to_witinv r p;
raise_val_inj x y
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
let pts_to_injective_eq #a #opened #p0 #p1 #v0 #v1 r =
extract_info_raw (pts_to r p0 v0 `star` pts_to r p1 v1) (v0 == v1)
(fun m -> pts_to_ref_injective r p0 p1 v0 v1 m);
rewrite_slprop (pts_to r p1 v1) (pts_to r p1 v0) (fun _ -> ())
let pts_to_perm
r
= H.pts_to_perm r
let alloc_pt x =
let r = H.alloc (U.raise_val x) in
rewrite_slprop (H.pts_to r full_perm (U.raise_val x)) (pts_to r full_perm x) (fun _ -> ());
return r
let read_pt #a #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
let x = H.read r in
let v':a = U.downgrade_val x in
rewrite_slprop (H.pts_to r p (hide x)) (pts_to r p v') (fun _ -> ());
return v'
let read_refine_pt #a #p q r =
Classical.forall_intro_2 reveal_equiv;
lift_exists (fun (v:a) -> pts_to r p v `star` q v);
exists_cong (fun (v:U.raise_t a) -> pts_to r p (U.downgrade_val v) `star` q (U.downgrade_val v))
(fun (v:U.raise_t a) -> H.pts_to r p v `star` U.lift_dom q v);
let x = H.read_refine (U.lift_dom q) r in
rewrite_slprop
(H.pts_to r p (hide x) `star` U.lift_dom q x)
(pts_to r p (U.downgrade_val x) `star` q (U.downgrade_val x)) (fun _ -> ());
return (U.downgrade_val x)
let write_pt #a #v r x =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
let x' = U.raise_val x in
H.write r x';
rewrite_slprop (H.pts_to r full_perm (hide x')) (pts_to r full_perm x) (fun _ -> ())
let free_pt #a #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
H.free r
let share_gen_pt #a #uses #p #v r p1 p2 =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
H.share_gen r p1 p2;
rewrite_slprop (H.pts_to r p1 v') (pts_to r p1 v) (fun _ -> ());
rewrite_slprop (H.pts_to r p2 v') (pts_to r p2 v) (fun _ -> ())
let share_pt #a #uses #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
H.share r;
rewrite_slprop (H.pts_to r (half_perm p) v') (pts_to r (half_perm p) v) (fun _ -> ());
rewrite_slprop (H.pts_to r (half_perm p) v') (pts_to r (half_perm p) v) (fun _ -> ())
let hide_raise_reveal (#a:Type) (v0:erased a) (v1:erased a)
: Lemma (hide (U.raise_val (reveal v0)) == hide (U.raise_val (reveal v1)) <==>
v0 == v1)
[SMTPat (hide (U.raise_val (reveal v0)));
SMTPat (hide (U.raise_val (reveal v1)))]
= let u0 = hide (U.raise_val (reveal v0)) in
let u1 = hide (U.raise_val (reveal v1)) in
assert (U.downgrade_val (U.raise_val (reveal v0)) == U.downgrade_val (U.raise_val (reveal v1)) <==>
v0 == v1)
let gather_pt #a #uses #p0 #p1 #v0 #v1 r =
let v0' = Ghost.hide (U.raise_val (Ghost.reveal v0)) in
let v1' = Ghost.hide (U.raise_val (Ghost.reveal v1)) in
rewrite_slprop (pts_to r p0 v0) (H.pts_to r p0 v0') (fun _ -> ());
rewrite_slprop (pts_to r p1 v1) (H.pts_to r p1 v1') (fun _ -> ());
let (u:unit{v0' == v1'}) = H.gather #_ #_ #p0 #p1 #v0' #v1' r in
rewrite_slprop (H.pts_to r (sum_perm p0 p1) v0') (pts_to r (sum_perm p0 p1) v0) (fun _ -> ());
u
let raise_equiv (#t:Type) (x y:t)
: Lemma (U.raise_val x == U.raise_val y <==>
x == y)
= assert (U.downgrade_val (U.raise_val x) == x);
assert (U.downgrade_val (U.raise_val y) == y)
let downgrade_equiv (#t:Type) (x y:U.raise_t t)
: Lemma (U.downgrade_val x == U.downgrade_val y <==>
x == y)
= assert (U.raise_val (U.downgrade_val x) == x);
assert (U.raise_val (U.downgrade_val y) == y)
let lift_eq (#t:eqtype) (x y:U.raise_t t)
: b:bool{b <==> x==y}
= downgrade_equiv x y; U.downgrade_val x = U.downgrade_val y
let cas_action (#t:eqtype)
(#uses:inames)
(r:ref t)
(v:Ghost.erased t)
(v_old:t)
(v_new:t)
(frame:slprop)
: MstTot (b:bool{b <==> (Ghost.reveal v == v_old)})
uses
(pts_to_sl r full_perm v)
(fun b -> if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v)
frame
(fun _ -> True)
(fun _ _ _ -> True)
= let hv = (Ghost.hide (U.raise_val (Ghost.reveal v))) in
let b = H.cas_action #(U.raise_t t)
(lift_eq #t)
#uses
r
hv
(U.raise_val v_old)
(U.raise_val v_new)
frame
in
assert (b <==> (Ghost.reveal hv == U.raise_val v_old));
assert (b <==> U.raise_val (Ghost.reveal v) == U.raise_val v_old);
raise_equiv (Ghost.reveal v) v_old;
b
let atomic_read_pt_u32 #_ #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
let x = H.atomic_read r in
let v':U32.t = U.downgrade_val x in
rewrite_slprop (H.pts_to r p (hide x)) (pts_to r p v') (fun _ -> ());
return v'
let atomic_write_pt_u32 #_ #v r x =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
let x' = U.raise_val x in
H.atomic_write r x';
rewrite_slprop (H.pts_to r full_perm (hide x')) (pts_to r full_perm x) (fun _ -> ())
let cas_pt_u32 #uses r v v_old v_new =
let b = as_atomic_action (cas_action #U32.t #uses r v v_old v_new) in
rewrite_slprop (to_vprop (if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v))
(if b then pts_to r full_perm v_new else pts_to r full_perm v)
(fun _ -> ());
return b
let cas_pt_bool #uses r v v_old v_new =
let b = as_atomic_action (cas_action #bool #uses r v v_old v_new) in
rewrite_slprop (to_vprop (if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v))
(if b then pts_to r full_perm v_new else pts_to r full_perm v)
(fun _ -> ());
return b
(* Library for references with fractional permissions.
Permissions need to be an index of the vprop ptr.
It cannot be part of a selector, as it is not invariant when joining with a disjoint memory
Using the value of the ref as a selector is ok because refs with fractional permissions
all share the same value.
Refs on PCM are more complicated, and likely not usable with selectors
*)
let ptrp r p = Mem.h_exists (pts_to_sl r p)
val ptr_sel' (#a:Type0) (r: ref a) (p: perm) : selector' a (ptrp r p)
let ptr_sel' #a r p = fun h -> id_elim_exists #a (pts_to_sl r p) h
let ptr_sel_depends_only_on (#a:Type0) (r:ref a)
(p: perm)
(m0:Mem.hmem (ptrp r p)) (m1:mem{disjoint m0 m1})
: Lemma (ptr_sel' r p m0 == ptr_sel' r p (Mem.join m0 m1))
= let x = reveal (id_elim_exists #a (pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (pts_to_sl r p) (Mem.join m0 m1)) in
pts_to_witinv r p;
elim_wi (pts_to_sl r p) x y (Mem.join m0 m1)
let ptr_sel_depends_only_on_core (#a:Type0) (r:ref a)
(p: perm) (m0:Mem.hmem (ptrp r p))
: Lemma (ptr_sel' r p m0 == ptr_sel' r p (core_mem m0))
= let x = reveal (id_elim_exists #a (pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (pts_to_sl r p) (core_mem m0)) in
pts_to_witinv r p;
elim_wi (pts_to_sl r p) x y (core_mem m0)
let ptrp_sel r p =
Classical.forall_intro_2 (ptr_sel_depends_only_on r p);
Classical.forall_intro (ptr_sel_depends_only_on_core r p);
ptr_sel' r p
let ptrp_sel_interp #a r p m = pts_to_witinv r p
let intro_ptrp_interp r p v m = intro_h_exists (reveal v) (pts_to_sl r p) m
let intro_vptr_lemma (#a:Type) (r:ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (pts_to_sl r p v) m)
(ensures interp (ptrp r p) m /\ ptrp_sel r p m == reveal v)
= Mem.intro_h_exists (reveal v) (pts_to_sl r p) m;
pts_to_witinv r p
let elim_vptr_lemma (#a:Type) (r:ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (ptrp r p) m /\ ptrp_sel r p m == reveal v)
(ensures interp (pts_to_sl r p v) m)
= Mem.elim_h_exists (pts_to_sl r p) m;
pts_to_witinv r p
let intro_vptr (#a:Type) (#opened:inames) (r:ref a) (p: perm) (v:erased a)
: SteelGhost unit opened (pts_to r p v) (fun _ -> vptrp r p)
(requires fun _ -> True)
(ensures fun _ _ h1 -> h1 (vptrp r p) == reveal v)
= change_slprop_2 (pts_to r p v) (vptrp r p) v (intro_vptr_lemma r p v)
let elim_vptr (#a:Type) (#opened:inames) (r:ref a) (p: perm)
: SteelGhost (erased a) opened (vptrp r p) (fun v -> pts_to r p v)
(requires fun _ -> True)
(ensures fun h0 v _ -> reveal v == h0 (vptrp r p))
= let v = gget (vptrp r p) in
change_slprop (vptrp r p) (pts_to r p v) v () (elim_vptr_lemma r p v);
v
let malloc x =
let r = alloc_pt x in
intro_vptr r _ (hide x);
return r | {
"checked_file": "/",
"dependencies": [
"Steel.Memory.fsti.checked",
"Steel.HigherReference.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Reference.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "Steel.HigherReference",
"short_module": "H"
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | r: Steel.Reference.ref a -> Steel.Effect.Steel Prims.unit | Steel.Effect.Steel | [] | [] | [
"Steel.Reference.ref",
"Steel.Reference.free_pt",
"Prims.unit",
"FStar.Ghost.erased",
"Steel.Reference.elim_vptr",
"FStar.Ghost.hide",
"FStar.Set.set",
"Steel.Memory.iname",
"FStar.Set.empty",
"Steel.FractionalPermission.full_perm"
] | [] | false | true | false | false | false | let free r =
| let _ = elim_vptr r _ in
free_pt r | false |
Hacl.Bignum.Addition.fst | Hacl.Bignum.Addition.bn_sub1 | val bn_sub1:
#t:limb_t
-> aLen:size_t{0 < v aLen}
-> a:lbignum t aLen
-> b1:limb t
-> res:lbignum t aLen ->
Stack (carry t)
(requires fun h ->
live h a /\ live h res /\ eq_or_disjoint a res)
(ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\
(let c, r = S.bn_sub1 (as_seq h0 a) b1 in
c_out == c /\ as_seq h1 res == r)) | val bn_sub1:
#t:limb_t
-> aLen:size_t{0 < v aLen}
-> a:lbignum t aLen
-> b1:limb t
-> res:lbignum t aLen ->
Stack (carry t)
(requires fun h ->
live h a /\ live h res /\ eq_or_disjoint a res)
(ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\
(let c, r = S.bn_sub1 (as_seq h0 a) b1 in
c_out == c /\ as_seq h1 res == r)) | let bn_sub1 #t aLen a b1 res =
let c0 = subborrow_st (uint #t 0) a.(0ul) b1 (sub res 0ul 1ul) in
let h0 = ST.get () in
LSeq.eq_intro (LSeq.sub (as_seq h0 res) 0 1) (LSeq.create 1 (LSeq.index (as_seq h0 res) 0));
if 1ul <. aLen then begin
[@inline_let] let rLen = aLen -! 1ul in
let a1 = sub a 1ul rLen in
let res1 = sub res 1ul rLen in
let c1 = bn_sub_carry rLen a1 c0 res1 in
let h = ST.get () in
LSeq.lemma_concat2 1 (LSeq.sub (as_seq h0 res) 0 1) (v rLen) (as_seq h res1) (as_seq h res);
c1 end
else c0 | {
"file_name": "code/bignum/Hacl.Bignum.Addition.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 9,
"end_line": 175,
"start_col": 0,
"start_line": 162
} | module Hacl.Bignum.Addition
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Hacl.Bignum.Definitions
open Hacl.Bignum.Base
open Hacl.Impl.Lib
open Lib.IntTypes
open Lib.Buffer
module ST = FStar.HyperStack.ST
module B = LowStar.Buffer
module S = Hacl.Spec.Bignum.Addition
module LSeq = Lib.Sequence
module SL = Hacl.Spec.Lib
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val bn_sub_carry:
#t:limb_t
-> aLen:size_t
-> a:lbignum t aLen
-> c_in:carry t
-> res:lbignum t aLen ->
Stack (carry t)
(requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res)
(ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\
(let c, r = S.bn_sub_carry (as_seq h0 a) c_in in
c_out == c /\ as_seq h1 res == r))
let bn_sub_carry #t aLen a c_in res =
push_frame ();
let c = create 1ul c_in in
[@inline_let]
let refl h i = LSeq.index (as_seq h c) 0 in
[@inline_let]
let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\
B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in
[@inline_let]
let spec h = S.bn_sub_carry_f (as_seq h a) in
let h0 = ST.get () in
fill_elems4 h0 aLen res refl footprint spec
(fun i ->
let h1 = ST.get () in
let t1 = a.(i) in
let res_i = sub res i 1ul in
c.(0ul) <- subborrow_st c.(0ul) t1 (uint #t 0) res_i;
lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1
);
let res = c.(0ul) in
pop_frame ();
res
inline_for_extraction noextract
let bn_sub_eq_len_st (t:limb_t) (aLen:size_t) =
a:lbignum t aLen
-> b:lbignum t aLen
-> res:lbignum t aLen ->
Stack (carry t)
(requires fun h ->
live h a /\ live h b /\ live h res /\
eq_or_disjoint a b /\ eq_or_disjoint a res /\ eq_or_disjoint b res)
(ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\
(let c, r = SL.generate_elems (v aLen) (v aLen) (S.bn_sub_f (as_seq h0 a) (as_seq h0 b)) (uint #t 0) in
c_out == c /\ as_seq h1 res == r))
inline_for_extraction noextract
val bn_sub_eq_len: #t:limb_t -> aLen:size_t -> bn_sub_eq_len_st t aLen
let bn_sub_eq_len #t aLen a b res =
push_frame ();
let c = create 1ul (uint #t 0) in
[@inline_let]
let refl h i = LSeq.index (as_seq h c) 0 in
[@inline_let]
let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\
B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in
[@inline_let]
let spec h = S.bn_sub_f (as_seq h a) (as_seq h b) in
let h0 = ST.get () in
fill_elems4 h0 aLen res refl footprint spec
(fun i ->
let h1 = ST.get () in
let t1 = a.(i) in
let t2 = b.(i) in
let res_i = sub res i 1ul in
c.(0ul) <- subborrow_st c.(0ul) t1 t2 res_i;
lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1;
lemma_eq_disjoint aLen aLen 1ul res b c i h0 h1
);
let res = c.(0ul) in
pop_frame ();
res
let bn_sub_eq_len_u32 (aLen:size_t) : bn_sub_eq_len_st U32 aLen = bn_sub_eq_len aLen
let bn_sub_eq_len_u64 (aLen:size_t) : bn_sub_eq_len_st U64 aLen = bn_sub_eq_len aLen
inline_for_extraction noextract
let bn_sub_eq_len_u (#t:limb_t) (aLen:size_t) : bn_sub_eq_len_st t aLen =
match t with
| U32 -> bn_sub_eq_len_u32 aLen
| U64 -> bn_sub_eq_len_u64 aLen
inline_for_extraction noextract
val bn_sub:
#t:limb_t
-> aLen:size_t
-> a:lbignum t aLen
-> bLen:size_t{v bLen <= v aLen}
-> b:lbignum t bLen
-> res:lbignum t aLen ->
Stack (carry t)
(requires fun h ->
live h a /\ live h b /\ live h res /\
disjoint a b /\ eq_or_disjoint a res /\ disjoint b res)
(ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\
(let c, r = S.bn_sub (as_seq h0 a) (as_seq h0 b) in
c_out == c /\ as_seq h1 res == r))
let bn_sub #t aLen a bLen b res =
let h0 = ST.get () in
let a0 = sub a 0ul bLen in
let res0 = sub res 0ul bLen in
let h1 = ST.get () in
let c0 = bn_sub_eq_len bLen a0 b res0 in
let h1 = ST.get () in
if bLen <. aLen then begin
[@inline_let] let rLen = aLen -! bLen in
let a1 = sub a bLen rLen in
let res1 = sub res bLen rLen in
let c1 = bn_sub_carry rLen a1 c0 res1 in
let h2 = ST.get () in
LSeq.lemma_concat2 (v bLen) (as_seq h1 res0) (v rLen) (as_seq h2 res1) (as_seq h2 res);
c1 end
else c0
inline_for_extraction noextract
val bn_sub1:
#t:limb_t
-> aLen:size_t{0 < v aLen}
-> a:lbignum t aLen
-> b1:limb t
-> res:lbignum t aLen ->
Stack (carry t)
(requires fun h ->
live h a /\ live h res /\ eq_or_disjoint a res)
(ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\
(let c, r = S.bn_sub1 (as_seq h0 a) b1 in
c_out == c /\ as_seq h1 res == r)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Addition.fst.checked",
"Hacl.Impl.Lib.fst.checked",
"Hacl.Bignum.Definitions.fst.checked",
"Hacl.Bignum.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Bignum.Addition.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Lib",
"short_module": "SL"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Addition",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
aLen: Lib.IntTypes.size_t{0 < Lib.IntTypes.v aLen} ->
a: Hacl.Bignum.Definitions.lbignum t aLen ->
b1: Hacl.Bignum.Definitions.limb t ->
res: Hacl.Bignum.Definitions.lbignum t aLen
-> FStar.HyperStack.ST.Stack (Hacl.Spec.Bignum.Base.carry t) | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_t",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Hacl.Bignum.Definitions.lbignum",
"Hacl.Bignum.Definitions.limb",
"Lib.IntTypes.op_Less_Dot",
"FStar.UInt32.__uint_to_t",
"Prims.unit",
"Lib.Sequence.lemma_concat2",
"Lib.Sequence.sub",
"Lib.Buffer.as_seq",
"Lib.Buffer.MUT",
"Hacl.Spec.Bignum.Base.carry",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"Hacl.Bignum.Addition.bn_sub_carry",
"Lib.Buffer.lbuffer_t",
"Lib.Buffer.sub",
"Lib.IntTypes.int_t",
"Lib.IntTypes.op_Subtraction_Bang",
"Prims.bool",
"Lib.Sequence.eq_intro",
"Lib.Sequence.create",
"Lib.Sequence.index",
"Hacl.Bignum.Base.subborrow_st",
"Lib.IntTypes.uint",
"Lib.IntTypes.SEC",
"FStar.UInt32.uint_to_t",
"FStar.UInt32.t",
"Lib.Buffer.op_Array_Access"
] | [] | false | true | false | false | false | let bn_sub1 #t aLen a b1 res =
| let c0 = subborrow_st (uint #t 0) a.(0ul) b1 (sub res 0ul 1ul) in
let h0 = ST.get () in
LSeq.eq_intro (LSeq.sub (as_seq h0 res) 0 1) (LSeq.create 1 (LSeq.index (as_seq h0 res) 0));
if 1ul <. aLen
then
[@@ inline_let ]let rLen = aLen -! 1ul in
let a1 = sub a 1ul rLen in
let res1 = sub res 1ul rLen in
let c1 = bn_sub_carry rLen a1 c0 res1 in
let h = ST.get () in
LSeq.lemma_concat2 1 (LSeq.sub (as_seq h0 res) 0 1) (v rLen) (as_seq h res1) (as_seq h res);
c1
else c0 | false |
Hacl.Bignum.Addition.fst | Hacl.Bignum.Addition.bn_sub | val bn_sub:
#t:limb_t
-> aLen:size_t
-> a:lbignum t aLen
-> bLen:size_t{v bLen <= v aLen}
-> b:lbignum t bLen
-> res:lbignum t aLen ->
Stack (carry t)
(requires fun h ->
live h a /\ live h b /\ live h res /\
disjoint a b /\ eq_or_disjoint a res /\ disjoint b res)
(ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\
(let c, r = S.bn_sub (as_seq h0 a) (as_seq h0 b) in
c_out == c /\ as_seq h1 res == r)) | val bn_sub:
#t:limb_t
-> aLen:size_t
-> a:lbignum t aLen
-> bLen:size_t{v bLen <= v aLen}
-> b:lbignum t bLen
-> res:lbignum t aLen ->
Stack (carry t)
(requires fun h ->
live h a /\ live h b /\ live h res /\
disjoint a b /\ eq_or_disjoint a res /\ disjoint b res)
(ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\
(let c, r = S.bn_sub (as_seq h0 a) (as_seq h0 b) in
c_out == c /\ as_seq h1 res == r)) | let bn_sub #t aLen a bLen b res =
let h0 = ST.get () in
let a0 = sub a 0ul bLen in
let res0 = sub res 0ul bLen in
let h1 = ST.get () in
let c0 = bn_sub_eq_len bLen a0 b res0 in
let h1 = ST.get () in
if bLen <. aLen then begin
[@inline_let] let rLen = aLen -! bLen in
let a1 = sub a bLen rLen in
let res1 = sub res bLen rLen in
let c1 = bn_sub_carry rLen a1 c0 res1 in
let h2 = ST.get () in
LSeq.lemma_concat2 (v bLen) (as_seq h1 res0) (v rLen) (as_seq h2 res1) (as_seq h2 res);
c1 end
else c0 | {
"file_name": "code/bignum/Hacl.Bignum.Addition.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 9,
"end_line": 145,
"start_col": 0,
"start_line": 130
} | module Hacl.Bignum.Addition
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Hacl.Bignum.Definitions
open Hacl.Bignum.Base
open Hacl.Impl.Lib
open Lib.IntTypes
open Lib.Buffer
module ST = FStar.HyperStack.ST
module B = LowStar.Buffer
module S = Hacl.Spec.Bignum.Addition
module LSeq = Lib.Sequence
module SL = Hacl.Spec.Lib
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val bn_sub_carry:
#t:limb_t
-> aLen:size_t
-> a:lbignum t aLen
-> c_in:carry t
-> res:lbignum t aLen ->
Stack (carry t)
(requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res)
(ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\
(let c, r = S.bn_sub_carry (as_seq h0 a) c_in in
c_out == c /\ as_seq h1 res == r))
let bn_sub_carry #t aLen a c_in res =
push_frame ();
let c = create 1ul c_in in
[@inline_let]
let refl h i = LSeq.index (as_seq h c) 0 in
[@inline_let]
let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\
B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in
[@inline_let]
let spec h = S.bn_sub_carry_f (as_seq h a) in
let h0 = ST.get () in
fill_elems4 h0 aLen res refl footprint spec
(fun i ->
let h1 = ST.get () in
let t1 = a.(i) in
let res_i = sub res i 1ul in
c.(0ul) <- subborrow_st c.(0ul) t1 (uint #t 0) res_i;
lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1
);
let res = c.(0ul) in
pop_frame ();
res
inline_for_extraction noextract
let bn_sub_eq_len_st (t:limb_t) (aLen:size_t) =
a:lbignum t aLen
-> b:lbignum t aLen
-> res:lbignum t aLen ->
Stack (carry t)
(requires fun h ->
live h a /\ live h b /\ live h res /\
eq_or_disjoint a b /\ eq_or_disjoint a res /\ eq_or_disjoint b res)
(ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\
(let c, r = SL.generate_elems (v aLen) (v aLen) (S.bn_sub_f (as_seq h0 a) (as_seq h0 b)) (uint #t 0) in
c_out == c /\ as_seq h1 res == r))
inline_for_extraction noextract
val bn_sub_eq_len: #t:limb_t -> aLen:size_t -> bn_sub_eq_len_st t aLen
let bn_sub_eq_len #t aLen a b res =
push_frame ();
let c = create 1ul (uint #t 0) in
[@inline_let]
let refl h i = LSeq.index (as_seq h c) 0 in
[@inline_let]
let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\
B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in
[@inline_let]
let spec h = S.bn_sub_f (as_seq h a) (as_seq h b) in
let h0 = ST.get () in
fill_elems4 h0 aLen res refl footprint spec
(fun i ->
let h1 = ST.get () in
let t1 = a.(i) in
let t2 = b.(i) in
let res_i = sub res i 1ul in
c.(0ul) <- subborrow_st c.(0ul) t1 t2 res_i;
lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1;
lemma_eq_disjoint aLen aLen 1ul res b c i h0 h1
);
let res = c.(0ul) in
pop_frame ();
res
let bn_sub_eq_len_u32 (aLen:size_t) : bn_sub_eq_len_st U32 aLen = bn_sub_eq_len aLen
let bn_sub_eq_len_u64 (aLen:size_t) : bn_sub_eq_len_st U64 aLen = bn_sub_eq_len aLen
inline_for_extraction noextract
let bn_sub_eq_len_u (#t:limb_t) (aLen:size_t) : bn_sub_eq_len_st t aLen =
match t with
| U32 -> bn_sub_eq_len_u32 aLen
| U64 -> bn_sub_eq_len_u64 aLen
inline_for_extraction noextract
val bn_sub:
#t:limb_t
-> aLen:size_t
-> a:lbignum t aLen
-> bLen:size_t{v bLen <= v aLen}
-> b:lbignum t bLen
-> res:lbignum t aLen ->
Stack (carry t)
(requires fun h ->
live h a /\ live h b /\ live h res /\
disjoint a b /\ eq_or_disjoint a res /\ disjoint b res)
(ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\
(let c, r = S.bn_sub (as_seq h0 a) (as_seq h0 b) in
c_out == c /\ as_seq h1 res == r)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Addition.fst.checked",
"Hacl.Impl.Lib.fst.checked",
"Hacl.Bignum.Definitions.fst.checked",
"Hacl.Bignum.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Bignum.Addition.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Lib",
"short_module": "SL"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Addition",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
aLen: Lib.IntTypes.size_t ->
a: Hacl.Bignum.Definitions.lbignum t aLen ->
bLen: Lib.IntTypes.size_t{Lib.IntTypes.v bLen <= Lib.IntTypes.v aLen} ->
b: Hacl.Bignum.Definitions.lbignum t bLen ->
res: Hacl.Bignum.Definitions.lbignum t aLen
-> FStar.HyperStack.ST.Stack (Hacl.Spec.Bignum.Base.carry t) | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_t",
"Hacl.Bignum.Definitions.lbignum",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Lib.IntTypes.op_Less_Dot",
"Prims.unit",
"Lib.Sequence.lemma_concat2",
"Hacl.Bignum.Definitions.limb",
"Lib.Buffer.as_seq",
"Lib.Buffer.MUT",
"Hacl.Spec.Bignum.Base.carry",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"Hacl.Bignum.Addition.bn_sub_carry",
"Lib.Buffer.lbuffer_t",
"Lib.Buffer.sub",
"Lib.IntTypes.int_t",
"Lib.IntTypes.op_Subtraction_Bang",
"Prims.bool",
"Hacl.Bignum.Addition.bn_sub_eq_len",
"FStar.UInt32.__uint_to_t"
] | [] | false | true | false | false | false | let bn_sub #t aLen a bLen b res =
| let h0 = ST.get () in
let a0 = sub a 0ul bLen in
let res0 = sub res 0ul bLen in
let h1 = ST.get () in
let c0 = bn_sub_eq_len bLen a0 b res0 in
let h1 = ST.get () in
if bLen <. aLen
then
[@@ inline_let ]let rLen = aLen -! bLen in
let a1 = sub a bLen rLen in
let res1 = sub res bLen rLen in
let c1 = bn_sub_carry rLen a1 c0 res1 in
let h2 = ST.get () in
LSeq.lemma_concat2 (v bLen) (as_seq h1 res0) (v rLen) (as_seq h2 res1) (as_seq h2 res);
c1
else c0 | false |
Hacl.Bignum.Addition.fst | Hacl.Bignum.Addition.bn_sub_eq_len | val bn_sub_eq_len: #t:limb_t -> aLen:size_t -> bn_sub_eq_len_st t aLen | val bn_sub_eq_len: #t:limb_t -> aLen:size_t -> bn_sub_eq_len_st t aLen | let bn_sub_eq_len #t aLen a b res =
push_frame ();
let c = create 1ul (uint #t 0) in
[@inline_let]
let refl h i = LSeq.index (as_seq h c) 0 in
[@inline_let]
let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\
B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in
[@inline_let]
let spec h = S.bn_sub_f (as_seq h a) (as_seq h b) in
let h0 = ST.get () in
fill_elems4 h0 aLen res refl footprint spec
(fun i ->
let h1 = ST.get () in
let t1 = a.(i) in
let t2 = b.(i) in
let res_i = sub res i 1ul in
c.(0ul) <- subborrow_st c.(0ul) t1 t2 res_i;
lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1;
lemma_eq_disjoint aLen aLen 1ul res b c i h0 h1
);
let res = c.(0ul) in
pop_frame ();
res | {
"file_name": "code/bignum/Hacl.Bignum.Addition.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 5,
"end_line": 102,
"start_col": 0,
"start_line": 77
} | module Hacl.Bignum.Addition
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Hacl.Bignum.Definitions
open Hacl.Bignum.Base
open Hacl.Impl.Lib
open Lib.IntTypes
open Lib.Buffer
module ST = FStar.HyperStack.ST
module B = LowStar.Buffer
module S = Hacl.Spec.Bignum.Addition
module LSeq = Lib.Sequence
module SL = Hacl.Spec.Lib
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val bn_sub_carry:
#t:limb_t
-> aLen:size_t
-> a:lbignum t aLen
-> c_in:carry t
-> res:lbignum t aLen ->
Stack (carry t)
(requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res)
(ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\
(let c, r = S.bn_sub_carry (as_seq h0 a) c_in in
c_out == c /\ as_seq h1 res == r))
let bn_sub_carry #t aLen a c_in res =
push_frame ();
let c = create 1ul c_in in
[@inline_let]
let refl h i = LSeq.index (as_seq h c) 0 in
[@inline_let]
let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\
B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in
[@inline_let]
let spec h = S.bn_sub_carry_f (as_seq h a) in
let h0 = ST.get () in
fill_elems4 h0 aLen res refl footprint spec
(fun i ->
let h1 = ST.get () in
let t1 = a.(i) in
let res_i = sub res i 1ul in
c.(0ul) <- subborrow_st c.(0ul) t1 (uint #t 0) res_i;
lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1
);
let res = c.(0ul) in
pop_frame ();
res
inline_for_extraction noextract
let bn_sub_eq_len_st (t:limb_t) (aLen:size_t) =
a:lbignum t aLen
-> b:lbignum t aLen
-> res:lbignum t aLen ->
Stack (carry t)
(requires fun h ->
live h a /\ live h b /\ live h res /\
eq_or_disjoint a b /\ eq_or_disjoint a res /\ eq_or_disjoint b res)
(ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\
(let c, r = SL.generate_elems (v aLen) (v aLen) (S.bn_sub_f (as_seq h0 a) (as_seq h0 b)) (uint #t 0) in
c_out == c /\ as_seq h1 res == r))
inline_for_extraction noextract | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Addition.fst.checked",
"Hacl.Impl.Lib.fst.checked",
"Hacl.Bignum.Definitions.fst.checked",
"Hacl.Bignum.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Bignum.Addition.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Lib",
"short_module": "SL"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Addition",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | aLen: Lib.IntTypes.size_t -> Hacl.Bignum.Addition.bn_sub_eq_len_st t aLen | Prims.Tot | [
"total"
] | [] | [
"Hacl.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_t",
"Hacl.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Base.carry",
"Prims.unit",
"FStar.HyperStack.ST.pop_frame",
"Lib.Buffer.op_Array_Access",
"Lib.Buffer.MUT",
"FStar.UInt32.__uint_to_t",
"Hacl.Impl.Lib.fill_elems4",
"Hacl.Bignum.Definitions.limb",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Hacl.Impl.Lib.lemma_eq_disjoint",
"Lib.Buffer.op_Array_Assignment",
"Hacl.Bignum.Base.subborrow_st",
"Lib.Buffer.lbuffer_t",
"FStar.UInt32.uint_to_t",
"FStar.UInt32.t",
"Lib.Buffer.sub",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"Prims.nat",
"Prims.op_LessThanOrEqual",
"Prims.op_Subtraction",
"Prims.pow2",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.Bignum.Definitions.limb",
"Hacl.Spec.Bignum.Addition.bn_sub_f",
"Lib.Buffer.as_seq",
"LowStar.Monotonic.Buffer.loc",
"Prims.l_and",
"LowStar.Monotonic.Buffer.loc_disjoint",
"Lib.Buffer.loc",
"LowStar.Monotonic.Buffer.loc_includes",
"LowStar.Monotonic.Buffer.address_liveness_insensitive_locs",
"Lib.IntTypes.size_nat",
"Prims.eq2",
"FStar.Seq.Base.index",
"Lib.Sequence.to_seq",
"Lib.Sequence.index",
"Lib.Buffer.create",
"Lib.IntTypes.uint",
"Lib.IntTypes.SEC",
"Lib.Buffer.lbuffer",
"FStar.HyperStack.ST.push_frame"
] | [] | false | false | false | false | false | let bn_sub_eq_len #t aLen a b res =
| push_frame ();
let c = create 1ul (uint #t 0) in
[@@ inline_let ]let refl h i = LSeq.index (as_seq h c) 0 in
[@@ inline_let ]let footprint (i: size_nat{i <= v aLen})
: GTot
(l: B.loc{B.loc_disjoint l (loc res) /\ B.address_liveness_insensitive_locs `B.loc_includes` l})
=
loc c
in
[@@ inline_let ]let spec h = S.bn_sub_f (as_seq h a) (as_seq h b) in
let h0 = ST.get () in
fill_elems4 h0
aLen
res
refl
footprint
spec
(fun i ->
let h1 = ST.get () in
let t1 = a.(i) in
let t2 = b.(i) in
let res_i = sub res i 1ul in
c.(0ul) <- subborrow_st c.(0ul) t1 t2 res_i;
lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1;
lemma_eq_disjoint aLen aLen 1ul res b c i h0 h1);
let res = c.(0ul) in
pop_frame ();
res | false |
Hacl.Bignum.Addition.fst | Hacl.Bignum.Addition.bn_sub_carry | val bn_sub_carry:
#t:limb_t
-> aLen:size_t
-> a:lbignum t aLen
-> c_in:carry t
-> res:lbignum t aLen ->
Stack (carry t)
(requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res)
(ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\
(let c, r = S.bn_sub_carry (as_seq h0 a) c_in in
c_out == c /\ as_seq h1 res == r)) | val bn_sub_carry:
#t:limb_t
-> aLen:size_t
-> a:lbignum t aLen
-> c_in:carry t
-> res:lbignum t aLen ->
Stack (carry t)
(requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res)
(ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\
(let c, r = S.bn_sub_carry (as_seq h0 a) c_in in
c_out == c /\ as_seq h1 res == r)) | let bn_sub_carry #t aLen a c_in res =
push_frame ();
let c = create 1ul c_in in
[@inline_let]
let refl h i = LSeq.index (as_seq h c) 0 in
[@inline_let]
let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\
B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in
[@inline_let]
let spec h = S.bn_sub_carry_f (as_seq h a) in
let h0 = ST.get () in
fill_elems4 h0 aLen res refl footprint spec
(fun i ->
let h1 = ST.get () in
let t1 = a.(i) in
let res_i = sub res i 1ul in
c.(0ul) <- subborrow_st c.(0ul) t1 (uint #t 0) res_i;
lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1
);
let res = c.(0ul) in
pop_frame ();
res | {
"file_name": "code/bignum/Hacl.Bignum.Addition.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 5,
"end_line": 58,
"start_col": 0,
"start_line": 35
} | module Hacl.Bignum.Addition
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Hacl.Bignum.Definitions
open Hacl.Bignum.Base
open Hacl.Impl.Lib
open Lib.IntTypes
open Lib.Buffer
module ST = FStar.HyperStack.ST
module B = LowStar.Buffer
module S = Hacl.Spec.Bignum.Addition
module LSeq = Lib.Sequence
module SL = Hacl.Spec.Lib
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val bn_sub_carry:
#t:limb_t
-> aLen:size_t
-> a:lbignum t aLen
-> c_in:carry t
-> res:lbignum t aLen ->
Stack (carry t)
(requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res)
(ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\
(let c, r = S.bn_sub_carry (as_seq h0 a) c_in in
c_out == c /\ as_seq h1 res == r)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Addition.fst.checked",
"Hacl.Impl.Lib.fst.checked",
"Hacl.Bignum.Definitions.fst.checked",
"Hacl.Bignum.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Bignum.Addition.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Lib",
"short_module": "SL"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Addition",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
aLen: Lib.IntTypes.size_t ->
a: Hacl.Bignum.Definitions.lbignum t aLen ->
c_in: Hacl.Spec.Bignum.Base.carry t ->
res: Hacl.Bignum.Definitions.lbignum t aLen
-> FStar.HyperStack.ST.Stack (Hacl.Spec.Bignum.Base.carry t) | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_t",
"Hacl.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Base.carry",
"Prims.unit",
"FStar.HyperStack.ST.pop_frame",
"Lib.Buffer.op_Array_Access",
"Lib.Buffer.MUT",
"FStar.UInt32.__uint_to_t",
"Hacl.Impl.Lib.fill_elems4",
"Hacl.Bignum.Definitions.limb",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Hacl.Impl.Lib.lemma_eq_disjoint",
"Lib.Buffer.op_Array_Assignment",
"Hacl.Bignum.Base.subborrow_st",
"Lib.IntTypes.uint",
"Lib.IntTypes.SEC",
"Lib.Buffer.lbuffer_t",
"FStar.UInt32.uint_to_t",
"FStar.UInt32.t",
"Lib.Buffer.sub",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"Prims.nat",
"Prims.op_LessThanOrEqual",
"Prims.op_Subtraction",
"Prims.pow2",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.Bignum.Definitions.limb",
"Hacl.Spec.Bignum.Addition.bn_sub_carry_f",
"Lib.Buffer.as_seq",
"LowStar.Monotonic.Buffer.loc",
"Prims.l_and",
"LowStar.Monotonic.Buffer.loc_disjoint",
"Lib.Buffer.loc",
"LowStar.Monotonic.Buffer.loc_includes",
"LowStar.Monotonic.Buffer.address_liveness_insensitive_locs",
"Lib.IntTypes.size_nat",
"Prims.eq2",
"FStar.Seq.Base.index",
"Lib.Sequence.to_seq",
"Lib.Sequence.index",
"Lib.Buffer.create",
"Lib.Buffer.lbuffer",
"FStar.HyperStack.ST.push_frame"
] | [] | false | true | false | false | false | let bn_sub_carry #t aLen a c_in res =
| push_frame ();
let c = create 1ul c_in in
[@@ inline_let ]let refl h i = LSeq.index (as_seq h c) 0 in
[@@ inline_let ]let footprint (i: size_nat{i <= v aLen})
: GTot
(l: B.loc{B.loc_disjoint l (loc res) /\ B.address_liveness_insensitive_locs `B.loc_includes` l})
=
loc c
in
[@@ inline_let ]let spec h = S.bn_sub_carry_f (as_seq h a) in
let h0 = ST.get () in
fill_elems4 h0
aLen
res
refl
footprint
spec
(fun i ->
let h1 = ST.get () in
let t1 = a.(i) in
let res_i = sub res i 1ul in
c.(0ul) <- subborrow_st c.(0ul) t1 (uint #t 0) res_i;
lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1);
let res = c.(0ul) in
pop_frame ();
res | false |
Hacl.Bignum.Addition.fst | Hacl.Bignum.Addition.bn_add_carry | val bn_add_carry:
#t:limb_t
-> aLen:size_t
-> a:lbignum t aLen
-> c_in:carry t
-> res:lbignum t aLen ->
Stack (carry t)
(requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res)
(ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\
(let c, r = S.bn_add_carry (as_seq h0 a) c_in in
c_out == c /\ as_seq h1 res == r)) | val bn_add_carry:
#t:limb_t
-> aLen:size_t
-> a:lbignum t aLen
-> c_in:carry t
-> res:lbignum t aLen ->
Stack (carry t)
(requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res)
(ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\
(let c, r = S.bn_add_carry (as_seq h0 a) c_in in
c_out == c /\ as_seq h1 res == r)) | let bn_add_carry #t aLen a c_in res =
push_frame ();
let c = create 1ul c_in in
[@inline_let]
let refl h i = LSeq.index (as_seq h c) 0 in
[@inline_let]
let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\
B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in
[@inline_let]
let spec h = S.bn_add_carry_f (as_seq h a) in
let h0 = ST.get () in
fill_elems4 h0 aLen res refl footprint spec
(fun i ->
let h1 = ST.get () in
let t1 = a.(i) in
let res_i = sub res i 1ul in
c.(0ul) <- addcarry_st c.(0ul) t1 (uint #t 0) res_i;
lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1
);
let res = c.(0ul) in
pop_frame ();
res | {
"file_name": "code/bignum/Hacl.Bignum.Addition.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 5,
"end_line": 214,
"start_col": 0,
"start_line": 191
} | module Hacl.Bignum.Addition
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Hacl.Bignum.Definitions
open Hacl.Bignum.Base
open Hacl.Impl.Lib
open Lib.IntTypes
open Lib.Buffer
module ST = FStar.HyperStack.ST
module B = LowStar.Buffer
module S = Hacl.Spec.Bignum.Addition
module LSeq = Lib.Sequence
module SL = Hacl.Spec.Lib
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val bn_sub_carry:
#t:limb_t
-> aLen:size_t
-> a:lbignum t aLen
-> c_in:carry t
-> res:lbignum t aLen ->
Stack (carry t)
(requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res)
(ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\
(let c, r = S.bn_sub_carry (as_seq h0 a) c_in in
c_out == c /\ as_seq h1 res == r))
let bn_sub_carry #t aLen a c_in res =
push_frame ();
let c = create 1ul c_in in
[@inline_let]
let refl h i = LSeq.index (as_seq h c) 0 in
[@inline_let]
let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\
B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in
[@inline_let]
let spec h = S.bn_sub_carry_f (as_seq h a) in
let h0 = ST.get () in
fill_elems4 h0 aLen res refl footprint spec
(fun i ->
let h1 = ST.get () in
let t1 = a.(i) in
let res_i = sub res i 1ul in
c.(0ul) <- subborrow_st c.(0ul) t1 (uint #t 0) res_i;
lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1
);
let res = c.(0ul) in
pop_frame ();
res
inline_for_extraction noextract
let bn_sub_eq_len_st (t:limb_t) (aLen:size_t) =
a:lbignum t aLen
-> b:lbignum t aLen
-> res:lbignum t aLen ->
Stack (carry t)
(requires fun h ->
live h a /\ live h b /\ live h res /\
eq_or_disjoint a b /\ eq_or_disjoint a res /\ eq_or_disjoint b res)
(ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\
(let c, r = SL.generate_elems (v aLen) (v aLen) (S.bn_sub_f (as_seq h0 a) (as_seq h0 b)) (uint #t 0) in
c_out == c /\ as_seq h1 res == r))
inline_for_extraction noextract
val bn_sub_eq_len: #t:limb_t -> aLen:size_t -> bn_sub_eq_len_st t aLen
let bn_sub_eq_len #t aLen a b res =
push_frame ();
let c = create 1ul (uint #t 0) in
[@inline_let]
let refl h i = LSeq.index (as_seq h c) 0 in
[@inline_let]
let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\
B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in
[@inline_let]
let spec h = S.bn_sub_f (as_seq h a) (as_seq h b) in
let h0 = ST.get () in
fill_elems4 h0 aLen res refl footprint spec
(fun i ->
let h1 = ST.get () in
let t1 = a.(i) in
let t2 = b.(i) in
let res_i = sub res i 1ul in
c.(0ul) <- subborrow_st c.(0ul) t1 t2 res_i;
lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1;
lemma_eq_disjoint aLen aLen 1ul res b c i h0 h1
);
let res = c.(0ul) in
pop_frame ();
res
let bn_sub_eq_len_u32 (aLen:size_t) : bn_sub_eq_len_st U32 aLen = bn_sub_eq_len aLen
let bn_sub_eq_len_u64 (aLen:size_t) : bn_sub_eq_len_st U64 aLen = bn_sub_eq_len aLen
inline_for_extraction noextract
let bn_sub_eq_len_u (#t:limb_t) (aLen:size_t) : bn_sub_eq_len_st t aLen =
match t with
| U32 -> bn_sub_eq_len_u32 aLen
| U64 -> bn_sub_eq_len_u64 aLen
inline_for_extraction noextract
val bn_sub:
#t:limb_t
-> aLen:size_t
-> a:lbignum t aLen
-> bLen:size_t{v bLen <= v aLen}
-> b:lbignum t bLen
-> res:lbignum t aLen ->
Stack (carry t)
(requires fun h ->
live h a /\ live h b /\ live h res /\
disjoint a b /\ eq_or_disjoint a res /\ disjoint b res)
(ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\
(let c, r = S.bn_sub (as_seq h0 a) (as_seq h0 b) in
c_out == c /\ as_seq h1 res == r))
let bn_sub #t aLen a bLen b res =
let h0 = ST.get () in
let a0 = sub a 0ul bLen in
let res0 = sub res 0ul bLen in
let h1 = ST.get () in
let c0 = bn_sub_eq_len bLen a0 b res0 in
let h1 = ST.get () in
if bLen <. aLen then begin
[@inline_let] let rLen = aLen -! bLen in
let a1 = sub a bLen rLen in
let res1 = sub res bLen rLen in
let c1 = bn_sub_carry rLen a1 c0 res1 in
let h2 = ST.get () in
LSeq.lemma_concat2 (v bLen) (as_seq h1 res0) (v rLen) (as_seq h2 res1) (as_seq h2 res);
c1 end
else c0
inline_for_extraction noextract
val bn_sub1:
#t:limb_t
-> aLen:size_t{0 < v aLen}
-> a:lbignum t aLen
-> b1:limb t
-> res:lbignum t aLen ->
Stack (carry t)
(requires fun h ->
live h a /\ live h res /\ eq_or_disjoint a res)
(ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\
(let c, r = S.bn_sub1 (as_seq h0 a) b1 in
c_out == c /\ as_seq h1 res == r))
let bn_sub1 #t aLen a b1 res =
let c0 = subborrow_st (uint #t 0) a.(0ul) b1 (sub res 0ul 1ul) in
let h0 = ST.get () in
LSeq.eq_intro (LSeq.sub (as_seq h0 res) 0 1) (LSeq.create 1 (LSeq.index (as_seq h0 res) 0));
if 1ul <. aLen then begin
[@inline_let] let rLen = aLen -! 1ul in
let a1 = sub a 1ul rLen in
let res1 = sub res 1ul rLen in
let c1 = bn_sub_carry rLen a1 c0 res1 in
let h = ST.get () in
LSeq.lemma_concat2 1 (LSeq.sub (as_seq h0 res) 0 1) (v rLen) (as_seq h res1) (as_seq h res);
c1 end
else c0
inline_for_extraction noextract
val bn_add_carry:
#t:limb_t
-> aLen:size_t
-> a:lbignum t aLen
-> c_in:carry t
-> res:lbignum t aLen ->
Stack (carry t)
(requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res)
(ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\
(let c, r = S.bn_add_carry (as_seq h0 a) c_in in
c_out == c /\ as_seq h1 res == r)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Addition.fst.checked",
"Hacl.Impl.Lib.fst.checked",
"Hacl.Bignum.Definitions.fst.checked",
"Hacl.Bignum.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Bignum.Addition.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Lib",
"short_module": "SL"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Addition",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
aLen: Lib.IntTypes.size_t ->
a: Hacl.Bignum.Definitions.lbignum t aLen ->
c_in: Hacl.Spec.Bignum.Base.carry t ->
res: Hacl.Bignum.Definitions.lbignum t aLen
-> FStar.HyperStack.ST.Stack (Hacl.Spec.Bignum.Base.carry t) | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_t",
"Hacl.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Base.carry",
"Prims.unit",
"FStar.HyperStack.ST.pop_frame",
"Lib.Buffer.op_Array_Access",
"Lib.Buffer.MUT",
"FStar.UInt32.__uint_to_t",
"Hacl.Impl.Lib.fill_elems4",
"Hacl.Bignum.Definitions.limb",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Hacl.Impl.Lib.lemma_eq_disjoint",
"Lib.Buffer.op_Array_Assignment",
"Hacl.Bignum.Base.addcarry_st",
"Lib.IntTypes.uint",
"Lib.IntTypes.SEC",
"Lib.Buffer.lbuffer_t",
"FStar.UInt32.uint_to_t",
"FStar.UInt32.t",
"Lib.Buffer.sub",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"Prims.nat",
"Prims.op_LessThanOrEqual",
"Prims.op_Subtraction",
"Prims.pow2",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.Bignum.Definitions.limb",
"Hacl.Spec.Bignum.Addition.bn_add_carry_f",
"Lib.Buffer.as_seq",
"LowStar.Monotonic.Buffer.loc",
"Prims.l_and",
"LowStar.Monotonic.Buffer.loc_disjoint",
"Lib.Buffer.loc",
"LowStar.Monotonic.Buffer.loc_includes",
"LowStar.Monotonic.Buffer.address_liveness_insensitive_locs",
"Lib.IntTypes.size_nat",
"Prims.eq2",
"FStar.Seq.Base.index",
"Lib.Sequence.to_seq",
"Lib.Sequence.index",
"Lib.Buffer.create",
"Lib.Buffer.lbuffer",
"FStar.HyperStack.ST.push_frame"
] | [] | false | true | false | false | false | let bn_add_carry #t aLen a c_in res =
| push_frame ();
let c = create 1ul c_in in
[@@ inline_let ]let refl h i = LSeq.index (as_seq h c) 0 in
[@@ inline_let ]let footprint (i: size_nat{i <= v aLen})
: GTot
(l: B.loc{B.loc_disjoint l (loc res) /\ B.address_liveness_insensitive_locs `B.loc_includes` l})
=
loc c
in
[@@ inline_let ]let spec h = S.bn_add_carry_f (as_seq h a) in
let h0 = ST.get () in
fill_elems4 h0
aLen
res
refl
footprint
spec
(fun i ->
let h1 = ST.get () in
let t1 = a.(i) in
let res_i = sub res i 1ul in
c.(0ul) <- addcarry_st c.(0ul) t1 (uint #t 0) res_i;
lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1);
let res = c.(0ul) in
pop_frame ();
res | false |
Hacl.Bignum.Addition.fst | Hacl.Bignum.Addition.bn_add_eq_len | val bn_add_eq_len: #t:limb_t -> aLen:size_t -> bn_add_eq_len_st t aLen | val bn_add_eq_len: #t:limb_t -> aLen:size_t -> bn_add_eq_len_st t aLen | let bn_add_eq_len #t aLen a b res =
push_frame ();
let c = create 1ul (uint #t 0) in
[@inline_let]
let refl h i = LSeq.index (as_seq h c) 0 in
[@inline_let]
let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\
B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in
[@inline_let]
let spec h = S.bn_add_f (as_seq h a) (as_seq h b) in
let h0 = ST.get () in
fill_elems4 h0 aLen res refl footprint spec
(fun i ->
let h1 = ST.get () in
let t1 = a.(i) in
let t2 = b.(i) in
let res_i = sub res i 1ul in
c.(0ul) <- addcarry_st c.(0ul) t1 t2 res_i;
lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1;
lemma_eq_disjoint aLen aLen 1ul res b c i h0 h1
);
let res = c.(0ul) in
pop_frame ();
res | {
"file_name": "code/bignum/Hacl.Bignum.Addition.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 5,
"end_line": 258,
"start_col": 0,
"start_line": 233
} | module Hacl.Bignum.Addition
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Hacl.Bignum.Definitions
open Hacl.Bignum.Base
open Hacl.Impl.Lib
open Lib.IntTypes
open Lib.Buffer
module ST = FStar.HyperStack.ST
module B = LowStar.Buffer
module S = Hacl.Spec.Bignum.Addition
module LSeq = Lib.Sequence
module SL = Hacl.Spec.Lib
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val bn_sub_carry:
#t:limb_t
-> aLen:size_t
-> a:lbignum t aLen
-> c_in:carry t
-> res:lbignum t aLen ->
Stack (carry t)
(requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res)
(ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\
(let c, r = S.bn_sub_carry (as_seq h0 a) c_in in
c_out == c /\ as_seq h1 res == r))
let bn_sub_carry #t aLen a c_in res =
push_frame ();
let c = create 1ul c_in in
[@inline_let]
let refl h i = LSeq.index (as_seq h c) 0 in
[@inline_let]
let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\
B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in
[@inline_let]
let spec h = S.bn_sub_carry_f (as_seq h a) in
let h0 = ST.get () in
fill_elems4 h0 aLen res refl footprint spec
(fun i ->
let h1 = ST.get () in
let t1 = a.(i) in
let res_i = sub res i 1ul in
c.(0ul) <- subborrow_st c.(0ul) t1 (uint #t 0) res_i;
lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1
);
let res = c.(0ul) in
pop_frame ();
res
inline_for_extraction noextract
let bn_sub_eq_len_st (t:limb_t) (aLen:size_t) =
a:lbignum t aLen
-> b:lbignum t aLen
-> res:lbignum t aLen ->
Stack (carry t)
(requires fun h ->
live h a /\ live h b /\ live h res /\
eq_or_disjoint a b /\ eq_or_disjoint a res /\ eq_or_disjoint b res)
(ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\
(let c, r = SL.generate_elems (v aLen) (v aLen) (S.bn_sub_f (as_seq h0 a) (as_seq h0 b)) (uint #t 0) in
c_out == c /\ as_seq h1 res == r))
inline_for_extraction noextract
val bn_sub_eq_len: #t:limb_t -> aLen:size_t -> bn_sub_eq_len_st t aLen
let bn_sub_eq_len #t aLen a b res =
push_frame ();
let c = create 1ul (uint #t 0) in
[@inline_let]
let refl h i = LSeq.index (as_seq h c) 0 in
[@inline_let]
let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\
B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in
[@inline_let]
let spec h = S.bn_sub_f (as_seq h a) (as_seq h b) in
let h0 = ST.get () in
fill_elems4 h0 aLen res refl footprint spec
(fun i ->
let h1 = ST.get () in
let t1 = a.(i) in
let t2 = b.(i) in
let res_i = sub res i 1ul in
c.(0ul) <- subborrow_st c.(0ul) t1 t2 res_i;
lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1;
lemma_eq_disjoint aLen aLen 1ul res b c i h0 h1
);
let res = c.(0ul) in
pop_frame ();
res
let bn_sub_eq_len_u32 (aLen:size_t) : bn_sub_eq_len_st U32 aLen = bn_sub_eq_len aLen
let bn_sub_eq_len_u64 (aLen:size_t) : bn_sub_eq_len_st U64 aLen = bn_sub_eq_len aLen
inline_for_extraction noextract
let bn_sub_eq_len_u (#t:limb_t) (aLen:size_t) : bn_sub_eq_len_st t aLen =
match t with
| U32 -> bn_sub_eq_len_u32 aLen
| U64 -> bn_sub_eq_len_u64 aLen
inline_for_extraction noextract
val bn_sub:
#t:limb_t
-> aLen:size_t
-> a:lbignum t aLen
-> bLen:size_t{v bLen <= v aLen}
-> b:lbignum t bLen
-> res:lbignum t aLen ->
Stack (carry t)
(requires fun h ->
live h a /\ live h b /\ live h res /\
disjoint a b /\ eq_or_disjoint a res /\ disjoint b res)
(ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\
(let c, r = S.bn_sub (as_seq h0 a) (as_seq h0 b) in
c_out == c /\ as_seq h1 res == r))
let bn_sub #t aLen a bLen b res =
let h0 = ST.get () in
let a0 = sub a 0ul bLen in
let res0 = sub res 0ul bLen in
let h1 = ST.get () in
let c0 = bn_sub_eq_len bLen a0 b res0 in
let h1 = ST.get () in
if bLen <. aLen then begin
[@inline_let] let rLen = aLen -! bLen in
let a1 = sub a bLen rLen in
let res1 = sub res bLen rLen in
let c1 = bn_sub_carry rLen a1 c0 res1 in
let h2 = ST.get () in
LSeq.lemma_concat2 (v bLen) (as_seq h1 res0) (v rLen) (as_seq h2 res1) (as_seq h2 res);
c1 end
else c0
inline_for_extraction noextract
val bn_sub1:
#t:limb_t
-> aLen:size_t{0 < v aLen}
-> a:lbignum t aLen
-> b1:limb t
-> res:lbignum t aLen ->
Stack (carry t)
(requires fun h ->
live h a /\ live h res /\ eq_or_disjoint a res)
(ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\
(let c, r = S.bn_sub1 (as_seq h0 a) b1 in
c_out == c /\ as_seq h1 res == r))
let bn_sub1 #t aLen a b1 res =
let c0 = subborrow_st (uint #t 0) a.(0ul) b1 (sub res 0ul 1ul) in
let h0 = ST.get () in
LSeq.eq_intro (LSeq.sub (as_seq h0 res) 0 1) (LSeq.create 1 (LSeq.index (as_seq h0 res) 0));
if 1ul <. aLen then begin
[@inline_let] let rLen = aLen -! 1ul in
let a1 = sub a 1ul rLen in
let res1 = sub res 1ul rLen in
let c1 = bn_sub_carry rLen a1 c0 res1 in
let h = ST.get () in
LSeq.lemma_concat2 1 (LSeq.sub (as_seq h0 res) 0 1) (v rLen) (as_seq h res1) (as_seq h res);
c1 end
else c0
inline_for_extraction noextract
val bn_add_carry:
#t:limb_t
-> aLen:size_t
-> a:lbignum t aLen
-> c_in:carry t
-> res:lbignum t aLen ->
Stack (carry t)
(requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res)
(ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\
(let c, r = S.bn_add_carry (as_seq h0 a) c_in in
c_out == c /\ as_seq h1 res == r))
let bn_add_carry #t aLen a c_in res =
push_frame ();
let c = create 1ul c_in in
[@inline_let]
let refl h i = LSeq.index (as_seq h c) 0 in
[@inline_let]
let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\
B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in
[@inline_let]
let spec h = S.bn_add_carry_f (as_seq h a) in
let h0 = ST.get () in
fill_elems4 h0 aLen res refl footprint spec
(fun i ->
let h1 = ST.get () in
let t1 = a.(i) in
let res_i = sub res i 1ul in
c.(0ul) <- addcarry_st c.(0ul) t1 (uint #t 0) res_i;
lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1
);
let res = c.(0ul) in
pop_frame ();
res
inline_for_extraction noextract
let bn_add_eq_len_st (t:limb_t) (aLen:size_t) =
a:lbignum t aLen
-> b:lbignum t aLen
-> res:lbignum t aLen ->
Stack (carry t)
(requires fun h ->
live h a /\ live h b /\ live h res /\
eq_or_disjoint a b /\ eq_or_disjoint a res /\ eq_or_disjoint b res)
(ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\
(let c, r = SL.generate_elems (v aLen) (v aLen) (S.bn_add_f (as_seq h0 a) (as_seq h0 b)) (uint #t 0) in
c_out == c /\ as_seq h1 res == r))
inline_for_extraction noextract | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Addition.fst.checked",
"Hacl.Impl.Lib.fst.checked",
"Hacl.Bignum.Definitions.fst.checked",
"Hacl.Bignum.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Bignum.Addition.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Lib",
"short_module": "SL"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Addition",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | aLen: Lib.IntTypes.size_t -> Hacl.Bignum.Addition.bn_add_eq_len_st t aLen | Prims.Tot | [
"total"
] | [] | [
"Hacl.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_t",
"Hacl.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Base.carry",
"Prims.unit",
"FStar.HyperStack.ST.pop_frame",
"Lib.Buffer.op_Array_Access",
"Lib.Buffer.MUT",
"FStar.UInt32.__uint_to_t",
"Hacl.Impl.Lib.fill_elems4",
"Hacl.Bignum.Definitions.limb",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Hacl.Impl.Lib.lemma_eq_disjoint",
"Lib.Buffer.op_Array_Assignment",
"Hacl.Bignum.Base.addcarry_st",
"Lib.Buffer.lbuffer_t",
"FStar.UInt32.uint_to_t",
"FStar.UInt32.t",
"Lib.Buffer.sub",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"Prims.nat",
"Prims.op_LessThanOrEqual",
"Prims.op_Subtraction",
"Prims.pow2",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.Bignum.Definitions.limb",
"Hacl.Spec.Bignum.Addition.bn_add_f",
"Lib.Buffer.as_seq",
"LowStar.Monotonic.Buffer.loc",
"Prims.l_and",
"LowStar.Monotonic.Buffer.loc_disjoint",
"Lib.Buffer.loc",
"LowStar.Monotonic.Buffer.loc_includes",
"LowStar.Monotonic.Buffer.address_liveness_insensitive_locs",
"Lib.IntTypes.size_nat",
"Prims.eq2",
"FStar.Seq.Base.index",
"Lib.Sequence.to_seq",
"Lib.Sequence.index",
"Lib.Buffer.create",
"Lib.IntTypes.uint",
"Lib.IntTypes.SEC",
"Lib.Buffer.lbuffer",
"FStar.HyperStack.ST.push_frame"
] | [] | false | false | false | false | false | let bn_add_eq_len #t aLen a b res =
| push_frame ();
let c = create 1ul (uint #t 0) in
[@@ inline_let ]let refl h i = LSeq.index (as_seq h c) 0 in
[@@ inline_let ]let footprint (i: size_nat{i <= v aLen})
: GTot
(l: B.loc{B.loc_disjoint l (loc res) /\ B.address_liveness_insensitive_locs `B.loc_includes` l})
=
loc c
in
[@@ inline_let ]let spec h = S.bn_add_f (as_seq h a) (as_seq h b) in
let h0 = ST.get () in
fill_elems4 h0
aLen
res
refl
footprint
spec
(fun i ->
let h1 = ST.get () in
let t1 = a.(i) in
let t2 = b.(i) in
let res_i = sub res i 1ul in
c.(0ul) <- addcarry_st c.(0ul) t1 t2 res_i;
lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1;
lemma_eq_disjoint aLen aLen 1ul res b c i h0 h1);
let res = c.(0ul) in
pop_frame ();
res | false |
Steel.Reference.fst | Steel.Reference.pts_to_injective_eq | val pts_to_injective_eq
(#a: Type)
(#opened:inames)
(#p0 #p1:perm)
(#v0 #v1: erased a)
(r: ref a)
: SteelGhost unit opened
(pts_to r p0 v0 `star` pts_to r p1 v1)
(fun _ -> pts_to r p0 v0 `star` pts_to r p1 v0)
(requires fun _ -> True)
(ensures fun _ _ _ -> v0 == v1) | val pts_to_injective_eq
(#a: Type)
(#opened:inames)
(#p0 #p1:perm)
(#v0 #v1: erased a)
(r: ref a)
: SteelGhost unit opened
(pts_to r p0 v0 `star` pts_to r p1 v1)
(fun _ -> pts_to r p0 v0 `star` pts_to r p1 v0)
(requires fun _ -> True)
(ensures fun _ _ _ -> v0 == v1) | let pts_to_injective_eq #a #opened #p0 #p1 #v0 #v1 r =
extract_info_raw (pts_to r p0 v0 `star` pts_to r p1 v1) (v0 == v1)
(fun m -> pts_to_ref_injective r p0 p1 v0 v1 m);
rewrite_slprop (pts_to r p1 v1) (pts_to r p1 v0) (fun _ -> ()) | {
"file_name": "lib/steel/Steel.Reference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 64,
"end_line": 93,
"start_col": 0,
"start_line": 90
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.Reference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module Mem = Steel.Memory
module H = Steel.HigherReference
module U = FStar.Universe
#set-options "--ide_id_info_off"
let ref a = H.ref (U.raise_t a)
let null #a = H.null #(U.raise_t a)
let is_null #a r = H.is_null #(U.raise_t a) r
let pts_to_sl r p v = H.pts_to_sl r p (U.raise_val v)
val raise_val_inj (#a:Type) (x y:a) : Lemma
(requires U.raise_val x == U.raise_val y)
(ensures x == y)
let raise_val_inj x y =
U.downgrade_val_raise_val x;
U.downgrade_val_raise_val y
let pts_to_ref_injective
(#a: Type u#0)
(r: ref a)
(p0 p1:perm)
(v0 v1:a)
(m:mem)
: Lemma
(requires
interp (pts_to_sl r p0 v0 `Mem.star` pts_to_sl r p1 v1) m)
(ensures v0 == v1)
= let v0' = U.raise_val v0 in
let v1' = U.raise_val v1 in
H.pts_to_ref_injective r p0 p1 v0' v1' m;
raise_val_inj v0 v1
let pts_to_not_null (#a:Type u#0)
(x:ref a)
(p:perm)
(v:a)
(m:mem)
: Lemma (requires interp (pts_to_sl x p v) m)
(ensures x =!= null)
= let v = U.raise_val v in
H.pts_to_not_null #(U.raise_t a) x p v m
// let pts_to_not_null' (#a:Type u#0)
// (x:ref a)
// (p:perm)
// (v: erased a)
// (m:mem)
// (m1:mem{disjoint m m1})
// : Lemma (requires interp (pts_to_sl x p v) m)
// (ensures interp (pts_to_sl x p v) (Mem.join m m1))
// = ()
let pts_to_witinv (#a:Type) (r:ref a) (p:perm) : Lemma (is_witness_invariant (pts_to_sl r p)) =
let aux (x y : a) (m:mem)
: Lemma (requires (interp (pts_to_sl r p x) m /\ interp (pts_to_sl r p y) m))
(ensures (x == y))
= H.pts_to_witinv r p;
raise_val_inj x y
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y)) | {
"checked_file": "/",
"dependencies": [
"Steel.Memory.fsti.checked",
"Steel.HigherReference.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Reference.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "Steel.HigherReference",
"short_module": "H"
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | r: Steel.Reference.ref a -> Steel.Effect.Atomic.SteelGhost Prims.unit | Steel.Effect.Atomic.SteelGhost | [] | [] | [
"Steel.Memory.inames",
"Steel.FractionalPermission.perm",
"FStar.Ghost.erased",
"Steel.Reference.ref",
"Steel.Effect.Atomic.rewrite_slprop",
"Steel.Reference.pts_to",
"FStar.Ghost.reveal",
"Steel.Memory.mem",
"Prims.unit",
"Steel.Effect.Atomic.extract_info_raw",
"Steel.Effect.Common.star",
"Prims.eq2",
"Steel.Reference.pts_to_ref_injective"
] | [] | false | true | false | false | false | let pts_to_injective_eq #a #opened #p0 #p1 #v0 #v1 r =
| extract_info_raw ((pts_to r p0 v0) `star` (pts_to r p1 v1))
(v0 == v1)
(fun m -> pts_to_ref_injective r p0 p1 v0 v1 m);
rewrite_slprop (pts_to r p1 v1) (pts_to r p1 v0) (fun _ -> ()) | false |
Steel.Reference.fst | Steel.Reference.ghost_alloc_pt | val ghost_alloc_pt (#a:Type) (#u:_) (x:erased a)
: SteelGhostT (ghost_ref a) u
emp
(fun r -> ghost_pts_to r full_perm x) | val ghost_alloc_pt (#a:Type) (#u:_) (x:erased a)
: SteelGhostT (ghost_ref a) u
emp
(fun r -> ghost_pts_to r full_perm x) | let ghost_alloc_pt (#a:Type) (#u:_) (x:erased a)
: SteelGhostT (ghost_ref a) u
emp
(fun r -> ghost_pts_to r full_perm x)
= H.ghost_alloc (raise_erased x) | {
"file_name": "lib/steel/Steel.Reference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 34,
"end_line": 398,
"start_col": 0,
"start_line": 394
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.Reference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module Mem = Steel.Memory
module H = Steel.HigherReference
module U = FStar.Universe
#set-options "--ide_id_info_off"
let ref a = H.ref (U.raise_t a)
let null #a = H.null #(U.raise_t a)
let is_null #a r = H.is_null #(U.raise_t a) r
let pts_to_sl r p v = H.pts_to_sl r p (U.raise_val v)
val raise_val_inj (#a:Type) (x y:a) : Lemma
(requires U.raise_val x == U.raise_val y)
(ensures x == y)
let raise_val_inj x y =
U.downgrade_val_raise_val x;
U.downgrade_val_raise_val y
let pts_to_ref_injective
(#a: Type u#0)
(r: ref a)
(p0 p1:perm)
(v0 v1:a)
(m:mem)
: Lemma
(requires
interp (pts_to_sl r p0 v0 `Mem.star` pts_to_sl r p1 v1) m)
(ensures v0 == v1)
= let v0' = U.raise_val v0 in
let v1' = U.raise_val v1 in
H.pts_to_ref_injective r p0 p1 v0' v1' m;
raise_val_inj v0 v1
let pts_to_not_null (#a:Type u#0)
(x:ref a)
(p:perm)
(v:a)
(m:mem)
: Lemma (requires interp (pts_to_sl x p v) m)
(ensures x =!= null)
= let v = U.raise_val v in
H.pts_to_not_null #(U.raise_t a) x p v m
// let pts_to_not_null' (#a:Type u#0)
// (x:ref a)
// (p:perm)
// (v: erased a)
// (m:mem)
// (m1:mem{disjoint m m1})
// : Lemma (requires interp (pts_to_sl x p v) m)
// (ensures interp (pts_to_sl x p v) (Mem.join m m1))
// = ()
let pts_to_witinv (#a:Type) (r:ref a) (p:perm) : Lemma (is_witness_invariant (pts_to_sl r p)) =
let aux (x y : a) (m:mem)
: Lemma (requires (interp (pts_to_sl r p x) m /\ interp (pts_to_sl r p y) m))
(ensures (x == y))
= H.pts_to_witinv r p;
raise_val_inj x y
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
let pts_to_injective_eq #a #opened #p0 #p1 #v0 #v1 r =
extract_info_raw (pts_to r p0 v0 `star` pts_to r p1 v1) (v0 == v1)
(fun m -> pts_to_ref_injective r p0 p1 v0 v1 m);
rewrite_slprop (pts_to r p1 v1) (pts_to r p1 v0) (fun _ -> ())
let pts_to_perm
r
= H.pts_to_perm r
let alloc_pt x =
let r = H.alloc (U.raise_val x) in
rewrite_slprop (H.pts_to r full_perm (U.raise_val x)) (pts_to r full_perm x) (fun _ -> ());
return r
let read_pt #a #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
let x = H.read r in
let v':a = U.downgrade_val x in
rewrite_slprop (H.pts_to r p (hide x)) (pts_to r p v') (fun _ -> ());
return v'
let read_refine_pt #a #p q r =
Classical.forall_intro_2 reveal_equiv;
lift_exists (fun (v:a) -> pts_to r p v `star` q v);
exists_cong (fun (v:U.raise_t a) -> pts_to r p (U.downgrade_val v) `star` q (U.downgrade_val v))
(fun (v:U.raise_t a) -> H.pts_to r p v `star` U.lift_dom q v);
let x = H.read_refine (U.lift_dom q) r in
rewrite_slprop
(H.pts_to r p (hide x) `star` U.lift_dom q x)
(pts_to r p (U.downgrade_val x) `star` q (U.downgrade_val x)) (fun _ -> ());
return (U.downgrade_val x)
let write_pt #a #v r x =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
let x' = U.raise_val x in
H.write r x';
rewrite_slprop (H.pts_to r full_perm (hide x')) (pts_to r full_perm x) (fun _ -> ())
let free_pt #a #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
H.free r
let share_gen_pt #a #uses #p #v r p1 p2 =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
H.share_gen r p1 p2;
rewrite_slprop (H.pts_to r p1 v') (pts_to r p1 v) (fun _ -> ());
rewrite_slprop (H.pts_to r p2 v') (pts_to r p2 v) (fun _ -> ())
let share_pt #a #uses #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
H.share r;
rewrite_slprop (H.pts_to r (half_perm p) v') (pts_to r (half_perm p) v) (fun _ -> ());
rewrite_slprop (H.pts_to r (half_perm p) v') (pts_to r (half_perm p) v) (fun _ -> ())
let hide_raise_reveal (#a:Type) (v0:erased a) (v1:erased a)
: Lemma (hide (U.raise_val (reveal v0)) == hide (U.raise_val (reveal v1)) <==>
v0 == v1)
[SMTPat (hide (U.raise_val (reveal v0)));
SMTPat (hide (U.raise_val (reveal v1)))]
= let u0 = hide (U.raise_val (reveal v0)) in
let u1 = hide (U.raise_val (reveal v1)) in
assert (U.downgrade_val (U.raise_val (reveal v0)) == U.downgrade_val (U.raise_val (reveal v1)) <==>
v0 == v1)
let gather_pt #a #uses #p0 #p1 #v0 #v1 r =
let v0' = Ghost.hide (U.raise_val (Ghost.reveal v0)) in
let v1' = Ghost.hide (U.raise_val (Ghost.reveal v1)) in
rewrite_slprop (pts_to r p0 v0) (H.pts_to r p0 v0') (fun _ -> ());
rewrite_slprop (pts_to r p1 v1) (H.pts_to r p1 v1') (fun _ -> ());
let (u:unit{v0' == v1'}) = H.gather #_ #_ #p0 #p1 #v0' #v1' r in
rewrite_slprop (H.pts_to r (sum_perm p0 p1) v0') (pts_to r (sum_perm p0 p1) v0) (fun _ -> ());
u
let raise_equiv (#t:Type) (x y:t)
: Lemma (U.raise_val x == U.raise_val y <==>
x == y)
= assert (U.downgrade_val (U.raise_val x) == x);
assert (U.downgrade_val (U.raise_val y) == y)
let downgrade_equiv (#t:Type) (x y:U.raise_t t)
: Lemma (U.downgrade_val x == U.downgrade_val y <==>
x == y)
= assert (U.raise_val (U.downgrade_val x) == x);
assert (U.raise_val (U.downgrade_val y) == y)
let lift_eq (#t:eqtype) (x y:U.raise_t t)
: b:bool{b <==> x==y}
= downgrade_equiv x y; U.downgrade_val x = U.downgrade_val y
let cas_action (#t:eqtype)
(#uses:inames)
(r:ref t)
(v:Ghost.erased t)
(v_old:t)
(v_new:t)
(frame:slprop)
: MstTot (b:bool{b <==> (Ghost.reveal v == v_old)})
uses
(pts_to_sl r full_perm v)
(fun b -> if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v)
frame
(fun _ -> True)
(fun _ _ _ -> True)
= let hv = (Ghost.hide (U.raise_val (Ghost.reveal v))) in
let b = H.cas_action #(U.raise_t t)
(lift_eq #t)
#uses
r
hv
(U.raise_val v_old)
(U.raise_val v_new)
frame
in
assert (b <==> (Ghost.reveal hv == U.raise_val v_old));
assert (b <==> U.raise_val (Ghost.reveal v) == U.raise_val v_old);
raise_equiv (Ghost.reveal v) v_old;
b
let atomic_read_pt_u32 #_ #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
let x = H.atomic_read r in
let v':U32.t = U.downgrade_val x in
rewrite_slprop (H.pts_to r p (hide x)) (pts_to r p v') (fun _ -> ());
return v'
let atomic_write_pt_u32 #_ #v r x =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
let x' = U.raise_val x in
H.atomic_write r x';
rewrite_slprop (H.pts_to r full_perm (hide x')) (pts_to r full_perm x) (fun _ -> ())
let cas_pt_u32 #uses r v v_old v_new =
let b = as_atomic_action (cas_action #U32.t #uses r v v_old v_new) in
rewrite_slprop (to_vprop (if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v))
(if b then pts_to r full_perm v_new else pts_to r full_perm v)
(fun _ -> ());
return b
let cas_pt_bool #uses r v v_old v_new =
let b = as_atomic_action (cas_action #bool #uses r v v_old v_new) in
rewrite_slprop (to_vprop (if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v))
(if b then pts_to r full_perm v_new else pts_to r full_perm v)
(fun _ -> ());
return b
(* Library for references with fractional permissions.
Permissions need to be an index of the vprop ptr.
It cannot be part of a selector, as it is not invariant when joining with a disjoint memory
Using the value of the ref as a selector is ok because refs with fractional permissions
all share the same value.
Refs on PCM are more complicated, and likely not usable with selectors
*)
let ptrp r p = Mem.h_exists (pts_to_sl r p)
val ptr_sel' (#a:Type0) (r: ref a) (p: perm) : selector' a (ptrp r p)
let ptr_sel' #a r p = fun h -> id_elim_exists #a (pts_to_sl r p) h
let ptr_sel_depends_only_on (#a:Type0) (r:ref a)
(p: perm)
(m0:Mem.hmem (ptrp r p)) (m1:mem{disjoint m0 m1})
: Lemma (ptr_sel' r p m0 == ptr_sel' r p (Mem.join m0 m1))
= let x = reveal (id_elim_exists #a (pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (pts_to_sl r p) (Mem.join m0 m1)) in
pts_to_witinv r p;
elim_wi (pts_to_sl r p) x y (Mem.join m0 m1)
let ptr_sel_depends_only_on_core (#a:Type0) (r:ref a)
(p: perm) (m0:Mem.hmem (ptrp r p))
: Lemma (ptr_sel' r p m0 == ptr_sel' r p (core_mem m0))
= let x = reveal (id_elim_exists #a (pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (pts_to_sl r p) (core_mem m0)) in
pts_to_witinv r p;
elim_wi (pts_to_sl r p) x y (core_mem m0)
let ptrp_sel r p =
Classical.forall_intro_2 (ptr_sel_depends_only_on r p);
Classical.forall_intro (ptr_sel_depends_only_on_core r p);
ptr_sel' r p
let ptrp_sel_interp #a r p m = pts_to_witinv r p
let intro_ptrp_interp r p v m = intro_h_exists (reveal v) (pts_to_sl r p) m
let intro_vptr_lemma (#a:Type) (r:ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (pts_to_sl r p v) m)
(ensures interp (ptrp r p) m /\ ptrp_sel r p m == reveal v)
= Mem.intro_h_exists (reveal v) (pts_to_sl r p) m;
pts_to_witinv r p
let elim_vptr_lemma (#a:Type) (r:ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (ptrp r p) m /\ ptrp_sel r p m == reveal v)
(ensures interp (pts_to_sl r p v) m)
= Mem.elim_h_exists (pts_to_sl r p) m;
pts_to_witinv r p
let intro_vptr (#a:Type) (#opened:inames) (r:ref a) (p: perm) (v:erased a)
: SteelGhost unit opened (pts_to r p v) (fun _ -> vptrp r p)
(requires fun _ -> True)
(ensures fun _ _ h1 -> h1 (vptrp r p) == reveal v)
= change_slprop_2 (pts_to r p v) (vptrp r p) v (intro_vptr_lemma r p v)
let elim_vptr (#a:Type) (#opened:inames) (r:ref a) (p: perm)
: SteelGhost (erased a) opened (vptrp r p) (fun v -> pts_to r p v)
(requires fun _ -> True)
(ensures fun h0 v _ -> reveal v == h0 (vptrp r p))
= let v = gget (vptrp r p) in
change_slprop (vptrp r p) (pts_to r p v) v () (elim_vptr_lemma r p v);
v
let malloc x =
let r = alloc_pt x in
intro_vptr r _ (hide x);
return r
let free r =
let _ = elim_vptr r _ in
free_pt r
let readp r _ =
let _ = elim_vptr r _ in
let x = read_pt r in
intro_vptr r _ x;
return x
let write r x =
let _ = elim_vptr r _ in
write_pt r x;
intro_vptr r _ x
let share #a #_ #p r =
let x = elim_vptr r p in
share_pt r;
intro_vptr r _ x;
intro_vptr r _ x
let gather_gen #a #_ r p0 p1 =
let x1 = elim_vptr r p1 in
let x0 = elim_vptr r p0 in
gather_pt #_ #_ #p0 #p1 #x0 #x1 r;
intro_vptr r (sum_perm p0 p1) x0;
sum_perm p0 p1
let gather (#a: Type0) (#uses: _) (#p: perm) (r: ref a)
: SteelGhost unit uses
(vptrp r (half_perm p) `star` vptrp r (half_perm p))
(fun _ -> vptrp r p)
(fun _ -> True)
(fun h _ h' ->
h' (vptrp r p) == h (vptrp r (half_perm p))
)
= let _ = gather_gen r _ _ in
change_equal_slprop
(vptrp r _)
(vptrp r p)
(*** Lemmas on references *)
let vptrp_not_null
#opened #a r
p
= change_slprop_rel
(vptrp r p)
(vptrp r p)
(fun x y -> x == y /\ is_null r == false)
(fun m -> pts_to_not_null r p (ptrp_sel r p m) m)
(*** Ghost pointers *)
(*** GHOST REFERENCES ***)
let ghost_ref a = H.ghost_ref (U.raise_t a)
let dummy_ghost_ref a =
H.reveal_ghost_ref (U.raise_t a);
coerce_eq () (Ghost.hide (H.null #(U.raise_t a)))
[@__reduce__]
let ghost_pts_to_sl #a r p x = H.ghost_pts_to_sl #(U.raise_t a) r p (U.raise_val x)
let ghost_pts_to_witinv (#a:Type) (r:ghost_ref a) (p:perm) : Lemma (is_witness_invariant (ghost_pts_to_sl r p)) =
let aux (x y : a) (m:mem)
: Lemma (requires (interp (ghost_pts_to_sl r p x) m /\ interp (ghost_pts_to_sl r p y) m))
(ensures (x == y))
= H.ghost_pts_to_witinv r p;
raise_val_inj x y
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
[@@__reduce__]
let raise_erased (#a:Type0) (x:erased a)
: erased (U.raise_t u#0 u#1 a)
= Ghost.hide (U.raise_val (Ghost.reveal x)) | {
"checked_file": "/",
"dependencies": [
"Steel.Memory.fsti.checked",
"Steel.HigherReference.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Reference.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "Steel.HigherReference",
"short_module": "H"
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | x: FStar.Ghost.erased a -> Steel.Effect.Atomic.SteelGhostT (Steel.Reference.ghost_ref a) | Steel.Effect.Atomic.SteelGhostT | [] | [] | [
"Steel.Memory.inames",
"FStar.Ghost.erased",
"Steel.HigherReference.ghost_alloc",
"FStar.Universe.raise_t",
"Steel.Reference.raise_erased",
"Steel.HigherReference.ghost_ref",
"Steel.Reference.ghost_ref",
"Steel.Effect.Common.emp",
"Steel.Reference.ghost_pts_to",
"Steel.FractionalPermission.full_perm",
"FStar.Ghost.reveal",
"Steel.Effect.Common.vprop"
] | [] | false | true | false | false | false | let ghost_alloc_pt (#a: Type) (#u: _) (x: erased a)
: SteelGhostT (ghost_ref a) u emp (fun r -> ghost_pts_to r full_perm x) =
| H.ghost_alloc (raise_erased x) | false |
Hacl.Bignum.Addition.fst | Hacl.Bignum.Addition.bn_add | val bn_add:
#t:limb_t
-> aLen:size_t
-> a:lbignum t aLen
-> bLen:size_t{v bLen <= v aLen}
-> b:lbignum t bLen
-> res:lbignum t aLen ->
Stack (carry t)
(requires fun h ->
live h a /\ live h b /\ live h res /\
disjoint a b /\ eq_or_disjoint a res /\ disjoint b res)
(ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\
(let c, r = S.bn_add (as_seq h0 a) (as_seq h0 b) in
c_out == c /\ as_seq h1 res == r)) | val bn_add:
#t:limb_t
-> aLen:size_t
-> a:lbignum t aLen
-> bLen:size_t{v bLen <= v aLen}
-> b:lbignum t bLen
-> res:lbignum t aLen ->
Stack (carry t)
(requires fun h ->
live h a /\ live h b /\ live h res /\
disjoint a b /\ eq_or_disjoint a res /\ disjoint b res)
(ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\
(let c, r = S.bn_add (as_seq h0 a) (as_seq h0 b) in
c_out == c /\ as_seq h1 res == r)) | let bn_add #t aLen a bLen b res =
let h0 = ST.get () in
let a0 = sub a 0ul bLen in
let res0 = sub res 0ul bLen in
let c0 = bn_add_eq_len bLen a0 b res0 in
let h1 = ST.get () in
if bLen <. aLen then begin
[@inline_let] let rLen = aLen -! bLen in
let a1 = sub a bLen rLen in
let res1 = sub res bLen rLen in
let c1 = bn_add_carry rLen a1 c0 res1 in
let h2 = ST.get () in
LSeq.lemma_concat2 (v bLen) (as_seq h1 res0) (v rLen) (as_seq h2 res1) (as_seq h2 res);
c1 end
else c0 | {
"file_name": "code/bignum/Hacl.Bignum.Addition.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 9,
"end_line": 301,
"start_col": 0,
"start_line": 287
} | module Hacl.Bignum.Addition
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Hacl.Bignum.Definitions
open Hacl.Bignum.Base
open Hacl.Impl.Lib
open Lib.IntTypes
open Lib.Buffer
module ST = FStar.HyperStack.ST
module B = LowStar.Buffer
module S = Hacl.Spec.Bignum.Addition
module LSeq = Lib.Sequence
module SL = Hacl.Spec.Lib
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val bn_sub_carry:
#t:limb_t
-> aLen:size_t
-> a:lbignum t aLen
-> c_in:carry t
-> res:lbignum t aLen ->
Stack (carry t)
(requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res)
(ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\
(let c, r = S.bn_sub_carry (as_seq h0 a) c_in in
c_out == c /\ as_seq h1 res == r))
let bn_sub_carry #t aLen a c_in res =
push_frame ();
let c = create 1ul c_in in
[@inline_let]
let refl h i = LSeq.index (as_seq h c) 0 in
[@inline_let]
let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\
B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in
[@inline_let]
let spec h = S.bn_sub_carry_f (as_seq h a) in
let h0 = ST.get () in
fill_elems4 h0 aLen res refl footprint spec
(fun i ->
let h1 = ST.get () in
let t1 = a.(i) in
let res_i = sub res i 1ul in
c.(0ul) <- subborrow_st c.(0ul) t1 (uint #t 0) res_i;
lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1
);
let res = c.(0ul) in
pop_frame ();
res
inline_for_extraction noextract
let bn_sub_eq_len_st (t:limb_t) (aLen:size_t) =
a:lbignum t aLen
-> b:lbignum t aLen
-> res:lbignum t aLen ->
Stack (carry t)
(requires fun h ->
live h a /\ live h b /\ live h res /\
eq_or_disjoint a b /\ eq_or_disjoint a res /\ eq_or_disjoint b res)
(ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\
(let c, r = SL.generate_elems (v aLen) (v aLen) (S.bn_sub_f (as_seq h0 a) (as_seq h0 b)) (uint #t 0) in
c_out == c /\ as_seq h1 res == r))
inline_for_extraction noextract
val bn_sub_eq_len: #t:limb_t -> aLen:size_t -> bn_sub_eq_len_st t aLen
let bn_sub_eq_len #t aLen a b res =
push_frame ();
let c = create 1ul (uint #t 0) in
[@inline_let]
let refl h i = LSeq.index (as_seq h c) 0 in
[@inline_let]
let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\
B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in
[@inline_let]
let spec h = S.bn_sub_f (as_seq h a) (as_seq h b) in
let h0 = ST.get () in
fill_elems4 h0 aLen res refl footprint spec
(fun i ->
let h1 = ST.get () in
let t1 = a.(i) in
let t2 = b.(i) in
let res_i = sub res i 1ul in
c.(0ul) <- subborrow_st c.(0ul) t1 t2 res_i;
lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1;
lemma_eq_disjoint aLen aLen 1ul res b c i h0 h1
);
let res = c.(0ul) in
pop_frame ();
res
let bn_sub_eq_len_u32 (aLen:size_t) : bn_sub_eq_len_st U32 aLen = bn_sub_eq_len aLen
let bn_sub_eq_len_u64 (aLen:size_t) : bn_sub_eq_len_st U64 aLen = bn_sub_eq_len aLen
inline_for_extraction noextract
let bn_sub_eq_len_u (#t:limb_t) (aLen:size_t) : bn_sub_eq_len_st t aLen =
match t with
| U32 -> bn_sub_eq_len_u32 aLen
| U64 -> bn_sub_eq_len_u64 aLen
inline_for_extraction noextract
val bn_sub:
#t:limb_t
-> aLen:size_t
-> a:lbignum t aLen
-> bLen:size_t{v bLen <= v aLen}
-> b:lbignum t bLen
-> res:lbignum t aLen ->
Stack (carry t)
(requires fun h ->
live h a /\ live h b /\ live h res /\
disjoint a b /\ eq_or_disjoint a res /\ disjoint b res)
(ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\
(let c, r = S.bn_sub (as_seq h0 a) (as_seq h0 b) in
c_out == c /\ as_seq h1 res == r))
let bn_sub #t aLen a bLen b res =
let h0 = ST.get () in
let a0 = sub a 0ul bLen in
let res0 = sub res 0ul bLen in
let h1 = ST.get () in
let c0 = bn_sub_eq_len bLen a0 b res0 in
let h1 = ST.get () in
if bLen <. aLen then begin
[@inline_let] let rLen = aLen -! bLen in
let a1 = sub a bLen rLen in
let res1 = sub res bLen rLen in
let c1 = bn_sub_carry rLen a1 c0 res1 in
let h2 = ST.get () in
LSeq.lemma_concat2 (v bLen) (as_seq h1 res0) (v rLen) (as_seq h2 res1) (as_seq h2 res);
c1 end
else c0
inline_for_extraction noextract
val bn_sub1:
#t:limb_t
-> aLen:size_t{0 < v aLen}
-> a:lbignum t aLen
-> b1:limb t
-> res:lbignum t aLen ->
Stack (carry t)
(requires fun h ->
live h a /\ live h res /\ eq_or_disjoint a res)
(ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\
(let c, r = S.bn_sub1 (as_seq h0 a) b1 in
c_out == c /\ as_seq h1 res == r))
let bn_sub1 #t aLen a b1 res =
let c0 = subborrow_st (uint #t 0) a.(0ul) b1 (sub res 0ul 1ul) in
let h0 = ST.get () in
LSeq.eq_intro (LSeq.sub (as_seq h0 res) 0 1) (LSeq.create 1 (LSeq.index (as_seq h0 res) 0));
if 1ul <. aLen then begin
[@inline_let] let rLen = aLen -! 1ul in
let a1 = sub a 1ul rLen in
let res1 = sub res 1ul rLen in
let c1 = bn_sub_carry rLen a1 c0 res1 in
let h = ST.get () in
LSeq.lemma_concat2 1 (LSeq.sub (as_seq h0 res) 0 1) (v rLen) (as_seq h res1) (as_seq h res);
c1 end
else c0
inline_for_extraction noextract
val bn_add_carry:
#t:limb_t
-> aLen:size_t
-> a:lbignum t aLen
-> c_in:carry t
-> res:lbignum t aLen ->
Stack (carry t)
(requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res)
(ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\
(let c, r = S.bn_add_carry (as_seq h0 a) c_in in
c_out == c /\ as_seq h1 res == r))
let bn_add_carry #t aLen a c_in res =
push_frame ();
let c = create 1ul c_in in
[@inline_let]
let refl h i = LSeq.index (as_seq h c) 0 in
[@inline_let]
let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\
B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in
[@inline_let]
let spec h = S.bn_add_carry_f (as_seq h a) in
let h0 = ST.get () in
fill_elems4 h0 aLen res refl footprint spec
(fun i ->
let h1 = ST.get () in
let t1 = a.(i) in
let res_i = sub res i 1ul in
c.(0ul) <- addcarry_st c.(0ul) t1 (uint #t 0) res_i;
lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1
);
let res = c.(0ul) in
pop_frame ();
res
inline_for_extraction noextract
let bn_add_eq_len_st (t:limb_t) (aLen:size_t) =
a:lbignum t aLen
-> b:lbignum t aLen
-> res:lbignum t aLen ->
Stack (carry t)
(requires fun h ->
live h a /\ live h b /\ live h res /\
eq_or_disjoint a b /\ eq_or_disjoint a res /\ eq_or_disjoint b res)
(ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\
(let c, r = SL.generate_elems (v aLen) (v aLen) (S.bn_add_f (as_seq h0 a) (as_seq h0 b)) (uint #t 0) in
c_out == c /\ as_seq h1 res == r))
inline_for_extraction noextract
val bn_add_eq_len: #t:limb_t -> aLen:size_t -> bn_add_eq_len_st t aLen
let bn_add_eq_len #t aLen a b res =
push_frame ();
let c = create 1ul (uint #t 0) in
[@inline_let]
let refl h i = LSeq.index (as_seq h c) 0 in
[@inline_let]
let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\
B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in
[@inline_let]
let spec h = S.bn_add_f (as_seq h a) (as_seq h b) in
let h0 = ST.get () in
fill_elems4 h0 aLen res refl footprint spec
(fun i ->
let h1 = ST.get () in
let t1 = a.(i) in
let t2 = b.(i) in
let res_i = sub res i 1ul in
c.(0ul) <- addcarry_st c.(0ul) t1 t2 res_i;
lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1;
lemma_eq_disjoint aLen aLen 1ul res b c i h0 h1
);
let res = c.(0ul) in
pop_frame ();
res
let bn_add_eq_len_u32 (aLen:size_t) : bn_add_eq_len_st U32 aLen = bn_add_eq_len aLen
let bn_add_eq_len_u64 (aLen:size_t) : bn_add_eq_len_st U64 aLen = bn_add_eq_len aLen
inline_for_extraction noextract
let bn_add_eq_len_u (#t:limb_t) (aLen:size_t) : bn_add_eq_len_st t aLen =
match t with
| U32 -> bn_add_eq_len_u32 aLen
| U64 -> bn_add_eq_len_u64 aLen
inline_for_extraction noextract
val bn_add:
#t:limb_t
-> aLen:size_t
-> a:lbignum t aLen
-> bLen:size_t{v bLen <= v aLen}
-> b:lbignum t bLen
-> res:lbignum t aLen ->
Stack (carry t)
(requires fun h ->
live h a /\ live h b /\ live h res /\
disjoint a b /\ eq_or_disjoint a res /\ disjoint b res)
(ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\
(let c, r = S.bn_add (as_seq h0 a) (as_seq h0 b) in
c_out == c /\ as_seq h1 res == r)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Addition.fst.checked",
"Hacl.Impl.Lib.fst.checked",
"Hacl.Bignum.Definitions.fst.checked",
"Hacl.Bignum.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Bignum.Addition.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Lib",
"short_module": "SL"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Addition",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
aLen: Lib.IntTypes.size_t ->
a: Hacl.Bignum.Definitions.lbignum t aLen ->
bLen: Lib.IntTypes.size_t{Lib.IntTypes.v bLen <= Lib.IntTypes.v aLen} ->
b: Hacl.Bignum.Definitions.lbignum t bLen ->
res: Hacl.Bignum.Definitions.lbignum t aLen
-> FStar.HyperStack.ST.Stack (Hacl.Spec.Bignum.Base.carry t) | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_t",
"Hacl.Bignum.Definitions.lbignum",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Lib.IntTypes.op_Less_Dot",
"Prims.unit",
"Lib.Sequence.lemma_concat2",
"Hacl.Bignum.Definitions.limb",
"Lib.Buffer.as_seq",
"Lib.Buffer.MUT",
"Hacl.Spec.Bignum.Base.carry",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"Hacl.Bignum.Addition.bn_add_carry",
"Lib.Buffer.lbuffer_t",
"Lib.Buffer.sub",
"Lib.IntTypes.int_t",
"Lib.IntTypes.op_Subtraction_Bang",
"Prims.bool",
"Hacl.Bignum.Addition.bn_add_eq_len",
"FStar.UInt32.__uint_to_t"
] | [] | false | true | false | false | false | let bn_add #t aLen a bLen b res =
| let h0 = ST.get () in
let a0 = sub a 0ul bLen in
let res0 = sub res 0ul bLen in
let c0 = bn_add_eq_len bLen a0 b res0 in
let h1 = ST.get () in
if bLen <. aLen
then
[@@ inline_let ]let rLen = aLen -! bLen in
let a1 = sub a bLen rLen in
let res1 = sub res bLen rLen in
let c1 = bn_add_carry rLen a1 c0 res1 in
let h2 = ST.get () in
LSeq.lemma_concat2 (v bLen) (as_seq h1 res0) (v rLen) (as_seq h2 res1) (as_seq h2 res);
c1
else c0 | false |
Hacl.Bignum.Addition.fst | Hacl.Bignum.Addition.bn_add1 | val bn_add1:
#t:limb_t
-> aLen:size_t{0 < v aLen}
-> a:lbignum t aLen
-> b1:limb t
-> res:lbignum t aLen ->
Stack (carry t)
(requires fun h ->
live h a /\ live h res /\ eq_or_disjoint a res)
(ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\
(let c, r = S.bn_add1 (as_seq h0 a) b1 in
c_out == c /\ as_seq h1 res == r)) | val bn_add1:
#t:limb_t
-> aLen:size_t{0 < v aLen}
-> a:lbignum t aLen
-> b1:limb t
-> res:lbignum t aLen ->
Stack (carry t)
(requires fun h ->
live h a /\ live h res /\ eq_or_disjoint a res)
(ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\
(let c, r = S.bn_add1 (as_seq h0 a) b1 in
c_out == c /\ as_seq h1 res == r)) | let bn_add1 #t aLen a b1 res =
let c0 = addcarry_st (uint #t 0) a.(0ul) b1 (sub res 0ul 1ul) in
let h0 = ST.get () in
LSeq.eq_intro (LSeq.sub (as_seq h0 res) 0 1) (LSeq.create 1 (LSeq.index (as_seq h0 res) 0));
if 1ul <. aLen then begin
[@inline_let] let rLen = aLen -! 1ul in
let a1 = sub a 1ul rLen in
let res1 = sub res 1ul rLen in
let c1 = bn_add_carry rLen a1 c0 res1 in
let h = ST.get () in
LSeq.lemma_concat2 1 (LSeq.sub (as_seq h0 res) 0 1) (v rLen) (as_seq h res1) (as_seq h res);
c1 end
else c0 | {
"file_name": "code/bignum/Hacl.Bignum.Addition.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 9,
"end_line": 331,
"start_col": 0,
"start_line": 318
} | module Hacl.Bignum.Addition
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Hacl.Bignum.Definitions
open Hacl.Bignum.Base
open Hacl.Impl.Lib
open Lib.IntTypes
open Lib.Buffer
module ST = FStar.HyperStack.ST
module B = LowStar.Buffer
module S = Hacl.Spec.Bignum.Addition
module LSeq = Lib.Sequence
module SL = Hacl.Spec.Lib
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val bn_sub_carry:
#t:limb_t
-> aLen:size_t
-> a:lbignum t aLen
-> c_in:carry t
-> res:lbignum t aLen ->
Stack (carry t)
(requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res)
(ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\
(let c, r = S.bn_sub_carry (as_seq h0 a) c_in in
c_out == c /\ as_seq h1 res == r))
let bn_sub_carry #t aLen a c_in res =
push_frame ();
let c = create 1ul c_in in
[@inline_let]
let refl h i = LSeq.index (as_seq h c) 0 in
[@inline_let]
let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\
B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in
[@inline_let]
let spec h = S.bn_sub_carry_f (as_seq h a) in
let h0 = ST.get () in
fill_elems4 h0 aLen res refl footprint spec
(fun i ->
let h1 = ST.get () in
let t1 = a.(i) in
let res_i = sub res i 1ul in
c.(0ul) <- subborrow_st c.(0ul) t1 (uint #t 0) res_i;
lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1
);
let res = c.(0ul) in
pop_frame ();
res
inline_for_extraction noextract
let bn_sub_eq_len_st (t:limb_t) (aLen:size_t) =
a:lbignum t aLen
-> b:lbignum t aLen
-> res:lbignum t aLen ->
Stack (carry t)
(requires fun h ->
live h a /\ live h b /\ live h res /\
eq_or_disjoint a b /\ eq_or_disjoint a res /\ eq_or_disjoint b res)
(ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\
(let c, r = SL.generate_elems (v aLen) (v aLen) (S.bn_sub_f (as_seq h0 a) (as_seq h0 b)) (uint #t 0) in
c_out == c /\ as_seq h1 res == r))
inline_for_extraction noextract
val bn_sub_eq_len: #t:limb_t -> aLen:size_t -> bn_sub_eq_len_st t aLen
let bn_sub_eq_len #t aLen a b res =
push_frame ();
let c = create 1ul (uint #t 0) in
[@inline_let]
let refl h i = LSeq.index (as_seq h c) 0 in
[@inline_let]
let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\
B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in
[@inline_let]
let spec h = S.bn_sub_f (as_seq h a) (as_seq h b) in
let h0 = ST.get () in
fill_elems4 h0 aLen res refl footprint spec
(fun i ->
let h1 = ST.get () in
let t1 = a.(i) in
let t2 = b.(i) in
let res_i = sub res i 1ul in
c.(0ul) <- subborrow_st c.(0ul) t1 t2 res_i;
lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1;
lemma_eq_disjoint aLen aLen 1ul res b c i h0 h1
);
let res = c.(0ul) in
pop_frame ();
res
let bn_sub_eq_len_u32 (aLen:size_t) : bn_sub_eq_len_st U32 aLen = bn_sub_eq_len aLen
let bn_sub_eq_len_u64 (aLen:size_t) : bn_sub_eq_len_st U64 aLen = bn_sub_eq_len aLen
inline_for_extraction noextract
let bn_sub_eq_len_u (#t:limb_t) (aLen:size_t) : bn_sub_eq_len_st t aLen =
match t with
| U32 -> bn_sub_eq_len_u32 aLen
| U64 -> bn_sub_eq_len_u64 aLen
inline_for_extraction noextract
val bn_sub:
#t:limb_t
-> aLen:size_t
-> a:lbignum t aLen
-> bLen:size_t{v bLen <= v aLen}
-> b:lbignum t bLen
-> res:lbignum t aLen ->
Stack (carry t)
(requires fun h ->
live h a /\ live h b /\ live h res /\
disjoint a b /\ eq_or_disjoint a res /\ disjoint b res)
(ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\
(let c, r = S.bn_sub (as_seq h0 a) (as_seq h0 b) in
c_out == c /\ as_seq h1 res == r))
let bn_sub #t aLen a bLen b res =
let h0 = ST.get () in
let a0 = sub a 0ul bLen in
let res0 = sub res 0ul bLen in
let h1 = ST.get () in
let c0 = bn_sub_eq_len bLen a0 b res0 in
let h1 = ST.get () in
if bLen <. aLen then begin
[@inline_let] let rLen = aLen -! bLen in
let a1 = sub a bLen rLen in
let res1 = sub res bLen rLen in
let c1 = bn_sub_carry rLen a1 c0 res1 in
let h2 = ST.get () in
LSeq.lemma_concat2 (v bLen) (as_seq h1 res0) (v rLen) (as_seq h2 res1) (as_seq h2 res);
c1 end
else c0
inline_for_extraction noextract
val bn_sub1:
#t:limb_t
-> aLen:size_t{0 < v aLen}
-> a:lbignum t aLen
-> b1:limb t
-> res:lbignum t aLen ->
Stack (carry t)
(requires fun h ->
live h a /\ live h res /\ eq_or_disjoint a res)
(ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\
(let c, r = S.bn_sub1 (as_seq h0 a) b1 in
c_out == c /\ as_seq h1 res == r))
let bn_sub1 #t aLen a b1 res =
let c0 = subborrow_st (uint #t 0) a.(0ul) b1 (sub res 0ul 1ul) in
let h0 = ST.get () in
LSeq.eq_intro (LSeq.sub (as_seq h0 res) 0 1) (LSeq.create 1 (LSeq.index (as_seq h0 res) 0));
if 1ul <. aLen then begin
[@inline_let] let rLen = aLen -! 1ul in
let a1 = sub a 1ul rLen in
let res1 = sub res 1ul rLen in
let c1 = bn_sub_carry rLen a1 c0 res1 in
let h = ST.get () in
LSeq.lemma_concat2 1 (LSeq.sub (as_seq h0 res) 0 1) (v rLen) (as_seq h res1) (as_seq h res);
c1 end
else c0
inline_for_extraction noextract
val bn_add_carry:
#t:limb_t
-> aLen:size_t
-> a:lbignum t aLen
-> c_in:carry t
-> res:lbignum t aLen ->
Stack (carry t)
(requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res)
(ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\
(let c, r = S.bn_add_carry (as_seq h0 a) c_in in
c_out == c /\ as_seq h1 res == r))
let bn_add_carry #t aLen a c_in res =
push_frame ();
let c = create 1ul c_in in
[@inline_let]
let refl h i = LSeq.index (as_seq h c) 0 in
[@inline_let]
let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\
B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in
[@inline_let]
let spec h = S.bn_add_carry_f (as_seq h a) in
let h0 = ST.get () in
fill_elems4 h0 aLen res refl footprint spec
(fun i ->
let h1 = ST.get () in
let t1 = a.(i) in
let res_i = sub res i 1ul in
c.(0ul) <- addcarry_st c.(0ul) t1 (uint #t 0) res_i;
lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1
);
let res = c.(0ul) in
pop_frame ();
res
inline_for_extraction noextract
let bn_add_eq_len_st (t:limb_t) (aLen:size_t) =
a:lbignum t aLen
-> b:lbignum t aLen
-> res:lbignum t aLen ->
Stack (carry t)
(requires fun h ->
live h a /\ live h b /\ live h res /\
eq_or_disjoint a b /\ eq_or_disjoint a res /\ eq_or_disjoint b res)
(ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\
(let c, r = SL.generate_elems (v aLen) (v aLen) (S.bn_add_f (as_seq h0 a) (as_seq h0 b)) (uint #t 0) in
c_out == c /\ as_seq h1 res == r))
inline_for_extraction noextract
val bn_add_eq_len: #t:limb_t -> aLen:size_t -> bn_add_eq_len_st t aLen
let bn_add_eq_len #t aLen a b res =
push_frame ();
let c = create 1ul (uint #t 0) in
[@inline_let]
let refl h i = LSeq.index (as_seq h c) 0 in
[@inline_let]
let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\
B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in
[@inline_let]
let spec h = S.bn_add_f (as_seq h a) (as_seq h b) in
let h0 = ST.get () in
fill_elems4 h0 aLen res refl footprint spec
(fun i ->
let h1 = ST.get () in
let t1 = a.(i) in
let t2 = b.(i) in
let res_i = sub res i 1ul in
c.(0ul) <- addcarry_st c.(0ul) t1 t2 res_i;
lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1;
lemma_eq_disjoint aLen aLen 1ul res b c i h0 h1
);
let res = c.(0ul) in
pop_frame ();
res
let bn_add_eq_len_u32 (aLen:size_t) : bn_add_eq_len_st U32 aLen = bn_add_eq_len aLen
let bn_add_eq_len_u64 (aLen:size_t) : bn_add_eq_len_st U64 aLen = bn_add_eq_len aLen
inline_for_extraction noextract
let bn_add_eq_len_u (#t:limb_t) (aLen:size_t) : bn_add_eq_len_st t aLen =
match t with
| U32 -> bn_add_eq_len_u32 aLen
| U64 -> bn_add_eq_len_u64 aLen
inline_for_extraction noextract
val bn_add:
#t:limb_t
-> aLen:size_t
-> a:lbignum t aLen
-> bLen:size_t{v bLen <= v aLen}
-> b:lbignum t bLen
-> res:lbignum t aLen ->
Stack (carry t)
(requires fun h ->
live h a /\ live h b /\ live h res /\
disjoint a b /\ eq_or_disjoint a res /\ disjoint b res)
(ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\
(let c, r = S.bn_add (as_seq h0 a) (as_seq h0 b) in
c_out == c /\ as_seq h1 res == r))
let bn_add #t aLen a bLen b res =
let h0 = ST.get () in
let a0 = sub a 0ul bLen in
let res0 = sub res 0ul bLen in
let c0 = bn_add_eq_len bLen a0 b res0 in
let h1 = ST.get () in
if bLen <. aLen then begin
[@inline_let] let rLen = aLen -! bLen in
let a1 = sub a bLen rLen in
let res1 = sub res bLen rLen in
let c1 = bn_add_carry rLen a1 c0 res1 in
let h2 = ST.get () in
LSeq.lemma_concat2 (v bLen) (as_seq h1 res0) (v rLen) (as_seq h2 res1) (as_seq h2 res);
c1 end
else c0
inline_for_extraction noextract
val bn_add1:
#t:limb_t
-> aLen:size_t{0 < v aLen}
-> a:lbignum t aLen
-> b1:limb t
-> res:lbignum t aLen ->
Stack (carry t)
(requires fun h ->
live h a /\ live h res /\ eq_or_disjoint a res)
(ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\
(let c, r = S.bn_add1 (as_seq h0 a) b1 in
c_out == c /\ as_seq h1 res == r)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Addition.fst.checked",
"Hacl.Impl.Lib.fst.checked",
"Hacl.Bignum.Definitions.fst.checked",
"Hacl.Bignum.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Bignum.Addition.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Lib",
"short_module": "SL"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Addition",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
aLen: Lib.IntTypes.size_t{0 < Lib.IntTypes.v aLen} ->
a: Hacl.Bignum.Definitions.lbignum t aLen ->
b1: Hacl.Bignum.Definitions.limb t ->
res: Hacl.Bignum.Definitions.lbignum t aLen
-> FStar.HyperStack.ST.Stack (Hacl.Spec.Bignum.Base.carry t) | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_t",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Hacl.Bignum.Definitions.lbignum",
"Hacl.Bignum.Definitions.limb",
"Lib.IntTypes.op_Less_Dot",
"FStar.UInt32.__uint_to_t",
"Prims.unit",
"Lib.Sequence.lemma_concat2",
"Lib.Sequence.sub",
"Lib.Buffer.as_seq",
"Lib.Buffer.MUT",
"Hacl.Spec.Bignum.Base.carry",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"Hacl.Bignum.Addition.bn_add_carry",
"Lib.Buffer.lbuffer_t",
"Lib.Buffer.sub",
"Lib.IntTypes.int_t",
"Lib.IntTypes.op_Subtraction_Bang",
"Prims.bool",
"Lib.Sequence.eq_intro",
"Lib.Sequence.create",
"Lib.Sequence.index",
"Hacl.Bignum.Base.addcarry_st",
"Lib.IntTypes.uint",
"Lib.IntTypes.SEC",
"FStar.UInt32.uint_to_t",
"FStar.UInt32.t",
"Lib.Buffer.op_Array_Access"
] | [] | false | true | false | false | false | let bn_add1 #t aLen a b1 res =
| let c0 = addcarry_st (uint #t 0) a.(0ul) b1 (sub res 0ul 1ul) in
let h0 = ST.get () in
LSeq.eq_intro (LSeq.sub (as_seq h0 res) 0 1) (LSeq.create 1 (LSeq.index (as_seq h0 res) 0));
if 1ul <. aLen
then
[@@ inline_let ]let rLen = aLen -! 1ul in
let a1 = sub a 1ul rLen in
let res1 = sub res 1ul rLen in
let c1 = bn_add_carry rLen a1 c0 res1 in
let h = ST.get () in
LSeq.lemma_concat2 1 (LSeq.sub (as_seq h0 res) 0 1) (v rLen) (as_seq h res1) (as_seq h res);
c1
else c0 | false |
Steel.Reference.fst | Steel.Reference.intro_vptr | val intro_vptr (#a:Type) (#opened:inames) (r:ref a) (p: perm) (v:erased a)
: SteelGhost unit opened (pts_to r p v) (fun _ -> vptrp r p)
(requires fun _ -> True)
(ensures fun _ _ h1 -> h1 (vptrp r p) == reveal v) | val intro_vptr (#a:Type) (#opened:inames) (r:ref a) (p: perm) (v:erased a)
: SteelGhost unit opened (pts_to r p v) (fun _ -> vptrp r p)
(requires fun _ -> True)
(ensures fun _ _ h1 -> h1 (vptrp r p) == reveal v) | let intro_vptr (#a:Type) (#opened:inames) (r:ref a) (p: perm) (v:erased a)
: SteelGhost unit opened (pts_to r p v) (fun _ -> vptrp r p)
(requires fun _ -> True)
(ensures fun _ _ h1 -> h1 (vptrp r p) == reveal v)
= change_slprop_2 (pts_to r p v) (vptrp r p) v (intro_vptr_lemma r p v) | {
"file_name": "lib/steel/Steel.Reference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 73,
"end_line": 300,
"start_col": 0,
"start_line": 296
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.Reference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module Mem = Steel.Memory
module H = Steel.HigherReference
module U = FStar.Universe
#set-options "--ide_id_info_off"
let ref a = H.ref (U.raise_t a)
let null #a = H.null #(U.raise_t a)
let is_null #a r = H.is_null #(U.raise_t a) r
let pts_to_sl r p v = H.pts_to_sl r p (U.raise_val v)
val raise_val_inj (#a:Type) (x y:a) : Lemma
(requires U.raise_val x == U.raise_val y)
(ensures x == y)
let raise_val_inj x y =
U.downgrade_val_raise_val x;
U.downgrade_val_raise_val y
let pts_to_ref_injective
(#a: Type u#0)
(r: ref a)
(p0 p1:perm)
(v0 v1:a)
(m:mem)
: Lemma
(requires
interp (pts_to_sl r p0 v0 `Mem.star` pts_to_sl r p1 v1) m)
(ensures v0 == v1)
= let v0' = U.raise_val v0 in
let v1' = U.raise_val v1 in
H.pts_to_ref_injective r p0 p1 v0' v1' m;
raise_val_inj v0 v1
let pts_to_not_null (#a:Type u#0)
(x:ref a)
(p:perm)
(v:a)
(m:mem)
: Lemma (requires interp (pts_to_sl x p v) m)
(ensures x =!= null)
= let v = U.raise_val v in
H.pts_to_not_null #(U.raise_t a) x p v m
// let pts_to_not_null' (#a:Type u#0)
// (x:ref a)
// (p:perm)
// (v: erased a)
// (m:mem)
// (m1:mem{disjoint m m1})
// : Lemma (requires interp (pts_to_sl x p v) m)
// (ensures interp (pts_to_sl x p v) (Mem.join m m1))
// = ()
let pts_to_witinv (#a:Type) (r:ref a) (p:perm) : Lemma (is_witness_invariant (pts_to_sl r p)) =
let aux (x y : a) (m:mem)
: Lemma (requires (interp (pts_to_sl r p x) m /\ interp (pts_to_sl r p y) m))
(ensures (x == y))
= H.pts_to_witinv r p;
raise_val_inj x y
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
let pts_to_injective_eq #a #opened #p0 #p1 #v0 #v1 r =
extract_info_raw (pts_to r p0 v0 `star` pts_to r p1 v1) (v0 == v1)
(fun m -> pts_to_ref_injective r p0 p1 v0 v1 m);
rewrite_slprop (pts_to r p1 v1) (pts_to r p1 v0) (fun _ -> ())
let pts_to_perm
r
= H.pts_to_perm r
let alloc_pt x =
let r = H.alloc (U.raise_val x) in
rewrite_slprop (H.pts_to r full_perm (U.raise_val x)) (pts_to r full_perm x) (fun _ -> ());
return r
let read_pt #a #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
let x = H.read r in
let v':a = U.downgrade_val x in
rewrite_slprop (H.pts_to r p (hide x)) (pts_to r p v') (fun _ -> ());
return v'
let read_refine_pt #a #p q r =
Classical.forall_intro_2 reveal_equiv;
lift_exists (fun (v:a) -> pts_to r p v `star` q v);
exists_cong (fun (v:U.raise_t a) -> pts_to r p (U.downgrade_val v) `star` q (U.downgrade_val v))
(fun (v:U.raise_t a) -> H.pts_to r p v `star` U.lift_dom q v);
let x = H.read_refine (U.lift_dom q) r in
rewrite_slprop
(H.pts_to r p (hide x) `star` U.lift_dom q x)
(pts_to r p (U.downgrade_val x) `star` q (U.downgrade_val x)) (fun _ -> ());
return (U.downgrade_val x)
let write_pt #a #v r x =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
let x' = U.raise_val x in
H.write r x';
rewrite_slprop (H.pts_to r full_perm (hide x')) (pts_to r full_perm x) (fun _ -> ())
let free_pt #a #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
H.free r
let share_gen_pt #a #uses #p #v r p1 p2 =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
H.share_gen r p1 p2;
rewrite_slprop (H.pts_to r p1 v') (pts_to r p1 v) (fun _ -> ());
rewrite_slprop (H.pts_to r p2 v') (pts_to r p2 v) (fun _ -> ())
let share_pt #a #uses #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
H.share r;
rewrite_slprop (H.pts_to r (half_perm p) v') (pts_to r (half_perm p) v) (fun _ -> ());
rewrite_slprop (H.pts_to r (half_perm p) v') (pts_to r (half_perm p) v) (fun _ -> ())
let hide_raise_reveal (#a:Type) (v0:erased a) (v1:erased a)
: Lemma (hide (U.raise_val (reveal v0)) == hide (U.raise_val (reveal v1)) <==>
v0 == v1)
[SMTPat (hide (U.raise_val (reveal v0)));
SMTPat (hide (U.raise_val (reveal v1)))]
= let u0 = hide (U.raise_val (reveal v0)) in
let u1 = hide (U.raise_val (reveal v1)) in
assert (U.downgrade_val (U.raise_val (reveal v0)) == U.downgrade_val (U.raise_val (reveal v1)) <==>
v0 == v1)
let gather_pt #a #uses #p0 #p1 #v0 #v1 r =
let v0' = Ghost.hide (U.raise_val (Ghost.reveal v0)) in
let v1' = Ghost.hide (U.raise_val (Ghost.reveal v1)) in
rewrite_slprop (pts_to r p0 v0) (H.pts_to r p0 v0') (fun _ -> ());
rewrite_slprop (pts_to r p1 v1) (H.pts_to r p1 v1') (fun _ -> ());
let (u:unit{v0' == v1'}) = H.gather #_ #_ #p0 #p1 #v0' #v1' r in
rewrite_slprop (H.pts_to r (sum_perm p0 p1) v0') (pts_to r (sum_perm p0 p1) v0) (fun _ -> ());
u
let raise_equiv (#t:Type) (x y:t)
: Lemma (U.raise_val x == U.raise_val y <==>
x == y)
= assert (U.downgrade_val (U.raise_val x) == x);
assert (U.downgrade_val (U.raise_val y) == y)
let downgrade_equiv (#t:Type) (x y:U.raise_t t)
: Lemma (U.downgrade_val x == U.downgrade_val y <==>
x == y)
= assert (U.raise_val (U.downgrade_val x) == x);
assert (U.raise_val (U.downgrade_val y) == y)
let lift_eq (#t:eqtype) (x y:U.raise_t t)
: b:bool{b <==> x==y}
= downgrade_equiv x y; U.downgrade_val x = U.downgrade_val y
let cas_action (#t:eqtype)
(#uses:inames)
(r:ref t)
(v:Ghost.erased t)
(v_old:t)
(v_new:t)
(frame:slprop)
: MstTot (b:bool{b <==> (Ghost.reveal v == v_old)})
uses
(pts_to_sl r full_perm v)
(fun b -> if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v)
frame
(fun _ -> True)
(fun _ _ _ -> True)
= let hv = (Ghost.hide (U.raise_val (Ghost.reveal v))) in
let b = H.cas_action #(U.raise_t t)
(lift_eq #t)
#uses
r
hv
(U.raise_val v_old)
(U.raise_val v_new)
frame
in
assert (b <==> (Ghost.reveal hv == U.raise_val v_old));
assert (b <==> U.raise_val (Ghost.reveal v) == U.raise_val v_old);
raise_equiv (Ghost.reveal v) v_old;
b
let atomic_read_pt_u32 #_ #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
let x = H.atomic_read r in
let v':U32.t = U.downgrade_val x in
rewrite_slprop (H.pts_to r p (hide x)) (pts_to r p v') (fun _ -> ());
return v'
let atomic_write_pt_u32 #_ #v r x =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
let x' = U.raise_val x in
H.atomic_write r x';
rewrite_slprop (H.pts_to r full_perm (hide x')) (pts_to r full_perm x) (fun _ -> ())
let cas_pt_u32 #uses r v v_old v_new =
let b = as_atomic_action (cas_action #U32.t #uses r v v_old v_new) in
rewrite_slprop (to_vprop (if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v))
(if b then pts_to r full_perm v_new else pts_to r full_perm v)
(fun _ -> ());
return b
let cas_pt_bool #uses r v v_old v_new =
let b = as_atomic_action (cas_action #bool #uses r v v_old v_new) in
rewrite_slprop (to_vprop (if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v))
(if b then pts_to r full_perm v_new else pts_to r full_perm v)
(fun _ -> ());
return b
(* Library for references with fractional permissions.
Permissions need to be an index of the vprop ptr.
It cannot be part of a selector, as it is not invariant when joining with a disjoint memory
Using the value of the ref as a selector is ok because refs with fractional permissions
all share the same value.
Refs on PCM are more complicated, and likely not usable with selectors
*)
let ptrp r p = Mem.h_exists (pts_to_sl r p)
val ptr_sel' (#a:Type0) (r: ref a) (p: perm) : selector' a (ptrp r p)
let ptr_sel' #a r p = fun h -> id_elim_exists #a (pts_to_sl r p) h
let ptr_sel_depends_only_on (#a:Type0) (r:ref a)
(p: perm)
(m0:Mem.hmem (ptrp r p)) (m1:mem{disjoint m0 m1})
: Lemma (ptr_sel' r p m0 == ptr_sel' r p (Mem.join m0 m1))
= let x = reveal (id_elim_exists #a (pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (pts_to_sl r p) (Mem.join m0 m1)) in
pts_to_witinv r p;
elim_wi (pts_to_sl r p) x y (Mem.join m0 m1)
let ptr_sel_depends_only_on_core (#a:Type0) (r:ref a)
(p: perm) (m0:Mem.hmem (ptrp r p))
: Lemma (ptr_sel' r p m0 == ptr_sel' r p (core_mem m0))
= let x = reveal (id_elim_exists #a (pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (pts_to_sl r p) (core_mem m0)) in
pts_to_witinv r p;
elim_wi (pts_to_sl r p) x y (core_mem m0)
let ptrp_sel r p =
Classical.forall_intro_2 (ptr_sel_depends_only_on r p);
Classical.forall_intro (ptr_sel_depends_only_on_core r p);
ptr_sel' r p
let ptrp_sel_interp #a r p m = pts_to_witinv r p
let intro_ptrp_interp r p v m = intro_h_exists (reveal v) (pts_to_sl r p) m
let intro_vptr_lemma (#a:Type) (r:ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (pts_to_sl r p v) m)
(ensures interp (ptrp r p) m /\ ptrp_sel r p m == reveal v)
= Mem.intro_h_exists (reveal v) (pts_to_sl r p) m;
pts_to_witinv r p
let elim_vptr_lemma (#a:Type) (r:ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (ptrp r p) m /\ ptrp_sel r p m == reveal v)
(ensures interp (pts_to_sl r p v) m)
= Mem.elim_h_exists (pts_to_sl r p) m;
pts_to_witinv r p | {
"checked_file": "/",
"dependencies": [
"Steel.Memory.fsti.checked",
"Steel.HigherReference.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Reference.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "Steel.HigherReference",
"short_module": "H"
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | r: Steel.Reference.ref a -> p: Steel.FractionalPermission.perm -> v: FStar.Ghost.erased a
-> Steel.Effect.Atomic.SteelGhost Prims.unit | Steel.Effect.Atomic.SteelGhost | [] | [] | [
"Steel.Memory.inames",
"Steel.Reference.ref",
"Steel.FractionalPermission.perm",
"FStar.Ghost.erased",
"Steel.Effect.Atomic.change_slprop_2",
"Steel.Reference.pts_to",
"FStar.Ghost.reveal",
"Steel.Reference.vptrp",
"Steel.Reference.intro_vptr_lemma",
"Prims.unit",
"Steel.Effect.Common.vprop",
"Steel.Effect.Common.rmem",
"Prims.l_True",
"Prims.eq2",
"Steel.Effect.Common.normal",
"Steel.Effect.Common.t_of"
] | [] | false | true | false | false | false | let intro_vptr (#a: Type) (#opened: inames) (r: ref a) (p: perm) (v: erased a)
: SteelGhost unit
opened
(pts_to r p v)
(fun _ -> vptrp r p)
(requires fun _ -> True)
(ensures fun _ _ h1 -> h1 (vptrp r p) == reveal v) =
| change_slprop_2 (pts_to r p v) (vptrp r p) v (intro_vptr_lemma r p v) | false |
Steel.Reference.fst | Steel.Reference.ghost_free | val ghost_free (#a:Type0) (#opened:inames) (r:ghost_ref a) : SteelGhost unit opened
(ghost_vptr r) (fun _ -> emp)
(requires fun _ -> True)
(ensures fun _ _ _ -> True) | val ghost_free (#a:Type0) (#opened:inames) (r:ghost_ref a) : SteelGhost unit opened
(ghost_vptr r) (fun _ -> emp)
(requires fun _ -> True)
(ensures fun _ _ _ -> True) | let ghost_free r =
let _ = elim_ghost_vptr r _ in
ghost_free_pt r | {
"file_name": "lib/steel/Steel.Reference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 17,
"end_line": 512,
"start_col": 0,
"start_line": 510
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.Reference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module Mem = Steel.Memory
module H = Steel.HigherReference
module U = FStar.Universe
#set-options "--ide_id_info_off"
let ref a = H.ref (U.raise_t a)
let null #a = H.null #(U.raise_t a)
let is_null #a r = H.is_null #(U.raise_t a) r
let pts_to_sl r p v = H.pts_to_sl r p (U.raise_val v)
val raise_val_inj (#a:Type) (x y:a) : Lemma
(requires U.raise_val x == U.raise_val y)
(ensures x == y)
let raise_val_inj x y =
U.downgrade_val_raise_val x;
U.downgrade_val_raise_val y
let pts_to_ref_injective
(#a: Type u#0)
(r: ref a)
(p0 p1:perm)
(v0 v1:a)
(m:mem)
: Lemma
(requires
interp (pts_to_sl r p0 v0 `Mem.star` pts_to_sl r p1 v1) m)
(ensures v0 == v1)
= let v0' = U.raise_val v0 in
let v1' = U.raise_val v1 in
H.pts_to_ref_injective r p0 p1 v0' v1' m;
raise_val_inj v0 v1
let pts_to_not_null (#a:Type u#0)
(x:ref a)
(p:perm)
(v:a)
(m:mem)
: Lemma (requires interp (pts_to_sl x p v) m)
(ensures x =!= null)
= let v = U.raise_val v in
H.pts_to_not_null #(U.raise_t a) x p v m
// let pts_to_not_null' (#a:Type u#0)
// (x:ref a)
// (p:perm)
// (v: erased a)
// (m:mem)
// (m1:mem{disjoint m m1})
// : Lemma (requires interp (pts_to_sl x p v) m)
// (ensures interp (pts_to_sl x p v) (Mem.join m m1))
// = ()
let pts_to_witinv (#a:Type) (r:ref a) (p:perm) : Lemma (is_witness_invariant (pts_to_sl r p)) =
let aux (x y : a) (m:mem)
: Lemma (requires (interp (pts_to_sl r p x) m /\ interp (pts_to_sl r p y) m))
(ensures (x == y))
= H.pts_to_witinv r p;
raise_val_inj x y
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
let pts_to_injective_eq #a #opened #p0 #p1 #v0 #v1 r =
extract_info_raw (pts_to r p0 v0 `star` pts_to r p1 v1) (v0 == v1)
(fun m -> pts_to_ref_injective r p0 p1 v0 v1 m);
rewrite_slprop (pts_to r p1 v1) (pts_to r p1 v0) (fun _ -> ())
let pts_to_perm
r
= H.pts_to_perm r
let alloc_pt x =
let r = H.alloc (U.raise_val x) in
rewrite_slprop (H.pts_to r full_perm (U.raise_val x)) (pts_to r full_perm x) (fun _ -> ());
return r
let read_pt #a #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
let x = H.read r in
let v':a = U.downgrade_val x in
rewrite_slprop (H.pts_to r p (hide x)) (pts_to r p v') (fun _ -> ());
return v'
let read_refine_pt #a #p q r =
Classical.forall_intro_2 reveal_equiv;
lift_exists (fun (v:a) -> pts_to r p v `star` q v);
exists_cong (fun (v:U.raise_t a) -> pts_to r p (U.downgrade_val v) `star` q (U.downgrade_val v))
(fun (v:U.raise_t a) -> H.pts_to r p v `star` U.lift_dom q v);
let x = H.read_refine (U.lift_dom q) r in
rewrite_slprop
(H.pts_to r p (hide x) `star` U.lift_dom q x)
(pts_to r p (U.downgrade_val x) `star` q (U.downgrade_val x)) (fun _ -> ());
return (U.downgrade_val x)
let write_pt #a #v r x =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
let x' = U.raise_val x in
H.write r x';
rewrite_slprop (H.pts_to r full_perm (hide x')) (pts_to r full_perm x) (fun _ -> ())
let free_pt #a #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
H.free r
let share_gen_pt #a #uses #p #v r p1 p2 =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
H.share_gen r p1 p2;
rewrite_slprop (H.pts_to r p1 v') (pts_to r p1 v) (fun _ -> ());
rewrite_slprop (H.pts_to r p2 v') (pts_to r p2 v) (fun _ -> ())
let share_pt #a #uses #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
H.share r;
rewrite_slprop (H.pts_to r (half_perm p) v') (pts_to r (half_perm p) v) (fun _ -> ());
rewrite_slprop (H.pts_to r (half_perm p) v') (pts_to r (half_perm p) v) (fun _ -> ())
let hide_raise_reveal (#a:Type) (v0:erased a) (v1:erased a)
: Lemma (hide (U.raise_val (reveal v0)) == hide (U.raise_val (reveal v1)) <==>
v0 == v1)
[SMTPat (hide (U.raise_val (reveal v0)));
SMTPat (hide (U.raise_val (reveal v1)))]
= let u0 = hide (U.raise_val (reveal v0)) in
let u1 = hide (U.raise_val (reveal v1)) in
assert (U.downgrade_val (U.raise_val (reveal v0)) == U.downgrade_val (U.raise_val (reveal v1)) <==>
v0 == v1)
let gather_pt #a #uses #p0 #p1 #v0 #v1 r =
let v0' = Ghost.hide (U.raise_val (Ghost.reveal v0)) in
let v1' = Ghost.hide (U.raise_val (Ghost.reveal v1)) in
rewrite_slprop (pts_to r p0 v0) (H.pts_to r p0 v0') (fun _ -> ());
rewrite_slprop (pts_to r p1 v1) (H.pts_to r p1 v1') (fun _ -> ());
let (u:unit{v0' == v1'}) = H.gather #_ #_ #p0 #p1 #v0' #v1' r in
rewrite_slprop (H.pts_to r (sum_perm p0 p1) v0') (pts_to r (sum_perm p0 p1) v0) (fun _ -> ());
u
let raise_equiv (#t:Type) (x y:t)
: Lemma (U.raise_val x == U.raise_val y <==>
x == y)
= assert (U.downgrade_val (U.raise_val x) == x);
assert (U.downgrade_val (U.raise_val y) == y)
let downgrade_equiv (#t:Type) (x y:U.raise_t t)
: Lemma (U.downgrade_val x == U.downgrade_val y <==>
x == y)
= assert (U.raise_val (U.downgrade_val x) == x);
assert (U.raise_val (U.downgrade_val y) == y)
let lift_eq (#t:eqtype) (x y:U.raise_t t)
: b:bool{b <==> x==y}
= downgrade_equiv x y; U.downgrade_val x = U.downgrade_val y
let cas_action (#t:eqtype)
(#uses:inames)
(r:ref t)
(v:Ghost.erased t)
(v_old:t)
(v_new:t)
(frame:slprop)
: MstTot (b:bool{b <==> (Ghost.reveal v == v_old)})
uses
(pts_to_sl r full_perm v)
(fun b -> if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v)
frame
(fun _ -> True)
(fun _ _ _ -> True)
= let hv = (Ghost.hide (U.raise_val (Ghost.reveal v))) in
let b = H.cas_action #(U.raise_t t)
(lift_eq #t)
#uses
r
hv
(U.raise_val v_old)
(U.raise_val v_new)
frame
in
assert (b <==> (Ghost.reveal hv == U.raise_val v_old));
assert (b <==> U.raise_val (Ghost.reveal v) == U.raise_val v_old);
raise_equiv (Ghost.reveal v) v_old;
b
let atomic_read_pt_u32 #_ #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
let x = H.atomic_read r in
let v':U32.t = U.downgrade_val x in
rewrite_slprop (H.pts_to r p (hide x)) (pts_to r p v') (fun _ -> ());
return v'
let atomic_write_pt_u32 #_ #v r x =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
let x' = U.raise_val x in
H.atomic_write r x';
rewrite_slprop (H.pts_to r full_perm (hide x')) (pts_to r full_perm x) (fun _ -> ())
let cas_pt_u32 #uses r v v_old v_new =
let b = as_atomic_action (cas_action #U32.t #uses r v v_old v_new) in
rewrite_slprop (to_vprop (if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v))
(if b then pts_to r full_perm v_new else pts_to r full_perm v)
(fun _ -> ());
return b
let cas_pt_bool #uses r v v_old v_new =
let b = as_atomic_action (cas_action #bool #uses r v v_old v_new) in
rewrite_slprop (to_vprop (if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v))
(if b then pts_to r full_perm v_new else pts_to r full_perm v)
(fun _ -> ());
return b
(* Library for references with fractional permissions.
Permissions need to be an index of the vprop ptr.
It cannot be part of a selector, as it is not invariant when joining with a disjoint memory
Using the value of the ref as a selector is ok because refs with fractional permissions
all share the same value.
Refs on PCM are more complicated, and likely not usable with selectors
*)
let ptrp r p = Mem.h_exists (pts_to_sl r p)
val ptr_sel' (#a:Type0) (r: ref a) (p: perm) : selector' a (ptrp r p)
let ptr_sel' #a r p = fun h -> id_elim_exists #a (pts_to_sl r p) h
let ptr_sel_depends_only_on (#a:Type0) (r:ref a)
(p: perm)
(m0:Mem.hmem (ptrp r p)) (m1:mem{disjoint m0 m1})
: Lemma (ptr_sel' r p m0 == ptr_sel' r p (Mem.join m0 m1))
= let x = reveal (id_elim_exists #a (pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (pts_to_sl r p) (Mem.join m0 m1)) in
pts_to_witinv r p;
elim_wi (pts_to_sl r p) x y (Mem.join m0 m1)
let ptr_sel_depends_only_on_core (#a:Type0) (r:ref a)
(p: perm) (m0:Mem.hmem (ptrp r p))
: Lemma (ptr_sel' r p m0 == ptr_sel' r p (core_mem m0))
= let x = reveal (id_elim_exists #a (pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (pts_to_sl r p) (core_mem m0)) in
pts_to_witinv r p;
elim_wi (pts_to_sl r p) x y (core_mem m0)
let ptrp_sel r p =
Classical.forall_intro_2 (ptr_sel_depends_only_on r p);
Classical.forall_intro (ptr_sel_depends_only_on_core r p);
ptr_sel' r p
let ptrp_sel_interp #a r p m = pts_to_witinv r p
let intro_ptrp_interp r p v m = intro_h_exists (reveal v) (pts_to_sl r p) m
let intro_vptr_lemma (#a:Type) (r:ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (pts_to_sl r p v) m)
(ensures interp (ptrp r p) m /\ ptrp_sel r p m == reveal v)
= Mem.intro_h_exists (reveal v) (pts_to_sl r p) m;
pts_to_witinv r p
let elim_vptr_lemma (#a:Type) (r:ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (ptrp r p) m /\ ptrp_sel r p m == reveal v)
(ensures interp (pts_to_sl r p v) m)
= Mem.elim_h_exists (pts_to_sl r p) m;
pts_to_witinv r p
let intro_vptr (#a:Type) (#opened:inames) (r:ref a) (p: perm) (v:erased a)
: SteelGhost unit opened (pts_to r p v) (fun _ -> vptrp r p)
(requires fun _ -> True)
(ensures fun _ _ h1 -> h1 (vptrp r p) == reveal v)
= change_slprop_2 (pts_to r p v) (vptrp r p) v (intro_vptr_lemma r p v)
let elim_vptr (#a:Type) (#opened:inames) (r:ref a) (p: perm)
: SteelGhost (erased a) opened (vptrp r p) (fun v -> pts_to r p v)
(requires fun _ -> True)
(ensures fun h0 v _ -> reveal v == h0 (vptrp r p))
= let v = gget (vptrp r p) in
change_slprop (vptrp r p) (pts_to r p v) v () (elim_vptr_lemma r p v);
v
let malloc x =
let r = alloc_pt x in
intro_vptr r _ (hide x);
return r
let free r =
let _ = elim_vptr r _ in
free_pt r
let readp r _ =
let _ = elim_vptr r _ in
let x = read_pt r in
intro_vptr r _ x;
return x
let write r x =
let _ = elim_vptr r _ in
write_pt r x;
intro_vptr r _ x
let share #a #_ #p r =
let x = elim_vptr r p in
share_pt r;
intro_vptr r _ x;
intro_vptr r _ x
let gather_gen #a #_ r p0 p1 =
let x1 = elim_vptr r p1 in
let x0 = elim_vptr r p0 in
gather_pt #_ #_ #p0 #p1 #x0 #x1 r;
intro_vptr r (sum_perm p0 p1) x0;
sum_perm p0 p1
let gather (#a: Type0) (#uses: _) (#p: perm) (r: ref a)
: SteelGhost unit uses
(vptrp r (half_perm p) `star` vptrp r (half_perm p))
(fun _ -> vptrp r p)
(fun _ -> True)
(fun h _ h' ->
h' (vptrp r p) == h (vptrp r (half_perm p))
)
= let _ = gather_gen r _ _ in
change_equal_slprop
(vptrp r _)
(vptrp r p)
(*** Lemmas on references *)
let vptrp_not_null
#opened #a r
p
= change_slprop_rel
(vptrp r p)
(vptrp r p)
(fun x y -> x == y /\ is_null r == false)
(fun m -> pts_to_not_null r p (ptrp_sel r p m) m)
(*** Ghost pointers *)
(*** GHOST REFERENCES ***)
let ghost_ref a = H.ghost_ref (U.raise_t a)
let dummy_ghost_ref a =
H.reveal_ghost_ref (U.raise_t a);
coerce_eq () (Ghost.hide (H.null #(U.raise_t a)))
[@__reduce__]
let ghost_pts_to_sl #a r p x = H.ghost_pts_to_sl #(U.raise_t a) r p (U.raise_val x)
let ghost_pts_to_witinv (#a:Type) (r:ghost_ref a) (p:perm) : Lemma (is_witness_invariant (ghost_pts_to_sl r p)) =
let aux (x y : a) (m:mem)
: Lemma (requires (interp (ghost_pts_to_sl r p x) m /\ interp (ghost_pts_to_sl r p y) m))
(ensures (x == y))
= H.ghost_pts_to_witinv r p;
raise_val_inj x y
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
[@@__reduce__]
let raise_erased (#a:Type0) (x:erased a)
: erased (U.raise_t u#0 u#1 a)
= Ghost.hide (U.raise_val (Ghost.reveal x))
let ghost_alloc_pt (#a:Type) (#u:_) (x:erased a)
: SteelGhostT (ghost_ref a) u
emp
(fun r -> ghost_pts_to r full_perm x)
= H.ghost_alloc (raise_erased x)
let ghost_free_pt r = H.ghost_free r
let ghost_share_gen_pt
#_ #_ #_ #x r p1 p2
= H.ghost_share_gen #_ #_ #_ #(raise_erased x) r p1 p2
let ghost_share_pt (#a:Type) (#u:_)
(#p:perm)
(#x:erased a)
(r:ghost_ref a)
= H.ghost_share #_ #_ #_ #(raise_erased x) r
let ghost_gather_pt (#a:Type) (#u:_)
(#p0 #p1:perm)
(#x0 #x1:erased a)
(r:ghost_ref a)
: SteelGhost unit u
(ghost_pts_to r p0 x0 `star`
ghost_pts_to r p1 x1)
(fun _ -> ghost_pts_to r (sum_perm p0 p1) x0)
(requires fun _ -> true)
(ensures fun _ _ _ -> x0 == x1)
= H.ghost_gather r
let ghost_pts_to_injective_eq (#a:_) (#u:_) (#p #q:_) (r:ghost_ref a) (v0 v1:Ghost.erased a)
: SteelGhost unit u
(ghost_pts_to r p v0 `star` ghost_pts_to r q v1)
(fun _ -> ghost_pts_to r p v0 `star` ghost_pts_to r q v0)
(requires fun _ -> True)
(ensures fun _ _ _ -> v0 == v1)
= H.ghost_pts_to_injective_eq #_ #_ #p #q r (raise_erased v0) (raise_erased v1)
let ghost_pts_to_perm r = H.ghost_pts_to_perm r
let ghost_read_pt #a #u #p #v r =
let x = H.ghost_read r in
let x' = hide (U.downgrade_val (reveal x)) in
rewrite_slprop (H.ghost_pts_to r p x) (ghost_pts_to r p x') (fun _ -> ());
x'
let ghost_write_pt (#a:Type) (#u:_) (#v:erased a) (r:ghost_ref a) (x:erased a)
: SteelGhostT unit u
(ghost_pts_to r full_perm v)
(fun _ -> ghost_pts_to r full_perm x)
= H.ghost_write r (raise_erased x)
(* Selector version of ghost pointers *)
let ghost_ptrp r p = Mem.h_exists (ghost_pts_to_sl r p)
val ghost_ptr_sel' (#a:Type0) (r: ghost_ref a) (p: perm) : selector' a (ghost_ptrp r p)
let ghost_ptr_sel' #a r p = fun h -> id_elim_exists #a (ghost_pts_to_sl r p) h
let ghost_ptr_sel_depends_only_on (#a:Type0) (r:ghost_ref a)
(p: perm)
(m0:Mem.hmem (ghost_ptrp r p)) (m1:mem{disjoint m0 m1})
: Lemma (ghost_ptr_sel' r p m0 == ghost_ptr_sel' r p (Mem.join m0 m1))
= let x = reveal (id_elim_exists #a (ghost_pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (ghost_pts_to_sl r p) (Mem.join m0 m1)) in
ghost_pts_to_witinv r p;
elim_wi (ghost_pts_to_sl r p) x y (Mem.join m0 m1)
let ghost_ptr_sel_depends_only_on_core (#a:Type0) (r:ghost_ref a)
(p: perm) (m0:Mem.hmem (ghost_ptrp r p))
: Lemma (ghost_ptr_sel' r p m0 == ghost_ptr_sel' r p (core_mem m0))
= let x = reveal (id_elim_exists #a (ghost_pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (ghost_pts_to_sl r p) (core_mem m0)) in
ghost_pts_to_witinv r p;
elim_wi (ghost_pts_to_sl r p) x y (core_mem m0)
let ghost_ptrp_sel r p =
Classical.forall_intro_2 (ghost_ptr_sel_depends_only_on r p);
Classical.forall_intro (ghost_ptr_sel_depends_only_on_core r p);
ghost_ptr_sel' r p
let ghost_ptrp_sel_interp #a r p m = ghost_pts_to_witinv r p
let intro_ghost_vptr_lemma (#a:Type) (r:ghost_ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (ghost_pts_to_sl r p v) m)
(ensures interp (ghost_ptrp r p) m /\ ghost_ptrp_sel r p m == reveal v)
= Mem.intro_h_exists (reveal v) (ghost_pts_to_sl r p) m;
ghost_pts_to_witinv r p
let elim_ghost_vptr_lemma (#a:Type) (r:ghost_ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (ghost_ptrp r p) m /\ ghost_ptrp_sel r p m == reveal v)
(ensures interp (ghost_pts_to_sl r p v) m)
= Mem.elim_h_exists (ghost_pts_to_sl r p) m;
ghost_pts_to_witinv r p
let intro_ghost_vptr (#a:Type) (#opened:inames) (r:ghost_ref a) (p: perm) (v:erased a)
: SteelGhost unit opened (ghost_pts_to r p v) (fun _ -> ghost_vptrp r p)
(requires fun _ -> True)
(ensures fun _ _ h1 -> h1 (ghost_vptrp r p) == reveal v)
= change_slprop_2 (ghost_pts_to r p v) (ghost_vptrp r p) v (intro_ghost_vptr_lemma r p v)
let elim_ghost_vptr (#a:Type) (#opened:inames) (r:ghost_ref a)
(p: perm)
: SteelGhost (erased a) opened (ghost_vptrp r p) (fun v -> ghost_pts_to r p v)
(requires fun _ -> True)
(ensures fun h0 v _ -> reveal v == h0 (ghost_vptrp r p))
= let v = gget (ghost_vptrp r p) in
change_slprop (ghost_vptrp r p) (ghost_pts_to r p v) v () (elim_ghost_vptr_lemma r p v);
v
let ghost_alloc x =
let r = ghost_alloc_pt x in
intro_ghost_vptr r _ x;
r | {
"checked_file": "/",
"dependencies": [
"Steel.Memory.fsti.checked",
"Steel.HigherReference.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Reference.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "Steel.HigherReference",
"short_module": "H"
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | r: Steel.Reference.ghost_ref a -> Steel.Effect.Atomic.SteelGhost Prims.unit | Steel.Effect.Atomic.SteelGhost | [] | [] | [
"Steel.Memory.inames",
"Steel.Reference.ghost_ref",
"Steel.Reference.ghost_free_pt",
"Prims.unit",
"FStar.Ghost.erased",
"Steel.Reference.elim_ghost_vptr",
"Steel.FractionalPermission.full_perm"
] | [] | false | true | false | false | false | let ghost_free r =
| let _ = elim_ghost_vptr r _ in
ghost_free_pt r | false |
Steel.Reference.fst | Steel.Reference.intro_ghost_vptr | val intro_ghost_vptr (#a: Type) (#opened: inames) (r: ghost_ref a) (p: perm) (v: erased a)
: SteelGhost unit
opened
(ghost_pts_to r p v)
(fun _ -> ghost_vptrp r p)
(requires fun _ -> True)
(ensures fun _ _ h1 -> h1 (ghost_vptrp r p) == reveal v) | val intro_ghost_vptr (#a: Type) (#opened: inames) (r: ghost_ref a) (p: perm) (v: erased a)
: SteelGhost unit
opened
(ghost_pts_to r p v)
(fun _ -> ghost_vptrp r p)
(requires fun _ -> True)
(ensures fun _ _ h1 -> h1 (ghost_vptrp r p) == reveal v) | let intro_ghost_vptr (#a:Type) (#opened:inames) (r:ghost_ref a) (p: perm) (v:erased a)
: SteelGhost unit opened (ghost_pts_to r p v) (fun _ -> ghost_vptrp r p)
(requires fun _ -> True)
(ensures fun _ _ h1 -> h1 (ghost_vptrp r p) == reveal v)
= change_slprop_2 (ghost_pts_to r p v) (ghost_vptrp r p) v (intro_ghost_vptr_lemma r p v) | {
"file_name": "lib/steel/Steel.Reference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 91,
"end_line": 494,
"start_col": 0,
"start_line": 490
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.Reference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module Mem = Steel.Memory
module H = Steel.HigherReference
module U = FStar.Universe
#set-options "--ide_id_info_off"
let ref a = H.ref (U.raise_t a)
let null #a = H.null #(U.raise_t a)
let is_null #a r = H.is_null #(U.raise_t a) r
let pts_to_sl r p v = H.pts_to_sl r p (U.raise_val v)
val raise_val_inj (#a:Type) (x y:a) : Lemma
(requires U.raise_val x == U.raise_val y)
(ensures x == y)
let raise_val_inj x y =
U.downgrade_val_raise_val x;
U.downgrade_val_raise_val y
let pts_to_ref_injective
(#a: Type u#0)
(r: ref a)
(p0 p1:perm)
(v0 v1:a)
(m:mem)
: Lemma
(requires
interp (pts_to_sl r p0 v0 `Mem.star` pts_to_sl r p1 v1) m)
(ensures v0 == v1)
= let v0' = U.raise_val v0 in
let v1' = U.raise_val v1 in
H.pts_to_ref_injective r p0 p1 v0' v1' m;
raise_val_inj v0 v1
let pts_to_not_null (#a:Type u#0)
(x:ref a)
(p:perm)
(v:a)
(m:mem)
: Lemma (requires interp (pts_to_sl x p v) m)
(ensures x =!= null)
= let v = U.raise_val v in
H.pts_to_not_null #(U.raise_t a) x p v m
// let pts_to_not_null' (#a:Type u#0)
// (x:ref a)
// (p:perm)
// (v: erased a)
// (m:mem)
// (m1:mem{disjoint m m1})
// : Lemma (requires interp (pts_to_sl x p v) m)
// (ensures interp (pts_to_sl x p v) (Mem.join m m1))
// = ()
let pts_to_witinv (#a:Type) (r:ref a) (p:perm) : Lemma (is_witness_invariant (pts_to_sl r p)) =
let aux (x y : a) (m:mem)
: Lemma (requires (interp (pts_to_sl r p x) m /\ interp (pts_to_sl r p y) m))
(ensures (x == y))
= H.pts_to_witinv r p;
raise_val_inj x y
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
let pts_to_injective_eq #a #opened #p0 #p1 #v0 #v1 r =
extract_info_raw (pts_to r p0 v0 `star` pts_to r p1 v1) (v0 == v1)
(fun m -> pts_to_ref_injective r p0 p1 v0 v1 m);
rewrite_slprop (pts_to r p1 v1) (pts_to r p1 v0) (fun _ -> ())
let pts_to_perm
r
= H.pts_to_perm r
let alloc_pt x =
let r = H.alloc (U.raise_val x) in
rewrite_slprop (H.pts_to r full_perm (U.raise_val x)) (pts_to r full_perm x) (fun _ -> ());
return r
let read_pt #a #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
let x = H.read r in
let v':a = U.downgrade_val x in
rewrite_slprop (H.pts_to r p (hide x)) (pts_to r p v') (fun _ -> ());
return v'
let read_refine_pt #a #p q r =
Classical.forall_intro_2 reveal_equiv;
lift_exists (fun (v:a) -> pts_to r p v `star` q v);
exists_cong (fun (v:U.raise_t a) -> pts_to r p (U.downgrade_val v) `star` q (U.downgrade_val v))
(fun (v:U.raise_t a) -> H.pts_to r p v `star` U.lift_dom q v);
let x = H.read_refine (U.lift_dom q) r in
rewrite_slprop
(H.pts_to r p (hide x) `star` U.lift_dom q x)
(pts_to r p (U.downgrade_val x) `star` q (U.downgrade_val x)) (fun _ -> ());
return (U.downgrade_val x)
let write_pt #a #v r x =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
let x' = U.raise_val x in
H.write r x';
rewrite_slprop (H.pts_to r full_perm (hide x')) (pts_to r full_perm x) (fun _ -> ())
let free_pt #a #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
H.free r
let share_gen_pt #a #uses #p #v r p1 p2 =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
H.share_gen r p1 p2;
rewrite_slprop (H.pts_to r p1 v') (pts_to r p1 v) (fun _ -> ());
rewrite_slprop (H.pts_to r p2 v') (pts_to r p2 v) (fun _ -> ())
let share_pt #a #uses #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
H.share r;
rewrite_slprop (H.pts_to r (half_perm p) v') (pts_to r (half_perm p) v) (fun _ -> ());
rewrite_slprop (H.pts_to r (half_perm p) v') (pts_to r (half_perm p) v) (fun _ -> ())
let hide_raise_reveal (#a:Type) (v0:erased a) (v1:erased a)
: Lemma (hide (U.raise_val (reveal v0)) == hide (U.raise_val (reveal v1)) <==>
v0 == v1)
[SMTPat (hide (U.raise_val (reveal v0)));
SMTPat (hide (U.raise_val (reveal v1)))]
= let u0 = hide (U.raise_val (reveal v0)) in
let u1 = hide (U.raise_val (reveal v1)) in
assert (U.downgrade_val (U.raise_val (reveal v0)) == U.downgrade_val (U.raise_val (reveal v1)) <==>
v0 == v1)
let gather_pt #a #uses #p0 #p1 #v0 #v1 r =
let v0' = Ghost.hide (U.raise_val (Ghost.reveal v0)) in
let v1' = Ghost.hide (U.raise_val (Ghost.reveal v1)) in
rewrite_slprop (pts_to r p0 v0) (H.pts_to r p0 v0') (fun _ -> ());
rewrite_slprop (pts_to r p1 v1) (H.pts_to r p1 v1') (fun _ -> ());
let (u:unit{v0' == v1'}) = H.gather #_ #_ #p0 #p1 #v0' #v1' r in
rewrite_slprop (H.pts_to r (sum_perm p0 p1) v0') (pts_to r (sum_perm p0 p1) v0) (fun _ -> ());
u
let raise_equiv (#t:Type) (x y:t)
: Lemma (U.raise_val x == U.raise_val y <==>
x == y)
= assert (U.downgrade_val (U.raise_val x) == x);
assert (U.downgrade_val (U.raise_val y) == y)
let downgrade_equiv (#t:Type) (x y:U.raise_t t)
: Lemma (U.downgrade_val x == U.downgrade_val y <==>
x == y)
= assert (U.raise_val (U.downgrade_val x) == x);
assert (U.raise_val (U.downgrade_val y) == y)
let lift_eq (#t:eqtype) (x y:U.raise_t t)
: b:bool{b <==> x==y}
= downgrade_equiv x y; U.downgrade_val x = U.downgrade_val y
let cas_action (#t:eqtype)
(#uses:inames)
(r:ref t)
(v:Ghost.erased t)
(v_old:t)
(v_new:t)
(frame:slprop)
: MstTot (b:bool{b <==> (Ghost.reveal v == v_old)})
uses
(pts_to_sl r full_perm v)
(fun b -> if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v)
frame
(fun _ -> True)
(fun _ _ _ -> True)
= let hv = (Ghost.hide (U.raise_val (Ghost.reveal v))) in
let b = H.cas_action #(U.raise_t t)
(lift_eq #t)
#uses
r
hv
(U.raise_val v_old)
(U.raise_val v_new)
frame
in
assert (b <==> (Ghost.reveal hv == U.raise_val v_old));
assert (b <==> U.raise_val (Ghost.reveal v) == U.raise_val v_old);
raise_equiv (Ghost.reveal v) v_old;
b
let atomic_read_pt_u32 #_ #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
let x = H.atomic_read r in
let v':U32.t = U.downgrade_val x in
rewrite_slprop (H.pts_to r p (hide x)) (pts_to r p v') (fun _ -> ());
return v'
let atomic_write_pt_u32 #_ #v r x =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
let x' = U.raise_val x in
H.atomic_write r x';
rewrite_slprop (H.pts_to r full_perm (hide x')) (pts_to r full_perm x) (fun _ -> ())
let cas_pt_u32 #uses r v v_old v_new =
let b = as_atomic_action (cas_action #U32.t #uses r v v_old v_new) in
rewrite_slprop (to_vprop (if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v))
(if b then pts_to r full_perm v_new else pts_to r full_perm v)
(fun _ -> ());
return b
let cas_pt_bool #uses r v v_old v_new =
let b = as_atomic_action (cas_action #bool #uses r v v_old v_new) in
rewrite_slprop (to_vprop (if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v))
(if b then pts_to r full_perm v_new else pts_to r full_perm v)
(fun _ -> ());
return b
(* Library for references with fractional permissions.
Permissions need to be an index of the vprop ptr.
It cannot be part of a selector, as it is not invariant when joining with a disjoint memory
Using the value of the ref as a selector is ok because refs with fractional permissions
all share the same value.
Refs on PCM are more complicated, and likely not usable with selectors
*)
let ptrp r p = Mem.h_exists (pts_to_sl r p)
val ptr_sel' (#a:Type0) (r: ref a) (p: perm) : selector' a (ptrp r p)
let ptr_sel' #a r p = fun h -> id_elim_exists #a (pts_to_sl r p) h
let ptr_sel_depends_only_on (#a:Type0) (r:ref a)
(p: perm)
(m0:Mem.hmem (ptrp r p)) (m1:mem{disjoint m0 m1})
: Lemma (ptr_sel' r p m0 == ptr_sel' r p (Mem.join m0 m1))
= let x = reveal (id_elim_exists #a (pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (pts_to_sl r p) (Mem.join m0 m1)) in
pts_to_witinv r p;
elim_wi (pts_to_sl r p) x y (Mem.join m0 m1)
let ptr_sel_depends_only_on_core (#a:Type0) (r:ref a)
(p: perm) (m0:Mem.hmem (ptrp r p))
: Lemma (ptr_sel' r p m0 == ptr_sel' r p (core_mem m0))
= let x = reveal (id_elim_exists #a (pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (pts_to_sl r p) (core_mem m0)) in
pts_to_witinv r p;
elim_wi (pts_to_sl r p) x y (core_mem m0)
let ptrp_sel r p =
Classical.forall_intro_2 (ptr_sel_depends_only_on r p);
Classical.forall_intro (ptr_sel_depends_only_on_core r p);
ptr_sel' r p
let ptrp_sel_interp #a r p m = pts_to_witinv r p
let intro_ptrp_interp r p v m = intro_h_exists (reveal v) (pts_to_sl r p) m
let intro_vptr_lemma (#a:Type) (r:ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (pts_to_sl r p v) m)
(ensures interp (ptrp r p) m /\ ptrp_sel r p m == reveal v)
= Mem.intro_h_exists (reveal v) (pts_to_sl r p) m;
pts_to_witinv r p
let elim_vptr_lemma (#a:Type) (r:ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (ptrp r p) m /\ ptrp_sel r p m == reveal v)
(ensures interp (pts_to_sl r p v) m)
= Mem.elim_h_exists (pts_to_sl r p) m;
pts_to_witinv r p
let intro_vptr (#a:Type) (#opened:inames) (r:ref a) (p: perm) (v:erased a)
: SteelGhost unit opened (pts_to r p v) (fun _ -> vptrp r p)
(requires fun _ -> True)
(ensures fun _ _ h1 -> h1 (vptrp r p) == reveal v)
= change_slprop_2 (pts_to r p v) (vptrp r p) v (intro_vptr_lemma r p v)
let elim_vptr (#a:Type) (#opened:inames) (r:ref a) (p: perm)
: SteelGhost (erased a) opened (vptrp r p) (fun v -> pts_to r p v)
(requires fun _ -> True)
(ensures fun h0 v _ -> reveal v == h0 (vptrp r p))
= let v = gget (vptrp r p) in
change_slprop (vptrp r p) (pts_to r p v) v () (elim_vptr_lemma r p v);
v
let malloc x =
let r = alloc_pt x in
intro_vptr r _ (hide x);
return r
let free r =
let _ = elim_vptr r _ in
free_pt r
let readp r _ =
let _ = elim_vptr r _ in
let x = read_pt r in
intro_vptr r _ x;
return x
let write r x =
let _ = elim_vptr r _ in
write_pt r x;
intro_vptr r _ x
let share #a #_ #p r =
let x = elim_vptr r p in
share_pt r;
intro_vptr r _ x;
intro_vptr r _ x
let gather_gen #a #_ r p0 p1 =
let x1 = elim_vptr r p1 in
let x0 = elim_vptr r p0 in
gather_pt #_ #_ #p0 #p1 #x0 #x1 r;
intro_vptr r (sum_perm p0 p1) x0;
sum_perm p0 p1
let gather (#a: Type0) (#uses: _) (#p: perm) (r: ref a)
: SteelGhost unit uses
(vptrp r (half_perm p) `star` vptrp r (half_perm p))
(fun _ -> vptrp r p)
(fun _ -> True)
(fun h _ h' ->
h' (vptrp r p) == h (vptrp r (half_perm p))
)
= let _ = gather_gen r _ _ in
change_equal_slprop
(vptrp r _)
(vptrp r p)
(*** Lemmas on references *)
let vptrp_not_null
#opened #a r
p
= change_slprop_rel
(vptrp r p)
(vptrp r p)
(fun x y -> x == y /\ is_null r == false)
(fun m -> pts_to_not_null r p (ptrp_sel r p m) m)
(*** Ghost pointers *)
(*** GHOST REFERENCES ***)
let ghost_ref a = H.ghost_ref (U.raise_t a)
let dummy_ghost_ref a =
H.reveal_ghost_ref (U.raise_t a);
coerce_eq () (Ghost.hide (H.null #(U.raise_t a)))
[@__reduce__]
let ghost_pts_to_sl #a r p x = H.ghost_pts_to_sl #(U.raise_t a) r p (U.raise_val x)
let ghost_pts_to_witinv (#a:Type) (r:ghost_ref a) (p:perm) : Lemma (is_witness_invariant (ghost_pts_to_sl r p)) =
let aux (x y : a) (m:mem)
: Lemma (requires (interp (ghost_pts_to_sl r p x) m /\ interp (ghost_pts_to_sl r p y) m))
(ensures (x == y))
= H.ghost_pts_to_witinv r p;
raise_val_inj x y
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
[@@__reduce__]
let raise_erased (#a:Type0) (x:erased a)
: erased (U.raise_t u#0 u#1 a)
= Ghost.hide (U.raise_val (Ghost.reveal x))
let ghost_alloc_pt (#a:Type) (#u:_) (x:erased a)
: SteelGhostT (ghost_ref a) u
emp
(fun r -> ghost_pts_to r full_perm x)
= H.ghost_alloc (raise_erased x)
let ghost_free_pt r = H.ghost_free r
let ghost_share_gen_pt
#_ #_ #_ #x r p1 p2
= H.ghost_share_gen #_ #_ #_ #(raise_erased x) r p1 p2
let ghost_share_pt (#a:Type) (#u:_)
(#p:perm)
(#x:erased a)
(r:ghost_ref a)
= H.ghost_share #_ #_ #_ #(raise_erased x) r
let ghost_gather_pt (#a:Type) (#u:_)
(#p0 #p1:perm)
(#x0 #x1:erased a)
(r:ghost_ref a)
: SteelGhost unit u
(ghost_pts_to r p0 x0 `star`
ghost_pts_to r p1 x1)
(fun _ -> ghost_pts_to r (sum_perm p0 p1) x0)
(requires fun _ -> true)
(ensures fun _ _ _ -> x0 == x1)
= H.ghost_gather r
let ghost_pts_to_injective_eq (#a:_) (#u:_) (#p #q:_) (r:ghost_ref a) (v0 v1:Ghost.erased a)
: SteelGhost unit u
(ghost_pts_to r p v0 `star` ghost_pts_to r q v1)
(fun _ -> ghost_pts_to r p v0 `star` ghost_pts_to r q v0)
(requires fun _ -> True)
(ensures fun _ _ _ -> v0 == v1)
= H.ghost_pts_to_injective_eq #_ #_ #p #q r (raise_erased v0) (raise_erased v1)
let ghost_pts_to_perm r = H.ghost_pts_to_perm r
let ghost_read_pt #a #u #p #v r =
let x = H.ghost_read r in
let x' = hide (U.downgrade_val (reveal x)) in
rewrite_slprop (H.ghost_pts_to r p x) (ghost_pts_to r p x') (fun _ -> ());
x'
let ghost_write_pt (#a:Type) (#u:_) (#v:erased a) (r:ghost_ref a) (x:erased a)
: SteelGhostT unit u
(ghost_pts_to r full_perm v)
(fun _ -> ghost_pts_to r full_perm x)
= H.ghost_write r (raise_erased x)
(* Selector version of ghost pointers *)
let ghost_ptrp r p = Mem.h_exists (ghost_pts_to_sl r p)
val ghost_ptr_sel' (#a:Type0) (r: ghost_ref a) (p: perm) : selector' a (ghost_ptrp r p)
let ghost_ptr_sel' #a r p = fun h -> id_elim_exists #a (ghost_pts_to_sl r p) h
let ghost_ptr_sel_depends_only_on (#a:Type0) (r:ghost_ref a)
(p: perm)
(m0:Mem.hmem (ghost_ptrp r p)) (m1:mem{disjoint m0 m1})
: Lemma (ghost_ptr_sel' r p m0 == ghost_ptr_sel' r p (Mem.join m0 m1))
= let x = reveal (id_elim_exists #a (ghost_pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (ghost_pts_to_sl r p) (Mem.join m0 m1)) in
ghost_pts_to_witinv r p;
elim_wi (ghost_pts_to_sl r p) x y (Mem.join m0 m1)
let ghost_ptr_sel_depends_only_on_core (#a:Type0) (r:ghost_ref a)
(p: perm) (m0:Mem.hmem (ghost_ptrp r p))
: Lemma (ghost_ptr_sel' r p m0 == ghost_ptr_sel' r p (core_mem m0))
= let x = reveal (id_elim_exists #a (ghost_pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (ghost_pts_to_sl r p) (core_mem m0)) in
ghost_pts_to_witinv r p;
elim_wi (ghost_pts_to_sl r p) x y (core_mem m0)
let ghost_ptrp_sel r p =
Classical.forall_intro_2 (ghost_ptr_sel_depends_only_on r p);
Classical.forall_intro (ghost_ptr_sel_depends_only_on_core r p);
ghost_ptr_sel' r p
let ghost_ptrp_sel_interp #a r p m = ghost_pts_to_witinv r p
let intro_ghost_vptr_lemma (#a:Type) (r:ghost_ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (ghost_pts_to_sl r p v) m)
(ensures interp (ghost_ptrp r p) m /\ ghost_ptrp_sel r p m == reveal v)
= Mem.intro_h_exists (reveal v) (ghost_pts_to_sl r p) m;
ghost_pts_to_witinv r p
let elim_ghost_vptr_lemma (#a:Type) (r:ghost_ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (ghost_ptrp r p) m /\ ghost_ptrp_sel r p m == reveal v)
(ensures interp (ghost_pts_to_sl r p v) m)
= Mem.elim_h_exists (ghost_pts_to_sl r p) m;
ghost_pts_to_witinv r p | {
"checked_file": "/",
"dependencies": [
"Steel.Memory.fsti.checked",
"Steel.HigherReference.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Reference.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "Steel.HigherReference",
"short_module": "H"
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | r: Steel.Reference.ghost_ref a -> p: Steel.FractionalPermission.perm -> v: FStar.Ghost.erased a
-> Steel.Effect.Atomic.SteelGhost Prims.unit | Steel.Effect.Atomic.SteelGhost | [] | [] | [
"Steel.Memory.inames",
"Steel.Reference.ghost_ref",
"Steel.FractionalPermission.perm",
"FStar.Ghost.erased",
"Steel.Effect.Atomic.change_slprop_2",
"Steel.Reference.ghost_pts_to",
"FStar.Ghost.reveal",
"Steel.Reference.ghost_vptrp",
"Steel.Reference.intro_ghost_vptr_lemma",
"Prims.unit",
"Steel.Effect.Common.vprop",
"Steel.Effect.Common.rmem",
"Prims.l_True",
"Prims.eq2",
"Steel.Effect.Common.normal",
"Steel.Effect.Common.t_of"
] | [] | false | true | false | false | false | let intro_ghost_vptr (#a: Type) (#opened: inames) (r: ghost_ref a) (p: perm) (v: erased a)
: SteelGhost unit
opened
(ghost_pts_to r p v)
(fun _ -> ghost_vptrp r p)
(requires fun _ -> True)
(ensures fun _ _ h1 -> h1 (ghost_vptrp r p) == reveal v) =
| change_slprop_2 (ghost_pts_to r p v) (ghost_vptrp r p) v (intro_ghost_vptr_lemma r p v) | false |
Steel.Reference.fst | Steel.Reference.ghost_write_pt | val ghost_write_pt (#a:Type) (#u:_) (#v:erased a) (r:ghost_ref a) (x:erased a)
: SteelGhostT unit u
(ghost_pts_to r full_perm v)
(fun _ -> ghost_pts_to r full_perm x) | val ghost_write_pt (#a:Type) (#u:_) (#v:erased a) (r:ghost_ref a) (x:erased a)
: SteelGhostT unit u
(ghost_pts_to r full_perm v)
(fun _ -> ghost_pts_to r full_perm x) | let ghost_write_pt (#a:Type) (#u:_) (#v:erased a) (r:ghost_ref a) (x:erased a)
: SteelGhostT unit u
(ghost_pts_to r full_perm v)
(fun _ -> ghost_pts_to r full_perm x)
= H.ghost_write r (raise_erased x) | {
"file_name": "lib/steel/Steel.Reference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 36,
"end_line": 444,
"start_col": 0,
"start_line": 440
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.Reference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module Mem = Steel.Memory
module H = Steel.HigherReference
module U = FStar.Universe
#set-options "--ide_id_info_off"
let ref a = H.ref (U.raise_t a)
let null #a = H.null #(U.raise_t a)
let is_null #a r = H.is_null #(U.raise_t a) r
let pts_to_sl r p v = H.pts_to_sl r p (U.raise_val v)
val raise_val_inj (#a:Type) (x y:a) : Lemma
(requires U.raise_val x == U.raise_val y)
(ensures x == y)
let raise_val_inj x y =
U.downgrade_val_raise_val x;
U.downgrade_val_raise_val y
let pts_to_ref_injective
(#a: Type u#0)
(r: ref a)
(p0 p1:perm)
(v0 v1:a)
(m:mem)
: Lemma
(requires
interp (pts_to_sl r p0 v0 `Mem.star` pts_to_sl r p1 v1) m)
(ensures v0 == v1)
= let v0' = U.raise_val v0 in
let v1' = U.raise_val v1 in
H.pts_to_ref_injective r p0 p1 v0' v1' m;
raise_val_inj v0 v1
let pts_to_not_null (#a:Type u#0)
(x:ref a)
(p:perm)
(v:a)
(m:mem)
: Lemma (requires interp (pts_to_sl x p v) m)
(ensures x =!= null)
= let v = U.raise_val v in
H.pts_to_not_null #(U.raise_t a) x p v m
// let pts_to_not_null' (#a:Type u#0)
// (x:ref a)
// (p:perm)
// (v: erased a)
// (m:mem)
// (m1:mem{disjoint m m1})
// : Lemma (requires interp (pts_to_sl x p v) m)
// (ensures interp (pts_to_sl x p v) (Mem.join m m1))
// = ()
let pts_to_witinv (#a:Type) (r:ref a) (p:perm) : Lemma (is_witness_invariant (pts_to_sl r p)) =
let aux (x y : a) (m:mem)
: Lemma (requires (interp (pts_to_sl r p x) m /\ interp (pts_to_sl r p y) m))
(ensures (x == y))
= H.pts_to_witinv r p;
raise_val_inj x y
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
let pts_to_injective_eq #a #opened #p0 #p1 #v0 #v1 r =
extract_info_raw (pts_to r p0 v0 `star` pts_to r p1 v1) (v0 == v1)
(fun m -> pts_to_ref_injective r p0 p1 v0 v1 m);
rewrite_slprop (pts_to r p1 v1) (pts_to r p1 v0) (fun _ -> ())
let pts_to_perm
r
= H.pts_to_perm r
let alloc_pt x =
let r = H.alloc (U.raise_val x) in
rewrite_slprop (H.pts_to r full_perm (U.raise_val x)) (pts_to r full_perm x) (fun _ -> ());
return r
let read_pt #a #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
let x = H.read r in
let v':a = U.downgrade_val x in
rewrite_slprop (H.pts_to r p (hide x)) (pts_to r p v') (fun _ -> ());
return v'
let read_refine_pt #a #p q r =
Classical.forall_intro_2 reveal_equiv;
lift_exists (fun (v:a) -> pts_to r p v `star` q v);
exists_cong (fun (v:U.raise_t a) -> pts_to r p (U.downgrade_val v) `star` q (U.downgrade_val v))
(fun (v:U.raise_t a) -> H.pts_to r p v `star` U.lift_dom q v);
let x = H.read_refine (U.lift_dom q) r in
rewrite_slprop
(H.pts_to r p (hide x) `star` U.lift_dom q x)
(pts_to r p (U.downgrade_val x) `star` q (U.downgrade_val x)) (fun _ -> ());
return (U.downgrade_val x)
let write_pt #a #v r x =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
let x' = U.raise_val x in
H.write r x';
rewrite_slprop (H.pts_to r full_perm (hide x')) (pts_to r full_perm x) (fun _ -> ())
let free_pt #a #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
H.free r
let share_gen_pt #a #uses #p #v r p1 p2 =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
H.share_gen r p1 p2;
rewrite_slprop (H.pts_to r p1 v') (pts_to r p1 v) (fun _ -> ());
rewrite_slprop (H.pts_to r p2 v') (pts_to r p2 v) (fun _ -> ())
let share_pt #a #uses #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
H.share r;
rewrite_slprop (H.pts_to r (half_perm p) v') (pts_to r (half_perm p) v) (fun _ -> ());
rewrite_slprop (H.pts_to r (half_perm p) v') (pts_to r (half_perm p) v) (fun _ -> ())
let hide_raise_reveal (#a:Type) (v0:erased a) (v1:erased a)
: Lemma (hide (U.raise_val (reveal v0)) == hide (U.raise_val (reveal v1)) <==>
v0 == v1)
[SMTPat (hide (U.raise_val (reveal v0)));
SMTPat (hide (U.raise_val (reveal v1)))]
= let u0 = hide (U.raise_val (reveal v0)) in
let u1 = hide (U.raise_val (reveal v1)) in
assert (U.downgrade_val (U.raise_val (reveal v0)) == U.downgrade_val (U.raise_val (reveal v1)) <==>
v0 == v1)
let gather_pt #a #uses #p0 #p1 #v0 #v1 r =
let v0' = Ghost.hide (U.raise_val (Ghost.reveal v0)) in
let v1' = Ghost.hide (U.raise_val (Ghost.reveal v1)) in
rewrite_slprop (pts_to r p0 v0) (H.pts_to r p0 v0') (fun _ -> ());
rewrite_slprop (pts_to r p1 v1) (H.pts_to r p1 v1') (fun _ -> ());
let (u:unit{v0' == v1'}) = H.gather #_ #_ #p0 #p1 #v0' #v1' r in
rewrite_slprop (H.pts_to r (sum_perm p0 p1) v0') (pts_to r (sum_perm p0 p1) v0) (fun _ -> ());
u
let raise_equiv (#t:Type) (x y:t)
: Lemma (U.raise_val x == U.raise_val y <==>
x == y)
= assert (U.downgrade_val (U.raise_val x) == x);
assert (U.downgrade_val (U.raise_val y) == y)
let downgrade_equiv (#t:Type) (x y:U.raise_t t)
: Lemma (U.downgrade_val x == U.downgrade_val y <==>
x == y)
= assert (U.raise_val (U.downgrade_val x) == x);
assert (U.raise_val (U.downgrade_val y) == y)
let lift_eq (#t:eqtype) (x y:U.raise_t t)
: b:bool{b <==> x==y}
= downgrade_equiv x y; U.downgrade_val x = U.downgrade_val y
let cas_action (#t:eqtype)
(#uses:inames)
(r:ref t)
(v:Ghost.erased t)
(v_old:t)
(v_new:t)
(frame:slprop)
: MstTot (b:bool{b <==> (Ghost.reveal v == v_old)})
uses
(pts_to_sl r full_perm v)
(fun b -> if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v)
frame
(fun _ -> True)
(fun _ _ _ -> True)
= let hv = (Ghost.hide (U.raise_val (Ghost.reveal v))) in
let b = H.cas_action #(U.raise_t t)
(lift_eq #t)
#uses
r
hv
(U.raise_val v_old)
(U.raise_val v_new)
frame
in
assert (b <==> (Ghost.reveal hv == U.raise_val v_old));
assert (b <==> U.raise_val (Ghost.reveal v) == U.raise_val v_old);
raise_equiv (Ghost.reveal v) v_old;
b
let atomic_read_pt_u32 #_ #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
let x = H.atomic_read r in
let v':U32.t = U.downgrade_val x in
rewrite_slprop (H.pts_to r p (hide x)) (pts_to r p v') (fun _ -> ());
return v'
let atomic_write_pt_u32 #_ #v r x =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
let x' = U.raise_val x in
H.atomic_write r x';
rewrite_slprop (H.pts_to r full_perm (hide x')) (pts_to r full_perm x) (fun _ -> ())
let cas_pt_u32 #uses r v v_old v_new =
let b = as_atomic_action (cas_action #U32.t #uses r v v_old v_new) in
rewrite_slprop (to_vprop (if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v))
(if b then pts_to r full_perm v_new else pts_to r full_perm v)
(fun _ -> ());
return b
let cas_pt_bool #uses r v v_old v_new =
let b = as_atomic_action (cas_action #bool #uses r v v_old v_new) in
rewrite_slprop (to_vprop (if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v))
(if b then pts_to r full_perm v_new else pts_to r full_perm v)
(fun _ -> ());
return b
(* Library for references with fractional permissions.
Permissions need to be an index of the vprop ptr.
It cannot be part of a selector, as it is not invariant when joining with a disjoint memory
Using the value of the ref as a selector is ok because refs with fractional permissions
all share the same value.
Refs on PCM are more complicated, and likely not usable with selectors
*)
let ptrp r p = Mem.h_exists (pts_to_sl r p)
val ptr_sel' (#a:Type0) (r: ref a) (p: perm) : selector' a (ptrp r p)
let ptr_sel' #a r p = fun h -> id_elim_exists #a (pts_to_sl r p) h
let ptr_sel_depends_only_on (#a:Type0) (r:ref a)
(p: perm)
(m0:Mem.hmem (ptrp r p)) (m1:mem{disjoint m0 m1})
: Lemma (ptr_sel' r p m0 == ptr_sel' r p (Mem.join m0 m1))
= let x = reveal (id_elim_exists #a (pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (pts_to_sl r p) (Mem.join m0 m1)) in
pts_to_witinv r p;
elim_wi (pts_to_sl r p) x y (Mem.join m0 m1)
let ptr_sel_depends_only_on_core (#a:Type0) (r:ref a)
(p: perm) (m0:Mem.hmem (ptrp r p))
: Lemma (ptr_sel' r p m0 == ptr_sel' r p (core_mem m0))
= let x = reveal (id_elim_exists #a (pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (pts_to_sl r p) (core_mem m0)) in
pts_to_witinv r p;
elim_wi (pts_to_sl r p) x y (core_mem m0)
let ptrp_sel r p =
Classical.forall_intro_2 (ptr_sel_depends_only_on r p);
Classical.forall_intro (ptr_sel_depends_only_on_core r p);
ptr_sel' r p
let ptrp_sel_interp #a r p m = pts_to_witinv r p
let intro_ptrp_interp r p v m = intro_h_exists (reveal v) (pts_to_sl r p) m
let intro_vptr_lemma (#a:Type) (r:ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (pts_to_sl r p v) m)
(ensures interp (ptrp r p) m /\ ptrp_sel r p m == reveal v)
= Mem.intro_h_exists (reveal v) (pts_to_sl r p) m;
pts_to_witinv r p
let elim_vptr_lemma (#a:Type) (r:ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (ptrp r p) m /\ ptrp_sel r p m == reveal v)
(ensures interp (pts_to_sl r p v) m)
= Mem.elim_h_exists (pts_to_sl r p) m;
pts_to_witinv r p
let intro_vptr (#a:Type) (#opened:inames) (r:ref a) (p: perm) (v:erased a)
: SteelGhost unit opened (pts_to r p v) (fun _ -> vptrp r p)
(requires fun _ -> True)
(ensures fun _ _ h1 -> h1 (vptrp r p) == reveal v)
= change_slprop_2 (pts_to r p v) (vptrp r p) v (intro_vptr_lemma r p v)
let elim_vptr (#a:Type) (#opened:inames) (r:ref a) (p: perm)
: SteelGhost (erased a) opened (vptrp r p) (fun v -> pts_to r p v)
(requires fun _ -> True)
(ensures fun h0 v _ -> reveal v == h0 (vptrp r p))
= let v = gget (vptrp r p) in
change_slprop (vptrp r p) (pts_to r p v) v () (elim_vptr_lemma r p v);
v
let malloc x =
let r = alloc_pt x in
intro_vptr r _ (hide x);
return r
let free r =
let _ = elim_vptr r _ in
free_pt r
let readp r _ =
let _ = elim_vptr r _ in
let x = read_pt r in
intro_vptr r _ x;
return x
let write r x =
let _ = elim_vptr r _ in
write_pt r x;
intro_vptr r _ x
let share #a #_ #p r =
let x = elim_vptr r p in
share_pt r;
intro_vptr r _ x;
intro_vptr r _ x
let gather_gen #a #_ r p0 p1 =
let x1 = elim_vptr r p1 in
let x0 = elim_vptr r p0 in
gather_pt #_ #_ #p0 #p1 #x0 #x1 r;
intro_vptr r (sum_perm p0 p1) x0;
sum_perm p0 p1
let gather (#a: Type0) (#uses: _) (#p: perm) (r: ref a)
: SteelGhost unit uses
(vptrp r (half_perm p) `star` vptrp r (half_perm p))
(fun _ -> vptrp r p)
(fun _ -> True)
(fun h _ h' ->
h' (vptrp r p) == h (vptrp r (half_perm p))
)
= let _ = gather_gen r _ _ in
change_equal_slprop
(vptrp r _)
(vptrp r p)
(*** Lemmas on references *)
let vptrp_not_null
#opened #a r
p
= change_slprop_rel
(vptrp r p)
(vptrp r p)
(fun x y -> x == y /\ is_null r == false)
(fun m -> pts_to_not_null r p (ptrp_sel r p m) m)
(*** Ghost pointers *)
(*** GHOST REFERENCES ***)
let ghost_ref a = H.ghost_ref (U.raise_t a)
let dummy_ghost_ref a =
H.reveal_ghost_ref (U.raise_t a);
coerce_eq () (Ghost.hide (H.null #(U.raise_t a)))
[@__reduce__]
let ghost_pts_to_sl #a r p x = H.ghost_pts_to_sl #(U.raise_t a) r p (U.raise_val x)
let ghost_pts_to_witinv (#a:Type) (r:ghost_ref a) (p:perm) : Lemma (is_witness_invariant (ghost_pts_to_sl r p)) =
let aux (x y : a) (m:mem)
: Lemma (requires (interp (ghost_pts_to_sl r p x) m /\ interp (ghost_pts_to_sl r p y) m))
(ensures (x == y))
= H.ghost_pts_to_witinv r p;
raise_val_inj x y
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
[@@__reduce__]
let raise_erased (#a:Type0) (x:erased a)
: erased (U.raise_t u#0 u#1 a)
= Ghost.hide (U.raise_val (Ghost.reveal x))
let ghost_alloc_pt (#a:Type) (#u:_) (x:erased a)
: SteelGhostT (ghost_ref a) u
emp
(fun r -> ghost_pts_to r full_perm x)
= H.ghost_alloc (raise_erased x)
let ghost_free_pt r = H.ghost_free r
let ghost_share_gen_pt
#_ #_ #_ #x r p1 p2
= H.ghost_share_gen #_ #_ #_ #(raise_erased x) r p1 p2
let ghost_share_pt (#a:Type) (#u:_)
(#p:perm)
(#x:erased a)
(r:ghost_ref a)
= H.ghost_share #_ #_ #_ #(raise_erased x) r
let ghost_gather_pt (#a:Type) (#u:_)
(#p0 #p1:perm)
(#x0 #x1:erased a)
(r:ghost_ref a)
: SteelGhost unit u
(ghost_pts_to r p0 x0 `star`
ghost_pts_to r p1 x1)
(fun _ -> ghost_pts_to r (sum_perm p0 p1) x0)
(requires fun _ -> true)
(ensures fun _ _ _ -> x0 == x1)
= H.ghost_gather r
let ghost_pts_to_injective_eq (#a:_) (#u:_) (#p #q:_) (r:ghost_ref a) (v0 v1:Ghost.erased a)
: SteelGhost unit u
(ghost_pts_to r p v0 `star` ghost_pts_to r q v1)
(fun _ -> ghost_pts_to r p v0 `star` ghost_pts_to r q v0)
(requires fun _ -> True)
(ensures fun _ _ _ -> v0 == v1)
= H.ghost_pts_to_injective_eq #_ #_ #p #q r (raise_erased v0) (raise_erased v1)
let ghost_pts_to_perm r = H.ghost_pts_to_perm r
let ghost_read_pt #a #u #p #v r =
let x = H.ghost_read r in
let x' = hide (U.downgrade_val (reveal x)) in
rewrite_slprop (H.ghost_pts_to r p x) (ghost_pts_to r p x') (fun _ -> ());
x' | {
"checked_file": "/",
"dependencies": [
"Steel.Memory.fsti.checked",
"Steel.HigherReference.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Reference.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "Steel.HigherReference",
"short_module": "H"
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | r: Steel.Reference.ghost_ref a -> x: FStar.Ghost.erased a
-> Steel.Effect.Atomic.SteelGhostT Prims.unit | Steel.Effect.Atomic.SteelGhostT | [] | [] | [
"Steel.Memory.inames",
"FStar.Ghost.erased",
"Steel.Reference.ghost_ref",
"Steel.HigherReference.ghost_write",
"FStar.Universe.raise_t",
"FStar.Ghost.hide",
"FStar.Universe.raise_val",
"FStar.Ghost.reveal",
"Steel.Reference.raise_erased",
"Prims.unit",
"Steel.Reference.ghost_pts_to",
"Steel.FractionalPermission.full_perm",
"Steel.Effect.Common.vprop"
] | [] | false | true | false | false | false | let ghost_write_pt (#a: Type) (#u: _) (#v: erased a) (r: ghost_ref a) (x: erased a)
: SteelGhostT unit u (ghost_pts_to r full_perm v) (fun _ -> ghost_pts_to r full_perm x) =
| H.ghost_write r (raise_erased x) | false |
Steel.Reference.fst | Steel.Reference.ghost_gather_pt | val ghost_gather_pt (#a:Type) (#u:_)
(#p0 #p1:perm)
(#x0 #x1:erased a)
(r:ghost_ref a)
: SteelGhost unit u
(ghost_pts_to r p0 x0 `star`
ghost_pts_to r p1 x1)
(fun _ -> ghost_pts_to r (sum_perm p0 p1) x0)
(requires fun _ -> true)
(ensures fun _ _ _ -> x0 == x1) | val ghost_gather_pt (#a:Type) (#u:_)
(#p0 #p1:perm)
(#x0 #x1:erased a)
(r:ghost_ref a)
: SteelGhost unit u
(ghost_pts_to r p0 x0 `star`
ghost_pts_to r p1 x1)
(fun _ -> ghost_pts_to r (sum_perm p0 p1) x0)
(requires fun _ -> true)
(ensures fun _ _ _ -> x0 == x1) | let ghost_gather_pt (#a:Type) (#u:_)
(#p0 #p1:perm)
(#x0 #x1:erased a)
(r:ghost_ref a)
: SteelGhost unit u
(ghost_pts_to r p0 x0 `star`
ghost_pts_to r p1 x1)
(fun _ -> ghost_pts_to r (sum_perm p0 p1) x0)
(requires fun _ -> true)
(ensures fun _ _ _ -> x0 == x1)
= H.ghost_gather r | {
"file_name": "lib/steel/Steel.Reference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 20,
"end_line": 422,
"start_col": 0,
"start_line": 412
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.Reference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module Mem = Steel.Memory
module H = Steel.HigherReference
module U = FStar.Universe
#set-options "--ide_id_info_off"
let ref a = H.ref (U.raise_t a)
let null #a = H.null #(U.raise_t a)
let is_null #a r = H.is_null #(U.raise_t a) r
let pts_to_sl r p v = H.pts_to_sl r p (U.raise_val v)
val raise_val_inj (#a:Type) (x y:a) : Lemma
(requires U.raise_val x == U.raise_val y)
(ensures x == y)
let raise_val_inj x y =
U.downgrade_val_raise_val x;
U.downgrade_val_raise_val y
let pts_to_ref_injective
(#a: Type u#0)
(r: ref a)
(p0 p1:perm)
(v0 v1:a)
(m:mem)
: Lemma
(requires
interp (pts_to_sl r p0 v0 `Mem.star` pts_to_sl r p1 v1) m)
(ensures v0 == v1)
= let v0' = U.raise_val v0 in
let v1' = U.raise_val v1 in
H.pts_to_ref_injective r p0 p1 v0' v1' m;
raise_val_inj v0 v1
let pts_to_not_null (#a:Type u#0)
(x:ref a)
(p:perm)
(v:a)
(m:mem)
: Lemma (requires interp (pts_to_sl x p v) m)
(ensures x =!= null)
= let v = U.raise_val v in
H.pts_to_not_null #(U.raise_t a) x p v m
// let pts_to_not_null' (#a:Type u#0)
// (x:ref a)
// (p:perm)
// (v: erased a)
// (m:mem)
// (m1:mem{disjoint m m1})
// : Lemma (requires interp (pts_to_sl x p v) m)
// (ensures interp (pts_to_sl x p v) (Mem.join m m1))
// = ()
let pts_to_witinv (#a:Type) (r:ref a) (p:perm) : Lemma (is_witness_invariant (pts_to_sl r p)) =
let aux (x y : a) (m:mem)
: Lemma (requires (interp (pts_to_sl r p x) m /\ interp (pts_to_sl r p y) m))
(ensures (x == y))
= H.pts_to_witinv r p;
raise_val_inj x y
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
let pts_to_injective_eq #a #opened #p0 #p1 #v0 #v1 r =
extract_info_raw (pts_to r p0 v0 `star` pts_to r p1 v1) (v0 == v1)
(fun m -> pts_to_ref_injective r p0 p1 v0 v1 m);
rewrite_slprop (pts_to r p1 v1) (pts_to r p1 v0) (fun _ -> ())
let pts_to_perm
r
= H.pts_to_perm r
let alloc_pt x =
let r = H.alloc (U.raise_val x) in
rewrite_slprop (H.pts_to r full_perm (U.raise_val x)) (pts_to r full_perm x) (fun _ -> ());
return r
let read_pt #a #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
let x = H.read r in
let v':a = U.downgrade_val x in
rewrite_slprop (H.pts_to r p (hide x)) (pts_to r p v') (fun _ -> ());
return v'
let read_refine_pt #a #p q r =
Classical.forall_intro_2 reveal_equiv;
lift_exists (fun (v:a) -> pts_to r p v `star` q v);
exists_cong (fun (v:U.raise_t a) -> pts_to r p (U.downgrade_val v) `star` q (U.downgrade_val v))
(fun (v:U.raise_t a) -> H.pts_to r p v `star` U.lift_dom q v);
let x = H.read_refine (U.lift_dom q) r in
rewrite_slprop
(H.pts_to r p (hide x) `star` U.lift_dom q x)
(pts_to r p (U.downgrade_val x) `star` q (U.downgrade_val x)) (fun _ -> ());
return (U.downgrade_val x)
let write_pt #a #v r x =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
let x' = U.raise_val x in
H.write r x';
rewrite_slprop (H.pts_to r full_perm (hide x')) (pts_to r full_perm x) (fun _ -> ())
let free_pt #a #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
H.free r
let share_gen_pt #a #uses #p #v r p1 p2 =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
H.share_gen r p1 p2;
rewrite_slprop (H.pts_to r p1 v') (pts_to r p1 v) (fun _ -> ());
rewrite_slprop (H.pts_to r p2 v') (pts_to r p2 v) (fun _ -> ())
let share_pt #a #uses #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
H.share r;
rewrite_slprop (H.pts_to r (half_perm p) v') (pts_to r (half_perm p) v) (fun _ -> ());
rewrite_slprop (H.pts_to r (half_perm p) v') (pts_to r (half_perm p) v) (fun _ -> ())
let hide_raise_reveal (#a:Type) (v0:erased a) (v1:erased a)
: Lemma (hide (U.raise_val (reveal v0)) == hide (U.raise_val (reveal v1)) <==>
v0 == v1)
[SMTPat (hide (U.raise_val (reveal v0)));
SMTPat (hide (U.raise_val (reveal v1)))]
= let u0 = hide (U.raise_val (reveal v0)) in
let u1 = hide (U.raise_val (reveal v1)) in
assert (U.downgrade_val (U.raise_val (reveal v0)) == U.downgrade_val (U.raise_val (reveal v1)) <==>
v0 == v1)
let gather_pt #a #uses #p0 #p1 #v0 #v1 r =
let v0' = Ghost.hide (U.raise_val (Ghost.reveal v0)) in
let v1' = Ghost.hide (U.raise_val (Ghost.reveal v1)) in
rewrite_slprop (pts_to r p0 v0) (H.pts_to r p0 v0') (fun _ -> ());
rewrite_slprop (pts_to r p1 v1) (H.pts_to r p1 v1') (fun _ -> ());
let (u:unit{v0' == v1'}) = H.gather #_ #_ #p0 #p1 #v0' #v1' r in
rewrite_slprop (H.pts_to r (sum_perm p0 p1) v0') (pts_to r (sum_perm p0 p1) v0) (fun _ -> ());
u
let raise_equiv (#t:Type) (x y:t)
: Lemma (U.raise_val x == U.raise_val y <==>
x == y)
= assert (U.downgrade_val (U.raise_val x) == x);
assert (U.downgrade_val (U.raise_val y) == y)
let downgrade_equiv (#t:Type) (x y:U.raise_t t)
: Lemma (U.downgrade_val x == U.downgrade_val y <==>
x == y)
= assert (U.raise_val (U.downgrade_val x) == x);
assert (U.raise_val (U.downgrade_val y) == y)
let lift_eq (#t:eqtype) (x y:U.raise_t t)
: b:bool{b <==> x==y}
= downgrade_equiv x y; U.downgrade_val x = U.downgrade_val y
let cas_action (#t:eqtype)
(#uses:inames)
(r:ref t)
(v:Ghost.erased t)
(v_old:t)
(v_new:t)
(frame:slprop)
: MstTot (b:bool{b <==> (Ghost.reveal v == v_old)})
uses
(pts_to_sl r full_perm v)
(fun b -> if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v)
frame
(fun _ -> True)
(fun _ _ _ -> True)
= let hv = (Ghost.hide (U.raise_val (Ghost.reveal v))) in
let b = H.cas_action #(U.raise_t t)
(lift_eq #t)
#uses
r
hv
(U.raise_val v_old)
(U.raise_val v_new)
frame
in
assert (b <==> (Ghost.reveal hv == U.raise_val v_old));
assert (b <==> U.raise_val (Ghost.reveal v) == U.raise_val v_old);
raise_equiv (Ghost.reveal v) v_old;
b
let atomic_read_pt_u32 #_ #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
let x = H.atomic_read r in
let v':U32.t = U.downgrade_val x in
rewrite_slprop (H.pts_to r p (hide x)) (pts_to r p v') (fun _ -> ());
return v'
let atomic_write_pt_u32 #_ #v r x =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
let x' = U.raise_val x in
H.atomic_write r x';
rewrite_slprop (H.pts_to r full_perm (hide x')) (pts_to r full_perm x) (fun _ -> ())
let cas_pt_u32 #uses r v v_old v_new =
let b = as_atomic_action (cas_action #U32.t #uses r v v_old v_new) in
rewrite_slprop (to_vprop (if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v))
(if b then pts_to r full_perm v_new else pts_to r full_perm v)
(fun _ -> ());
return b
let cas_pt_bool #uses r v v_old v_new =
let b = as_atomic_action (cas_action #bool #uses r v v_old v_new) in
rewrite_slprop (to_vprop (if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v))
(if b then pts_to r full_perm v_new else pts_to r full_perm v)
(fun _ -> ());
return b
(* Library for references with fractional permissions.
Permissions need to be an index of the vprop ptr.
It cannot be part of a selector, as it is not invariant when joining with a disjoint memory
Using the value of the ref as a selector is ok because refs with fractional permissions
all share the same value.
Refs on PCM are more complicated, and likely not usable with selectors
*)
let ptrp r p = Mem.h_exists (pts_to_sl r p)
val ptr_sel' (#a:Type0) (r: ref a) (p: perm) : selector' a (ptrp r p)
let ptr_sel' #a r p = fun h -> id_elim_exists #a (pts_to_sl r p) h
let ptr_sel_depends_only_on (#a:Type0) (r:ref a)
(p: perm)
(m0:Mem.hmem (ptrp r p)) (m1:mem{disjoint m0 m1})
: Lemma (ptr_sel' r p m0 == ptr_sel' r p (Mem.join m0 m1))
= let x = reveal (id_elim_exists #a (pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (pts_to_sl r p) (Mem.join m0 m1)) in
pts_to_witinv r p;
elim_wi (pts_to_sl r p) x y (Mem.join m0 m1)
let ptr_sel_depends_only_on_core (#a:Type0) (r:ref a)
(p: perm) (m0:Mem.hmem (ptrp r p))
: Lemma (ptr_sel' r p m0 == ptr_sel' r p (core_mem m0))
= let x = reveal (id_elim_exists #a (pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (pts_to_sl r p) (core_mem m0)) in
pts_to_witinv r p;
elim_wi (pts_to_sl r p) x y (core_mem m0)
let ptrp_sel r p =
Classical.forall_intro_2 (ptr_sel_depends_only_on r p);
Classical.forall_intro (ptr_sel_depends_only_on_core r p);
ptr_sel' r p
let ptrp_sel_interp #a r p m = pts_to_witinv r p
let intro_ptrp_interp r p v m = intro_h_exists (reveal v) (pts_to_sl r p) m
let intro_vptr_lemma (#a:Type) (r:ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (pts_to_sl r p v) m)
(ensures interp (ptrp r p) m /\ ptrp_sel r p m == reveal v)
= Mem.intro_h_exists (reveal v) (pts_to_sl r p) m;
pts_to_witinv r p
let elim_vptr_lemma (#a:Type) (r:ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (ptrp r p) m /\ ptrp_sel r p m == reveal v)
(ensures interp (pts_to_sl r p v) m)
= Mem.elim_h_exists (pts_to_sl r p) m;
pts_to_witinv r p
let intro_vptr (#a:Type) (#opened:inames) (r:ref a) (p: perm) (v:erased a)
: SteelGhost unit opened (pts_to r p v) (fun _ -> vptrp r p)
(requires fun _ -> True)
(ensures fun _ _ h1 -> h1 (vptrp r p) == reveal v)
= change_slprop_2 (pts_to r p v) (vptrp r p) v (intro_vptr_lemma r p v)
let elim_vptr (#a:Type) (#opened:inames) (r:ref a) (p: perm)
: SteelGhost (erased a) opened (vptrp r p) (fun v -> pts_to r p v)
(requires fun _ -> True)
(ensures fun h0 v _ -> reveal v == h0 (vptrp r p))
= let v = gget (vptrp r p) in
change_slprop (vptrp r p) (pts_to r p v) v () (elim_vptr_lemma r p v);
v
let malloc x =
let r = alloc_pt x in
intro_vptr r _ (hide x);
return r
let free r =
let _ = elim_vptr r _ in
free_pt r
let readp r _ =
let _ = elim_vptr r _ in
let x = read_pt r in
intro_vptr r _ x;
return x
let write r x =
let _ = elim_vptr r _ in
write_pt r x;
intro_vptr r _ x
let share #a #_ #p r =
let x = elim_vptr r p in
share_pt r;
intro_vptr r _ x;
intro_vptr r _ x
let gather_gen #a #_ r p0 p1 =
let x1 = elim_vptr r p1 in
let x0 = elim_vptr r p0 in
gather_pt #_ #_ #p0 #p1 #x0 #x1 r;
intro_vptr r (sum_perm p0 p1) x0;
sum_perm p0 p1
let gather (#a: Type0) (#uses: _) (#p: perm) (r: ref a)
: SteelGhost unit uses
(vptrp r (half_perm p) `star` vptrp r (half_perm p))
(fun _ -> vptrp r p)
(fun _ -> True)
(fun h _ h' ->
h' (vptrp r p) == h (vptrp r (half_perm p))
)
= let _ = gather_gen r _ _ in
change_equal_slprop
(vptrp r _)
(vptrp r p)
(*** Lemmas on references *)
let vptrp_not_null
#opened #a r
p
= change_slprop_rel
(vptrp r p)
(vptrp r p)
(fun x y -> x == y /\ is_null r == false)
(fun m -> pts_to_not_null r p (ptrp_sel r p m) m)
(*** Ghost pointers *)
(*** GHOST REFERENCES ***)
let ghost_ref a = H.ghost_ref (U.raise_t a)
let dummy_ghost_ref a =
H.reveal_ghost_ref (U.raise_t a);
coerce_eq () (Ghost.hide (H.null #(U.raise_t a)))
[@__reduce__]
let ghost_pts_to_sl #a r p x = H.ghost_pts_to_sl #(U.raise_t a) r p (U.raise_val x)
let ghost_pts_to_witinv (#a:Type) (r:ghost_ref a) (p:perm) : Lemma (is_witness_invariant (ghost_pts_to_sl r p)) =
let aux (x y : a) (m:mem)
: Lemma (requires (interp (ghost_pts_to_sl r p x) m /\ interp (ghost_pts_to_sl r p y) m))
(ensures (x == y))
= H.ghost_pts_to_witinv r p;
raise_val_inj x y
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
[@@__reduce__]
let raise_erased (#a:Type0) (x:erased a)
: erased (U.raise_t u#0 u#1 a)
= Ghost.hide (U.raise_val (Ghost.reveal x))
let ghost_alloc_pt (#a:Type) (#u:_) (x:erased a)
: SteelGhostT (ghost_ref a) u
emp
(fun r -> ghost_pts_to r full_perm x)
= H.ghost_alloc (raise_erased x)
let ghost_free_pt r = H.ghost_free r
let ghost_share_gen_pt
#_ #_ #_ #x r p1 p2
= H.ghost_share_gen #_ #_ #_ #(raise_erased x) r p1 p2
let ghost_share_pt (#a:Type) (#u:_)
(#p:perm)
(#x:erased a)
(r:ghost_ref a)
= H.ghost_share #_ #_ #_ #(raise_erased x) r | {
"checked_file": "/",
"dependencies": [
"Steel.Memory.fsti.checked",
"Steel.HigherReference.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Reference.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "Steel.HigherReference",
"short_module": "H"
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | r: Steel.Reference.ghost_ref a -> Steel.Effect.Atomic.SteelGhost Prims.unit | Steel.Effect.Atomic.SteelGhost | [] | [] | [
"Steel.Memory.inames",
"Steel.FractionalPermission.perm",
"FStar.Ghost.erased",
"Steel.Reference.ghost_ref",
"Steel.HigherReference.ghost_gather",
"FStar.Universe.raise_t",
"FStar.Ghost.hide",
"FStar.Universe.raise_val",
"FStar.Ghost.reveal",
"Prims.unit",
"Steel.Effect.Common.star",
"Steel.Reference.ghost_pts_to",
"Steel.FractionalPermission.sum_perm",
"Steel.Effect.Common.vprop",
"Steel.Effect.Common.rmem",
"Prims.b2t",
"Prims.eq2"
] | [] | false | true | false | false | false | let ghost_gather_pt (#a: Type) (#u: _) (#p0 #p1: perm) (#x0 #x1: erased a) (r: ghost_ref a)
: SteelGhost unit
u
((ghost_pts_to r p0 x0) `star` (ghost_pts_to r p1 x1))
(fun _ -> ghost_pts_to r (sum_perm p0 p1) x0)
(requires fun _ -> true)
(ensures fun _ _ _ -> x0 == x1) =
| H.ghost_gather r | false |
Steel.Reference.fst | Steel.Reference.alloc_pt | val alloc_pt (#a:Type) (x:a)
: Steel (ref a) emp (fun r -> pts_to r full_perm x)
(requires fun _ -> True)
(ensures fun _ r _ -> not (is_null r)) | val alloc_pt (#a:Type) (x:a)
: Steel (ref a) emp (fun r -> pts_to r full_perm x)
(requires fun _ -> True)
(ensures fun _ r _ -> not (is_null r)) | let alloc_pt x =
let r = H.alloc (U.raise_val x) in
rewrite_slprop (H.pts_to r full_perm (U.raise_val x)) (pts_to r full_perm x) (fun _ -> ());
return r | {
"file_name": "lib/steel/Steel.Reference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 10,
"end_line": 102,
"start_col": 0,
"start_line": 99
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.Reference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module Mem = Steel.Memory
module H = Steel.HigherReference
module U = FStar.Universe
#set-options "--ide_id_info_off"
let ref a = H.ref (U.raise_t a)
let null #a = H.null #(U.raise_t a)
let is_null #a r = H.is_null #(U.raise_t a) r
let pts_to_sl r p v = H.pts_to_sl r p (U.raise_val v)
val raise_val_inj (#a:Type) (x y:a) : Lemma
(requires U.raise_val x == U.raise_val y)
(ensures x == y)
let raise_val_inj x y =
U.downgrade_val_raise_val x;
U.downgrade_val_raise_val y
let pts_to_ref_injective
(#a: Type u#0)
(r: ref a)
(p0 p1:perm)
(v0 v1:a)
(m:mem)
: Lemma
(requires
interp (pts_to_sl r p0 v0 `Mem.star` pts_to_sl r p1 v1) m)
(ensures v0 == v1)
= let v0' = U.raise_val v0 in
let v1' = U.raise_val v1 in
H.pts_to_ref_injective r p0 p1 v0' v1' m;
raise_val_inj v0 v1
let pts_to_not_null (#a:Type u#0)
(x:ref a)
(p:perm)
(v:a)
(m:mem)
: Lemma (requires interp (pts_to_sl x p v) m)
(ensures x =!= null)
= let v = U.raise_val v in
H.pts_to_not_null #(U.raise_t a) x p v m
// let pts_to_not_null' (#a:Type u#0)
// (x:ref a)
// (p:perm)
// (v: erased a)
// (m:mem)
// (m1:mem{disjoint m m1})
// : Lemma (requires interp (pts_to_sl x p v) m)
// (ensures interp (pts_to_sl x p v) (Mem.join m m1))
// = ()
let pts_to_witinv (#a:Type) (r:ref a) (p:perm) : Lemma (is_witness_invariant (pts_to_sl r p)) =
let aux (x y : a) (m:mem)
: Lemma (requires (interp (pts_to_sl r p x) m /\ interp (pts_to_sl r p y) m))
(ensures (x == y))
= H.pts_to_witinv r p;
raise_val_inj x y
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
let pts_to_injective_eq #a #opened #p0 #p1 #v0 #v1 r =
extract_info_raw (pts_to r p0 v0 `star` pts_to r p1 v1) (v0 == v1)
(fun m -> pts_to_ref_injective r p0 p1 v0 v1 m);
rewrite_slprop (pts_to r p1 v1) (pts_to r p1 v0) (fun _ -> ())
let pts_to_perm
r
= H.pts_to_perm r | {
"checked_file": "/",
"dependencies": [
"Steel.Memory.fsti.checked",
"Steel.HigherReference.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Reference.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "Steel.HigherReference",
"short_module": "H"
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | x: a -> Steel.Effect.Steel (Steel.Reference.ref a) | Steel.Effect.Steel | [] | [] | [
"Steel.Effect.Atomic.return",
"Steel.Reference.ref",
"FStar.Ghost.hide",
"FStar.Set.set",
"Steel.Memory.iname",
"FStar.Set.empty",
"Steel.Reference.pts_to",
"Steel.FractionalPermission.full_perm",
"Steel.Effect.Common.vprop",
"Prims.unit",
"Steel.Effect.Atomic.rewrite_slprop",
"Steel.HigherReference.pts_to",
"FStar.Universe.raise_t",
"FStar.Universe.raise_val",
"Steel.Memory.mem",
"Steel.HigherReference.ref",
"Steel.HigherReference.alloc"
] | [] | false | true | false | false | false | let alloc_pt x =
| let r = H.alloc (U.raise_val x) in
rewrite_slprop (H.pts_to r full_perm (U.raise_val x)) (pts_to r full_perm x) (fun _ -> ());
return r | false |
Steel.Reference.fst | Steel.Reference.gather | val gather (#a: Type0) (#uses: _) (#p: perm) (r: ref a)
: SteelGhost unit uses
(vptrp r (half_perm p) `star` vptrp r (half_perm p))
(fun _ -> vptrp r p)
(fun _ -> True)
(fun h _ h' ->
h' (vptrp r p) == h (vptrp r (half_perm p))
) | val gather (#a: Type0) (#uses: _) (#p: perm) (r: ref a)
: SteelGhost unit uses
(vptrp r (half_perm p) `star` vptrp r (half_perm p))
(fun _ -> vptrp r p)
(fun _ -> True)
(fun h _ h' ->
h' (vptrp r p) == h (vptrp r (half_perm p))
) | let gather (#a: Type0) (#uses: _) (#p: perm) (r: ref a)
: SteelGhost unit uses
(vptrp r (half_perm p) `star` vptrp r (half_perm p))
(fun _ -> vptrp r p)
(fun _ -> True)
(fun h _ h' ->
h' (vptrp r p) == h (vptrp r (half_perm p))
)
= let _ = gather_gen r _ _ in
change_equal_slprop
(vptrp r _)
(vptrp r p) | {
"file_name": "lib/steel/Steel.Reference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 17,
"end_line": 355,
"start_col": 0,
"start_line": 344
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.Reference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module Mem = Steel.Memory
module H = Steel.HigherReference
module U = FStar.Universe
#set-options "--ide_id_info_off"
let ref a = H.ref (U.raise_t a)
let null #a = H.null #(U.raise_t a)
let is_null #a r = H.is_null #(U.raise_t a) r
let pts_to_sl r p v = H.pts_to_sl r p (U.raise_val v)
val raise_val_inj (#a:Type) (x y:a) : Lemma
(requires U.raise_val x == U.raise_val y)
(ensures x == y)
let raise_val_inj x y =
U.downgrade_val_raise_val x;
U.downgrade_val_raise_val y
let pts_to_ref_injective
(#a: Type u#0)
(r: ref a)
(p0 p1:perm)
(v0 v1:a)
(m:mem)
: Lemma
(requires
interp (pts_to_sl r p0 v0 `Mem.star` pts_to_sl r p1 v1) m)
(ensures v0 == v1)
= let v0' = U.raise_val v0 in
let v1' = U.raise_val v1 in
H.pts_to_ref_injective r p0 p1 v0' v1' m;
raise_val_inj v0 v1
let pts_to_not_null (#a:Type u#0)
(x:ref a)
(p:perm)
(v:a)
(m:mem)
: Lemma (requires interp (pts_to_sl x p v) m)
(ensures x =!= null)
= let v = U.raise_val v in
H.pts_to_not_null #(U.raise_t a) x p v m
// let pts_to_not_null' (#a:Type u#0)
// (x:ref a)
// (p:perm)
// (v: erased a)
// (m:mem)
// (m1:mem{disjoint m m1})
// : Lemma (requires interp (pts_to_sl x p v) m)
// (ensures interp (pts_to_sl x p v) (Mem.join m m1))
// = ()
let pts_to_witinv (#a:Type) (r:ref a) (p:perm) : Lemma (is_witness_invariant (pts_to_sl r p)) =
let aux (x y : a) (m:mem)
: Lemma (requires (interp (pts_to_sl r p x) m /\ interp (pts_to_sl r p y) m))
(ensures (x == y))
= H.pts_to_witinv r p;
raise_val_inj x y
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
let pts_to_injective_eq #a #opened #p0 #p1 #v0 #v1 r =
extract_info_raw (pts_to r p0 v0 `star` pts_to r p1 v1) (v0 == v1)
(fun m -> pts_to_ref_injective r p0 p1 v0 v1 m);
rewrite_slprop (pts_to r p1 v1) (pts_to r p1 v0) (fun _ -> ())
let pts_to_perm
r
= H.pts_to_perm r
let alloc_pt x =
let r = H.alloc (U.raise_val x) in
rewrite_slprop (H.pts_to r full_perm (U.raise_val x)) (pts_to r full_perm x) (fun _ -> ());
return r
let read_pt #a #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
let x = H.read r in
let v':a = U.downgrade_val x in
rewrite_slprop (H.pts_to r p (hide x)) (pts_to r p v') (fun _ -> ());
return v'
let read_refine_pt #a #p q r =
Classical.forall_intro_2 reveal_equiv;
lift_exists (fun (v:a) -> pts_to r p v `star` q v);
exists_cong (fun (v:U.raise_t a) -> pts_to r p (U.downgrade_val v) `star` q (U.downgrade_val v))
(fun (v:U.raise_t a) -> H.pts_to r p v `star` U.lift_dom q v);
let x = H.read_refine (U.lift_dom q) r in
rewrite_slprop
(H.pts_to r p (hide x) `star` U.lift_dom q x)
(pts_to r p (U.downgrade_val x) `star` q (U.downgrade_val x)) (fun _ -> ());
return (U.downgrade_val x)
let write_pt #a #v r x =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
let x' = U.raise_val x in
H.write r x';
rewrite_slprop (H.pts_to r full_perm (hide x')) (pts_to r full_perm x) (fun _ -> ())
let free_pt #a #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
H.free r
let share_gen_pt #a #uses #p #v r p1 p2 =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
H.share_gen r p1 p2;
rewrite_slprop (H.pts_to r p1 v') (pts_to r p1 v) (fun _ -> ());
rewrite_slprop (H.pts_to r p2 v') (pts_to r p2 v) (fun _ -> ())
let share_pt #a #uses #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
H.share r;
rewrite_slprop (H.pts_to r (half_perm p) v') (pts_to r (half_perm p) v) (fun _ -> ());
rewrite_slprop (H.pts_to r (half_perm p) v') (pts_to r (half_perm p) v) (fun _ -> ())
let hide_raise_reveal (#a:Type) (v0:erased a) (v1:erased a)
: Lemma (hide (U.raise_val (reveal v0)) == hide (U.raise_val (reveal v1)) <==>
v0 == v1)
[SMTPat (hide (U.raise_val (reveal v0)));
SMTPat (hide (U.raise_val (reveal v1)))]
= let u0 = hide (U.raise_val (reveal v0)) in
let u1 = hide (U.raise_val (reveal v1)) in
assert (U.downgrade_val (U.raise_val (reveal v0)) == U.downgrade_val (U.raise_val (reveal v1)) <==>
v0 == v1)
let gather_pt #a #uses #p0 #p1 #v0 #v1 r =
let v0' = Ghost.hide (U.raise_val (Ghost.reveal v0)) in
let v1' = Ghost.hide (U.raise_val (Ghost.reveal v1)) in
rewrite_slprop (pts_to r p0 v0) (H.pts_to r p0 v0') (fun _ -> ());
rewrite_slprop (pts_to r p1 v1) (H.pts_to r p1 v1') (fun _ -> ());
let (u:unit{v0' == v1'}) = H.gather #_ #_ #p0 #p1 #v0' #v1' r in
rewrite_slprop (H.pts_to r (sum_perm p0 p1) v0') (pts_to r (sum_perm p0 p1) v0) (fun _ -> ());
u
let raise_equiv (#t:Type) (x y:t)
: Lemma (U.raise_val x == U.raise_val y <==>
x == y)
= assert (U.downgrade_val (U.raise_val x) == x);
assert (U.downgrade_val (U.raise_val y) == y)
let downgrade_equiv (#t:Type) (x y:U.raise_t t)
: Lemma (U.downgrade_val x == U.downgrade_val y <==>
x == y)
= assert (U.raise_val (U.downgrade_val x) == x);
assert (U.raise_val (U.downgrade_val y) == y)
let lift_eq (#t:eqtype) (x y:U.raise_t t)
: b:bool{b <==> x==y}
= downgrade_equiv x y; U.downgrade_val x = U.downgrade_val y
let cas_action (#t:eqtype)
(#uses:inames)
(r:ref t)
(v:Ghost.erased t)
(v_old:t)
(v_new:t)
(frame:slprop)
: MstTot (b:bool{b <==> (Ghost.reveal v == v_old)})
uses
(pts_to_sl r full_perm v)
(fun b -> if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v)
frame
(fun _ -> True)
(fun _ _ _ -> True)
= let hv = (Ghost.hide (U.raise_val (Ghost.reveal v))) in
let b = H.cas_action #(U.raise_t t)
(lift_eq #t)
#uses
r
hv
(U.raise_val v_old)
(U.raise_val v_new)
frame
in
assert (b <==> (Ghost.reveal hv == U.raise_val v_old));
assert (b <==> U.raise_val (Ghost.reveal v) == U.raise_val v_old);
raise_equiv (Ghost.reveal v) v_old;
b
let atomic_read_pt_u32 #_ #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
let x = H.atomic_read r in
let v':U32.t = U.downgrade_val x in
rewrite_slprop (H.pts_to r p (hide x)) (pts_to r p v') (fun _ -> ());
return v'
let atomic_write_pt_u32 #_ #v r x =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
let x' = U.raise_val x in
H.atomic_write r x';
rewrite_slprop (H.pts_to r full_perm (hide x')) (pts_to r full_perm x) (fun _ -> ())
let cas_pt_u32 #uses r v v_old v_new =
let b = as_atomic_action (cas_action #U32.t #uses r v v_old v_new) in
rewrite_slprop (to_vprop (if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v))
(if b then pts_to r full_perm v_new else pts_to r full_perm v)
(fun _ -> ());
return b
let cas_pt_bool #uses r v v_old v_new =
let b = as_atomic_action (cas_action #bool #uses r v v_old v_new) in
rewrite_slprop (to_vprop (if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v))
(if b then pts_to r full_perm v_new else pts_to r full_perm v)
(fun _ -> ());
return b
(* Library for references with fractional permissions.
Permissions need to be an index of the vprop ptr.
It cannot be part of a selector, as it is not invariant when joining with a disjoint memory
Using the value of the ref as a selector is ok because refs with fractional permissions
all share the same value.
Refs on PCM are more complicated, and likely not usable with selectors
*)
let ptrp r p = Mem.h_exists (pts_to_sl r p)
val ptr_sel' (#a:Type0) (r: ref a) (p: perm) : selector' a (ptrp r p)
let ptr_sel' #a r p = fun h -> id_elim_exists #a (pts_to_sl r p) h
let ptr_sel_depends_only_on (#a:Type0) (r:ref a)
(p: perm)
(m0:Mem.hmem (ptrp r p)) (m1:mem{disjoint m0 m1})
: Lemma (ptr_sel' r p m0 == ptr_sel' r p (Mem.join m0 m1))
= let x = reveal (id_elim_exists #a (pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (pts_to_sl r p) (Mem.join m0 m1)) in
pts_to_witinv r p;
elim_wi (pts_to_sl r p) x y (Mem.join m0 m1)
let ptr_sel_depends_only_on_core (#a:Type0) (r:ref a)
(p: perm) (m0:Mem.hmem (ptrp r p))
: Lemma (ptr_sel' r p m0 == ptr_sel' r p (core_mem m0))
= let x = reveal (id_elim_exists #a (pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (pts_to_sl r p) (core_mem m0)) in
pts_to_witinv r p;
elim_wi (pts_to_sl r p) x y (core_mem m0)
let ptrp_sel r p =
Classical.forall_intro_2 (ptr_sel_depends_only_on r p);
Classical.forall_intro (ptr_sel_depends_only_on_core r p);
ptr_sel' r p
let ptrp_sel_interp #a r p m = pts_to_witinv r p
let intro_ptrp_interp r p v m = intro_h_exists (reveal v) (pts_to_sl r p) m
let intro_vptr_lemma (#a:Type) (r:ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (pts_to_sl r p v) m)
(ensures interp (ptrp r p) m /\ ptrp_sel r p m == reveal v)
= Mem.intro_h_exists (reveal v) (pts_to_sl r p) m;
pts_to_witinv r p
let elim_vptr_lemma (#a:Type) (r:ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (ptrp r p) m /\ ptrp_sel r p m == reveal v)
(ensures interp (pts_to_sl r p v) m)
= Mem.elim_h_exists (pts_to_sl r p) m;
pts_to_witinv r p
let intro_vptr (#a:Type) (#opened:inames) (r:ref a) (p: perm) (v:erased a)
: SteelGhost unit opened (pts_to r p v) (fun _ -> vptrp r p)
(requires fun _ -> True)
(ensures fun _ _ h1 -> h1 (vptrp r p) == reveal v)
= change_slprop_2 (pts_to r p v) (vptrp r p) v (intro_vptr_lemma r p v)
let elim_vptr (#a:Type) (#opened:inames) (r:ref a) (p: perm)
: SteelGhost (erased a) opened (vptrp r p) (fun v -> pts_to r p v)
(requires fun _ -> True)
(ensures fun h0 v _ -> reveal v == h0 (vptrp r p))
= let v = gget (vptrp r p) in
change_slprop (vptrp r p) (pts_to r p v) v () (elim_vptr_lemma r p v);
v
let malloc x =
let r = alloc_pt x in
intro_vptr r _ (hide x);
return r
let free r =
let _ = elim_vptr r _ in
free_pt r
let readp r _ =
let _ = elim_vptr r _ in
let x = read_pt r in
intro_vptr r _ x;
return x
let write r x =
let _ = elim_vptr r _ in
write_pt r x;
intro_vptr r _ x
let share #a #_ #p r =
let x = elim_vptr r p in
share_pt r;
intro_vptr r _ x;
intro_vptr r _ x
let gather_gen #a #_ r p0 p1 =
let x1 = elim_vptr r p1 in
let x0 = elim_vptr r p0 in
gather_pt #_ #_ #p0 #p1 #x0 #x1 r;
intro_vptr r (sum_perm p0 p1) x0;
sum_perm p0 p1 | {
"checked_file": "/",
"dependencies": [
"Steel.Memory.fsti.checked",
"Steel.HigherReference.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Reference.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "Steel.HigherReference",
"short_module": "H"
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | r: Steel.Reference.ref a -> Steel.Effect.Atomic.SteelGhost Prims.unit | Steel.Effect.Atomic.SteelGhost | [] | [] | [
"Steel.Memory.inames",
"Steel.FractionalPermission.perm",
"Steel.Reference.ref",
"Steel.Effect.Atomic.change_equal_slprop",
"Steel.Reference.vptrp",
"Prims.unit",
"Steel.Reference.gather_gen",
"Steel.FractionalPermission.half_perm",
"Steel.Effect.Common.star",
"Steel.Effect.Common.vprop",
"Steel.Effect.Common.rmem",
"Prims.l_True",
"Prims.eq2",
"Steel.Effect.Common.normal",
"Steel.Effect.Common.t_of"
] | [] | false | true | false | false | false | let gather (#a: Type0) (#uses: _) (#p: perm) (r: ref a)
: SteelGhost unit
uses
((vptrp r (half_perm p)) `star` (vptrp r (half_perm p)))
(fun _ -> vptrp r p)
(fun _ -> True)
(fun h _ h' -> h' (vptrp r p) == h (vptrp r (half_perm p))) =
| let _ = gather_gen r _ _ in
change_equal_slprop (vptrp r _) (vptrp r p) | false |
Steel.Reference.fst | Steel.Reference.ghost_pts_to_injective_eq | val ghost_pts_to_injective_eq (#a:_) (#u:_) (#p #q:_) (r:ghost_ref a) (v0 v1:Ghost.erased a)
: SteelGhost unit u
(ghost_pts_to r p v0 `star` ghost_pts_to r q v1)
(fun _ -> ghost_pts_to r p v0 `star` ghost_pts_to r q v0)
(requires fun _ -> True)
(ensures fun _ _ _ -> v0 == v1) | val ghost_pts_to_injective_eq (#a:_) (#u:_) (#p #q:_) (r:ghost_ref a) (v0 v1:Ghost.erased a)
: SteelGhost unit u
(ghost_pts_to r p v0 `star` ghost_pts_to r q v1)
(fun _ -> ghost_pts_to r p v0 `star` ghost_pts_to r q v0)
(requires fun _ -> True)
(ensures fun _ _ _ -> v0 == v1) | let ghost_pts_to_injective_eq (#a:_) (#u:_) (#p #q:_) (r:ghost_ref a) (v0 v1:Ghost.erased a)
: SteelGhost unit u
(ghost_pts_to r p v0 `star` ghost_pts_to r q v1)
(fun _ -> ghost_pts_to r p v0 `star` ghost_pts_to r q v0)
(requires fun _ -> True)
(ensures fun _ _ _ -> v0 == v1)
= H.ghost_pts_to_injective_eq #_ #_ #p #q r (raise_erased v0) (raise_erased v1) | {
"file_name": "lib/steel/Steel.Reference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 81,
"end_line": 430,
"start_col": 0,
"start_line": 424
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.Reference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module Mem = Steel.Memory
module H = Steel.HigherReference
module U = FStar.Universe
#set-options "--ide_id_info_off"
let ref a = H.ref (U.raise_t a)
let null #a = H.null #(U.raise_t a)
let is_null #a r = H.is_null #(U.raise_t a) r
let pts_to_sl r p v = H.pts_to_sl r p (U.raise_val v)
val raise_val_inj (#a:Type) (x y:a) : Lemma
(requires U.raise_val x == U.raise_val y)
(ensures x == y)
let raise_val_inj x y =
U.downgrade_val_raise_val x;
U.downgrade_val_raise_val y
let pts_to_ref_injective
(#a: Type u#0)
(r: ref a)
(p0 p1:perm)
(v0 v1:a)
(m:mem)
: Lemma
(requires
interp (pts_to_sl r p0 v0 `Mem.star` pts_to_sl r p1 v1) m)
(ensures v0 == v1)
= let v0' = U.raise_val v0 in
let v1' = U.raise_val v1 in
H.pts_to_ref_injective r p0 p1 v0' v1' m;
raise_val_inj v0 v1
let pts_to_not_null (#a:Type u#0)
(x:ref a)
(p:perm)
(v:a)
(m:mem)
: Lemma (requires interp (pts_to_sl x p v) m)
(ensures x =!= null)
= let v = U.raise_val v in
H.pts_to_not_null #(U.raise_t a) x p v m
// let pts_to_not_null' (#a:Type u#0)
// (x:ref a)
// (p:perm)
// (v: erased a)
// (m:mem)
// (m1:mem{disjoint m m1})
// : Lemma (requires interp (pts_to_sl x p v) m)
// (ensures interp (pts_to_sl x p v) (Mem.join m m1))
// = ()
let pts_to_witinv (#a:Type) (r:ref a) (p:perm) : Lemma (is_witness_invariant (pts_to_sl r p)) =
let aux (x y : a) (m:mem)
: Lemma (requires (interp (pts_to_sl r p x) m /\ interp (pts_to_sl r p y) m))
(ensures (x == y))
= H.pts_to_witinv r p;
raise_val_inj x y
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
let pts_to_injective_eq #a #opened #p0 #p1 #v0 #v1 r =
extract_info_raw (pts_to r p0 v0 `star` pts_to r p1 v1) (v0 == v1)
(fun m -> pts_to_ref_injective r p0 p1 v0 v1 m);
rewrite_slprop (pts_to r p1 v1) (pts_to r p1 v0) (fun _ -> ())
let pts_to_perm
r
= H.pts_to_perm r
let alloc_pt x =
let r = H.alloc (U.raise_val x) in
rewrite_slprop (H.pts_to r full_perm (U.raise_val x)) (pts_to r full_perm x) (fun _ -> ());
return r
let read_pt #a #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
let x = H.read r in
let v':a = U.downgrade_val x in
rewrite_slprop (H.pts_to r p (hide x)) (pts_to r p v') (fun _ -> ());
return v'
let read_refine_pt #a #p q r =
Classical.forall_intro_2 reveal_equiv;
lift_exists (fun (v:a) -> pts_to r p v `star` q v);
exists_cong (fun (v:U.raise_t a) -> pts_to r p (U.downgrade_val v) `star` q (U.downgrade_val v))
(fun (v:U.raise_t a) -> H.pts_to r p v `star` U.lift_dom q v);
let x = H.read_refine (U.lift_dom q) r in
rewrite_slprop
(H.pts_to r p (hide x) `star` U.lift_dom q x)
(pts_to r p (U.downgrade_val x) `star` q (U.downgrade_val x)) (fun _ -> ());
return (U.downgrade_val x)
let write_pt #a #v r x =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
let x' = U.raise_val x in
H.write r x';
rewrite_slprop (H.pts_to r full_perm (hide x')) (pts_to r full_perm x) (fun _ -> ())
let free_pt #a #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
H.free r
let share_gen_pt #a #uses #p #v r p1 p2 =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
H.share_gen r p1 p2;
rewrite_slprop (H.pts_to r p1 v') (pts_to r p1 v) (fun _ -> ());
rewrite_slprop (H.pts_to r p2 v') (pts_to r p2 v) (fun _ -> ())
let share_pt #a #uses #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
H.share r;
rewrite_slprop (H.pts_to r (half_perm p) v') (pts_to r (half_perm p) v) (fun _ -> ());
rewrite_slprop (H.pts_to r (half_perm p) v') (pts_to r (half_perm p) v) (fun _ -> ())
let hide_raise_reveal (#a:Type) (v0:erased a) (v1:erased a)
: Lemma (hide (U.raise_val (reveal v0)) == hide (U.raise_val (reveal v1)) <==>
v0 == v1)
[SMTPat (hide (U.raise_val (reveal v0)));
SMTPat (hide (U.raise_val (reveal v1)))]
= let u0 = hide (U.raise_val (reveal v0)) in
let u1 = hide (U.raise_val (reveal v1)) in
assert (U.downgrade_val (U.raise_val (reveal v0)) == U.downgrade_val (U.raise_val (reveal v1)) <==>
v0 == v1)
let gather_pt #a #uses #p0 #p1 #v0 #v1 r =
let v0' = Ghost.hide (U.raise_val (Ghost.reveal v0)) in
let v1' = Ghost.hide (U.raise_val (Ghost.reveal v1)) in
rewrite_slprop (pts_to r p0 v0) (H.pts_to r p0 v0') (fun _ -> ());
rewrite_slprop (pts_to r p1 v1) (H.pts_to r p1 v1') (fun _ -> ());
let (u:unit{v0' == v1'}) = H.gather #_ #_ #p0 #p1 #v0' #v1' r in
rewrite_slprop (H.pts_to r (sum_perm p0 p1) v0') (pts_to r (sum_perm p0 p1) v0) (fun _ -> ());
u
let raise_equiv (#t:Type) (x y:t)
: Lemma (U.raise_val x == U.raise_val y <==>
x == y)
= assert (U.downgrade_val (U.raise_val x) == x);
assert (U.downgrade_val (U.raise_val y) == y)
let downgrade_equiv (#t:Type) (x y:U.raise_t t)
: Lemma (U.downgrade_val x == U.downgrade_val y <==>
x == y)
= assert (U.raise_val (U.downgrade_val x) == x);
assert (U.raise_val (U.downgrade_val y) == y)
let lift_eq (#t:eqtype) (x y:U.raise_t t)
: b:bool{b <==> x==y}
= downgrade_equiv x y; U.downgrade_val x = U.downgrade_val y
let cas_action (#t:eqtype)
(#uses:inames)
(r:ref t)
(v:Ghost.erased t)
(v_old:t)
(v_new:t)
(frame:slprop)
: MstTot (b:bool{b <==> (Ghost.reveal v == v_old)})
uses
(pts_to_sl r full_perm v)
(fun b -> if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v)
frame
(fun _ -> True)
(fun _ _ _ -> True)
= let hv = (Ghost.hide (U.raise_val (Ghost.reveal v))) in
let b = H.cas_action #(U.raise_t t)
(lift_eq #t)
#uses
r
hv
(U.raise_val v_old)
(U.raise_val v_new)
frame
in
assert (b <==> (Ghost.reveal hv == U.raise_val v_old));
assert (b <==> U.raise_val (Ghost.reveal v) == U.raise_val v_old);
raise_equiv (Ghost.reveal v) v_old;
b
let atomic_read_pt_u32 #_ #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
let x = H.atomic_read r in
let v':U32.t = U.downgrade_val x in
rewrite_slprop (H.pts_to r p (hide x)) (pts_to r p v') (fun _ -> ());
return v'
let atomic_write_pt_u32 #_ #v r x =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
let x' = U.raise_val x in
H.atomic_write r x';
rewrite_slprop (H.pts_to r full_perm (hide x')) (pts_to r full_perm x) (fun _ -> ())
let cas_pt_u32 #uses r v v_old v_new =
let b = as_atomic_action (cas_action #U32.t #uses r v v_old v_new) in
rewrite_slprop (to_vprop (if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v))
(if b then pts_to r full_perm v_new else pts_to r full_perm v)
(fun _ -> ());
return b
let cas_pt_bool #uses r v v_old v_new =
let b = as_atomic_action (cas_action #bool #uses r v v_old v_new) in
rewrite_slprop (to_vprop (if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v))
(if b then pts_to r full_perm v_new else pts_to r full_perm v)
(fun _ -> ());
return b
(* Library for references with fractional permissions.
Permissions need to be an index of the vprop ptr.
It cannot be part of a selector, as it is not invariant when joining with a disjoint memory
Using the value of the ref as a selector is ok because refs with fractional permissions
all share the same value.
Refs on PCM are more complicated, and likely not usable with selectors
*)
let ptrp r p = Mem.h_exists (pts_to_sl r p)
val ptr_sel' (#a:Type0) (r: ref a) (p: perm) : selector' a (ptrp r p)
let ptr_sel' #a r p = fun h -> id_elim_exists #a (pts_to_sl r p) h
let ptr_sel_depends_only_on (#a:Type0) (r:ref a)
(p: perm)
(m0:Mem.hmem (ptrp r p)) (m1:mem{disjoint m0 m1})
: Lemma (ptr_sel' r p m0 == ptr_sel' r p (Mem.join m0 m1))
= let x = reveal (id_elim_exists #a (pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (pts_to_sl r p) (Mem.join m0 m1)) in
pts_to_witinv r p;
elim_wi (pts_to_sl r p) x y (Mem.join m0 m1)
let ptr_sel_depends_only_on_core (#a:Type0) (r:ref a)
(p: perm) (m0:Mem.hmem (ptrp r p))
: Lemma (ptr_sel' r p m0 == ptr_sel' r p (core_mem m0))
= let x = reveal (id_elim_exists #a (pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (pts_to_sl r p) (core_mem m0)) in
pts_to_witinv r p;
elim_wi (pts_to_sl r p) x y (core_mem m0)
let ptrp_sel r p =
Classical.forall_intro_2 (ptr_sel_depends_only_on r p);
Classical.forall_intro (ptr_sel_depends_only_on_core r p);
ptr_sel' r p
let ptrp_sel_interp #a r p m = pts_to_witinv r p
let intro_ptrp_interp r p v m = intro_h_exists (reveal v) (pts_to_sl r p) m
let intro_vptr_lemma (#a:Type) (r:ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (pts_to_sl r p v) m)
(ensures interp (ptrp r p) m /\ ptrp_sel r p m == reveal v)
= Mem.intro_h_exists (reveal v) (pts_to_sl r p) m;
pts_to_witinv r p
let elim_vptr_lemma (#a:Type) (r:ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (ptrp r p) m /\ ptrp_sel r p m == reveal v)
(ensures interp (pts_to_sl r p v) m)
= Mem.elim_h_exists (pts_to_sl r p) m;
pts_to_witinv r p
let intro_vptr (#a:Type) (#opened:inames) (r:ref a) (p: perm) (v:erased a)
: SteelGhost unit opened (pts_to r p v) (fun _ -> vptrp r p)
(requires fun _ -> True)
(ensures fun _ _ h1 -> h1 (vptrp r p) == reveal v)
= change_slprop_2 (pts_to r p v) (vptrp r p) v (intro_vptr_lemma r p v)
let elim_vptr (#a:Type) (#opened:inames) (r:ref a) (p: perm)
: SteelGhost (erased a) opened (vptrp r p) (fun v -> pts_to r p v)
(requires fun _ -> True)
(ensures fun h0 v _ -> reveal v == h0 (vptrp r p))
= let v = gget (vptrp r p) in
change_slprop (vptrp r p) (pts_to r p v) v () (elim_vptr_lemma r p v);
v
let malloc x =
let r = alloc_pt x in
intro_vptr r _ (hide x);
return r
let free r =
let _ = elim_vptr r _ in
free_pt r
let readp r _ =
let _ = elim_vptr r _ in
let x = read_pt r in
intro_vptr r _ x;
return x
let write r x =
let _ = elim_vptr r _ in
write_pt r x;
intro_vptr r _ x
let share #a #_ #p r =
let x = elim_vptr r p in
share_pt r;
intro_vptr r _ x;
intro_vptr r _ x
let gather_gen #a #_ r p0 p1 =
let x1 = elim_vptr r p1 in
let x0 = elim_vptr r p0 in
gather_pt #_ #_ #p0 #p1 #x0 #x1 r;
intro_vptr r (sum_perm p0 p1) x0;
sum_perm p0 p1
let gather (#a: Type0) (#uses: _) (#p: perm) (r: ref a)
: SteelGhost unit uses
(vptrp r (half_perm p) `star` vptrp r (half_perm p))
(fun _ -> vptrp r p)
(fun _ -> True)
(fun h _ h' ->
h' (vptrp r p) == h (vptrp r (half_perm p))
)
= let _ = gather_gen r _ _ in
change_equal_slprop
(vptrp r _)
(vptrp r p)
(*** Lemmas on references *)
let vptrp_not_null
#opened #a r
p
= change_slprop_rel
(vptrp r p)
(vptrp r p)
(fun x y -> x == y /\ is_null r == false)
(fun m -> pts_to_not_null r p (ptrp_sel r p m) m)
(*** Ghost pointers *)
(*** GHOST REFERENCES ***)
let ghost_ref a = H.ghost_ref (U.raise_t a)
let dummy_ghost_ref a =
H.reveal_ghost_ref (U.raise_t a);
coerce_eq () (Ghost.hide (H.null #(U.raise_t a)))
[@__reduce__]
let ghost_pts_to_sl #a r p x = H.ghost_pts_to_sl #(U.raise_t a) r p (U.raise_val x)
let ghost_pts_to_witinv (#a:Type) (r:ghost_ref a) (p:perm) : Lemma (is_witness_invariant (ghost_pts_to_sl r p)) =
let aux (x y : a) (m:mem)
: Lemma (requires (interp (ghost_pts_to_sl r p x) m /\ interp (ghost_pts_to_sl r p y) m))
(ensures (x == y))
= H.ghost_pts_to_witinv r p;
raise_val_inj x y
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
[@@__reduce__]
let raise_erased (#a:Type0) (x:erased a)
: erased (U.raise_t u#0 u#1 a)
= Ghost.hide (U.raise_val (Ghost.reveal x))
let ghost_alloc_pt (#a:Type) (#u:_) (x:erased a)
: SteelGhostT (ghost_ref a) u
emp
(fun r -> ghost_pts_to r full_perm x)
= H.ghost_alloc (raise_erased x)
let ghost_free_pt r = H.ghost_free r
let ghost_share_gen_pt
#_ #_ #_ #x r p1 p2
= H.ghost_share_gen #_ #_ #_ #(raise_erased x) r p1 p2
let ghost_share_pt (#a:Type) (#u:_)
(#p:perm)
(#x:erased a)
(r:ghost_ref a)
= H.ghost_share #_ #_ #_ #(raise_erased x) r
let ghost_gather_pt (#a:Type) (#u:_)
(#p0 #p1:perm)
(#x0 #x1:erased a)
(r:ghost_ref a)
: SteelGhost unit u
(ghost_pts_to r p0 x0 `star`
ghost_pts_to r p1 x1)
(fun _ -> ghost_pts_to r (sum_perm p0 p1) x0)
(requires fun _ -> true)
(ensures fun _ _ _ -> x0 == x1)
= H.ghost_gather r | {
"checked_file": "/",
"dependencies": [
"Steel.Memory.fsti.checked",
"Steel.HigherReference.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Reference.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "Steel.HigherReference",
"short_module": "H"
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | r: Steel.Reference.ghost_ref a -> v0: FStar.Ghost.erased a -> v1: FStar.Ghost.erased a
-> Steel.Effect.Atomic.SteelGhost Prims.unit | Steel.Effect.Atomic.SteelGhost | [] | [] | [
"Steel.Memory.inames",
"Steel.FractionalPermission.perm",
"Steel.Reference.ghost_ref",
"FStar.Ghost.erased",
"Steel.HigherReference.ghost_pts_to_injective_eq",
"FStar.Universe.raise_t",
"Steel.Reference.raise_erased",
"Prims.unit",
"Steel.Effect.Common.star",
"Steel.Reference.ghost_pts_to",
"FStar.Ghost.reveal",
"Steel.Effect.Common.vprop",
"Steel.Effect.Common.rmem",
"Prims.l_True",
"Prims.eq2"
] | [] | false | true | false | false | false | let ghost_pts_to_injective_eq (#a #u #p #q: _) (r: ghost_ref a) (v0 v1: Ghost.erased a)
: SteelGhost unit
u
((ghost_pts_to r p v0) `star` (ghost_pts_to r q v1))
(fun _ -> (ghost_pts_to r p v0) `star` (ghost_pts_to r q v0))
(requires fun _ -> True)
(ensures fun _ _ _ -> v0 == v1) =
| H.ghost_pts_to_injective_eq #_ #_ #p #q r (raise_erased v0) (raise_erased v1) | false |
Steel.Reference.fst | Steel.Reference.malloc | val malloc (#a:Type0) (x:a) : Steel (ref a)
emp (fun r -> vptr r)
(requires fun _ -> True)
(ensures fun _ r h1 -> sel r h1 == x /\ not (is_null r)) | val malloc (#a:Type0) (x:a) : Steel (ref a)
emp (fun r -> vptr r)
(requires fun _ -> True)
(ensures fun _ r h1 -> sel r h1 == x /\ not (is_null r)) | let malloc x =
let r = alloc_pt x in
intro_vptr r _ (hide x);
return r | {
"file_name": "lib/steel/Steel.Reference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 10,
"end_line": 313,
"start_col": 0,
"start_line": 310
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.Reference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module Mem = Steel.Memory
module H = Steel.HigherReference
module U = FStar.Universe
#set-options "--ide_id_info_off"
let ref a = H.ref (U.raise_t a)
let null #a = H.null #(U.raise_t a)
let is_null #a r = H.is_null #(U.raise_t a) r
let pts_to_sl r p v = H.pts_to_sl r p (U.raise_val v)
val raise_val_inj (#a:Type) (x y:a) : Lemma
(requires U.raise_val x == U.raise_val y)
(ensures x == y)
let raise_val_inj x y =
U.downgrade_val_raise_val x;
U.downgrade_val_raise_val y
let pts_to_ref_injective
(#a: Type u#0)
(r: ref a)
(p0 p1:perm)
(v0 v1:a)
(m:mem)
: Lemma
(requires
interp (pts_to_sl r p0 v0 `Mem.star` pts_to_sl r p1 v1) m)
(ensures v0 == v1)
= let v0' = U.raise_val v0 in
let v1' = U.raise_val v1 in
H.pts_to_ref_injective r p0 p1 v0' v1' m;
raise_val_inj v0 v1
let pts_to_not_null (#a:Type u#0)
(x:ref a)
(p:perm)
(v:a)
(m:mem)
: Lemma (requires interp (pts_to_sl x p v) m)
(ensures x =!= null)
= let v = U.raise_val v in
H.pts_to_not_null #(U.raise_t a) x p v m
// let pts_to_not_null' (#a:Type u#0)
// (x:ref a)
// (p:perm)
// (v: erased a)
// (m:mem)
// (m1:mem{disjoint m m1})
// : Lemma (requires interp (pts_to_sl x p v) m)
// (ensures interp (pts_to_sl x p v) (Mem.join m m1))
// = ()
let pts_to_witinv (#a:Type) (r:ref a) (p:perm) : Lemma (is_witness_invariant (pts_to_sl r p)) =
let aux (x y : a) (m:mem)
: Lemma (requires (interp (pts_to_sl r p x) m /\ interp (pts_to_sl r p y) m))
(ensures (x == y))
= H.pts_to_witinv r p;
raise_val_inj x y
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
let pts_to_injective_eq #a #opened #p0 #p1 #v0 #v1 r =
extract_info_raw (pts_to r p0 v0 `star` pts_to r p1 v1) (v0 == v1)
(fun m -> pts_to_ref_injective r p0 p1 v0 v1 m);
rewrite_slprop (pts_to r p1 v1) (pts_to r p1 v0) (fun _ -> ())
let pts_to_perm
r
= H.pts_to_perm r
let alloc_pt x =
let r = H.alloc (U.raise_val x) in
rewrite_slprop (H.pts_to r full_perm (U.raise_val x)) (pts_to r full_perm x) (fun _ -> ());
return r
let read_pt #a #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
let x = H.read r in
let v':a = U.downgrade_val x in
rewrite_slprop (H.pts_to r p (hide x)) (pts_to r p v') (fun _ -> ());
return v'
let read_refine_pt #a #p q r =
Classical.forall_intro_2 reveal_equiv;
lift_exists (fun (v:a) -> pts_to r p v `star` q v);
exists_cong (fun (v:U.raise_t a) -> pts_to r p (U.downgrade_val v) `star` q (U.downgrade_val v))
(fun (v:U.raise_t a) -> H.pts_to r p v `star` U.lift_dom q v);
let x = H.read_refine (U.lift_dom q) r in
rewrite_slprop
(H.pts_to r p (hide x) `star` U.lift_dom q x)
(pts_to r p (U.downgrade_val x) `star` q (U.downgrade_val x)) (fun _ -> ());
return (U.downgrade_val x)
let write_pt #a #v r x =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
let x' = U.raise_val x in
H.write r x';
rewrite_slprop (H.pts_to r full_perm (hide x')) (pts_to r full_perm x) (fun _ -> ())
let free_pt #a #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
H.free r
let share_gen_pt #a #uses #p #v r p1 p2 =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
H.share_gen r p1 p2;
rewrite_slprop (H.pts_to r p1 v') (pts_to r p1 v) (fun _ -> ());
rewrite_slprop (H.pts_to r p2 v') (pts_to r p2 v) (fun _ -> ())
let share_pt #a #uses #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
H.share r;
rewrite_slprop (H.pts_to r (half_perm p) v') (pts_to r (half_perm p) v) (fun _ -> ());
rewrite_slprop (H.pts_to r (half_perm p) v') (pts_to r (half_perm p) v) (fun _ -> ())
let hide_raise_reveal (#a:Type) (v0:erased a) (v1:erased a)
: Lemma (hide (U.raise_val (reveal v0)) == hide (U.raise_val (reveal v1)) <==>
v0 == v1)
[SMTPat (hide (U.raise_val (reveal v0)));
SMTPat (hide (U.raise_val (reveal v1)))]
= let u0 = hide (U.raise_val (reveal v0)) in
let u1 = hide (U.raise_val (reveal v1)) in
assert (U.downgrade_val (U.raise_val (reveal v0)) == U.downgrade_val (U.raise_val (reveal v1)) <==>
v0 == v1)
let gather_pt #a #uses #p0 #p1 #v0 #v1 r =
let v0' = Ghost.hide (U.raise_val (Ghost.reveal v0)) in
let v1' = Ghost.hide (U.raise_val (Ghost.reveal v1)) in
rewrite_slprop (pts_to r p0 v0) (H.pts_to r p0 v0') (fun _ -> ());
rewrite_slprop (pts_to r p1 v1) (H.pts_to r p1 v1') (fun _ -> ());
let (u:unit{v0' == v1'}) = H.gather #_ #_ #p0 #p1 #v0' #v1' r in
rewrite_slprop (H.pts_to r (sum_perm p0 p1) v0') (pts_to r (sum_perm p0 p1) v0) (fun _ -> ());
u
let raise_equiv (#t:Type) (x y:t)
: Lemma (U.raise_val x == U.raise_val y <==>
x == y)
= assert (U.downgrade_val (U.raise_val x) == x);
assert (U.downgrade_val (U.raise_val y) == y)
let downgrade_equiv (#t:Type) (x y:U.raise_t t)
: Lemma (U.downgrade_val x == U.downgrade_val y <==>
x == y)
= assert (U.raise_val (U.downgrade_val x) == x);
assert (U.raise_val (U.downgrade_val y) == y)
let lift_eq (#t:eqtype) (x y:U.raise_t t)
: b:bool{b <==> x==y}
= downgrade_equiv x y; U.downgrade_val x = U.downgrade_val y
let cas_action (#t:eqtype)
(#uses:inames)
(r:ref t)
(v:Ghost.erased t)
(v_old:t)
(v_new:t)
(frame:slprop)
: MstTot (b:bool{b <==> (Ghost.reveal v == v_old)})
uses
(pts_to_sl r full_perm v)
(fun b -> if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v)
frame
(fun _ -> True)
(fun _ _ _ -> True)
= let hv = (Ghost.hide (U.raise_val (Ghost.reveal v))) in
let b = H.cas_action #(U.raise_t t)
(lift_eq #t)
#uses
r
hv
(U.raise_val v_old)
(U.raise_val v_new)
frame
in
assert (b <==> (Ghost.reveal hv == U.raise_val v_old));
assert (b <==> U.raise_val (Ghost.reveal v) == U.raise_val v_old);
raise_equiv (Ghost.reveal v) v_old;
b
let atomic_read_pt_u32 #_ #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
let x = H.atomic_read r in
let v':U32.t = U.downgrade_val x in
rewrite_slprop (H.pts_to r p (hide x)) (pts_to r p v') (fun _ -> ());
return v'
let atomic_write_pt_u32 #_ #v r x =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
let x' = U.raise_val x in
H.atomic_write r x';
rewrite_slprop (H.pts_to r full_perm (hide x')) (pts_to r full_perm x) (fun _ -> ())
let cas_pt_u32 #uses r v v_old v_new =
let b = as_atomic_action (cas_action #U32.t #uses r v v_old v_new) in
rewrite_slprop (to_vprop (if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v))
(if b then pts_to r full_perm v_new else pts_to r full_perm v)
(fun _ -> ());
return b
let cas_pt_bool #uses r v v_old v_new =
let b = as_atomic_action (cas_action #bool #uses r v v_old v_new) in
rewrite_slprop (to_vprop (if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v))
(if b then pts_to r full_perm v_new else pts_to r full_perm v)
(fun _ -> ());
return b
(* Library for references with fractional permissions.
Permissions need to be an index of the vprop ptr.
It cannot be part of a selector, as it is not invariant when joining with a disjoint memory
Using the value of the ref as a selector is ok because refs with fractional permissions
all share the same value.
Refs on PCM are more complicated, and likely not usable with selectors
*)
let ptrp r p = Mem.h_exists (pts_to_sl r p)
val ptr_sel' (#a:Type0) (r: ref a) (p: perm) : selector' a (ptrp r p)
let ptr_sel' #a r p = fun h -> id_elim_exists #a (pts_to_sl r p) h
let ptr_sel_depends_only_on (#a:Type0) (r:ref a)
(p: perm)
(m0:Mem.hmem (ptrp r p)) (m1:mem{disjoint m0 m1})
: Lemma (ptr_sel' r p m0 == ptr_sel' r p (Mem.join m0 m1))
= let x = reveal (id_elim_exists #a (pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (pts_to_sl r p) (Mem.join m0 m1)) in
pts_to_witinv r p;
elim_wi (pts_to_sl r p) x y (Mem.join m0 m1)
let ptr_sel_depends_only_on_core (#a:Type0) (r:ref a)
(p: perm) (m0:Mem.hmem (ptrp r p))
: Lemma (ptr_sel' r p m0 == ptr_sel' r p (core_mem m0))
= let x = reveal (id_elim_exists #a (pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (pts_to_sl r p) (core_mem m0)) in
pts_to_witinv r p;
elim_wi (pts_to_sl r p) x y (core_mem m0)
let ptrp_sel r p =
Classical.forall_intro_2 (ptr_sel_depends_only_on r p);
Classical.forall_intro (ptr_sel_depends_only_on_core r p);
ptr_sel' r p
let ptrp_sel_interp #a r p m = pts_to_witinv r p
let intro_ptrp_interp r p v m = intro_h_exists (reveal v) (pts_to_sl r p) m
let intro_vptr_lemma (#a:Type) (r:ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (pts_to_sl r p v) m)
(ensures interp (ptrp r p) m /\ ptrp_sel r p m == reveal v)
= Mem.intro_h_exists (reveal v) (pts_to_sl r p) m;
pts_to_witinv r p
let elim_vptr_lemma (#a:Type) (r:ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (ptrp r p) m /\ ptrp_sel r p m == reveal v)
(ensures interp (pts_to_sl r p v) m)
= Mem.elim_h_exists (pts_to_sl r p) m;
pts_to_witinv r p
let intro_vptr (#a:Type) (#opened:inames) (r:ref a) (p: perm) (v:erased a)
: SteelGhost unit opened (pts_to r p v) (fun _ -> vptrp r p)
(requires fun _ -> True)
(ensures fun _ _ h1 -> h1 (vptrp r p) == reveal v)
= change_slprop_2 (pts_to r p v) (vptrp r p) v (intro_vptr_lemma r p v)
let elim_vptr (#a:Type) (#opened:inames) (r:ref a) (p: perm)
: SteelGhost (erased a) opened (vptrp r p) (fun v -> pts_to r p v)
(requires fun _ -> True)
(ensures fun h0 v _ -> reveal v == h0 (vptrp r p))
= let v = gget (vptrp r p) in
change_slprop (vptrp r p) (pts_to r p v) v () (elim_vptr_lemma r p v);
v | {
"checked_file": "/",
"dependencies": [
"Steel.Memory.fsti.checked",
"Steel.HigherReference.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Reference.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "Steel.HigherReference",
"short_module": "H"
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | x: a -> Steel.Effect.Steel (Steel.Reference.ref a) | Steel.Effect.Steel | [] | [] | [
"Steel.Effect.Atomic.return",
"Steel.Reference.ref",
"FStar.Ghost.hide",
"FStar.Set.set",
"Steel.Memory.iname",
"FStar.Set.empty",
"Steel.Reference.vptrp",
"Steel.FractionalPermission.full_perm",
"Steel.Effect.Common.vprop",
"Prims.unit",
"Steel.Reference.intro_vptr",
"Steel.Reference.alloc_pt"
] | [] | false | true | false | false | false | let malloc x =
| let r = alloc_pt x in
intro_vptr r _ (hide x);
return r | false |
Steel.Reference.fst | Steel.Reference.ghost_write | val ghost_write (#a:Type0) (#opened:inames) (r:ghost_ref a) (x:Ghost.erased a)
: SteelGhost unit opened
(ghost_vptr r) (fun _ -> ghost_vptr r)
(requires fun _ -> True)
(ensures fun _ _ h1 -> Ghost.reveal x == h1 (ghost_vptr r)) | val ghost_write (#a:Type0) (#opened:inames) (r:ghost_ref a) (x:Ghost.erased a)
: SteelGhost unit opened
(ghost_vptr r) (fun _ -> ghost_vptr r)
(requires fun _ -> True)
(ensures fun _ _ h1 -> Ghost.reveal x == h1 (ghost_vptr r)) | let ghost_write r x =
let _ = elim_ghost_vptr r _ in
ghost_write_pt r x;
intro_ghost_vptr r _ x | {
"file_name": "lib/steel/Steel.Reference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 24,
"end_line": 523,
"start_col": 0,
"start_line": 520
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.Reference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module Mem = Steel.Memory
module H = Steel.HigherReference
module U = FStar.Universe
#set-options "--ide_id_info_off"
let ref a = H.ref (U.raise_t a)
let null #a = H.null #(U.raise_t a)
let is_null #a r = H.is_null #(U.raise_t a) r
let pts_to_sl r p v = H.pts_to_sl r p (U.raise_val v)
val raise_val_inj (#a:Type) (x y:a) : Lemma
(requires U.raise_val x == U.raise_val y)
(ensures x == y)
let raise_val_inj x y =
U.downgrade_val_raise_val x;
U.downgrade_val_raise_val y
let pts_to_ref_injective
(#a: Type u#0)
(r: ref a)
(p0 p1:perm)
(v0 v1:a)
(m:mem)
: Lemma
(requires
interp (pts_to_sl r p0 v0 `Mem.star` pts_to_sl r p1 v1) m)
(ensures v0 == v1)
= let v0' = U.raise_val v0 in
let v1' = U.raise_val v1 in
H.pts_to_ref_injective r p0 p1 v0' v1' m;
raise_val_inj v0 v1
let pts_to_not_null (#a:Type u#0)
(x:ref a)
(p:perm)
(v:a)
(m:mem)
: Lemma (requires interp (pts_to_sl x p v) m)
(ensures x =!= null)
= let v = U.raise_val v in
H.pts_to_not_null #(U.raise_t a) x p v m
// let pts_to_not_null' (#a:Type u#0)
// (x:ref a)
// (p:perm)
// (v: erased a)
// (m:mem)
// (m1:mem{disjoint m m1})
// : Lemma (requires interp (pts_to_sl x p v) m)
// (ensures interp (pts_to_sl x p v) (Mem.join m m1))
// = ()
let pts_to_witinv (#a:Type) (r:ref a) (p:perm) : Lemma (is_witness_invariant (pts_to_sl r p)) =
let aux (x y : a) (m:mem)
: Lemma (requires (interp (pts_to_sl r p x) m /\ interp (pts_to_sl r p y) m))
(ensures (x == y))
= H.pts_to_witinv r p;
raise_val_inj x y
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
let pts_to_injective_eq #a #opened #p0 #p1 #v0 #v1 r =
extract_info_raw (pts_to r p0 v0 `star` pts_to r p1 v1) (v0 == v1)
(fun m -> pts_to_ref_injective r p0 p1 v0 v1 m);
rewrite_slprop (pts_to r p1 v1) (pts_to r p1 v0) (fun _ -> ())
let pts_to_perm
r
= H.pts_to_perm r
let alloc_pt x =
let r = H.alloc (U.raise_val x) in
rewrite_slprop (H.pts_to r full_perm (U.raise_val x)) (pts_to r full_perm x) (fun _ -> ());
return r
let read_pt #a #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
let x = H.read r in
let v':a = U.downgrade_val x in
rewrite_slprop (H.pts_to r p (hide x)) (pts_to r p v') (fun _ -> ());
return v'
let read_refine_pt #a #p q r =
Classical.forall_intro_2 reveal_equiv;
lift_exists (fun (v:a) -> pts_to r p v `star` q v);
exists_cong (fun (v:U.raise_t a) -> pts_to r p (U.downgrade_val v) `star` q (U.downgrade_val v))
(fun (v:U.raise_t a) -> H.pts_to r p v `star` U.lift_dom q v);
let x = H.read_refine (U.lift_dom q) r in
rewrite_slprop
(H.pts_to r p (hide x) `star` U.lift_dom q x)
(pts_to r p (U.downgrade_val x) `star` q (U.downgrade_val x)) (fun _ -> ());
return (U.downgrade_val x)
let write_pt #a #v r x =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
let x' = U.raise_val x in
H.write r x';
rewrite_slprop (H.pts_to r full_perm (hide x')) (pts_to r full_perm x) (fun _ -> ())
let free_pt #a #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
H.free r
let share_gen_pt #a #uses #p #v r p1 p2 =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
H.share_gen r p1 p2;
rewrite_slprop (H.pts_to r p1 v') (pts_to r p1 v) (fun _ -> ());
rewrite_slprop (H.pts_to r p2 v') (pts_to r p2 v) (fun _ -> ())
let share_pt #a #uses #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
H.share r;
rewrite_slprop (H.pts_to r (half_perm p) v') (pts_to r (half_perm p) v) (fun _ -> ());
rewrite_slprop (H.pts_to r (half_perm p) v') (pts_to r (half_perm p) v) (fun _ -> ())
let hide_raise_reveal (#a:Type) (v0:erased a) (v1:erased a)
: Lemma (hide (U.raise_val (reveal v0)) == hide (U.raise_val (reveal v1)) <==>
v0 == v1)
[SMTPat (hide (U.raise_val (reveal v0)));
SMTPat (hide (U.raise_val (reveal v1)))]
= let u0 = hide (U.raise_val (reveal v0)) in
let u1 = hide (U.raise_val (reveal v1)) in
assert (U.downgrade_val (U.raise_val (reveal v0)) == U.downgrade_val (U.raise_val (reveal v1)) <==>
v0 == v1)
let gather_pt #a #uses #p0 #p1 #v0 #v1 r =
let v0' = Ghost.hide (U.raise_val (Ghost.reveal v0)) in
let v1' = Ghost.hide (U.raise_val (Ghost.reveal v1)) in
rewrite_slprop (pts_to r p0 v0) (H.pts_to r p0 v0') (fun _ -> ());
rewrite_slprop (pts_to r p1 v1) (H.pts_to r p1 v1') (fun _ -> ());
let (u:unit{v0' == v1'}) = H.gather #_ #_ #p0 #p1 #v0' #v1' r in
rewrite_slprop (H.pts_to r (sum_perm p0 p1) v0') (pts_to r (sum_perm p0 p1) v0) (fun _ -> ());
u
let raise_equiv (#t:Type) (x y:t)
: Lemma (U.raise_val x == U.raise_val y <==>
x == y)
= assert (U.downgrade_val (U.raise_val x) == x);
assert (U.downgrade_val (U.raise_val y) == y)
let downgrade_equiv (#t:Type) (x y:U.raise_t t)
: Lemma (U.downgrade_val x == U.downgrade_val y <==>
x == y)
= assert (U.raise_val (U.downgrade_val x) == x);
assert (U.raise_val (U.downgrade_val y) == y)
let lift_eq (#t:eqtype) (x y:U.raise_t t)
: b:bool{b <==> x==y}
= downgrade_equiv x y; U.downgrade_val x = U.downgrade_val y
let cas_action (#t:eqtype)
(#uses:inames)
(r:ref t)
(v:Ghost.erased t)
(v_old:t)
(v_new:t)
(frame:slprop)
: MstTot (b:bool{b <==> (Ghost.reveal v == v_old)})
uses
(pts_to_sl r full_perm v)
(fun b -> if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v)
frame
(fun _ -> True)
(fun _ _ _ -> True)
= let hv = (Ghost.hide (U.raise_val (Ghost.reveal v))) in
let b = H.cas_action #(U.raise_t t)
(lift_eq #t)
#uses
r
hv
(U.raise_val v_old)
(U.raise_val v_new)
frame
in
assert (b <==> (Ghost.reveal hv == U.raise_val v_old));
assert (b <==> U.raise_val (Ghost.reveal v) == U.raise_val v_old);
raise_equiv (Ghost.reveal v) v_old;
b
let atomic_read_pt_u32 #_ #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
let x = H.atomic_read r in
let v':U32.t = U.downgrade_val x in
rewrite_slprop (H.pts_to r p (hide x)) (pts_to r p v') (fun _ -> ());
return v'
let atomic_write_pt_u32 #_ #v r x =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
let x' = U.raise_val x in
H.atomic_write r x';
rewrite_slprop (H.pts_to r full_perm (hide x')) (pts_to r full_perm x) (fun _ -> ())
let cas_pt_u32 #uses r v v_old v_new =
let b = as_atomic_action (cas_action #U32.t #uses r v v_old v_new) in
rewrite_slprop (to_vprop (if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v))
(if b then pts_to r full_perm v_new else pts_to r full_perm v)
(fun _ -> ());
return b
let cas_pt_bool #uses r v v_old v_new =
let b = as_atomic_action (cas_action #bool #uses r v v_old v_new) in
rewrite_slprop (to_vprop (if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v))
(if b then pts_to r full_perm v_new else pts_to r full_perm v)
(fun _ -> ());
return b
(* Library for references with fractional permissions.
Permissions need to be an index of the vprop ptr.
It cannot be part of a selector, as it is not invariant when joining with a disjoint memory
Using the value of the ref as a selector is ok because refs with fractional permissions
all share the same value.
Refs on PCM are more complicated, and likely not usable with selectors
*)
let ptrp r p = Mem.h_exists (pts_to_sl r p)
val ptr_sel' (#a:Type0) (r: ref a) (p: perm) : selector' a (ptrp r p)
let ptr_sel' #a r p = fun h -> id_elim_exists #a (pts_to_sl r p) h
let ptr_sel_depends_only_on (#a:Type0) (r:ref a)
(p: perm)
(m0:Mem.hmem (ptrp r p)) (m1:mem{disjoint m0 m1})
: Lemma (ptr_sel' r p m0 == ptr_sel' r p (Mem.join m0 m1))
= let x = reveal (id_elim_exists #a (pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (pts_to_sl r p) (Mem.join m0 m1)) in
pts_to_witinv r p;
elim_wi (pts_to_sl r p) x y (Mem.join m0 m1)
let ptr_sel_depends_only_on_core (#a:Type0) (r:ref a)
(p: perm) (m0:Mem.hmem (ptrp r p))
: Lemma (ptr_sel' r p m0 == ptr_sel' r p (core_mem m0))
= let x = reveal (id_elim_exists #a (pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (pts_to_sl r p) (core_mem m0)) in
pts_to_witinv r p;
elim_wi (pts_to_sl r p) x y (core_mem m0)
let ptrp_sel r p =
Classical.forall_intro_2 (ptr_sel_depends_only_on r p);
Classical.forall_intro (ptr_sel_depends_only_on_core r p);
ptr_sel' r p
let ptrp_sel_interp #a r p m = pts_to_witinv r p
let intro_ptrp_interp r p v m = intro_h_exists (reveal v) (pts_to_sl r p) m
let intro_vptr_lemma (#a:Type) (r:ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (pts_to_sl r p v) m)
(ensures interp (ptrp r p) m /\ ptrp_sel r p m == reveal v)
= Mem.intro_h_exists (reveal v) (pts_to_sl r p) m;
pts_to_witinv r p
let elim_vptr_lemma (#a:Type) (r:ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (ptrp r p) m /\ ptrp_sel r p m == reveal v)
(ensures interp (pts_to_sl r p v) m)
= Mem.elim_h_exists (pts_to_sl r p) m;
pts_to_witinv r p
let intro_vptr (#a:Type) (#opened:inames) (r:ref a) (p: perm) (v:erased a)
: SteelGhost unit opened (pts_to r p v) (fun _ -> vptrp r p)
(requires fun _ -> True)
(ensures fun _ _ h1 -> h1 (vptrp r p) == reveal v)
= change_slprop_2 (pts_to r p v) (vptrp r p) v (intro_vptr_lemma r p v)
let elim_vptr (#a:Type) (#opened:inames) (r:ref a) (p: perm)
: SteelGhost (erased a) opened (vptrp r p) (fun v -> pts_to r p v)
(requires fun _ -> True)
(ensures fun h0 v _ -> reveal v == h0 (vptrp r p))
= let v = gget (vptrp r p) in
change_slprop (vptrp r p) (pts_to r p v) v () (elim_vptr_lemma r p v);
v
let malloc x =
let r = alloc_pt x in
intro_vptr r _ (hide x);
return r
let free r =
let _ = elim_vptr r _ in
free_pt r
let readp r _ =
let _ = elim_vptr r _ in
let x = read_pt r in
intro_vptr r _ x;
return x
let write r x =
let _ = elim_vptr r _ in
write_pt r x;
intro_vptr r _ x
let share #a #_ #p r =
let x = elim_vptr r p in
share_pt r;
intro_vptr r _ x;
intro_vptr r _ x
let gather_gen #a #_ r p0 p1 =
let x1 = elim_vptr r p1 in
let x0 = elim_vptr r p0 in
gather_pt #_ #_ #p0 #p1 #x0 #x1 r;
intro_vptr r (sum_perm p0 p1) x0;
sum_perm p0 p1
let gather (#a: Type0) (#uses: _) (#p: perm) (r: ref a)
: SteelGhost unit uses
(vptrp r (half_perm p) `star` vptrp r (half_perm p))
(fun _ -> vptrp r p)
(fun _ -> True)
(fun h _ h' ->
h' (vptrp r p) == h (vptrp r (half_perm p))
)
= let _ = gather_gen r _ _ in
change_equal_slprop
(vptrp r _)
(vptrp r p)
(*** Lemmas on references *)
let vptrp_not_null
#opened #a r
p
= change_slprop_rel
(vptrp r p)
(vptrp r p)
(fun x y -> x == y /\ is_null r == false)
(fun m -> pts_to_not_null r p (ptrp_sel r p m) m)
(*** Ghost pointers *)
(*** GHOST REFERENCES ***)
let ghost_ref a = H.ghost_ref (U.raise_t a)
let dummy_ghost_ref a =
H.reveal_ghost_ref (U.raise_t a);
coerce_eq () (Ghost.hide (H.null #(U.raise_t a)))
[@__reduce__]
let ghost_pts_to_sl #a r p x = H.ghost_pts_to_sl #(U.raise_t a) r p (U.raise_val x)
let ghost_pts_to_witinv (#a:Type) (r:ghost_ref a) (p:perm) : Lemma (is_witness_invariant (ghost_pts_to_sl r p)) =
let aux (x y : a) (m:mem)
: Lemma (requires (interp (ghost_pts_to_sl r p x) m /\ interp (ghost_pts_to_sl r p y) m))
(ensures (x == y))
= H.ghost_pts_to_witinv r p;
raise_val_inj x y
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
[@@__reduce__]
let raise_erased (#a:Type0) (x:erased a)
: erased (U.raise_t u#0 u#1 a)
= Ghost.hide (U.raise_val (Ghost.reveal x))
let ghost_alloc_pt (#a:Type) (#u:_) (x:erased a)
: SteelGhostT (ghost_ref a) u
emp
(fun r -> ghost_pts_to r full_perm x)
= H.ghost_alloc (raise_erased x)
let ghost_free_pt r = H.ghost_free r
let ghost_share_gen_pt
#_ #_ #_ #x r p1 p2
= H.ghost_share_gen #_ #_ #_ #(raise_erased x) r p1 p2
let ghost_share_pt (#a:Type) (#u:_)
(#p:perm)
(#x:erased a)
(r:ghost_ref a)
= H.ghost_share #_ #_ #_ #(raise_erased x) r
let ghost_gather_pt (#a:Type) (#u:_)
(#p0 #p1:perm)
(#x0 #x1:erased a)
(r:ghost_ref a)
: SteelGhost unit u
(ghost_pts_to r p0 x0 `star`
ghost_pts_to r p1 x1)
(fun _ -> ghost_pts_to r (sum_perm p0 p1) x0)
(requires fun _ -> true)
(ensures fun _ _ _ -> x0 == x1)
= H.ghost_gather r
let ghost_pts_to_injective_eq (#a:_) (#u:_) (#p #q:_) (r:ghost_ref a) (v0 v1:Ghost.erased a)
: SteelGhost unit u
(ghost_pts_to r p v0 `star` ghost_pts_to r q v1)
(fun _ -> ghost_pts_to r p v0 `star` ghost_pts_to r q v0)
(requires fun _ -> True)
(ensures fun _ _ _ -> v0 == v1)
= H.ghost_pts_to_injective_eq #_ #_ #p #q r (raise_erased v0) (raise_erased v1)
let ghost_pts_to_perm r = H.ghost_pts_to_perm r
let ghost_read_pt #a #u #p #v r =
let x = H.ghost_read r in
let x' = hide (U.downgrade_val (reveal x)) in
rewrite_slprop (H.ghost_pts_to r p x) (ghost_pts_to r p x') (fun _ -> ());
x'
let ghost_write_pt (#a:Type) (#u:_) (#v:erased a) (r:ghost_ref a) (x:erased a)
: SteelGhostT unit u
(ghost_pts_to r full_perm v)
(fun _ -> ghost_pts_to r full_perm x)
= H.ghost_write r (raise_erased x)
(* Selector version of ghost pointers *)
let ghost_ptrp r p = Mem.h_exists (ghost_pts_to_sl r p)
val ghost_ptr_sel' (#a:Type0) (r: ghost_ref a) (p: perm) : selector' a (ghost_ptrp r p)
let ghost_ptr_sel' #a r p = fun h -> id_elim_exists #a (ghost_pts_to_sl r p) h
let ghost_ptr_sel_depends_only_on (#a:Type0) (r:ghost_ref a)
(p: perm)
(m0:Mem.hmem (ghost_ptrp r p)) (m1:mem{disjoint m0 m1})
: Lemma (ghost_ptr_sel' r p m0 == ghost_ptr_sel' r p (Mem.join m0 m1))
= let x = reveal (id_elim_exists #a (ghost_pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (ghost_pts_to_sl r p) (Mem.join m0 m1)) in
ghost_pts_to_witinv r p;
elim_wi (ghost_pts_to_sl r p) x y (Mem.join m0 m1)
let ghost_ptr_sel_depends_only_on_core (#a:Type0) (r:ghost_ref a)
(p: perm) (m0:Mem.hmem (ghost_ptrp r p))
: Lemma (ghost_ptr_sel' r p m0 == ghost_ptr_sel' r p (core_mem m0))
= let x = reveal (id_elim_exists #a (ghost_pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (ghost_pts_to_sl r p) (core_mem m0)) in
ghost_pts_to_witinv r p;
elim_wi (ghost_pts_to_sl r p) x y (core_mem m0)
let ghost_ptrp_sel r p =
Classical.forall_intro_2 (ghost_ptr_sel_depends_only_on r p);
Classical.forall_intro (ghost_ptr_sel_depends_only_on_core r p);
ghost_ptr_sel' r p
let ghost_ptrp_sel_interp #a r p m = ghost_pts_to_witinv r p
let intro_ghost_vptr_lemma (#a:Type) (r:ghost_ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (ghost_pts_to_sl r p v) m)
(ensures interp (ghost_ptrp r p) m /\ ghost_ptrp_sel r p m == reveal v)
= Mem.intro_h_exists (reveal v) (ghost_pts_to_sl r p) m;
ghost_pts_to_witinv r p
let elim_ghost_vptr_lemma (#a:Type) (r:ghost_ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (ghost_ptrp r p) m /\ ghost_ptrp_sel r p m == reveal v)
(ensures interp (ghost_pts_to_sl r p v) m)
= Mem.elim_h_exists (ghost_pts_to_sl r p) m;
ghost_pts_to_witinv r p
let intro_ghost_vptr (#a:Type) (#opened:inames) (r:ghost_ref a) (p: perm) (v:erased a)
: SteelGhost unit opened (ghost_pts_to r p v) (fun _ -> ghost_vptrp r p)
(requires fun _ -> True)
(ensures fun _ _ h1 -> h1 (ghost_vptrp r p) == reveal v)
= change_slprop_2 (ghost_pts_to r p v) (ghost_vptrp r p) v (intro_ghost_vptr_lemma r p v)
let elim_ghost_vptr (#a:Type) (#opened:inames) (r:ghost_ref a)
(p: perm)
: SteelGhost (erased a) opened (ghost_vptrp r p) (fun v -> ghost_pts_to r p v)
(requires fun _ -> True)
(ensures fun h0 v _ -> reveal v == h0 (ghost_vptrp r p))
= let v = gget (ghost_vptrp r p) in
change_slprop (ghost_vptrp r p) (ghost_pts_to r p v) v () (elim_ghost_vptr_lemma r p v);
v
let ghost_alloc x =
let r = ghost_alloc_pt x in
intro_ghost_vptr r _ x;
r
let ghost_free r =
let _ = elim_ghost_vptr r _ in
ghost_free_pt r
let ghost_readp r _ =
let _ = elim_ghost_vptr r _ in
let x = ghost_read_pt r in
intro_ghost_vptr r _ x;
x | {
"checked_file": "/",
"dependencies": [
"Steel.Memory.fsti.checked",
"Steel.HigherReference.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Reference.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "Steel.HigherReference",
"short_module": "H"
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | r: Steel.Reference.ghost_ref a -> x: FStar.Ghost.erased a
-> Steel.Effect.Atomic.SteelGhost Prims.unit | Steel.Effect.Atomic.SteelGhost | [] | [] | [
"Steel.Memory.inames",
"Steel.Reference.ghost_ref",
"FStar.Ghost.erased",
"Steel.Reference.intro_ghost_vptr",
"Steel.FractionalPermission.full_perm",
"Prims.unit",
"Steel.Reference.ghost_write_pt",
"Steel.Reference.elim_ghost_vptr"
] | [] | false | true | false | false | false | let ghost_write r x =
| let _ = elim_ghost_vptr r _ in
ghost_write_pt r x;
intro_ghost_vptr r _ x | false |
Steel.Reference.fst | Steel.Reference.atomic_write_pt_u32 | val atomic_write_pt_u32 (#opened:_) (#v:erased U32.t) (r:ref U32.t) (x:U32.t)
: SteelAtomicT unit opened
(pts_to r full_perm v)
(fun _ -> pts_to r full_perm x) | val atomic_write_pt_u32 (#opened:_) (#v:erased U32.t) (r:ref U32.t) (x:U32.t)
: SteelAtomicT unit opened
(pts_to r full_perm v)
(fun _ -> pts_to r full_perm x) | let atomic_write_pt_u32 #_ #v r x =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
let x' = U.raise_val x in
H.atomic_write r x';
rewrite_slprop (H.pts_to r full_perm (hide x')) (pts_to r full_perm x) (fun _ -> ()) | {
"file_name": "lib/steel/Steel.Reference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 86,
"end_line": 229,
"start_col": 0,
"start_line": 224
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.Reference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module Mem = Steel.Memory
module H = Steel.HigherReference
module U = FStar.Universe
#set-options "--ide_id_info_off"
let ref a = H.ref (U.raise_t a)
let null #a = H.null #(U.raise_t a)
let is_null #a r = H.is_null #(U.raise_t a) r
let pts_to_sl r p v = H.pts_to_sl r p (U.raise_val v)
val raise_val_inj (#a:Type) (x y:a) : Lemma
(requires U.raise_val x == U.raise_val y)
(ensures x == y)
let raise_val_inj x y =
U.downgrade_val_raise_val x;
U.downgrade_val_raise_val y
let pts_to_ref_injective
(#a: Type u#0)
(r: ref a)
(p0 p1:perm)
(v0 v1:a)
(m:mem)
: Lemma
(requires
interp (pts_to_sl r p0 v0 `Mem.star` pts_to_sl r p1 v1) m)
(ensures v0 == v1)
= let v0' = U.raise_val v0 in
let v1' = U.raise_val v1 in
H.pts_to_ref_injective r p0 p1 v0' v1' m;
raise_val_inj v0 v1
let pts_to_not_null (#a:Type u#0)
(x:ref a)
(p:perm)
(v:a)
(m:mem)
: Lemma (requires interp (pts_to_sl x p v) m)
(ensures x =!= null)
= let v = U.raise_val v in
H.pts_to_not_null #(U.raise_t a) x p v m
// let pts_to_not_null' (#a:Type u#0)
// (x:ref a)
// (p:perm)
// (v: erased a)
// (m:mem)
// (m1:mem{disjoint m m1})
// : Lemma (requires interp (pts_to_sl x p v) m)
// (ensures interp (pts_to_sl x p v) (Mem.join m m1))
// = ()
let pts_to_witinv (#a:Type) (r:ref a) (p:perm) : Lemma (is_witness_invariant (pts_to_sl r p)) =
let aux (x y : a) (m:mem)
: Lemma (requires (interp (pts_to_sl r p x) m /\ interp (pts_to_sl r p y) m))
(ensures (x == y))
= H.pts_to_witinv r p;
raise_val_inj x y
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
let pts_to_injective_eq #a #opened #p0 #p1 #v0 #v1 r =
extract_info_raw (pts_to r p0 v0 `star` pts_to r p1 v1) (v0 == v1)
(fun m -> pts_to_ref_injective r p0 p1 v0 v1 m);
rewrite_slprop (pts_to r p1 v1) (pts_to r p1 v0) (fun _ -> ())
let pts_to_perm
r
= H.pts_to_perm r
let alloc_pt x =
let r = H.alloc (U.raise_val x) in
rewrite_slprop (H.pts_to r full_perm (U.raise_val x)) (pts_to r full_perm x) (fun _ -> ());
return r
let read_pt #a #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
let x = H.read r in
let v':a = U.downgrade_val x in
rewrite_slprop (H.pts_to r p (hide x)) (pts_to r p v') (fun _ -> ());
return v'
let read_refine_pt #a #p q r =
Classical.forall_intro_2 reveal_equiv;
lift_exists (fun (v:a) -> pts_to r p v `star` q v);
exists_cong (fun (v:U.raise_t a) -> pts_to r p (U.downgrade_val v) `star` q (U.downgrade_val v))
(fun (v:U.raise_t a) -> H.pts_to r p v `star` U.lift_dom q v);
let x = H.read_refine (U.lift_dom q) r in
rewrite_slprop
(H.pts_to r p (hide x) `star` U.lift_dom q x)
(pts_to r p (U.downgrade_val x) `star` q (U.downgrade_val x)) (fun _ -> ());
return (U.downgrade_val x)
let write_pt #a #v r x =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
let x' = U.raise_val x in
H.write r x';
rewrite_slprop (H.pts_to r full_perm (hide x')) (pts_to r full_perm x) (fun _ -> ())
let free_pt #a #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
H.free r
let share_gen_pt #a #uses #p #v r p1 p2 =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
H.share_gen r p1 p2;
rewrite_slprop (H.pts_to r p1 v') (pts_to r p1 v) (fun _ -> ());
rewrite_slprop (H.pts_to r p2 v') (pts_to r p2 v) (fun _ -> ())
let share_pt #a #uses #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
H.share r;
rewrite_slprop (H.pts_to r (half_perm p) v') (pts_to r (half_perm p) v) (fun _ -> ());
rewrite_slprop (H.pts_to r (half_perm p) v') (pts_to r (half_perm p) v) (fun _ -> ())
let hide_raise_reveal (#a:Type) (v0:erased a) (v1:erased a)
: Lemma (hide (U.raise_val (reveal v0)) == hide (U.raise_val (reveal v1)) <==>
v0 == v1)
[SMTPat (hide (U.raise_val (reveal v0)));
SMTPat (hide (U.raise_val (reveal v1)))]
= let u0 = hide (U.raise_val (reveal v0)) in
let u1 = hide (U.raise_val (reveal v1)) in
assert (U.downgrade_val (U.raise_val (reveal v0)) == U.downgrade_val (U.raise_val (reveal v1)) <==>
v0 == v1)
let gather_pt #a #uses #p0 #p1 #v0 #v1 r =
let v0' = Ghost.hide (U.raise_val (Ghost.reveal v0)) in
let v1' = Ghost.hide (U.raise_val (Ghost.reveal v1)) in
rewrite_slprop (pts_to r p0 v0) (H.pts_to r p0 v0') (fun _ -> ());
rewrite_slprop (pts_to r p1 v1) (H.pts_to r p1 v1') (fun _ -> ());
let (u:unit{v0' == v1'}) = H.gather #_ #_ #p0 #p1 #v0' #v1' r in
rewrite_slprop (H.pts_to r (sum_perm p0 p1) v0') (pts_to r (sum_perm p0 p1) v0) (fun _ -> ());
u
let raise_equiv (#t:Type) (x y:t)
: Lemma (U.raise_val x == U.raise_val y <==>
x == y)
= assert (U.downgrade_val (U.raise_val x) == x);
assert (U.downgrade_val (U.raise_val y) == y)
let downgrade_equiv (#t:Type) (x y:U.raise_t t)
: Lemma (U.downgrade_val x == U.downgrade_val y <==>
x == y)
= assert (U.raise_val (U.downgrade_val x) == x);
assert (U.raise_val (U.downgrade_val y) == y)
let lift_eq (#t:eqtype) (x y:U.raise_t t)
: b:bool{b <==> x==y}
= downgrade_equiv x y; U.downgrade_val x = U.downgrade_val y
let cas_action (#t:eqtype)
(#uses:inames)
(r:ref t)
(v:Ghost.erased t)
(v_old:t)
(v_new:t)
(frame:slprop)
: MstTot (b:bool{b <==> (Ghost.reveal v == v_old)})
uses
(pts_to_sl r full_perm v)
(fun b -> if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v)
frame
(fun _ -> True)
(fun _ _ _ -> True)
= let hv = (Ghost.hide (U.raise_val (Ghost.reveal v))) in
let b = H.cas_action #(U.raise_t t)
(lift_eq #t)
#uses
r
hv
(U.raise_val v_old)
(U.raise_val v_new)
frame
in
assert (b <==> (Ghost.reveal hv == U.raise_val v_old));
assert (b <==> U.raise_val (Ghost.reveal v) == U.raise_val v_old);
raise_equiv (Ghost.reveal v) v_old;
b
let atomic_read_pt_u32 #_ #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
let x = H.atomic_read r in
let v':U32.t = U.downgrade_val x in
rewrite_slprop (H.pts_to r p (hide x)) (pts_to r p v') (fun _ -> ());
return v' | {
"checked_file": "/",
"dependencies": [
"Steel.Memory.fsti.checked",
"Steel.HigherReference.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Reference.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "Steel.HigherReference",
"short_module": "H"
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | r: Steel.Reference.ref FStar.UInt32.t -> x: FStar.UInt32.t
-> Steel.Effect.Atomic.SteelAtomicT Prims.unit | Steel.Effect.Atomic.SteelAtomicT | [] | [] | [
"Steel.Memory.inames",
"FStar.Ghost.erased",
"FStar.UInt32.t",
"Steel.Reference.ref",
"Steel.Effect.Atomic.rewrite_slprop",
"Steel.HigherReference.pts_to",
"FStar.Universe.raise_t",
"Steel.FractionalPermission.full_perm",
"Steel.Reference.pts_to",
"Steel.Memory.mem",
"Prims.unit",
"Steel.HigherReference.atomic_write",
"FStar.Universe.raise_val",
"FStar.Ghost.reveal",
"FStar.Ghost.hide"
] | [] | false | true | false | false | false | let atomic_write_pt_u32 #_ #v r x =
| let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
let x' = U.raise_val x in
H.atomic_write r x';
rewrite_slprop (H.pts_to r full_perm (hide x')) (pts_to r full_perm x) (fun _ -> ()) | false |
Steel.Reference.fst | Steel.Reference.ghost_alloc | val ghost_alloc (#a:Type0) (#opened:inames) (x:Ghost.erased a)
: SteelGhost (ghost_ref a) opened
emp (fun r -> ghost_vptr r)
(requires fun _ -> True)
(ensures fun _ r h1 -> ghost_sel r h1 == Ghost.reveal x) | val ghost_alloc (#a:Type0) (#opened:inames) (x:Ghost.erased a)
: SteelGhost (ghost_ref a) opened
emp (fun r -> ghost_vptr r)
(requires fun _ -> True)
(ensures fun _ r h1 -> ghost_sel r h1 == Ghost.reveal x) | let ghost_alloc x =
let r = ghost_alloc_pt x in
intro_ghost_vptr r _ x;
r | {
"file_name": "lib/steel/Steel.Reference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 3,
"end_line": 508,
"start_col": 0,
"start_line": 505
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.Reference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module Mem = Steel.Memory
module H = Steel.HigherReference
module U = FStar.Universe
#set-options "--ide_id_info_off"
let ref a = H.ref (U.raise_t a)
let null #a = H.null #(U.raise_t a)
let is_null #a r = H.is_null #(U.raise_t a) r
let pts_to_sl r p v = H.pts_to_sl r p (U.raise_val v)
val raise_val_inj (#a:Type) (x y:a) : Lemma
(requires U.raise_val x == U.raise_val y)
(ensures x == y)
let raise_val_inj x y =
U.downgrade_val_raise_val x;
U.downgrade_val_raise_val y
let pts_to_ref_injective
(#a: Type u#0)
(r: ref a)
(p0 p1:perm)
(v0 v1:a)
(m:mem)
: Lemma
(requires
interp (pts_to_sl r p0 v0 `Mem.star` pts_to_sl r p1 v1) m)
(ensures v0 == v1)
= let v0' = U.raise_val v0 in
let v1' = U.raise_val v1 in
H.pts_to_ref_injective r p0 p1 v0' v1' m;
raise_val_inj v0 v1
let pts_to_not_null (#a:Type u#0)
(x:ref a)
(p:perm)
(v:a)
(m:mem)
: Lemma (requires interp (pts_to_sl x p v) m)
(ensures x =!= null)
= let v = U.raise_val v in
H.pts_to_not_null #(U.raise_t a) x p v m
// let pts_to_not_null' (#a:Type u#0)
// (x:ref a)
// (p:perm)
// (v: erased a)
// (m:mem)
// (m1:mem{disjoint m m1})
// : Lemma (requires interp (pts_to_sl x p v) m)
// (ensures interp (pts_to_sl x p v) (Mem.join m m1))
// = ()
let pts_to_witinv (#a:Type) (r:ref a) (p:perm) : Lemma (is_witness_invariant (pts_to_sl r p)) =
let aux (x y : a) (m:mem)
: Lemma (requires (interp (pts_to_sl r p x) m /\ interp (pts_to_sl r p y) m))
(ensures (x == y))
= H.pts_to_witinv r p;
raise_val_inj x y
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
let pts_to_injective_eq #a #opened #p0 #p1 #v0 #v1 r =
extract_info_raw (pts_to r p0 v0 `star` pts_to r p1 v1) (v0 == v1)
(fun m -> pts_to_ref_injective r p0 p1 v0 v1 m);
rewrite_slprop (pts_to r p1 v1) (pts_to r p1 v0) (fun _ -> ())
let pts_to_perm
r
= H.pts_to_perm r
let alloc_pt x =
let r = H.alloc (U.raise_val x) in
rewrite_slprop (H.pts_to r full_perm (U.raise_val x)) (pts_to r full_perm x) (fun _ -> ());
return r
let read_pt #a #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
let x = H.read r in
let v':a = U.downgrade_val x in
rewrite_slprop (H.pts_to r p (hide x)) (pts_to r p v') (fun _ -> ());
return v'
let read_refine_pt #a #p q r =
Classical.forall_intro_2 reveal_equiv;
lift_exists (fun (v:a) -> pts_to r p v `star` q v);
exists_cong (fun (v:U.raise_t a) -> pts_to r p (U.downgrade_val v) `star` q (U.downgrade_val v))
(fun (v:U.raise_t a) -> H.pts_to r p v `star` U.lift_dom q v);
let x = H.read_refine (U.lift_dom q) r in
rewrite_slprop
(H.pts_to r p (hide x) `star` U.lift_dom q x)
(pts_to r p (U.downgrade_val x) `star` q (U.downgrade_val x)) (fun _ -> ());
return (U.downgrade_val x)
let write_pt #a #v r x =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
let x' = U.raise_val x in
H.write r x';
rewrite_slprop (H.pts_to r full_perm (hide x')) (pts_to r full_perm x) (fun _ -> ())
let free_pt #a #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
H.free r
let share_gen_pt #a #uses #p #v r p1 p2 =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
H.share_gen r p1 p2;
rewrite_slprop (H.pts_to r p1 v') (pts_to r p1 v) (fun _ -> ());
rewrite_slprop (H.pts_to r p2 v') (pts_to r p2 v) (fun _ -> ())
let share_pt #a #uses #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
H.share r;
rewrite_slprop (H.pts_to r (half_perm p) v') (pts_to r (half_perm p) v) (fun _ -> ());
rewrite_slprop (H.pts_to r (half_perm p) v') (pts_to r (half_perm p) v) (fun _ -> ())
let hide_raise_reveal (#a:Type) (v0:erased a) (v1:erased a)
: Lemma (hide (U.raise_val (reveal v0)) == hide (U.raise_val (reveal v1)) <==>
v0 == v1)
[SMTPat (hide (U.raise_val (reveal v0)));
SMTPat (hide (U.raise_val (reveal v1)))]
= let u0 = hide (U.raise_val (reveal v0)) in
let u1 = hide (U.raise_val (reveal v1)) in
assert (U.downgrade_val (U.raise_val (reveal v0)) == U.downgrade_val (U.raise_val (reveal v1)) <==>
v0 == v1)
let gather_pt #a #uses #p0 #p1 #v0 #v1 r =
let v0' = Ghost.hide (U.raise_val (Ghost.reveal v0)) in
let v1' = Ghost.hide (U.raise_val (Ghost.reveal v1)) in
rewrite_slprop (pts_to r p0 v0) (H.pts_to r p0 v0') (fun _ -> ());
rewrite_slprop (pts_to r p1 v1) (H.pts_to r p1 v1') (fun _ -> ());
let (u:unit{v0' == v1'}) = H.gather #_ #_ #p0 #p1 #v0' #v1' r in
rewrite_slprop (H.pts_to r (sum_perm p0 p1) v0') (pts_to r (sum_perm p0 p1) v0) (fun _ -> ());
u
let raise_equiv (#t:Type) (x y:t)
: Lemma (U.raise_val x == U.raise_val y <==>
x == y)
= assert (U.downgrade_val (U.raise_val x) == x);
assert (U.downgrade_val (U.raise_val y) == y)
let downgrade_equiv (#t:Type) (x y:U.raise_t t)
: Lemma (U.downgrade_val x == U.downgrade_val y <==>
x == y)
= assert (U.raise_val (U.downgrade_val x) == x);
assert (U.raise_val (U.downgrade_val y) == y)
let lift_eq (#t:eqtype) (x y:U.raise_t t)
: b:bool{b <==> x==y}
= downgrade_equiv x y; U.downgrade_val x = U.downgrade_val y
let cas_action (#t:eqtype)
(#uses:inames)
(r:ref t)
(v:Ghost.erased t)
(v_old:t)
(v_new:t)
(frame:slprop)
: MstTot (b:bool{b <==> (Ghost.reveal v == v_old)})
uses
(pts_to_sl r full_perm v)
(fun b -> if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v)
frame
(fun _ -> True)
(fun _ _ _ -> True)
= let hv = (Ghost.hide (U.raise_val (Ghost.reveal v))) in
let b = H.cas_action #(U.raise_t t)
(lift_eq #t)
#uses
r
hv
(U.raise_val v_old)
(U.raise_val v_new)
frame
in
assert (b <==> (Ghost.reveal hv == U.raise_val v_old));
assert (b <==> U.raise_val (Ghost.reveal v) == U.raise_val v_old);
raise_equiv (Ghost.reveal v) v_old;
b
let atomic_read_pt_u32 #_ #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
let x = H.atomic_read r in
let v':U32.t = U.downgrade_val x in
rewrite_slprop (H.pts_to r p (hide x)) (pts_to r p v') (fun _ -> ());
return v'
let atomic_write_pt_u32 #_ #v r x =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
let x' = U.raise_val x in
H.atomic_write r x';
rewrite_slprop (H.pts_to r full_perm (hide x')) (pts_to r full_perm x) (fun _ -> ())
let cas_pt_u32 #uses r v v_old v_new =
let b = as_atomic_action (cas_action #U32.t #uses r v v_old v_new) in
rewrite_slprop (to_vprop (if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v))
(if b then pts_to r full_perm v_new else pts_to r full_perm v)
(fun _ -> ());
return b
let cas_pt_bool #uses r v v_old v_new =
let b = as_atomic_action (cas_action #bool #uses r v v_old v_new) in
rewrite_slprop (to_vprop (if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v))
(if b then pts_to r full_perm v_new else pts_to r full_perm v)
(fun _ -> ());
return b
(* Library for references with fractional permissions.
Permissions need to be an index of the vprop ptr.
It cannot be part of a selector, as it is not invariant when joining with a disjoint memory
Using the value of the ref as a selector is ok because refs with fractional permissions
all share the same value.
Refs on PCM are more complicated, and likely not usable with selectors
*)
let ptrp r p = Mem.h_exists (pts_to_sl r p)
val ptr_sel' (#a:Type0) (r: ref a) (p: perm) : selector' a (ptrp r p)
let ptr_sel' #a r p = fun h -> id_elim_exists #a (pts_to_sl r p) h
let ptr_sel_depends_only_on (#a:Type0) (r:ref a)
(p: perm)
(m0:Mem.hmem (ptrp r p)) (m1:mem{disjoint m0 m1})
: Lemma (ptr_sel' r p m0 == ptr_sel' r p (Mem.join m0 m1))
= let x = reveal (id_elim_exists #a (pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (pts_to_sl r p) (Mem.join m0 m1)) in
pts_to_witinv r p;
elim_wi (pts_to_sl r p) x y (Mem.join m0 m1)
let ptr_sel_depends_only_on_core (#a:Type0) (r:ref a)
(p: perm) (m0:Mem.hmem (ptrp r p))
: Lemma (ptr_sel' r p m0 == ptr_sel' r p (core_mem m0))
= let x = reveal (id_elim_exists #a (pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (pts_to_sl r p) (core_mem m0)) in
pts_to_witinv r p;
elim_wi (pts_to_sl r p) x y (core_mem m0)
let ptrp_sel r p =
Classical.forall_intro_2 (ptr_sel_depends_only_on r p);
Classical.forall_intro (ptr_sel_depends_only_on_core r p);
ptr_sel' r p
let ptrp_sel_interp #a r p m = pts_to_witinv r p
let intro_ptrp_interp r p v m = intro_h_exists (reveal v) (pts_to_sl r p) m
let intro_vptr_lemma (#a:Type) (r:ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (pts_to_sl r p v) m)
(ensures interp (ptrp r p) m /\ ptrp_sel r p m == reveal v)
= Mem.intro_h_exists (reveal v) (pts_to_sl r p) m;
pts_to_witinv r p
let elim_vptr_lemma (#a:Type) (r:ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (ptrp r p) m /\ ptrp_sel r p m == reveal v)
(ensures interp (pts_to_sl r p v) m)
= Mem.elim_h_exists (pts_to_sl r p) m;
pts_to_witinv r p
let intro_vptr (#a:Type) (#opened:inames) (r:ref a) (p: perm) (v:erased a)
: SteelGhost unit opened (pts_to r p v) (fun _ -> vptrp r p)
(requires fun _ -> True)
(ensures fun _ _ h1 -> h1 (vptrp r p) == reveal v)
= change_slprop_2 (pts_to r p v) (vptrp r p) v (intro_vptr_lemma r p v)
let elim_vptr (#a:Type) (#opened:inames) (r:ref a) (p: perm)
: SteelGhost (erased a) opened (vptrp r p) (fun v -> pts_to r p v)
(requires fun _ -> True)
(ensures fun h0 v _ -> reveal v == h0 (vptrp r p))
= let v = gget (vptrp r p) in
change_slprop (vptrp r p) (pts_to r p v) v () (elim_vptr_lemma r p v);
v
let malloc x =
let r = alloc_pt x in
intro_vptr r _ (hide x);
return r
let free r =
let _ = elim_vptr r _ in
free_pt r
let readp r _ =
let _ = elim_vptr r _ in
let x = read_pt r in
intro_vptr r _ x;
return x
let write r x =
let _ = elim_vptr r _ in
write_pt r x;
intro_vptr r _ x
let share #a #_ #p r =
let x = elim_vptr r p in
share_pt r;
intro_vptr r _ x;
intro_vptr r _ x
let gather_gen #a #_ r p0 p1 =
let x1 = elim_vptr r p1 in
let x0 = elim_vptr r p0 in
gather_pt #_ #_ #p0 #p1 #x0 #x1 r;
intro_vptr r (sum_perm p0 p1) x0;
sum_perm p0 p1
let gather (#a: Type0) (#uses: _) (#p: perm) (r: ref a)
: SteelGhost unit uses
(vptrp r (half_perm p) `star` vptrp r (half_perm p))
(fun _ -> vptrp r p)
(fun _ -> True)
(fun h _ h' ->
h' (vptrp r p) == h (vptrp r (half_perm p))
)
= let _ = gather_gen r _ _ in
change_equal_slprop
(vptrp r _)
(vptrp r p)
(*** Lemmas on references *)
let vptrp_not_null
#opened #a r
p
= change_slprop_rel
(vptrp r p)
(vptrp r p)
(fun x y -> x == y /\ is_null r == false)
(fun m -> pts_to_not_null r p (ptrp_sel r p m) m)
(*** Ghost pointers *)
(*** GHOST REFERENCES ***)
let ghost_ref a = H.ghost_ref (U.raise_t a)
let dummy_ghost_ref a =
H.reveal_ghost_ref (U.raise_t a);
coerce_eq () (Ghost.hide (H.null #(U.raise_t a)))
[@__reduce__]
let ghost_pts_to_sl #a r p x = H.ghost_pts_to_sl #(U.raise_t a) r p (U.raise_val x)
let ghost_pts_to_witinv (#a:Type) (r:ghost_ref a) (p:perm) : Lemma (is_witness_invariant (ghost_pts_to_sl r p)) =
let aux (x y : a) (m:mem)
: Lemma (requires (interp (ghost_pts_to_sl r p x) m /\ interp (ghost_pts_to_sl r p y) m))
(ensures (x == y))
= H.ghost_pts_to_witinv r p;
raise_val_inj x y
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
[@@__reduce__]
let raise_erased (#a:Type0) (x:erased a)
: erased (U.raise_t u#0 u#1 a)
= Ghost.hide (U.raise_val (Ghost.reveal x))
let ghost_alloc_pt (#a:Type) (#u:_) (x:erased a)
: SteelGhostT (ghost_ref a) u
emp
(fun r -> ghost_pts_to r full_perm x)
= H.ghost_alloc (raise_erased x)
let ghost_free_pt r = H.ghost_free r
let ghost_share_gen_pt
#_ #_ #_ #x r p1 p2
= H.ghost_share_gen #_ #_ #_ #(raise_erased x) r p1 p2
let ghost_share_pt (#a:Type) (#u:_)
(#p:perm)
(#x:erased a)
(r:ghost_ref a)
= H.ghost_share #_ #_ #_ #(raise_erased x) r
let ghost_gather_pt (#a:Type) (#u:_)
(#p0 #p1:perm)
(#x0 #x1:erased a)
(r:ghost_ref a)
: SteelGhost unit u
(ghost_pts_to r p0 x0 `star`
ghost_pts_to r p1 x1)
(fun _ -> ghost_pts_to r (sum_perm p0 p1) x0)
(requires fun _ -> true)
(ensures fun _ _ _ -> x0 == x1)
= H.ghost_gather r
let ghost_pts_to_injective_eq (#a:_) (#u:_) (#p #q:_) (r:ghost_ref a) (v0 v1:Ghost.erased a)
: SteelGhost unit u
(ghost_pts_to r p v0 `star` ghost_pts_to r q v1)
(fun _ -> ghost_pts_to r p v0 `star` ghost_pts_to r q v0)
(requires fun _ -> True)
(ensures fun _ _ _ -> v0 == v1)
= H.ghost_pts_to_injective_eq #_ #_ #p #q r (raise_erased v0) (raise_erased v1)
let ghost_pts_to_perm r = H.ghost_pts_to_perm r
let ghost_read_pt #a #u #p #v r =
let x = H.ghost_read r in
let x' = hide (U.downgrade_val (reveal x)) in
rewrite_slprop (H.ghost_pts_to r p x) (ghost_pts_to r p x') (fun _ -> ());
x'
let ghost_write_pt (#a:Type) (#u:_) (#v:erased a) (r:ghost_ref a) (x:erased a)
: SteelGhostT unit u
(ghost_pts_to r full_perm v)
(fun _ -> ghost_pts_to r full_perm x)
= H.ghost_write r (raise_erased x)
(* Selector version of ghost pointers *)
let ghost_ptrp r p = Mem.h_exists (ghost_pts_to_sl r p)
val ghost_ptr_sel' (#a:Type0) (r: ghost_ref a) (p: perm) : selector' a (ghost_ptrp r p)
let ghost_ptr_sel' #a r p = fun h -> id_elim_exists #a (ghost_pts_to_sl r p) h
let ghost_ptr_sel_depends_only_on (#a:Type0) (r:ghost_ref a)
(p: perm)
(m0:Mem.hmem (ghost_ptrp r p)) (m1:mem{disjoint m0 m1})
: Lemma (ghost_ptr_sel' r p m0 == ghost_ptr_sel' r p (Mem.join m0 m1))
= let x = reveal (id_elim_exists #a (ghost_pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (ghost_pts_to_sl r p) (Mem.join m0 m1)) in
ghost_pts_to_witinv r p;
elim_wi (ghost_pts_to_sl r p) x y (Mem.join m0 m1)
let ghost_ptr_sel_depends_only_on_core (#a:Type0) (r:ghost_ref a)
(p: perm) (m0:Mem.hmem (ghost_ptrp r p))
: Lemma (ghost_ptr_sel' r p m0 == ghost_ptr_sel' r p (core_mem m0))
= let x = reveal (id_elim_exists #a (ghost_pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (ghost_pts_to_sl r p) (core_mem m0)) in
ghost_pts_to_witinv r p;
elim_wi (ghost_pts_to_sl r p) x y (core_mem m0)
let ghost_ptrp_sel r p =
Classical.forall_intro_2 (ghost_ptr_sel_depends_only_on r p);
Classical.forall_intro (ghost_ptr_sel_depends_only_on_core r p);
ghost_ptr_sel' r p
let ghost_ptrp_sel_interp #a r p m = ghost_pts_to_witinv r p
let intro_ghost_vptr_lemma (#a:Type) (r:ghost_ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (ghost_pts_to_sl r p v) m)
(ensures interp (ghost_ptrp r p) m /\ ghost_ptrp_sel r p m == reveal v)
= Mem.intro_h_exists (reveal v) (ghost_pts_to_sl r p) m;
ghost_pts_to_witinv r p
let elim_ghost_vptr_lemma (#a:Type) (r:ghost_ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (ghost_ptrp r p) m /\ ghost_ptrp_sel r p m == reveal v)
(ensures interp (ghost_pts_to_sl r p v) m)
= Mem.elim_h_exists (ghost_pts_to_sl r p) m;
ghost_pts_to_witinv r p
let intro_ghost_vptr (#a:Type) (#opened:inames) (r:ghost_ref a) (p: perm) (v:erased a)
: SteelGhost unit opened (ghost_pts_to r p v) (fun _ -> ghost_vptrp r p)
(requires fun _ -> True)
(ensures fun _ _ h1 -> h1 (ghost_vptrp r p) == reveal v)
= change_slprop_2 (ghost_pts_to r p v) (ghost_vptrp r p) v (intro_ghost_vptr_lemma r p v)
let elim_ghost_vptr (#a:Type) (#opened:inames) (r:ghost_ref a)
(p: perm)
: SteelGhost (erased a) opened (ghost_vptrp r p) (fun v -> ghost_pts_to r p v)
(requires fun _ -> True)
(ensures fun h0 v _ -> reveal v == h0 (ghost_vptrp r p))
= let v = gget (ghost_vptrp r p) in
change_slprop (ghost_vptrp r p) (ghost_pts_to r p v) v () (elim_ghost_vptr_lemma r p v);
v | {
"checked_file": "/",
"dependencies": [
"Steel.Memory.fsti.checked",
"Steel.HigherReference.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Reference.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "Steel.HigherReference",
"short_module": "H"
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | x: FStar.Ghost.erased a -> Steel.Effect.Atomic.SteelGhost (Steel.Reference.ghost_ref a) | Steel.Effect.Atomic.SteelGhost | [] | [] | [
"Steel.Memory.inames",
"FStar.Ghost.erased",
"Steel.Reference.ghost_ref",
"Prims.unit",
"Steel.Reference.intro_ghost_vptr",
"Steel.FractionalPermission.full_perm",
"Steel.Reference.ghost_alloc_pt"
] | [] | false | true | false | false | false | let ghost_alloc x =
| let r = ghost_alloc_pt x in
intro_ghost_vptr r _ x;
r | false |
Steel.Reference.fst | Steel.Reference.write | val write (#a:Type0) (r:ref a) (x:a) : Steel unit
(vptr r) (fun _ -> vptr r)
(requires fun _ -> True)
(ensures fun _ _ h1 -> x == sel r h1) | val write (#a:Type0) (r:ref a) (x:a) : Steel unit
(vptr r) (fun _ -> vptr r)
(requires fun _ -> True)
(ensures fun _ _ h1 -> x == sel r h1) | let write r x =
let _ = elim_vptr r _ in
write_pt r x;
intro_vptr r _ x | {
"file_name": "lib/steel/Steel.Reference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 18,
"end_line": 328,
"start_col": 0,
"start_line": 325
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.Reference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module Mem = Steel.Memory
module H = Steel.HigherReference
module U = FStar.Universe
#set-options "--ide_id_info_off"
let ref a = H.ref (U.raise_t a)
let null #a = H.null #(U.raise_t a)
let is_null #a r = H.is_null #(U.raise_t a) r
let pts_to_sl r p v = H.pts_to_sl r p (U.raise_val v)
val raise_val_inj (#a:Type) (x y:a) : Lemma
(requires U.raise_val x == U.raise_val y)
(ensures x == y)
let raise_val_inj x y =
U.downgrade_val_raise_val x;
U.downgrade_val_raise_val y
let pts_to_ref_injective
(#a: Type u#0)
(r: ref a)
(p0 p1:perm)
(v0 v1:a)
(m:mem)
: Lemma
(requires
interp (pts_to_sl r p0 v0 `Mem.star` pts_to_sl r p1 v1) m)
(ensures v0 == v1)
= let v0' = U.raise_val v0 in
let v1' = U.raise_val v1 in
H.pts_to_ref_injective r p0 p1 v0' v1' m;
raise_val_inj v0 v1
let pts_to_not_null (#a:Type u#0)
(x:ref a)
(p:perm)
(v:a)
(m:mem)
: Lemma (requires interp (pts_to_sl x p v) m)
(ensures x =!= null)
= let v = U.raise_val v in
H.pts_to_not_null #(U.raise_t a) x p v m
// let pts_to_not_null' (#a:Type u#0)
// (x:ref a)
// (p:perm)
// (v: erased a)
// (m:mem)
// (m1:mem{disjoint m m1})
// : Lemma (requires interp (pts_to_sl x p v) m)
// (ensures interp (pts_to_sl x p v) (Mem.join m m1))
// = ()
let pts_to_witinv (#a:Type) (r:ref a) (p:perm) : Lemma (is_witness_invariant (pts_to_sl r p)) =
let aux (x y : a) (m:mem)
: Lemma (requires (interp (pts_to_sl r p x) m /\ interp (pts_to_sl r p y) m))
(ensures (x == y))
= H.pts_to_witinv r p;
raise_val_inj x y
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
let pts_to_injective_eq #a #opened #p0 #p1 #v0 #v1 r =
extract_info_raw (pts_to r p0 v0 `star` pts_to r p1 v1) (v0 == v1)
(fun m -> pts_to_ref_injective r p0 p1 v0 v1 m);
rewrite_slprop (pts_to r p1 v1) (pts_to r p1 v0) (fun _ -> ())
let pts_to_perm
r
= H.pts_to_perm r
let alloc_pt x =
let r = H.alloc (U.raise_val x) in
rewrite_slprop (H.pts_to r full_perm (U.raise_val x)) (pts_to r full_perm x) (fun _ -> ());
return r
let read_pt #a #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
let x = H.read r in
let v':a = U.downgrade_val x in
rewrite_slprop (H.pts_to r p (hide x)) (pts_to r p v') (fun _ -> ());
return v'
let read_refine_pt #a #p q r =
Classical.forall_intro_2 reveal_equiv;
lift_exists (fun (v:a) -> pts_to r p v `star` q v);
exists_cong (fun (v:U.raise_t a) -> pts_to r p (U.downgrade_val v) `star` q (U.downgrade_val v))
(fun (v:U.raise_t a) -> H.pts_to r p v `star` U.lift_dom q v);
let x = H.read_refine (U.lift_dom q) r in
rewrite_slprop
(H.pts_to r p (hide x) `star` U.lift_dom q x)
(pts_to r p (U.downgrade_val x) `star` q (U.downgrade_val x)) (fun _ -> ());
return (U.downgrade_val x)
let write_pt #a #v r x =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
let x' = U.raise_val x in
H.write r x';
rewrite_slprop (H.pts_to r full_perm (hide x')) (pts_to r full_perm x) (fun _ -> ())
let free_pt #a #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
H.free r
let share_gen_pt #a #uses #p #v r p1 p2 =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
H.share_gen r p1 p2;
rewrite_slprop (H.pts_to r p1 v') (pts_to r p1 v) (fun _ -> ());
rewrite_slprop (H.pts_to r p2 v') (pts_to r p2 v) (fun _ -> ())
let share_pt #a #uses #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
H.share r;
rewrite_slprop (H.pts_to r (half_perm p) v') (pts_to r (half_perm p) v) (fun _ -> ());
rewrite_slprop (H.pts_to r (half_perm p) v') (pts_to r (half_perm p) v) (fun _ -> ())
let hide_raise_reveal (#a:Type) (v0:erased a) (v1:erased a)
: Lemma (hide (U.raise_val (reveal v0)) == hide (U.raise_val (reveal v1)) <==>
v0 == v1)
[SMTPat (hide (U.raise_val (reveal v0)));
SMTPat (hide (U.raise_val (reveal v1)))]
= let u0 = hide (U.raise_val (reveal v0)) in
let u1 = hide (U.raise_val (reveal v1)) in
assert (U.downgrade_val (U.raise_val (reveal v0)) == U.downgrade_val (U.raise_val (reveal v1)) <==>
v0 == v1)
let gather_pt #a #uses #p0 #p1 #v0 #v1 r =
let v0' = Ghost.hide (U.raise_val (Ghost.reveal v0)) in
let v1' = Ghost.hide (U.raise_val (Ghost.reveal v1)) in
rewrite_slprop (pts_to r p0 v0) (H.pts_to r p0 v0') (fun _ -> ());
rewrite_slprop (pts_to r p1 v1) (H.pts_to r p1 v1') (fun _ -> ());
let (u:unit{v0' == v1'}) = H.gather #_ #_ #p0 #p1 #v0' #v1' r in
rewrite_slprop (H.pts_to r (sum_perm p0 p1) v0') (pts_to r (sum_perm p0 p1) v0) (fun _ -> ());
u
let raise_equiv (#t:Type) (x y:t)
: Lemma (U.raise_val x == U.raise_val y <==>
x == y)
= assert (U.downgrade_val (U.raise_val x) == x);
assert (U.downgrade_val (U.raise_val y) == y)
let downgrade_equiv (#t:Type) (x y:U.raise_t t)
: Lemma (U.downgrade_val x == U.downgrade_val y <==>
x == y)
= assert (U.raise_val (U.downgrade_val x) == x);
assert (U.raise_val (U.downgrade_val y) == y)
let lift_eq (#t:eqtype) (x y:U.raise_t t)
: b:bool{b <==> x==y}
= downgrade_equiv x y; U.downgrade_val x = U.downgrade_val y
let cas_action (#t:eqtype)
(#uses:inames)
(r:ref t)
(v:Ghost.erased t)
(v_old:t)
(v_new:t)
(frame:slprop)
: MstTot (b:bool{b <==> (Ghost.reveal v == v_old)})
uses
(pts_to_sl r full_perm v)
(fun b -> if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v)
frame
(fun _ -> True)
(fun _ _ _ -> True)
= let hv = (Ghost.hide (U.raise_val (Ghost.reveal v))) in
let b = H.cas_action #(U.raise_t t)
(lift_eq #t)
#uses
r
hv
(U.raise_val v_old)
(U.raise_val v_new)
frame
in
assert (b <==> (Ghost.reveal hv == U.raise_val v_old));
assert (b <==> U.raise_val (Ghost.reveal v) == U.raise_val v_old);
raise_equiv (Ghost.reveal v) v_old;
b
let atomic_read_pt_u32 #_ #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
let x = H.atomic_read r in
let v':U32.t = U.downgrade_val x in
rewrite_slprop (H.pts_to r p (hide x)) (pts_to r p v') (fun _ -> ());
return v'
let atomic_write_pt_u32 #_ #v r x =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
let x' = U.raise_val x in
H.atomic_write r x';
rewrite_slprop (H.pts_to r full_perm (hide x')) (pts_to r full_perm x) (fun _ -> ())
let cas_pt_u32 #uses r v v_old v_new =
let b = as_atomic_action (cas_action #U32.t #uses r v v_old v_new) in
rewrite_slprop (to_vprop (if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v))
(if b then pts_to r full_perm v_new else pts_to r full_perm v)
(fun _ -> ());
return b
let cas_pt_bool #uses r v v_old v_new =
let b = as_atomic_action (cas_action #bool #uses r v v_old v_new) in
rewrite_slprop (to_vprop (if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v))
(if b then pts_to r full_perm v_new else pts_to r full_perm v)
(fun _ -> ());
return b
(* Library for references with fractional permissions.
Permissions need to be an index of the vprop ptr.
It cannot be part of a selector, as it is not invariant when joining with a disjoint memory
Using the value of the ref as a selector is ok because refs with fractional permissions
all share the same value.
Refs on PCM are more complicated, and likely not usable with selectors
*)
let ptrp r p = Mem.h_exists (pts_to_sl r p)
val ptr_sel' (#a:Type0) (r: ref a) (p: perm) : selector' a (ptrp r p)
let ptr_sel' #a r p = fun h -> id_elim_exists #a (pts_to_sl r p) h
let ptr_sel_depends_only_on (#a:Type0) (r:ref a)
(p: perm)
(m0:Mem.hmem (ptrp r p)) (m1:mem{disjoint m0 m1})
: Lemma (ptr_sel' r p m0 == ptr_sel' r p (Mem.join m0 m1))
= let x = reveal (id_elim_exists #a (pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (pts_to_sl r p) (Mem.join m0 m1)) in
pts_to_witinv r p;
elim_wi (pts_to_sl r p) x y (Mem.join m0 m1)
let ptr_sel_depends_only_on_core (#a:Type0) (r:ref a)
(p: perm) (m0:Mem.hmem (ptrp r p))
: Lemma (ptr_sel' r p m0 == ptr_sel' r p (core_mem m0))
= let x = reveal (id_elim_exists #a (pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (pts_to_sl r p) (core_mem m0)) in
pts_to_witinv r p;
elim_wi (pts_to_sl r p) x y (core_mem m0)
let ptrp_sel r p =
Classical.forall_intro_2 (ptr_sel_depends_only_on r p);
Classical.forall_intro (ptr_sel_depends_only_on_core r p);
ptr_sel' r p
let ptrp_sel_interp #a r p m = pts_to_witinv r p
let intro_ptrp_interp r p v m = intro_h_exists (reveal v) (pts_to_sl r p) m
let intro_vptr_lemma (#a:Type) (r:ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (pts_to_sl r p v) m)
(ensures interp (ptrp r p) m /\ ptrp_sel r p m == reveal v)
= Mem.intro_h_exists (reveal v) (pts_to_sl r p) m;
pts_to_witinv r p
let elim_vptr_lemma (#a:Type) (r:ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (ptrp r p) m /\ ptrp_sel r p m == reveal v)
(ensures interp (pts_to_sl r p v) m)
= Mem.elim_h_exists (pts_to_sl r p) m;
pts_to_witinv r p
let intro_vptr (#a:Type) (#opened:inames) (r:ref a) (p: perm) (v:erased a)
: SteelGhost unit opened (pts_to r p v) (fun _ -> vptrp r p)
(requires fun _ -> True)
(ensures fun _ _ h1 -> h1 (vptrp r p) == reveal v)
= change_slprop_2 (pts_to r p v) (vptrp r p) v (intro_vptr_lemma r p v)
let elim_vptr (#a:Type) (#opened:inames) (r:ref a) (p: perm)
: SteelGhost (erased a) opened (vptrp r p) (fun v -> pts_to r p v)
(requires fun _ -> True)
(ensures fun h0 v _ -> reveal v == h0 (vptrp r p))
= let v = gget (vptrp r p) in
change_slprop (vptrp r p) (pts_to r p v) v () (elim_vptr_lemma r p v);
v
let malloc x =
let r = alloc_pt x in
intro_vptr r _ (hide x);
return r
let free r =
let _ = elim_vptr r _ in
free_pt r
let readp r _ =
let _ = elim_vptr r _ in
let x = read_pt r in
intro_vptr r _ x;
return x | {
"checked_file": "/",
"dependencies": [
"Steel.Memory.fsti.checked",
"Steel.HigherReference.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Reference.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "Steel.HigherReference",
"short_module": "H"
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | r: Steel.Reference.ref a -> x: a -> Steel.Effect.Steel Prims.unit | Steel.Effect.Steel | [] | [] | [
"Steel.Reference.ref",
"Steel.Reference.intro_vptr",
"FStar.Ghost.hide",
"FStar.Set.set",
"Steel.Memory.iname",
"FStar.Set.empty",
"Steel.FractionalPermission.full_perm",
"Prims.unit",
"Steel.Reference.write_pt",
"FStar.Ghost.erased",
"Steel.Reference.elim_vptr"
] | [] | false | true | false | false | false | let write r x =
| let _ = elim_vptr r _ in
write_pt r x;
intro_vptr r _ x | false |
Steel.Reference.fst | Steel.Reference.write_pt | val write_pt (#a:Type0) (#v:erased a) (r:ref a) (x:a)
: SteelT unit (pts_to r full_perm v) (fun _ -> pts_to r full_perm x) | val write_pt (#a:Type0) (#v:erased a) (r:ref a) (x:a)
: SteelT unit (pts_to r full_perm v) (fun _ -> pts_to r full_perm x) | let write_pt #a #v r x =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
let x' = U.raise_val x in
H.write r x';
rewrite_slprop (H.pts_to r full_perm (hide x')) (pts_to r full_perm x) (fun _ -> ()) | {
"file_name": "lib/steel/Steel.Reference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 86,
"end_line": 129,
"start_col": 0,
"start_line": 124
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.Reference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module Mem = Steel.Memory
module H = Steel.HigherReference
module U = FStar.Universe
#set-options "--ide_id_info_off"
let ref a = H.ref (U.raise_t a)
let null #a = H.null #(U.raise_t a)
let is_null #a r = H.is_null #(U.raise_t a) r
let pts_to_sl r p v = H.pts_to_sl r p (U.raise_val v)
val raise_val_inj (#a:Type) (x y:a) : Lemma
(requires U.raise_val x == U.raise_val y)
(ensures x == y)
let raise_val_inj x y =
U.downgrade_val_raise_val x;
U.downgrade_val_raise_val y
let pts_to_ref_injective
(#a: Type u#0)
(r: ref a)
(p0 p1:perm)
(v0 v1:a)
(m:mem)
: Lemma
(requires
interp (pts_to_sl r p0 v0 `Mem.star` pts_to_sl r p1 v1) m)
(ensures v0 == v1)
= let v0' = U.raise_val v0 in
let v1' = U.raise_val v1 in
H.pts_to_ref_injective r p0 p1 v0' v1' m;
raise_val_inj v0 v1
let pts_to_not_null (#a:Type u#0)
(x:ref a)
(p:perm)
(v:a)
(m:mem)
: Lemma (requires interp (pts_to_sl x p v) m)
(ensures x =!= null)
= let v = U.raise_val v in
H.pts_to_not_null #(U.raise_t a) x p v m
// let pts_to_not_null' (#a:Type u#0)
// (x:ref a)
// (p:perm)
// (v: erased a)
// (m:mem)
// (m1:mem{disjoint m m1})
// : Lemma (requires interp (pts_to_sl x p v) m)
// (ensures interp (pts_to_sl x p v) (Mem.join m m1))
// = ()
let pts_to_witinv (#a:Type) (r:ref a) (p:perm) : Lemma (is_witness_invariant (pts_to_sl r p)) =
let aux (x y : a) (m:mem)
: Lemma (requires (interp (pts_to_sl r p x) m /\ interp (pts_to_sl r p y) m))
(ensures (x == y))
= H.pts_to_witinv r p;
raise_val_inj x y
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
let pts_to_injective_eq #a #opened #p0 #p1 #v0 #v1 r =
extract_info_raw (pts_to r p0 v0 `star` pts_to r p1 v1) (v0 == v1)
(fun m -> pts_to_ref_injective r p0 p1 v0 v1 m);
rewrite_slprop (pts_to r p1 v1) (pts_to r p1 v0) (fun _ -> ())
let pts_to_perm
r
= H.pts_to_perm r
let alloc_pt x =
let r = H.alloc (U.raise_val x) in
rewrite_slprop (H.pts_to r full_perm (U.raise_val x)) (pts_to r full_perm x) (fun _ -> ());
return r
let read_pt #a #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
let x = H.read r in
let v':a = U.downgrade_val x in
rewrite_slprop (H.pts_to r p (hide x)) (pts_to r p v') (fun _ -> ());
return v'
let read_refine_pt #a #p q r =
Classical.forall_intro_2 reveal_equiv;
lift_exists (fun (v:a) -> pts_to r p v `star` q v);
exists_cong (fun (v:U.raise_t a) -> pts_to r p (U.downgrade_val v) `star` q (U.downgrade_val v))
(fun (v:U.raise_t a) -> H.pts_to r p v `star` U.lift_dom q v);
let x = H.read_refine (U.lift_dom q) r in
rewrite_slprop
(H.pts_to r p (hide x) `star` U.lift_dom q x)
(pts_to r p (U.downgrade_val x) `star` q (U.downgrade_val x)) (fun _ -> ());
return (U.downgrade_val x) | {
"checked_file": "/",
"dependencies": [
"Steel.Memory.fsti.checked",
"Steel.HigherReference.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Reference.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "Steel.HigherReference",
"short_module": "H"
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | r: Steel.Reference.ref a -> x: a -> Steel.Effect.SteelT Prims.unit | Steel.Effect.SteelT | [] | [] | [
"FStar.Ghost.erased",
"Steel.Reference.ref",
"Steel.Effect.Atomic.rewrite_slprop",
"FStar.Ghost.hide",
"FStar.Set.set",
"Steel.Memory.iname",
"FStar.Set.empty",
"Steel.HigherReference.pts_to",
"FStar.Universe.raise_t",
"Steel.FractionalPermission.full_perm",
"Steel.Reference.pts_to",
"Steel.Memory.mem",
"Prims.unit",
"Steel.HigherReference.write",
"FStar.Universe.raise_val",
"FStar.Ghost.reveal"
] | [] | false | true | false | false | false | let write_pt #a #v r x =
| let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
let x' = U.raise_val x in
H.write r x';
rewrite_slprop (H.pts_to r full_perm (hide x')) (pts_to r full_perm x) (fun _ -> ()) | false |
Steel.Reference.fst | Steel.Reference.ghost_read_pt | val ghost_read_pt (#a:Type) (#u:_) (#p:perm) (#v:erased a) (r:ghost_ref a)
: SteelGhost (erased a) u (ghost_pts_to r p v) (fun x -> ghost_pts_to r p x)
(requires fun _ -> True)
(ensures fun _ x _ -> x == v) | val ghost_read_pt (#a:Type) (#u:_) (#p:perm) (#v:erased a) (r:ghost_ref a)
: SteelGhost (erased a) u (ghost_pts_to r p v) (fun x -> ghost_pts_to r p x)
(requires fun _ -> True)
(ensures fun _ x _ -> x == v) | let ghost_read_pt #a #u #p #v r =
let x = H.ghost_read r in
let x' = hide (U.downgrade_val (reveal x)) in
rewrite_slprop (H.ghost_pts_to r p x) (ghost_pts_to r p x') (fun _ -> ());
x' | {
"file_name": "lib/steel/Steel.Reference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 4,
"end_line": 438,
"start_col": 0,
"start_line": 434
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.Reference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module Mem = Steel.Memory
module H = Steel.HigherReference
module U = FStar.Universe
#set-options "--ide_id_info_off"
let ref a = H.ref (U.raise_t a)
let null #a = H.null #(U.raise_t a)
let is_null #a r = H.is_null #(U.raise_t a) r
let pts_to_sl r p v = H.pts_to_sl r p (U.raise_val v)
val raise_val_inj (#a:Type) (x y:a) : Lemma
(requires U.raise_val x == U.raise_val y)
(ensures x == y)
let raise_val_inj x y =
U.downgrade_val_raise_val x;
U.downgrade_val_raise_val y
let pts_to_ref_injective
(#a: Type u#0)
(r: ref a)
(p0 p1:perm)
(v0 v1:a)
(m:mem)
: Lemma
(requires
interp (pts_to_sl r p0 v0 `Mem.star` pts_to_sl r p1 v1) m)
(ensures v0 == v1)
= let v0' = U.raise_val v0 in
let v1' = U.raise_val v1 in
H.pts_to_ref_injective r p0 p1 v0' v1' m;
raise_val_inj v0 v1
let pts_to_not_null (#a:Type u#0)
(x:ref a)
(p:perm)
(v:a)
(m:mem)
: Lemma (requires interp (pts_to_sl x p v) m)
(ensures x =!= null)
= let v = U.raise_val v in
H.pts_to_not_null #(U.raise_t a) x p v m
// let pts_to_not_null' (#a:Type u#0)
// (x:ref a)
// (p:perm)
// (v: erased a)
// (m:mem)
// (m1:mem{disjoint m m1})
// : Lemma (requires interp (pts_to_sl x p v) m)
// (ensures interp (pts_to_sl x p v) (Mem.join m m1))
// = ()
let pts_to_witinv (#a:Type) (r:ref a) (p:perm) : Lemma (is_witness_invariant (pts_to_sl r p)) =
let aux (x y : a) (m:mem)
: Lemma (requires (interp (pts_to_sl r p x) m /\ interp (pts_to_sl r p y) m))
(ensures (x == y))
= H.pts_to_witinv r p;
raise_val_inj x y
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
let pts_to_injective_eq #a #opened #p0 #p1 #v0 #v1 r =
extract_info_raw (pts_to r p0 v0 `star` pts_to r p1 v1) (v0 == v1)
(fun m -> pts_to_ref_injective r p0 p1 v0 v1 m);
rewrite_slprop (pts_to r p1 v1) (pts_to r p1 v0) (fun _ -> ())
let pts_to_perm
r
= H.pts_to_perm r
let alloc_pt x =
let r = H.alloc (U.raise_val x) in
rewrite_slprop (H.pts_to r full_perm (U.raise_val x)) (pts_to r full_perm x) (fun _ -> ());
return r
let read_pt #a #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
let x = H.read r in
let v':a = U.downgrade_val x in
rewrite_slprop (H.pts_to r p (hide x)) (pts_to r p v') (fun _ -> ());
return v'
let read_refine_pt #a #p q r =
Classical.forall_intro_2 reveal_equiv;
lift_exists (fun (v:a) -> pts_to r p v `star` q v);
exists_cong (fun (v:U.raise_t a) -> pts_to r p (U.downgrade_val v) `star` q (U.downgrade_val v))
(fun (v:U.raise_t a) -> H.pts_to r p v `star` U.lift_dom q v);
let x = H.read_refine (U.lift_dom q) r in
rewrite_slprop
(H.pts_to r p (hide x) `star` U.lift_dom q x)
(pts_to r p (U.downgrade_val x) `star` q (U.downgrade_val x)) (fun _ -> ());
return (U.downgrade_val x)
let write_pt #a #v r x =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
let x' = U.raise_val x in
H.write r x';
rewrite_slprop (H.pts_to r full_perm (hide x')) (pts_to r full_perm x) (fun _ -> ())
let free_pt #a #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
H.free r
let share_gen_pt #a #uses #p #v r p1 p2 =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
H.share_gen r p1 p2;
rewrite_slprop (H.pts_to r p1 v') (pts_to r p1 v) (fun _ -> ());
rewrite_slprop (H.pts_to r p2 v') (pts_to r p2 v) (fun _ -> ())
let share_pt #a #uses #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
H.share r;
rewrite_slprop (H.pts_to r (half_perm p) v') (pts_to r (half_perm p) v) (fun _ -> ());
rewrite_slprop (H.pts_to r (half_perm p) v') (pts_to r (half_perm p) v) (fun _ -> ())
let hide_raise_reveal (#a:Type) (v0:erased a) (v1:erased a)
: Lemma (hide (U.raise_val (reveal v0)) == hide (U.raise_val (reveal v1)) <==>
v0 == v1)
[SMTPat (hide (U.raise_val (reveal v0)));
SMTPat (hide (U.raise_val (reveal v1)))]
= let u0 = hide (U.raise_val (reveal v0)) in
let u1 = hide (U.raise_val (reveal v1)) in
assert (U.downgrade_val (U.raise_val (reveal v0)) == U.downgrade_val (U.raise_val (reveal v1)) <==>
v0 == v1)
let gather_pt #a #uses #p0 #p1 #v0 #v1 r =
let v0' = Ghost.hide (U.raise_val (Ghost.reveal v0)) in
let v1' = Ghost.hide (U.raise_val (Ghost.reveal v1)) in
rewrite_slprop (pts_to r p0 v0) (H.pts_to r p0 v0') (fun _ -> ());
rewrite_slprop (pts_to r p1 v1) (H.pts_to r p1 v1') (fun _ -> ());
let (u:unit{v0' == v1'}) = H.gather #_ #_ #p0 #p1 #v0' #v1' r in
rewrite_slprop (H.pts_to r (sum_perm p0 p1) v0') (pts_to r (sum_perm p0 p1) v0) (fun _ -> ());
u
let raise_equiv (#t:Type) (x y:t)
: Lemma (U.raise_val x == U.raise_val y <==>
x == y)
= assert (U.downgrade_val (U.raise_val x) == x);
assert (U.downgrade_val (U.raise_val y) == y)
let downgrade_equiv (#t:Type) (x y:U.raise_t t)
: Lemma (U.downgrade_val x == U.downgrade_val y <==>
x == y)
= assert (U.raise_val (U.downgrade_val x) == x);
assert (U.raise_val (U.downgrade_val y) == y)
let lift_eq (#t:eqtype) (x y:U.raise_t t)
: b:bool{b <==> x==y}
= downgrade_equiv x y; U.downgrade_val x = U.downgrade_val y
let cas_action (#t:eqtype)
(#uses:inames)
(r:ref t)
(v:Ghost.erased t)
(v_old:t)
(v_new:t)
(frame:slprop)
: MstTot (b:bool{b <==> (Ghost.reveal v == v_old)})
uses
(pts_to_sl r full_perm v)
(fun b -> if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v)
frame
(fun _ -> True)
(fun _ _ _ -> True)
= let hv = (Ghost.hide (U.raise_val (Ghost.reveal v))) in
let b = H.cas_action #(U.raise_t t)
(lift_eq #t)
#uses
r
hv
(U.raise_val v_old)
(U.raise_val v_new)
frame
in
assert (b <==> (Ghost.reveal hv == U.raise_val v_old));
assert (b <==> U.raise_val (Ghost.reveal v) == U.raise_val v_old);
raise_equiv (Ghost.reveal v) v_old;
b
let atomic_read_pt_u32 #_ #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
let x = H.atomic_read r in
let v':U32.t = U.downgrade_val x in
rewrite_slprop (H.pts_to r p (hide x)) (pts_to r p v') (fun _ -> ());
return v'
let atomic_write_pt_u32 #_ #v r x =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
let x' = U.raise_val x in
H.atomic_write r x';
rewrite_slprop (H.pts_to r full_perm (hide x')) (pts_to r full_perm x) (fun _ -> ())
let cas_pt_u32 #uses r v v_old v_new =
let b = as_atomic_action (cas_action #U32.t #uses r v v_old v_new) in
rewrite_slprop (to_vprop (if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v))
(if b then pts_to r full_perm v_new else pts_to r full_perm v)
(fun _ -> ());
return b
let cas_pt_bool #uses r v v_old v_new =
let b = as_atomic_action (cas_action #bool #uses r v v_old v_new) in
rewrite_slprop (to_vprop (if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v))
(if b then pts_to r full_perm v_new else pts_to r full_perm v)
(fun _ -> ());
return b
(* Library for references with fractional permissions.
Permissions need to be an index of the vprop ptr.
It cannot be part of a selector, as it is not invariant when joining with a disjoint memory
Using the value of the ref as a selector is ok because refs with fractional permissions
all share the same value.
Refs on PCM are more complicated, and likely not usable with selectors
*)
let ptrp r p = Mem.h_exists (pts_to_sl r p)
val ptr_sel' (#a:Type0) (r: ref a) (p: perm) : selector' a (ptrp r p)
let ptr_sel' #a r p = fun h -> id_elim_exists #a (pts_to_sl r p) h
let ptr_sel_depends_only_on (#a:Type0) (r:ref a)
(p: perm)
(m0:Mem.hmem (ptrp r p)) (m1:mem{disjoint m0 m1})
: Lemma (ptr_sel' r p m0 == ptr_sel' r p (Mem.join m0 m1))
= let x = reveal (id_elim_exists #a (pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (pts_to_sl r p) (Mem.join m0 m1)) in
pts_to_witinv r p;
elim_wi (pts_to_sl r p) x y (Mem.join m0 m1)
let ptr_sel_depends_only_on_core (#a:Type0) (r:ref a)
(p: perm) (m0:Mem.hmem (ptrp r p))
: Lemma (ptr_sel' r p m0 == ptr_sel' r p (core_mem m0))
= let x = reveal (id_elim_exists #a (pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (pts_to_sl r p) (core_mem m0)) in
pts_to_witinv r p;
elim_wi (pts_to_sl r p) x y (core_mem m0)
let ptrp_sel r p =
Classical.forall_intro_2 (ptr_sel_depends_only_on r p);
Classical.forall_intro (ptr_sel_depends_only_on_core r p);
ptr_sel' r p
let ptrp_sel_interp #a r p m = pts_to_witinv r p
let intro_ptrp_interp r p v m = intro_h_exists (reveal v) (pts_to_sl r p) m
let intro_vptr_lemma (#a:Type) (r:ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (pts_to_sl r p v) m)
(ensures interp (ptrp r p) m /\ ptrp_sel r p m == reveal v)
= Mem.intro_h_exists (reveal v) (pts_to_sl r p) m;
pts_to_witinv r p
let elim_vptr_lemma (#a:Type) (r:ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (ptrp r p) m /\ ptrp_sel r p m == reveal v)
(ensures interp (pts_to_sl r p v) m)
= Mem.elim_h_exists (pts_to_sl r p) m;
pts_to_witinv r p
let intro_vptr (#a:Type) (#opened:inames) (r:ref a) (p: perm) (v:erased a)
: SteelGhost unit opened (pts_to r p v) (fun _ -> vptrp r p)
(requires fun _ -> True)
(ensures fun _ _ h1 -> h1 (vptrp r p) == reveal v)
= change_slprop_2 (pts_to r p v) (vptrp r p) v (intro_vptr_lemma r p v)
let elim_vptr (#a:Type) (#opened:inames) (r:ref a) (p: perm)
: SteelGhost (erased a) opened (vptrp r p) (fun v -> pts_to r p v)
(requires fun _ -> True)
(ensures fun h0 v _ -> reveal v == h0 (vptrp r p))
= let v = gget (vptrp r p) in
change_slprop (vptrp r p) (pts_to r p v) v () (elim_vptr_lemma r p v);
v
let malloc x =
let r = alloc_pt x in
intro_vptr r _ (hide x);
return r
let free r =
let _ = elim_vptr r _ in
free_pt r
let readp r _ =
let _ = elim_vptr r _ in
let x = read_pt r in
intro_vptr r _ x;
return x
let write r x =
let _ = elim_vptr r _ in
write_pt r x;
intro_vptr r _ x
let share #a #_ #p r =
let x = elim_vptr r p in
share_pt r;
intro_vptr r _ x;
intro_vptr r _ x
let gather_gen #a #_ r p0 p1 =
let x1 = elim_vptr r p1 in
let x0 = elim_vptr r p0 in
gather_pt #_ #_ #p0 #p1 #x0 #x1 r;
intro_vptr r (sum_perm p0 p1) x0;
sum_perm p0 p1
let gather (#a: Type0) (#uses: _) (#p: perm) (r: ref a)
: SteelGhost unit uses
(vptrp r (half_perm p) `star` vptrp r (half_perm p))
(fun _ -> vptrp r p)
(fun _ -> True)
(fun h _ h' ->
h' (vptrp r p) == h (vptrp r (half_perm p))
)
= let _ = gather_gen r _ _ in
change_equal_slprop
(vptrp r _)
(vptrp r p)
(*** Lemmas on references *)
let vptrp_not_null
#opened #a r
p
= change_slprop_rel
(vptrp r p)
(vptrp r p)
(fun x y -> x == y /\ is_null r == false)
(fun m -> pts_to_not_null r p (ptrp_sel r p m) m)
(*** Ghost pointers *)
(*** GHOST REFERENCES ***)
let ghost_ref a = H.ghost_ref (U.raise_t a)
let dummy_ghost_ref a =
H.reveal_ghost_ref (U.raise_t a);
coerce_eq () (Ghost.hide (H.null #(U.raise_t a)))
[@__reduce__]
let ghost_pts_to_sl #a r p x = H.ghost_pts_to_sl #(U.raise_t a) r p (U.raise_val x)
let ghost_pts_to_witinv (#a:Type) (r:ghost_ref a) (p:perm) : Lemma (is_witness_invariant (ghost_pts_to_sl r p)) =
let aux (x y : a) (m:mem)
: Lemma (requires (interp (ghost_pts_to_sl r p x) m /\ interp (ghost_pts_to_sl r p y) m))
(ensures (x == y))
= H.ghost_pts_to_witinv r p;
raise_val_inj x y
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
[@@__reduce__]
let raise_erased (#a:Type0) (x:erased a)
: erased (U.raise_t u#0 u#1 a)
= Ghost.hide (U.raise_val (Ghost.reveal x))
let ghost_alloc_pt (#a:Type) (#u:_) (x:erased a)
: SteelGhostT (ghost_ref a) u
emp
(fun r -> ghost_pts_to r full_perm x)
= H.ghost_alloc (raise_erased x)
let ghost_free_pt r = H.ghost_free r
let ghost_share_gen_pt
#_ #_ #_ #x r p1 p2
= H.ghost_share_gen #_ #_ #_ #(raise_erased x) r p1 p2
let ghost_share_pt (#a:Type) (#u:_)
(#p:perm)
(#x:erased a)
(r:ghost_ref a)
= H.ghost_share #_ #_ #_ #(raise_erased x) r
let ghost_gather_pt (#a:Type) (#u:_)
(#p0 #p1:perm)
(#x0 #x1:erased a)
(r:ghost_ref a)
: SteelGhost unit u
(ghost_pts_to r p0 x0 `star`
ghost_pts_to r p1 x1)
(fun _ -> ghost_pts_to r (sum_perm p0 p1) x0)
(requires fun _ -> true)
(ensures fun _ _ _ -> x0 == x1)
= H.ghost_gather r
let ghost_pts_to_injective_eq (#a:_) (#u:_) (#p #q:_) (r:ghost_ref a) (v0 v1:Ghost.erased a)
: SteelGhost unit u
(ghost_pts_to r p v0 `star` ghost_pts_to r q v1)
(fun _ -> ghost_pts_to r p v0 `star` ghost_pts_to r q v0)
(requires fun _ -> True)
(ensures fun _ _ _ -> v0 == v1)
= H.ghost_pts_to_injective_eq #_ #_ #p #q r (raise_erased v0) (raise_erased v1)
let ghost_pts_to_perm r = H.ghost_pts_to_perm r | {
"checked_file": "/",
"dependencies": [
"Steel.Memory.fsti.checked",
"Steel.HigherReference.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Reference.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "Steel.HigherReference",
"short_module": "H"
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | r: Steel.Reference.ghost_ref a -> Steel.Effect.Atomic.SteelGhost (FStar.Ghost.erased a) | Steel.Effect.Atomic.SteelGhost | [] | [] | [
"Steel.Memory.inames",
"Steel.FractionalPermission.perm",
"FStar.Ghost.erased",
"Steel.Reference.ghost_ref",
"Prims.unit",
"Steel.Effect.Atomic.rewrite_slprop",
"Steel.HigherReference.ghost_pts_to",
"FStar.Universe.raise_t",
"FStar.Ghost.reveal",
"Steel.Reference.ghost_pts_to",
"Steel.Memory.mem",
"FStar.Ghost.hide",
"FStar.Universe.downgrade_val",
"Steel.HigherReference.ghost_read",
"FStar.Universe.raise_val"
] | [] | false | true | false | false | false | let ghost_read_pt #a #u #p #v r =
| let x = H.ghost_read r in
let x' = hide (U.downgrade_val (reveal x)) in
rewrite_slprop (H.ghost_pts_to r p x) (ghost_pts_to r p x') (fun _ -> ());
x' | false |
EverParse3d.CopyBuffer.fsti | EverParse3d.CopyBuffer.loc_of | val loc_of (x: copy_buffer_t) : GTot B.loc | val loc_of (x: copy_buffer_t) : GTot B.loc | let loc_of (x:copy_buffer_t) : GTot B.loc =
I.footprint (stream_of x) | {
"file_name": "src/3d/prelude/EverParse3d.CopyBuffer.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 27,
"end_line": 18,
"start_col": 0,
"start_line": 17
} | module EverParse3d.CopyBuffer
module AppCtxt = EverParse3d.AppCtxt
module I = EverParse3d.InputStream.All
module B = LowStar.Buffer
module HS = FStar.HyperStack
module U64 = FStar.UInt64
open LowStar.Buffer
open FStar.HyperStack.ST
val region : HS.rid
val copy_buffer_t : Type0
val stream_of : copy_buffer_t -> I.t
val stream_len (c:copy_buffer_t) : I.tlen (stream_of c) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"EverParse3d.InputStream.All.fsti.checked",
"EverParse3d.AppCtxt.fsti.checked"
],
"interface_file": false,
"source_file": "EverParse3d.CopyBuffer.fsti"
} | [
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Buffer",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "EverParse3d.InputStream.All",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "EverParse3d.AppCtxt",
"short_module": "AppCtxt"
},
{
"abbrev": false,
"full_module": "EverParse3d",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverParse3d",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 2,
"max_fuel": 0,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=10"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | x: EverParse3d.CopyBuffer.copy_buffer_t -> Prims.GTot LowStar.Monotonic.Buffer.loc | Prims.GTot | [
"sometrivial"
] | [] | [
"EverParse3d.CopyBuffer.copy_buffer_t",
"EverParse3d.InputStream.Base.footprint",
"EverParse3d.InputStream.All.t",
"EverParse3d.InputStream.All.inst",
"EverParse3d.CopyBuffer.stream_of",
"LowStar.Monotonic.Buffer.loc"
] | [] | false | false | false | false | false | let loc_of (x: copy_buffer_t) : GTot B.loc =
| I.footprint (stream_of x) | false |
EverParse3d.CopyBuffer.fsti | EverParse3d.CopyBuffer.inv | val inv : x: EverParse3d.CopyBuffer.copy_buffer_t -> h: FStar.Monotonic.HyperStack.mem -> Prims.prop | let inv (x:copy_buffer_t) (h:HS.mem) = I.live (stream_of x) h | {
"file_name": "src/3d/prelude/EverParse3d.CopyBuffer.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 61,
"end_line": 20,
"start_col": 0,
"start_line": 20
} | module EverParse3d.CopyBuffer
module AppCtxt = EverParse3d.AppCtxt
module I = EverParse3d.InputStream.All
module B = LowStar.Buffer
module HS = FStar.HyperStack
module U64 = FStar.UInt64
open LowStar.Buffer
open FStar.HyperStack.ST
val region : HS.rid
val copy_buffer_t : Type0
val stream_of : copy_buffer_t -> I.t
val stream_len (c:copy_buffer_t) : I.tlen (stream_of c)
let loc_of (x:copy_buffer_t) : GTot B.loc =
I.footprint (stream_of x) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"EverParse3d.InputStream.All.fsti.checked",
"EverParse3d.AppCtxt.fsti.checked"
],
"interface_file": false,
"source_file": "EverParse3d.CopyBuffer.fsti"
} | [
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Buffer",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "EverParse3d.InputStream.All",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "EverParse3d.AppCtxt",
"short_module": "AppCtxt"
},
{
"abbrev": false,
"full_module": "EverParse3d",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverParse3d",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 2,
"max_fuel": 0,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=10"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | x: EverParse3d.CopyBuffer.copy_buffer_t -> h: FStar.Monotonic.HyperStack.mem -> Prims.prop | Prims.Tot | [
"total"
] | [] | [
"EverParse3d.CopyBuffer.copy_buffer_t",
"FStar.Monotonic.HyperStack.mem",
"EverParse3d.InputStream.Base.live",
"EverParse3d.InputStream.All.t",
"EverParse3d.InputStream.All.inst",
"EverParse3d.CopyBuffer.stream_of",
"Prims.prop"
] | [] | false | false | false | true | true | let inv (x: copy_buffer_t) (h: HS.mem) =
| I.live (stream_of x) h | false |
|
EverParse3d.CopyBuffer.fsti | EverParse3d.CopyBuffer.liveness_preserved | val liveness_preserved : x: EverParse3d.CopyBuffer.copy_buffer_t -> Prims.logical | let liveness_preserved (x:copy_buffer_t) =
let sl = stream_of x in
forall l h0 h1. {:pattern (modifies l h0 h1)}
(I.live sl h0 /\
B.modifies l h0 h1 /\
address_liveness_insensitive_locs `loc_includes` l) ==>
I.live sl h1 | {
"file_name": "src/3d/prelude/EverParse3d.CopyBuffer.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 16,
"end_line": 28,
"start_col": 0,
"start_line": 22
} | module EverParse3d.CopyBuffer
module AppCtxt = EverParse3d.AppCtxt
module I = EverParse3d.InputStream.All
module B = LowStar.Buffer
module HS = FStar.HyperStack
module U64 = FStar.UInt64
open LowStar.Buffer
open FStar.HyperStack.ST
val region : HS.rid
val copy_buffer_t : Type0
val stream_of : copy_buffer_t -> I.t
val stream_len (c:copy_buffer_t) : I.tlen (stream_of c)
let loc_of (x:copy_buffer_t) : GTot B.loc =
I.footprint (stream_of x)
let inv (x:copy_buffer_t) (h:HS.mem) = I.live (stream_of x) h | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"EverParse3d.InputStream.All.fsti.checked",
"EverParse3d.AppCtxt.fsti.checked"
],
"interface_file": false,
"source_file": "EverParse3d.CopyBuffer.fsti"
} | [
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Buffer",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "EverParse3d.InputStream.All",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "EverParse3d.AppCtxt",
"short_module": "AppCtxt"
},
{
"abbrev": false,
"full_module": "EverParse3d",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverParse3d",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 2,
"max_fuel": 0,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=10"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | x: EverParse3d.CopyBuffer.copy_buffer_t -> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"EverParse3d.CopyBuffer.copy_buffer_t",
"Prims.l_Forall",
"LowStar.Monotonic.Buffer.loc",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_imp",
"Prims.l_and",
"EverParse3d.InputStream.Base.live",
"EverParse3d.InputStream.All.t",
"EverParse3d.InputStream.All.inst",
"LowStar.Monotonic.Buffer.modifies",
"LowStar.Monotonic.Buffer.loc_includes",
"LowStar.Monotonic.Buffer.address_liveness_insensitive_locs",
"EverParse3d.CopyBuffer.stream_of",
"Prims.logical"
] | [] | false | false | false | true | true | let liveness_preserved (x: copy_buffer_t) =
| let sl = stream_of x in
forall l h0 h1. {:pattern (modifies l h0 h1)}
(I.live sl h0 /\ B.modifies l h0 h1 /\ address_liveness_insensitive_locs `loc_includes` l) ==>
I.live sl h1 | false |
|
Steel.Reference.fst | Steel.Reference.elim_vptr | val elim_vptr (#a:Type) (#opened:inames) (r:ref a) (p: perm)
: SteelGhost (erased a) opened (vptrp r p) (fun v -> pts_to r p v)
(requires fun _ -> True)
(ensures fun h0 v _ -> reveal v == h0 (vptrp r p)) | val elim_vptr (#a:Type) (#opened:inames) (r:ref a) (p: perm)
: SteelGhost (erased a) opened (vptrp r p) (fun v -> pts_to r p v)
(requires fun _ -> True)
(ensures fun h0 v _ -> reveal v == h0 (vptrp r p)) | let elim_vptr (#a:Type) (#opened:inames) (r:ref a) (p: perm)
: SteelGhost (erased a) opened (vptrp r p) (fun v -> pts_to r p v)
(requires fun _ -> True)
(ensures fun h0 v _ -> reveal v == h0 (vptrp r p))
= let v = gget (vptrp r p) in
change_slprop (vptrp r p) (pts_to r p v) v () (elim_vptr_lemma r p v);
v | {
"file_name": "lib/steel/Steel.Reference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 5,
"end_line": 308,
"start_col": 0,
"start_line": 302
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.Reference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module Mem = Steel.Memory
module H = Steel.HigherReference
module U = FStar.Universe
#set-options "--ide_id_info_off"
let ref a = H.ref (U.raise_t a)
let null #a = H.null #(U.raise_t a)
let is_null #a r = H.is_null #(U.raise_t a) r
let pts_to_sl r p v = H.pts_to_sl r p (U.raise_val v)
val raise_val_inj (#a:Type) (x y:a) : Lemma
(requires U.raise_val x == U.raise_val y)
(ensures x == y)
let raise_val_inj x y =
U.downgrade_val_raise_val x;
U.downgrade_val_raise_val y
let pts_to_ref_injective
(#a: Type u#0)
(r: ref a)
(p0 p1:perm)
(v0 v1:a)
(m:mem)
: Lemma
(requires
interp (pts_to_sl r p0 v0 `Mem.star` pts_to_sl r p1 v1) m)
(ensures v0 == v1)
= let v0' = U.raise_val v0 in
let v1' = U.raise_val v1 in
H.pts_to_ref_injective r p0 p1 v0' v1' m;
raise_val_inj v0 v1
let pts_to_not_null (#a:Type u#0)
(x:ref a)
(p:perm)
(v:a)
(m:mem)
: Lemma (requires interp (pts_to_sl x p v) m)
(ensures x =!= null)
= let v = U.raise_val v in
H.pts_to_not_null #(U.raise_t a) x p v m
// let pts_to_not_null' (#a:Type u#0)
// (x:ref a)
// (p:perm)
// (v: erased a)
// (m:mem)
// (m1:mem{disjoint m m1})
// : Lemma (requires interp (pts_to_sl x p v) m)
// (ensures interp (pts_to_sl x p v) (Mem.join m m1))
// = ()
let pts_to_witinv (#a:Type) (r:ref a) (p:perm) : Lemma (is_witness_invariant (pts_to_sl r p)) =
let aux (x y : a) (m:mem)
: Lemma (requires (interp (pts_to_sl r p x) m /\ interp (pts_to_sl r p y) m))
(ensures (x == y))
= H.pts_to_witinv r p;
raise_val_inj x y
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
let pts_to_injective_eq #a #opened #p0 #p1 #v0 #v1 r =
extract_info_raw (pts_to r p0 v0 `star` pts_to r p1 v1) (v0 == v1)
(fun m -> pts_to_ref_injective r p0 p1 v0 v1 m);
rewrite_slprop (pts_to r p1 v1) (pts_to r p1 v0) (fun _ -> ())
let pts_to_perm
r
= H.pts_to_perm r
let alloc_pt x =
let r = H.alloc (U.raise_val x) in
rewrite_slprop (H.pts_to r full_perm (U.raise_val x)) (pts_to r full_perm x) (fun _ -> ());
return r
let read_pt #a #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
let x = H.read r in
let v':a = U.downgrade_val x in
rewrite_slprop (H.pts_to r p (hide x)) (pts_to r p v') (fun _ -> ());
return v'
let read_refine_pt #a #p q r =
Classical.forall_intro_2 reveal_equiv;
lift_exists (fun (v:a) -> pts_to r p v `star` q v);
exists_cong (fun (v:U.raise_t a) -> pts_to r p (U.downgrade_val v) `star` q (U.downgrade_val v))
(fun (v:U.raise_t a) -> H.pts_to r p v `star` U.lift_dom q v);
let x = H.read_refine (U.lift_dom q) r in
rewrite_slprop
(H.pts_to r p (hide x) `star` U.lift_dom q x)
(pts_to r p (U.downgrade_val x) `star` q (U.downgrade_val x)) (fun _ -> ());
return (U.downgrade_val x)
let write_pt #a #v r x =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
let x' = U.raise_val x in
H.write r x';
rewrite_slprop (H.pts_to r full_perm (hide x')) (pts_to r full_perm x) (fun _ -> ())
let free_pt #a #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
H.free r
let share_gen_pt #a #uses #p #v r p1 p2 =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
H.share_gen r p1 p2;
rewrite_slprop (H.pts_to r p1 v') (pts_to r p1 v) (fun _ -> ());
rewrite_slprop (H.pts_to r p2 v') (pts_to r p2 v) (fun _ -> ())
let share_pt #a #uses #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
H.share r;
rewrite_slprop (H.pts_to r (half_perm p) v') (pts_to r (half_perm p) v) (fun _ -> ());
rewrite_slprop (H.pts_to r (half_perm p) v') (pts_to r (half_perm p) v) (fun _ -> ())
let hide_raise_reveal (#a:Type) (v0:erased a) (v1:erased a)
: Lemma (hide (U.raise_val (reveal v0)) == hide (U.raise_val (reveal v1)) <==>
v0 == v1)
[SMTPat (hide (U.raise_val (reveal v0)));
SMTPat (hide (U.raise_val (reveal v1)))]
= let u0 = hide (U.raise_val (reveal v0)) in
let u1 = hide (U.raise_val (reveal v1)) in
assert (U.downgrade_val (U.raise_val (reveal v0)) == U.downgrade_val (U.raise_val (reveal v1)) <==>
v0 == v1)
let gather_pt #a #uses #p0 #p1 #v0 #v1 r =
let v0' = Ghost.hide (U.raise_val (Ghost.reveal v0)) in
let v1' = Ghost.hide (U.raise_val (Ghost.reveal v1)) in
rewrite_slprop (pts_to r p0 v0) (H.pts_to r p0 v0') (fun _ -> ());
rewrite_slprop (pts_to r p1 v1) (H.pts_to r p1 v1') (fun _ -> ());
let (u:unit{v0' == v1'}) = H.gather #_ #_ #p0 #p1 #v0' #v1' r in
rewrite_slprop (H.pts_to r (sum_perm p0 p1) v0') (pts_to r (sum_perm p0 p1) v0) (fun _ -> ());
u
let raise_equiv (#t:Type) (x y:t)
: Lemma (U.raise_val x == U.raise_val y <==>
x == y)
= assert (U.downgrade_val (U.raise_val x) == x);
assert (U.downgrade_val (U.raise_val y) == y)
let downgrade_equiv (#t:Type) (x y:U.raise_t t)
: Lemma (U.downgrade_val x == U.downgrade_val y <==>
x == y)
= assert (U.raise_val (U.downgrade_val x) == x);
assert (U.raise_val (U.downgrade_val y) == y)
let lift_eq (#t:eqtype) (x y:U.raise_t t)
: b:bool{b <==> x==y}
= downgrade_equiv x y; U.downgrade_val x = U.downgrade_val y
let cas_action (#t:eqtype)
(#uses:inames)
(r:ref t)
(v:Ghost.erased t)
(v_old:t)
(v_new:t)
(frame:slprop)
: MstTot (b:bool{b <==> (Ghost.reveal v == v_old)})
uses
(pts_to_sl r full_perm v)
(fun b -> if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v)
frame
(fun _ -> True)
(fun _ _ _ -> True)
= let hv = (Ghost.hide (U.raise_val (Ghost.reveal v))) in
let b = H.cas_action #(U.raise_t t)
(lift_eq #t)
#uses
r
hv
(U.raise_val v_old)
(U.raise_val v_new)
frame
in
assert (b <==> (Ghost.reveal hv == U.raise_val v_old));
assert (b <==> U.raise_val (Ghost.reveal v) == U.raise_val v_old);
raise_equiv (Ghost.reveal v) v_old;
b
let atomic_read_pt_u32 #_ #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
let x = H.atomic_read r in
let v':U32.t = U.downgrade_val x in
rewrite_slprop (H.pts_to r p (hide x)) (pts_to r p v') (fun _ -> ());
return v'
let atomic_write_pt_u32 #_ #v r x =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
let x' = U.raise_val x in
H.atomic_write r x';
rewrite_slprop (H.pts_to r full_perm (hide x')) (pts_to r full_perm x) (fun _ -> ())
let cas_pt_u32 #uses r v v_old v_new =
let b = as_atomic_action (cas_action #U32.t #uses r v v_old v_new) in
rewrite_slprop (to_vprop (if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v))
(if b then pts_to r full_perm v_new else pts_to r full_perm v)
(fun _ -> ());
return b
let cas_pt_bool #uses r v v_old v_new =
let b = as_atomic_action (cas_action #bool #uses r v v_old v_new) in
rewrite_slprop (to_vprop (if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v))
(if b then pts_to r full_perm v_new else pts_to r full_perm v)
(fun _ -> ());
return b
(* Library for references with fractional permissions.
Permissions need to be an index of the vprop ptr.
It cannot be part of a selector, as it is not invariant when joining with a disjoint memory
Using the value of the ref as a selector is ok because refs with fractional permissions
all share the same value.
Refs on PCM are more complicated, and likely not usable with selectors
*)
let ptrp r p = Mem.h_exists (pts_to_sl r p)
val ptr_sel' (#a:Type0) (r: ref a) (p: perm) : selector' a (ptrp r p)
let ptr_sel' #a r p = fun h -> id_elim_exists #a (pts_to_sl r p) h
let ptr_sel_depends_only_on (#a:Type0) (r:ref a)
(p: perm)
(m0:Mem.hmem (ptrp r p)) (m1:mem{disjoint m0 m1})
: Lemma (ptr_sel' r p m0 == ptr_sel' r p (Mem.join m0 m1))
= let x = reveal (id_elim_exists #a (pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (pts_to_sl r p) (Mem.join m0 m1)) in
pts_to_witinv r p;
elim_wi (pts_to_sl r p) x y (Mem.join m0 m1)
let ptr_sel_depends_only_on_core (#a:Type0) (r:ref a)
(p: perm) (m0:Mem.hmem (ptrp r p))
: Lemma (ptr_sel' r p m0 == ptr_sel' r p (core_mem m0))
= let x = reveal (id_elim_exists #a (pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (pts_to_sl r p) (core_mem m0)) in
pts_to_witinv r p;
elim_wi (pts_to_sl r p) x y (core_mem m0)
let ptrp_sel r p =
Classical.forall_intro_2 (ptr_sel_depends_only_on r p);
Classical.forall_intro (ptr_sel_depends_only_on_core r p);
ptr_sel' r p
let ptrp_sel_interp #a r p m = pts_to_witinv r p
let intro_ptrp_interp r p v m = intro_h_exists (reveal v) (pts_to_sl r p) m
let intro_vptr_lemma (#a:Type) (r:ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (pts_to_sl r p v) m)
(ensures interp (ptrp r p) m /\ ptrp_sel r p m == reveal v)
= Mem.intro_h_exists (reveal v) (pts_to_sl r p) m;
pts_to_witinv r p
let elim_vptr_lemma (#a:Type) (r:ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (ptrp r p) m /\ ptrp_sel r p m == reveal v)
(ensures interp (pts_to_sl r p v) m)
= Mem.elim_h_exists (pts_to_sl r p) m;
pts_to_witinv r p
let intro_vptr (#a:Type) (#opened:inames) (r:ref a) (p: perm) (v:erased a)
: SteelGhost unit opened (pts_to r p v) (fun _ -> vptrp r p)
(requires fun _ -> True)
(ensures fun _ _ h1 -> h1 (vptrp r p) == reveal v)
= change_slprop_2 (pts_to r p v) (vptrp r p) v (intro_vptr_lemma r p v) | {
"checked_file": "/",
"dependencies": [
"Steel.Memory.fsti.checked",
"Steel.HigherReference.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Reference.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "Steel.HigherReference",
"short_module": "H"
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | r: Steel.Reference.ref a -> p: Steel.FractionalPermission.perm
-> Steel.Effect.Atomic.SteelGhost (FStar.Ghost.erased a) | Steel.Effect.Atomic.SteelGhost | [] | [] | [
"Steel.Memory.inames",
"Steel.Reference.ref",
"Steel.FractionalPermission.perm",
"FStar.Ghost.erased",
"Prims.unit",
"Steel.Effect.Atomic.change_slprop",
"Steel.Reference.vptrp",
"Steel.Reference.pts_to",
"FStar.Ghost.reveal",
"Steel.Effect.Common.t_of",
"FStar.Ghost.hide",
"Steel.Effect.Common.normal",
"Steel.Reference.elim_vptr_lemma",
"Steel.Effect.Common.VUnit",
"Steel.Reference.vptr'",
"Steel.Effect.Atomic.gget",
"Steel.Effect.Common.vprop",
"Steel.Effect.Common.rmem",
"Prims.l_True",
"Prims.eq2"
] | [] | false | true | false | false | false | let elim_vptr (#a: Type) (#opened: inames) (r: ref a) (p: perm)
: SteelGhost (erased a)
opened
(vptrp r p)
(fun v -> pts_to r p v)
(requires fun _ -> True)
(ensures fun h0 v _ -> reveal v == h0 (vptrp r p)) =
| let v = gget (vptrp r p) in
change_slprop (vptrp r p) (pts_to r p v) v () (elim_vptr_lemma r p v);
v | false |
Steel.Reference.fst | Steel.Reference.share_gen_pt | val share_gen_pt (#a:Type0)
(#uses:_)
(#p:perm)
(#v: a)
(r:ref a)
(p1 p2: perm)
: SteelGhost unit uses
(pts_to r p v)
(fun _ -> pts_to r p1 v `star` pts_to r p2 v)
(fun _ -> p == p1 `sum_perm` p2)
(fun _ _ _ -> True) | val share_gen_pt (#a:Type0)
(#uses:_)
(#p:perm)
(#v: a)
(r:ref a)
(p1 p2: perm)
: SteelGhost unit uses
(pts_to r p v)
(fun _ -> pts_to r p1 v `star` pts_to r p2 v)
(fun _ -> p == p1 `sum_perm` p2)
(fun _ _ _ -> True) | let share_gen_pt #a #uses #p #v r p1 p2 =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
H.share_gen r p1 p2;
rewrite_slprop (H.pts_to r p1 v') (pts_to r p1 v) (fun _ -> ());
rewrite_slprop (H.pts_to r p2 v') (pts_to r p2 v) (fun _ -> ()) | {
"file_name": "lib/steel/Steel.Reference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 65,
"end_line": 141,
"start_col": 0,
"start_line": 136
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.Reference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module Mem = Steel.Memory
module H = Steel.HigherReference
module U = FStar.Universe
#set-options "--ide_id_info_off"
let ref a = H.ref (U.raise_t a)
let null #a = H.null #(U.raise_t a)
let is_null #a r = H.is_null #(U.raise_t a) r
let pts_to_sl r p v = H.pts_to_sl r p (U.raise_val v)
val raise_val_inj (#a:Type) (x y:a) : Lemma
(requires U.raise_val x == U.raise_val y)
(ensures x == y)
let raise_val_inj x y =
U.downgrade_val_raise_val x;
U.downgrade_val_raise_val y
let pts_to_ref_injective
(#a: Type u#0)
(r: ref a)
(p0 p1:perm)
(v0 v1:a)
(m:mem)
: Lemma
(requires
interp (pts_to_sl r p0 v0 `Mem.star` pts_to_sl r p1 v1) m)
(ensures v0 == v1)
= let v0' = U.raise_val v0 in
let v1' = U.raise_val v1 in
H.pts_to_ref_injective r p0 p1 v0' v1' m;
raise_val_inj v0 v1
let pts_to_not_null (#a:Type u#0)
(x:ref a)
(p:perm)
(v:a)
(m:mem)
: Lemma (requires interp (pts_to_sl x p v) m)
(ensures x =!= null)
= let v = U.raise_val v in
H.pts_to_not_null #(U.raise_t a) x p v m
// let pts_to_not_null' (#a:Type u#0)
// (x:ref a)
// (p:perm)
// (v: erased a)
// (m:mem)
// (m1:mem{disjoint m m1})
// : Lemma (requires interp (pts_to_sl x p v) m)
// (ensures interp (pts_to_sl x p v) (Mem.join m m1))
// = ()
let pts_to_witinv (#a:Type) (r:ref a) (p:perm) : Lemma (is_witness_invariant (pts_to_sl r p)) =
let aux (x y : a) (m:mem)
: Lemma (requires (interp (pts_to_sl r p x) m /\ interp (pts_to_sl r p y) m))
(ensures (x == y))
= H.pts_to_witinv r p;
raise_val_inj x y
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
let pts_to_injective_eq #a #opened #p0 #p1 #v0 #v1 r =
extract_info_raw (pts_to r p0 v0 `star` pts_to r p1 v1) (v0 == v1)
(fun m -> pts_to_ref_injective r p0 p1 v0 v1 m);
rewrite_slprop (pts_to r p1 v1) (pts_to r p1 v0) (fun _ -> ())
let pts_to_perm
r
= H.pts_to_perm r
let alloc_pt x =
let r = H.alloc (U.raise_val x) in
rewrite_slprop (H.pts_to r full_perm (U.raise_val x)) (pts_to r full_perm x) (fun _ -> ());
return r
let read_pt #a #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
let x = H.read r in
let v':a = U.downgrade_val x in
rewrite_slprop (H.pts_to r p (hide x)) (pts_to r p v') (fun _ -> ());
return v'
let read_refine_pt #a #p q r =
Classical.forall_intro_2 reveal_equiv;
lift_exists (fun (v:a) -> pts_to r p v `star` q v);
exists_cong (fun (v:U.raise_t a) -> pts_to r p (U.downgrade_val v) `star` q (U.downgrade_val v))
(fun (v:U.raise_t a) -> H.pts_to r p v `star` U.lift_dom q v);
let x = H.read_refine (U.lift_dom q) r in
rewrite_slprop
(H.pts_to r p (hide x) `star` U.lift_dom q x)
(pts_to r p (U.downgrade_val x) `star` q (U.downgrade_val x)) (fun _ -> ());
return (U.downgrade_val x)
let write_pt #a #v r x =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
let x' = U.raise_val x in
H.write r x';
rewrite_slprop (H.pts_to r full_perm (hide x')) (pts_to r full_perm x) (fun _ -> ())
let free_pt #a #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
H.free r | {
"checked_file": "/",
"dependencies": [
"Steel.Memory.fsti.checked",
"Steel.HigherReference.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Reference.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "Steel.HigherReference",
"short_module": "H"
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
r: Steel.Reference.ref a ->
p1: Steel.FractionalPermission.perm ->
p2: Steel.FractionalPermission.perm
-> Steel.Effect.Atomic.SteelGhost Prims.unit | Steel.Effect.Atomic.SteelGhost | [] | [] | [
"Steel.Memory.inames",
"Steel.FractionalPermission.perm",
"Steel.Reference.ref",
"Steel.Effect.Atomic.rewrite_slprop",
"Steel.HigherReference.pts_to",
"FStar.Universe.raise_t",
"FStar.Ghost.reveal",
"Steel.Reference.pts_to",
"Steel.Memory.mem",
"Prims.unit",
"Steel.HigherReference.share_gen",
"FStar.Ghost.erased",
"FStar.Ghost.hide",
"FStar.Universe.raise_val"
] | [] | false | true | false | false | false | let share_gen_pt #a #uses #p #v r p1 p2 =
| let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
H.share_gen r p1 p2;
rewrite_slprop (H.pts_to r p1 v') (pts_to r p1 v) (fun _ -> ());
rewrite_slprop (H.pts_to r p2 v') (pts_to r p2 v) (fun _ -> ()) | false |
EverParse3d.CopyBuffer.fsti | EverParse3d.CopyBuffer.probe_fn | val probe_fn : Type0 | let probe_fn = src:U64.t -> len:U64.t -> dest:copy_buffer_t ->
Stack bool
(fun h0 ->
I.live (stream_of dest) h0)
(fun h0 b h1 ->
let sl = stream_of dest in
I.live sl h1 /\
(if b
then (
Seq.length (I.get_read sl h1) == 0 /\
modifies (I.footprint sl) h0 h1
)
else (
h0 == h1
))) | {
"file_name": "src/3d/prelude/EverParse3d.CopyBuffer.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 10,
"end_line": 52,
"start_col": 0,
"start_line": 38
} | module EverParse3d.CopyBuffer
module AppCtxt = EverParse3d.AppCtxt
module I = EverParse3d.InputStream.All
module B = LowStar.Buffer
module HS = FStar.HyperStack
module U64 = FStar.UInt64
open LowStar.Buffer
open FStar.HyperStack.ST
val region : HS.rid
val copy_buffer_t : Type0
val stream_of : copy_buffer_t -> I.t
val stream_len (c:copy_buffer_t) : I.tlen (stream_of c)
let loc_of (x:copy_buffer_t) : GTot B.loc =
I.footprint (stream_of x)
let inv (x:copy_buffer_t) (h:HS.mem) = I.live (stream_of x) h
let liveness_preserved (x:copy_buffer_t) =
let sl = stream_of x in
forall l h0 h1. {:pattern (modifies l h0 h1)}
(I.live sl h0 /\
B.modifies l h0 h1 /\
address_liveness_insensitive_locs `loc_includes` l) ==>
I.live sl h1
val properties (x:copy_buffer_t)
: Lemma (
liveness_preserved x /\
B.loc_region_only true region `loc_includes` loc_of x /\
region `HS.disjoint` AppCtxt.region
) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"EverParse3d.InputStream.All.fsti.checked",
"EverParse3d.AppCtxt.fsti.checked"
],
"interface_file": false,
"source_file": "EverParse3d.CopyBuffer.fsti"
} | [
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Buffer",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "EverParse3d.InputStream.All",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "EverParse3d.AppCtxt",
"short_module": "AppCtxt"
},
{
"abbrev": false,
"full_module": "EverParse3d",
"short_module": null
},
{
"abbrev": false,
"full_module": "EverParse3d",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 2,
"max_fuel": 0,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.qi.eager_threshold=10"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.UInt64.t",
"EverParse3d.CopyBuffer.copy_buffer_t",
"Prims.bool",
"FStar.Monotonic.HyperStack.mem",
"EverParse3d.InputStream.Base.live",
"EverParse3d.InputStream.All.t",
"EverParse3d.InputStream.All.inst",
"EverParse3d.CopyBuffer.stream_of",
"Prims.l_and",
"Prims.eq2",
"Prims.int",
"FStar.Seq.Base.length",
"FStar.UInt8.t",
"EverParse3d.InputStream.Base.get_read",
"LowStar.Monotonic.Buffer.modifies",
"EverParse3d.InputStream.Base.footprint",
"Prims.logical"
] | [] | false | false | false | true | true | let probe_fn =
| src: U64.t -> len: U64.t -> dest: copy_buffer_t
-> Stack bool
(fun h0 -> I.live (stream_of dest) h0)
(fun h0 b h1 ->
let sl = stream_of dest in
I.live sl h1 /\
(if b
then (Seq.length (I.get_read sl h1) == 0 /\ modifies (I.footprint sl) h0 h1)
else (h0 == h1))) | false |
|
Steel.Reference.fst | Steel.Reference.atomic_read_pt_u32 | val atomic_read_pt_u32 (#opened:_) (#p:perm) (#v:erased U32.t) (r:ref U32.t)
: SteelAtomic U32.t opened
(pts_to r p v)
(fun x -> pts_to r p x)
(requires fun _ -> True)
(ensures fun _ x _ -> x == Ghost.reveal v) | val atomic_read_pt_u32 (#opened:_) (#p:perm) (#v:erased U32.t) (r:ref U32.t)
: SteelAtomic U32.t opened
(pts_to r p v)
(fun x -> pts_to r p x)
(requires fun _ -> True)
(ensures fun _ x _ -> x == Ghost.reveal v) | let atomic_read_pt_u32 #_ #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
let x = H.atomic_read r in
let v':U32.t = U.downgrade_val x in
rewrite_slprop (H.pts_to r p (hide x)) (pts_to r p v') (fun _ -> ());
return v' | {
"file_name": "lib/steel/Steel.Reference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 11,
"end_line": 222,
"start_col": 0,
"start_line": 216
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.Reference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module Mem = Steel.Memory
module H = Steel.HigherReference
module U = FStar.Universe
#set-options "--ide_id_info_off"
let ref a = H.ref (U.raise_t a)
let null #a = H.null #(U.raise_t a)
let is_null #a r = H.is_null #(U.raise_t a) r
let pts_to_sl r p v = H.pts_to_sl r p (U.raise_val v)
val raise_val_inj (#a:Type) (x y:a) : Lemma
(requires U.raise_val x == U.raise_val y)
(ensures x == y)
let raise_val_inj x y =
U.downgrade_val_raise_val x;
U.downgrade_val_raise_val y
let pts_to_ref_injective
(#a: Type u#0)
(r: ref a)
(p0 p1:perm)
(v0 v1:a)
(m:mem)
: Lemma
(requires
interp (pts_to_sl r p0 v0 `Mem.star` pts_to_sl r p1 v1) m)
(ensures v0 == v1)
= let v0' = U.raise_val v0 in
let v1' = U.raise_val v1 in
H.pts_to_ref_injective r p0 p1 v0' v1' m;
raise_val_inj v0 v1
let pts_to_not_null (#a:Type u#0)
(x:ref a)
(p:perm)
(v:a)
(m:mem)
: Lemma (requires interp (pts_to_sl x p v) m)
(ensures x =!= null)
= let v = U.raise_val v in
H.pts_to_not_null #(U.raise_t a) x p v m
// let pts_to_not_null' (#a:Type u#0)
// (x:ref a)
// (p:perm)
// (v: erased a)
// (m:mem)
// (m1:mem{disjoint m m1})
// : Lemma (requires interp (pts_to_sl x p v) m)
// (ensures interp (pts_to_sl x p v) (Mem.join m m1))
// = ()
let pts_to_witinv (#a:Type) (r:ref a) (p:perm) : Lemma (is_witness_invariant (pts_to_sl r p)) =
let aux (x y : a) (m:mem)
: Lemma (requires (interp (pts_to_sl r p x) m /\ interp (pts_to_sl r p y) m))
(ensures (x == y))
= H.pts_to_witinv r p;
raise_val_inj x y
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
let pts_to_injective_eq #a #opened #p0 #p1 #v0 #v1 r =
extract_info_raw (pts_to r p0 v0 `star` pts_to r p1 v1) (v0 == v1)
(fun m -> pts_to_ref_injective r p0 p1 v0 v1 m);
rewrite_slprop (pts_to r p1 v1) (pts_to r p1 v0) (fun _ -> ())
let pts_to_perm
r
= H.pts_to_perm r
let alloc_pt x =
let r = H.alloc (U.raise_val x) in
rewrite_slprop (H.pts_to r full_perm (U.raise_val x)) (pts_to r full_perm x) (fun _ -> ());
return r
let read_pt #a #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
let x = H.read r in
let v':a = U.downgrade_val x in
rewrite_slprop (H.pts_to r p (hide x)) (pts_to r p v') (fun _ -> ());
return v'
let read_refine_pt #a #p q r =
Classical.forall_intro_2 reveal_equiv;
lift_exists (fun (v:a) -> pts_to r p v `star` q v);
exists_cong (fun (v:U.raise_t a) -> pts_to r p (U.downgrade_val v) `star` q (U.downgrade_val v))
(fun (v:U.raise_t a) -> H.pts_to r p v `star` U.lift_dom q v);
let x = H.read_refine (U.lift_dom q) r in
rewrite_slprop
(H.pts_to r p (hide x) `star` U.lift_dom q x)
(pts_to r p (U.downgrade_val x) `star` q (U.downgrade_val x)) (fun _ -> ());
return (U.downgrade_val x)
let write_pt #a #v r x =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
let x' = U.raise_val x in
H.write r x';
rewrite_slprop (H.pts_to r full_perm (hide x')) (pts_to r full_perm x) (fun _ -> ())
let free_pt #a #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
H.free r
let share_gen_pt #a #uses #p #v r p1 p2 =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
H.share_gen r p1 p2;
rewrite_slprop (H.pts_to r p1 v') (pts_to r p1 v) (fun _ -> ());
rewrite_slprop (H.pts_to r p2 v') (pts_to r p2 v) (fun _ -> ())
let share_pt #a #uses #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
H.share r;
rewrite_slprop (H.pts_to r (half_perm p) v') (pts_to r (half_perm p) v) (fun _ -> ());
rewrite_slprop (H.pts_to r (half_perm p) v') (pts_to r (half_perm p) v) (fun _ -> ())
let hide_raise_reveal (#a:Type) (v0:erased a) (v1:erased a)
: Lemma (hide (U.raise_val (reveal v0)) == hide (U.raise_val (reveal v1)) <==>
v0 == v1)
[SMTPat (hide (U.raise_val (reveal v0)));
SMTPat (hide (U.raise_val (reveal v1)))]
= let u0 = hide (U.raise_val (reveal v0)) in
let u1 = hide (U.raise_val (reveal v1)) in
assert (U.downgrade_val (U.raise_val (reveal v0)) == U.downgrade_val (U.raise_val (reveal v1)) <==>
v0 == v1)
let gather_pt #a #uses #p0 #p1 #v0 #v1 r =
let v0' = Ghost.hide (U.raise_val (Ghost.reveal v0)) in
let v1' = Ghost.hide (U.raise_val (Ghost.reveal v1)) in
rewrite_slprop (pts_to r p0 v0) (H.pts_to r p0 v0') (fun _ -> ());
rewrite_slprop (pts_to r p1 v1) (H.pts_to r p1 v1') (fun _ -> ());
let (u:unit{v0' == v1'}) = H.gather #_ #_ #p0 #p1 #v0' #v1' r in
rewrite_slprop (H.pts_to r (sum_perm p0 p1) v0') (pts_to r (sum_perm p0 p1) v0) (fun _ -> ());
u
let raise_equiv (#t:Type) (x y:t)
: Lemma (U.raise_val x == U.raise_val y <==>
x == y)
= assert (U.downgrade_val (U.raise_val x) == x);
assert (U.downgrade_val (U.raise_val y) == y)
let downgrade_equiv (#t:Type) (x y:U.raise_t t)
: Lemma (U.downgrade_val x == U.downgrade_val y <==>
x == y)
= assert (U.raise_val (U.downgrade_val x) == x);
assert (U.raise_val (U.downgrade_val y) == y)
let lift_eq (#t:eqtype) (x y:U.raise_t t)
: b:bool{b <==> x==y}
= downgrade_equiv x y; U.downgrade_val x = U.downgrade_val y
let cas_action (#t:eqtype)
(#uses:inames)
(r:ref t)
(v:Ghost.erased t)
(v_old:t)
(v_new:t)
(frame:slprop)
: MstTot (b:bool{b <==> (Ghost.reveal v == v_old)})
uses
(pts_to_sl r full_perm v)
(fun b -> if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v)
frame
(fun _ -> True)
(fun _ _ _ -> True)
= let hv = (Ghost.hide (U.raise_val (Ghost.reveal v))) in
let b = H.cas_action #(U.raise_t t)
(lift_eq #t)
#uses
r
hv
(U.raise_val v_old)
(U.raise_val v_new)
frame
in
assert (b <==> (Ghost.reveal hv == U.raise_val v_old));
assert (b <==> U.raise_val (Ghost.reveal v) == U.raise_val v_old);
raise_equiv (Ghost.reveal v) v_old;
b | {
"checked_file": "/",
"dependencies": [
"Steel.Memory.fsti.checked",
"Steel.HigherReference.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Reference.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "Steel.HigherReference",
"short_module": "H"
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | r: Steel.Reference.ref FStar.UInt32.t -> Steel.Effect.Atomic.SteelAtomic FStar.UInt32.t | Steel.Effect.Atomic.SteelAtomic | [] | [] | [
"Steel.Memory.inames",
"Steel.FractionalPermission.perm",
"FStar.Ghost.erased",
"FStar.UInt32.t",
"Steel.Reference.ref",
"Steel.Effect.Atomic.return",
"Steel.Reference.pts_to",
"Steel.Effect.Common.vprop",
"Prims.unit",
"Steel.Effect.Atomic.rewrite_slprop",
"Steel.HigherReference.pts_to",
"FStar.Universe.raise_t",
"Steel.Memory.mem",
"FStar.Universe.downgrade_val",
"Steel.HigherReference.atomic_read",
"FStar.Ghost.reveal",
"FStar.Ghost.hide",
"FStar.Universe.raise_val"
] | [] | false | true | false | false | false | let atomic_read_pt_u32 #_ #p #v r =
| let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
let x = H.atomic_read r in
let v':U32.t = U.downgrade_val x in
rewrite_slprop (H.pts_to r p (hide x)) (pts_to r p v') (fun _ -> ());
return v' | false |
Steel.Reference.fst | Steel.Reference.share | val share (#a:Type0) (#uses:_) (#p: perm) (r:ref a)
: SteelGhost unit uses
(vptrp r p)
(fun _ -> vptrp r (half_perm p) `star` vptrp r (half_perm p))
(fun _ -> True)
(fun h _ h' ->
h' (vptrp r (half_perm p)) == h (vptrp r p)
) | val share (#a:Type0) (#uses:_) (#p: perm) (r:ref a)
: SteelGhost unit uses
(vptrp r p)
(fun _ -> vptrp r (half_perm p) `star` vptrp r (half_perm p))
(fun _ -> True)
(fun h _ h' ->
h' (vptrp r (half_perm p)) == h (vptrp r p)
) | let share #a #_ #p r =
let x = elim_vptr r p in
share_pt r;
intro_vptr r _ x;
intro_vptr r _ x | {
"file_name": "lib/steel/Steel.Reference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 18,
"end_line": 334,
"start_col": 0,
"start_line": 330
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.Reference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module Mem = Steel.Memory
module H = Steel.HigherReference
module U = FStar.Universe
#set-options "--ide_id_info_off"
let ref a = H.ref (U.raise_t a)
let null #a = H.null #(U.raise_t a)
let is_null #a r = H.is_null #(U.raise_t a) r
let pts_to_sl r p v = H.pts_to_sl r p (U.raise_val v)
val raise_val_inj (#a:Type) (x y:a) : Lemma
(requires U.raise_val x == U.raise_val y)
(ensures x == y)
let raise_val_inj x y =
U.downgrade_val_raise_val x;
U.downgrade_val_raise_val y
let pts_to_ref_injective
(#a: Type u#0)
(r: ref a)
(p0 p1:perm)
(v0 v1:a)
(m:mem)
: Lemma
(requires
interp (pts_to_sl r p0 v0 `Mem.star` pts_to_sl r p1 v1) m)
(ensures v0 == v1)
= let v0' = U.raise_val v0 in
let v1' = U.raise_val v1 in
H.pts_to_ref_injective r p0 p1 v0' v1' m;
raise_val_inj v0 v1
let pts_to_not_null (#a:Type u#0)
(x:ref a)
(p:perm)
(v:a)
(m:mem)
: Lemma (requires interp (pts_to_sl x p v) m)
(ensures x =!= null)
= let v = U.raise_val v in
H.pts_to_not_null #(U.raise_t a) x p v m
// let pts_to_not_null' (#a:Type u#0)
// (x:ref a)
// (p:perm)
// (v: erased a)
// (m:mem)
// (m1:mem{disjoint m m1})
// : Lemma (requires interp (pts_to_sl x p v) m)
// (ensures interp (pts_to_sl x p v) (Mem.join m m1))
// = ()
let pts_to_witinv (#a:Type) (r:ref a) (p:perm) : Lemma (is_witness_invariant (pts_to_sl r p)) =
let aux (x y : a) (m:mem)
: Lemma (requires (interp (pts_to_sl r p x) m /\ interp (pts_to_sl r p y) m))
(ensures (x == y))
= H.pts_to_witinv r p;
raise_val_inj x y
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
let pts_to_injective_eq #a #opened #p0 #p1 #v0 #v1 r =
extract_info_raw (pts_to r p0 v0 `star` pts_to r p1 v1) (v0 == v1)
(fun m -> pts_to_ref_injective r p0 p1 v0 v1 m);
rewrite_slprop (pts_to r p1 v1) (pts_to r p1 v0) (fun _ -> ())
let pts_to_perm
r
= H.pts_to_perm r
let alloc_pt x =
let r = H.alloc (U.raise_val x) in
rewrite_slprop (H.pts_to r full_perm (U.raise_val x)) (pts_to r full_perm x) (fun _ -> ());
return r
let read_pt #a #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
let x = H.read r in
let v':a = U.downgrade_val x in
rewrite_slprop (H.pts_to r p (hide x)) (pts_to r p v') (fun _ -> ());
return v'
let read_refine_pt #a #p q r =
Classical.forall_intro_2 reveal_equiv;
lift_exists (fun (v:a) -> pts_to r p v `star` q v);
exists_cong (fun (v:U.raise_t a) -> pts_to r p (U.downgrade_val v) `star` q (U.downgrade_val v))
(fun (v:U.raise_t a) -> H.pts_to r p v `star` U.lift_dom q v);
let x = H.read_refine (U.lift_dom q) r in
rewrite_slprop
(H.pts_to r p (hide x) `star` U.lift_dom q x)
(pts_to r p (U.downgrade_val x) `star` q (U.downgrade_val x)) (fun _ -> ());
return (U.downgrade_val x)
let write_pt #a #v r x =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
let x' = U.raise_val x in
H.write r x';
rewrite_slprop (H.pts_to r full_perm (hide x')) (pts_to r full_perm x) (fun _ -> ())
let free_pt #a #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
H.free r
let share_gen_pt #a #uses #p #v r p1 p2 =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
H.share_gen r p1 p2;
rewrite_slprop (H.pts_to r p1 v') (pts_to r p1 v) (fun _ -> ());
rewrite_slprop (H.pts_to r p2 v') (pts_to r p2 v) (fun _ -> ())
let share_pt #a #uses #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
H.share r;
rewrite_slprop (H.pts_to r (half_perm p) v') (pts_to r (half_perm p) v) (fun _ -> ());
rewrite_slprop (H.pts_to r (half_perm p) v') (pts_to r (half_perm p) v) (fun _ -> ())
let hide_raise_reveal (#a:Type) (v0:erased a) (v1:erased a)
: Lemma (hide (U.raise_val (reveal v0)) == hide (U.raise_val (reveal v1)) <==>
v0 == v1)
[SMTPat (hide (U.raise_val (reveal v0)));
SMTPat (hide (U.raise_val (reveal v1)))]
= let u0 = hide (U.raise_val (reveal v0)) in
let u1 = hide (U.raise_val (reveal v1)) in
assert (U.downgrade_val (U.raise_val (reveal v0)) == U.downgrade_val (U.raise_val (reveal v1)) <==>
v0 == v1)
let gather_pt #a #uses #p0 #p1 #v0 #v1 r =
let v0' = Ghost.hide (U.raise_val (Ghost.reveal v0)) in
let v1' = Ghost.hide (U.raise_val (Ghost.reveal v1)) in
rewrite_slprop (pts_to r p0 v0) (H.pts_to r p0 v0') (fun _ -> ());
rewrite_slprop (pts_to r p1 v1) (H.pts_to r p1 v1') (fun _ -> ());
let (u:unit{v0' == v1'}) = H.gather #_ #_ #p0 #p1 #v0' #v1' r in
rewrite_slprop (H.pts_to r (sum_perm p0 p1) v0') (pts_to r (sum_perm p0 p1) v0) (fun _ -> ());
u
let raise_equiv (#t:Type) (x y:t)
: Lemma (U.raise_val x == U.raise_val y <==>
x == y)
= assert (U.downgrade_val (U.raise_val x) == x);
assert (U.downgrade_val (U.raise_val y) == y)
let downgrade_equiv (#t:Type) (x y:U.raise_t t)
: Lemma (U.downgrade_val x == U.downgrade_val y <==>
x == y)
= assert (U.raise_val (U.downgrade_val x) == x);
assert (U.raise_val (U.downgrade_val y) == y)
let lift_eq (#t:eqtype) (x y:U.raise_t t)
: b:bool{b <==> x==y}
= downgrade_equiv x y; U.downgrade_val x = U.downgrade_val y
let cas_action (#t:eqtype)
(#uses:inames)
(r:ref t)
(v:Ghost.erased t)
(v_old:t)
(v_new:t)
(frame:slprop)
: MstTot (b:bool{b <==> (Ghost.reveal v == v_old)})
uses
(pts_to_sl r full_perm v)
(fun b -> if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v)
frame
(fun _ -> True)
(fun _ _ _ -> True)
= let hv = (Ghost.hide (U.raise_val (Ghost.reveal v))) in
let b = H.cas_action #(U.raise_t t)
(lift_eq #t)
#uses
r
hv
(U.raise_val v_old)
(U.raise_val v_new)
frame
in
assert (b <==> (Ghost.reveal hv == U.raise_val v_old));
assert (b <==> U.raise_val (Ghost.reveal v) == U.raise_val v_old);
raise_equiv (Ghost.reveal v) v_old;
b
let atomic_read_pt_u32 #_ #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
let x = H.atomic_read r in
let v':U32.t = U.downgrade_val x in
rewrite_slprop (H.pts_to r p (hide x)) (pts_to r p v') (fun _ -> ());
return v'
let atomic_write_pt_u32 #_ #v r x =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
let x' = U.raise_val x in
H.atomic_write r x';
rewrite_slprop (H.pts_to r full_perm (hide x')) (pts_to r full_perm x) (fun _ -> ())
let cas_pt_u32 #uses r v v_old v_new =
let b = as_atomic_action (cas_action #U32.t #uses r v v_old v_new) in
rewrite_slprop (to_vprop (if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v))
(if b then pts_to r full_perm v_new else pts_to r full_perm v)
(fun _ -> ());
return b
let cas_pt_bool #uses r v v_old v_new =
let b = as_atomic_action (cas_action #bool #uses r v v_old v_new) in
rewrite_slprop (to_vprop (if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v))
(if b then pts_to r full_perm v_new else pts_to r full_perm v)
(fun _ -> ());
return b
(* Library for references with fractional permissions.
Permissions need to be an index of the vprop ptr.
It cannot be part of a selector, as it is not invariant when joining with a disjoint memory
Using the value of the ref as a selector is ok because refs with fractional permissions
all share the same value.
Refs on PCM are more complicated, and likely not usable with selectors
*)
let ptrp r p = Mem.h_exists (pts_to_sl r p)
val ptr_sel' (#a:Type0) (r: ref a) (p: perm) : selector' a (ptrp r p)
let ptr_sel' #a r p = fun h -> id_elim_exists #a (pts_to_sl r p) h
let ptr_sel_depends_only_on (#a:Type0) (r:ref a)
(p: perm)
(m0:Mem.hmem (ptrp r p)) (m1:mem{disjoint m0 m1})
: Lemma (ptr_sel' r p m0 == ptr_sel' r p (Mem.join m0 m1))
= let x = reveal (id_elim_exists #a (pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (pts_to_sl r p) (Mem.join m0 m1)) in
pts_to_witinv r p;
elim_wi (pts_to_sl r p) x y (Mem.join m0 m1)
let ptr_sel_depends_only_on_core (#a:Type0) (r:ref a)
(p: perm) (m0:Mem.hmem (ptrp r p))
: Lemma (ptr_sel' r p m0 == ptr_sel' r p (core_mem m0))
= let x = reveal (id_elim_exists #a (pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (pts_to_sl r p) (core_mem m0)) in
pts_to_witinv r p;
elim_wi (pts_to_sl r p) x y (core_mem m0)
let ptrp_sel r p =
Classical.forall_intro_2 (ptr_sel_depends_only_on r p);
Classical.forall_intro (ptr_sel_depends_only_on_core r p);
ptr_sel' r p
let ptrp_sel_interp #a r p m = pts_to_witinv r p
let intro_ptrp_interp r p v m = intro_h_exists (reveal v) (pts_to_sl r p) m
let intro_vptr_lemma (#a:Type) (r:ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (pts_to_sl r p v) m)
(ensures interp (ptrp r p) m /\ ptrp_sel r p m == reveal v)
= Mem.intro_h_exists (reveal v) (pts_to_sl r p) m;
pts_to_witinv r p
let elim_vptr_lemma (#a:Type) (r:ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (ptrp r p) m /\ ptrp_sel r p m == reveal v)
(ensures interp (pts_to_sl r p v) m)
= Mem.elim_h_exists (pts_to_sl r p) m;
pts_to_witinv r p
let intro_vptr (#a:Type) (#opened:inames) (r:ref a) (p: perm) (v:erased a)
: SteelGhost unit opened (pts_to r p v) (fun _ -> vptrp r p)
(requires fun _ -> True)
(ensures fun _ _ h1 -> h1 (vptrp r p) == reveal v)
= change_slprop_2 (pts_to r p v) (vptrp r p) v (intro_vptr_lemma r p v)
let elim_vptr (#a:Type) (#opened:inames) (r:ref a) (p: perm)
: SteelGhost (erased a) opened (vptrp r p) (fun v -> pts_to r p v)
(requires fun _ -> True)
(ensures fun h0 v _ -> reveal v == h0 (vptrp r p))
= let v = gget (vptrp r p) in
change_slprop (vptrp r p) (pts_to r p v) v () (elim_vptr_lemma r p v);
v
let malloc x =
let r = alloc_pt x in
intro_vptr r _ (hide x);
return r
let free r =
let _ = elim_vptr r _ in
free_pt r
let readp r _ =
let _ = elim_vptr r _ in
let x = read_pt r in
intro_vptr r _ x;
return x
let write r x =
let _ = elim_vptr r _ in
write_pt r x;
intro_vptr r _ x | {
"checked_file": "/",
"dependencies": [
"Steel.Memory.fsti.checked",
"Steel.HigherReference.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Reference.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "Steel.HigherReference",
"short_module": "H"
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | r: Steel.Reference.ref a -> Steel.Effect.Atomic.SteelGhost Prims.unit | Steel.Effect.Atomic.SteelGhost | [] | [] | [
"Steel.Memory.inames",
"Steel.FractionalPermission.perm",
"Steel.Reference.ref",
"Steel.Reference.intro_vptr",
"Steel.FractionalPermission.half_perm",
"Prims.unit",
"Steel.Reference.share_pt",
"FStar.Ghost.erased",
"Steel.Reference.elim_vptr"
] | [] | false | true | false | false | false | let share #a #_ #p r =
| let x = elim_vptr r p in
share_pt r;
intro_vptr r _ x;
intro_vptr r _ x | false |
Steel.Reference.fst | Steel.Reference.share_pt | val share_pt (#a:Type0) (#uses:_) (#p:perm) (#v:erased a) (r:ref a)
: SteelGhostT unit uses
(pts_to r p v)
(fun _ -> pts_to r (half_perm p) v `star` pts_to r (half_perm p) v) | val share_pt (#a:Type0) (#uses:_) (#p:perm) (#v:erased a) (r:ref a)
: SteelGhostT unit uses
(pts_to r p v)
(fun _ -> pts_to r (half_perm p) v `star` pts_to r (half_perm p) v) | let share_pt #a #uses #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
H.share r;
rewrite_slprop (H.pts_to r (half_perm p) v') (pts_to r (half_perm p) v) (fun _ -> ());
rewrite_slprop (H.pts_to r (half_perm p) v') (pts_to r (half_perm p) v) (fun _ -> ()) | {
"file_name": "lib/steel/Steel.Reference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 87,
"end_line": 148,
"start_col": 0,
"start_line": 143
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.Reference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module Mem = Steel.Memory
module H = Steel.HigherReference
module U = FStar.Universe
#set-options "--ide_id_info_off"
let ref a = H.ref (U.raise_t a)
let null #a = H.null #(U.raise_t a)
let is_null #a r = H.is_null #(U.raise_t a) r
let pts_to_sl r p v = H.pts_to_sl r p (U.raise_val v)
val raise_val_inj (#a:Type) (x y:a) : Lemma
(requires U.raise_val x == U.raise_val y)
(ensures x == y)
let raise_val_inj x y =
U.downgrade_val_raise_val x;
U.downgrade_val_raise_val y
let pts_to_ref_injective
(#a: Type u#0)
(r: ref a)
(p0 p1:perm)
(v0 v1:a)
(m:mem)
: Lemma
(requires
interp (pts_to_sl r p0 v0 `Mem.star` pts_to_sl r p1 v1) m)
(ensures v0 == v1)
= let v0' = U.raise_val v0 in
let v1' = U.raise_val v1 in
H.pts_to_ref_injective r p0 p1 v0' v1' m;
raise_val_inj v0 v1
let pts_to_not_null (#a:Type u#0)
(x:ref a)
(p:perm)
(v:a)
(m:mem)
: Lemma (requires interp (pts_to_sl x p v) m)
(ensures x =!= null)
= let v = U.raise_val v in
H.pts_to_not_null #(U.raise_t a) x p v m
// let pts_to_not_null' (#a:Type u#0)
// (x:ref a)
// (p:perm)
// (v: erased a)
// (m:mem)
// (m1:mem{disjoint m m1})
// : Lemma (requires interp (pts_to_sl x p v) m)
// (ensures interp (pts_to_sl x p v) (Mem.join m m1))
// = ()
let pts_to_witinv (#a:Type) (r:ref a) (p:perm) : Lemma (is_witness_invariant (pts_to_sl r p)) =
let aux (x y : a) (m:mem)
: Lemma (requires (interp (pts_to_sl r p x) m /\ interp (pts_to_sl r p y) m))
(ensures (x == y))
= H.pts_to_witinv r p;
raise_val_inj x y
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
let pts_to_injective_eq #a #opened #p0 #p1 #v0 #v1 r =
extract_info_raw (pts_to r p0 v0 `star` pts_to r p1 v1) (v0 == v1)
(fun m -> pts_to_ref_injective r p0 p1 v0 v1 m);
rewrite_slprop (pts_to r p1 v1) (pts_to r p1 v0) (fun _ -> ())
let pts_to_perm
r
= H.pts_to_perm r
let alloc_pt x =
let r = H.alloc (U.raise_val x) in
rewrite_slprop (H.pts_to r full_perm (U.raise_val x)) (pts_to r full_perm x) (fun _ -> ());
return r
let read_pt #a #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
let x = H.read r in
let v':a = U.downgrade_val x in
rewrite_slprop (H.pts_to r p (hide x)) (pts_to r p v') (fun _ -> ());
return v'
let read_refine_pt #a #p q r =
Classical.forall_intro_2 reveal_equiv;
lift_exists (fun (v:a) -> pts_to r p v `star` q v);
exists_cong (fun (v:U.raise_t a) -> pts_to r p (U.downgrade_val v) `star` q (U.downgrade_val v))
(fun (v:U.raise_t a) -> H.pts_to r p v `star` U.lift_dom q v);
let x = H.read_refine (U.lift_dom q) r in
rewrite_slprop
(H.pts_to r p (hide x) `star` U.lift_dom q x)
(pts_to r p (U.downgrade_val x) `star` q (U.downgrade_val x)) (fun _ -> ());
return (U.downgrade_val x)
let write_pt #a #v r x =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
let x' = U.raise_val x in
H.write r x';
rewrite_slprop (H.pts_to r full_perm (hide x')) (pts_to r full_perm x) (fun _ -> ())
let free_pt #a #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
H.free r
let share_gen_pt #a #uses #p #v r p1 p2 =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
H.share_gen r p1 p2;
rewrite_slprop (H.pts_to r p1 v') (pts_to r p1 v) (fun _ -> ());
rewrite_slprop (H.pts_to r p2 v') (pts_to r p2 v) (fun _ -> ()) | {
"checked_file": "/",
"dependencies": [
"Steel.Memory.fsti.checked",
"Steel.HigherReference.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Reference.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "Steel.HigherReference",
"short_module": "H"
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | r: Steel.Reference.ref a -> Steel.Effect.Atomic.SteelGhostT Prims.unit | Steel.Effect.Atomic.SteelGhostT | [] | [] | [
"Steel.Memory.inames",
"Steel.FractionalPermission.perm",
"FStar.Ghost.erased",
"Steel.Reference.ref",
"Steel.Effect.Atomic.rewrite_slprop",
"Steel.HigherReference.pts_to",
"FStar.Universe.raise_t",
"Steel.FractionalPermission.half_perm",
"FStar.Ghost.reveal",
"Steel.Reference.pts_to",
"Steel.Memory.mem",
"Prims.unit",
"Steel.HigherReference.share",
"FStar.Ghost.hide",
"FStar.Universe.raise_val"
] | [] | false | true | false | false | false | let share_pt #a #uses #p #v r =
| let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
H.share r;
rewrite_slprop (H.pts_to r (half_perm p) v') (pts_to r (half_perm p) v) (fun _ -> ());
rewrite_slprop (H.pts_to r (half_perm p) v') (pts_to r (half_perm p) v) (fun _ -> ()) | false |
Steel.Reference.fst | Steel.Reference.readp | val readp (#a:Type0) (r:ref a) (p: perm) : Steel a
(vptrp r p) (fun _ -> vptrp r p)
(requires fun _ -> True)
(ensures fun h0 x h1 -> h0 (vptrp r p) == h1 (vptrp r p) /\ x == h1 (vptrp r p)) | val readp (#a:Type0) (r:ref a) (p: perm) : Steel a
(vptrp r p) (fun _ -> vptrp r p)
(requires fun _ -> True)
(ensures fun h0 x h1 -> h0 (vptrp r p) == h1 (vptrp r p) /\ x == h1 (vptrp r p)) | let readp r _ =
let _ = elim_vptr r _ in
let x = read_pt r in
intro_vptr r _ x;
return x | {
"file_name": "lib/steel/Steel.Reference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 10,
"end_line": 323,
"start_col": 0,
"start_line": 319
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.Reference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module Mem = Steel.Memory
module H = Steel.HigherReference
module U = FStar.Universe
#set-options "--ide_id_info_off"
let ref a = H.ref (U.raise_t a)
let null #a = H.null #(U.raise_t a)
let is_null #a r = H.is_null #(U.raise_t a) r
let pts_to_sl r p v = H.pts_to_sl r p (U.raise_val v)
val raise_val_inj (#a:Type) (x y:a) : Lemma
(requires U.raise_val x == U.raise_val y)
(ensures x == y)
let raise_val_inj x y =
U.downgrade_val_raise_val x;
U.downgrade_val_raise_val y
let pts_to_ref_injective
(#a: Type u#0)
(r: ref a)
(p0 p1:perm)
(v0 v1:a)
(m:mem)
: Lemma
(requires
interp (pts_to_sl r p0 v0 `Mem.star` pts_to_sl r p1 v1) m)
(ensures v0 == v1)
= let v0' = U.raise_val v0 in
let v1' = U.raise_val v1 in
H.pts_to_ref_injective r p0 p1 v0' v1' m;
raise_val_inj v0 v1
let pts_to_not_null (#a:Type u#0)
(x:ref a)
(p:perm)
(v:a)
(m:mem)
: Lemma (requires interp (pts_to_sl x p v) m)
(ensures x =!= null)
= let v = U.raise_val v in
H.pts_to_not_null #(U.raise_t a) x p v m
// let pts_to_not_null' (#a:Type u#0)
// (x:ref a)
// (p:perm)
// (v: erased a)
// (m:mem)
// (m1:mem{disjoint m m1})
// : Lemma (requires interp (pts_to_sl x p v) m)
// (ensures interp (pts_to_sl x p v) (Mem.join m m1))
// = ()
let pts_to_witinv (#a:Type) (r:ref a) (p:perm) : Lemma (is_witness_invariant (pts_to_sl r p)) =
let aux (x y : a) (m:mem)
: Lemma (requires (interp (pts_to_sl r p x) m /\ interp (pts_to_sl r p y) m))
(ensures (x == y))
= H.pts_to_witinv r p;
raise_val_inj x y
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
let pts_to_injective_eq #a #opened #p0 #p1 #v0 #v1 r =
extract_info_raw (pts_to r p0 v0 `star` pts_to r p1 v1) (v0 == v1)
(fun m -> pts_to_ref_injective r p0 p1 v0 v1 m);
rewrite_slprop (pts_to r p1 v1) (pts_to r p1 v0) (fun _ -> ())
let pts_to_perm
r
= H.pts_to_perm r
let alloc_pt x =
let r = H.alloc (U.raise_val x) in
rewrite_slprop (H.pts_to r full_perm (U.raise_val x)) (pts_to r full_perm x) (fun _ -> ());
return r
let read_pt #a #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
let x = H.read r in
let v':a = U.downgrade_val x in
rewrite_slprop (H.pts_to r p (hide x)) (pts_to r p v') (fun _ -> ());
return v'
let read_refine_pt #a #p q r =
Classical.forall_intro_2 reveal_equiv;
lift_exists (fun (v:a) -> pts_to r p v `star` q v);
exists_cong (fun (v:U.raise_t a) -> pts_to r p (U.downgrade_val v) `star` q (U.downgrade_val v))
(fun (v:U.raise_t a) -> H.pts_to r p v `star` U.lift_dom q v);
let x = H.read_refine (U.lift_dom q) r in
rewrite_slprop
(H.pts_to r p (hide x) `star` U.lift_dom q x)
(pts_to r p (U.downgrade_val x) `star` q (U.downgrade_val x)) (fun _ -> ());
return (U.downgrade_val x)
let write_pt #a #v r x =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
let x' = U.raise_val x in
H.write r x';
rewrite_slprop (H.pts_to r full_perm (hide x')) (pts_to r full_perm x) (fun _ -> ())
let free_pt #a #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
H.free r
let share_gen_pt #a #uses #p #v r p1 p2 =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
H.share_gen r p1 p2;
rewrite_slprop (H.pts_to r p1 v') (pts_to r p1 v) (fun _ -> ());
rewrite_slprop (H.pts_to r p2 v') (pts_to r p2 v) (fun _ -> ())
let share_pt #a #uses #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
H.share r;
rewrite_slprop (H.pts_to r (half_perm p) v') (pts_to r (half_perm p) v) (fun _ -> ());
rewrite_slprop (H.pts_to r (half_perm p) v') (pts_to r (half_perm p) v) (fun _ -> ())
let hide_raise_reveal (#a:Type) (v0:erased a) (v1:erased a)
: Lemma (hide (U.raise_val (reveal v0)) == hide (U.raise_val (reveal v1)) <==>
v0 == v1)
[SMTPat (hide (U.raise_val (reveal v0)));
SMTPat (hide (U.raise_val (reveal v1)))]
= let u0 = hide (U.raise_val (reveal v0)) in
let u1 = hide (U.raise_val (reveal v1)) in
assert (U.downgrade_val (U.raise_val (reveal v0)) == U.downgrade_val (U.raise_val (reveal v1)) <==>
v0 == v1)
let gather_pt #a #uses #p0 #p1 #v0 #v1 r =
let v0' = Ghost.hide (U.raise_val (Ghost.reveal v0)) in
let v1' = Ghost.hide (U.raise_val (Ghost.reveal v1)) in
rewrite_slprop (pts_to r p0 v0) (H.pts_to r p0 v0') (fun _ -> ());
rewrite_slprop (pts_to r p1 v1) (H.pts_to r p1 v1') (fun _ -> ());
let (u:unit{v0' == v1'}) = H.gather #_ #_ #p0 #p1 #v0' #v1' r in
rewrite_slprop (H.pts_to r (sum_perm p0 p1) v0') (pts_to r (sum_perm p0 p1) v0) (fun _ -> ());
u
let raise_equiv (#t:Type) (x y:t)
: Lemma (U.raise_val x == U.raise_val y <==>
x == y)
= assert (U.downgrade_val (U.raise_val x) == x);
assert (U.downgrade_val (U.raise_val y) == y)
let downgrade_equiv (#t:Type) (x y:U.raise_t t)
: Lemma (U.downgrade_val x == U.downgrade_val y <==>
x == y)
= assert (U.raise_val (U.downgrade_val x) == x);
assert (U.raise_val (U.downgrade_val y) == y)
let lift_eq (#t:eqtype) (x y:U.raise_t t)
: b:bool{b <==> x==y}
= downgrade_equiv x y; U.downgrade_val x = U.downgrade_val y
let cas_action (#t:eqtype)
(#uses:inames)
(r:ref t)
(v:Ghost.erased t)
(v_old:t)
(v_new:t)
(frame:slprop)
: MstTot (b:bool{b <==> (Ghost.reveal v == v_old)})
uses
(pts_to_sl r full_perm v)
(fun b -> if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v)
frame
(fun _ -> True)
(fun _ _ _ -> True)
= let hv = (Ghost.hide (U.raise_val (Ghost.reveal v))) in
let b = H.cas_action #(U.raise_t t)
(lift_eq #t)
#uses
r
hv
(U.raise_val v_old)
(U.raise_val v_new)
frame
in
assert (b <==> (Ghost.reveal hv == U.raise_val v_old));
assert (b <==> U.raise_val (Ghost.reveal v) == U.raise_val v_old);
raise_equiv (Ghost.reveal v) v_old;
b
let atomic_read_pt_u32 #_ #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
let x = H.atomic_read r in
let v':U32.t = U.downgrade_val x in
rewrite_slprop (H.pts_to r p (hide x)) (pts_to r p v') (fun _ -> ());
return v'
let atomic_write_pt_u32 #_ #v r x =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
let x' = U.raise_val x in
H.atomic_write r x';
rewrite_slprop (H.pts_to r full_perm (hide x')) (pts_to r full_perm x) (fun _ -> ())
let cas_pt_u32 #uses r v v_old v_new =
let b = as_atomic_action (cas_action #U32.t #uses r v v_old v_new) in
rewrite_slprop (to_vprop (if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v))
(if b then pts_to r full_perm v_new else pts_to r full_perm v)
(fun _ -> ());
return b
let cas_pt_bool #uses r v v_old v_new =
let b = as_atomic_action (cas_action #bool #uses r v v_old v_new) in
rewrite_slprop (to_vprop (if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v))
(if b then pts_to r full_perm v_new else pts_to r full_perm v)
(fun _ -> ());
return b
(* Library for references with fractional permissions.
Permissions need to be an index of the vprop ptr.
It cannot be part of a selector, as it is not invariant when joining with a disjoint memory
Using the value of the ref as a selector is ok because refs with fractional permissions
all share the same value.
Refs on PCM are more complicated, and likely not usable with selectors
*)
let ptrp r p = Mem.h_exists (pts_to_sl r p)
val ptr_sel' (#a:Type0) (r: ref a) (p: perm) : selector' a (ptrp r p)
let ptr_sel' #a r p = fun h -> id_elim_exists #a (pts_to_sl r p) h
let ptr_sel_depends_only_on (#a:Type0) (r:ref a)
(p: perm)
(m0:Mem.hmem (ptrp r p)) (m1:mem{disjoint m0 m1})
: Lemma (ptr_sel' r p m0 == ptr_sel' r p (Mem.join m0 m1))
= let x = reveal (id_elim_exists #a (pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (pts_to_sl r p) (Mem.join m0 m1)) in
pts_to_witinv r p;
elim_wi (pts_to_sl r p) x y (Mem.join m0 m1)
let ptr_sel_depends_only_on_core (#a:Type0) (r:ref a)
(p: perm) (m0:Mem.hmem (ptrp r p))
: Lemma (ptr_sel' r p m0 == ptr_sel' r p (core_mem m0))
= let x = reveal (id_elim_exists #a (pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (pts_to_sl r p) (core_mem m0)) in
pts_to_witinv r p;
elim_wi (pts_to_sl r p) x y (core_mem m0)
let ptrp_sel r p =
Classical.forall_intro_2 (ptr_sel_depends_only_on r p);
Classical.forall_intro (ptr_sel_depends_only_on_core r p);
ptr_sel' r p
let ptrp_sel_interp #a r p m = pts_to_witinv r p
let intro_ptrp_interp r p v m = intro_h_exists (reveal v) (pts_to_sl r p) m
let intro_vptr_lemma (#a:Type) (r:ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (pts_to_sl r p v) m)
(ensures interp (ptrp r p) m /\ ptrp_sel r p m == reveal v)
= Mem.intro_h_exists (reveal v) (pts_to_sl r p) m;
pts_to_witinv r p
let elim_vptr_lemma (#a:Type) (r:ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (ptrp r p) m /\ ptrp_sel r p m == reveal v)
(ensures interp (pts_to_sl r p v) m)
= Mem.elim_h_exists (pts_to_sl r p) m;
pts_to_witinv r p
let intro_vptr (#a:Type) (#opened:inames) (r:ref a) (p: perm) (v:erased a)
: SteelGhost unit opened (pts_to r p v) (fun _ -> vptrp r p)
(requires fun _ -> True)
(ensures fun _ _ h1 -> h1 (vptrp r p) == reveal v)
= change_slprop_2 (pts_to r p v) (vptrp r p) v (intro_vptr_lemma r p v)
let elim_vptr (#a:Type) (#opened:inames) (r:ref a) (p: perm)
: SteelGhost (erased a) opened (vptrp r p) (fun v -> pts_to r p v)
(requires fun _ -> True)
(ensures fun h0 v _ -> reveal v == h0 (vptrp r p))
= let v = gget (vptrp r p) in
change_slprop (vptrp r p) (pts_to r p v) v () (elim_vptr_lemma r p v);
v
let malloc x =
let r = alloc_pt x in
intro_vptr r _ (hide x);
return r
let free r =
let _ = elim_vptr r _ in
free_pt r | {
"checked_file": "/",
"dependencies": [
"Steel.Memory.fsti.checked",
"Steel.HigherReference.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Reference.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "Steel.HigherReference",
"short_module": "H"
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | r: Steel.Reference.ref a -> p: Steel.FractionalPermission.perm -> Steel.Effect.Steel a | Steel.Effect.Steel | [] | [] | [
"Steel.Reference.ref",
"Steel.FractionalPermission.perm",
"Steel.Effect.Atomic.return",
"FStar.Ghost.hide",
"FStar.Set.set",
"Steel.Memory.iname",
"FStar.Set.empty",
"Steel.Reference.vptrp",
"Steel.Effect.Common.vprop",
"Prims.unit",
"Steel.Reference.intro_vptr",
"Steel.Reference.read_pt",
"FStar.Ghost.erased",
"Steel.Reference.elim_vptr"
] | [] | false | true | false | false | false | let readp r _ =
| let _ = elim_vptr r _ in
let x = read_pt r in
intro_vptr r _ x;
return x | false |
Steel.Reference.fst | Steel.Reference.read_pt | val read_pt (#a:Type) (#p:perm) (#v:erased a) (r:ref a)
: Steel a (pts_to r p v) (fun x -> pts_to r p x)
(requires fun _ -> True)
(ensures fun _ x _ -> x == Ghost.reveal v) | val read_pt (#a:Type) (#p:perm) (#v:erased a) (r:ref a)
: Steel a (pts_to r p v) (fun x -> pts_to r p x)
(requires fun _ -> True)
(ensures fun _ x _ -> x == Ghost.reveal v) | let read_pt #a #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
let x = H.read r in
let v':a = U.downgrade_val x in
rewrite_slprop (H.pts_to r p (hide x)) (pts_to r p v') (fun _ -> ());
return v' | {
"file_name": "lib/steel/Steel.Reference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 11,
"end_line": 110,
"start_col": 0,
"start_line": 104
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.Reference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module Mem = Steel.Memory
module H = Steel.HigherReference
module U = FStar.Universe
#set-options "--ide_id_info_off"
let ref a = H.ref (U.raise_t a)
let null #a = H.null #(U.raise_t a)
let is_null #a r = H.is_null #(U.raise_t a) r
let pts_to_sl r p v = H.pts_to_sl r p (U.raise_val v)
val raise_val_inj (#a:Type) (x y:a) : Lemma
(requires U.raise_val x == U.raise_val y)
(ensures x == y)
let raise_val_inj x y =
U.downgrade_val_raise_val x;
U.downgrade_val_raise_val y
let pts_to_ref_injective
(#a: Type u#0)
(r: ref a)
(p0 p1:perm)
(v0 v1:a)
(m:mem)
: Lemma
(requires
interp (pts_to_sl r p0 v0 `Mem.star` pts_to_sl r p1 v1) m)
(ensures v0 == v1)
= let v0' = U.raise_val v0 in
let v1' = U.raise_val v1 in
H.pts_to_ref_injective r p0 p1 v0' v1' m;
raise_val_inj v0 v1
let pts_to_not_null (#a:Type u#0)
(x:ref a)
(p:perm)
(v:a)
(m:mem)
: Lemma (requires interp (pts_to_sl x p v) m)
(ensures x =!= null)
= let v = U.raise_val v in
H.pts_to_not_null #(U.raise_t a) x p v m
// let pts_to_not_null' (#a:Type u#0)
// (x:ref a)
// (p:perm)
// (v: erased a)
// (m:mem)
// (m1:mem{disjoint m m1})
// : Lemma (requires interp (pts_to_sl x p v) m)
// (ensures interp (pts_to_sl x p v) (Mem.join m m1))
// = ()
let pts_to_witinv (#a:Type) (r:ref a) (p:perm) : Lemma (is_witness_invariant (pts_to_sl r p)) =
let aux (x y : a) (m:mem)
: Lemma (requires (interp (pts_to_sl r p x) m /\ interp (pts_to_sl r p y) m))
(ensures (x == y))
= H.pts_to_witinv r p;
raise_val_inj x y
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
let pts_to_injective_eq #a #opened #p0 #p1 #v0 #v1 r =
extract_info_raw (pts_to r p0 v0 `star` pts_to r p1 v1) (v0 == v1)
(fun m -> pts_to_ref_injective r p0 p1 v0 v1 m);
rewrite_slprop (pts_to r p1 v1) (pts_to r p1 v0) (fun _ -> ())
let pts_to_perm
r
= H.pts_to_perm r
let alloc_pt x =
let r = H.alloc (U.raise_val x) in
rewrite_slprop (H.pts_to r full_perm (U.raise_val x)) (pts_to r full_perm x) (fun _ -> ());
return r | {
"checked_file": "/",
"dependencies": [
"Steel.Memory.fsti.checked",
"Steel.HigherReference.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Reference.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "Steel.HigherReference",
"short_module": "H"
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | r: Steel.Reference.ref a -> Steel.Effect.Steel a | Steel.Effect.Steel | [] | [] | [
"Steel.FractionalPermission.perm",
"FStar.Ghost.erased",
"Steel.Reference.ref",
"Steel.Effect.Atomic.return",
"FStar.Ghost.hide",
"FStar.Set.set",
"Steel.Memory.iname",
"FStar.Set.empty",
"Steel.Reference.pts_to",
"Steel.Effect.Common.vprop",
"Prims.unit",
"Steel.Effect.Atomic.rewrite_slprop",
"Steel.HigherReference.pts_to",
"FStar.Universe.raise_t",
"Steel.Memory.mem",
"FStar.Universe.downgrade_val",
"Steel.HigherReference.read",
"FStar.Ghost.reveal",
"FStar.Universe.raise_val"
] | [] | false | true | false | false | false | let read_pt #a #p #v r =
| let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
let x = H.read r in
let v':a = U.downgrade_val x in
rewrite_slprop (H.pts_to r p (hide x)) (pts_to r p v') (fun _ -> ());
return v' | false |
Steel.Reference.fst | Steel.Reference.elim_ghost_vptr | val elim_ghost_vptr (#a: Type) (#opened: inames) (r: ghost_ref a) (p: perm)
: SteelGhost (erased a)
opened
(ghost_vptrp r p)
(fun v -> ghost_pts_to r p v)
(requires fun _ -> True)
(ensures fun h0 v _ -> reveal v == h0 (ghost_vptrp r p)) | val elim_ghost_vptr (#a: Type) (#opened: inames) (r: ghost_ref a) (p: perm)
: SteelGhost (erased a)
opened
(ghost_vptrp r p)
(fun v -> ghost_pts_to r p v)
(requires fun _ -> True)
(ensures fun h0 v _ -> reveal v == h0 (ghost_vptrp r p)) | let elim_ghost_vptr (#a:Type) (#opened:inames) (r:ghost_ref a)
(p: perm)
: SteelGhost (erased a) opened (ghost_vptrp r p) (fun v -> ghost_pts_to r p v)
(requires fun _ -> True)
(ensures fun h0 v _ -> reveal v == h0 (ghost_vptrp r p))
= let v = gget (ghost_vptrp r p) in
change_slprop (ghost_vptrp r p) (ghost_pts_to r p v) v () (elim_ghost_vptr_lemma r p v);
v | {
"file_name": "lib/steel/Steel.Reference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 5,
"end_line": 503,
"start_col": 0,
"start_line": 496
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.Reference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module Mem = Steel.Memory
module H = Steel.HigherReference
module U = FStar.Universe
#set-options "--ide_id_info_off"
let ref a = H.ref (U.raise_t a)
let null #a = H.null #(U.raise_t a)
let is_null #a r = H.is_null #(U.raise_t a) r
let pts_to_sl r p v = H.pts_to_sl r p (U.raise_val v)
val raise_val_inj (#a:Type) (x y:a) : Lemma
(requires U.raise_val x == U.raise_val y)
(ensures x == y)
let raise_val_inj x y =
U.downgrade_val_raise_val x;
U.downgrade_val_raise_val y
let pts_to_ref_injective
(#a: Type u#0)
(r: ref a)
(p0 p1:perm)
(v0 v1:a)
(m:mem)
: Lemma
(requires
interp (pts_to_sl r p0 v0 `Mem.star` pts_to_sl r p1 v1) m)
(ensures v0 == v1)
= let v0' = U.raise_val v0 in
let v1' = U.raise_val v1 in
H.pts_to_ref_injective r p0 p1 v0' v1' m;
raise_val_inj v0 v1
let pts_to_not_null (#a:Type u#0)
(x:ref a)
(p:perm)
(v:a)
(m:mem)
: Lemma (requires interp (pts_to_sl x p v) m)
(ensures x =!= null)
= let v = U.raise_val v in
H.pts_to_not_null #(U.raise_t a) x p v m
// let pts_to_not_null' (#a:Type u#0)
// (x:ref a)
// (p:perm)
// (v: erased a)
// (m:mem)
// (m1:mem{disjoint m m1})
// : Lemma (requires interp (pts_to_sl x p v) m)
// (ensures interp (pts_to_sl x p v) (Mem.join m m1))
// = ()
let pts_to_witinv (#a:Type) (r:ref a) (p:perm) : Lemma (is_witness_invariant (pts_to_sl r p)) =
let aux (x y : a) (m:mem)
: Lemma (requires (interp (pts_to_sl r p x) m /\ interp (pts_to_sl r p y) m))
(ensures (x == y))
= H.pts_to_witinv r p;
raise_val_inj x y
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
let pts_to_injective_eq #a #opened #p0 #p1 #v0 #v1 r =
extract_info_raw (pts_to r p0 v0 `star` pts_to r p1 v1) (v0 == v1)
(fun m -> pts_to_ref_injective r p0 p1 v0 v1 m);
rewrite_slprop (pts_to r p1 v1) (pts_to r p1 v0) (fun _ -> ())
let pts_to_perm
r
= H.pts_to_perm r
let alloc_pt x =
let r = H.alloc (U.raise_val x) in
rewrite_slprop (H.pts_to r full_perm (U.raise_val x)) (pts_to r full_perm x) (fun _ -> ());
return r
let read_pt #a #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
let x = H.read r in
let v':a = U.downgrade_val x in
rewrite_slprop (H.pts_to r p (hide x)) (pts_to r p v') (fun _ -> ());
return v'
let read_refine_pt #a #p q r =
Classical.forall_intro_2 reveal_equiv;
lift_exists (fun (v:a) -> pts_to r p v `star` q v);
exists_cong (fun (v:U.raise_t a) -> pts_to r p (U.downgrade_val v) `star` q (U.downgrade_val v))
(fun (v:U.raise_t a) -> H.pts_to r p v `star` U.lift_dom q v);
let x = H.read_refine (U.lift_dom q) r in
rewrite_slprop
(H.pts_to r p (hide x) `star` U.lift_dom q x)
(pts_to r p (U.downgrade_val x) `star` q (U.downgrade_val x)) (fun _ -> ());
return (U.downgrade_val x)
let write_pt #a #v r x =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
let x' = U.raise_val x in
H.write r x';
rewrite_slprop (H.pts_to r full_perm (hide x')) (pts_to r full_perm x) (fun _ -> ())
let free_pt #a #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
H.free r
let share_gen_pt #a #uses #p #v r p1 p2 =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
H.share_gen r p1 p2;
rewrite_slprop (H.pts_to r p1 v') (pts_to r p1 v) (fun _ -> ());
rewrite_slprop (H.pts_to r p2 v') (pts_to r p2 v) (fun _ -> ())
let share_pt #a #uses #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
H.share r;
rewrite_slprop (H.pts_to r (half_perm p) v') (pts_to r (half_perm p) v) (fun _ -> ());
rewrite_slprop (H.pts_to r (half_perm p) v') (pts_to r (half_perm p) v) (fun _ -> ())
let hide_raise_reveal (#a:Type) (v0:erased a) (v1:erased a)
: Lemma (hide (U.raise_val (reveal v0)) == hide (U.raise_val (reveal v1)) <==>
v0 == v1)
[SMTPat (hide (U.raise_val (reveal v0)));
SMTPat (hide (U.raise_val (reveal v1)))]
= let u0 = hide (U.raise_val (reveal v0)) in
let u1 = hide (U.raise_val (reveal v1)) in
assert (U.downgrade_val (U.raise_val (reveal v0)) == U.downgrade_val (U.raise_val (reveal v1)) <==>
v0 == v1)
let gather_pt #a #uses #p0 #p1 #v0 #v1 r =
let v0' = Ghost.hide (U.raise_val (Ghost.reveal v0)) in
let v1' = Ghost.hide (U.raise_val (Ghost.reveal v1)) in
rewrite_slprop (pts_to r p0 v0) (H.pts_to r p0 v0') (fun _ -> ());
rewrite_slprop (pts_to r p1 v1) (H.pts_to r p1 v1') (fun _ -> ());
let (u:unit{v0' == v1'}) = H.gather #_ #_ #p0 #p1 #v0' #v1' r in
rewrite_slprop (H.pts_to r (sum_perm p0 p1) v0') (pts_to r (sum_perm p0 p1) v0) (fun _ -> ());
u
let raise_equiv (#t:Type) (x y:t)
: Lemma (U.raise_val x == U.raise_val y <==>
x == y)
= assert (U.downgrade_val (U.raise_val x) == x);
assert (U.downgrade_val (U.raise_val y) == y)
let downgrade_equiv (#t:Type) (x y:U.raise_t t)
: Lemma (U.downgrade_val x == U.downgrade_val y <==>
x == y)
= assert (U.raise_val (U.downgrade_val x) == x);
assert (U.raise_val (U.downgrade_val y) == y)
let lift_eq (#t:eqtype) (x y:U.raise_t t)
: b:bool{b <==> x==y}
= downgrade_equiv x y; U.downgrade_val x = U.downgrade_val y
let cas_action (#t:eqtype)
(#uses:inames)
(r:ref t)
(v:Ghost.erased t)
(v_old:t)
(v_new:t)
(frame:slprop)
: MstTot (b:bool{b <==> (Ghost.reveal v == v_old)})
uses
(pts_to_sl r full_perm v)
(fun b -> if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v)
frame
(fun _ -> True)
(fun _ _ _ -> True)
= let hv = (Ghost.hide (U.raise_val (Ghost.reveal v))) in
let b = H.cas_action #(U.raise_t t)
(lift_eq #t)
#uses
r
hv
(U.raise_val v_old)
(U.raise_val v_new)
frame
in
assert (b <==> (Ghost.reveal hv == U.raise_val v_old));
assert (b <==> U.raise_val (Ghost.reveal v) == U.raise_val v_old);
raise_equiv (Ghost.reveal v) v_old;
b
let atomic_read_pt_u32 #_ #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
let x = H.atomic_read r in
let v':U32.t = U.downgrade_val x in
rewrite_slprop (H.pts_to r p (hide x)) (pts_to r p v') (fun _ -> ());
return v'
let atomic_write_pt_u32 #_ #v r x =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
let x' = U.raise_val x in
H.atomic_write r x';
rewrite_slprop (H.pts_to r full_perm (hide x')) (pts_to r full_perm x) (fun _ -> ())
let cas_pt_u32 #uses r v v_old v_new =
let b = as_atomic_action (cas_action #U32.t #uses r v v_old v_new) in
rewrite_slprop (to_vprop (if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v))
(if b then pts_to r full_perm v_new else pts_to r full_perm v)
(fun _ -> ());
return b
let cas_pt_bool #uses r v v_old v_new =
let b = as_atomic_action (cas_action #bool #uses r v v_old v_new) in
rewrite_slprop (to_vprop (if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v))
(if b then pts_to r full_perm v_new else pts_to r full_perm v)
(fun _ -> ());
return b
(* Library for references with fractional permissions.
Permissions need to be an index of the vprop ptr.
It cannot be part of a selector, as it is not invariant when joining with a disjoint memory
Using the value of the ref as a selector is ok because refs with fractional permissions
all share the same value.
Refs on PCM are more complicated, and likely not usable with selectors
*)
let ptrp r p = Mem.h_exists (pts_to_sl r p)
val ptr_sel' (#a:Type0) (r: ref a) (p: perm) : selector' a (ptrp r p)
let ptr_sel' #a r p = fun h -> id_elim_exists #a (pts_to_sl r p) h
let ptr_sel_depends_only_on (#a:Type0) (r:ref a)
(p: perm)
(m0:Mem.hmem (ptrp r p)) (m1:mem{disjoint m0 m1})
: Lemma (ptr_sel' r p m0 == ptr_sel' r p (Mem.join m0 m1))
= let x = reveal (id_elim_exists #a (pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (pts_to_sl r p) (Mem.join m0 m1)) in
pts_to_witinv r p;
elim_wi (pts_to_sl r p) x y (Mem.join m0 m1)
let ptr_sel_depends_only_on_core (#a:Type0) (r:ref a)
(p: perm) (m0:Mem.hmem (ptrp r p))
: Lemma (ptr_sel' r p m0 == ptr_sel' r p (core_mem m0))
= let x = reveal (id_elim_exists #a (pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (pts_to_sl r p) (core_mem m0)) in
pts_to_witinv r p;
elim_wi (pts_to_sl r p) x y (core_mem m0)
let ptrp_sel r p =
Classical.forall_intro_2 (ptr_sel_depends_only_on r p);
Classical.forall_intro (ptr_sel_depends_only_on_core r p);
ptr_sel' r p
let ptrp_sel_interp #a r p m = pts_to_witinv r p
let intro_ptrp_interp r p v m = intro_h_exists (reveal v) (pts_to_sl r p) m
let intro_vptr_lemma (#a:Type) (r:ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (pts_to_sl r p v) m)
(ensures interp (ptrp r p) m /\ ptrp_sel r p m == reveal v)
= Mem.intro_h_exists (reveal v) (pts_to_sl r p) m;
pts_to_witinv r p
let elim_vptr_lemma (#a:Type) (r:ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (ptrp r p) m /\ ptrp_sel r p m == reveal v)
(ensures interp (pts_to_sl r p v) m)
= Mem.elim_h_exists (pts_to_sl r p) m;
pts_to_witinv r p
let intro_vptr (#a:Type) (#opened:inames) (r:ref a) (p: perm) (v:erased a)
: SteelGhost unit opened (pts_to r p v) (fun _ -> vptrp r p)
(requires fun _ -> True)
(ensures fun _ _ h1 -> h1 (vptrp r p) == reveal v)
= change_slprop_2 (pts_to r p v) (vptrp r p) v (intro_vptr_lemma r p v)
let elim_vptr (#a:Type) (#opened:inames) (r:ref a) (p: perm)
: SteelGhost (erased a) opened (vptrp r p) (fun v -> pts_to r p v)
(requires fun _ -> True)
(ensures fun h0 v _ -> reveal v == h0 (vptrp r p))
= let v = gget (vptrp r p) in
change_slprop (vptrp r p) (pts_to r p v) v () (elim_vptr_lemma r p v);
v
let malloc x =
let r = alloc_pt x in
intro_vptr r _ (hide x);
return r
let free r =
let _ = elim_vptr r _ in
free_pt r
let readp r _ =
let _ = elim_vptr r _ in
let x = read_pt r in
intro_vptr r _ x;
return x
let write r x =
let _ = elim_vptr r _ in
write_pt r x;
intro_vptr r _ x
let share #a #_ #p r =
let x = elim_vptr r p in
share_pt r;
intro_vptr r _ x;
intro_vptr r _ x
let gather_gen #a #_ r p0 p1 =
let x1 = elim_vptr r p1 in
let x0 = elim_vptr r p0 in
gather_pt #_ #_ #p0 #p1 #x0 #x1 r;
intro_vptr r (sum_perm p0 p1) x0;
sum_perm p0 p1
let gather (#a: Type0) (#uses: _) (#p: perm) (r: ref a)
: SteelGhost unit uses
(vptrp r (half_perm p) `star` vptrp r (half_perm p))
(fun _ -> vptrp r p)
(fun _ -> True)
(fun h _ h' ->
h' (vptrp r p) == h (vptrp r (half_perm p))
)
= let _ = gather_gen r _ _ in
change_equal_slprop
(vptrp r _)
(vptrp r p)
(*** Lemmas on references *)
let vptrp_not_null
#opened #a r
p
= change_slprop_rel
(vptrp r p)
(vptrp r p)
(fun x y -> x == y /\ is_null r == false)
(fun m -> pts_to_not_null r p (ptrp_sel r p m) m)
(*** Ghost pointers *)
(*** GHOST REFERENCES ***)
let ghost_ref a = H.ghost_ref (U.raise_t a)
let dummy_ghost_ref a =
H.reveal_ghost_ref (U.raise_t a);
coerce_eq () (Ghost.hide (H.null #(U.raise_t a)))
[@__reduce__]
let ghost_pts_to_sl #a r p x = H.ghost_pts_to_sl #(U.raise_t a) r p (U.raise_val x)
let ghost_pts_to_witinv (#a:Type) (r:ghost_ref a) (p:perm) : Lemma (is_witness_invariant (ghost_pts_to_sl r p)) =
let aux (x y : a) (m:mem)
: Lemma (requires (interp (ghost_pts_to_sl r p x) m /\ interp (ghost_pts_to_sl r p y) m))
(ensures (x == y))
= H.ghost_pts_to_witinv r p;
raise_val_inj x y
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
[@@__reduce__]
let raise_erased (#a:Type0) (x:erased a)
: erased (U.raise_t u#0 u#1 a)
= Ghost.hide (U.raise_val (Ghost.reveal x))
let ghost_alloc_pt (#a:Type) (#u:_) (x:erased a)
: SteelGhostT (ghost_ref a) u
emp
(fun r -> ghost_pts_to r full_perm x)
= H.ghost_alloc (raise_erased x)
let ghost_free_pt r = H.ghost_free r
let ghost_share_gen_pt
#_ #_ #_ #x r p1 p2
= H.ghost_share_gen #_ #_ #_ #(raise_erased x) r p1 p2
let ghost_share_pt (#a:Type) (#u:_)
(#p:perm)
(#x:erased a)
(r:ghost_ref a)
= H.ghost_share #_ #_ #_ #(raise_erased x) r
let ghost_gather_pt (#a:Type) (#u:_)
(#p0 #p1:perm)
(#x0 #x1:erased a)
(r:ghost_ref a)
: SteelGhost unit u
(ghost_pts_to r p0 x0 `star`
ghost_pts_to r p1 x1)
(fun _ -> ghost_pts_to r (sum_perm p0 p1) x0)
(requires fun _ -> true)
(ensures fun _ _ _ -> x0 == x1)
= H.ghost_gather r
let ghost_pts_to_injective_eq (#a:_) (#u:_) (#p #q:_) (r:ghost_ref a) (v0 v1:Ghost.erased a)
: SteelGhost unit u
(ghost_pts_to r p v0 `star` ghost_pts_to r q v1)
(fun _ -> ghost_pts_to r p v0 `star` ghost_pts_to r q v0)
(requires fun _ -> True)
(ensures fun _ _ _ -> v0 == v1)
= H.ghost_pts_to_injective_eq #_ #_ #p #q r (raise_erased v0) (raise_erased v1)
let ghost_pts_to_perm r = H.ghost_pts_to_perm r
let ghost_read_pt #a #u #p #v r =
let x = H.ghost_read r in
let x' = hide (U.downgrade_val (reveal x)) in
rewrite_slprop (H.ghost_pts_to r p x) (ghost_pts_to r p x') (fun _ -> ());
x'
let ghost_write_pt (#a:Type) (#u:_) (#v:erased a) (r:ghost_ref a) (x:erased a)
: SteelGhostT unit u
(ghost_pts_to r full_perm v)
(fun _ -> ghost_pts_to r full_perm x)
= H.ghost_write r (raise_erased x)
(* Selector version of ghost pointers *)
let ghost_ptrp r p = Mem.h_exists (ghost_pts_to_sl r p)
val ghost_ptr_sel' (#a:Type0) (r: ghost_ref a) (p: perm) : selector' a (ghost_ptrp r p)
let ghost_ptr_sel' #a r p = fun h -> id_elim_exists #a (ghost_pts_to_sl r p) h
let ghost_ptr_sel_depends_only_on (#a:Type0) (r:ghost_ref a)
(p: perm)
(m0:Mem.hmem (ghost_ptrp r p)) (m1:mem{disjoint m0 m1})
: Lemma (ghost_ptr_sel' r p m0 == ghost_ptr_sel' r p (Mem.join m0 m1))
= let x = reveal (id_elim_exists #a (ghost_pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (ghost_pts_to_sl r p) (Mem.join m0 m1)) in
ghost_pts_to_witinv r p;
elim_wi (ghost_pts_to_sl r p) x y (Mem.join m0 m1)
let ghost_ptr_sel_depends_only_on_core (#a:Type0) (r:ghost_ref a)
(p: perm) (m0:Mem.hmem (ghost_ptrp r p))
: Lemma (ghost_ptr_sel' r p m0 == ghost_ptr_sel' r p (core_mem m0))
= let x = reveal (id_elim_exists #a (ghost_pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (ghost_pts_to_sl r p) (core_mem m0)) in
ghost_pts_to_witinv r p;
elim_wi (ghost_pts_to_sl r p) x y (core_mem m0)
let ghost_ptrp_sel r p =
Classical.forall_intro_2 (ghost_ptr_sel_depends_only_on r p);
Classical.forall_intro (ghost_ptr_sel_depends_only_on_core r p);
ghost_ptr_sel' r p
let ghost_ptrp_sel_interp #a r p m = ghost_pts_to_witinv r p
let intro_ghost_vptr_lemma (#a:Type) (r:ghost_ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (ghost_pts_to_sl r p v) m)
(ensures interp (ghost_ptrp r p) m /\ ghost_ptrp_sel r p m == reveal v)
= Mem.intro_h_exists (reveal v) (ghost_pts_to_sl r p) m;
ghost_pts_to_witinv r p
let elim_ghost_vptr_lemma (#a:Type) (r:ghost_ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (ghost_ptrp r p) m /\ ghost_ptrp_sel r p m == reveal v)
(ensures interp (ghost_pts_to_sl r p v) m)
= Mem.elim_h_exists (ghost_pts_to_sl r p) m;
ghost_pts_to_witinv r p
let intro_ghost_vptr (#a:Type) (#opened:inames) (r:ghost_ref a) (p: perm) (v:erased a)
: SteelGhost unit opened (ghost_pts_to r p v) (fun _ -> ghost_vptrp r p)
(requires fun _ -> True)
(ensures fun _ _ h1 -> h1 (ghost_vptrp r p) == reveal v)
= change_slprop_2 (ghost_pts_to r p v) (ghost_vptrp r p) v (intro_ghost_vptr_lemma r p v) | {
"checked_file": "/",
"dependencies": [
"Steel.Memory.fsti.checked",
"Steel.HigherReference.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Reference.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "Steel.HigherReference",
"short_module": "H"
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | r: Steel.Reference.ghost_ref a -> p: Steel.FractionalPermission.perm
-> Steel.Effect.Atomic.SteelGhost (FStar.Ghost.erased a) | Steel.Effect.Atomic.SteelGhost | [] | [] | [
"Steel.Memory.inames",
"Steel.Reference.ghost_ref",
"Steel.FractionalPermission.perm",
"FStar.Ghost.erased",
"Prims.unit",
"Steel.Effect.Atomic.change_slprop",
"Steel.Reference.ghost_vptrp",
"Steel.Reference.ghost_pts_to",
"FStar.Ghost.reveal",
"Steel.Effect.Common.t_of",
"FStar.Ghost.hide",
"Steel.Effect.Common.normal",
"Steel.Reference.elim_ghost_vptr_lemma",
"Steel.Effect.Common.VUnit",
"Steel.Reference.ghost_vptr'",
"Steel.Effect.Atomic.gget",
"Steel.Effect.Common.vprop",
"Steel.Effect.Common.rmem",
"Prims.l_True",
"Prims.eq2"
] | [] | false | true | false | false | false | let elim_ghost_vptr (#a: Type) (#opened: inames) (r: ghost_ref a) (p: perm)
: SteelGhost (erased a)
opened
(ghost_vptrp r p)
(fun v -> ghost_pts_to r p v)
(requires fun _ -> True)
(ensures fun h0 v _ -> reveal v == h0 (ghost_vptrp r p)) =
| let v = gget (ghost_vptrp r p) in
change_slprop (ghost_vptrp r p) (ghost_pts_to r p v) v () (elim_ghost_vptr_lemma r p v);
v | false |
Steel.Reference.fst | Steel.Reference.ghost_readp | val ghost_readp (#a:Type0) (#opened:inames) (r:ghost_ref a)
(p: perm)
: SteelGhost (Ghost.erased a) opened
(ghost_vptrp r p) (fun _ -> ghost_vptrp r p)
(requires fun _ -> True)
(ensures fun h0 x h1 -> h0 (ghost_vptrp r p) == h1 (ghost_vptrp r p) /\ Ghost.reveal x == h1 (ghost_vptrp r p)) | val ghost_readp (#a:Type0) (#opened:inames) (r:ghost_ref a)
(p: perm)
: SteelGhost (Ghost.erased a) opened
(ghost_vptrp r p) (fun _ -> ghost_vptrp r p)
(requires fun _ -> True)
(ensures fun h0 x h1 -> h0 (ghost_vptrp r p) == h1 (ghost_vptrp r p) /\ Ghost.reveal x == h1 (ghost_vptrp r p)) | let ghost_readp r _ =
let _ = elim_ghost_vptr r _ in
let x = ghost_read_pt r in
intro_ghost_vptr r _ x;
x | {
"file_name": "lib/steel/Steel.Reference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 3,
"end_line": 518,
"start_col": 0,
"start_line": 514
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.Reference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module Mem = Steel.Memory
module H = Steel.HigherReference
module U = FStar.Universe
#set-options "--ide_id_info_off"
let ref a = H.ref (U.raise_t a)
let null #a = H.null #(U.raise_t a)
let is_null #a r = H.is_null #(U.raise_t a) r
let pts_to_sl r p v = H.pts_to_sl r p (U.raise_val v)
val raise_val_inj (#a:Type) (x y:a) : Lemma
(requires U.raise_val x == U.raise_val y)
(ensures x == y)
let raise_val_inj x y =
U.downgrade_val_raise_val x;
U.downgrade_val_raise_val y
let pts_to_ref_injective
(#a: Type u#0)
(r: ref a)
(p0 p1:perm)
(v0 v1:a)
(m:mem)
: Lemma
(requires
interp (pts_to_sl r p0 v0 `Mem.star` pts_to_sl r p1 v1) m)
(ensures v0 == v1)
= let v0' = U.raise_val v0 in
let v1' = U.raise_val v1 in
H.pts_to_ref_injective r p0 p1 v0' v1' m;
raise_val_inj v0 v1
let pts_to_not_null (#a:Type u#0)
(x:ref a)
(p:perm)
(v:a)
(m:mem)
: Lemma (requires interp (pts_to_sl x p v) m)
(ensures x =!= null)
= let v = U.raise_val v in
H.pts_to_not_null #(U.raise_t a) x p v m
// let pts_to_not_null' (#a:Type u#0)
// (x:ref a)
// (p:perm)
// (v: erased a)
// (m:mem)
// (m1:mem{disjoint m m1})
// : Lemma (requires interp (pts_to_sl x p v) m)
// (ensures interp (pts_to_sl x p v) (Mem.join m m1))
// = ()
let pts_to_witinv (#a:Type) (r:ref a) (p:perm) : Lemma (is_witness_invariant (pts_to_sl r p)) =
let aux (x y : a) (m:mem)
: Lemma (requires (interp (pts_to_sl r p x) m /\ interp (pts_to_sl r p y) m))
(ensures (x == y))
= H.pts_to_witinv r p;
raise_val_inj x y
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
let pts_to_injective_eq #a #opened #p0 #p1 #v0 #v1 r =
extract_info_raw (pts_to r p0 v0 `star` pts_to r p1 v1) (v0 == v1)
(fun m -> pts_to_ref_injective r p0 p1 v0 v1 m);
rewrite_slprop (pts_to r p1 v1) (pts_to r p1 v0) (fun _ -> ())
let pts_to_perm
r
= H.pts_to_perm r
let alloc_pt x =
let r = H.alloc (U.raise_val x) in
rewrite_slprop (H.pts_to r full_perm (U.raise_val x)) (pts_to r full_perm x) (fun _ -> ());
return r
let read_pt #a #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
let x = H.read r in
let v':a = U.downgrade_val x in
rewrite_slprop (H.pts_to r p (hide x)) (pts_to r p v') (fun _ -> ());
return v'
let read_refine_pt #a #p q r =
Classical.forall_intro_2 reveal_equiv;
lift_exists (fun (v:a) -> pts_to r p v `star` q v);
exists_cong (fun (v:U.raise_t a) -> pts_to r p (U.downgrade_val v) `star` q (U.downgrade_val v))
(fun (v:U.raise_t a) -> H.pts_to r p v `star` U.lift_dom q v);
let x = H.read_refine (U.lift_dom q) r in
rewrite_slprop
(H.pts_to r p (hide x) `star` U.lift_dom q x)
(pts_to r p (U.downgrade_val x) `star` q (U.downgrade_val x)) (fun _ -> ());
return (U.downgrade_val x)
let write_pt #a #v r x =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
let x' = U.raise_val x in
H.write r x';
rewrite_slprop (H.pts_to r full_perm (hide x')) (pts_to r full_perm x) (fun _ -> ())
let free_pt #a #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
H.free r
let share_gen_pt #a #uses #p #v r p1 p2 =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
H.share_gen r p1 p2;
rewrite_slprop (H.pts_to r p1 v') (pts_to r p1 v) (fun _ -> ());
rewrite_slprop (H.pts_to r p2 v') (pts_to r p2 v) (fun _ -> ())
let share_pt #a #uses #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
H.share r;
rewrite_slprop (H.pts_to r (half_perm p) v') (pts_to r (half_perm p) v) (fun _ -> ());
rewrite_slprop (H.pts_to r (half_perm p) v') (pts_to r (half_perm p) v) (fun _ -> ())
let hide_raise_reveal (#a:Type) (v0:erased a) (v1:erased a)
: Lemma (hide (U.raise_val (reveal v0)) == hide (U.raise_val (reveal v1)) <==>
v0 == v1)
[SMTPat (hide (U.raise_val (reveal v0)));
SMTPat (hide (U.raise_val (reveal v1)))]
= let u0 = hide (U.raise_val (reveal v0)) in
let u1 = hide (U.raise_val (reveal v1)) in
assert (U.downgrade_val (U.raise_val (reveal v0)) == U.downgrade_val (U.raise_val (reveal v1)) <==>
v0 == v1)
let gather_pt #a #uses #p0 #p1 #v0 #v1 r =
let v0' = Ghost.hide (U.raise_val (Ghost.reveal v0)) in
let v1' = Ghost.hide (U.raise_val (Ghost.reveal v1)) in
rewrite_slprop (pts_to r p0 v0) (H.pts_to r p0 v0') (fun _ -> ());
rewrite_slprop (pts_to r p1 v1) (H.pts_to r p1 v1') (fun _ -> ());
let (u:unit{v0' == v1'}) = H.gather #_ #_ #p0 #p1 #v0' #v1' r in
rewrite_slprop (H.pts_to r (sum_perm p0 p1) v0') (pts_to r (sum_perm p0 p1) v0) (fun _ -> ());
u
let raise_equiv (#t:Type) (x y:t)
: Lemma (U.raise_val x == U.raise_val y <==>
x == y)
= assert (U.downgrade_val (U.raise_val x) == x);
assert (U.downgrade_val (U.raise_val y) == y)
let downgrade_equiv (#t:Type) (x y:U.raise_t t)
: Lemma (U.downgrade_val x == U.downgrade_val y <==>
x == y)
= assert (U.raise_val (U.downgrade_val x) == x);
assert (U.raise_val (U.downgrade_val y) == y)
let lift_eq (#t:eqtype) (x y:U.raise_t t)
: b:bool{b <==> x==y}
= downgrade_equiv x y; U.downgrade_val x = U.downgrade_val y
let cas_action (#t:eqtype)
(#uses:inames)
(r:ref t)
(v:Ghost.erased t)
(v_old:t)
(v_new:t)
(frame:slprop)
: MstTot (b:bool{b <==> (Ghost.reveal v == v_old)})
uses
(pts_to_sl r full_perm v)
(fun b -> if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v)
frame
(fun _ -> True)
(fun _ _ _ -> True)
= let hv = (Ghost.hide (U.raise_val (Ghost.reveal v))) in
let b = H.cas_action #(U.raise_t t)
(lift_eq #t)
#uses
r
hv
(U.raise_val v_old)
(U.raise_val v_new)
frame
in
assert (b <==> (Ghost.reveal hv == U.raise_val v_old));
assert (b <==> U.raise_val (Ghost.reveal v) == U.raise_val v_old);
raise_equiv (Ghost.reveal v) v_old;
b
let atomic_read_pt_u32 #_ #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
let x = H.atomic_read r in
let v':U32.t = U.downgrade_val x in
rewrite_slprop (H.pts_to r p (hide x)) (pts_to r p v') (fun _ -> ());
return v'
let atomic_write_pt_u32 #_ #v r x =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
let x' = U.raise_val x in
H.atomic_write r x';
rewrite_slprop (H.pts_to r full_perm (hide x')) (pts_to r full_perm x) (fun _ -> ())
let cas_pt_u32 #uses r v v_old v_new =
let b = as_atomic_action (cas_action #U32.t #uses r v v_old v_new) in
rewrite_slprop (to_vprop (if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v))
(if b then pts_to r full_perm v_new else pts_to r full_perm v)
(fun _ -> ());
return b
let cas_pt_bool #uses r v v_old v_new =
let b = as_atomic_action (cas_action #bool #uses r v v_old v_new) in
rewrite_slprop (to_vprop (if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v))
(if b then pts_to r full_perm v_new else pts_to r full_perm v)
(fun _ -> ());
return b
(* Library for references with fractional permissions.
Permissions need to be an index of the vprop ptr.
It cannot be part of a selector, as it is not invariant when joining with a disjoint memory
Using the value of the ref as a selector is ok because refs with fractional permissions
all share the same value.
Refs on PCM are more complicated, and likely not usable with selectors
*)
let ptrp r p = Mem.h_exists (pts_to_sl r p)
val ptr_sel' (#a:Type0) (r: ref a) (p: perm) : selector' a (ptrp r p)
let ptr_sel' #a r p = fun h -> id_elim_exists #a (pts_to_sl r p) h
let ptr_sel_depends_only_on (#a:Type0) (r:ref a)
(p: perm)
(m0:Mem.hmem (ptrp r p)) (m1:mem{disjoint m0 m1})
: Lemma (ptr_sel' r p m0 == ptr_sel' r p (Mem.join m0 m1))
= let x = reveal (id_elim_exists #a (pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (pts_to_sl r p) (Mem.join m0 m1)) in
pts_to_witinv r p;
elim_wi (pts_to_sl r p) x y (Mem.join m0 m1)
let ptr_sel_depends_only_on_core (#a:Type0) (r:ref a)
(p: perm) (m0:Mem.hmem (ptrp r p))
: Lemma (ptr_sel' r p m0 == ptr_sel' r p (core_mem m0))
= let x = reveal (id_elim_exists #a (pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (pts_to_sl r p) (core_mem m0)) in
pts_to_witinv r p;
elim_wi (pts_to_sl r p) x y (core_mem m0)
let ptrp_sel r p =
Classical.forall_intro_2 (ptr_sel_depends_only_on r p);
Classical.forall_intro (ptr_sel_depends_only_on_core r p);
ptr_sel' r p
let ptrp_sel_interp #a r p m = pts_to_witinv r p
let intro_ptrp_interp r p v m = intro_h_exists (reveal v) (pts_to_sl r p) m
let intro_vptr_lemma (#a:Type) (r:ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (pts_to_sl r p v) m)
(ensures interp (ptrp r p) m /\ ptrp_sel r p m == reveal v)
= Mem.intro_h_exists (reveal v) (pts_to_sl r p) m;
pts_to_witinv r p
let elim_vptr_lemma (#a:Type) (r:ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (ptrp r p) m /\ ptrp_sel r p m == reveal v)
(ensures interp (pts_to_sl r p v) m)
= Mem.elim_h_exists (pts_to_sl r p) m;
pts_to_witinv r p
let intro_vptr (#a:Type) (#opened:inames) (r:ref a) (p: perm) (v:erased a)
: SteelGhost unit opened (pts_to r p v) (fun _ -> vptrp r p)
(requires fun _ -> True)
(ensures fun _ _ h1 -> h1 (vptrp r p) == reveal v)
= change_slprop_2 (pts_to r p v) (vptrp r p) v (intro_vptr_lemma r p v)
let elim_vptr (#a:Type) (#opened:inames) (r:ref a) (p: perm)
: SteelGhost (erased a) opened (vptrp r p) (fun v -> pts_to r p v)
(requires fun _ -> True)
(ensures fun h0 v _ -> reveal v == h0 (vptrp r p))
= let v = gget (vptrp r p) in
change_slprop (vptrp r p) (pts_to r p v) v () (elim_vptr_lemma r p v);
v
let malloc x =
let r = alloc_pt x in
intro_vptr r _ (hide x);
return r
let free r =
let _ = elim_vptr r _ in
free_pt r
let readp r _ =
let _ = elim_vptr r _ in
let x = read_pt r in
intro_vptr r _ x;
return x
let write r x =
let _ = elim_vptr r _ in
write_pt r x;
intro_vptr r _ x
let share #a #_ #p r =
let x = elim_vptr r p in
share_pt r;
intro_vptr r _ x;
intro_vptr r _ x
let gather_gen #a #_ r p0 p1 =
let x1 = elim_vptr r p1 in
let x0 = elim_vptr r p0 in
gather_pt #_ #_ #p0 #p1 #x0 #x1 r;
intro_vptr r (sum_perm p0 p1) x0;
sum_perm p0 p1
let gather (#a: Type0) (#uses: _) (#p: perm) (r: ref a)
: SteelGhost unit uses
(vptrp r (half_perm p) `star` vptrp r (half_perm p))
(fun _ -> vptrp r p)
(fun _ -> True)
(fun h _ h' ->
h' (vptrp r p) == h (vptrp r (half_perm p))
)
= let _ = gather_gen r _ _ in
change_equal_slprop
(vptrp r _)
(vptrp r p)
(*** Lemmas on references *)
let vptrp_not_null
#opened #a r
p
= change_slprop_rel
(vptrp r p)
(vptrp r p)
(fun x y -> x == y /\ is_null r == false)
(fun m -> pts_to_not_null r p (ptrp_sel r p m) m)
(*** Ghost pointers *)
(*** GHOST REFERENCES ***)
let ghost_ref a = H.ghost_ref (U.raise_t a)
let dummy_ghost_ref a =
H.reveal_ghost_ref (U.raise_t a);
coerce_eq () (Ghost.hide (H.null #(U.raise_t a)))
[@__reduce__]
let ghost_pts_to_sl #a r p x = H.ghost_pts_to_sl #(U.raise_t a) r p (U.raise_val x)
let ghost_pts_to_witinv (#a:Type) (r:ghost_ref a) (p:perm) : Lemma (is_witness_invariant (ghost_pts_to_sl r p)) =
let aux (x y : a) (m:mem)
: Lemma (requires (interp (ghost_pts_to_sl r p x) m /\ interp (ghost_pts_to_sl r p y) m))
(ensures (x == y))
= H.ghost_pts_to_witinv r p;
raise_val_inj x y
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
[@@__reduce__]
let raise_erased (#a:Type0) (x:erased a)
: erased (U.raise_t u#0 u#1 a)
= Ghost.hide (U.raise_val (Ghost.reveal x))
let ghost_alloc_pt (#a:Type) (#u:_) (x:erased a)
: SteelGhostT (ghost_ref a) u
emp
(fun r -> ghost_pts_to r full_perm x)
= H.ghost_alloc (raise_erased x)
let ghost_free_pt r = H.ghost_free r
let ghost_share_gen_pt
#_ #_ #_ #x r p1 p2
= H.ghost_share_gen #_ #_ #_ #(raise_erased x) r p1 p2
let ghost_share_pt (#a:Type) (#u:_)
(#p:perm)
(#x:erased a)
(r:ghost_ref a)
= H.ghost_share #_ #_ #_ #(raise_erased x) r
let ghost_gather_pt (#a:Type) (#u:_)
(#p0 #p1:perm)
(#x0 #x1:erased a)
(r:ghost_ref a)
: SteelGhost unit u
(ghost_pts_to r p0 x0 `star`
ghost_pts_to r p1 x1)
(fun _ -> ghost_pts_to r (sum_perm p0 p1) x0)
(requires fun _ -> true)
(ensures fun _ _ _ -> x0 == x1)
= H.ghost_gather r
let ghost_pts_to_injective_eq (#a:_) (#u:_) (#p #q:_) (r:ghost_ref a) (v0 v1:Ghost.erased a)
: SteelGhost unit u
(ghost_pts_to r p v0 `star` ghost_pts_to r q v1)
(fun _ -> ghost_pts_to r p v0 `star` ghost_pts_to r q v0)
(requires fun _ -> True)
(ensures fun _ _ _ -> v0 == v1)
= H.ghost_pts_to_injective_eq #_ #_ #p #q r (raise_erased v0) (raise_erased v1)
let ghost_pts_to_perm r = H.ghost_pts_to_perm r
let ghost_read_pt #a #u #p #v r =
let x = H.ghost_read r in
let x' = hide (U.downgrade_val (reveal x)) in
rewrite_slprop (H.ghost_pts_to r p x) (ghost_pts_to r p x') (fun _ -> ());
x'
let ghost_write_pt (#a:Type) (#u:_) (#v:erased a) (r:ghost_ref a) (x:erased a)
: SteelGhostT unit u
(ghost_pts_to r full_perm v)
(fun _ -> ghost_pts_to r full_perm x)
= H.ghost_write r (raise_erased x)
(* Selector version of ghost pointers *)
let ghost_ptrp r p = Mem.h_exists (ghost_pts_to_sl r p)
val ghost_ptr_sel' (#a:Type0) (r: ghost_ref a) (p: perm) : selector' a (ghost_ptrp r p)
let ghost_ptr_sel' #a r p = fun h -> id_elim_exists #a (ghost_pts_to_sl r p) h
let ghost_ptr_sel_depends_only_on (#a:Type0) (r:ghost_ref a)
(p: perm)
(m0:Mem.hmem (ghost_ptrp r p)) (m1:mem{disjoint m0 m1})
: Lemma (ghost_ptr_sel' r p m0 == ghost_ptr_sel' r p (Mem.join m0 m1))
= let x = reveal (id_elim_exists #a (ghost_pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (ghost_pts_to_sl r p) (Mem.join m0 m1)) in
ghost_pts_to_witinv r p;
elim_wi (ghost_pts_to_sl r p) x y (Mem.join m0 m1)
let ghost_ptr_sel_depends_only_on_core (#a:Type0) (r:ghost_ref a)
(p: perm) (m0:Mem.hmem (ghost_ptrp r p))
: Lemma (ghost_ptr_sel' r p m0 == ghost_ptr_sel' r p (core_mem m0))
= let x = reveal (id_elim_exists #a (ghost_pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (ghost_pts_to_sl r p) (core_mem m0)) in
ghost_pts_to_witinv r p;
elim_wi (ghost_pts_to_sl r p) x y (core_mem m0)
let ghost_ptrp_sel r p =
Classical.forall_intro_2 (ghost_ptr_sel_depends_only_on r p);
Classical.forall_intro (ghost_ptr_sel_depends_only_on_core r p);
ghost_ptr_sel' r p
let ghost_ptrp_sel_interp #a r p m = ghost_pts_to_witinv r p
let intro_ghost_vptr_lemma (#a:Type) (r:ghost_ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (ghost_pts_to_sl r p v) m)
(ensures interp (ghost_ptrp r p) m /\ ghost_ptrp_sel r p m == reveal v)
= Mem.intro_h_exists (reveal v) (ghost_pts_to_sl r p) m;
ghost_pts_to_witinv r p
let elim_ghost_vptr_lemma (#a:Type) (r:ghost_ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (ghost_ptrp r p) m /\ ghost_ptrp_sel r p m == reveal v)
(ensures interp (ghost_pts_to_sl r p v) m)
= Mem.elim_h_exists (ghost_pts_to_sl r p) m;
ghost_pts_to_witinv r p
let intro_ghost_vptr (#a:Type) (#opened:inames) (r:ghost_ref a) (p: perm) (v:erased a)
: SteelGhost unit opened (ghost_pts_to r p v) (fun _ -> ghost_vptrp r p)
(requires fun _ -> True)
(ensures fun _ _ h1 -> h1 (ghost_vptrp r p) == reveal v)
= change_slprop_2 (ghost_pts_to r p v) (ghost_vptrp r p) v (intro_ghost_vptr_lemma r p v)
let elim_ghost_vptr (#a:Type) (#opened:inames) (r:ghost_ref a)
(p: perm)
: SteelGhost (erased a) opened (ghost_vptrp r p) (fun v -> ghost_pts_to r p v)
(requires fun _ -> True)
(ensures fun h0 v _ -> reveal v == h0 (ghost_vptrp r p))
= let v = gget (ghost_vptrp r p) in
change_slprop (ghost_vptrp r p) (ghost_pts_to r p v) v () (elim_ghost_vptr_lemma r p v);
v
let ghost_alloc x =
let r = ghost_alloc_pt x in
intro_ghost_vptr r _ x;
r
let ghost_free r =
let _ = elim_ghost_vptr r _ in
ghost_free_pt r | {
"checked_file": "/",
"dependencies": [
"Steel.Memory.fsti.checked",
"Steel.HigherReference.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Reference.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "Steel.HigherReference",
"short_module": "H"
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | r: Steel.Reference.ghost_ref a -> p: Steel.FractionalPermission.perm
-> Steel.Effect.Atomic.SteelGhost (FStar.Ghost.erased a) | Steel.Effect.Atomic.SteelGhost | [] | [] | [
"Steel.Memory.inames",
"Steel.Reference.ghost_ref",
"Steel.FractionalPermission.perm",
"FStar.Ghost.erased",
"Prims.unit",
"Steel.Reference.intro_ghost_vptr",
"Steel.Reference.ghost_read_pt",
"Steel.Reference.elim_ghost_vptr"
] | [] | false | true | false | false | false | let ghost_readp r _ =
| let _ = elim_ghost_vptr r _ in
let x = ghost_read_pt r in
intro_ghost_vptr r _ x;
x | false |
Steel.Reference.fst | Steel.Reference.ghost_share | val ghost_share (#a:Type0) (#uses:_) (#p: perm) (r:ghost_ref a)
: SteelGhost unit uses
(ghost_vptrp r p)
(fun _ -> ghost_vptrp r (half_perm p) `star` ghost_vptrp r (half_perm p))
(fun _ -> True)
(fun h res h' ->
h' (ghost_vptrp r (half_perm p)) == h (ghost_vptrp r p)
) | val ghost_share (#a:Type0) (#uses:_) (#p: perm) (r:ghost_ref a)
: SteelGhost unit uses
(ghost_vptrp r p)
(fun _ -> ghost_vptrp r (half_perm p) `star` ghost_vptrp r (half_perm p))
(fun _ -> True)
(fun h res h' ->
h' (ghost_vptrp r (half_perm p)) == h (ghost_vptrp r p)
) | let ghost_share #a #_ #p r =
let x = elim_ghost_vptr r p in
ghost_share_pt r;
intro_ghost_vptr r _ x;
intro_ghost_vptr r _ x | {
"file_name": "lib/steel/Steel.Reference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 24,
"end_line": 529,
"start_col": 0,
"start_line": 525
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.Reference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module Mem = Steel.Memory
module H = Steel.HigherReference
module U = FStar.Universe
#set-options "--ide_id_info_off"
let ref a = H.ref (U.raise_t a)
let null #a = H.null #(U.raise_t a)
let is_null #a r = H.is_null #(U.raise_t a) r
let pts_to_sl r p v = H.pts_to_sl r p (U.raise_val v)
val raise_val_inj (#a:Type) (x y:a) : Lemma
(requires U.raise_val x == U.raise_val y)
(ensures x == y)
let raise_val_inj x y =
U.downgrade_val_raise_val x;
U.downgrade_val_raise_val y
let pts_to_ref_injective
(#a: Type u#0)
(r: ref a)
(p0 p1:perm)
(v0 v1:a)
(m:mem)
: Lemma
(requires
interp (pts_to_sl r p0 v0 `Mem.star` pts_to_sl r p1 v1) m)
(ensures v0 == v1)
= let v0' = U.raise_val v0 in
let v1' = U.raise_val v1 in
H.pts_to_ref_injective r p0 p1 v0' v1' m;
raise_val_inj v0 v1
let pts_to_not_null (#a:Type u#0)
(x:ref a)
(p:perm)
(v:a)
(m:mem)
: Lemma (requires interp (pts_to_sl x p v) m)
(ensures x =!= null)
= let v = U.raise_val v in
H.pts_to_not_null #(U.raise_t a) x p v m
// let pts_to_not_null' (#a:Type u#0)
// (x:ref a)
// (p:perm)
// (v: erased a)
// (m:mem)
// (m1:mem{disjoint m m1})
// : Lemma (requires interp (pts_to_sl x p v) m)
// (ensures interp (pts_to_sl x p v) (Mem.join m m1))
// = ()
let pts_to_witinv (#a:Type) (r:ref a) (p:perm) : Lemma (is_witness_invariant (pts_to_sl r p)) =
let aux (x y : a) (m:mem)
: Lemma (requires (interp (pts_to_sl r p x) m /\ interp (pts_to_sl r p y) m))
(ensures (x == y))
= H.pts_to_witinv r p;
raise_val_inj x y
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
let pts_to_injective_eq #a #opened #p0 #p1 #v0 #v1 r =
extract_info_raw (pts_to r p0 v0 `star` pts_to r p1 v1) (v0 == v1)
(fun m -> pts_to_ref_injective r p0 p1 v0 v1 m);
rewrite_slprop (pts_to r p1 v1) (pts_to r p1 v0) (fun _ -> ())
let pts_to_perm
r
= H.pts_to_perm r
let alloc_pt x =
let r = H.alloc (U.raise_val x) in
rewrite_slprop (H.pts_to r full_perm (U.raise_val x)) (pts_to r full_perm x) (fun _ -> ());
return r
let read_pt #a #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
let x = H.read r in
let v':a = U.downgrade_val x in
rewrite_slprop (H.pts_to r p (hide x)) (pts_to r p v') (fun _ -> ());
return v'
let read_refine_pt #a #p q r =
Classical.forall_intro_2 reveal_equiv;
lift_exists (fun (v:a) -> pts_to r p v `star` q v);
exists_cong (fun (v:U.raise_t a) -> pts_to r p (U.downgrade_val v) `star` q (U.downgrade_val v))
(fun (v:U.raise_t a) -> H.pts_to r p v `star` U.lift_dom q v);
let x = H.read_refine (U.lift_dom q) r in
rewrite_slprop
(H.pts_to r p (hide x) `star` U.lift_dom q x)
(pts_to r p (U.downgrade_val x) `star` q (U.downgrade_val x)) (fun _ -> ());
return (U.downgrade_val x)
let write_pt #a #v r x =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
let x' = U.raise_val x in
H.write r x';
rewrite_slprop (H.pts_to r full_perm (hide x')) (pts_to r full_perm x) (fun _ -> ())
let free_pt #a #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
H.free r
let share_gen_pt #a #uses #p #v r p1 p2 =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
H.share_gen r p1 p2;
rewrite_slprop (H.pts_to r p1 v') (pts_to r p1 v) (fun _ -> ());
rewrite_slprop (H.pts_to r p2 v') (pts_to r p2 v) (fun _ -> ())
let share_pt #a #uses #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
H.share r;
rewrite_slprop (H.pts_to r (half_perm p) v') (pts_to r (half_perm p) v) (fun _ -> ());
rewrite_slprop (H.pts_to r (half_perm p) v') (pts_to r (half_perm p) v) (fun _ -> ())
let hide_raise_reveal (#a:Type) (v0:erased a) (v1:erased a)
: Lemma (hide (U.raise_val (reveal v0)) == hide (U.raise_val (reveal v1)) <==>
v0 == v1)
[SMTPat (hide (U.raise_val (reveal v0)));
SMTPat (hide (U.raise_val (reveal v1)))]
= let u0 = hide (U.raise_val (reveal v0)) in
let u1 = hide (U.raise_val (reveal v1)) in
assert (U.downgrade_val (U.raise_val (reveal v0)) == U.downgrade_val (U.raise_val (reveal v1)) <==>
v0 == v1)
let gather_pt #a #uses #p0 #p1 #v0 #v1 r =
let v0' = Ghost.hide (U.raise_val (Ghost.reveal v0)) in
let v1' = Ghost.hide (U.raise_val (Ghost.reveal v1)) in
rewrite_slprop (pts_to r p0 v0) (H.pts_to r p0 v0') (fun _ -> ());
rewrite_slprop (pts_to r p1 v1) (H.pts_to r p1 v1') (fun _ -> ());
let (u:unit{v0' == v1'}) = H.gather #_ #_ #p0 #p1 #v0' #v1' r in
rewrite_slprop (H.pts_to r (sum_perm p0 p1) v0') (pts_to r (sum_perm p0 p1) v0) (fun _ -> ());
u
let raise_equiv (#t:Type) (x y:t)
: Lemma (U.raise_val x == U.raise_val y <==>
x == y)
= assert (U.downgrade_val (U.raise_val x) == x);
assert (U.downgrade_val (U.raise_val y) == y)
let downgrade_equiv (#t:Type) (x y:U.raise_t t)
: Lemma (U.downgrade_val x == U.downgrade_val y <==>
x == y)
= assert (U.raise_val (U.downgrade_val x) == x);
assert (U.raise_val (U.downgrade_val y) == y)
let lift_eq (#t:eqtype) (x y:U.raise_t t)
: b:bool{b <==> x==y}
= downgrade_equiv x y; U.downgrade_val x = U.downgrade_val y
let cas_action (#t:eqtype)
(#uses:inames)
(r:ref t)
(v:Ghost.erased t)
(v_old:t)
(v_new:t)
(frame:slprop)
: MstTot (b:bool{b <==> (Ghost.reveal v == v_old)})
uses
(pts_to_sl r full_perm v)
(fun b -> if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v)
frame
(fun _ -> True)
(fun _ _ _ -> True)
= let hv = (Ghost.hide (U.raise_val (Ghost.reveal v))) in
let b = H.cas_action #(U.raise_t t)
(lift_eq #t)
#uses
r
hv
(U.raise_val v_old)
(U.raise_val v_new)
frame
in
assert (b <==> (Ghost.reveal hv == U.raise_val v_old));
assert (b <==> U.raise_val (Ghost.reveal v) == U.raise_val v_old);
raise_equiv (Ghost.reveal v) v_old;
b
let atomic_read_pt_u32 #_ #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
let x = H.atomic_read r in
let v':U32.t = U.downgrade_val x in
rewrite_slprop (H.pts_to r p (hide x)) (pts_to r p v') (fun _ -> ());
return v'
let atomic_write_pt_u32 #_ #v r x =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
let x' = U.raise_val x in
H.atomic_write r x';
rewrite_slprop (H.pts_to r full_perm (hide x')) (pts_to r full_perm x) (fun _ -> ())
let cas_pt_u32 #uses r v v_old v_new =
let b = as_atomic_action (cas_action #U32.t #uses r v v_old v_new) in
rewrite_slprop (to_vprop (if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v))
(if b then pts_to r full_perm v_new else pts_to r full_perm v)
(fun _ -> ());
return b
let cas_pt_bool #uses r v v_old v_new =
let b = as_atomic_action (cas_action #bool #uses r v v_old v_new) in
rewrite_slprop (to_vprop (if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v))
(if b then pts_to r full_perm v_new else pts_to r full_perm v)
(fun _ -> ());
return b
(* Library for references with fractional permissions.
Permissions need to be an index of the vprop ptr.
It cannot be part of a selector, as it is not invariant when joining with a disjoint memory
Using the value of the ref as a selector is ok because refs with fractional permissions
all share the same value.
Refs on PCM are more complicated, and likely not usable with selectors
*)
let ptrp r p = Mem.h_exists (pts_to_sl r p)
val ptr_sel' (#a:Type0) (r: ref a) (p: perm) : selector' a (ptrp r p)
let ptr_sel' #a r p = fun h -> id_elim_exists #a (pts_to_sl r p) h
let ptr_sel_depends_only_on (#a:Type0) (r:ref a)
(p: perm)
(m0:Mem.hmem (ptrp r p)) (m1:mem{disjoint m0 m1})
: Lemma (ptr_sel' r p m0 == ptr_sel' r p (Mem.join m0 m1))
= let x = reveal (id_elim_exists #a (pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (pts_to_sl r p) (Mem.join m0 m1)) in
pts_to_witinv r p;
elim_wi (pts_to_sl r p) x y (Mem.join m0 m1)
let ptr_sel_depends_only_on_core (#a:Type0) (r:ref a)
(p: perm) (m0:Mem.hmem (ptrp r p))
: Lemma (ptr_sel' r p m0 == ptr_sel' r p (core_mem m0))
= let x = reveal (id_elim_exists #a (pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (pts_to_sl r p) (core_mem m0)) in
pts_to_witinv r p;
elim_wi (pts_to_sl r p) x y (core_mem m0)
let ptrp_sel r p =
Classical.forall_intro_2 (ptr_sel_depends_only_on r p);
Classical.forall_intro (ptr_sel_depends_only_on_core r p);
ptr_sel' r p
let ptrp_sel_interp #a r p m = pts_to_witinv r p
let intro_ptrp_interp r p v m = intro_h_exists (reveal v) (pts_to_sl r p) m
let intro_vptr_lemma (#a:Type) (r:ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (pts_to_sl r p v) m)
(ensures interp (ptrp r p) m /\ ptrp_sel r p m == reveal v)
= Mem.intro_h_exists (reveal v) (pts_to_sl r p) m;
pts_to_witinv r p
let elim_vptr_lemma (#a:Type) (r:ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (ptrp r p) m /\ ptrp_sel r p m == reveal v)
(ensures interp (pts_to_sl r p v) m)
= Mem.elim_h_exists (pts_to_sl r p) m;
pts_to_witinv r p
let intro_vptr (#a:Type) (#opened:inames) (r:ref a) (p: perm) (v:erased a)
: SteelGhost unit opened (pts_to r p v) (fun _ -> vptrp r p)
(requires fun _ -> True)
(ensures fun _ _ h1 -> h1 (vptrp r p) == reveal v)
= change_slprop_2 (pts_to r p v) (vptrp r p) v (intro_vptr_lemma r p v)
let elim_vptr (#a:Type) (#opened:inames) (r:ref a) (p: perm)
: SteelGhost (erased a) opened (vptrp r p) (fun v -> pts_to r p v)
(requires fun _ -> True)
(ensures fun h0 v _ -> reveal v == h0 (vptrp r p))
= let v = gget (vptrp r p) in
change_slprop (vptrp r p) (pts_to r p v) v () (elim_vptr_lemma r p v);
v
let malloc x =
let r = alloc_pt x in
intro_vptr r _ (hide x);
return r
let free r =
let _ = elim_vptr r _ in
free_pt r
let readp r _ =
let _ = elim_vptr r _ in
let x = read_pt r in
intro_vptr r _ x;
return x
let write r x =
let _ = elim_vptr r _ in
write_pt r x;
intro_vptr r _ x
let share #a #_ #p r =
let x = elim_vptr r p in
share_pt r;
intro_vptr r _ x;
intro_vptr r _ x
let gather_gen #a #_ r p0 p1 =
let x1 = elim_vptr r p1 in
let x0 = elim_vptr r p0 in
gather_pt #_ #_ #p0 #p1 #x0 #x1 r;
intro_vptr r (sum_perm p0 p1) x0;
sum_perm p0 p1
let gather (#a: Type0) (#uses: _) (#p: perm) (r: ref a)
: SteelGhost unit uses
(vptrp r (half_perm p) `star` vptrp r (half_perm p))
(fun _ -> vptrp r p)
(fun _ -> True)
(fun h _ h' ->
h' (vptrp r p) == h (vptrp r (half_perm p))
)
= let _ = gather_gen r _ _ in
change_equal_slprop
(vptrp r _)
(vptrp r p)
(*** Lemmas on references *)
let vptrp_not_null
#opened #a r
p
= change_slprop_rel
(vptrp r p)
(vptrp r p)
(fun x y -> x == y /\ is_null r == false)
(fun m -> pts_to_not_null r p (ptrp_sel r p m) m)
(*** Ghost pointers *)
(*** GHOST REFERENCES ***)
let ghost_ref a = H.ghost_ref (U.raise_t a)
let dummy_ghost_ref a =
H.reveal_ghost_ref (U.raise_t a);
coerce_eq () (Ghost.hide (H.null #(U.raise_t a)))
[@__reduce__]
let ghost_pts_to_sl #a r p x = H.ghost_pts_to_sl #(U.raise_t a) r p (U.raise_val x)
let ghost_pts_to_witinv (#a:Type) (r:ghost_ref a) (p:perm) : Lemma (is_witness_invariant (ghost_pts_to_sl r p)) =
let aux (x y : a) (m:mem)
: Lemma (requires (interp (ghost_pts_to_sl r p x) m /\ interp (ghost_pts_to_sl r p y) m))
(ensures (x == y))
= H.ghost_pts_to_witinv r p;
raise_val_inj x y
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
[@@__reduce__]
let raise_erased (#a:Type0) (x:erased a)
: erased (U.raise_t u#0 u#1 a)
= Ghost.hide (U.raise_val (Ghost.reveal x))
let ghost_alloc_pt (#a:Type) (#u:_) (x:erased a)
: SteelGhostT (ghost_ref a) u
emp
(fun r -> ghost_pts_to r full_perm x)
= H.ghost_alloc (raise_erased x)
let ghost_free_pt r = H.ghost_free r
let ghost_share_gen_pt
#_ #_ #_ #x r p1 p2
= H.ghost_share_gen #_ #_ #_ #(raise_erased x) r p1 p2
let ghost_share_pt (#a:Type) (#u:_)
(#p:perm)
(#x:erased a)
(r:ghost_ref a)
= H.ghost_share #_ #_ #_ #(raise_erased x) r
let ghost_gather_pt (#a:Type) (#u:_)
(#p0 #p1:perm)
(#x0 #x1:erased a)
(r:ghost_ref a)
: SteelGhost unit u
(ghost_pts_to r p0 x0 `star`
ghost_pts_to r p1 x1)
(fun _ -> ghost_pts_to r (sum_perm p0 p1) x0)
(requires fun _ -> true)
(ensures fun _ _ _ -> x0 == x1)
= H.ghost_gather r
let ghost_pts_to_injective_eq (#a:_) (#u:_) (#p #q:_) (r:ghost_ref a) (v0 v1:Ghost.erased a)
: SteelGhost unit u
(ghost_pts_to r p v0 `star` ghost_pts_to r q v1)
(fun _ -> ghost_pts_to r p v0 `star` ghost_pts_to r q v0)
(requires fun _ -> True)
(ensures fun _ _ _ -> v0 == v1)
= H.ghost_pts_to_injective_eq #_ #_ #p #q r (raise_erased v0) (raise_erased v1)
let ghost_pts_to_perm r = H.ghost_pts_to_perm r
let ghost_read_pt #a #u #p #v r =
let x = H.ghost_read r in
let x' = hide (U.downgrade_val (reveal x)) in
rewrite_slprop (H.ghost_pts_to r p x) (ghost_pts_to r p x') (fun _ -> ());
x'
let ghost_write_pt (#a:Type) (#u:_) (#v:erased a) (r:ghost_ref a) (x:erased a)
: SteelGhostT unit u
(ghost_pts_to r full_perm v)
(fun _ -> ghost_pts_to r full_perm x)
= H.ghost_write r (raise_erased x)
(* Selector version of ghost pointers *)
let ghost_ptrp r p = Mem.h_exists (ghost_pts_to_sl r p)
val ghost_ptr_sel' (#a:Type0) (r: ghost_ref a) (p: perm) : selector' a (ghost_ptrp r p)
let ghost_ptr_sel' #a r p = fun h -> id_elim_exists #a (ghost_pts_to_sl r p) h
let ghost_ptr_sel_depends_only_on (#a:Type0) (r:ghost_ref a)
(p: perm)
(m0:Mem.hmem (ghost_ptrp r p)) (m1:mem{disjoint m0 m1})
: Lemma (ghost_ptr_sel' r p m0 == ghost_ptr_sel' r p (Mem.join m0 m1))
= let x = reveal (id_elim_exists #a (ghost_pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (ghost_pts_to_sl r p) (Mem.join m0 m1)) in
ghost_pts_to_witinv r p;
elim_wi (ghost_pts_to_sl r p) x y (Mem.join m0 m1)
let ghost_ptr_sel_depends_only_on_core (#a:Type0) (r:ghost_ref a)
(p: perm) (m0:Mem.hmem (ghost_ptrp r p))
: Lemma (ghost_ptr_sel' r p m0 == ghost_ptr_sel' r p (core_mem m0))
= let x = reveal (id_elim_exists #a (ghost_pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (ghost_pts_to_sl r p) (core_mem m0)) in
ghost_pts_to_witinv r p;
elim_wi (ghost_pts_to_sl r p) x y (core_mem m0)
let ghost_ptrp_sel r p =
Classical.forall_intro_2 (ghost_ptr_sel_depends_only_on r p);
Classical.forall_intro (ghost_ptr_sel_depends_only_on_core r p);
ghost_ptr_sel' r p
let ghost_ptrp_sel_interp #a r p m = ghost_pts_to_witinv r p
let intro_ghost_vptr_lemma (#a:Type) (r:ghost_ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (ghost_pts_to_sl r p v) m)
(ensures interp (ghost_ptrp r p) m /\ ghost_ptrp_sel r p m == reveal v)
= Mem.intro_h_exists (reveal v) (ghost_pts_to_sl r p) m;
ghost_pts_to_witinv r p
let elim_ghost_vptr_lemma (#a:Type) (r:ghost_ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (ghost_ptrp r p) m /\ ghost_ptrp_sel r p m == reveal v)
(ensures interp (ghost_pts_to_sl r p v) m)
= Mem.elim_h_exists (ghost_pts_to_sl r p) m;
ghost_pts_to_witinv r p
let intro_ghost_vptr (#a:Type) (#opened:inames) (r:ghost_ref a) (p: perm) (v:erased a)
: SteelGhost unit opened (ghost_pts_to r p v) (fun _ -> ghost_vptrp r p)
(requires fun _ -> True)
(ensures fun _ _ h1 -> h1 (ghost_vptrp r p) == reveal v)
= change_slprop_2 (ghost_pts_to r p v) (ghost_vptrp r p) v (intro_ghost_vptr_lemma r p v)
let elim_ghost_vptr (#a:Type) (#opened:inames) (r:ghost_ref a)
(p: perm)
: SteelGhost (erased a) opened (ghost_vptrp r p) (fun v -> ghost_pts_to r p v)
(requires fun _ -> True)
(ensures fun h0 v _ -> reveal v == h0 (ghost_vptrp r p))
= let v = gget (ghost_vptrp r p) in
change_slprop (ghost_vptrp r p) (ghost_pts_to r p v) v () (elim_ghost_vptr_lemma r p v);
v
let ghost_alloc x =
let r = ghost_alloc_pt x in
intro_ghost_vptr r _ x;
r
let ghost_free r =
let _ = elim_ghost_vptr r _ in
ghost_free_pt r
let ghost_readp r _ =
let _ = elim_ghost_vptr r _ in
let x = ghost_read_pt r in
intro_ghost_vptr r _ x;
x
let ghost_write r x =
let _ = elim_ghost_vptr r _ in
ghost_write_pt r x;
intro_ghost_vptr r _ x | {
"checked_file": "/",
"dependencies": [
"Steel.Memory.fsti.checked",
"Steel.HigherReference.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Reference.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "Steel.HigherReference",
"short_module": "H"
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | r: Steel.Reference.ghost_ref a -> Steel.Effect.Atomic.SteelGhost Prims.unit | Steel.Effect.Atomic.SteelGhost | [] | [] | [
"Steel.Memory.inames",
"Steel.FractionalPermission.perm",
"Steel.Reference.ghost_ref",
"Steel.Reference.intro_ghost_vptr",
"Steel.FractionalPermission.half_perm",
"Prims.unit",
"Steel.Reference.ghost_share_pt",
"FStar.Ghost.erased",
"Steel.Reference.elim_ghost_vptr"
] | [] | false | true | false | false | false | let ghost_share #a #_ #p r =
| let x = elim_ghost_vptr r p in
ghost_share_pt r;
intro_ghost_vptr r _ x;
intro_ghost_vptr r _ x | false |
Steel.Reference.fst | Steel.Reference.ghost_gather_gen | val ghost_gather_gen (#a:Type0) (#uses:_) (r:ghost_ref a) (p0:perm) (p1:perm)
: SteelGhost perm uses
(ghost_vptrp r p0 `star` ghost_vptrp r p1)
(fun res -> ghost_vptrp r res)
(fun _ -> True)
(fun h res h' ->
res == sum_perm p0 p1 /\
h' (ghost_vptrp r res) == h (ghost_vptrp r p0) /\
h' (ghost_vptrp r res) == h (ghost_vptrp r p1)
) | val ghost_gather_gen (#a:Type0) (#uses:_) (r:ghost_ref a) (p0:perm) (p1:perm)
: SteelGhost perm uses
(ghost_vptrp r p0 `star` ghost_vptrp r p1)
(fun res -> ghost_vptrp r res)
(fun _ -> True)
(fun h res h' ->
res == sum_perm p0 p1 /\
h' (ghost_vptrp r res) == h (ghost_vptrp r p0) /\
h' (ghost_vptrp r res) == h (ghost_vptrp r p1)
) | let ghost_gather_gen #a #_ r p0 p1 =
let x1 = elim_ghost_vptr r p1 in
let x0 = elim_ghost_vptr r p0 in
ghost_gather_pt #_ #_ #p0 #p1 #x0 #x1 r;
intro_ghost_vptr r (sum_perm p0 p1) x0;
sum_perm p0 p1 | {
"file_name": "lib/steel/Steel.Reference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 16,
"end_line": 536,
"start_col": 0,
"start_line": 531
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.Reference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module Mem = Steel.Memory
module H = Steel.HigherReference
module U = FStar.Universe
#set-options "--ide_id_info_off"
let ref a = H.ref (U.raise_t a)
let null #a = H.null #(U.raise_t a)
let is_null #a r = H.is_null #(U.raise_t a) r
let pts_to_sl r p v = H.pts_to_sl r p (U.raise_val v)
val raise_val_inj (#a:Type) (x y:a) : Lemma
(requires U.raise_val x == U.raise_val y)
(ensures x == y)
let raise_val_inj x y =
U.downgrade_val_raise_val x;
U.downgrade_val_raise_val y
let pts_to_ref_injective
(#a: Type u#0)
(r: ref a)
(p0 p1:perm)
(v0 v1:a)
(m:mem)
: Lemma
(requires
interp (pts_to_sl r p0 v0 `Mem.star` pts_to_sl r p1 v1) m)
(ensures v0 == v1)
= let v0' = U.raise_val v0 in
let v1' = U.raise_val v1 in
H.pts_to_ref_injective r p0 p1 v0' v1' m;
raise_val_inj v0 v1
let pts_to_not_null (#a:Type u#0)
(x:ref a)
(p:perm)
(v:a)
(m:mem)
: Lemma (requires interp (pts_to_sl x p v) m)
(ensures x =!= null)
= let v = U.raise_val v in
H.pts_to_not_null #(U.raise_t a) x p v m
// let pts_to_not_null' (#a:Type u#0)
// (x:ref a)
// (p:perm)
// (v: erased a)
// (m:mem)
// (m1:mem{disjoint m m1})
// : Lemma (requires interp (pts_to_sl x p v) m)
// (ensures interp (pts_to_sl x p v) (Mem.join m m1))
// = ()
let pts_to_witinv (#a:Type) (r:ref a) (p:perm) : Lemma (is_witness_invariant (pts_to_sl r p)) =
let aux (x y : a) (m:mem)
: Lemma (requires (interp (pts_to_sl r p x) m /\ interp (pts_to_sl r p y) m))
(ensures (x == y))
= H.pts_to_witinv r p;
raise_val_inj x y
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
let pts_to_injective_eq #a #opened #p0 #p1 #v0 #v1 r =
extract_info_raw (pts_to r p0 v0 `star` pts_to r p1 v1) (v0 == v1)
(fun m -> pts_to_ref_injective r p0 p1 v0 v1 m);
rewrite_slprop (pts_to r p1 v1) (pts_to r p1 v0) (fun _ -> ())
let pts_to_perm
r
= H.pts_to_perm r
let alloc_pt x =
let r = H.alloc (U.raise_val x) in
rewrite_slprop (H.pts_to r full_perm (U.raise_val x)) (pts_to r full_perm x) (fun _ -> ());
return r
let read_pt #a #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
let x = H.read r in
let v':a = U.downgrade_val x in
rewrite_slprop (H.pts_to r p (hide x)) (pts_to r p v') (fun _ -> ());
return v'
let read_refine_pt #a #p q r =
Classical.forall_intro_2 reveal_equiv;
lift_exists (fun (v:a) -> pts_to r p v `star` q v);
exists_cong (fun (v:U.raise_t a) -> pts_to r p (U.downgrade_val v) `star` q (U.downgrade_val v))
(fun (v:U.raise_t a) -> H.pts_to r p v `star` U.lift_dom q v);
let x = H.read_refine (U.lift_dom q) r in
rewrite_slprop
(H.pts_to r p (hide x) `star` U.lift_dom q x)
(pts_to r p (U.downgrade_val x) `star` q (U.downgrade_val x)) (fun _ -> ());
return (U.downgrade_val x)
let write_pt #a #v r x =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
let x' = U.raise_val x in
H.write r x';
rewrite_slprop (H.pts_to r full_perm (hide x')) (pts_to r full_perm x) (fun _ -> ())
let free_pt #a #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
H.free r
let share_gen_pt #a #uses #p #v r p1 p2 =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
H.share_gen r p1 p2;
rewrite_slprop (H.pts_to r p1 v') (pts_to r p1 v) (fun _ -> ());
rewrite_slprop (H.pts_to r p2 v') (pts_to r p2 v) (fun _ -> ())
let share_pt #a #uses #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
H.share r;
rewrite_slprop (H.pts_to r (half_perm p) v') (pts_to r (half_perm p) v) (fun _ -> ());
rewrite_slprop (H.pts_to r (half_perm p) v') (pts_to r (half_perm p) v) (fun _ -> ())
let hide_raise_reveal (#a:Type) (v0:erased a) (v1:erased a)
: Lemma (hide (U.raise_val (reveal v0)) == hide (U.raise_val (reveal v1)) <==>
v0 == v1)
[SMTPat (hide (U.raise_val (reveal v0)));
SMTPat (hide (U.raise_val (reveal v1)))]
= let u0 = hide (U.raise_val (reveal v0)) in
let u1 = hide (U.raise_val (reveal v1)) in
assert (U.downgrade_val (U.raise_val (reveal v0)) == U.downgrade_val (U.raise_val (reveal v1)) <==>
v0 == v1)
let gather_pt #a #uses #p0 #p1 #v0 #v1 r =
let v0' = Ghost.hide (U.raise_val (Ghost.reveal v0)) in
let v1' = Ghost.hide (U.raise_val (Ghost.reveal v1)) in
rewrite_slprop (pts_to r p0 v0) (H.pts_to r p0 v0') (fun _ -> ());
rewrite_slprop (pts_to r p1 v1) (H.pts_to r p1 v1') (fun _ -> ());
let (u:unit{v0' == v1'}) = H.gather #_ #_ #p0 #p1 #v0' #v1' r in
rewrite_slprop (H.pts_to r (sum_perm p0 p1) v0') (pts_to r (sum_perm p0 p1) v0) (fun _ -> ());
u
let raise_equiv (#t:Type) (x y:t)
: Lemma (U.raise_val x == U.raise_val y <==>
x == y)
= assert (U.downgrade_val (U.raise_val x) == x);
assert (U.downgrade_val (U.raise_val y) == y)
let downgrade_equiv (#t:Type) (x y:U.raise_t t)
: Lemma (U.downgrade_val x == U.downgrade_val y <==>
x == y)
= assert (U.raise_val (U.downgrade_val x) == x);
assert (U.raise_val (U.downgrade_val y) == y)
let lift_eq (#t:eqtype) (x y:U.raise_t t)
: b:bool{b <==> x==y}
= downgrade_equiv x y; U.downgrade_val x = U.downgrade_val y
let cas_action (#t:eqtype)
(#uses:inames)
(r:ref t)
(v:Ghost.erased t)
(v_old:t)
(v_new:t)
(frame:slprop)
: MstTot (b:bool{b <==> (Ghost.reveal v == v_old)})
uses
(pts_to_sl r full_perm v)
(fun b -> if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v)
frame
(fun _ -> True)
(fun _ _ _ -> True)
= let hv = (Ghost.hide (U.raise_val (Ghost.reveal v))) in
let b = H.cas_action #(U.raise_t t)
(lift_eq #t)
#uses
r
hv
(U.raise_val v_old)
(U.raise_val v_new)
frame
in
assert (b <==> (Ghost.reveal hv == U.raise_val v_old));
assert (b <==> U.raise_val (Ghost.reveal v) == U.raise_val v_old);
raise_equiv (Ghost.reveal v) v_old;
b
let atomic_read_pt_u32 #_ #p #v r =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r p v) (H.pts_to r p v') (fun _ -> ());
let x = H.atomic_read r in
let v':U32.t = U.downgrade_val x in
rewrite_slprop (H.pts_to r p (hide x)) (pts_to r p v') (fun _ -> ());
return v'
let atomic_write_pt_u32 #_ #v r x =
let v' = Ghost.hide (U.raise_val (Ghost.reveal v)) in
rewrite_slprop (pts_to r full_perm v) (H.pts_to r full_perm v') (fun _ -> ());
let x' = U.raise_val x in
H.atomic_write r x';
rewrite_slprop (H.pts_to r full_perm (hide x')) (pts_to r full_perm x) (fun _ -> ())
let cas_pt_u32 #uses r v v_old v_new =
let b = as_atomic_action (cas_action #U32.t #uses r v v_old v_new) in
rewrite_slprop (to_vprop (if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v))
(if b then pts_to r full_perm v_new else pts_to r full_perm v)
(fun _ -> ());
return b
let cas_pt_bool #uses r v v_old v_new =
let b = as_atomic_action (cas_action #bool #uses r v v_old v_new) in
rewrite_slprop (to_vprop (if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v))
(if b then pts_to r full_perm v_new else pts_to r full_perm v)
(fun _ -> ());
return b
(* Library for references with fractional permissions.
Permissions need to be an index of the vprop ptr.
It cannot be part of a selector, as it is not invariant when joining with a disjoint memory
Using the value of the ref as a selector is ok because refs with fractional permissions
all share the same value.
Refs on PCM are more complicated, and likely not usable with selectors
*)
let ptrp r p = Mem.h_exists (pts_to_sl r p)
val ptr_sel' (#a:Type0) (r: ref a) (p: perm) : selector' a (ptrp r p)
let ptr_sel' #a r p = fun h -> id_elim_exists #a (pts_to_sl r p) h
let ptr_sel_depends_only_on (#a:Type0) (r:ref a)
(p: perm)
(m0:Mem.hmem (ptrp r p)) (m1:mem{disjoint m0 m1})
: Lemma (ptr_sel' r p m0 == ptr_sel' r p (Mem.join m0 m1))
= let x = reveal (id_elim_exists #a (pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (pts_to_sl r p) (Mem.join m0 m1)) in
pts_to_witinv r p;
elim_wi (pts_to_sl r p) x y (Mem.join m0 m1)
let ptr_sel_depends_only_on_core (#a:Type0) (r:ref a)
(p: perm) (m0:Mem.hmem (ptrp r p))
: Lemma (ptr_sel' r p m0 == ptr_sel' r p (core_mem m0))
= let x = reveal (id_elim_exists #a (pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (pts_to_sl r p) (core_mem m0)) in
pts_to_witinv r p;
elim_wi (pts_to_sl r p) x y (core_mem m0)
let ptrp_sel r p =
Classical.forall_intro_2 (ptr_sel_depends_only_on r p);
Classical.forall_intro (ptr_sel_depends_only_on_core r p);
ptr_sel' r p
let ptrp_sel_interp #a r p m = pts_to_witinv r p
let intro_ptrp_interp r p v m = intro_h_exists (reveal v) (pts_to_sl r p) m
let intro_vptr_lemma (#a:Type) (r:ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (pts_to_sl r p v) m)
(ensures interp (ptrp r p) m /\ ptrp_sel r p m == reveal v)
= Mem.intro_h_exists (reveal v) (pts_to_sl r p) m;
pts_to_witinv r p
let elim_vptr_lemma (#a:Type) (r:ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (ptrp r p) m /\ ptrp_sel r p m == reveal v)
(ensures interp (pts_to_sl r p v) m)
= Mem.elim_h_exists (pts_to_sl r p) m;
pts_to_witinv r p
let intro_vptr (#a:Type) (#opened:inames) (r:ref a) (p: perm) (v:erased a)
: SteelGhost unit opened (pts_to r p v) (fun _ -> vptrp r p)
(requires fun _ -> True)
(ensures fun _ _ h1 -> h1 (vptrp r p) == reveal v)
= change_slprop_2 (pts_to r p v) (vptrp r p) v (intro_vptr_lemma r p v)
let elim_vptr (#a:Type) (#opened:inames) (r:ref a) (p: perm)
: SteelGhost (erased a) opened (vptrp r p) (fun v -> pts_to r p v)
(requires fun _ -> True)
(ensures fun h0 v _ -> reveal v == h0 (vptrp r p))
= let v = gget (vptrp r p) in
change_slprop (vptrp r p) (pts_to r p v) v () (elim_vptr_lemma r p v);
v
let malloc x =
let r = alloc_pt x in
intro_vptr r _ (hide x);
return r
let free r =
let _ = elim_vptr r _ in
free_pt r
let readp r _ =
let _ = elim_vptr r _ in
let x = read_pt r in
intro_vptr r _ x;
return x
let write r x =
let _ = elim_vptr r _ in
write_pt r x;
intro_vptr r _ x
let share #a #_ #p r =
let x = elim_vptr r p in
share_pt r;
intro_vptr r _ x;
intro_vptr r _ x
let gather_gen #a #_ r p0 p1 =
let x1 = elim_vptr r p1 in
let x0 = elim_vptr r p0 in
gather_pt #_ #_ #p0 #p1 #x0 #x1 r;
intro_vptr r (sum_perm p0 p1) x0;
sum_perm p0 p1
let gather (#a: Type0) (#uses: _) (#p: perm) (r: ref a)
: SteelGhost unit uses
(vptrp r (half_perm p) `star` vptrp r (half_perm p))
(fun _ -> vptrp r p)
(fun _ -> True)
(fun h _ h' ->
h' (vptrp r p) == h (vptrp r (half_perm p))
)
= let _ = gather_gen r _ _ in
change_equal_slprop
(vptrp r _)
(vptrp r p)
(*** Lemmas on references *)
let vptrp_not_null
#opened #a r
p
= change_slprop_rel
(vptrp r p)
(vptrp r p)
(fun x y -> x == y /\ is_null r == false)
(fun m -> pts_to_not_null r p (ptrp_sel r p m) m)
(*** Ghost pointers *)
(*** GHOST REFERENCES ***)
let ghost_ref a = H.ghost_ref (U.raise_t a)
let dummy_ghost_ref a =
H.reveal_ghost_ref (U.raise_t a);
coerce_eq () (Ghost.hide (H.null #(U.raise_t a)))
[@__reduce__]
let ghost_pts_to_sl #a r p x = H.ghost_pts_to_sl #(U.raise_t a) r p (U.raise_val x)
let ghost_pts_to_witinv (#a:Type) (r:ghost_ref a) (p:perm) : Lemma (is_witness_invariant (ghost_pts_to_sl r p)) =
let aux (x y : a) (m:mem)
: Lemma (requires (interp (ghost_pts_to_sl r p x) m /\ interp (ghost_pts_to_sl r p y) m))
(ensures (x == y))
= H.ghost_pts_to_witinv r p;
raise_val_inj x y
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
[@@__reduce__]
let raise_erased (#a:Type0) (x:erased a)
: erased (U.raise_t u#0 u#1 a)
= Ghost.hide (U.raise_val (Ghost.reveal x))
let ghost_alloc_pt (#a:Type) (#u:_) (x:erased a)
: SteelGhostT (ghost_ref a) u
emp
(fun r -> ghost_pts_to r full_perm x)
= H.ghost_alloc (raise_erased x)
let ghost_free_pt r = H.ghost_free r
let ghost_share_gen_pt
#_ #_ #_ #x r p1 p2
= H.ghost_share_gen #_ #_ #_ #(raise_erased x) r p1 p2
let ghost_share_pt (#a:Type) (#u:_)
(#p:perm)
(#x:erased a)
(r:ghost_ref a)
= H.ghost_share #_ #_ #_ #(raise_erased x) r
let ghost_gather_pt (#a:Type) (#u:_)
(#p0 #p1:perm)
(#x0 #x1:erased a)
(r:ghost_ref a)
: SteelGhost unit u
(ghost_pts_to r p0 x0 `star`
ghost_pts_to r p1 x1)
(fun _ -> ghost_pts_to r (sum_perm p0 p1) x0)
(requires fun _ -> true)
(ensures fun _ _ _ -> x0 == x1)
= H.ghost_gather r
let ghost_pts_to_injective_eq (#a:_) (#u:_) (#p #q:_) (r:ghost_ref a) (v0 v1:Ghost.erased a)
: SteelGhost unit u
(ghost_pts_to r p v0 `star` ghost_pts_to r q v1)
(fun _ -> ghost_pts_to r p v0 `star` ghost_pts_to r q v0)
(requires fun _ -> True)
(ensures fun _ _ _ -> v0 == v1)
= H.ghost_pts_to_injective_eq #_ #_ #p #q r (raise_erased v0) (raise_erased v1)
let ghost_pts_to_perm r = H.ghost_pts_to_perm r
let ghost_read_pt #a #u #p #v r =
let x = H.ghost_read r in
let x' = hide (U.downgrade_val (reveal x)) in
rewrite_slprop (H.ghost_pts_to r p x) (ghost_pts_to r p x') (fun _ -> ());
x'
let ghost_write_pt (#a:Type) (#u:_) (#v:erased a) (r:ghost_ref a) (x:erased a)
: SteelGhostT unit u
(ghost_pts_to r full_perm v)
(fun _ -> ghost_pts_to r full_perm x)
= H.ghost_write r (raise_erased x)
(* Selector version of ghost pointers *)
let ghost_ptrp r p = Mem.h_exists (ghost_pts_to_sl r p)
val ghost_ptr_sel' (#a:Type0) (r: ghost_ref a) (p: perm) : selector' a (ghost_ptrp r p)
let ghost_ptr_sel' #a r p = fun h -> id_elim_exists #a (ghost_pts_to_sl r p) h
let ghost_ptr_sel_depends_only_on (#a:Type0) (r:ghost_ref a)
(p: perm)
(m0:Mem.hmem (ghost_ptrp r p)) (m1:mem{disjoint m0 m1})
: Lemma (ghost_ptr_sel' r p m0 == ghost_ptr_sel' r p (Mem.join m0 m1))
= let x = reveal (id_elim_exists #a (ghost_pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (ghost_pts_to_sl r p) (Mem.join m0 m1)) in
ghost_pts_to_witinv r p;
elim_wi (ghost_pts_to_sl r p) x y (Mem.join m0 m1)
let ghost_ptr_sel_depends_only_on_core (#a:Type0) (r:ghost_ref a)
(p: perm) (m0:Mem.hmem (ghost_ptrp r p))
: Lemma (ghost_ptr_sel' r p m0 == ghost_ptr_sel' r p (core_mem m0))
= let x = reveal (id_elim_exists #a (ghost_pts_to_sl r p) m0) in
let y = reveal (id_elim_exists #a (ghost_pts_to_sl r p) (core_mem m0)) in
ghost_pts_to_witinv r p;
elim_wi (ghost_pts_to_sl r p) x y (core_mem m0)
let ghost_ptrp_sel r p =
Classical.forall_intro_2 (ghost_ptr_sel_depends_only_on r p);
Classical.forall_intro (ghost_ptr_sel_depends_only_on_core r p);
ghost_ptr_sel' r p
let ghost_ptrp_sel_interp #a r p m = ghost_pts_to_witinv r p
let intro_ghost_vptr_lemma (#a:Type) (r:ghost_ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (ghost_pts_to_sl r p v) m)
(ensures interp (ghost_ptrp r p) m /\ ghost_ptrp_sel r p m == reveal v)
= Mem.intro_h_exists (reveal v) (ghost_pts_to_sl r p) m;
ghost_pts_to_witinv r p
let elim_ghost_vptr_lemma (#a:Type) (r:ghost_ref a) (p: perm) (v:erased a) (m:mem) : Lemma
(requires interp (ghost_ptrp r p) m /\ ghost_ptrp_sel r p m == reveal v)
(ensures interp (ghost_pts_to_sl r p v) m)
= Mem.elim_h_exists (ghost_pts_to_sl r p) m;
ghost_pts_to_witinv r p
let intro_ghost_vptr (#a:Type) (#opened:inames) (r:ghost_ref a) (p: perm) (v:erased a)
: SteelGhost unit opened (ghost_pts_to r p v) (fun _ -> ghost_vptrp r p)
(requires fun _ -> True)
(ensures fun _ _ h1 -> h1 (ghost_vptrp r p) == reveal v)
= change_slprop_2 (ghost_pts_to r p v) (ghost_vptrp r p) v (intro_ghost_vptr_lemma r p v)
let elim_ghost_vptr (#a:Type) (#opened:inames) (r:ghost_ref a)
(p: perm)
: SteelGhost (erased a) opened (ghost_vptrp r p) (fun v -> ghost_pts_to r p v)
(requires fun _ -> True)
(ensures fun h0 v _ -> reveal v == h0 (ghost_vptrp r p))
= let v = gget (ghost_vptrp r p) in
change_slprop (ghost_vptrp r p) (ghost_pts_to r p v) v () (elim_ghost_vptr_lemma r p v);
v
let ghost_alloc x =
let r = ghost_alloc_pt x in
intro_ghost_vptr r _ x;
r
let ghost_free r =
let _ = elim_ghost_vptr r _ in
ghost_free_pt r
let ghost_readp r _ =
let _ = elim_ghost_vptr r _ in
let x = ghost_read_pt r in
intro_ghost_vptr r _ x;
x
let ghost_write r x =
let _ = elim_ghost_vptr r _ in
ghost_write_pt r x;
intro_ghost_vptr r _ x
let ghost_share #a #_ #p r =
let x = elim_ghost_vptr r p in
ghost_share_pt r;
intro_ghost_vptr r _ x;
intro_ghost_vptr r _ x | {
"checked_file": "/",
"dependencies": [
"Steel.Memory.fsti.checked",
"Steel.HigherReference.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.Reference.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "Steel.HigherReference",
"short_module": "H"
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
r: Steel.Reference.ghost_ref a ->
p0: Steel.FractionalPermission.perm ->
p1: Steel.FractionalPermission.perm
-> Steel.Effect.Atomic.SteelGhost Steel.FractionalPermission.perm | Steel.Effect.Atomic.SteelGhost | [] | [] | [
"Steel.Memory.inames",
"Steel.Reference.ghost_ref",
"Steel.FractionalPermission.perm",
"Steel.FractionalPermission.sum_perm",
"Prims.unit",
"Steel.Reference.intro_ghost_vptr",
"Steel.Reference.ghost_gather_pt",
"FStar.Ghost.erased",
"Steel.Reference.elim_ghost_vptr"
] | [] | false | true | false | false | false | let ghost_gather_gen #a #_ r p0 p1 =
| let x1 = elim_ghost_vptr r p1 in
let x0 = elim_ghost_vptr r p0 in
ghost_gather_pt #_ #_ #p0 #p1 #x0 #x1 r;
intro_ghost_vptr r (sum_perm p0 p1) x0;
sum_perm p0 p1 | false |
Hacl.Spec.Bignum.Addition.fst | Hacl.Spec.Bignum.Addition.bn_sub_f | val bn_sub_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t | val bn_sub_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t | let bn_sub_f #t #aLen a b i c = subborrow c a.[i] b.[i] | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Addition.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 55,
"end_line": 22,
"start_col": 0,
"start_line": 22
} | module Hacl.Spec.Bignum.Addition
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_sub_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t
let bn_sub_carry_f #t #aLen a i c_in = subborrow c_in a.[i] (uint #t 0)
val bn_sub_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen)
let bn_sub_carry #t #aLen a c_in = generate_elems aLen aLen (bn_sub_carry_f a) c_in | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Addition.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Hacl.Spec.Bignum.Definitions.lbignum t aLen ->
b: Hacl.Spec.Bignum.Definitions.lbignum t aLen ->
i: Lib.IntTypes.size_nat{i < aLen} ->
c: Hacl.Spec.Bignum.Base.carry t
-> Hacl.Spec.Bignum.Base.carry t * Hacl.Spec.Bignum.Definitions.limb t | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.b2t",
"Prims.op_LessThan",
"Hacl.Spec.Bignum.Base.carry",
"Hacl.Spec.Bignum.Base.subborrow",
"Lib.Sequence.op_String_Access",
"Hacl.Spec.Bignum.Definitions.limb",
"FStar.Pervasives.Native.tuple2"
] | [] | false | false | false | false | false | let bn_sub_f #t #aLen a b i c =
| subborrow c a.[ i ] b.[ i ] | false |
Hacl.Spec.Bignum.Addition.fst | Hacl.Spec.Bignum.Addition.bn_add_f | val bn_add_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t | val bn_add_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t | let bn_add_f #t #aLen a b i c = addcarry c a.[i] b.[i] | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Addition.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 54,
"end_line": 51,
"start_col": 0,
"start_line": 51
} | module Hacl.Spec.Bignum.Addition
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_sub_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t
let bn_sub_carry_f #t #aLen a i c_in = subborrow c_in a.[i] (uint #t 0)
val bn_sub_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen)
let bn_sub_carry #t #aLen a c_in = generate_elems aLen aLen (bn_sub_carry_f a) c_in
val bn_sub_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t
let bn_sub_f #t #aLen a b i c = subborrow c a.[i] b.[i]
val bn_sub: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> tuple2 (carry t) (lbignum t aLen)
let bn_sub #t #aLen #bLen a b =
let c0, res0 = generate_elems bLen bLen (bn_sub_f (sub a 0 bLen) b) (uint #t 0) in
if bLen < aLen then
let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in
c1, concat #_ #bLen res0 res1
else c0, res0
val bn_sub1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen)
let bn_sub1 #t #aLen a b1 =
let c0, r0 = subborrow (uint #t 0) a.[0] b1 in
let res0 = create 1 r0 in
if 1 < aLen then
let c1, res1 = bn_sub_carry (sub a 1 (aLen - 1)) c0 in
c1, concat res0 res1
else c0, res0
val bn_add_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t
let bn_add_carry_f #t #aLen a i c_in = addcarry c_in a.[i] (uint #t 0)
val bn_add_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen)
let bn_add_carry #t #aLen a c_in = generate_elems aLen aLen (bn_add_carry_f a) c_in | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Addition.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Hacl.Spec.Bignum.Definitions.lbignum t aLen ->
b: Hacl.Spec.Bignum.Definitions.lbignum t aLen ->
i: Lib.IntTypes.size_nat{i < aLen} ->
c: Hacl.Spec.Bignum.Base.carry t
-> Hacl.Spec.Bignum.Base.carry t * Hacl.Spec.Bignum.Definitions.limb t | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.b2t",
"Prims.op_LessThan",
"Hacl.Spec.Bignum.Base.carry",
"Hacl.Spec.Bignum.Base.addcarry",
"Lib.Sequence.op_String_Access",
"Hacl.Spec.Bignum.Definitions.limb",
"FStar.Pervasives.Native.tuple2"
] | [] | false | false | false | false | false | let bn_add_f #t #aLen a b i c =
| addcarry c a.[ i ] b.[ i ] | false |
Hacl.Spec.Bignum.Addition.fst | Hacl.Spec.Bignum.Addition.bn_sub_carry | val bn_sub_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen) | val bn_sub_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen) | let bn_sub_carry #t #aLen a c_in = generate_elems aLen aLen (bn_sub_carry_f a) c_in | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Addition.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 83,
"end_line": 19,
"start_col": 0,
"start_line": 19
} | module Hacl.Spec.Bignum.Addition
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_sub_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t
let bn_sub_carry_f #t #aLen a i c_in = subborrow c_in a.[i] (uint #t 0) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Addition.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | a: Hacl.Spec.Bignum.Definitions.lbignum t aLen -> c_in: Hacl.Spec.Bignum.Base.carry t
-> Hacl.Spec.Bignum.Base.carry t * Hacl.Spec.Bignum.Definitions.lbignum t aLen | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Base.carry",
"Hacl.Spec.Lib.generate_elems",
"Hacl.Spec.Bignum.Definitions.limb",
"Hacl.Spec.Bignum.Addition.bn_sub_carry_f",
"FStar.Pervasives.Native.tuple2"
] | [] | false | false | false | false | false | let bn_sub_carry #t #aLen a c_in =
| generate_elems aLen aLen (bn_sub_carry_f a) c_in | false |
FStar.Tactics.SMT.fst | FStar.Tactics.SMT.smt_sync | val smt_sync: Prims.unit -> Tac unit | val smt_sync: Prims.unit -> Tac unit | let smt_sync () : Tac unit = t_smt_sync (get_vconfig ()) | {
"file_name": "ulib/FStar.Tactics.SMT.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 56,
"end_line": 8,
"start_col": 0,
"start_line": 8
} | module FStar.Tactics.SMT
open FStar.Tactics.Effect
open FStar.Stubs.Tactics.V2.Builtins
open FStar.VConfig | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.VConfig.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Stubs.Tactics.V2.Builtins.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Tactics.SMT.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.VConfig",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Tactics.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: Prims.unit -> FStar.Tactics.Effect.Tac Prims.unit | FStar.Tactics.Effect.Tac | [] | [] | [
"Prims.unit",
"FStar.Stubs.Tactics.V2.Builtins.t_smt_sync",
"FStar.VConfig.vconfig",
"FStar.Stubs.Tactics.V2.Builtins.get_vconfig"
] | [] | false | true | false | false | false | let smt_sync () : Tac unit =
| t_smt_sync (get_vconfig ()) | false |
FStar.Tactics.SMT.fst | FStar.Tactics.SMT.smt_sync' | val smt_sync' (fuel ifuel: nat) : Tac unit | val smt_sync' (fuel ifuel: nat) : Tac unit | let smt_sync' (fuel ifuel : nat) : Tac unit =
let vcfg = get_vconfig () in
let vcfg' = { vcfg with initial_fuel = fuel; max_fuel = fuel
; initial_ifuel = ifuel; max_ifuel = ifuel }
in
t_smt_sync vcfg' | {
"file_name": "ulib/FStar.Tactics.SMT.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 20,
"end_line": 16,
"start_col": 0,
"start_line": 11
} | module FStar.Tactics.SMT
open FStar.Tactics.Effect
open FStar.Stubs.Tactics.V2.Builtins
open FStar.VConfig
(* Alias to just use the current vconfig *)
let smt_sync () : Tac unit = t_smt_sync (get_vconfig ()) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.VConfig.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Stubs.Tactics.V2.Builtins.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Tactics.SMT.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.VConfig",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Tactics.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | fuel: Prims.nat -> ifuel: Prims.nat -> FStar.Tactics.Effect.Tac Prims.unit | FStar.Tactics.Effect.Tac | [] | [] | [
"Prims.nat",
"FStar.Stubs.Tactics.V2.Builtins.t_smt_sync",
"Prims.unit",
"FStar.VConfig.vconfig",
"FStar.VConfig.Mkvconfig",
"FStar.VConfig.__proj__Mkvconfig__item__detail_errors",
"FStar.VConfig.__proj__Mkvconfig__item__detail_hint_replay",
"FStar.VConfig.__proj__Mkvconfig__item__no_smt",
"FStar.VConfig.__proj__Mkvconfig__item__quake_lo",
"FStar.VConfig.__proj__Mkvconfig__item__quake_hi",
"FStar.VConfig.__proj__Mkvconfig__item__quake_keep",
"FStar.VConfig.__proj__Mkvconfig__item__retry",
"FStar.VConfig.__proj__Mkvconfig__item__smtencoding_elim_box",
"FStar.VConfig.__proj__Mkvconfig__item__smtencoding_nl_arith_repr",
"FStar.VConfig.__proj__Mkvconfig__item__smtencoding_l_arith_repr",
"FStar.VConfig.__proj__Mkvconfig__item__smtencoding_valid_intro",
"FStar.VConfig.__proj__Mkvconfig__item__smtencoding_valid_elim",
"FStar.VConfig.__proj__Mkvconfig__item__tcnorm",
"FStar.VConfig.__proj__Mkvconfig__item__no_plugins",
"FStar.VConfig.__proj__Mkvconfig__item__no_tactics",
"FStar.VConfig.__proj__Mkvconfig__item__z3cliopt",
"FStar.VConfig.__proj__Mkvconfig__item__z3smtopt",
"FStar.VConfig.__proj__Mkvconfig__item__z3refresh",
"FStar.VConfig.__proj__Mkvconfig__item__z3rlimit",
"FStar.VConfig.__proj__Mkvconfig__item__z3rlimit_factor",
"FStar.VConfig.__proj__Mkvconfig__item__z3seed",
"FStar.VConfig.__proj__Mkvconfig__item__z3version",
"FStar.VConfig.__proj__Mkvconfig__item__trivial_pre_for_unannotated_effectful_fns",
"FStar.VConfig.__proj__Mkvconfig__item__reuse_hint_for",
"FStar.Stubs.Tactics.V2.Builtins.get_vconfig"
] | [] | false | true | false | false | false | let smt_sync' (fuel ifuel: nat) : Tac unit =
| let vcfg = get_vconfig () in
let vcfg' =
{ vcfg with initial_fuel = fuel; max_fuel = fuel; initial_ifuel = ifuel; max_ifuel = ifuel }
in
t_smt_sync vcfg' | false |
FStar.Tactics.SMT.fst | FStar.Tactics.SMT.get_rlimit | val get_rlimit: Prims.unit -> Tac int | val get_rlimit: Prims.unit -> Tac int | let get_rlimit () : Tac int = (get_vconfig()).z3rlimit | {
"file_name": "ulib/FStar.Tactics.SMT.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 69,
"end_line": 20,
"start_col": 0,
"start_line": 20
} | module FStar.Tactics.SMT
open FStar.Tactics.Effect
open FStar.Stubs.Tactics.V2.Builtins
open FStar.VConfig
(* Alias to just use the current vconfig *)
let smt_sync () : Tac unit = t_smt_sync (get_vconfig ())
(* smt_sync': as smt_sync, but using a particular fuel/ifuel *)
let smt_sync' (fuel ifuel : nat) : Tac unit =
let vcfg = get_vconfig () in
let vcfg' = { vcfg with initial_fuel = fuel; max_fuel = fuel
; initial_ifuel = ifuel; max_ifuel = ifuel }
in
t_smt_sync vcfg'
(* Getting/setting solver configuration *) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.VConfig.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Stubs.Tactics.V2.Builtins.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Tactics.SMT.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.VConfig",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Tactics.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: Prims.unit -> FStar.Tactics.Effect.Tac Prims.int | FStar.Tactics.Effect.Tac | [] | [] | [
"Prims.unit",
"FStar.VConfig.__proj__Mkvconfig__item__z3rlimit",
"Prims.int",
"FStar.VConfig.vconfig",
"FStar.Stubs.Tactics.V2.Builtins.get_vconfig"
] | [] | false | true | false | false | false | let get_rlimit () : Tac int =
| (get_vconfig ()).z3rlimit | false |
Hacl.Spec.Bignum.Addition.fst | Hacl.Spec.Bignum.Addition.bn_add_carry | val bn_add_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen) | val bn_add_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen) | let bn_add_carry #t #aLen a c_in = generate_elems aLen aLen (bn_add_carry_f a) c_in | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Addition.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 83,
"end_line": 48,
"start_col": 0,
"start_line": 48
} | module Hacl.Spec.Bignum.Addition
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_sub_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t
let bn_sub_carry_f #t #aLen a i c_in = subborrow c_in a.[i] (uint #t 0)
val bn_sub_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen)
let bn_sub_carry #t #aLen a c_in = generate_elems aLen aLen (bn_sub_carry_f a) c_in
val bn_sub_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t
let bn_sub_f #t #aLen a b i c = subborrow c a.[i] b.[i]
val bn_sub: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> tuple2 (carry t) (lbignum t aLen)
let bn_sub #t #aLen #bLen a b =
let c0, res0 = generate_elems bLen bLen (bn_sub_f (sub a 0 bLen) b) (uint #t 0) in
if bLen < aLen then
let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in
c1, concat #_ #bLen res0 res1
else c0, res0
val bn_sub1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen)
let bn_sub1 #t #aLen a b1 =
let c0, r0 = subborrow (uint #t 0) a.[0] b1 in
let res0 = create 1 r0 in
if 1 < aLen then
let c1, res1 = bn_sub_carry (sub a 1 (aLen - 1)) c0 in
c1, concat res0 res1
else c0, res0
val bn_add_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t
let bn_add_carry_f #t #aLen a i c_in = addcarry c_in a.[i] (uint #t 0) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Addition.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | a: Hacl.Spec.Bignum.Definitions.lbignum t aLen -> c_in: Hacl.Spec.Bignum.Base.carry t
-> Hacl.Spec.Bignum.Base.carry t * Hacl.Spec.Bignum.Definitions.lbignum t aLen | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Base.carry",
"Hacl.Spec.Lib.generate_elems",
"Hacl.Spec.Bignum.Definitions.limb",
"Hacl.Spec.Bignum.Addition.bn_add_carry_f",
"FStar.Pervasives.Native.tuple2"
] | [] | false | false | false | false | false | let bn_add_carry #t #aLen a c_in =
| generate_elems aLen aLen (bn_add_carry_f a) c_in | false |
Hacl.Spec.Bignum.Addition.fst | Hacl.Spec.Bignum.Addition.bn_sub_carry_f | val bn_sub_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t | val bn_sub_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t | let bn_sub_carry_f #t #aLen a i c_in = subborrow c_in a.[i] (uint #t 0) | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Addition.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 71,
"end_line": 16,
"start_col": 0,
"start_line": 16
} | module Hacl.Spec.Bignum.Addition
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Addition.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Hacl.Spec.Bignum.Definitions.lbignum t aLen ->
i: Lib.IntTypes.size_nat{i < aLen} ->
c_in: Hacl.Spec.Bignum.Base.carry t
-> Hacl.Spec.Bignum.Base.carry t * Hacl.Spec.Bignum.Definitions.limb t | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.b2t",
"Prims.op_LessThan",
"Hacl.Spec.Bignum.Base.carry",
"Hacl.Spec.Bignum.Base.subborrow",
"Lib.Sequence.op_String_Access",
"Hacl.Spec.Bignum.Definitions.limb",
"Lib.IntTypes.uint",
"Lib.IntTypes.SEC",
"FStar.Pervasives.Native.tuple2"
] | [] | false | false | false | false | false | let bn_sub_carry_f #t #aLen a i c_in =
| subborrow c_in a.[ i ] (uint #t 0) | false |
FStar.Tactics.SMT.fst | FStar.Tactics.SMT.set_rlimit | val set_rlimit (v: int) : Tac unit | val set_rlimit (v: int) : Tac unit | let set_rlimit (v : int) : Tac unit = set_vconfig { get_vconfig () with z3rlimit = v } | {
"file_name": "ulib/FStar.Tactics.SMT.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 93,
"end_line": 21,
"start_col": 0,
"start_line": 21
} | module FStar.Tactics.SMT
open FStar.Tactics.Effect
open FStar.Stubs.Tactics.V2.Builtins
open FStar.VConfig
(* Alias to just use the current vconfig *)
let smt_sync () : Tac unit = t_smt_sync (get_vconfig ())
(* smt_sync': as smt_sync, but using a particular fuel/ifuel *)
let smt_sync' (fuel ifuel : nat) : Tac unit =
let vcfg = get_vconfig () in
let vcfg' = { vcfg with initial_fuel = fuel; max_fuel = fuel
; initial_ifuel = ifuel; max_ifuel = ifuel }
in
t_smt_sync vcfg'
(* Getting/setting solver configuration *) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.VConfig.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Stubs.Tactics.V2.Builtins.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Tactics.SMT.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.VConfig",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Tactics.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | v: Prims.int -> FStar.Tactics.Effect.Tac Prims.unit | FStar.Tactics.Effect.Tac | [] | [] | [
"Prims.int",
"FStar.Stubs.Tactics.V2.Builtins.set_vconfig",
"Prims.unit",
"FStar.VConfig.vconfig",
"FStar.VConfig.Mkvconfig",
"FStar.VConfig.__proj__Mkvconfig__item__initial_fuel",
"FStar.VConfig.__proj__Mkvconfig__item__max_fuel",
"FStar.VConfig.__proj__Mkvconfig__item__initial_ifuel",
"FStar.VConfig.__proj__Mkvconfig__item__max_ifuel",
"FStar.VConfig.__proj__Mkvconfig__item__detail_errors",
"FStar.VConfig.__proj__Mkvconfig__item__detail_hint_replay",
"FStar.VConfig.__proj__Mkvconfig__item__no_smt",
"FStar.VConfig.__proj__Mkvconfig__item__quake_lo",
"FStar.VConfig.__proj__Mkvconfig__item__quake_hi",
"FStar.VConfig.__proj__Mkvconfig__item__quake_keep",
"FStar.VConfig.__proj__Mkvconfig__item__retry",
"FStar.VConfig.__proj__Mkvconfig__item__smtencoding_elim_box",
"FStar.VConfig.__proj__Mkvconfig__item__smtencoding_nl_arith_repr",
"FStar.VConfig.__proj__Mkvconfig__item__smtencoding_l_arith_repr",
"FStar.VConfig.__proj__Mkvconfig__item__smtencoding_valid_intro",
"FStar.VConfig.__proj__Mkvconfig__item__smtencoding_valid_elim",
"FStar.VConfig.__proj__Mkvconfig__item__tcnorm",
"FStar.VConfig.__proj__Mkvconfig__item__no_plugins",
"FStar.VConfig.__proj__Mkvconfig__item__no_tactics",
"FStar.VConfig.__proj__Mkvconfig__item__z3cliopt",
"FStar.VConfig.__proj__Mkvconfig__item__z3smtopt",
"FStar.VConfig.__proj__Mkvconfig__item__z3refresh",
"FStar.VConfig.__proj__Mkvconfig__item__z3rlimit_factor",
"FStar.VConfig.__proj__Mkvconfig__item__z3seed",
"FStar.VConfig.__proj__Mkvconfig__item__z3version",
"FStar.VConfig.__proj__Mkvconfig__item__trivial_pre_for_unannotated_effectful_fns",
"FStar.VConfig.__proj__Mkvconfig__item__reuse_hint_for",
"FStar.Stubs.Tactics.V2.Builtins.get_vconfig"
] | [] | false | true | false | false | false | let set_rlimit (v: int) : Tac unit =
| set_vconfig ({ get_vconfig () with z3rlimit = v }) | false |
FStar.Tactics.SMT.fst | FStar.Tactics.SMT.get_initial_fuel | val get_initial_fuel: Prims.unit -> Tac int | val get_initial_fuel: Prims.unit -> Tac int | let get_initial_fuel () : Tac int = (get_vconfig ()).initial_fuel | {
"file_name": "ulib/FStar.Tactics.SMT.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 74,
"end_line": 23,
"start_col": 0,
"start_line": 23
} | module FStar.Tactics.SMT
open FStar.Tactics.Effect
open FStar.Stubs.Tactics.V2.Builtins
open FStar.VConfig
(* Alias to just use the current vconfig *)
let smt_sync () : Tac unit = t_smt_sync (get_vconfig ())
(* smt_sync': as smt_sync, but using a particular fuel/ifuel *)
let smt_sync' (fuel ifuel : nat) : Tac unit =
let vcfg = get_vconfig () in
let vcfg' = { vcfg with initial_fuel = fuel; max_fuel = fuel
; initial_ifuel = ifuel; max_ifuel = ifuel }
in
t_smt_sync vcfg'
(* Getting/setting solver configuration *)
let get_rlimit () : Tac int = (get_vconfig()).z3rlimit
let set_rlimit (v : int) : Tac unit = set_vconfig { get_vconfig () with z3rlimit = v } | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.VConfig.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Stubs.Tactics.V2.Builtins.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Tactics.SMT.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.VConfig",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Tactics.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: Prims.unit -> FStar.Tactics.Effect.Tac Prims.int | FStar.Tactics.Effect.Tac | [] | [] | [
"Prims.unit",
"FStar.VConfig.__proj__Mkvconfig__item__initial_fuel",
"Prims.int",
"FStar.VConfig.vconfig",
"FStar.Stubs.Tactics.V2.Builtins.get_vconfig"
] | [] | false | true | false | false | false | let get_initial_fuel () : Tac int =
| (get_vconfig ()).initial_fuel | false |
FStar.Tactics.SMT.fst | FStar.Tactics.SMT.get_initial_ifuel | val get_initial_ifuel: Prims.unit -> Tac int | val get_initial_ifuel: Prims.unit -> Tac int | let get_initial_ifuel () : Tac int = (get_vconfig ()).initial_ifuel | {
"file_name": "ulib/FStar.Tactics.SMT.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 75,
"end_line": 24,
"start_col": 0,
"start_line": 24
} | module FStar.Tactics.SMT
open FStar.Tactics.Effect
open FStar.Stubs.Tactics.V2.Builtins
open FStar.VConfig
(* Alias to just use the current vconfig *)
let smt_sync () : Tac unit = t_smt_sync (get_vconfig ())
(* smt_sync': as smt_sync, but using a particular fuel/ifuel *)
let smt_sync' (fuel ifuel : nat) : Tac unit =
let vcfg = get_vconfig () in
let vcfg' = { vcfg with initial_fuel = fuel; max_fuel = fuel
; initial_ifuel = ifuel; max_ifuel = ifuel }
in
t_smt_sync vcfg'
(* Getting/setting solver configuration *)
let get_rlimit () : Tac int = (get_vconfig()).z3rlimit
let set_rlimit (v : int) : Tac unit = set_vconfig { get_vconfig () with z3rlimit = v } | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.VConfig.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Stubs.Tactics.V2.Builtins.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Tactics.SMT.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.VConfig",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Tactics.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: Prims.unit -> FStar.Tactics.Effect.Tac Prims.int | FStar.Tactics.Effect.Tac | [] | [] | [
"Prims.unit",
"FStar.VConfig.__proj__Mkvconfig__item__initial_ifuel",
"Prims.int",
"FStar.VConfig.vconfig",
"FStar.Stubs.Tactics.V2.Builtins.get_vconfig"
] | [] | false | true | false | false | false | let get_initial_ifuel () : Tac int =
| (get_vconfig ()).initial_ifuel | false |
Hacl.Spec.Bignum.Addition.fst | Hacl.Spec.Bignum.Addition.bn_sub1 | val bn_sub1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen) | val bn_sub1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen) | let bn_sub1 #t #aLen a b1 =
let c0, r0 = subborrow (uint #t 0) a.[0] b1 in
let res0 = create 1 r0 in
if 1 < aLen then
let c1, res1 = bn_sub_carry (sub a 1 (aLen - 1)) c0 in
c1, concat res0 res1
else c0, res0 | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Addition.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 41,
"start_col": 0,
"start_line": 34
} | module Hacl.Spec.Bignum.Addition
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_sub_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t
let bn_sub_carry_f #t #aLen a i c_in = subborrow c_in a.[i] (uint #t 0)
val bn_sub_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen)
let bn_sub_carry #t #aLen a c_in = generate_elems aLen aLen (bn_sub_carry_f a) c_in
val bn_sub_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t
let bn_sub_f #t #aLen a b i c = subborrow c a.[i] b.[i]
val bn_sub: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> tuple2 (carry t) (lbignum t aLen)
let bn_sub #t #aLen #bLen a b =
let c0, res0 = generate_elems bLen bLen (bn_sub_f (sub a 0 bLen) b) (uint #t 0) in
if bLen < aLen then
let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in
c1, concat #_ #bLen res0 res1
else c0, res0 | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Addition.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | a: Hacl.Spec.Bignum.Definitions.lbignum t aLen -> b1: Hacl.Spec.Bignum.Definitions.limb t
-> Hacl.Spec.Bignum.Base.carry t * Hacl.Spec.Bignum.Definitions.lbignum t aLen | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_pos",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Definitions.limb",
"Hacl.Spec.Bignum.Base.carry",
"Prims.op_LessThan",
"Prims.op_Subtraction",
"FStar.Pervasives.Native.Mktuple2",
"Lib.Sequence.concat",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.Bignum.Addition.bn_sub_carry",
"Lib.Sequence.sub",
"Prims.bool",
"Lib.Sequence.lseq",
"Prims.l_and",
"Prims.eq2",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.create",
"Prims.l_Forall",
"Prims.nat",
"Prims.l_imp",
"Prims.b2t",
"Lib.Sequence.index",
"Lib.Sequence.create",
"Hacl.Spec.Bignum.Base.subborrow",
"Lib.IntTypes.uint",
"Lib.IntTypes.SEC",
"Lib.Sequence.op_String_Access"
] | [] | false | false | false | false | false | let bn_sub1 #t #aLen a b1 =
| let c0, r0 = subborrow (uint #t 0) a.[ 0 ] b1 in
let res0 = create 1 r0 in
if 1 < aLen
then
let c1, res1 = bn_sub_carry (sub a 1 (aLen - 1)) c0 in
c1, concat res0 res1
else c0, res0 | false |
FStar.Tactics.SMT.fst | FStar.Tactics.SMT.get_max_fuel | val get_max_fuel: Prims.unit -> Tac int | val get_max_fuel: Prims.unit -> Tac int | let get_max_fuel () : Tac int = (get_vconfig ()).max_fuel | {
"file_name": "ulib/FStar.Tactics.SMT.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 70,
"end_line": 25,
"start_col": 0,
"start_line": 25
} | module FStar.Tactics.SMT
open FStar.Tactics.Effect
open FStar.Stubs.Tactics.V2.Builtins
open FStar.VConfig
(* Alias to just use the current vconfig *)
let smt_sync () : Tac unit = t_smt_sync (get_vconfig ())
(* smt_sync': as smt_sync, but using a particular fuel/ifuel *)
let smt_sync' (fuel ifuel : nat) : Tac unit =
let vcfg = get_vconfig () in
let vcfg' = { vcfg with initial_fuel = fuel; max_fuel = fuel
; initial_ifuel = ifuel; max_ifuel = ifuel }
in
t_smt_sync vcfg'
(* Getting/setting solver configuration *)
let get_rlimit () : Tac int = (get_vconfig()).z3rlimit
let set_rlimit (v : int) : Tac unit = set_vconfig { get_vconfig () with z3rlimit = v }
let get_initial_fuel () : Tac int = (get_vconfig ()).initial_fuel | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.VConfig.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Stubs.Tactics.V2.Builtins.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Tactics.SMT.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.VConfig",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Tactics.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: Prims.unit -> FStar.Tactics.Effect.Tac Prims.int | FStar.Tactics.Effect.Tac | [] | [] | [
"Prims.unit",
"FStar.VConfig.__proj__Mkvconfig__item__max_fuel",
"Prims.int",
"FStar.VConfig.vconfig",
"FStar.Stubs.Tactics.V2.Builtins.get_vconfig"
] | [] | false | true | false | false | false | let get_max_fuel () : Tac int =
| (get_vconfig ()).max_fuel | false |
FStar.Tactics.SMT.fst | FStar.Tactics.SMT.get_max_ifuel | val get_max_ifuel: Prims.unit -> Tac int | val get_max_ifuel: Prims.unit -> Tac int | let get_max_ifuel () : Tac int = (get_vconfig ()).max_ifuel | {
"file_name": "ulib/FStar.Tactics.SMT.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 71,
"end_line": 26,
"start_col": 0,
"start_line": 26
} | module FStar.Tactics.SMT
open FStar.Tactics.Effect
open FStar.Stubs.Tactics.V2.Builtins
open FStar.VConfig
(* Alias to just use the current vconfig *)
let smt_sync () : Tac unit = t_smt_sync (get_vconfig ())
(* smt_sync': as smt_sync, but using a particular fuel/ifuel *)
let smt_sync' (fuel ifuel : nat) : Tac unit =
let vcfg = get_vconfig () in
let vcfg' = { vcfg with initial_fuel = fuel; max_fuel = fuel
; initial_ifuel = ifuel; max_ifuel = ifuel }
in
t_smt_sync vcfg'
(* Getting/setting solver configuration *)
let get_rlimit () : Tac int = (get_vconfig()).z3rlimit
let set_rlimit (v : int) : Tac unit = set_vconfig { get_vconfig () with z3rlimit = v }
let get_initial_fuel () : Tac int = (get_vconfig ()).initial_fuel
let get_initial_ifuel () : Tac int = (get_vconfig ()).initial_ifuel | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.VConfig.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Stubs.Tactics.V2.Builtins.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Tactics.SMT.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.VConfig",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Tactics.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: Prims.unit -> FStar.Tactics.Effect.Tac Prims.int | FStar.Tactics.Effect.Tac | [] | [] | [
"Prims.unit",
"FStar.VConfig.__proj__Mkvconfig__item__max_ifuel",
"Prims.int",
"FStar.VConfig.vconfig",
"FStar.Stubs.Tactics.V2.Builtins.get_vconfig"
] | [] | false | true | false | false | false | let get_max_ifuel () : Tac int =
| (get_vconfig ()).max_ifuel | false |
FStar.Tactics.SMT.fst | FStar.Tactics.SMT.set_initial_ifuel | val set_initial_ifuel (v: int) : Tac unit | val set_initial_ifuel (v: int) : Tac unit | let set_initial_ifuel (v : int) : Tac unit = set_vconfig { get_vconfig () with initial_ifuel = v } | {
"file_name": "ulib/FStar.Tactics.SMT.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 98,
"end_line": 29,
"start_col": 0,
"start_line": 29
} | module FStar.Tactics.SMT
open FStar.Tactics.Effect
open FStar.Stubs.Tactics.V2.Builtins
open FStar.VConfig
(* Alias to just use the current vconfig *)
let smt_sync () : Tac unit = t_smt_sync (get_vconfig ())
(* smt_sync': as smt_sync, but using a particular fuel/ifuel *)
let smt_sync' (fuel ifuel : nat) : Tac unit =
let vcfg = get_vconfig () in
let vcfg' = { vcfg with initial_fuel = fuel; max_fuel = fuel
; initial_ifuel = ifuel; max_ifuel = ifuel }
in
t_smt_sync vcfg'
(* Getting/setting solver configuration *)
let get_rlimit () : Tac int = (get_vconfig()).z3rlimit
let set_rlimit (v : int) : Tac unit = set_vconfig { get_vconfig () with z3rlimit = v }
let get_initial_fuel () : Tac int = (get_vconfig ()).initial_fuel
let get_initial_ifuel () : Tac int = (get_vconfig ()).initial_ifuel
let get_max_fuel () : Tac int = (get_vconfig ()).max_fuel
let get_max_ifuel () : Tac int = (get_vconfig ()).max_ifuel | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.VConfig.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Stubs.Tactics.V2.Builtins.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Tactics.SMT.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.VConfig",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Tactics.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | v: Prims.int -> FStar.Tactics.Effect.Tac Prims.unit | FStar.Tactics.Effect.Tac | [] | [] | [
"Prims.int",
"FStar.Stubs.Tactics.V2.Builtins.set_vconfig",
"Prims.unit",
"FStar.VConfig.vconfig",
"FStar.VConfig.Mkvconfig",
"FStar.VConfig.__proj__Mkvconfig__item__initial_fuel",
"FStar.VConfig.__proj__Mkvconfig__item__max_fuel",
"FStar.VConfig.__proj__Mkvconfig__item__max_ifuel",
"FStar.VConfig.__proj__Mkvconfig__item__detail_errors",
"FStar.VConfig.__proj__Mkvconfig__item__detail_hint_replay",
"FStar.VConfig.__proj__Mkvconfig__item__no_smt",
"FStar.VConfig.__proj__Mkvconfig__item__quake_lo",
"FStar.VConfig.__proj__Mkvconfig__item__quake_hi",
"FStar.VConfig.__proj__Mkvconfig__item__quake_keep",
"FStar.VConfig.__proj__Mkvconfig__item__retry",
"FStar.VConfig.__proj__Mkvconfig__item__smtencoding_elim_box",
"FStar.VConfig.__proj__Mkvconfig__item__smtencoding_nl_arith_repr",
"FStar.VConfig.__proj__Mkvconfig__item__smtencoding_l_arith_repr",
"FStar.VConfig.__proj__Mkvconfig__item__smtencoding_valid_intro",
"FStar.VConfig.__proj__Mkvconfig__item__smtencoding_valid_elim",
"FStar.VConfig.__proj__Mkvconfig__item__tcnorm",
"FStar.VConfig.__proj__Mkvconfig__item__no_plugins",
"FStar.VConfig.__proj__Mkvconfig__item__no_tactics",
"FStar.VConfig.__proj__Mkvconfig__item__z3cliopt",
"FStar.VConfig.__proj__Mkvconfig__item__z3smtopt",
"FStar.VConfig.__proj__Mkvconfig__item__z3refresh",
"FStar.VConfig.__proj__Mkvconfig__item__z3rlimit",
"FStar.VConfig.__proj__Mkvconfig__item__z3rlimit_factor",
"FStar.VConfig.__proj__Mkvconfig__item__z3seed",
"FStar.VConfig.__proj__Mkvconfig__item__z3version",
"FStar.VConfig.__proj__Mkvconfig__item__trivial_pre_for_unannotated_effectful_fns",
"FStar.VConfig.__proj__Mkvconfig__item__reuse_hint_for",
"FStar.Stubs.Tactics.V2.Builtins.get_vconfig"
] | [] | false | true | false | false | false | let set_initial_ifuel (v: int) : Tac unit =
| set_vconfig ({ get_vconfig () with initial_ifuel = v }) | false |
Hacl.Spec.Bignum.Addition.fst | Hacl.Spec.Bignum.Addition.bn_add_carry_f | val bn_add_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t | val bn_add_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t | let bn_add_carry_f #t #aLen a i c_in = addcarry c_in a.[i] (uint #t 0) | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Addition.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 70,
"end_line": 45,
"start_col": 0,
"start_line": 45
} | module Hacl.Spec.Bignum.Addition
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_sub_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t
let bn_sub_carry_f #t #aLen a i c_in = subborrow c_in a.[i] (uint #t 0)
val bn_sub_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen)
let bn_sub_carry #t #aLen a c_in = generate_elems aLen aLen (bn_sub_carry_f a) c_in
val bn_sub_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t
let bn_sub_f #t #aLen a b i c = subborrow c a.[i] b.[i]
val bn_sub: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> tuple2 (carry t) (lbignum t aLen)
let bn_sub #t #aLen #bLen a b =
let c0, res0 = generate_elems bLen bLen (bn_sub_f (sub a 0 bLen) b) (uint #t 0) in
if bLen < aLen then
let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in
c1, concat #_ #bLen res0 res1
else c0, res0
val bn_sub1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen)
let bn_sub1 #t #aLen a b1 =
let c0, r0 = subborrow (uint #t 0) a.[0] b1 in
let res0 = create 1 r0 in
if 1 < aLen then
let c1, res1 = bn_sub_carry (sub a 1 (aLen - 1)) c0 in
c1, concat res0 res1
else c0, res0 | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Addition.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Hacl.Spec.Bignum.Definitions.lbignum t aLen ->
i: Lib.IntTypes.size_nat{i < aLen} ->
c_in: Hacl.Spec.Bignum.Base.carry t
-> Hacl.Spec.Bignum.Base.carry t * Hacl.Spec.Bignum.Definitions.limb t | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.b2t",
"Prims.op_LessThan",
"Hacl.Spec.Bignum.Base.carry",
"Hacl.Spec.Bignum.Base.addcarry",
"Lib.Sequence.op_String_Access",
"Hacl.Spec.Bignum.Definitions.limb",
"Lib.IntTypes.uint",
"Lib.IntTypes.SEC",
"FStar.Pervasives.Native.tuple2"
] | [] | false | false | false | false | false | let bn_add_carry_f #t #aLen a i c_in =
| addcarry c_in a.[ i ] (uint #t 0) | false |
FStar.Tactics.SMT.fst | FStar.Tactics.SMT.set_initial_fuel | val set_initial_fuel (v: int) : Tac unit | val set_initial_fuel (v: int) : Tac unit | let set_initial_fuel (v : int) : Tac unit = set_vconfig { get_vconfig () with initial_fuel = v } | {
"file_name": "ulib/FStar.Tactics.SMT.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 98,
"end_line": 28,
"start_col": 0,
"start_line": 28
} | module FStar.Tactics.SMT
open FStar.Tactics.Effect
open FStar.Stubs.Tactics.V2.Builtins
open FStar.VConfig
(* Alias to just use the current vconfig *)
let smt_sync () : Tac unit = t_smt_sync (get_vconfig ())
(* smt_sync': as smt_sync, but using a particular fuel/ifuel *)
let smt_sync' (fuel ifuel : nat) : Tac unit =
let vcfg = get_vconfig () in
let vcfg' = { vcfg with initial_fuel = fuel; max_fuel = fuel
; initial_ifuel = ifuel; max_ifuel = ifuel }
in
t_smt_sync vcfg'
(* Getting/setting solver configuration *)
let get_rlimit () : Tac int = (get_vconfig()).z3rlimit
let set_rlimit (v : int) : Tac unit = set_vconfig { get_vconfig () with z3rlimit = v }
let get_initial_fuel () : Tac int = (get_vconfig ()).initial_fuel
let get_initial_ifuel () : Tac int = (get_vconfig ()).initial_ifuel
let get_max_fuel () : Tac int = (get_vconfig ()).max_fuel
let get_max_ifuel () : Tac int = (get_vconfig ()).max_ifuel | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.VConfig.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Stubs.Tactics.V2.Builtins.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Tactics.SMT.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.VConfig",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Tactics.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | v: Prims.int -> FStar.Tactics.Effect.Tac Prims.unit | FStar.Tactics.Effect.Tac | [] | [] | [
"Prims.int",
"FStar.Stubs.Tactics.V2.Builtins.set_vconfig",
"Prims.unit",
"FStar.VConfig.vconfig",
"FStar.VConfig.Mkvconfig",
"FStar.VConfig.__proj__Mkvconfig__item__max_fuel",
"FStar.VConfig.__proj__Mkvconfig__item__initial_ifuel",
"FStar.VConfig.__proj__Mkvconfig__item__max_ifuel",
"FStar.VConfig.__proj__Mkvconfig__item__detail_errors",
"FStar.VConfig.__proj__Mkvconfig__item__detail_hint_replay",
"FStar.VConfig.__proj__Mkvconfig__item__no_smt",
"FStar.VConfig.__proj__Mkvconfig__item__quake_lo",
"FStar.VConfig.__proj__Mkvconfig__item__quake_hi",
"FStar.VConfig.__proj__Mkvconfig__item__quake_keep",
"FStar.VConfig.__proj__Mkvconfig__item__retry",
"FStar.VConfig.__proj__Mkvconfig__item__smtencoding_elim_box",
"FStar.VConfig.__proj__Mkvconfig__item__smtencoding_nl_arith_repr",
"FStar.VConfig.__proj__Mkvconfig__item__smtencoding_l_arith_repr",
"FStar.VConfig.__proj__Mkvconfig__item__smtencoding_valid_intro",
"FStar.VConfig.__proj__Mkvconfig__item__smtencoding_valid_elim",
"FStar.VConfig.__proj__Mkvconfig__item__tcnorm",
"FStar.VConfig.__proj__Mkvconfig__item__no_plugins",
"FStar.VConfig.__proj__Mkvconfig__item__no_tactics",
"FStar.VConfig.__proj__Mkvconfig__item__z3cliopt",
"FStar.VConfig.__proj__Mkvconfig__item__z3smtopt",
"FStar.VConfig.__proj__Mkvconfig__item__z3refresh",
"FStar.VConfig.__proj__Mkvconfig__item__z3rlimit",
"FStar.VConfig.__proj__Mkvconfig__item__z3rlimit_factor",
"FStar.VConfig.__proj__Mkvconfig__item__z3seed",
"FStar.VConfig.__proj__Mkvconfig__item__z3version",
"FStar.VConfig.__proj__Mkvconfig__item__trivial_pre_for_unannotated_effectful_fns",
"FStar.VConfig.__proj__Mkvconfig__item__reuse_hint_for",
"FStar.Stubs.Tactics.V2.Builtins.get_vconfig"
] | [] | false | true | false | false | false | let set_initial_fuel (v: int) : Tac unit =
| set_vconfig ({ get_vconfig () with initial_fuel = v }) | false |
Hacl.Spec.Bignum.Addition.fst | Hacl.Spec.Bignum.Addition.bn_sub | val bn_sub: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> tuple2 (carry t) (lbignum t aLen) | val bn_sub: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> tuple2 (carry t) (lbignum t aLen) | let bn_sub #t #aLen #bLen a b =
let c0, res0 = generate_elems bLen bLen (bn_sub_f (sub a 0 bLen) b) (uint #t 0) in
if bLen < aLen then
let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in
c1, concat #_ #bLen res0 res1
else c0, res0 | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Addition.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 31,
"start_col": 0,
"start_line": 25
} | module Hacl.Spec.Bignum.Addition
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_sub_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t
let bn_sub_carry_f #t #aLen a i c_in = subborrow c_in a.[i] (uint #t 0)
val bn_sub_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen)
let bn_sub_carry #t #aLen a c_in = generate_elems aLen aLen (bn_sub_carry_f a) c_in
val bn_sub_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t
let bn_sub_f #t #aLen a b i c = subborrow c a.[i] b.[i] | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Addition.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | a: Hacl.Spec.Bignum.Definitions.lbignum t aLen -> b: Hacl.Spec.Bignum.Definitions.lbignum t bLen
-> Hacl.Spec.Bignum.Base.carry t * Hacl.Spec.Bignum.Definitions.lbignum t aLen | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Base.carry",
"Lib.Sequence.seq",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.eq2",
"Prims.nat",
"Lib.Sequence.length",
"Prims.op_LessThan",
"Prims.op_Subtraction",
"FStar.Pervasives.Native.Mktuple2",
"Lib.Sequence.concat",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.Bignum.Addition.bn_sub_carry",
"Lib.Sequence.sub",
"Prims.bool",
"Hacl.Spec.Lib.generate_elems",
"Hacl.Spec.Bignum.Addition.bn_sub_f",
"Lib.IntTypes.uint",
"Lib.IntTypes.SEC"
] | [] | false | false | false | false | false | let bn_sub #t #aLen #bLen a b =
| let c0, res0 = generate_elems bLen bLen (bn_sub_f (sub a 0 bLen) b) (uint #t 0) in
if bLen < aLen
then
let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in
c1, concat #_ #bLen res0 res1
else c0, res0 | false |
FStar.Tactics.SMT.fst | FStar.Tactics.SMT.set_max_fuel | val set_max_fuel (v: int) : Tac unit | val set_max_fuel (v: int) : Tac unit | let set_max_fuel (v : int) : Tac unit = set_vconfig { get_vconfig () with max_fuel = v } | {
"file_name": "ulib/FStar.Tactics.SMT.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 98,
"end_line": 30,
"start_col": 0,
"start_line": 30
} | module FStar.Tactics.SMT
open FStar.Tactics.Effect
open FStar.Stubs.Tactics.V2.Builtins
open FStar.VConfig
(* Alias to just use the current vconfig *)
let smt_sync () : Tac unit = t_smt_sync (get_vconfig ())
(* smt_sync': as smt_sync, but using a particular fuel/ifuel *)
let smt_sync' (fuel ifuel : nat) : Tac unit =
let vcfg = get_vconfig () in
let vcfg' = { vcfg with initial_fuel = fuel; max_fuel = fuel
; initial_ifuel = ifuel; max_ifuel = ifuel }
in
t_smt_sync vcfg'
(* Getting/setting solver configuration *)
let get_rlimit () : Tac int = (get_vconfig()).z3rlimit
let set_rlimit (v : int) : Tac unit = set_vconfig { get_vconfig () with z3rlimit = v }
let get_initial_fuel () : Tac int = (get_vconfig ()).initial_fuel
let get_initial_ifuel () : Tac int = (get_vconfig ()).initial_ifuel
let get_max_fuel () : Tac int = (get_vconfig ()).max_fuel
let get_max_ifuel () : Tac int = (get_vconfig ()).max_ifuel
let set_initial_fuel (v : int) : Tac unit = set_vconfig { get_vconfig () with initial_fuel = v } | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.VConfig.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Stubs.Tactics.V2.Builtins.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Tactics.SMT.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.VConfig",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Tactics.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | v: Prims.int -> FStar.Tactics.Effect.Tac Prims.unit | FStar.Tactics.Effect.Tac | [] | [] | [
"Prims.int",
"FStar.Stubs.Tactics.V2.Builtins.set_vconfig",
"Prims.unit",
"FStar.VConfig.vconfig",
"FStar.VConfig.Mkvconfig",
"FStar.VConfig.__proj__Mkvconfig__item__initial_fuel",
"FStar.VConfig.__proj__Mkvconfig__item__initial_ifuel",
"FStar.VConfig.__proj__Mkvconfig__item__max_ifuel",
"FStar.VConfig.__proj__Mkvconfig__item__detail_errors",
"FStar.VConfig.__proj__Mkvconfig__item__detail_hint_replay",
"FStar.VConfig.__proj__Mkvconfig__item__no_smt",
"FStar.VConfig.__proj__Mkvconfig__item__quake_lo",
"FStar.VConfig.__proj__Mkvconfig__item__quake_hi",
"FStar.VConfig.__proj__Mkvconfig__item__quake_keep",
"FStar.VConfig.__proj__Mkvconfig__item__retry",
"FStar.VConfig.__proj__Mkvconfig__item__smtencoding_elim_box",
"FStar.VConfig.__proj__Mkvconfig__item__smtencoding_nl_arith_repr",
"FStar.VConfig.__proj__Mkvconfig__item__smtencoding_l_arith_repr",
"FStar.VConfig.__proj__Mkvconfig__item__smtencoding_valid_intro",
"FStar.VConfig.__proj__Mkvconfig__item__smtencoding_valid_elim",
"FStar.VConfig.__proj__Mkvconfig__item__tcnorm",
"FStar.VConfig.__proj__Mkvconfig__item__no_plugins",
"FStar.VConfig.__proj__Mkvconfig__item__no_tactics",
"FStar.VConfig.__proj__Mkvconfig__item__z3cliopt",
"FStar.VConfig.__proj__Mkvconfig__item__z3smtopt",
"FStar.VConfig.__proj__Mkvconfig__item__z3refresh",
"FStar.VConfig.__proj__Mkvconfig__item__z3rlimit",
"FStar.VConfig.__proj__Mkvconfig__item__z3rlimit_factor",
"FStar.VConfig.__proj__Mkvconfig__item__z3seed",
"FStar.VConfig.__proj__Mkvconfig__item__z3version",
"FStar.VConfig.__proj__Mkvconfig__item__trivial_pre_for_unannotated_effectful_fns",
"FStar.VConfig.__proj__Mkvconfig__item__reuse_hint_for",
"FStar.Stubs.Tactics.V2.Builtins.get_vconfig"
] | [] | false | true | false | false | false | let set_max_fuel (v: int) : Tac unit =
| set_vconfig ({ get_vconfig () with max_fuel = v }) | false |
FStar.Tactics.SMT.fst | FStar.Tactics.SMT.set_fuel | val set_fuel (v: int) : Tac unit | val set_fuel (v: int) : Tac unit | let set_fuel (v : int) : Tac unit = set_vconfig { get_vconfig () with initial_fuel = v; max_fuel = v } | {
"file_name": "ulib/FStar.Tactics.SMT.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 113,
"end_line": 34,
"start_col": 0,
"start_line": 34
} | module FStar.Tactics.SMT
open FStar.Tactics.Effect
open FStar.Stubs.Tactics.V2.Builtins
open FStar.VConfig
(* Alias to just use the current vconfig *)
let smt_sync () : Tac unit = t_smt_sync (get_vconfig ())
(* smt_sync': as smt_sync, but using a particular fuel/ifuel *)
let smt_sync' (fuel ifuel : nat) : Tac unit =
let vcfg = get_vconfig () in
let vcfg' = { vcfg with initial_fuel = fuel; max_fuel = fuel
; initial_ifuel = ifuel; max_ifuel = ifuel }
in
t_smt_sync vcfg'
(* Getting/setting solver configuration *)
let get_rlimit () : Tac int = (get_vconfig()).z3rlimit
let set_rlimit (v : int) : Tac unit = set_vconfig { get_vconfig () with z3rlimit = v }
let get_initial_fuel () : Tac int = (get_vconfig ()).initial_fuel
let get_initial_ifuel () : Tac int = (get_vconfig ()).initial_ifuel
let get_max_fuel () : Tac int = (get_vconfig ()).max_fuel
let get_max_ifuel () : Tac int = (get_vconfig ()).max_ifuel
let set_initial_fuel (v : int) : Tac unit = set_vconfig { get_vconfig () with initial_fuel = v }
let set_initial_ifuel (v : int) : Tac unit = set_vconfig { get_vconfig () with initial_ifuel = v }
let set_max_fuel (v : int) : Tac unit = set_vconfig { get_vconfig () with max_fuel = v }
let set_max_ifuel (v : int) : Tac unit = set_vconfig { get_vconfig () with max_ifuel = v } | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.VConfig.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Stubs.Tactics.V2.Builtins.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Tactics.SMT.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.VConfig",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Tactics.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | v: Prims.int -> FStar.Tactics.Effect.Tac Prims.unit | FStar.Tactics.Effect.Tac | [] | [] | [
"Prims.int",
"FStar.Stubs.Tactics.V2.Builtins.set_vconfig",
"Prims.unit",
"FStar.VConfig.vconfig",
"FStar.VConfig.Mkvconfig",
"FStar.VConfig.__proj__Mkvconfig__item__initial_ifuel",
"FStar.VConfig.__proj__Mkvconfig__item__max_ifuel",
"FStar.VConfig.__proj__Mkvconfig__item__detail_errors",
"FStar.VConfig.__proj__Mkvconfig__item__detail_hint_replay",
"FStar.VConfig.__proj__Mkvconfig__item__no_smt",
"FStar.VConfig.__proj__Mkvconfig__item__quake_lo",
"FStar.VConfig.__proj__Mkvconfig__item__quake_hi",
"FStar.VConfig.__proj__Mkvconfig__item__quake_keep",
"FStar.VConfig.__proj__Mkvconfig__item__retry",
"FStar.VConfig.__proj__Mkvconfig__item__smtencoding_elim_box",
"FStar.VConfig.__proj__Mkvconfig__item__smtencoding_nl_arith_repr",
"FStar.VConfig.__proj__Mkvconfig__item__smtencoding_l_arith_repr",
"FStar.VConfig.__proj__Mkvconfig__item__smtencoding_valid_intro",
"FStar.VConfig.__proj__Mkvconfig__item__smtencoding_valid_elim",
"FStar.VConfig.__proj__Mkvconfig__item__tcnorm",
"FStar.VConfig.__proj__Mkvconfig__item__no_plugins",
"FStar.VConfig.__proj__Mkvconfig__item__no_tactics",
"FStar.VConfig.__proj__Mkvconfig__item__z3cliopt",
"FStar.VConfig.__proj__Mkvconfig__item__z3smtopt",
"FStar.VConfig.__proj__Mkvconfig__item__z3refresh",
"FStar.VConfig.__proj__Mkvconfig__item__z3rlimit",
"FStar.VConfig.__proj__Mkvconfig__item__z3rlimit_factor",
"FStar.VConfig.__proj__Mkvconfig__item__z3seed",
"FStar.VConfig.__proj__Mkvconfig__item__z3version",
"FStar.VConfig.__proj__Mkvconfig__item__trivial_pre_for_unannotated_effectful_fns",
"FStar.VConfig.__proj__Mkvconfig__item__reuse_hint_for",
"FStar.Stubs.Tactics.V2.Builtins.get_vconfig"
] | [] | false | true | false | false | false | let set_fuel (v: int) : Tac unit =
| set_vconfig ({ get_vconfig () with initial_fuel = v; max_fuel = v }) | false |
Hacl.Spec.Bignum.Addition.fst | Hacl.Spec.Bignum.Addition.bn_add_carry_lemma | val bn_add_carry_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t ->
Lemma (let (c_out, res) = bn_add_carry a c_in in
v c_out * pow2 (bits t * aLen) + bn_v res == bn_v a + v c_in) | val bn_add_carry_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t ->
Lemma (let (c_out, res) = bn_add_carry a c_in in
v c_out * pow2 (bits t * aLen) + bn_v res == bn_v a + v c_in) | let bn_add_carry_lemma #t #aLen a c_in =
let (c_out, res) = bn_add_carry a c_in in
bn_add_carry_lemma_loop a c_in aLen | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Addition.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 37,
"end_line": 149,
"start_col": 0,
"start_line": 147
} | module Hacl.Spec.Bignum.Addition
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_sub_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t
let bn_sub_carry_f #t #aLen a i c_in = subborrow c_in a.[i] (uint #t 0)
val bn_sub_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen)
let bn_sub_carry #t #aLen a c_in = generate_elems aLen aLen (bn_sub_carry_f a) c_in
val bn_sub_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t
let bn_sub_f #t #aLen a b i c = subborrow c a.[i] b.[i]
val bn_sub: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> tuple2 (carry t) (lbignum t aLen)
let bn_sub #t #aLen #bLen a b =
let c0, res0 = generate_elems bLen bLen (bn_sub_f (sub a 0 bLen) b) (uint #t 0) in
if bLen < aLen then
let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in
c1, concat #_ #bLen res0 res1
else c0, res0
val bn_sub1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen)
let bn_sub1 #t #aLen a b1 =
let c0, r0 = subborrow (uint #t 0) a.[0] b1 in
let res0 = create 1 r0 in
if 1 < aLen then
let c1, res1 = bn_sub_carry (sub a 1 (aLen - 1)) c0 in
c1, concat res0 res1
else c0, res0
val bn_add_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t
let bn_add_carry_f #t #aLen a i c_in = addcarry c_in a.[i] (uint #t 0)
val bn_add_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen)
let bn_add_carry #t #aLen a c_in = generate_elems aLen aLen (bn_add_carry_f a) c_in
val bn_add_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t
let bn_add_f #t #aLen a b i c = addcarry c a.[i] b.[i]
val bn_add: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> carry t & lbignum t aLen
let bn_add #t #aLen #bLen a b =
let c0, res0 = generate_elems bLen bLen (bn_add_f (sub a 0 bLen) b) (uint #t 0) in
if bLen < aLen then
let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in
c1, concat #_ #bLen res0 res1
else c0, res0
val bn_add1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen)
let bn_add1 #t #aLen a b1 =
let c0, r0 = addcarry (uint #t 0) a.[0] b1 in
let res0 = create 1 r0 in
if 1 < aLen then
let c1, res1 = bn_add_carry (sub a 1 (aLen - 1)) c0 in
c1, concat res0 res1
else c0, res0
val bn_add_carry_lemma_loop_step:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> c_in:carry t
-> i:pos{i <= aLen}
-> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma
(requires
(let (c1, res1) = c1_res1 in
v c1 * pow2 (bits t * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + v c_in))
(ensures
(let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) c1_res1 in
v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in))
let bn_add_carry_lemma_loop_step #t #aLen a c_in i (c1, res1) =
let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1) in
let c, e = bn_add_carry_f a (i - 1) c1 in
assert (v e + v c * pow2 (bits t) == v a.[i - 1] + v c1);
let pbits = bits t in
calc (==) {
v c * pow2 (pbits * i) + bn_v #t #i res;
(==) { bn_eval_snoc #t #(i - 1) res1 e }
v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1));
(==) { }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in - (v e + v c * pow2 pbits - v a.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1]) (pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + (v e - v e - v c * pow2 pbits + v a.[i - 1]) * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1));
(==) { bn_eval_unfold_i #t #aLen a i }
eval_ aLen a i + v c_in;
};
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in)
val bn_add_carry_lemma_loop:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> c_in:carry t
-> i:nat{i <= aLen} ->
Lemma (let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in
v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in)
let rec bn_add_carry_lemma_loop #t #aLen a c_in i =
let pbits = bits t in
let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in
if i = 0 then begin
eq_generate_elems0 aLen i (bn_add_carry_f a) c_in;
assert (c_out == c_in /\ res == Seq.empty);
bn_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
() end
else begin
let (c1, res1) : generate_elem_a (limb t) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_add_carry_f a) c_in in
generate_elems_unfold aLen i (bn_add_carry_f a) c_in (i - 1);
assert (generate_elems aLen i (bn_add_carry_f a) c_in ==
generate_elem_f aLen (bn_add_carry_f a) (i - 1) (generate_elems aLen (i - 1) (bn_add_carry_f a) c_in));
assert ((c_out, res) == generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1));
bn_add_carry_lemma_loop a c_in (i - 1);
assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + v c_in);
bn_add_carry_lemma_loop_step a c_in i (c1, res1);
assert (v c_out * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in);
() end
val bn_add_carry_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t ->
Lemma (let (c_out, res) = bn_add_carry a c_in in
v c_out * pow2 (bits t * aLen) + bn_v res == bn_v a + v c_in) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Addition.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | a: Hacl.Spec.Bignum.Definitions.lbignum t aLen -> c_in: Hacl.Spec.Bignum.Base.carry t
-> FStar.Pervasives.Lemma
(ensures
(let _ = Hacl.Spec.Bignum.Addition.bn_add_carry a c_in in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ c_out res = _ in
Lib.IntTypes.v c_out * Prims.pow2 (Lib.IntTypes.bits t * aLen) +
Hacl.Spec.Bignum.Definitions.bn_v res ==
Hacl.Spec.Bignum.Definitions.bn_v a + Lib.IntTypes.v c_in)
<:
Type0)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Base.carry",
"Hacl.Spec.Bignum.Addition.bn_add_carry_lemma_loop",
"Prims.unit",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.Bignum.Addition.bn_add_carry"
] | [] | false | false | true | false | false | let bn_add_carry_lemma #t #aLen a c_in =
| let c_out, res = bn_add_carry a c_in in
bn_add_carry_lemma_loop a c_in aLen | false |
FStar.Tactics.SMT.fst | FStar.Tactics.SMT.set_max_ifuel | val set_max_ifuel (v: int) : Tac unit | val set_max_ifuel (v: int) : Tac unit | let set_max_ifuel (v : int) : Tac unit = set_vconfig { get_vconfig () with max_ifuel = v } | {
"file_name": "ulib/FStar.Tactics.SMT.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 98,
"end_line": 31,
"start_col": 0,
"start_line": 31
} | module FStar.Tactics.SMT
open FStar.Tactics.Effect
open FStar.Stubs.Tactics.V2.Builtins
open FStar.VConfig
(* Alias to just use the current vconfig *)
let smt_sync () : Tac unit = t_smt_sync (get_vconfig ())
(* smt_sync': as smt_sync, but using a particular fuel/ifuel *)
let smt_sync' (fuel ifuel : nat) : Tac unit =
let vcfg = get_vconfig () in
let vcfg' = { vcfg with initial_fuel = fuel; max_fuel = fuel
; initial_ifuel = ifuel; max_ifuel = ifuel }
in
t_smt_sync vcfg'
(* Getting/setting solver configuration *)
let get_rlimit () : Tac int = (get_vconfig()).z3rlimit
let set_rlimit (v : int) : Tac unit = set_vconfig { get_vconfig () with z3rlimit = v }
let get_initial_fuel () : Tac int = (get_vconfig ()).initial_fuel
let get_initial_ifuel () : Tac int = (get_vconfig ()).initial_ifuel
let get_max_fuel () : Tac int = (get_vconfig ()).max_fuel
let get_max_ifuel () : Tac int = (get_vconfig ()).max_ifuel
let set_initial_fuel (v : int) : Tac unit = set_vconfig { get_vconfig () with initial_fuel = v }
let set_initial_ifuel (v : int) : Tac unit = set_vconfig { get_vconfig () with initial_ifuel = v } | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.VConfig.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Stubs.Tactics.V2.Builtins.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Tactics.SMT.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.VConfig",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Tactics.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | v: Prims.int -> FStar.Tactics.Effect.Tac Prims.unit | FStar.Tactics.Effect.Tac | [] | [] | [
"Prims.int",
"FStar.Stubs.Tactics.V2.Builtins.set_vconfig",
"Prims.unit",
"FStar.VConfig.vconfig",
"FStar.VConfig.Mkvconfig",
"FStar.VConfig.__proj__Mkvconfig__item__initial_fuel",
"FStar.VConfig.__proj__Mkvconfig__item__max_fuel",
"FStar.VConfig.__proj__Mkvconfig__item__initial_ifuel",
"FStar.VConfig.__proj__Mkvconfig__item__detail_errors",
"FStar.VConfig.__proj__Mkvconfig__item__detail_hint_replay",
"FStar.VConfig.__proj__Mkvconfig__item__no_smt",
"FStar.VConfig.__proj__Mkvconfig__item__quake_lo",
"FStar.VConfig.__proj__Mkvconfig__item__quake_hi",
"FStar.VConfig.__proj__Mkvconfig__item__quake_keep",
"FStar.VConfig.__proj__Mkvconfig__item__retry",
"FStar.VConfig.__proj__Mkvconfig__item__smtencoding_elim_box",
"FStar.VConfig.__proj__Mkvconfig__item__smtencoding_nl_arith_repr",
"FStar.VConfig.__proj__Mkvconfig__item__smtencoding_l_arith_repr",
"FStar.VConfig.__proj__Mkvconfig__item__smtencoding_valid_intro",
"FStar.VConfig.__proj__Mkvconfig__item__smtencoding_valid_elim",
"FStar.VConfig.__proj__Mkvconfig__item__tcnorm",
"FStar.VConfig.__proj__Mkvconfig__item__no_plugins",
"FStar.VConfig.__proj__Mkvconfig__item__no_tactics",
"FStar.VConfig.__proj__Mkvconfig__item__z3cliopt",
"FStar.VConfig.__proj__Mkvconfig__item__z3smtopt",
"FStar.VConfig.__proj__Mkvconfig__item__z3refresh",
"FStar.VConfig.__proj__Mkvconfig__item__z3rlimit",
"FStar.VConfig.__proj__Mkvconfig__item__z3rlimit_factor",
"FStar.VConfig.__proj__Mkvconfig__item__z3seed",
"FStar.VConfig.__proj__Mkvconfig__item__z3version",
"FStar.VConfig.__proj__Mkvconfig__item__trivial_pre_for_unannotated_effectful_fns",
"FStar.VConfig.__proj__Mkvconfig__item__reuse_hint_for",
"FStar.Stubs.Tactics.V2.Builtins.get_vconfig"
] | [] | false | true | false | false | false | let set_max_ifuel (v: int) : Tac unit =
| set_vconfig ({ get_vconfig () with max_ifuel = v }) | false |
FStar.Tactics.SMT.fst | FStar.Tactics.SMT.set_ifuel | val set_ifuel (v: int) : Tac unit | val set_ifuel (v: int) : Tac unit | let set_ifuel (v : int) : Tac unit = set_vconfig { get_vconfig () with initial_ifuel = v; max_ifuel = v } | {
"file_name": "ulib/FStar.Tactics.SMT.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 113,
"end_line": 35,
"start_col": 0,
"start_line": 35
} | module FStar.Tactics.SMT
open FStar.Tactics.Effect
open FStar.Stubs.Tactics.V2.Builtins
open FStar.VConfig
(* Alias to just use the current vconfig *)
let smt_sync () : Tac unit = t_smt_sync (get_vconfig ())
(* smt_sync': as smt_sync, but using a particular fuel/ifuel *)
let smt_sync' (fuel ifuel : nat) : Tac unit =
let vcfg = get_vconfig () in
let vcfg' = { vcfg with initial_fuel = fuel; max_fuel = fuel
; initial_ifuel = ifuel; max_ifuel = ifuel }
in
t_smt_sync vcfg'
(* Getting/setting solver configuration *)
let get_rlimit () : Tac int = (get_vconfig()).z3rlimit
let set_rlimit (v : int) : Tac unit = set_vconfig { get_vconfig () with z3rlimit = v }
let get_initial_fuel () : Tac int = (get_vconfig ()).initial_fuel
let get_initial_ifuel () : Tac int = (get_vconfig ()).initial_ifuel
let get_max_fuel () : Tac int = (get_vconfig ()).max_fuel
let get_max_ifuel () : Tac int = (get_vconfig ()).max_ifuel
let set_initial_fuel (v : int) : Tac unit = set_vconfig { get_vconfig () with initial_fuel = v }
let set_initial_ifuel (v : int) : Tac unit = set_vconfig { get_vconfig () with initial_ifuel = v }
let set_max_fuel (v : int) : Tac unit = set_vconfig { get_vconfig () with max_fuel = v }
let set_max_ifuel (v : int) : Tac unit = set_vconfig { get_vconfig () with max_ifuel = v }
(* Set both min and max *) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.VConfig.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Stubs.Tactics.V2.Builtins.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Tactics.SMT.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.VConfig",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Tactics.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | v: Prims.int -> FStar.Tactics.Effect.Tac Prims.unit | FStar.Tactics.Effect.Tac | [] | [] | [
"Prims.int",
"FStar.Stubs.Tactics.V2.Builtins.set_vconfig",
"Prims.unit",
"FStar.VConfig.vconfig",
"FStar.VConfig.Mkvconfig",
"FStar.VConfig.__proj__Mkvconfig__item__initial_fuel",
"FStar.VConfig.__proj__Mkvconfig__item__max_fuel",
"FStar.VConfig.__proj__Mkvconfig__item__detail_errors",
"FStar.VConfig.__proj__Mkvconfig__item__detail_hint_replay",
"FStar.VConfig.__proj__Mkvconfig__item__no_smt",
"FStar.VConfig.__proj__Mkvconfig__item__quake_lo",
"FStar.VConfig.__proj__Mkvconfig__item__quake_hi",
"FStar.VConfig.__proj__Mkvconfig__item__quake_keep",
"FStar.VConfig.__proj__Mkvconfig__item__retry",
"FStar.VConfig.__proj__Mkvconfig__item__smtencoding_elim_box",
"FStar.VConfig.__proj__Mkvconfig__item__smtencoding_nl_arith_repr",
"FStar.VConfig.__proj__Mkvconfig__item__smtencoding_l_arith_repr",
"FStar.VConfig.__proj__Mkvconfig__item__smtencoding_valid_intro",
"FStar.VConfig.__proj__Mkvconfig__item__smtencoding_valid_elim",
"FStar.VConfig.__proj__Mkvconfig__item__tcnorm",
"FStar.VConfig.__proj__Mkvconfig__item__no_plugins",
"FStar.VConfig.__proj__Mkvconfig__item__no_tactics",
"FStar.VConfig.__proj__Mkvconfig__item__z3cliopt",
"FStar.VConfig.__proj__Mkvconfig__item__z3smtopt",
"FStar.VConfig.__proj__Mkvconfig__item__z3refresh",
"FStar.VConfig.__proj__Mkvconfig__item__z3rlimit",
"FStar.VConfig.__proj__Mkvconfig__item__z3rlimit_factor",
"FStar.VConfig.__proj__Mkvconfig__item__z3seed",
"FStar.VConfig.__proj__Mkvconfig__item__z3version",
"FStar.VConfig.__proj__Mkvconfig__item__trivial_pre_for_unannotated_effectful_fns",
"FStar.VConfig.__proj__Mkvconfig__item__reuse_hint_for",
"FStar.Stubs.Tactics.V2.Builtins.get_vconfig"
] | [] | false | true | false | false | false | let set_ifuel (v: int) : Tac unit =
| set_vconfig ({ get_vconfig () with initial_ifuel = v; max_ifuel = v }) | false |
Hacl.Spec.Bignum.Addition.fst | Hacl.Spec.Bignum.Addition.bn_add | val bn_add: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> carry t & lbignum t aLen | val bn_add: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> carry t & lbignum t aLen | let bn_add #t #aLen #bLen a b =
let c0, res0 = generate_elems bLen bLen (bn_add_f (sub a 0 bLen) b) (uint #t 0) in
if bLen < aLen then
let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in
c1, concat #_ #bLen res0 res1
else c0, res0 | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Addition.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 60,
"start_col": 0,
"start_line": 54
} | module Hacl.Spec.Bignum.Addition
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_sub_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t
let bn_sub_carry_f #t #aLen a i c_in = subborrow c_in a.[i] (uint #t 0)
val bn_sub_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen)
let bn_sub_carry #t #aLen a c_in = generate_elems aLen aLen (bn_sub_carry_f a) c_in
val bn_sub_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t
let bn_sub_f #t #aLen a b i c = subborrow c a.[i] b.[i]
val bn_sub: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> tuple2 (carry t) (lbignum t aLen)
let bn_sub #t #aLen #bLen a b =
let c0, res0 = generate_elems bLen bLen (bn_sub_f (sub a 0 bLen) b) (uint #t 0) in
if bLen < aLen then
let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in
c1, concat #_ #bLen res0 res1
else c0, res0
val bn_sub1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen)
let bn_sub1 #t #aLen a b1 =
let c0, r0 = subborrow (uint #t 0) a.[0] b1 in
let res0 = create 1 r0 in
if 1 < aLen then
let c1, res1 = bn_sub_carry (sub a 1 (aLen - 1)) c0 in
c1, concat res0 res1
else c0, res0
val bn_add_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t
let bn_add_carry_f #t #aLen a i c_in = addcarry c_in a.[i] (uint #t 0)
val bn_add_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen)
let bn_add_carry #t #aLen a c_in = generate_elems aLen aLen (bn_add_carry_f a) c_in
val bn_add_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t
let bn_add_f #t #aLen a b i c = addcarry c a.[i] b.[i] | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Addition.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | a: Hacl.Spec.Bignum.Definitions.lbignum t aLen -> b: Hacl.Spec.Bignum.Definitions.lbignum t bLen
-> Hacl.Spec.Bignum.Base.carry t * Hacl.Spec.Bignum.Definitions.lbignum t aLen | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Base.carry",
"Lib.Sequence.seq",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.eq2",
"Prims.nat",
"Lib.Sequence.length",
"Prims.op_LessThan",
"Prims.op_Subtraction",
"FStar.Pervasives.Native.Mktuple2",
"Lib.Sequence.concat",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.Bignum.Addition.bn_add_carry",
"Lib.Sequence.sub",
"Prims.bool",
"Hacl.Spec.Lib.generate_elems",
"Hacl.Spec.Bignum.Addition.bn_add_f",
"Lib.IntTypes.uint",
"Lib.IntTypes.SEC"
] | [] | false | false | false | false | false | let bn_add #t #aLen #bLen a b =
| let c0, res0 = generate_elems bLen bLen (bn_add_f (sub a 0 bLen) b) (uint #t 0) in
if bLen < aLen
then
let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in
c1, concat #_ #bLen res0 res1
else c0, res0 | false |
Hacl.Spec.Bignum.Addition.fst | Hacl.Spec.Bignum.Addition.bn_add1 | val bn_add1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen) | val bn_add1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen) | let bn_add1 #t #aLen a b1 =
let c0, r0 = addcarry (uint #t 0) a.[0] b1 in
let res0 = create 1 r0 in
if 1 < aLen then
let c1, res1 = bn_add_carry (sub a 1 (aLen - 1)) c0 in
c1, concat res0 res1
else c0, res0 | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Addition.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 70,
"start_col": 0,
"start_line": 63
} | module Hacl.Spec.Bignum.Addition
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_sub_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t
let bn_sub_carry_f #t #aLen a i c_in = subborrow c_in a.[i] (uint #t 0)
val bn_sub_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen)
let bn_sub_carry #t #aLen a c_in = generate_elems aLen aLen (bn_sub_carry_f a) c_in
val bn_sub_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t
let bn_sub_f #t #aLen a b i c = subborrow c a.[i] b.[i]
val bn_sub: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> tuple2 (carry t) (lbignum t aLen)
let bn_sub #t #aLen #bLen a b =
let c0, res0 = generate_elems bLen bLen (bn_sub_f (sub a 0 bLen) b) (uint #t 0) in
if bLen < aLen then
let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in
c1, concat #_ #bLen res0 res1
else c0, res0
val bn_sub1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen)
let bn_sub1 #t #aLen a b1 =
let c0, r0 = subborrow (uint #t 0) a.[0] b1 in
let res0 = create 1 r0 in
if 1 < aLen then
let c1, res1 = bn_sub_carry (sub a 1 (aLen - 1)) c0 in
c1, concat res0 res1
else c0, res0
val bn_add_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t
let bn_add_carry_f #t #aLen a i c_in = addcarry c_in a.[i] (uint #t 0)
val bn_add_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen)
let bn_add_carry #t #aLen a c_in = generate_elems aLen aLen (bn_add_carry_f a) c_in
val bn_add_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t
let bn_add_f #t #aLen a b i c = addcarry c a.[i] b.[i]
val bn_add: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> carry t & lbignum t aLen
let bn_add #t #aLen #bLen a b =
let c0, res0 = generate_elems bLen bLen (bn_add_f (sub a 0 bLen) b) (uint #t 0) in
if bLen < aLen then
let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in
c1, concat #_ #bLen res0 res1
else c0, res0 | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Addition.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | a: Hacl.Spec.Bignum.Definitions.lbignum t aLen -> b1: Hacl.Spec.Bignum.Definitions.limb t
-> Hacl.Spec.Bignum.Base.carry t * Hacl.Spec.Bignum.Definitions.lbignum t aLen | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_pos",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Definitions.limb",
"Hacl.Spec.Bignum.Base.carry",
"Prims.op_LessThan",
"Prims.op_Subtraction",
"FStar.Pervasives.Native.Mktuple2",
"Lib.Sequence.concat",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.Bignum.Addition.bn_add_carry",
"Lib.Sequence.sub",
"Prims.bool",
"Lib.Sequence.lseq",
"Prims.l_and",
"Prims.eq2",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.create",
"Prims.l_Forall",
"Prims.nat",
"Prims.l_imp",
"Prims.b2t",
"Lib.Sequence.index",
"Lib.Sequence.create",
"Hacl.Spec.Bignum.Base.addcarry",
"Lib.IntTypes.uint",
"Lib.IntTypes.SEC",
"Lib.Sequence.op_String_Access"
] | [] | false | false | false | false | false | let bn_add1 #t #aLen a b1 =
| let c0, r0 = addcarry (uint #t 0) a.[ 0 ] b1 in
let res0 = create 1 r0 in
if 1 < aLen
then
let c1, res1 = bn_add_carry (sub a 1 (aLen - 1)) c0 in
c1, concat res0 res1
else c0, res0 | false |
Hacl.Spec.Bignum.Addition.fst | Hacl.Spec.Bignum.Addition.bn_sub_carry_lemma | val bn_sub_carry_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t ->
Lemma (let (c_out, res) = bn_sub_carry a c_in in
bn_v res - v c_out * pow2 (bits t * aLen) == bn_v a - v c_in) | val bn_sub_carry_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t ->
Lemma (let (c_out, res) = bn_sub_carry a c_in in
bn_v res - v c_out * pow2 (bits t * aLen) == bn_v a - v c_in) | let bn_sub_carry_lemma #t #aLen a c_in =
let (c_out, res) = bn_sub_carry a c_in in
bn_sub_carry_lemma_loop a c_in aLen | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Addition.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 37,
"end_line": 399,
"start_col": 0,
"start_line": 397
} | module Hacl.Spec.Bignum.Addition
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_sub_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t
let bn_sub_carry_f #t #aLen a i c_in = subborrow c_in a.[i] (uint #t 0)
val bn_sub_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen)
let bn_sub_carry #t #aLen a c_in = generate_elems aLen aLen (bn_sub_carry_f a) c_in
val bn_sub_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t
let bn_sub_f #t #aLen a b i c = subborrow c a.[i] b.[i]
val bn_sub: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> tuple2 (carry t) (lbignum t aLen)
let bn_sub #t #aLen #bLen a b =
let c0, res0 = generate_elems bLen bLen (bn_sub_f (sub a 0 bLen) b) (uint #t 0) in
if bLen < aLen then
let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in
c1, concat #_ #bLen res0 res1
else c0, res0
val bn_sub1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen)
let bn_sub1 #t #aLen a b1 =
let c0, r0 = subborrow (uint #t 0) a.[0] b1 in
let res0 = create 1 r0 in
if 1 < aLen then
let c1, res1 = bn_sub_carry (sub a 1 (aLen - 1)) c0 in
c1, concat res0 res1
else c0, res0
val bn_add_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t
let bn_add_carry_f #t #aLen a i c_in = addcarry c_in a.[i] (uint #t 0)
val bn_add_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen)
let bn_add_carry #t #aLen a c_in = generate_elems aLen aLen (bn_add_carry_f a) c_in
val bn_add_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t
let bn_add_f #t #aLen a b i c = addcarry c a.[i] b.[i]
val bn_add: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> carry t & lbignum t aLen
let bn_add #t #aLen #bLen a b =
let c0, res0 = generate_elems bLen bLen (bn_add_f (sub a 0 bLen) b) (uint #t 0) in
if bLen < aLen then
let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in
c1, concat #_ #bLen res0 res1
else c0, res0
val bn_add1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen)
let bn_add1 #t #aLen a b1 =
let c0, r0 = addcarry (uint #t 0) a.[0] b1 in
let res0 = create 1 r0 in
if 1 < aLen then
let c1, res1 = bn_add_carry (sub a 1 (aLen - 1)) c0 in
c1, concat res0 res1
else c0, res0
val bn_add_carry_lemma_loop_step:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> c_in:carry t
-> i:pos{i <= aLen}
-> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma
(requires
(let (c1, res1) = c1_res1 in
v c1 * pow2 (bits t * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + v c_in))
(ensures
(let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) c1_res1 in
v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in))
let bn_add_carry_lemma_loop_step #t #aLen a c_in i (c1, res1) =
let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1) in
let c, e = bn_add_carry_f a (i - 1) c1 in
assert (v e + v c * pow2 (bits t) == v a.[i - 1] + v c1);
let pbits = bits t in
calc (==) {
v c * pow2 (pbits * i) + bn_v #t #i res;
(==) { bn_eval_snoc #t #(i - 1) res1 e }
v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1));
(==) { }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in - (v e + v c * pow2 pbits - v a.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1]) (pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + (v e - v e - v c * pow2 pbits + v a.[i - 1]) * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1));
(==) { bn_eval_unfold_i #t #aLen a i }
eval_ aLen a i + v c_in;
};
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in)
val bn_add_carry_lemma_loop:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> c_in:carry t
-> i:nat{i <= aLen} ->
Lemma (let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in
v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in)
let rec bn_add_carry_lemma_loop #t #aLen a c_in i =
let pbits = bits t in
let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in
if i = 0 then begin
eq_generate_elems0 aLen i (bn_add_carry_f a) c_in;
assert (c_out == c_in /\ res == Seq.empty);
bn_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
() end
else begin
let (c1, res1) : generate_elem_a (limb t) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_add_carry_f a) c_in in
generate_elems_unfold aLen i (bn_add_carry_f a) c_in (i - 1);
assert (generate_elems aLen i (bn_add_carry_f a) c_in ==
generate_elem_f aLen (bn_add_carry_f a) (i - 1) (generate_elems aLen (i - 1) (bn_add_carry_f a) c_in));
assert ((c_out, res) == generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1));
bn_add_carry_lemma_loop a c_in (i - 1);
assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + v c_in);
bn_add_carry_lemma_loop_step a c_in i (c1, res1);
assert (v c_out * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in);
() end
val bn_add_carry_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t ->
Lemma (let (c_out, res) = bn_add_carry a c_in in
v c_out * pow2 (bits t * aLen) + bn_v res == bn_v a + v c_in)
let bn_add_carry_lemma #t #aLen a c_in =
let (c_out, res) = bn_add_carry a c_in in
bn_add_carry_lemma_loop a c_in aLen
val bn_add_lemma_loop_step:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> b:lbignum t aLen
-> i:pos{i <= aLen}
-> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma
(requires
(let (c1, res1) = c1_res1 in
v c1 * pow2 (bits t * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + eval_ aLen b (i - 1)))
(ensures
(let (c1, res1) = c1_res1 in
let (c, res) = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in
v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i))
let bn_add_lemma_loop_step #t #aLen a b i (c1, res1) =
let pbits = bits t in
let (c, res) = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in
let c, e = bn_add_f a b (i - 1) c1 in
assert (v e + v c * pow2 pbits == v a.[i - 1] + v b.[i - 1] + v c1);
calc (==) {
v c * pow2 (pbits * i) + bn_v #t #i res;
(==) { bn_eval_snoc #t #(i - 1) res1 e }
v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1));
(==) { }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) - (v e + v c * pow2 pbits - v a.[i - 1] - v b.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1] - v b.[i - 1]) (pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v e - v e - v c * pow2 pbits + v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1] + v b.[i - 1]) (v c1 * pow2 pbits) (pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_add_left (v a.[i - 1]) (v b.[i - 1]) (pow2 (pbits * (i - 1))) }
eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + v a.[i - 1] * pow2 (pbits * (i - 1)) + v b.[i - 1] * pow2 (pbits * (i - 1));
(==) { bn_eval_unfold_i #t #aLen a i }
eval_ aLen a i + eval_ aLen b (i - 1) + v b.[i - 1] * pow2 (pbits * (i - 1));
(==) { bn_eval_unfold_i #t #aLen b i }
eval_ aLen a i + eval_ aLen b i;
};
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i)
val bn_add_lemma_loop:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> b:lbignum t aLen
-> i:nat{i <= aLen} ->
Lemma (let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_f a b) (uint #t 0) in
v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i)
let rec bn_add_lemma_loop #t #aLen a b i =
let pbits = bits t in
let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_f a b) (uint #t 0) in
if i = 0 then begin
eq_generate_elems0 aLen i (bn_add_f a b) (uint #t 0);
assert (c == uint #t 0 /\ res == Seq.empty);
bn_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
bn_eval0 b;
() end
else begin
let (c1, res1) : generate_elem_a (limb t) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_add_f a b) (uint #t 0) in
generate_elems_unfold aLen i (bn_add_f a b) (uint #t 0) (i - 1);
assert (generate_elems aLen i (bn_add_f a b) (uint #t 0) ==
generate_elem_f aLen (bn_add_f a b) (i - 1) (generate_elems aLen (i - 1) (bn_add_f a b) (uint #t 0)));
assert ((c, res) == generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1));
bn_add_lemma_loop a b (i - 1);
assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + eval_ aLen b (i - 1));
bn_add_lemma_loop_step a b i (c1, res1);
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i);
() end
val bn_add_concat_lemma:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat{bLen < aLen}
-> a:lbignum t aLen
-> b:lbignum t bLen
-> c0:carry t
-> res0:lbignum t bLen -> Lemma
(requires
v c0 * pow2 (bits t * bLen) + bn_v #t #bLen res0 == eval_ bLen (sub a 0 bLen) bLen + eval_ bLen b bLen)
(ensures
(let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in
let res = concat #_ #bLen res0 res1 in
bn_v res == eval_ aLen a aLen + eval_ bLen b bLen - v c1 * pow2 (bits t * aLen)))
let bn_add_concat_lemma #t #aLen #bLen a b c0 res0 =
let pbits = bits t in
let a0 = sub a 0 bLen in
let a1 = sub a bLen (aLen - bLen) in
let c1, res1 = bn_add_carry a1 c0 in
bn_add_carry_lemma a1 c0;
assert (v c1 * pow2 (pbits * (aLen - bLen)) + bn_v res1 == bn_v a1 + v c0);
let res = concat #_ #bLen res0 res1 in
bn_concat_lemma res0 res1;
assert (bn_v res == bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1);
calc (==) {
bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1;
(==) { }
eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0 - v c1 * pow2 (pbits * (aLen - bLen)));
(==) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * bLen)) (bn_v a1 + v c0) (v c1 * pow2 (pbits * (aLen - bLen))) }
eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0) - pow2 (pbits * bLen) * v c1 * pow2 (pbits * (aLen - bLen));
(==) { Math.Lemmas.paren_mul_right (pow2 (pbits * bLen)) (v c1) (pow2 (pbits * (aLen - bLen))); Math.Lemmas.pow2_plus (pbits * bLen) (pbits * (aLen - bLen)) }
eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0) - v c1 * pow2 (pbits * aLen);
(==) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * bLen)) (bn_v a1) (v c0) }
eval_ bLen a0 bLen + eval_ bLen b bLen + pow2 (pbits * bLen) * bn_v a1 - v c1 * pow2 (pbits * aLen);
(==) { bn_eval_split_i a bLen; bn_eval_extensionality_j a (sub a 0 bLen) bLen }
eval_ aLen a aLen + eval_ bLen b bLen - v c1 * pow2 (pbits * aLen);
}
val bn_add_lemma:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat{bLen <= aLen}
-> a:lbignum t aLen
-> b:lbignum t bLen ->
Lemma (let (c, res) = bn_add a b in
v c * pow2 (bits t * aLen) + bn_v res == bn_v a + bn_v b)
let bn_add_lemma #t #aLen #bLen a b =
let pbits = bits t in
let (c, res) = bn_add a b in
if bLen = aLen then
bn_add_lemma_loop a b aLen
else begin
let a0 = sub a 0 bLen in
let a1 = sub a bLen (aLen - bLen) in
let c0, res0 = generate_elems bLen bLen (bn_add_f a0 b) (uint #t 0) in
bn_add_lemma_loop a0 b bLen;
assert (v c0 * pow2 (pbits * bLen) + bn_v #t #bLen res0 == eval_ bLen a0 bLen + eval_ bLen b bLen);
bn_add_concat_lemma #t #aLen #bLen a b c0 res0 end
val bn_add1_lemma:
#t:limb_t
-> #aLen:size_pos
-> a:lbignum t aLen
-> b1:limb t ->
Lemma (let (c, res) = bn_add1 a b1 in
v c * pow2 (bits t * aLen) + bn_v res == bn_v a + v b1)
let bn_add1_lemma #t #aLen a b1 =
let pbits = bits t in
let c0, r0 = addcarry (uint #t 0) a.[0] b1 in
assert (v c0 * pow2 pbits + v r0 = v a.[0] + v b1);
let res0 = create 1 r0 in
let b = create 1 b1 in
bn_eval1 res0;
bn_eval1 b;
if aLen = 1 then
bn_eval1 a
else begin
let bLen = 1 in
let a0 = sub a 0 bLen in
bn_eval1 a0;
assert (v c0 * pow2 (pbits * bLen) + bn_v #t #1 res0 == eval_ bLen a0 bLen + eval_ bLen b bLen);
bn_add_concat_lemma a b c0 res0 end
val bn_sub_carry_lemma_loop_step:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> c_in:carry t
-> i:pos{i <= aLen}
-> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma
(requires
(let (c1, res1) = c1_res1 in
bn_v #t #(i - 1) res1 - v c1 * pow2 (bits t * (i - 1)) == eval_ aLen a (i - 1) - v c_in))
(ensures
(let (c_out, res) = generate_elem_f aLen (bn_sub_carry_f a) (i - 1) c1_res1 in
bn_v #t #i res - v c_out * pow2 (bits t * i) == eval_ aLen a i - v c_in))
let bn_sub_carry_lemma_loop_step #t #aLen a c_in i (c1, res1) =
let pbits = bits t in
let (c_out, res) = generate_elem_f aLen (bn_sub_carry_f a) (i - 1) (c1, res1) in
let c, e = bn_sub_carry_f a (i - 1) c1 in
assert (v e - v c * pow2 pbits == v a.[i - 1] - v c1);
calc (==) {
bn_v #t #i res - v c * pow2 (pbits * i);
(==) { bn_eval_snoc #t #(i - 1) res1 e }
bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i);
(==) { }
eval_ aLen a (i - 1) - v c_in + (v a.[i - 1] - v e + v c * pow2 pbits) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i);
(==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1] + v c * pow2 pbits) (v e) (pow2 (pbits * (i - 1))) }
eval_ aLen a (i - 1) - v c_in + (v a.[i - 1] + v c * pow2 pbits) * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i);
(==) { Math.Lemmas.distributivity_add_left (v a.[i - 1]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) }
eval_ aLen a (i - 1) - v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)) + v c * pow2 pbits * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i);
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen a (i - 1) - v c_in + v a.[i - 1] * pow2 (pbits * (i - 1));
(==) { bn_eval_unfold_i a i }
eval_ aLen a i - v c_in;
};
assert (bn_v #t #i res - v c * pow2 (pbits * i) == eval_ aLen a i - v c_in)
val bn_sub_carry_lemma_loop:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> c_in:carry t
-> i:nat{i <= aLen} ->
Lemma (let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_sub_carry_f a) c_in in
bn_v #t #i res - v c_out * pow2 (bits t * i) == eval_ aLen a i - v c_in)
let rec bn_sub_carry_lemma_loop #t #aLen a c_in i =
let pbits = bits t in
let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_sub_carry_f a) c_in in
if i = 0 then begin
eq_generate_elems0 aLen i (bn_sub_carry_f a) c_in;
assert (c_out == c_in /\ res == Seq.empty);
bn_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
() end
else begin
let (c1, res1) : generate_elem_a (limb t) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_sub_carry_f a) c_in in
generate_elems_unfold aLen i (bn_sub_carry_f a) c_in (i - 1);
assert (generate_elems aLen i (bn_sub_carry_f a) c_in ==
generate_elem_f aLen (bn_sub_carry_f a) (i - 1) (generate_elems aLen (i - 1) (bn_sub_carry_f a) c_in));
assert ((c_out, res) == generate_elem_f aLen (bn_sub_carry_f a) (i - 1) (c1, res1));
bn_sub_carry_lemma_loop a c_in (i - 1);
assert (bn_v #t #(i - 1) res1 - v c1 * pow2 (pbits * (i - 1)) == eval_ aLen a (i - 1) - v c_in);
bn_sub_carry_lemma_loop_step a c_in i (c1, res1);
assert (bn_v #t #i res - v c_out * pow2 (pbits * i) == eval_ aLen a i - v c_in);
() end
val bn_sub_carry_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t ->
Lemma (let (c_out, res) = bn_sub_carry a c_in in
bn_v res - v c_out * pow2 (bits t * aLen) == bn_v a - v c_in) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Addition.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | a: Hacl.Spec.Bignum.Definitions.lbignum t aLen -> c_in: Hacl.Spec.Bignum.Base.carry t
-> FStar.Pervasives.Lemma
(ensures
(let _ = Hacl.Spec.Bignum.Addition.bn_sub_carry a c_in in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ c_out res = _ in
Hacl.Spec.Bignum.Definitions.bn_v res -
Lib.IntTypes.v c_out * Prims.pow2 (Lib.IntTypes.bits t * aLen) ==
Hacl.Spec.Bignum.Definitions.bn_v a - Lib.IntTypes.v c_in)
<:
Type0)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Base.carry",
"Hacl.Spec.Bignum.Addition.bn_sub_carry_lemma_loop",
"Prims.unit",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.Bignum.Addition.bn_sub_carry"
] | [] | false | false | true | false | false | let bn_sub_carry_lemma #t #aLen a c_in =
| let c_out, res = bn_sub_carry a c_in in
bn_sub_carry_lemma_loop a c_in aLen | false |
Hacl.Spec.Bignum.Addition.fst | Hacl.Spec.Bignum.Addition.bn_add_carry_lemma_loop | val bn_add_carry_lemma_loop:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> c_in:carry t
-> i:nat{i <= aLen} ->
Lemma (let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in
v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in) | val bn_add_carry_lemma_loop:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> c_in:carry t
-> i:nat{i <= aLen} ->
Lemma (let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in
v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in) | let rec bn_add_carry_lemma_loop #t #aLen a c_in i =
let pbits = bits t in
let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in
if i = 0 then begin
eq_generate_elems0 aLen i (bn_add_carry_f a) c_in;
assert (c_out == c_in /\ res == Seq.empty);
bn_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
() end
else begin
let (c1, res1) : generate_elem_a (limb t) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_add_carry_f a) c_in in
generate_elems_unfold aLen i (bn_add_carry_f a) c_in (i - 1);
assert (generate_elems aLen i (bn_add_carry_f a) c_in ==
generate_elem_f aLen (bn_add_carry_f a) (i - 1) (generate_elems aLen (i - 1) (bn_add_carry_f a) c_in));
assert ((c_out, res) == generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1));
bn_add_carry_lemma_loop a c_in (i - 1);
assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + v c_in);
bn_add_carry_lemma_loop_step a c_in i (c1, res1);
assert (v c_out * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in);
() end | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Addition.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 10,
"end_line": 140,
"start_col": 0,
"start_line": 120
} | module Hacl.Spec.Bignum.Addition
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_sub_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t
let bn_sub_carry_f #t #aLen a i c_in = subborrow c_in a.[i] (uint #t 0)
val bn_sub_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen)
let bn_sub_carry #t #aLen a c_in = generate_elems aLen aLen (bn_sub_carry_f a) c_in
val bn_sub_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t
let bn_sub_f #t #aLen a b i c = subborrow c a.[i] b.[i]
val bn_sub: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> tuple2 (carry t) (lbignum t aLen)
let bn_sub #t #aLen #bLen a b =
let c0, res0 = generate_elems bLen bLen (bn_sub_f (sub a 0 bLen) b) (uint #t 0) in
if bLen < aLen then
let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in
c1, concat #_ #bLen res0 res1
else c0, res0
val bn_sub1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen)
let bn_sub1 #t #aLen a b1 =
let c0, r0 = subborrow (uint #t 0) a.[0] b1 in
let res0 = create 1 r0 in
if 1 < aLen then
let c1, res1 = bn_sub_carry (sub a 1 (aLen - 1)) c0 in
c1, concat res0 res1
else c0, res0
val bn_add_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t
let bn_add_carry_f #t #aLen a i c_in = addcarry c_in a.[i] (uint #t 0)
val bn_add_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen)
let bn_add_carry #t #aLen a c_in = generate_elems aLen aLen (bn_add_carry_f a) c_in
val bn_add_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t
let bn_add_f #t #aLen a b i c = addcarry c a.[i] b.[i]
val bn_add: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> carry t & lbignum t aLen
let bn_add #t #aLen #bLen a b =
let c0, res0 = generate_elems bLen bLen (bn_add_f (sub a 0 bLen) b) (uint #t 0) in
if bLen < aLen then
let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in
c1, concat #_ #bLen res0 res1
else c0, res0
val bn_add1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen)
let bn_add1 #t #aLen a b1 =
let c0, r0 = addcarry (uint #t 0) a.[0] b1 in
let res0 = create 1 r0 in
if 1 < aLen then
let c1, res1 = bn_add_carry (sub a 1 (aLen - 1)) c0 in
c1, concat res0 res1
else c0, res0
val bn_add_carry_lemma_loop_step:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> c_in:carry t
-> i:pos{i <= aLen}
-> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma
(requires
(let (c1, res1) = c1_res1 in
v c1 * pow2 (bits t * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + v c_in))
(ensures
(let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) c1_res1 in
v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in))
let bn_add_carry_lemma_loop_step #t #aLen a c_in i (c1, res1) =
let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1) in
let c, e = bn_add_carry_f a (i - 1) c1 in
assert (v e + v c * pow2 (bits t) == v a.[i - 1] + v c1);
let pbits = bits t in
calc (==) {
v c * pow2 (pbits * i) + bn_v #t #i res;
(==) { bn_eval_snoc #t #(i - 1) res1 e }
v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1));
(==) { }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in - (v e + v c * pow2 pbits - v a.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1]) (pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + (v e - v e - v c * pow2 pbits + v a.[i - 1]) * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1));
(==) { bn_eval_unfold_i #t #aLen a i }
eval_ aLen a i + v c_in;
};
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in)
val bn_add_carry_lemma_loop:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> c_in:carry t
-> i:nat{i <= aLen} ->
Lemma (let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in
v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Addition.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Hacl.Spec.Bignum.Definitions.lbignum t aLen ->
c_in: Hacl.Spec.Bignum.Base.carry t ->
i: Prims.nat{i <= aLen}
-> FStar.Pervasives.Lemma
(ensures
(let _ =
Hacl.Spec.Lib.generate_elems aLen i (Hacl.Spec.Bignum.Addition.bn_add_carry_f a) c_in
in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ c_out res = _ in
let _ = _ in
Lib.IntTypes.v c_out * Prims.pow2 (Lib.IntTypes.bits t * i) +
Hacl.Spec.Bignum.Definitions.bn_v res ==
Hacl.Spec.Bignum.Definitions.eval_ aLen a i + Lib.IntTypes.v c_in)
<:
Type0)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Base.carry",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Lib.Sequence.seq",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.eq2",
"Lib.Sequence.length",
"Prims.op_Equality",
"Prims.int",
"Prims.unit",
"Hacl.Spec.Bignum.Definitions.bn_eval0",
"FStar.Pervasives.assert_norm",
"Prims.pow2",
"Prims._assert",
"Prims.l_and",
"FStar.Seq.Base.seq",
"Prims.l_or",
"FStar.Seq.Base.length",
"FStar.Seq.Base.empty",
"Hacl.Spec.Lib.eq_generate_elems0",
"Hacl.Spec.Bignum.Addition.bn_add_carry_f",
"Prims.bool",
"Prims.op_Subtraction",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Hacl.Spec.Bignum.Definitions.eval_",
"Hacl.Spec.Bignum.Addition.bn_add_carry_lemma_loop_step",
"FStar.Pervasives.Native.Mktuple2",
"Hacl.Spec.Bignum.Addition.bn_add_carry_lemma_loop",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.Lib.generate_elem_f",
"Hacl.Spec.Lib.generate_elems",
"Hacl.Spec.Lib.generate_elems_unfold",
"Hacl.Spec.Lib.generate_elem_a",
"Lib.IntTypes.bits"
] | [
"recursion"
] | false | false | true | false | false | let rec bn_add_carry_lemma_loop #t #aLen a c_in i =
| let pbits = bits t in
let c_out, res:generate_elem_a (limb t) (carry t) aLen i =
generate_elems aLen i (bn_add_carry_f a) c_in
in
if i = 0
then
(eq_generate_elems0 aLen i (bn_add_carry_f a) c_in;
assert (c_out == c_in /\ res == Seq.empty);
bn_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
())
else
let c1, res1:generate_elem_a (limb t) (carry t) aLen (i - 1) =
generate_elems aLen (i - 1) (bn_add_carry_f a) c_in
in
generate_elems_unfold aLen i (bn_add_carry_f a) c_in (i - 1);
assert (generate_elems aLen i (bn_add_carry_f a) c_in ==
generate_elem_f aLen
(bn_add_carry_f a)
(i - 1)
(generate_elems aLen (i - 1) (bn_add_carry_f a) c_in));
assert ((c_out, res) == generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1));
bn_add_carry_lemma_loop a c_in (i - 1);
assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + v c_in);
bn_add_carry_lemma_loop_step a c_in i (c1, res1);
assert (v c_out * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in);
() | false |
Hacl.Spec.Bignum.Addition.fst | Hacl.Spec.Bignum.Addition.bn_add1_lemma | val bn_add1_lemma:
#t:limb_t
-> #aLen:size_pos
-> a:lbignum t aLen
-> b1:limb t ->
Lemma (let (c, res) = bn_add1 a b1 in
v c * pow2 (bits t * aLen) + bn_v res == bn_v a + v b1) | val bn_add1_lemma:
#t:limb_t
-> #aLen:size_pos
-> a:lbignum t aLen
-> b1:limb t ->
Lemma (let (c, res) = bn_add1 a b1 in
v c * pow2 (bits t * aLen) + bn_v res == bn_v a + v b1) | let bn_add1_lemma #t #aLen a b1 =
let pbits = bits t in
let c0, r0 = addcarry (uint #t 0) a.[0] b1 in
assert (v c0 * pow2 pbits + v r0 = v a.[0] + v b1);
let res0 = create 1 r0 in
let b = create 1 b1 in
bn_eval1 res0;
bn_eval1 b;
if aLen = 1 then
bn_eval1 a
else begin
let bLen = 1 in
let a0 = sub a 0 bLen in
bn_eval1 a0;
assert (v c0 * pow2 (pbits * bLen) + bn_v #t #1 res0 == eval_ bLen a0 bLen + eval_ bLen b bLen);
bn_add_concat_lemma a b c0 res0 end | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Addition.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 39,
"end_line": 319,
"start_col": 0,
"start_line": 302
} | module Hacl.Spec.Bignum.Addition
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_sub_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t
let bn_sub_carry_f #t #aLen a i c_in = subborrow c_in a.[i] (uint #t 0)
val bn_sub_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen)
let bn_sub_carry #t #aLen a c_in = generate_elems aLen aLen (bn_sub_carry_f a) c_in
val bn_sub_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t
let bn_sub_f #t #aLen a b i c = subborrow c a.[i] b.[i]
val bn_sub: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> tuple2 (carry t) (lbignum t aLen)
let bn_sub #t #aLen #bLen a b =
let c0, res0 = generate_elems bLen bLen (bn_sub_f (sub a 0 bLen) b) (uint #t 0) in
if bLen < aLen then
let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in
c1, concat #_ #bLen res0 res1
else c0, res0
val bn_sub1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen)
let bn_sub1 #t #aLen a b1 =
let c0, r0 = subborrow (uint #t 0) a.[0] b1 in
let res0 = create 1 r0 in
if 1 < aLen then
let c1, res1 = bn_sub_carry (sub a 1 (aLen - 1)) c0 in
c1, concat res0 res1
else c0, res0
val bn_add_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t
let bn_add_carry_f #t #aLen a i c_in = addcarry c_in a.[i] (uint #t 0)
val bn_add_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen)
let bn_add_carry #t #aLen a c_in = generate_elems aLen aLen (bn_add_carry_f a) c_in
val bn_add_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t
let bn_add_f #t #aLen a b i c = addcarry c a.[i] b.[i]
val bn_add: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> carry t & lbignum t aLen
let bn_add #t #aLen #bLen a b =
let c0, res0 = generate_elems bLen bLen (bn_add_f (sub a 0 bLen) b) (uint #t 0) in
if bLen < aLen then
let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in
c1, concat #_ #bLen res0 res1
else c0, res0
val bn_add1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen)
let bn_add1 #t #aLen a b1 =
let c0, r0 = addcarry (uint #t 0) a.[0] b1 in
let res0 = create 1 r0 in
if 1 < aLen then
let c1, res1 = bn_add_carry (sub a 1 (aLen - 1)) c0 in
c1, concat res0 res1
else c0, res0
val bn_add_carry_lemma_loop_step:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> c_in:carry t
-> i:pos{i <= aLen}
-> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma
(requires
(let (c1, res1) = c1_res1 in
v c1 * pow2 (bits t * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + v c_in))
(ensures
(let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) c1_res1 in
v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in))
let bn_add_carry_lemma_loop_step #t #aLen a c_in i (c1, res1) =
let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1) in
let c, e = bn_add_carry_f a (i - 1) c1 in
assert (v e + v c * pow2 (bits t) == v a.[i - 1] + v c1);
let pbits = bits t in
calc (==) {
v c * pow2 (pbits * i) + bn_v #t #i res;
(==) { bn_eval_snoc #t #(i - 1) res1 e }
v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1));
(==) { }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in - (v e + v c * pow2 pbits - v a.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1]) (pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + (v e - v e - v c * pow2 pbits + v a.[i - 1]) * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1));
(==) { bn_eval_unfold_i #t #aLen a i }
eval_ aLen a i + v c_in;
};
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in)
val bn_add_carry_lemma_loop:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> c_in:carry t
-> i:nat{i <= aLen} ->
Lemma (let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in
v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in)
let rec bn_add_carry_lemma_loop #t #aLen a c_in i =
let pbits = bits t in
let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in
if i = 0 then begin
eq_generate_elems0 aLen i (bn_add_carry_f a) c_in;
assert (c_out == c_in /\ res == Seq.empty);
bn_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
() end
else begin
let (c1, res1) : generate_elem_a (limb t) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_add_carry_f a) c_in in
generate_elems_unfold aLen i (bn_add_carry_f a) c_in (i - 1);
assert (generate_elems aLen i (bn_add_carry_f a) c_in ==
generate_elem_f aLen (bn_add_carry_f a) (i - 1) (generate_elems aLen (i - 1) (bn_add_carry_f a) c_in));
assert ((c_out, res) == generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1));
bn_add_carry_lemma_loop a c_in (i - 1);
assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + v c_in);
bn_add_carry_lemma_loop_step a c_in i (c1, res1);
assert (v c_out * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in);
() end
val bn_add_carry_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t ->
Lemma (let (c_out, res) = bn_add_carry a c_in in
v c_out * pow2 (bits t * aLen) + bn_v res == bn_v a + v c_in)
let bn_add_carry_lemma #t #aLen a c_in =
let (c_out, res) = bn_add_carry a c_in in
bn_add_carry_lemma_loop a c_in aLen
val bn_add_lemma_loop_step:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> b:lbignum t aLen
-> i:pos{i <= aLen}
-> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma
(requires
(let (c1, res1) = c1_res1 in
v c1 * pow2 (bits t * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + eval_ aLen b (i - 1)))
(ensures
(let (c1, res1) = c1_res1 in
let (c, res) = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in
v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i))
let bn_add_lemma_loop_step #t #aLen a b i (c1, res1) =
let pbits = bits t in
let (c, res) = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in
let c, e = bn_add_f a b (i - 1) c1 in
assert (v e + v c * pow2 pbits == v a.[i - 1] + v b.[i - 1] + v c1);
calc (==) {
v c * pow2 (pbits * i) + bn_v #t #i res;
(==) { bn_eval_snoc #t #(i - 1) res1 e }
v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1));
(==) { }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) - (v e + v c * pow2 pbits - v a.[i - 1] - v b.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1] - v b.[i - 1]) (pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v e - v e - v c * pow2 pbits + v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1] + v b.[i - 1]) (v c1 * pow2 pbits) (pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_add_left (v a.[i - 1]) (v b.[i - 1]) (pow2 (pbits * (i - 1))) }
eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + v a.[i - 1] * pow2 (pbits * (i - 1)) + v b.[i - 1] * pow2 (pbits * (i - 1));
(==) { bn_eval_unfold_i #t #aLen a i }
eval_ aLen a i + eval_ aLen b (i - 1) + v b.[i - 1] * pow2 (pbits * (i - 1));
(==) { bn_eval_unfold_i #t #aLen b i }
eval_ aLen a i + eval_ aLen b i;
};
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i)
val bn_add_lemma_loop:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> b:lbignum t aLen
-> i:nat{i <= aLen} ->
Lemma (let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_f a b) (uint #t 0) in
v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i)
let rec bn_add_lemma_loop #t #aLen a b i =
let pbits = bits t in
let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_f a b) (uint #t 0) in
if i = 0 then begin
eq_generate_elems0 aLen i (bn_add_f a b) (uint #t 0);
assert (c == uint #t 0 /\ res == Seq.empty);
bn_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
bn_eval0 b;
() end
else begin
let (c1, res1) : generate_elem_a (limb t) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_add_f a b) (uint #t 0) in
generate_elems_unfold aLen i (bn_add_f a b) (uint #t 0) (i - 1);
assert (generate_elems aLen i (bn_add_f a b) (uint #t 0) ==
generate_elem_f aLen (bn_add_f a b) (i - 1) (generate_elems aLen (i - 1) (bn_add_f a b) (uint #t 0)));
assert ((c, res) == generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1));
bn_add_lemma_loop a b (i - 1);
assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + eval_ aLen b (i - 1));
bn_add_lemma_loop_step a b i (c1, res1);
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i);
() end
val bn_add_concat_lemma:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat{bLen < aLen}
-> a:lbignum t aLen
-> b:lbignum t bLen
-> c0:carry t
-> res0:lbignum t bLen -> Lemma
(requires
v c0 * pow2 (bits t * bLen) + bn_v #t #bLen res0 == eval_ bLen (sub a 0 bLen) bLen + eval_ bLen b bLen)
(ensures
(let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in
let res = concat #_ #bLen res0 res1 in
bn_v res == eval_ aLen a aLen + eval_ bLen b bLen - v c1 * pow2 (bits t * aLen)))
let bn_add_concat_lemma #t #aLen #bLen a b c0 res0 =
let pbits = bits t in
let a0 = sub a 0 bLen in
let a1 = sub a bLen (aLen - bLen) in
let c1, res1 = bn_add_carry a1 c0 in
bn_add_carry_lemma a1 c0;
assert (v c1 * pow2 (pbits * (aLen - bLen)) + bn_v res1 == bn_v a1 + v c0);
let res = concat #_ #bLen res0 res1 in
bn_concat_lemma res0 res1;
assert (bn_v res == bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1);
calc (==) {
bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1;
(==) { }
eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0 - v c1 * pow2 (pbits * (aLen - bLen)));
(==) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * bLen)) (bn_v a1 + v c0) (v c1 * pow2 (pbits * (aLen - bLen))) }
eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0) - pow2 (pbits * bLen) * v c1 * pow2 (pbits * (aLen - bLen));
(==) { Math.Lemmas.paren_mul_right (pow2 (pbits * bLen)) (v c1) (pow2 (pbits * (aLen - bLen))); Math.Lemmas.pow2_plus (pbits * bLen) (pbits * (aLen - bLen)) }
eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0) - v c1 * pow2 (pbits * aLen);
(==) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * bLen)) (bn_v a1) (v c0) }
eval_ bLen a0 bLen + eval_ bLen b bLen + pow2 (pbits * bLen) * bn_v a1 - v c1 * pow2 (pbits * aLen);
(==) { bn_eval_split_i a bLen; bn_eval_extensionality_j a (sub a 0 bLen) bLen }
eval_ aLen a aLen + eval_ bLen b bLen - v c1 * pow2 (pbits * aLen);
}
val bn_add_lemma:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat{bLen <= aLen}
-> a:lbignum t aLen
-> b:lbignum t bLen ->
Lemma (let (c, res) = bn_add a b in
v c * pow2 (bits t * aLen) + bn_v res == bn_v a + bn_v b)
let bn_add_lemma #t #aLen #bLen a b =
let pbits = bits t in
let (c, res) = bn_add a b in
if bLen = aLen then
bn_add_lemma_loop a b aLen
else begin
let a0 = sub a 0 bLen in
let a1 = sub a bLen (aLen - bLen) in
let c0, res0 = generate_elems bLen bLen (bn_add_f a0 b) (uint #t 0) in
bn_add_lemma_loop a0 b bLen;
assert (v c0 * pow2 (pbits * bLen) + bn_v #t #bLen res0 == eval_ bLen a0 bLen + eval_ bLen b bLen);
bn_add_concat_lemma #t #aLen #bLen a b c0 res0 end
val bn_add1_lemma:
#t:limb_t
-> #aLen:size_pos
-> a:lbignum t aLen
-> b1:limb t ->
Lemma (let (c, res) = bn_add1 a b1 in
v c * pow2 (bits t * aLen) + bn_v res == bn_v a + v b1) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Addition.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | a: Hacl.Spec.Bignum.Definitions.lbignum t aLen -> b1: Hacl.Spec.Bignum.Definitions.limb t
-> FStar.Pervasives.Lemma
(ensures
(let _ = Hacl.Spec.Bignum.Addition.bn_add1 a b1 in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ c res = _ in
Lib.IntTypes.v c * Prims.pow2 (Lib.IntTypes.bits t * aLen) +
Hacl.Spec.Bignum.Definitions.bn_v res ==
Hacl.Spec.Bignum.Definitions.bn_v a + Lib.IntTypes.v b1)
<:
Type0)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_pos",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Definitions.limb",
"Hacl.Spec.Bignum.Base.carry",
"Prims.op_Equality",
"Prims.int",
"Hacl.Spec.Bignum.Definitions.bn_eval1",
"Prims.bool",
"Hacl.Spec.Bignum.Addition.bn_add_concat_lemma",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Prims.pow2",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Hacl.Spec.Bignum.Definitions.eval_",
"Lib.Sequence.lseq",
"Prims.l_and",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.slice",
"Prims.l_Forall",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.index",
"Lib.Sequence.sub",
"FStar.Seq.Base.create",
"Prims.l_imp",
"Lib.Sequence.create",
"Lib.Sequence.op_String_Access",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.Bignum.Base.addcarry",
"Lib.IntTypes.uint",
"Lib.IntTypes.bits"
] | [] | false | false | true | false | false | let bn_add1_lemma #t #aLen a b1 =
| let pbits = bits t in
let c0, r0 = addcarry (uint #t 0) a.[ 0 ] b1 in
assert (v c0 * pow2 pbits + v r0 = v a.[ 0 ] + v b1);
let res0 = create 1 r0 in
let b = create 1 b1 in
bn_eval1 res0;
bn_eval1 b;
if aLen = 1
then bn_eval1 a
else
let bLen = 1 in
let a0 = sub a 0 bLen in
bn_eval1 a0;
assert (v c0 * pow2 (pbits * bLen) + bn_v #t #1 res0 == eval_ bLen a0 bLen + eval_ bLen b bLen);
bn_add_concat_lemma a b c0 res0 | false |
Hacl.Spec.Bignum.Addition.fst | Hacl.Spec.Bignum.Addition.bn_add_lemma | val bn_add_lemma:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat{bLen <= aLen}
-> a:lbignum t aLen
-> b:lbignum t bLen ->
Lemma (let (c, res) = bn_add a b in
v c * pow2 (bits t * aLen) + bn_v res == bn_v a + bn_v b) | val bn_add_lemma:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat{bLen <= aLen}
-> a:lbignum t aLen
-> b:lbignum t bLen ->
Lemma (let (c, res) = bn_add a b in
v c * pow2 (bits t * aLen) + bn_v res == bn_v a + bn_v b) | let bn_add_lemma #t #aLen #bLen a b =
let pbits = bits t in
let (c, res) = bn_add a b in
if bLen = aLen then
bn_add_lemma_loop a b aLen
else begin
let a0 = sub a 0 bLen in
let a1 = sub a bLen (aLen - bLen) in
let c0, res0 = generate_elems bLen bLen (bn_add_f a0 b) (uint #t 0) in
bn_add_lemma_loop a0 b bLen;
assert (v c0 * pow2 (pbits * bLen) + bn_v #t #bLen res0 == eval_ bLen a0 bLen + eval_ bLen b bLen);
bn_add_concat_lemma #t #aLen #bLen a b c0 res0 end | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Addition.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 54,
"end_line": 291,
"start_col": 0,
"start_line": 279
} | module Hacl.Spec.Bignum.Addition
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_sub_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t
let bn_sub_carry_f #t #aLen a i c_in = subborrow c_in a.[i] (uint #t 0)
val bn_sub_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen)
let bn_sub_carry #t #aLen a c_in = generate_elems aLen aLen (bn_sub_carry_f a) c_in
val bn_sub_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t
let bn_sub_f #t #aLen a b i c = subborrow c a.[i] b.[i]
val bn_sub: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> tuple2 (carry t) (lbignum t aLen)
let bn_sub #t #aLen #bLen a b =
let c0, res0 = generate_elems bLen bLen (bn_sub_f (sub a 0 bLen) b) (uint #t 0) in
if bLen < aLen then
let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in
c1, concat #_ #bLen res0 res1
else c0, res0
val bn_sub1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen)
let bn_sub1 #t #aLen a b1 =
let c0, r0 = subborrow (uint #t 0) a.[0] b1 in
let res0 = create 1 r0 in
if 1 < aLen then
let c1, res1 = bn_sub_carry (sub a 1 (aLen - 1)) c0 in
c1, concat res0 res1
else c0, res0
val bn_add_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t
let bn_add_carry_f #t #aLen a i c_in = addcarry c_in a.[i] (uint #t 0)
val bn_add_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen)
let bn_add_carry #t #aLen a c_in = generate_elems aLen aLen (bn_add_carry_f a) c_in
val bn_add_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t
let bn_add_f #t #aLen a b i c = addcarry c a.[i] b.[i]
val bn_add: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> carry t & lbignum t aLen
let bn_add #t #aLen #bLen a b =
let c0, res0 = generate_elems bLen bLen (bn_add_f (sub a 0 bLen) b) (uint #t 0) in
if bLen < aLen then
let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in
c1, concat #_ #bLen res0 res1
else c0, res0
val bn_add1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen)
let bn_add1 #t #aLen a b1 =
let c0, r0 = addcarry (uint #t 0) a.[0] b1 in
let res0 = create 1 r0 in
if 1 < aLen then
let c1, res1 = bn_add_carry (sub a 1 (aLen - 1)) c0 in
c1, concat res0 res1
else c0, res0
val bn_add_carry_lemma_loop_step:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> c_in:carry t
-> i:pos{i <= aLen}
-> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma
(requires
(let (c1, res1) = c1_res1 in
v c1 * pow2 (bits t * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + v c_in))
(ensures
(let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) c1_res1 in
v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in))
let bn_add_carry_lemma_loop_step #t #aLen a c_in i (c1, res1) =
let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1) in
let c, e = bn_add_carry_f a (i - 1) c1 in
assert (v e + v c * pow2 (bits t) == v a.[i - 1] + v c1);
let pbits = bits t in
calc (==) {
v c * pow2 (pbits * i) + bn_v #t #i res;
(==) { bn_eval_snoc #t #(i - 1) res1 e }
v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1));
(==) { }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in - (v e + v c * pow2 pbits - v a.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1]) (pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + (v e - v e - v c * pow2 pbits + v a.[i - 1]) * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1));
(==) { bn_eval_unfold_i #t #aLen a i }
eval_ aLen a i + v c_in;
};
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in)
val bn_add_carry_lemma_loop:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> c_in:carry t
-> i:nat{i <= aLen} ->
Lemma (let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in
v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in)
let rec bn_add_carry_lemma_loop #t #aLen a c_in i =
let pbits = bits t in
let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in
if i = 0 then begin
eq_generate_elems0 aLen i (bn_add_carry_f a) c_in;
assert (c_out == c_in /\ res == Seq.empty);
bn_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
() end
else begin
let (c1, res1) : generate_elem_a (limb t) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_add_carry_f a) c_in in
generate_elems_unfold aLen i (bn_add_carry_f a) c_in (i - 1);
assert (generate_elems aLen i (bn_add_carry_f a) c_in ==
generate_elem_f aLen (bn_add_carry_f a) (i - 1) (generate_elems aLen (i - 1) (bn_add_carry_f a) c_in));
assert ((c_out, res) == generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1));
bn_add_carry_lemma_loop a c_in (i - 1);
assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + v c_in);
bn_add_carry_lemma_loop_step a c_in i (c1, res1);
assert (v c_out * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in);
() end
val bn_add_carry_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t ->
Lemma (let (c_out, res) = bn_add_carry a c_in in
v c_out * pow2 (bits t * aLen) + bn_v res == bn_v a + v c_in)
let bn_add_carry_lemma #t #aLen a c_in =
let (c_out, res) = bn_add_carry a c_in in
bn_add_carry_lemma_loop a c_in aLen
val bn_add_lemma_loop_step:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> b:lbignum t aLen
-> i:pos{i <= aLen}
-> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma
(requires
(let (c1, res1) = c1_res1 in
v c1 * pow2 (bits t * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + eval_ aLen b (i - 1)))
(ensures
(let (c1, res1) = c1_res1 in
let (c, res) = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in
v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i))
let bn_add_lemma_loop_step #t #aLen a b i (c1, res1) =
let pbits = bits t in
let (c, res) = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in
let c, e = bn_add_f a b (i - 1) c1 in
assert (v e + v c * pow2 pbits == v a.[i - 1] + v b.[i - 1] + v c1);
calc (==) {
v c * pow2 (pbits * i) + bn_v #t #i res;
(==) { bn_eval_snoc #t #(i - 1) res1 e }
v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1));
(==) { }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) - (v e + v c * pow2 pbits - v a.[i - 1] - v b.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1] - v b.[i - 1]) (pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v e - v e - v c * pow2 pbits + v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1] + v b.[i - 1]) (v c1 * pow2 pbits) (pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_add_left (v a.[i - 1]) (v b.[i - 1]) (pow2 (pbits * (i - 1))) }
eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + v a.[i - 1] * pow2 (pbits * (i - 1)) + v b.[i - 1] * pow2 (pbits * (i - 1));
(==) { bn_eval_unfold_i #t #aLen a i }
eval_ aLen a i + eval_ aLen b (i - 1) + v b.[i - 1] * pow2 (pbits * (i - 1));
(==) { bn_eval_unfold_i #t #aLen b i }
eval_ aLen a i + eval_ aLen b i;
};
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i)
val bn_add_lemma_loop:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> b:lbignum t aLen
-> i:nat{i <= aLen} ->
Lemma (let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_f a b) (uint #t 0) in
v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i)
let rec bn_add_lemma_loop #t #aLen a b i =
let pbits = bits t in
let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_f a b) (uint #t 0) in
if i = 0 then begin
eq_generate_elems0 aLen i (bn_add_f a b) (uint #t 0);
assert (c == uint #t 0 /\ res == Seq.empty);
bn_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
bn_eval0 b;
() end
else begin
let (c1, res1) : generate_elem_a (limb t) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_add_f a b) (uint #t 0) in
generate_elems_unfold aLen i (bn_add_f a b) (uint #t 0) (i - 1);
assert (generate_elems aLen i (bn_add_f a b) (uint #t 0) ==
generate_elem_f aLen (bn_add_f a b) (i - 1) (generate_elems aLen (i - 1) (bn_add_f a b) (uint #t 0)));
assert ((c, res) == generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1));
bn_add_lemma_loop a b (i - 1);
assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + eval_ aLen b (i - 1));
bn_add_lemma_loop_step a b i (c1, res1);
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i);
() end
val bn_add_concat_lemma:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat{bLen < aLen}
-> a:lbignum t aLen
-> b:lbignum t bLen
-> c0:carry t
-> res0:lbignum t bLen -> Lemma
(requires
v c0 * pow2 (bits t * bLen) + bn_v #t #bLen res0 == eval_ bLen (sub a 0 bLen) bLen + eval_ bLen b bLen)
(ensures
(let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in
let res = concat #_ #bLen res0 res1 in
bn_v res == eval_ aLen a aLen + eval_ bLen b bLen - v c1 * pow2 (bits t * aLen)))
let bn_add_concat_lemma #t #aLen #bLen a b c0 res0 =
let pbits = bits t in
let a0 = sub a 0 bLen in
let a1 = sub a bLen (aLen - bLen) in
let c1, res1 = bn_add_carry a1 c0 in
bn_add_carry_lemma a1 c0;
assert (v c1 * pow2 (pbits * (aLen - bLen)) + bn_v res1 == bn_v a1 + v c0);
let res = concat #_ #bLen res0 res1 in
bn_concat_lemma res0 res1;
assert (bn_v res == bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1);
calc (==) {
bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1;
(==) { }
eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0 - v c1 * pow2 (pbits * (aLen - bLen)));
(==) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * bLen)) (bn_v a1 + v c0) (v c1 * pow2 (pbits * (aLen - bLen))) }
eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0) - pow2 (pbits * bLen) * v c1 * pow2 (pbits * (aLen - bLen));
(==) { Math.Lemmas.paren_mul_right (pow2 (pbits * bLen)) (v c1) (pow2 (pbits * (aLen - bLen))); Math.Lemmas.pow2_plus (pbits * bLen) (pbits * (aLen - bLen)) }
eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0) - v c1 * pow2 (pbits * aLen);
(==) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * bLen)) (bn_v a1) (v c0) }
eval_ bLen a0 bLen + eval_ bLen b bLen + pow2 (pbits * bLen) * bn_v a1 - v c1 * pow2 (pbits * aLen);
(==) { bn_eval_split_i a bLen; bn_eval_extensionality_j a (sub a 0 bLen) bLen }
eval_ aLen a aLen + eval_ bLen b bLen - v c1 * pow2 (pbits * aLen);
}
val bn_add_lemma:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat{bLen <= aLen}
-> a:lbignum t aLen
-> b:lbignum t bLen ->
Lemma (let (c, res) = bn_add a b in
v c * pow2 (bits t * aLen) + bn_v res == bn_v a + bn_v b) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Addition.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | a: Hacl.Spec.Bignum.Definitions.lbignum t aLen -> b: Hacl.Spec.Bignum.Definitions.lbignum t bLen
-> FStar.Pervasives.Lemma
(ensures
(let _ = Hacl.Spec.Bignum.Addition.bn_add a b in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ c res = _ in
Lib.IntTypes.v c * Prims.pow2 (Lib.IntTypes.bits t * aLen) +
Hacl.Spec.Bignum.Definitions.bn_v res ==
Hacl.Spec.Bignum.Definitions.bn_v a + Hacl.Spec.Bignum.Definitions.bn_v b)
<:
Type0)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Base.carry",
"Prims.op_Equality",
"Hacl.Spec.Bignum.Addition.bn_add_lemma_loop",
"Prims.bool",
"Lib.Sequence.seq",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.eq2",
"Prims.nat",
"Lib.Sequence.length",
"Hacl.Spec.Bignum.Addition.bn_add_concat_lemma",
"Prims.unit",
"Prims._assert",
"Prims.int",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Prims.pow2",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Hacl.Spec.Bignum.Definitions.eval_",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.Lib.generate_elems",
"Hacl.Spec.Bignum.Addition.bn_add_f",
"Lib.IntTypes.uint",
"Lib.Sequence.lseq",
"Prims.op_Subtraction",
"Prims.l_and",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.slice",
"Prims.l_Forall",
"Prims.op_LessThan",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.index",
"Lib.Sequence.sub",
"Hacl.Spec.Bignum.Addition.bn_add",
"Lib.IntTypes.bits"
] | [] | false | false | true | false | false | let bn_add_lemma #t #aLen #bLen a b =
| let pbits = bits t in
let c, res = bn_add a b in
if bLen = aLen
then bn_add_lemma_loop a b aLen
else
let a0 = sub a 0 bLen in
let a1 = sub a bLen (aLen - bLen) in
let c0, res0 = generate_elems bLen bLen (bn_add_f a0 b) (uint #t 0) in
bn_add_lemma_loop a0 b bLen;
assert (v c0 * pow2 (pbits * bLen) + bn_v #t #bLen res0 == eval_ bLen a0 bLen + eval_ bLen b bLen);
bn_add_concat_lemma #t #aLen #bLen a b c0 res0 | false |
Hacl.Spec.Bignum.Addition.fst | Hacl.Spec.Bignum.Addition.bn_add_lemma_loop | val bn_add_lemma_loop:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> b:lbignum t aLen
-> i:nat{i <= aLen} ->
Lemma (let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_f a b) (uint #t 0) in
v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i) | val bn_add_lemma_loop:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> b:lbignum t aLen
-> i:nat{i <= aLen} ->
Lemma (let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_f a b) (uint #t 0) in
v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i) | let rec bn_add_lemma_loop #t #aLen a b i =
let pbits = bits t in
let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_f a b) (uint #t 0) in
if i = 0 then begin
eq_generate_elems0 aLen i (bn_add_f a b) (uint #t 0);
assert (c == uint #t 0 /\ res == Seq.empty);
bn_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
bn_eval0 b;
() end
else begin
let (c1, res1) : generate_elem_a (limb t) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_add_f a b) (uint #t 0) in
generate_elems_unfold aLen i (bn_add_f a b) (uint #t 0) (i - 1);
assert (generate_elems aLen i (bn_add_f a b) (uint #t 0) ==
generate_elem_f aLen (bn_add_f a b) (i - 1) (generate_elems aLen (i - 1) (bn_add_f a b) (uint #t 0)));
assert ((c, res) == generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1));
bn_add_lemma_loop a b (i - 1);
assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + eval_ aLen b (i - 1));
bn_add_lemma_loop_step a b i (c1, res1);
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i);
() end | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Addition.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 10,
"end_line": 225,
"start_col": 0,
"start_line": 204
} | module Hacl.Spec.Bignum.Addition
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_sub_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t
let bn_sub_carry_f #t #aLen a i c_in = subborrow c_in a.[i] (uint #t 0)
val bn_sub_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen)
let bn_sub_carry #t #aLen a c_in = generate_elems aLen aLen (bn_sub_carry_f a) c_in
val bn_sub_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t
let bn_sub_f #t #aLen a b i c = subborrow c a.[i] b.[i]
val bn_sub: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> tuple2 (carry t) (lbignum t aLen)
let bn_sub #t #aLen #bLen a b =
let c0, res0 = generate_elems bLen bLen (bn_sub_f (sub a 0 bLen) b) (uint #t 0) in
if bLen < aLen then
let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in
c1, concat #_ #bLen res0 res1
else c0, res0
val bn_sub1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen)
let bn_sub1 #t #aLen a b1 =
let c0, r0 = subborrow (uint #t 0) a.[0] b1 in
let res0 = create 1 r0 in
if 1 < aLen then
let c1, res1 = bn_sub_carry (sub a 1 (aLen - 1)) c0 in
c1, concat res0 res1
else c0, res0
val bn_add_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t
let bn_add_carry_f #t #aLen a i c_in = addcarry c_in a.[i] (uint #t 0)
val bn_add_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen)
let bn_add_carry #t #aLen a c_in = generate_elems aLen aLen (bn_add_carry_f a) c_in
val bn_add_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t
let bn_add_f #t #aLen a b i c = addcarry c a.[i] b.[i]
val bn_add: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> carry t & lbignum t aLen
let bn_add #t #aLen #bLen a b =
let c0, res0 = generate_elems bLen bLen (bn_add_f (sub a 0 bLen) b) (uint #t 0) in
if bLen < aLen then
let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in
c1, concat #_ #bLen res0 res1
else c0, res0
val bn_add1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen)
let bn_add1 #t #aLen a b1 =
let c0, r0 = addcarry (uint #t 0) a.[0] b1 in
let res0 = create 1 r0 in
if 1 < aLen then
let c1, res1 = bn_add_carry (sub a 1 (aLen - 1)) c0 in
c1, concat res0 res1
else c0, res0
val bn_add_carry_lemma_loop_step:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> c_in:carry t
-> i:pos{i <= aLen}
-> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma
(requires
(let (c1, res1) = c1_res1 in
v c1 * pow2 (bits t * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + v c_in))
(ensures
(let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) c1_res1 in
v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in))
let bn_add_carry_lemma_loop_step #t #aLen a c_in i (c1, res1) =
let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1) in
let c, e = bn_add_carry_f a (i - 1) c1 in
assert (v e + v c * pow2 (bits t) == v a.[i - 1] + v c1);
let pbits = bits t in
calc (==) {
v c * pow2 (pbits * i) + bn_v #t #i res;
(==) { bn_eval_snoc #t #(i - 1) res1 e }
v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1));
(==) { }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in - (v e + v c * pow2 pbits - v a.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1]) (pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + (v e - v e - v c * pow2 pbits + v a.[i - 1]) * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1));
(==) { bn_eval_unfold_i #t #aLen a i }
eval_ aLen a i + v c_in;
};
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in)
val bn_add_carry_lemma_loop:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> c_in:carry t
-> i:nat{i <= aLen} ->
Lemma (let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in
v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in)
let rec bn_add_carry_lemma_loop #t #aLen a c_in i =
let pbits = bits t in
let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in
if i = 0 then begin
eq_generate_elems0 aLen i (bn_add_carry_f a) c_in;
assert (c_out == c_in /\ res == Seq.empty);
bn_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
() end
else begin
let (c1, res1) : generate_elem_a (limb t) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_add_carry_f a) c_in in
generate_elems_unfold aLen i (bn_add_carry_f a) c_in (i - 1);
assert (generate_elems aLen i (bn_add_carry_f a) c_in ==
generate_elem_f aLen (bn_add_carry_f a) (i - 1) (generate_elems aLen (i - 1) (bn_add_carry_f a) c_in));
assert ((c_out, res) == generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1));
bn_add_carry_lemma_loop a c_in (i - 1);
assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + v c_in);
bn_add_carry_lemma_loop_step a c_in i (c1, res1);
assert (v c_out * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in);
() end
val bn_add_carry_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t ->
Lemma (let (c_out, res) = bn_add_carry a c_in in
v c_out * pow2 (bits t * aLen) + bn_v res == bn_v a + v c_in)
let bn_add_carry_lemma #t #aLen a c_in =
let (c_out, res) = bn_add_carry a c_in in
bn_add_carry_lemma_loop a c_in aLen
val bn_add_lemma_loop_step:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> b:lbignum t aLen
-> i:pos{i <= aLen}
-> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma
(requires
(let (c1, res1) = c1_res1 in
v c1 * pow2 (bits t * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + eval_ aLen b (i - 1)))
(ensures
(let (c1, res1) = c1_res1 in
let (c, res) = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in
v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i))
let bn_add_lemma_loop_step #t #aLen a b i (c1, res1) =
let pbits = bits t in
let (c, res) = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in
let c, e = bn_add_f a b (i - 1) c1 in
assert (v e + v c * pow2 pbits == v a.[i - 1] + v b.[i - 1] + v c1);
calc (==) {
v c * pow2 (pbits * i) + bn_v #t #i res;
(==) { bn_eval_snoc #t #(i - 1) res1 e }
v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1));
(==) { }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) - (v e + v c * pow2 pbits - v a.[i - 1] - v b.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1] - v b.[i - 1]) (pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v e - v e - v c * pow2 pbits + v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1] + v b.[i - 1]) (v c1 * pow2 pbits) (pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_add_left (v a.[i - 1]) (v b.[i - 1]) (pow2 (pbits * (i - 1))) }
eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + v a.[i - 1] * pow2 (pbits * (i - 1)) + v b.[i - 1] * pow2 (pbits * (i - 1));
(==) { bn_eval_unfold_i #t #aLen a i }
eval_ aLen a i + eval_ aLen b (i - 1) + v b.[i - 1] * pow2 (pbits * (i - 1));
(==) { bn_eval_unfold_i #t #aLen b i }
eval_ aLen a i + eval_ aLen b i;
};
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i)
val bn_add_lemma_loop:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> b:lbignum t aLen
-> i:nat{i <= aLen} ->
Lemma (let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_f a b) (uint #t 0) in
v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Addition.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Hacl.Spec.Bignum.Definitions.lbignum t aLen ->
b: Hacl.Spec.Bignum.Definitions.lbignum t aLen ->
i: Prims.nat{i <= aLen}
-> FStar.Pervasives.Lemma
(ensures
(let _ =
Hacl.Spec.Lib.generate_elems aLen
i
(Hacl.Spec.Bignum.Addition.bn_add_f a b)
(Lib.IntTypes.uint 0)
in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ c res = _ in
let _ = _ in
Lib.IntTypes.v c * Prims.pow2 (Lib.IntTypes.bits t * i) +
Hacl.Spec.Bignum.Definitions.bn_v res ==
Hacl.Spec.Bignum.Definitions.eval_ aLen a i + Hacl.Spec.Bignum.Definitions.eval_ aLen b i)
<:
Type0)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Hacl.Spec.Bignum.Base.carry",
"Lib.Sequence.seq",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.eq2",
"Lib.Sequence.length",
"Prims.op_Equality",
"Prims.int",
"Prims.unit",
"Hacl.Spec.Bignum.Definitions.bn_eval0",
"FStar.Pervasives.assert_norm",
"Prims.pow2",
"Prims._assert",
"Prims.l_and",
"Lib.IntTypes.int_t",
"Lib.IntTypes.SEC",
"Prims.l_or",
"Lib.IntTypes.uint_v",
"Lib.IntTypes.range",
"Lib.IntTypes.v",
"Lib.IntTypes.uint",
"FStar.Seq.Base.seq",
"FStar.Seq.Base.length",
"FStar.Seq.Base.empty",
"Hacl.Spec.Lib.eq_generate_elems0",
"Hacl.Spec.Bignum.Addition.bn_add_f",
"Prims.bool",
"Prims.op_Subtraction",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Hacl.Spec.Bignum.Definitions.eval_",
"Hacl.Spec.Bignum.Addition.bn_add_lemma_loop_step",
"FStar.Pervasives.Native.Mktuple2",
"Hacl.Spec.Bignum.Addition.bn_add_lemma_loop",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.Lib.generate_elem_f",
"Hacl.Spec.Lib.generate_elems",
"Hacl.Spec.Lib.generate_elems_unfold",
"Hacl.Spec.Lib.generate_elem_a",
"Lib.IntTypes.bits"
] | [
"recursion"
] | false | false | true | false | false | let rec bn_add_lemma_loop #t #aLen a b i =
| let pbits = bits t in
let c, res:generate_elem_a (limb t) (carry t) aLen i =
generate_elems aLen i (bn_add_f a b) (uint #t 0)
in
if i = 0
then
(eq_generate_elems0 aLen i (bn_add_f a b) (uint #t 0);
assert (c == uint #t 0 /\ res == Seq.empty);
bn_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
bn_eval0 b;
())
else
let c1, res1:generate_elem_a (limb t) (carry t) aLen (i - 1) =
generate_elems aLen (i - 1) (bn_add_f a b) (uint #t 0)
in
generate_elems_unfold aLen i (bn_add_f a b) (uint #t 0) (i - 1);
assert (generate_elems aLen i (bn_add_f a b) (uint #t 0) ==
generate_elem_f aLen
(bn_add_f a b)
(i - 1)
(generate_elems aLen (i - 1) (bn_add_f a b) (uint #t 0)));
assert ((c, res) == generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1));
bn_add_lemma_loop a b (i - 1);
assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 ==
eval_ aLen a (i - 1) + eval_ aLen b (i - 1));
bn_add_lemma_loop_step a b i (c1, res1);
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i);
() | false |
Hacl.Spec.Bignum.Addition.fst | Hacl.Spec.Bignum.Addition.bn_sub_carry_lemma_loop | val bn_sub_carry_lemma_loop:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> c_in:carry t
-> i:nat{i <= aLen} ->
Lemma (let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_sub_carry_f a) c_in in
bn_v #t #i res - v c_out * pow2 (bits t * i) == eval_ aLen a i - v c_in) | val bn_sub_carry_lemma_loop:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> c_in:carry t
-> i:nat{i <= aLen} ->
Lemma (let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_sub_carry_f a) c_in in
bn_v #t #i res - v c_out * pow2 (bits t * i) == eval_ aLen a i - v c_in) | let rec bn_sub_carry_lemma_loop #t #aLen a c_in i =
let pbits = bits t in
let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_sub_carry_f a) c_in in
if i = 0 then begin
eq_generate_elems0 aLen i (bn_sub_carry_f a) c_in;
assert (c_out == c_in /\ res == Seq.empty);
bn_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
() end
else begin
let (c1, res1) : generate_elem_a (limb t) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_sub_carry_f a) c_in in
generate_elems_unfold aLen i (bn_sub_carry_f a) c_in (i - 1);
assert (generate_elems aLen i (bn_sub_carry_f a) c_in ==
generate_elem_f aLen (bn_sub_carry_f a) (i - 1) (generate_elems aLen (i - 1) (bn_sub_carry_f a) c_in));
assert ((c_out, res) == generate_elem_f aLen (bn_sub_carry_f a) (i - 1) (c1, res1));
bn_sub_carry_lemma_loop a c_in (i - 1);
assert (bn_v #t #(i - 1) res1 - v c1 * pow2 (pbits * (i - 1)) == eval_ aLen a (i - 1) - v c_in);
bn_sub_carry_lemma_loop_step a c_in i (c1, res1);
assert (bn_v #t #i res - v c_out * pow2 (pbits * i) == eval_ aLen a i - v c_in);
() end | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Addition.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 10,
"end_line": 390,
"start_col": 0,
"start_line": 370
} | module Hacl.Spec.Bignum.Addition
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_sub_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t
let bn_sub_carry_f #t #aLen a i c_in = subborrow c_in a.[i] (uint #t 0)
val bn_sub_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen)
let bn_sub_carry #t #aLen a c_in = generate_elems aLen aLen (bn_sub_carry_f a) c_in
val bn_sub_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t
let bn_sub_f #t #aLen a b i c = subborrow c a.[i] b.[i]
val bn_sub: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> tuple2 (carry t) (lbignum t aLen)
let bn_sub #t #aLen #bLen a b =
let c0, res0 = generate_elems bLen bLen (bn_sub_f (sub a 0 bLen) b) (uint #t 0) in
if bLen < aLen then
let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in
c1, concat #_ #bLen res0 res1
else c0, res0
val bn_sub1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen)
let bn_sub1 #t #aLen a b1 =
let c0, r0 = subborrow (uint #t 0) a.[0] b1 in
let res0 = create 1 r0 in
if 1 < aLen then
let c1, res1 = bn_sub_carry (sub a 1 (aLen - 1)) c0 in
c1, concat res0 res1
else c0, res0
val bn_add_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t
let bn_add_carry_f #t #aLen a i c_in = addcarry c_in a.[i] (uint #t 0)
val bn_add_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen)
let bn_add_carry #t #aLen a c_in = generate_elems aLen aLen (bn_add_carry_f a) c_in
val bn_add_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t
let bn_add_f #t #aLen a b i c = addcarry c a.[i] b.[i]
val bn_add: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> carry t & lbignum t aLen
let bn_add #t #aLen #bLen a b =
let c0, res0 = generate_elems bLen bLen (bn_add_f (sub a 0 bLen) b) (uint #t 0) in
if bLen < aLen then
let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in
c1, concat #_ #bLen res0 res1
else c0, res0
val bn_add1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen)
let bn_add1 #t #aLen a b1 =
let c0, r0 = addcarry (uint #t 0) a.[0] b1 in
let res0 = create 1 r0 in
if 1 < aLen then
let c1, res1 = bn_add_carry (sub a 1 (aLen - 1)) c0 in
c1, concat res0 res1
else c0, res0
val bn_add_carry_lemma_loop_step:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> c_in:carry t
-> i:pos{i <= aLen}
-> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma
(requires
(let (c1, res1) = c1_res1 in
v c1 * pow2 (bits t * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + v c_in))
(ensures
(let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) c1_res1 in
v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in))
let bn_add_carry_lemma_loop_step #t #aLen a c_in i (c1, res1) =
let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1) in
let c, e = bn_add_carry_f a (i - 1) c1 in
assert (v e + v c * pow2 (bits t) == v a.[i - 1] + v c1);
let pbits = bits t in
calc (==) {
v c * pow2 (pbits * i) + bn_v #t #i res;
(==) { bn_eval_snoc #t #(i - 1) res1 e }
v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1));
(==) { }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in - (v e + v c * pow2 pbits - v a.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1]) (pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + (v e - v e - v c * pow2 pbits + v a.[i - 1]) * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1));
(==) { bn_eval_unfold_i #t #aLen a i }
eval_ aLen a i + v c_in;
};
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in)
val bn_add_carry_lemma_loop:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> c_in:carry t
-> i:nat{i <= aLen} ->
Lemma (let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in
v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in)
let rec bn_add_carry_lemma_loop #t #aLen a c_in i =
let pbits = bits t in
let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in
if i = 0 then begin
eq_generate_elems0 aLen i (bn_add_carry_f a) c_in;
assert (c_out == c_in /\ res == Seq.empty);
bn_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
() end
else begin
let (c1, res1) : generate_elem_a (limb t) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_add_carry_f a) c_in in
generate_elems_unfold aLen i (bn_add_carry_f a) c_in (i - 1);
assert (generate_elems aLen i (bn_add_carry_f a) c_in ==
generate_elem_f aLen (bn_add_carry_f a) (i - 1) (generate_elems aLen (i - 1) (bn_add_carry_f a) c_in));
assert ((c_out, res) == generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1));
bn_add_carry_lemma_loop a c_in (i - 1);
assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + v c_in);
bn_add_carry_lemma_loop_step a c_in i (c1, res1);
assert (v c_out * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in);
() end
val bn_add_carry_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t ->
Lemma (let (c_out, res) = bn_add_carry a c_in in
v c_out * pow2 (bits t * aLen) + bn_v res == bn_v a + v c_in)
let bn_add_carry_lemma #t #aLen a c_in =
let (c_out, res) = bn_add_carry a c_in in
bn_add_carry_lemma_loop a c_in aLen
val bn_add_lemma_loop_step:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> b:lbignum t aLen
-> i:pos{i <= aLen}
-> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma
(requires
(let (c1, res1) = c1_res1 in
v c1 * pow2 (bits t * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + eval_ aLen b (i - 1)))
(ensures
(let (c1, res1) = c1_res1 in
let (c, res) = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in
v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i))
let bn_add_lemma_loop_step #t #aLen a b i (c1, res1) =
let pbits = bits t in
let (c, res) = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in
let c, e = bn_add_f a b (i - 1) c1 in
assert (v e + v c * pow2 pbits == v a.[i - 1] + v b.[i - 1] + v c1);
calc (==) {
v c * pow2 (pbits * i) + bn_v #t #i res;
(==) { bn_eval_snoc #t #(i - 1) res1 e }
v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1));
(==) { }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) - (v e + v c * pow2 pbits - v a.[i - 1] - v b.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1] - v b.[i - 1]) (pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v e - v e - v c * pow2 pbits + v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1] + v b.[i - 1]) (v c1 * pow2 pbits) (pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_add_left (v a.[i - 1]) (v b.[i - 1]) (pow2 (pbits * (i - 1))) }
eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + v a.[i - 1] * pow2 (pbits * (i - 1)) + v b.[i - 1] * pow2 (pbits * (i - 1));
(==) { bn_eval_unfold_i #t #aLen a i }
eval_ aLen a i + eval_ aLen b (i - 1) + v b.[i - 1] * pow2 (pbits * (i - 1));
(==) { bn_eval_unfold_i #t #aLen b i }
eval_ aLen a i + eval_ aLen b i;
};
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i)
val bn_add_lemma_loop:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> b:lbignum t aLen
-> i:nat{i <= aLen} ->
Lemma (let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_f a b) (uint #t 0) in
v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i)
let rec bn_add_lemma_loop #t #aLen a b i =
let pbits = bits t in
let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_f a b) (uint #t 0) in
if i = 0 then begin
eq_generate_elems0 aLen i (bn_add_f a b) (uint #t 0);
assert (c == uint #t 0 /\ res == Seq.empty);
bn_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
bn_eval0 b;
() end
else begin
let (c1, res1) : generate_elem_a (limb t) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_add_f a b) (uint #t 0) in
generate_elems_unfold aLen i (bn_add_f a b) (uint #t 0) (i - 1);
assert (generate_elems aLen i (bn_add_f a b) (uint #t 0) ==
generate_elem_f aLen (bn_add_f a b) (i - 1) (generate_elems aLen (i - 1) (bn_add_f a b) (uint #t 0)));
assert ((c, res) == generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1));
bn_add_lemma_loop a b (i - 1);
assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + eval_ aLen b (i - 1));
bn_add_lemma_loop_step a b i (c1, res1);
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i);
() end
val bn_add_concat_lemma:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat{bLen < aLen}
-> a:lbignum t aLen
-> b:lbignum t bLen
-> c0:carry t
-> res0:lbignum t bLen -> Lemma
(requires
v c0 * pow2 (bits t * bLen) + bn_v #t #bLen res0 == eval_ bLen (sub a 0 bLen) bLen + eval_ bLen b bLen)
(ensures
(let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in
let res = concat #_ #bLen res0 res1 in
bn_v res == eval_ aLen a aLen + eval_ bLen b bLen - v c1 * pow2 (bits t * aLen)))
let bn_add_concat_lemma #t #aLen #bLen a b c0 res0 =
let pbits = bits t in
let a0 = sub a 0 bLen in
let a1 = sub a bLen (aLen - bLen) in
let c1, res1 = bn_add_carry a1 c0 in
bn_add_carry_lemma a1 c0;
assert (v c1 * pow2 (pbits * (aLen - bLen)) + bn_v res1 == bn_v a1 + v c0);
let res = concat #_ #bLen res0 res1 in
bn_concat_lemma res0 res1;
assert (bn_v res == bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1);
calc (==) {
bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1;
(==) { }
eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0 - v c1 * pow2 (pbits * (aLen - bLen)));
(==) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * bLen)) (bn_v a1 + v c0) (v c1 * pow2 (pbits * (aLen - bLen))) }
eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0) - pow2 (pbits * bLen) * v c1 * pow2 (pbits * (aLen - bLen));
(==) { Math.Lemmas.paren_mul_right (pow2 (pbits * bLen)) (v c1) (pow2 (pbits * (aLen - bLen))); Math.Lemmas.pow2_plus (pbits * bLen) (pbits * (aLen - bLen)) }
eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0) - v c1 * pow2 (pbits * aLen);
(==) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * bLen)) (bn_v a1) (v c0) }
eval_ bLen a0 bLen + eval_ bLen b bLen + pow2 (pbits * bLen) * bn_v a1 - v c1 * pow2 (pbits * aLen);
(==) { bn_eval_split_i a bLen; bn_eval_extensionality_j a (sub a 0 bLen) bLen }
eval_ aLen a aLen + eval_ bLen b bLen - v c1 * pow2 (pbits * aLen);
}
val bn_add_lemma:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat{bLen <= aLen}
-> a:lbignum t aLen
-> b:lbignum t bLen ->
Lemma (let (c, res) = bn_add a b in
v c * pow2 (bits t * aLen) + bn_v res == bn_v a + bn_v b)
let bn_add_lemma #t #aLen #bLen a b =
let pbits = bits t in
let (c, res) = bn_add a b in
if bLen = aLen then
bn_add_lemma_loop a b aLen
else begin
let a0 = sub a 0 bLen in
let a1 = sub a bLen (aLen - bLen) in
let c0, res0 = generate_elems bLen bLen (bn_add_f a0 b) (uint #t 0) in
bn_add_lemma_loop a0 b bLen;
assert (v c0 * pow2 (pbits * bLen) + bn_v #t #bLen res0 == eval_ bLen a0 bLen + eval_ bLen b bLen);
bn_add_concat_lemma #t #aLen #bLen a b c0 res0 end
val bn_add1_lemma:
#t:limb_t
-> #aLen:size_pos
-> a:lbignum t aLen
-> b1:limb t ->
Lemma (let (c, res) = bn_add1 a b1 in
v c * pow2 (bits t * aLen) + bn_v res == bn_v a + v b1)
let bn_add1_lemma #t #aLen a b1 =
let pbits = bits t in
let c0, r0 = addcarry (uint #t 0) a.[0] b1 in
assert (v c0 * pow2 pbits + v r0 = v a.[0] + v b1);
let res0 = create 1 r0 in
let b = create 1 b1 in
bn_eval1 res0;
bn_eval1 b;
if aLen = 1 then
bn_eval1 a
else begin
let bLen = 1 in
let a0 = sub a 0 bLen in
bn_eval1 a0;
assert (v c0 * pow2 (pbits * bLen) + bn_v #t #1 res0 == eval_ bLen a0 bLen + eval_ bLen b bLen);
bn_add_concat_lemma a b c0 res0 end
val bn_sub_carry_lemma_loop_step:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> c_in:carry t
-> i:pos{i <= aLen}
-> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma
(requires
(let (c1, res1) = c1_res1 in
bn_v #t #(i - 1) res1 - v c1 * pow2 (bits t * (i - 1)) == eval_ aLen a (i - 1) - v c_in))
(ensures
(let (c_out, res) = generate_elem_f aLen (bn_sub_carry_f a) (i - 1) c1_res1 in
bn_v #t #i res - v c_out * pow2 (bits t * i) == eval_ aLen a i - v c_in))
let bn_sub_carry_lemma_loop_step #t #aLen a c_in i (c1, res1) =
let pbits = bits t in
let (c_out, res) = generate_elem_f aLen (bn_sub_carry_f a) (i - 1) (c1, res1) in
let c, e = bn_sub_carry_f a (i - 1) c1 in
assert (v e - v c * pow2 pbits == v a.[i - 1] - v c1);
calc (==) {
bn_v #t #i res - v c * pow2 (pbits * i);
(==) { bn_eval_snoc #t #(i - 1) res1 e }
bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i);
(==) { }
eval_ aLen a (i - 1) - v c_in + (v a.[i - 1] - v e + v c * pow2 pbits) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i);
(==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1] + v c * pow2 pbits) (v e) (pow2 (pbits * (i - 1))) }
eval_ aLen a (i - 1) - v c_in + (v a.[i - 1] + v c * pow2 pbits) * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i);
(==) { Math.Lemmas.distributivity_add_left (v a.[i - 1]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) }
eval_ aLen a (i - 1) - v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)) + v c * pow2 pbits * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i);
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen a (i - 1) - v c_in + v a.[i - 1] * pow2 (pbits * (i - 1));
(==) { bn_eval_unfold_i a i }
eval_ aLen a i - v c_in;
};
assert (bn_v #t #i res - v c * pow2 (pbits * i) == eval_ aLen a i - v c_in)
val bn_sub_carry_lemma_loop:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> c_in:carry t
-> i:nat{i <= aLen} ->
Lemma (let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_sub_carry_f a) c_in in
bn_v #t #i res - v c_out * pow2 (bits t * i) == eval_ aLen a i - v c_in) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Addition.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Hacl.Spec.Bignum.Definitions.lbignum t aLen ->
c_in: Hacl.Spec.Bignum.Base.carry t ->
i: Prims.nat{i <= aLen}
-> FStar.Pervasives.Lemma
(ensures
(let _ =
Hacl.Spec.Lib.generate_elems aLen i (Hacl.Spec.Bignum.Addition.bn_sub_carry_f a) c_in
in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ c_out res = _ in
let _ = _ in
Hacl.Spec.Bignum.Definitions.bn_v res -
Lib.IntTypes.v c_out * Prims.pow2 (Lib.IntTypes.bits t * i) ==
Hacl.Spec.Bignum.Definitions.eval_ aLen a i - Lib.IntTypes.v c_in)
<:
Type0)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Base.carry",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Lib.Sequence.seq",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.eq2",
"Lib.Sequence.length",
"Prims.op_Equality",
"Prims.int",
"Prims.unit",
"Hacl.Spec.Bignum.Definitions.bn_eval0",
"FStar.Pervasives.assert_norm",
"Prims.pow2",
"Prims._assert",
"Prims.l_and",
"FStar.Seq.Base.seq",
"Prims.l_or",
"FStar.Seq.Base.length",
"FStar.Seq.Base.empty",
"Hacl.Spec.Lib.eq_generate_elems0",
"Hacl.Spec.Bignum.Addition.bn_sub_carry_f",
"Prims.bool",
"Prims.op_Subtraction",
"Hacl.Spec.Bignum.Definitions.bn_v",
"FStar.Mul.op_Star",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Hacl.Spec.Bignum.Definitions.eval_",
"Hacl.Spec.Bignum.Addition.bn_sub_carry_lemma_loop_step",
"FStar.Pervasives.Native.Mktuple2",
"Hacl.Spec.Bignum.Addition.bn_sub_carry_lemma_loop",
"FStar.Pervasives.Native.tuple2",
"Prims.op_Addition",
"Hacl.Spec.Lib.generate_elem_f",
"Hacl.Spec.Lib.generate_elems",
"Hacl.Spec.Lib.generate_elems_unfold",
"Hacl.Spec.Lib.generate_elem_a",
"Lib.IntTypes.bits"
] | [
"recursion"
] | false | false | true | false | false | let rec bn_sub_carry_lemma_loop #t #aLen a c_in i =
| let pbits = bits t in
let c_out, res:generate_elem_a (limb t) (carry t) aLen i =
generate_elems aLen i (bn_sub_carry_f a) c_in
in
if i = 0
then
(eq_generate_elems0 aLen i (bn_sub_carry_f a) c_in;
assert (c_out == c_in /\ res == Seq.empty);
bn_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
())
else
let c1, res1:generate_elem_a (limb t) (carry t) aLen (i - 1) =
generate_elems aLen (i - 1) (bn_sub_carry_f a) c_in
in
generate_elems_unfold aLen i (bn_sub_carry_f a) c_in (i - 1);
assert (generate_elems aLen i (bn_sub_carry_f a) c_in ==
generate_elem_f aLen
(bn_sub_carry_f a)
(i - 1)
(generate_elems aLen (i - 1) (bn_sub_carry_f a) c_in));
assert ((c_out, res) == generate_elem_f aLen (bn_sub_carry_f a) (i - 1) (c1, res1));
bn_sub_carry_lemma_loop a c_in (i - 1);
assert (bn_v #t #(i - 1) res1 - v c1 * pow2 (pbits * (i - 1)) == eval_ aLen a (i - 1) - v c_in);
bn_sub_carry_lemma_loop_step a c_in i (c1, res1);
assert (bn_v #t #i res - v c_out * pow2 (pbits * i) == eval_ aLen a i - v c_in);
() | false |
Hacl.Spec.Bignum.Addition.fst | Hacl.Spec.Bignum.Addition.bn_sub1_lemma | val bn_sub1_lemma:
#t:limb_t
-> #aLen:size_pos
-> a:lbignum t aLen
-> b1:limb t ->
Lemma (let (c, res) = bn_sub1 a b1 in
bn_v res - v c * pow2 (bits t * aLen) == bn_v a - v b1) | val bn_sub1_lemma:
#t:limb_t
-> #aLen:size_pos
-> a:lbignum t aLen
-> b1:limb t ->
Lemma (let (c, res) = bn_sub1 a b1 in
bn_v res - v c * pow2 (bits t * aLen) == bn_v a - v b1) | let bn_sub1_lemma #t #aLen a b1 =
let pbits = bits t in
let c0, r0 = subborrow (uint #t 0) a.[0] b1 in
assert (v r0 - v c0 * pow2 pbits = v a.[0] - v b1);
let res0 = create 1 r0 in
let b = create 1 b1 in
bn_eval1 res0;
bn_eval1 b;
if aLen = 1 then
bn_eval1 a
else begin
let bLen = 1 in
let a0 = sub a 0 bLen in
bn_eval1 a0;
assert (bn_v #t #1 res0 - v c0 * pow2 (pbits * bLen) == eval_ bLen a0 bLen - eval_ bLen b bLen);
bn_sub_concat_lemma a b c0 res0 end | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Addition.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 39,
"end_line": 567,
"start_col": 0,
"start_line": 550
} | module Hacl.Spec.Bignum.Addition
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_sub_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t
let bn_sub_carry_f #t #aLen a i c_in = subborrow c_in a.[i] (uint #t 0)
val bn_sub_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen)
let bn_sub_carry #t #aLen a c_in = generate_elems aLen aLen (bn_sub_carry_f a) c_in
val bn_sub_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t
let bn_sub_f #t #aLen a b i c = subborrow c a.[i] b.[i]
val bn_sub: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> tuple2 (carry t) (lbignum t aLen)
let bn_sub #t #aLen #bLen a b =
let c0, res0 = generate_elems bLen bLen (bn_sub_f (sub a 0 bLen) b) (uint #t 0) in
if bLen < aLen then
let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in
c1, concat #_ #bLen res0 res1
else c0, res0
val bn_sub1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen)
let bn_sub1 #t #aLen a b1 =
let c0, r0 = subborrow (uint #t 0) a.[0] b1 in
let res0 = create 1 r0 in
if 1 < aLen then
let c1, res1 = bn_sub_carry (sub a 1 (aLen - 1)) c0 in
c1, concat res0 res1
else c0, res0
val bn_add_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t
let bn_add_carry_f #t #aLen a i c_in = addcarry c_in a.[i] (uint #t 0)
val bn_add_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen)
let bn_add_carry #t #aLen a c_in = generate_elems aLen aLen (bn_add_carry_f a) c_in
val bn_add_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t
let bn_add_f #t #aLen a b i c = addcarry c a.[i] b.[i]
val bn_add: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> carry t & lbignum t aLen
let bn_add #t #aLen #bLen a b =
let c0, res0 = generate_elems bLen bLen (bn_add_f (sub a 0 bLen) b) (uint #t 0) in
if bLen < aLen then
let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in
c1, concat #_ #bLen res0 res1
else c0, res0
val bn_add1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen)
let bn_add1 #t #aLen a b1 =
let c0, r0 = addcarry (uint #t 0) a.[0] b1 in
let res0 = create 1 r0 in
if 1 < aLen then
let c1, res1 = bn_add_carry (sub a 1 (aLen - 1)) c0 in
c1, concat res0 res1
else c0, res0
val bn_add_carry_lemma_loop_step:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> c_in:carry t
-> i:pos{i <= aLen}
-> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma
(requires
(let (c1, res1) = c1_res1 in
v c1 * pow2 (bits t * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + v c_in))
(ensures
(let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) c1_res1 in
v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in))
let bn_add_carry_lemma_loop_step #t #aLen a c_in i (c1, res1) =
let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1) in
let c, e = bn_add_carry_f a (i - 1) c1 in
assert (v e + v c * pow2 (bits t) == v a.[i - 1] + v c1);
let pbits = bits t in
calc (==) {
v c * pow2 (pbits * i) + bn_v #t #i res;
(==) { bn_eval_snoc #t #(i - 1) res1 e }
v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1));
(==) { }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in - (v e + v c * pow2 pbits - v a.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1]) (pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + (v e - v e - v c * pow2 pbits + v a.[i - 1]) * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1));
(==) { bn_eval_unfold_i #t #aLen a i }
eval_ aLen a i + v c_in;
};
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in)
val bn_add_carry_lemma_loop:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> c_in:carry t
-> i:nat{i <= aLen} ->
Lemma (let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in
v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in)
let rec bn_add_carry_lemma_loop #t #aLen a c_in i =
let pbits = bits t in
let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in
if i = 0 then begin
eq_generate_elems0 aLen i (bn_add_carry_f a) c_in;
assert (c_out == c_in /\ res == Seq.empty);
bn_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
() end
else begin
let (c1, res1) : generate_elem_a (limb t) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_add_carry_f a) c_in in
generate_elems_unfold aLen i (bn_add_carry_f a) c_in (i - 1);
assert (generate_elems aLen i (bn_add_carry_f a) c_in ==
generate_elem_f aLen (bn_add_carry_f a) (i - 1) (generate_elems aLen (i - 1) (bn_add_carry_f a) c_in));
assert ((c_out, res) == generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1));
bn_add_carry_lemma_loop a c_in (i - 1);
assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + v c_in);
bn_add_carry_lemma_loop_step a c_in i (c1, res1);
assert (v c_out * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in);
() end
val bn_add_carry_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t ->
Lemma (let (c_out, res) = bn_add_carry a c_in in
v c_out * pow2 (bits t * aLen) + bn_v res == bn_v a + v c_in)
let bn_add_carry_lemma #t #aLen a c_in =
let (c_out, res) = bn_add_carry a c_in in
bn_add_carry_lemma_loop a c_in aLen
val bn_add_lemma_loop_step:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> b:lbignum t aLen
-> i:pos{i <= aLen}
-> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma
(requires
(let (c1, res1) = c1_res1 in
v c1 * pow2 (bits t * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + eval_ aLen b (i - 1)))
(ensures
(let (c1, res1) = c1_res1 in
let (c, res) = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in
v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i))
let bn_add_lemma_loop_step #t #aLen a b i (c1, res1) =
let pbits = bits t in
let (c, res) = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in
let c, e = bn_add_f a b (i - 1) c1 in
assert (v e + v c * pow2 pbits == v a.[i - 1] + v b.[i - 1] + v c1);
calc (==) {
v c * pow2 (pbits * i) + bn_v #t #i res;
(==) { bn_eval_snoc #t #(i - 1) res1 e }
v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1));
(==) { }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) - (v e + v c * pow2 pbits - v a.[i - 1] - v b.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1] - v b.[i - 1]) (pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v e - v e - v c * pow2 pbits + v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1] + v b.[i - 1]) (v c1 * pow2 pbits) (pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_add_left (v a.[i - 1]) (v b.[i - 1]) (pow2 (pbits * (i - 1))) }
eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + v a.[i - 1] * pow2 (pbits * (i - 1)) + v b.[i - 1] * pow2 (pbits * (i - 1));
(==) { bn_eval_unfold_i #t #aLen a i }
eval_ aLen a i + eval_ aLen b (i - 1) + v b.[i - 1] * pow2 (pbits * (i - 1));
(==) { bn_eval_unfold_i #t #aLen b i }
eval_ aLen a i + eval_ aLen b i;
};
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i)
val bn_add_lemma_loop:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> b:lbignum t aLen
-> i:nat{i <= aLen} ->
Lemma (let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_f a b) (uint #t 0) in
v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i)
let rec bn_add_lemma_loop #t #aLen a b i =
let pbits = bits t in
let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_f a b) (uint #t 0) in
if i = 0 then begin
eq_generate_elems0 aLen i (bn_add_f a b) (uint #t 0);
assert (c == uint #t 0 /\ res == Seq.empty);
bn_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
bn_eval0 b;
() end
else begin
let (c1, res1) : generate_elem_a (limb t) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_add_f a b) (uint #t 0) in
generate_elems_unfold aLen i (bn_add_f a b) (uint #t 0) (i - 1);
assert (generate_elems aLen i (bn_add_f a b) (uint #t 0) ==
generate_elem_f aLen (bn_add_f a b) (i - 1) (generate_elems aLen (i - 1) (bn_add_f a b) (uint #t 0)));
assert ((c, res) == generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1));
bn_add_lemma_loop a b (i - 1);
assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + eval_ aLen b (i - 1));
bn_add_lemma_loop_step a b i (c1, res1);
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i);
() end
val bn_add_concat_lemma:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat{bLen < aLen}
-> a:lbignum t aLen
-> b:lbignum t bLen
-> c0:carry t
-> res0:lbignum t bLen -> Lemma
(requires
v c0 * pow2 (bits t * bLen) + bn_v #t #bLen res0 == eval_ bLen (sub a 0 bLen) bLen + eval_ bLen b bLen)
(ensures
(let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in
let res = concat #_ #bLen res0 res1 in
bn_v res == eval_ aLen a aLen + eval_ bLen b bLen - v c1 * pow2 (bits t * aLen)))
let bn_add_concat_lemma #t #aLen #bLen a b c0 res0 =
let pbits = bits t in
let a0 = sub a 0 bLen in
let a1 = sub a bLen (aLen - bLen) in
let c1, res1 = bn_add_carry a1 c0 in
bn_add_carry_lemma a1 c0;
assert (v c1 * pow2 (pbits * (aLen - bLen)) + bn_v res1 == bn_v a1 + v c0);
let res = concat #_ #bLen res0 res1 in
bn_concat_lemma res0 res1;
assert (bn_v res == bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1);
calc (==) {
bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1;
(==) { }
eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0 - v c1 * pow2 (pbits * (aLen - bLen)));
(==) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * bLen)) (bn_v a1 + v c0) (v c1 * pow2 (pbits * (aLen - bLen))) }
eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0) - pow2 (pbits * bLen) * v c1 * pow2 (pbits * (aLen - bLen));
(==) { Math.Lemmas.paren_mul_right (pow2 (pbits * bLen)) (v c1) (pow2 (pbits * (aLen - bLen))); Math.Lemmas.pow2_plus (pbits * bLen) (pbits * (aLen - bLen)) }
eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0) - v c1 * pow2 (pbits * aLen);
(==) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * bLen)) (bn_v a1) (v c0) }
eval_ bLen a0 bLen + eval_ bLen b bLen + pow2 (pbits * bLen) * bn_v a1 - v c1 * pow2 (pbits * aLen);
(==) { bn_eval_split_i a bLen; bn_eval_extensionality_j a (sub a 0 bLen) bLen }
eval_ aLen a aLen + eval_ bLen b bLen - v c1 * pow2 (pbits * aLen);
}
val bn_add_lemma:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat{bLen <= aLen}
-> a:lbignum t aLen
-> b:lbignum t bLen ->
Lemma (let (c, res) = bn_add a b in
v c * pow2 (bits t * aLen) + bn_v res == bn_v a + bn_v b)
let bn_add_lemma #t #aLen #bLen a b =
let pbits = bits t in
let (c, res) = bn_add a b in
if bLen = aLen then
bn_add_lemma_loop a b aLen
else begin
let a0 = sub a 0 bLen in
let a1 = sub a bLen (aLen - bLen) in
let c0, res0 = generate_elems bLen bLen (bn_add_f a0 b) (uint #t 0) in
bn_add_lemma_loop a0 b bLen;
assert (v c0 * pow2 (pbits * bLen) + bn_v #t #bLen res0 == eval_ bLen a0 bLen + eval_ bLen b bLen);
bn_add_concat_lemma #t #aLen #bLen a b c0 res0 end
val bn_add1_lemma:
#t:limb_t
-> #aLen:size_pos
-> a:lbignum t aLen
-> b1:limb t ->
Lemma (let (c, res) = bn_add1 a b1 in
v c * pow2 (bits t * aLen) + bn_v res == bn_v a + v b1)
let bn_add1_lemma #t #aLen a b1 =
let pbits = bits t in
let c0, r0 = addcarry (uint #t 0) a.[0] b1 in
assert (v c0 * pow2 pbits + v r0 = v a.[0] + v b1);
let res0 = create 1 r0 in
let b = create 1 b1 in
bn_eval1 res0;
bn_eval1 b;
if aLen = 1 then
bn_eval1 a
else begin
let bLen = 1 in
let a0 = sub a 0 bLen in
bn_eval1 a0;
assert (v c0 * pow2 (pbits * bLen) + bn_v #t #1 res0 == eval_ bLen a0 bLen + eval_ bLen b bLen);
bn_add_concat_lemma a b c0 res0 end
val bn_sub_carry_lemma_loop_step:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> c_in:carry t
-> i:pos{i <= aLen}
-> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma
(requires
(let (c1, res1) = c1_res1 in
bn_v #t #(i - 1) res1 - v c1 * pow2 (bits t * (i - 1)) == eval_ aLen a (i - 1) - v c_in))
(ensures
(let (c_out, res) = generate_elem_f aLen (bn_sub_carry_f a) (i - 1) c1_res1 in
bn_v #t #i res - v c_out * pow2 (bits t * i) == eval_ aLen a i - v c_in))
let bn_sub_carry_lemma_loop_step #t #aLen a c_in i (c1, res1) =
let pbits = bits t in
let (c_out, res) = generate_elem_f aLen (bn_sub_carry_f a) (i - 1) (c1, res1) in
let c, e = bn_sub_carry_f a (i - 1) c1 in
assert (v e - v c * pow2 pbits == v a.[i - 1] - v c1);
calc (==) {
bn_v #t #i res - v c * pow2 (pbits * i);
(==) { bn_eval_snoc #t #(i - 1) res1 e }
bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i);
(==) { }
eval_ aLen a (i - 1) - v c_in + (v a.[i - 1] - v e + v c * pow2 pbits) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i);
(==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1] + v c * pow2 pbits) (v e) (pow2 (pbits * (i - 1))) }
eval_ aLen a (i - 1) - v c_in + (v a.[i - 1] + v c * pow2 pbits) * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i);
(==) { Math.Lemmas.distributivity_add_left (v a.[i - 1]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) }
eval_ aLen a (i - 1) - v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)) + v c * pow2 pbits * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i);
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen a (i - 1) - v c_in + v a.[i - 1] * pow2 (pbits * (i - 1));
(==) { bn_eval_unfold_i a i }
eval_ aLen a i - v c_in;
};
assert (bn_v #t #i res - v c * pow2 (pbits * i) == eval_ aLen a i - v c_in)
val bn_sub_carry_lemma_loop:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> c_in:carry t
-> i:nat{i <= aLen} ->
Lemma (let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_sub_carry_f a) c_in in
bn_v #t #i res - v c_out * pow2 (bits t * i) == eval_ aLen a i - v c_in)
let rec bn_sub_carry_lemma_loop #t #aLen a c_in i =
let pbits = bits t in
let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_sub_carry_f a) c_in in
if i = 0 then begin
eq_generate_elems0 aLen i (bn_sub_carry_f a) c_in;
assert (c_out == c_in /\ res == Seq.empty);
bn_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
() end
else begin
let (c1, res1) : generate_elem_a (limb t) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_sub_carry_f a) c_in in
generate_elems_unfold aLen i (bn_sub_carry_f a) c_in (i - 1);
assert (generate_elems aLen i (bn_sub_carry_f a) c_in ==
generate_elem_f aLen (bn_sub_carry_f a) (i - 1) (generate_elems aLen (i - 1) (bn_sub_carry_f a) c_in));
assert ((c_out, res) == generate_elem_f aLen (bn_sub_carry_f a) (i - 1) (c1, res1));
bn_sub_carry_lemma_loop a c_in (i - 1);
assert (bn_v #t #(i - 1) res1 - v c1 * pow2 (pbits * (i - 1)) == eval_ aLen a (i - 1) - v c_in);
bn_sub_carry_lemma_loop_step a c_in i (c1, res1);
assert (bn_v #t #i res - v c_out * pow2 (pbits * i) == eval_ aLen a i - v c_in);
() end
val bn_sub_carry_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t ->
Lemma (let (c_out, res) = bn_sub_carry a c_in in
bn_v res - v c_out * pow2 (bits t * aLen) == bn_v a - v c_in)
let bn_sub_carry_lemma #t #aLen a c_in =
let (c_out, res) = bn_sub_carry a c_in in
bn_sub_carry_lemma_loop a c_in aLen
val bn_sub_lemma_loop_step:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> b:lbignum t aLen
-> i:pos{i <= aLen}
-> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma
(requires
(let (c1, res1) = c1_res1 in
bn_v #t #(i - 1) res1 - v c1 * pow2 (bits t * (i - 1)) == eval_ aLen a (i - 1) - eval_ aLen b (i - 1)))
(ensures
(let (c, res) = generate_elem_f aLen (bn_sub_f a b) (i - 1) c1_res1 in
bn_v #t #i res - v c * pow2 (bits t * i) == eval_ aLen a i - eval_ aLen b i))
let bn_sub_lemma_loop_step #t #aLen a b i (c1, res1) =
let pbits = bits t in
let (c, res) = generate_elem_f aLen (bn_sub_f a b) (i - 1) (c1, res1) in
let c, e = bn_sub_f a b (i - 1) c1 in
assert (v e - v c * pow2 pbits == v a.[i - 1] - v b.[i - 1] - v c1);
calc (==) {
bn_v #t #i res - v c * pow2 (pbits * i);
(==) { bn_eval_snoc #t #(i - 1) res1 e }
bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i);
(==) { }
eval_ aLen a (i - 1) - eval_ aLen b (i - 1) + (v a.[i - 1] - v b.[i - 1] + v c * pow2 pbits - v e) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i);
(==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1] - v b.[i - 1] + v c * pow2 pbits) (v e) (pow2 (pbits * (i - 1))) }
eval_ aLen a (i - 1) - eval_ aLen b (i - 1) + (v a.[i - 1] - v b.[i - 1] + v c * pow2 pbits) * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i);
(==) { Math.Lemmas.distributivity_add_left (v a.[i - 1] - v b.[i - 1]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) }
eval_ aLen a (i - 1) - eval_ aLen b (i - 1) + (v a.[i - 1] - v b.[i - 1]) * pow2 (pbits * (i - 1)) + v c * pow2 pbits * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i);
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen a (i - 1) - eval_ aLen b (i - 1) + (v a.[i - 1] - v b.[i - 1]) * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1]) (v b.[i - 1]) (pow2 (pbits * (i - 1))) }
eval_ aLen a (i - 1) - eval_ aLen b (i - 1) + v a.[i - 1] * pow2 (pbits * (i - 1)) - v b.[i - 1] * pow2 (pbits * (i - 1));
(==) { bn_eval_unfold_i a i }
eval_ aLen a i - eval_ aLen b (i - 1) - v b.[i - 1] * pow2 (pbits * (i - 1));
(==) { bn_eval_unfold_i b i }
eval_ aLen a i - eval_ aLen b i;
};
assert (bn_v #t #i res - v c * pow2 (pbits * i) == eval_ aLen a i - eval_ aLen b i)
val bn_sub_lemma_loop:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> b:lbignum t aLen
-> i:nat{i <= aLen} ->
Lemma (let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_sub_f a b) (uint #t 0) in
bn_v #t #i res - v c * pow2 (bits t * i) == eval_ aLen a i - eval_ aLen b i)
let rec bn_sub_lemma_loop #t #aLen a b i =
let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_sub_f a b) (uint #t 0) in
if i = 0 then begin
eq_generate_elems0 aLen i (bn_sub_f a b) (uint #t 0);
assert (c == uint #t 0 /\ res == Seq.empty);
bn_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
bn_eval0 b;
() end
else begin
let (c1, res1) : generate_elem_a (limb t) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_sub_f a b) (uint #t 0) in
generate_elems_unfold aLen i (bn_sub_f a b) (uint #t 0) (i - 1);
assert (generate_elems aLen i (bn_sub_f a b) (uint #t 0) ==
generate_elem_f aLen (bn_sub_f a b) (i - 1) (generate_elems aLen (i - 1) (bn_sub_f a b) (uint #t 0)));
assert ((c, res) == generate_elem_f aLen (bn_sub_f a b) (i - 1) (c1, res1));
bn_sub_lemma_loop a b (i - 1);
assert (bn_v #t #(i - 1) res1 - v c1 * pow2 (bits t * (i - 1)) == eval_ aLen a (i - 1) - eval_ aLen b (i - 1));
bn_sub_lemma_loop_step a b i (c1, res1);
assert (bn_v #t #i res - v c * pow2 (bits t * i) == eval_ aLen a i - eval_ aLen b i);
() end
val bn_sub_concat_lemma:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat{bLen < aLen}
-> a:lbignum t aLen
-> b:lbignum t bLen
-> c0:carry t
-> res0:lbignum t bLen -> Lemma
(requires
bn_v #t #bLen res0 - v c0 * pow2 (bits t * bLen) == eval_ bLen (sub a 0 bLen) bLen - eval_ bLen b bLen)
(ensures
(let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in
let res = concat #_ #bLen res0 res1 in
bn_v res == eval_ aLen a aLen - eval_ bLen b bLen + v c1 * pow2 (bits t * aLen)))
let bn_sub_concat_lemma #t #aLen #bLen a b c0 res0 =
let pbits = bits t in
let a0 = sub a 0 bLen in
let a1 = sub a bLen (aLen - bLen) in
let c1, res1 = bn_sub_carry a1 c0 in
bn_sub_carry_lemma a1 c0;
assert (bn_v res1 - v c1 * pow2 (pbits * (aLen - bLen)) == bn_v a1 - v c0);
let res = concat #_ #bLen res0 res1 in
bn_concat_lemma res0 res1;
assert (bn_v res == bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1);
calc (==) {
bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1;
(==) { }
eval_ bLen a0 bLen - eval_ bLen b bLen + v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 - v c0 + v c1 * pow2 (pbits * (aLen - bLen)));
(==) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * bLen)) (bn_v a1 + v c1 * pow2 (pbits * (aLen - bLen))) (v c0) }
eval_ bLen a0 bLen - eval_ bLen b bLen + v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c1 * pow2 (pbits * (aLen - bLen))) - pow2 (pbits * bLen) * v c0;
(==) { Math.Lemmas.distributivity_add_right (pow2 (pbits * bLen)) (bn_v a1) (v c1 * pow2 (pbits * (aLen - bLen))) }
eval_ bLen a0 bLen - eval_ bLen b bLen + pow2 (pbits * bLen) * bn_v a1 + pow2 (pbits * bLen) * v c1 * pow2 (pbits * (aLen - bLen));
(==) { Math.Lemmas.paren_mul_right (pow2 (pbits * bLen)) (v c1) (pow2 (pbits * (aLen - bLen))); Math.Lemmas.pow2_plus (pbits * bLen) (pbits * (aLen - bLen)) }
eval_ bLen a0 bLen - eval_ bLen b bLen + pow2 (pbits * bLen) * bn_v a1 + v c1 * pow2 (pbits * aLen);
(==) { bn_eval_split_i a bLen; bn_eval_extensionality_j a (sub a 0 bLen) bLen }
eval_ aLen a aLen - eval_ bLen b bLen + v c1 * pow2 (pbits * aLen);
}
val bn_sub_lemma:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat{bLen <= aLen}
-> a:lbignum t aLen
-> b:lbignum t bLen ->
Lemma (let (c, res) = bn_sub a b in
bn_v res - v c * pow2 (bits t * aLen) == bn_v a - bn_v b)
let bn_sub_lemma #t #aLen #bLen a b =
let pbits = bits t in
let (c, res) = bn_sub a b in
if bLen = aLen then
bn_sub_lemma_loop a b aLen
else begin
let a0 = sub a 0 bLen in
let a1 = sub a bLen (aLen - bLen) in
let c0, res0 = generate_elems bLen bLen (bn_sub_f a0 b) (uint #t 0) in
bn_sub_lemma_loop a0 b bLen;
assert (bn_v #t #bLen res0 - v c0 * pow2 (pbits * bLen) == eval_ bLen a0 bLen - eval_ bLen b bLen);
bn_sub_concat_lemma #t #aLen #bLen a b c0 res0 end
val bn_sub1_lemma:
#t:limb_t
-> #aLen:size_pos
-> a:lbignum t aLen
-> b1:limb t ->
Lemma (let (c, res) = bn_sub1 a b1 in
bn_v res - v c * pow2 (bits t * aLen) == bn_v a - v b1) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Addition.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | a: Hacl.Spec.Bignum.Definitions.lbignum t aLen -> b1: Hacl.Spec.Bignum.Definitions.limb t
-> FStar.Pervasives.Lemma
(ensures
(let _ = Hacl.Spec.Bignum.Addition.bn_sub1 a b1 in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ c res = _ in
Hacl.Spec.Bignum.Definitions.bn_v res -
Lib.IntTypes.v c * Prims.pow2 (Lib.IntTypes.bits t * aLen) ==
Hacl.Spec.Bignum.Definitions.bn_v a - Lib.IntTypes.v b1)
<:
Type0)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_pos",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Definitions.limb",
"Hacl.Spec.Bignum.Base.carry",
"Prims.op_Equality",
"Prims.int",
"Hacl.Spec.Bignum.Definitions.bn_eval1",
"Prims.bool",
"Hacl.Spec.Bignum.Addition.bn_sub_concat_lemma",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Prims.op_Subtraction",
"Hacl.Spec.Bignum.Definitions.bn_v",
"FStar.Mul.op_Star",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Prims.pow2",
"Hacl.Spec.Bignum.Definitions.eval_",
"Lib.Sequence.lseq",
"Prims.l_and",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.slice",
"Prims.op_Addition",
"Prims.l_Forall",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.index",
"Lib.Sequence.sub",
"FStar.Seq.Base.create",
"Prims.l_imp",
"Lib.Sequence.create",
"Lib.Sequence.op_String_Access",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.Bignum.Base.subborrow",
"Lib.IntTypes.uint",
"Lib.IntTypes.bits"
] | [] | false | false | true | false | false | let bn_sub1_lemma #t #aLen a b1 =
| let pbits = bits t in
let c0, r0 = subborrow (uint #t 0) a.[ 0 ] b1 in
assert (v r0 - v c0 * pow2 pbits = v a.[ 0 ] - v b1);
let res0 = create 1 r0 in
let b = create 1 b1 in
bn_eval1 res0;
bn_eval1 b;
if aLen = 1
then bn_eval1 a
else
let bLen = 1 in
let a0 = sub a 0 bLen in
bn_eval1 a0;
assert (bn_v #t #1 res0 - v c0 * pow2 (pbits * bLen) == eval_ bLen a0 bLen - eval_ bLen b bLen);
bn_sub_concat_lemma a b c0 res0 | false |
Hacl.Spec.Bignum.Addition.fst | Hacl.Spec.Bignum.Addition.bn_sub_lemma | val bn_sub_lemma:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat{bLen <= aLen}
-> a:lbignum t aLen
-> b:lbignum t bLen ->
Lemma (let (c, res) = bn_sub a b in
bn_v res - v c * pow2 (bits t * aLen) == bn_v a - bn_v b) | val bn_sub_lemma:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat{bLen <= aLen}
-> a:lbignum t aLen
-> b:lbignum t bLen ->
Lemma (let (c, res) = bn_sub a b in
bn_v res - v c * pow2 (bits t * aLen) == bn_v a - bn_v b) | let bn_sub_lemma #t #aLen #bLen a b =
let pbits = bits t in
let (c, res) = bn_sub a b in
if bLen = aLen then
bn_sub_lemma_loop a b aLen
else begin
let a0 = sub a 0 bLen in
let a1 = sub a bLen (aLen - bLen) in
let c0, res0 = generate_elems bLen bLen (bn_sub_f a0 b) (uint #t 0) in
bn_sub_lemma_loop a0 b bLen;
assert (bn_v #t #bLen res0 - v c0 * pow2 (pbits * bLen) == eval_ bLen a0 bLen - eval_ bLen b bLen);
bn_sub_concat_lemma #t #aLen #bLen a b c0 res0 end | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Addition.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 54,
"end_line": 539,
"start_col": 0,
"start_line": 527
} | module Hacl.Spec.Bignum.Addition
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_sub_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t
let bn_sub_carry_f #t #aLen a i c_in = subborrow c_in a.[i] (uint #t 0)
val bn_sub_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen)
let bn_sub_carry #t #aLen a c_in = generate_elems aLen aLen (bn_sub_carry_f a) c_in
val bn_sub_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t
let bn_sub_f #t #aLen a b i c = subborrow c a.[i] b.[i]
val bn_sub: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> tuple2 (carry t) (lbignum t aLen)
let bn_sub #t #aLen #bLen a b =
let c0, res0 = generate_elems bLen bLen (bn_sub_f (sub a 0 bLen) b) (uint #t 0) in
if bLen < aLen then
let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in
c1, concat #_ #bLen res0 res1
else c0, res0
val bn_sub1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen)
let bn_sub1 #t #aLen a b1 =
let c0, r0 = subborrow (uint #t 0) a.[0] b1 in
let res0 = create 1 r0 in
if 1 < aLen then
let c1, res1 = bn_sub_carry (sub a 1 (aLen - 1)) c0 in
c1, concat res0 res1
else c0, res0
val bn_add_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t
let bn_add_carry_f #t #aLen a i c_in = addcarry c_in a.[i] (uint #t 0)
val bn_add_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen)
let bn_add_carry #t #aLen a c_in = generate_elems aLen aLen (bn_add_carry_f a) c_in
val bn_add_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t
let bn_add_f #t #aLen a b i c = addcarry c a.[i] b.[i]
val bn_add: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> carry t & lbignum t aLen
let bn_add #t #aLen #bLen a b =
let c0, res0 = generate_elems bLen bLen (bn_add_f (sub a 0 bLen) b) (uint #t 0) in
if bLen < aLen then
let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in
c1, concat #_ #bLen res0 res1
else c0, res0
val bn_add1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen)
let bn_add1 #t #aLen a b1 =
let c0, r0 = addcarry (uint #t 0) a.[0] b1 in
let res0 = create 1 r0 in
if 1 < aLen then
let c1, res1 = bn_add_carry (sub a 1 (aLen - 1)) c0 in
c1, concat res0 res1
else c0, res0
val bn_add_carry_lemma_loop_step:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> c_in:carry t
-> i:pos{i <= aLen}
-> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma
(requires
(let (c1, res1) = c1_res1 in
v c1 * pow2 (bits t * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + v c_in))
(ensures
(let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) c1_res1 in
v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in))
let bn_add_carry_lemma_loop_step #t #aLen a c_in i (c1, res1) =
let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1) in
let c, e = bn_add_carry_f a (i - 1) c1 in
assert (v e + v c * pow2 (bits t) == v a.[i - 1] + v c1);
let pbits = bits t in
calc (==) {
v c * pow2 (pbits * i) + bn_v #t #i res;
(==) { bn_eval_snoc #t #(i - 1) res1 e }
v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1));
(==) { }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in - (v e + v c * pow2 pbits - v a.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1]) (pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + (v e - v e - v c * pow2 pbits + v a.[i - 1]) * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1));
(==) { bn_eval_unfold_i #t #aLen a i }
eval_ aLen a i + v c_in;
};
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in)
val bn_add_carry_lemma_loop:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> c_in:carry t
-> i:nat{i <= aLen} ->
Lemma (let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in
v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in)
let rec bn_add_carry_lemma_loop #t #aLen a c_in i =
let pbits = bits t in
let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in
if i = 0 then begin
eq_generate_elems0 aLen i (bn_add_carry_f a) c_in;
assert (c_out == c_in /\ res == Seq.empty);
bn_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
() end
else begin
let (c1, res1) : generate_elem_a (limb t) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_add_carry_f a) c_in in
generate_elems_unfold aLen i (bn_add_carry_f a) c_in (i - 1);
assert (generate_elems aLen i (bn_add_carry_f a) c_in ==
generate_elem_f aLen (bn_add_carry_f a) (i - 1) (generate_elems aLen (i - 1) (bn_add_carry_f a) c_in));
assert ((c_out, res) == generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1));
bn_add_carry_lemma_loop a c_in (i - 1);
assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + v c_in);
bn_add_carry_lemma_loop_step a c_in i (c1, res1);
assert (v c_out * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in);
() end
val bn_add_carry_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t ->
Lemma (let (c_out, res) = bn_add_carry a c_in in
v c_out * pow2 (bits t * aLen) + bn_v res == bn_v a + v c_in)
let bn_add_carry_lemma #t #aLen a c_in =
let (c_out, res) = bn_add_carry a c_in in
bn_add_carry_lemma_loop a c_in aLen
val bn_add_lemma_loop_step:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> b:lbignum t aLen
-> i:pos{i <= aLen}
-> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma
(requires
(let (c1, res1) = c1_res1 in
v c1 * pow2 (bits t * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + eval_ aLen b (i - 1)))
(ensures
(let (c1, res1) = c1_res1 in
let (c, res) = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in
v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i))
let bn_add_lemma_loop_step #t #aLen a b i (c1, res1) =
let pbits = bits t in
let (c, res) = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in
let c, e = bn_add_f a b (i - 1) c1 in
assert (v e + v c * pow2 pbits == v a.[i - 1] + v b.[i - 1] + v c1);
calc (==) {
v c * pow2 (pbits * i) + bn_v #t #i res;
(==) { bn_eval_snoc #t #(i - 1) res1 e }
v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1));
(==) { }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) - (v e + v c * pow2 pbits - v a.[i - 1] - v b.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1] - v b.[i - 1]) (pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v e - v e - v c * pow2 pbits + v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1] + v b.[i - 1]) (v c1 * pow2 pbits) (pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_add_left (v a.[i - 1]) (v b.[i - 1]) (pow2 (pbits * (i - 1))) }
eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + v a.[i - 1] * pow2 (pbits * (i - 1)) + v b.[i - 1] * pow2 (pbits * (i - 1));
(==) { bn_eval_unfold_i #t #aLen a i }
eval_ aLen a i + eval_ aLen b (i - 1) + v b.[i - 1] * pow2 (pbits * (i - 1));
(==) { bn_eval_unfold_i #t #aLen b i }
eval_ aLen a i + eval_ aLen b i;
};
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i)
val bn_add_lemma_loop:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> b:lbignum t aLen
-> i:nat{i <= aLen} ->
Lemma (let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_f a b) (uint #t 0) in
v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i)
let rec bn_add_lemma_loop #t #aLen a b i =
let pbits = bits t in
let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_f a b) (uint #t 0) in
if i = 0 then begin
eq_generate_elems0 aLen i (bn_add_f a b) (uint #t 0);
assert (c == uint #t 0 /\ res == Seq.empty);
bn_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
bn_eval0 b;
() end
else begin
let (c1, res1) : generate_elem_a (limb t) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_add_f a b) (uint #t 0) in
generate_elems_unfold aLen i (bn_add_f a b) (uint #t 0) (i - 1);
assert (generate_elems aLen i (bn_add_f a b) (uint #t 0) ==
generate_elem_f aLen (bn_add_f a b) (i - 1) (generate_elems aLen (i - 1) (bn_add_f a b) (uint #t 0)));
assert ((c, res) == generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1));
bn_add_lemma_loop a b (i - 1);
assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + eval_ aLen b (i - 1));
bn_add_lemma_loop_step a b i (c1, res1);
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i);
() end
val bn_add_concat_lemma:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat{bLen < aLen}
-> a:lbignum t aLen
-> b:lbignum t bLen
-> c0:carry t
-> res0:lbignum t bLen -> Lemma
(requires
v c0 * pow2 (bits t * bLen) + bn_v #t #bLen res0 == eval_ bLen (sub a 0 bLen) bLen + eval_ bLen b bLen)
(ensures
(let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in
let res = concat #_ #bLen res0 res1 in
bn_v res == eval_ aLen a aLen + eval_ bLen b bLen - v c1 * pow2 (bits t * aLen)))
let bn_add_concat_lemma #t #aLen #bLen a b c0 res0 =
let pbits = bits t in
let a0 = sub a 0 bLen in
let a1 = sub a bLen (aLen - bLen) in
let c1, res1 = bn_add_carry a1 c0 in
bn_add_carry_lemma a1 c0;
assert (v c1 * pow2 (pbits * (aLen - bLen)) + bn_v res1 == bn_v a1 + v c0);
let res = concat #_ #bLen res0 res1 in
bn_concat_lemma res0 res1;
assert (bn_v res == bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1);
calc (==) {
bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1;
(==) { }
eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0 - v c1 * pow2 (pbits * (aLen - bLen)));
(==) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * bLen)) (bn_v a1 + v c0) (v c1 * pow2 (pbits * (aLen - bLen))) }
eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0) - pow2 (pbits * bLen) * v c1 * pow2 (pbits * (aLen - bLen));
(==) { Math.Lemmas.paren_mul_right (pow2 (pbits * bLen)) (v c1) (pow2 (pbits * (aLen - bLen))); Math.Lemmas.pow2_plus (pbits * bLen) (pbits * (aLen - bLen)) }
eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0) - v c1 * pow2 (pbits * aLen);
(==) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * bLen)) (bn_v a1) (v c0) }
eval_ bLen a0 bLen + eval_ bLen b bLen + pow2 (pbits * bLen) * bn_v a1 - v c1 * pow2 (pbits * aLen);
(==) { bn_eval_split_i a bLen; bn_eval_extensionality_j a (sub a 0 bLen) bLen }
eval_ aLen a aLen + eval_ bLen b bLen - v c1 * pow2 (pbits * aLen);
}
val bn_add_lemma:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat{bLen <= aLen}
-> a:lbignum t aLen
-> b:lbignum t bLen ->
Lemma (let (c, res) = bn_add a b in
v c * pow2 (bits t * aLen) + bn_v res == bn_v a + bn_v b)
let bn_add_lemma #t #aLen #bLen a b =
let pbits = bits t in
let (c, res) = bn_add a b in
if bLen = aLen then
bn_add_lemma_loop a b aLen
else begin
let a0 = sub a 0 bLen in
let a1 = sub a bLen (aLen - bLen) in
let c0, res0 = generate_elems bLen bLen (bn_add_f a0 b) (uint #t 0) in
bn_add_lemma_loop a0 b bLen;
assert (v c0 * pow2 (pbits * bLen) + bn_v #t #bLen res0 == eval_ bLen a0 bLen + eval_ bLen b bLen);
bn_add_concat_lemma #t #aLen #bLen a b c0 res0 end
val bn_add1_lemma:
#t:limb_t
-> #aLen:size_pos
-> a:lbignum t aLen
-> b1:limb t ->
Lemma (let (c, res) = bn_add1 a b1 in
v c * pow2 (bits t * aLen) + bn_v res == bn_v a + v b1)
let bn_add1_lemma #t #aLen a b1 =
let pbits = bits t in
let c0, r0 = addcarry (uint #t 0) a.[0] b1 in
assert (v c0 * pow2 pbits + v r0 = v a.[0] + v b1);
let res0 = create 1 r0 in
let b = create 1 b1 in
bn_eval1 res0;
bn_eval1 b;
if aLen = 1 then
bn_eval1 a
else begin
let bLen = 1 in
let a0 = sub a 0 bLen in
bn_eval1 a0;
assert (v c0 * pow2 (pbits * bLen) + bn_v #t #1 res0 == eval_ bLen a0 bLen + eval_ bLen b bLen);
bn_add_concat_lemma a b c0 res0 end
val bn_sub_carry_lemma_loop_step:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> c_in:carry t
-> i:pos{i <= aLen}
-> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma
(requires
(let (c1, res1) = c1_res1 in
bn_v #t #(i - 1) res1 - v c1 * pow2 (bits t * (i - 1)) == eval_ aLen a (i - 1) - v c_in))
(ensures
(let (c_out, res) = generate_elem_f aLen (bn_sub_carry_f a) (i - 1) c1_res1 in
bn_v #t #i res - v c_out * pow2 (bits t * i) == eval_ aLen a i - v c_in))
let bn_sub_carry_lemma_loop_step #t #aLen a c_in i (c1, res1) =
let pbits = bits t in
let (c_out, res) = generate_elem_f aLen (bn_sub_carry_f a) (i - 1) (c1, res1) in
let c, e = bn_sub_carry_f a (i - 1) c1 in
assert (v e - v c * pow2 pbits == v a.[i - 1] - v c1);
calc (==) {
bn_v #t #i res - v c * pow2 (pbits * i);
(==) { bn_eval_snoc #t #(i - 1) res1 e }
bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i);
(==) { }
eval_ aLen a (i - 1) - v c_in + (v a.[i - 1] - v e + v c * pow2 pbits) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i);
(==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1] + v c * pow2 pbits) (v e) (pow2 (pbits * (i - 1))) }
eval_ aLen a (i - 1) - v c_in + (v a.[i - 1] + v c * pow2 pbits) * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i);
(==) { Math.Lemmas.distributivity_add_left (v a.[i - 1]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) }
eval_ aLen a (i - 1) - v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)) + v c * pow2 pbits * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i);
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen a (i - 1) - v c_in + v a.[i - 1] * pow2 (pbits * (i - 1));
(==) { bn_eval_unfold_i a i }
eval_ aLen a i - v c_in;
};
assert (bn_v #t #i res - v c * pow2 (pbits * i) == eval_ aLen a i - v c_in)
val bn_sub_carry_lemma_loop:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> c_in:carry t
-> i:nat{i <= aLen} ->
Lemma (let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_sub_carry_f a) c_in in
bn_v #t #i res - v c_out * pow2 (bits t * i) == eval_ aLen a i - v c_in)
let rec bn_sub_carry_lemma_loop #t #aLen a c_in i =
let pbits = bits t in
let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_sub_carry_f a) c_in in
if i = 0 then begin
eq_generate_elems0 aLen i (bn_sub_carry_f a) c_in;
assert (c_out == c_in /\ res == Seq.empty);
bn_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
() end
else begin
let (c1, res1) : generate_elem_a (limb t) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_sub_carry_f a) c_in in
generate_elems_unfold aLen i (bn_sub_carry_f a) c_in (i - 1);
assert (generate_elems aLen i (bn_sub_carry_f a) c_in ==
generate_elem_f aLen (bn_sub_carry_f a) (i - 1) (generate_elems aLen (i - 1) (bn_sub_carry_f a) c_in));
assert ((c_out, res) == generate_elem_f aLen (bn_sub_carry_f a) (i - 1) (c1, res1));
bn_sub_carry_lemma_loop a c_in (i - 1);
assert (bn_v #t #(i - 1) res1 - v c1 * pow2 (pbits * (i - 1)) == eval_ aLen a (i - 1) - v c_in);
bn_sub_carry_lemma_loop_step a c_in i (c1, res1);
assert (bn_v #t #i res - v c_out * pow2 (pbits * i) == eval_ aLen a i - v c_in);
() end
val bn_sub_carry_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t ->
Lemma (let (c_out, res) = bn_sub_carry a c_in in
bn_v res - v c_out * pow2 (bits t * aLen) == bn_v a - v c_in)
let bn_sub_carry_lemma #t #aLen a c_in =
let (c_out, res) = bn_sub_carry a c_in in
bn_sub_carry_lemma_loop a c_in aLen
val bn_sub_lemma_loop_step:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> b:lbignum t aLen
-> i:pos{i <= aLen}
-> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma
(requires
(let (c1, res1) = c1_res1 in
bn_v #t #(i - 1) res1 - v c1 * pow2 (bits t * (i - 1)) == eval_ aLen a (i - 1) - eval_ aLen b (i - 1)))
(ensures
(let (c, res) = generate_elem_f aLen (bn_sub_f a b) (i - 1) c1_res1 in
bn_v #t #i res - v c * pow2 (bits t * i) == eval_ aLen a i - eval_ aLen b i))
let bn_sub_lemma_loop_step #t #aLen a b i (c1, res1) =
let pbits = bits t in
let (c, res) = generate_elem_f aLen (bn_sub_f a b) (i - 1) (c1, res1) in
let c, e = bn_sub_f a b (i - 1) c1 in
assert (v e - v c * pow2 pbits == v a.[i - 1] - v b.[i - 1] - v c1);
calc (==) {
bn_v #t #i res - v c * pow2 (pbits * i);
(==) { bn_eval_snoc #t #(i - 1) res1 e }
bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i);
(==) { }
eval_ aLen a (i - 1) - eval_ aLen b (i - 1) + (v a.[i - 1] - v b.[i - 1] + v c * pow2 pbits - v e) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i);
(==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1] - v b.[i - 1] + v c * pow2 pbits) (v e) (pow2 (pbits * (i - 1))) }
eval_ aLen a (i - 1) - eval_ aLen b (i - 1) + (v a.[i - 1] - v b.[i - 1] + v c * pow2 pbits) * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i);
(==) { Math.Lemmas.distributivity_add_left (v a.[i - 1] - v b.[i - 1]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) }
eval_ aLen a (i - 1) - eval_ aLen b (i - 1) + (v a.[i - 1] - v b.[i - 1]) * pow2 (pbits * (i - 1)) + v c * pow2 pbits * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i);
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen a (i - 1) - eval_ aLen b (i - 1) + (v a.[i - 1] - v b.[i - 1]) * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1]) (v b.[i - 1]) (pow2 (pbits * (i - 1))) }
eval_ aLen a (i - 1) - eval_ aLen b (i - 1) + v a.[i - 1] * pow2 (pbits * (i - 1)) - v b.[i - 1] * pow2 (pbits * (i - 1));
(==) { bn_eval_unfold_i a i }
eval_ aLen a i - eval_ aLen b (i - 1) - v b.[i - 1] * pow2 (pbits * (i - 1));
(==) { bn_eval_unfold_i b i }
eval_ aLen a i - eval_ aLen b i;
};
assert (bn_v #t #i res - v c * pow2 (pbits * i) == eval_ aLen a i - eval_ aLen b i)
val bn_sub_lemma_loop:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> b:lbignum t aLen
-> i:nat{i <= aLen} ->
Lemma (let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_sub_f a b) (uint #t 0) in
bn_v #t #i res - v c * pow2 (bits t * i) == eval_ aLen a i - eval_ aLen b i)
let rec bn_sub_lemma_loop #t #aLen a b i =
let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_sub_f a b) (uint #t 0) in
if i = 0 then begin
eq_generate_elems0 aLen i (bn_sub_f a b) (uint #t 0);
assert (c == uint #t 0 /\ res == Seq.empty);
bn_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
bn_eval0 b;
() end
else begin
let (c1, res1) : generate_elem_a (limb t) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_sub_f a b) (uint #t 0) in
generate_elems_unfold aLen i (bn_sub_f a b) (uint #t 0) (i - 1);
assert (generate_elems aLen i (bn_sub_f a b) (uint #t 0) ==
generate_elem_f aLen (bn_sub_f a b) (i - 1) (generate_elems aLen (i - 1) (bn_sub_f a b) (uint #t 0)));
assert ((c, res) == generate_elem_f aLen (bn_sub_f a b) (i - 1) (c1, res1));
bn_sub_lemma_loop a b (i - 1);
assert (bn_v #t #(i - 1) res1 - v c1 * pow2 (bits t * (i - 1)) == eval_ aLen a (i - 1) - eval_ aLen b (i - 1));
bn_sub_lemma_loop_step a b i (c1, res1);
assert (bn_v #t #i res - v c * pow2 (bits t * i) == eval_ aLen a i - eval_ aLen b i);
() end
val bn_sub_concat_lemma:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat{bLen < aLen}
-> a:lbignum t aLen
-> b:lbignum t bLen
-> c0:carry t
-> res0:lbignum t bLen -> Lemma
(requires
bn_v #t #bLen res0 - v c0 * pow2 (bits t * bLen) == eval_ bLen (sub a 0 bLen) bLen - eval_ bLen b bLen)
(ensures
(let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in
let res = concat #_ #bLen res0 res1 in
bn_v res == eval_ aLen a aLen - eval_ bLen b bLen + v c1 * pow2 (bits t * aLen)))
let bn_sub_concat_lemma #t #aLen #bLen a b c0 res0 =
let pbits = bits t in
let a0 = sub a 0 bLen in
let a1 = sub a bLen (aLen - bLen) in
let c1, res1 = bn_sub_carry a1 c0 in
bn_sub_carry_lemma a1 c0;
assert (bn_v res1 - v c1 * pow2 (pbits * (aLen - bLen)) == bn_v a1 - v c0);
let res = concat #_ #bLen res0 res1 in
bn_concat_lemma res0 res1;
assert (bn_v res == bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1);
calc (==) {
bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1;
(==) { }
eval_ bLen a0 bLen - eval_ bLen b bLen + v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 - v c0 + v c1 * pow2 (pbits * (aLen - bLen)));
(==) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * bLen)) (bn_v a1 + v c1 * pow2 (pbits * (aLen - bLen))) (v c0) }
eval_ bLen a0 bLen - eval_ bLen b bLen + v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c1 * pow2 (pbits * (aLen - bLen))) - pow2 (pbits * bLen) * v c0;
(==) { Math.Lemmas.distributivity_add_right (pow2 (pbits * bLen)) (bn_v a1) (v c1 * pow2 (pbits * (aLen - bLen))) }
eval_ bLen a0 bLen - eval_ bLen b bLen + pow2 (pbits * bLen) * bn_v a1 + pow2 (pbits * bLen) * v c1 * pow2 (pbits * (aLen - bLen));
(==) { Math.Lemmas.paren_mul_right (pow2 (pbits * bLen)) (v c1) (pow2 (pbits * (aLen - bLen))); Math.Lemmas.pow2_plus (pbits * bLen) (pbits * (aLen - bLen)) }
eval_ bLen a0 bLen - eval_ bLen b bLen + pow2 (pbits * bLen) * bn_v a1 + v c1 * pow2 (pbits * aLen);
(==) { bn_eval_split_i a bLen; bn_eval_extensionality_j a (sub a 0 bLen) bLen }
eval_ aLen a aLen - eval_ bLen b bLen + v c1 * pow2 (pbits * aLen);
}
val bn_sub_lemma:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat{bLen <= aLen}
-> a:lbignum t aLen
-> b:lbignum t bLen ->
Lemma (let (c, res) = bn_sub a b in
bn_v res - v c * pow2 (bits t * aLen) == bn_v a - bn_v b) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Addition.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | a: Hacl.Spec.Bignum.Definitions.lbignum t aLen -> b: Hacl.Spec.Bignum.Definitions.lbignum t bLen
-> FStar.Pervasives.Lemma
(ensures
(let _ = Hacl.Spec.Bignum.Addition.bn_sub a b in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ c res = _ in
Hacl.Spec.Bignum.Definitions.bn_v res -
Lib.IntTypes.v c * Prims.pow2 (Lib.IntTypes.bits t * aLen) ==
Hacl.Spec.Bignum.Definitions.bn_v a - Hacl.Spec.Bignum.Definitions.bn_v b)
<:
Type0)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Base.carry",
"Prims.op_Equality",
"Hacl.Spec.Bignum.Addition.bn_sub_lemma_loop",
"Prims.bool",
"Lib.Sequence.seq",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.eq2",
"Prims.nat",
"Lib.Sequence.length",
"Hacl.Spec.Bignum.Addition.bn_sub_concat_lemma",
"Prims.unit",
"Prims._assert",
"Prims.int",
"Prims.op_Subtraction",
"Hacl.Spec.Bignum.Definitions.bn_v",
"FStar.Mul.op_Star",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Prims.pow2",
"Hacl.Spec.Bignum.Definitions.eval_",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.Lib.generate_elems",
"Hacl.Spec.Bignum.Addition.bn_sub_f",
"Lib.IntTypes.uint",
"Lib.Sequence.lseq",
"Prims.l_and",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.slice",
"Prims.op_Addition",
"Prims.l_Forall",
"Prims.op_LessThan",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.index",
"Lib.Sequence.sub",
"Hacl.Spec.Bignum.Addition.bn_sub",
"Lib.IntTypes.bits"
] | [] | false | false | true | false | false | let bn_sub_lemma #t #aLen #bLen a b =
| let pbits = bits t in
let c, res = bn_sub a b in
if bLen = aLen
then bn_sub_lemma_loop a b aLen
else
let a0 = sub a 0 bLen in
let a1 = sub a bLen (aLen - bLen) in
let c0, res0 = generate_elems bLen bLen (bn_sub_f a0 b) (uint #t 0) in
bn_sub_lemma_loop a0 b bLen;
assert (bn_v #t #bLen res0 - v c0 * pow2 (pbits * bLen) == eval_ bLen a0 bLen - eval_ bLen b bLen);
bn_sub_concat_lemma #t #aLen #bLen a b c0 res0 | false |
Hacl.Spec.Bignum.Addition.fst | Hacl.Spec.Bignum.Addition.bn_sub_lemma_loop | val bn_sub_lemma_loop:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> b:lbignum t aLen
-> i:nat{i <= aLen} ->
Lemma (let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_sub_f a b) (uint #t 0) in
bn_v #t #i res - v c * pow2 (bits t * i) == eval_ aLen a i - eval_ aLen b i) | val bn_sub_lemma_loop:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> b:lbignum t aLen
-> i:nat{i <= aLen} ->
Lemma (let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_sub_f a b) (uint #t 0) in
bn_v #t #i res - v c * pow2 (bits t * i) == eval_ aLen a i - eval_ aLen b i) | let rec bn_sub_lemma_loop #t #aLen a b i =
let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_sub_f a b) (uint #t 0) in
if i = 0 then begin
eq_generate_elems0 aLen i (bn_sub_f a b) (uint #t 0);
assert (c == uint #t 0 /\ res == Seq.empty);
bn_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
bn_eval0 b;
() end
else begin
let (c1, res1) : generate_elem_a (limb t) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_sub_f a b) (uint #t 0) in
generate_elems_unfold aLen i (bn_sub_f a b) (uint #t 0) (i - 1);
assert (generate_elems aLen i (bn_sub_f a b) (uint #t 0) ==
generate_elem_f aLen (bn_sub_f a b) (i - 1) (generate_elems aLen (i - 1) (bn_sub_f a b) (uint #t 0)));
assert ((c, res) == generate_elem_f aLen (bn_sub_f a b) (i - 1) (c1, res1));
bn_sub_lemma_loop a b (i - 1);
assert (bn_v #t #(i - 1) res1 - v c1 * pow2 (bits t * (i - 1)) == eval_ aLen a (i - 1) - eval_ aLen b (i - 1));
bn_sub_lemma_loop_step a b i (c1, res1);
assert (bn_v #t #i res - v c * pow2 (bits t * i) == eval_ aLen a i - eval_ aLen b i);
() end | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Addition.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 10,
"end_line": 473,
"start_col": 0,
"start_line": 453
} | module Hacl.Spec.Bignum.Addition
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_sub_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t
let bn_sub_carry_f #t #aLen a i c_in = subborrow c_in a.[i] (uint #t 0)
val bn_sub_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen)
let bn_sub_carry #t #aLen a c_in = generate_elems aLen aLen (bn_sub_carry_f a) c_in
val bn_sub_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t
let bn_sub_f #t #aLen a b i c = subborrow c a.[i] b.[i]
val bn_sub: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> tuple2 (carry t) (lbignum t aLen)
let bn_sub #t #aLen #bLen a b =
let c0, res0 = generate_elems bLen bLen (bn_sub_f (sub a 0 bLen) b) (uint #t 0) in
if bLen < aLen then
let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in
c1, concat #_ #bLen res0 res1
else c0, res0
val bn_sub1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen)
let bn_sub1 #t #aLen a b1 =
let c0, r0 = subborrow (uint #t 0) a.[0] b1 in
let res0 = create 1 r0 in
if 1 < aLen then
let c1, res1 = bn_sub_carry (sub a 1 (aLen - 1)) c0 in
c1, concat res0 res1
else c0, res0
val bn_add_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t
let bn_add_carry_f #t #aLen a i c_in = addcarry c_in a.[i] (uint #t 0)
val bn_add_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen)
let bn_add_carry #t #aLen a c_in = generate_elems aLen aLen (bn_add_carry_f a) c_in
val bn_add_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t
let bn_add_f #t #aLen a b i c = addcarry c a.[i] b.[i]
val bn_add: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> carry t & lbignum t aLen
let bn_add #t #aLen #bLen a b =
let c0, res0 = generate_elems bLen bLen (bn_add_f (sub a 0 bLen) b) (uint #t 0) in
if bLen < aLen then
let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in
c1, concat #_ #bLen res0 res1
else c0, res0
val bn_add1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen)
let bn_add1 #t #aLen a b1 =
let c0, r0 = addcarry (uint #t 0) a.[0] b1 in
let res0 = create 1 r0 in
if 1 < aLen then
let c1, res1 = bn_add_carry (sub a 1 (aLen - 1)) c0 in
c1, concat res0 res1
else c0, res0
val bn_add_carry_lemma_loop_step:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> c_in:carry t
-> i:pos{i <= aLen}
-> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma
(requires
(let (c1, res1) = c1_res1 in
v c1 * pow2 (bits t * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + v c_in))
(ensures
(let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) c1_res1 in
v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in))
let bn_add_carry_lemma_loop_step #t #aLen a c_in i (c1, res1) =
let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1) in
let c, e = bn_add_carry_f a (i - 1) c1 in
assert (v e + v c * pow2 (bits t) == v a.[i - 1] + v c1);
let pbits = bits t in
calc (==) {
v c * pow2 (pbits * i) + bn_v #t #i res;
(==) { bn_eval_snoc #t #(i - 1) res1 e }
v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1));
(==) { }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in - (v e + v c * pow2 pbits - v a.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1]) (pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + (v e - v e - v c * pow2 pbits + v a.[i - 1]) * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1));
(==) { bn_eval_unfold_i #t #aLen a i }
eval_ aLen a i + v c_in;
};
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in)
val bn_add_carry_lemma_loop:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> c_in:carry t
-> i:nat{i <= aLen} ->
Lemma (let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in
v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in)
let rec bn_add_carry_lemma_loop #t #aLen a c_in i =
let pbits = bits t in
let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in
if i = 0 then begin
eq_generate_elems0 aLen i (bn_add_carry_f a) c_in;
assert (c_out == c_in /\ res == Seq.empty);
bn_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
() end
else begin
let (c1, res1) : generate_elem_a (limb t) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_add_carry_f a) c_in in
generate_elems_unfold aLen i (bn_add_carry_f a) c_in (i - 1);
assert (generate_elems aLen i (bn_add_carry_f a) c_in ==
generate_elem_f aLen (bn_add_carry_f a) (i - 1) (generate_elems aLen (i - 1) (bn_add_carry_f a) c_in));
assert ((c_out, res) == generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1));
bn_add_carry_lemma_loop a c_in (i - 1);
assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + v c_in);
bn_add_carry_lemma_loop_step a c_in i (c1, res1);
assert (v c_out * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in);
() end
val bn_add_carry_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t ->
Lemma (let (c_out, res) = bn_add_carry a c_in in
v c_out * pow2 (bits t * aLen) + bn_v res == bn_v a + v c_in)
let bn_add_carry_lemma #t #aLen a c_in =
let (c_out, res) = bn_add_carry a c_in in
bn_add_carry_lemma_loop a c_in aLen
val bn_add_lemma_loop_step:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> b:lbignum t aLen
-> i:pos{i <= aLen}
-> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma
(requires
(let (c1, res1) = c1_res1 in
v c1 * pow2 (bits t * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + eval_ aLen b (i - 1)))
(ensures
(let (c1, res1) = c1_res1 in
let (c, res) = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in
v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i))
let bn_add_lemma_loop_step #t #aLen a b i (c1, res1) =
let pbits = bits t in
let (c, res) = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in
let c, e = bn_add_f a b (i - 1) c1 in
assert (v e + v c * pow2 pbits == v a.[i - 1] + v b.[i - 1] + v c1);
calc (==) {
v c * pow2 (pbits * i) + bn_v #t #i res;
(==) { bn_eval_snoc #t #(i - 1) res1 e }
v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1));
(==) { }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) - (v e + v c * pow2 pbits - v a.[i - 1] - v b.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1] - v b.[i - 1]) (pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v e - v e - v c * pow2 pbits + v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1] + v b.[i - 1]) (v c1 * pow2 pbits) (pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_add_left (v a.[i - 1]) (v b.[i - 1]) (pow2 (pbits * (i - 1))) }
eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + v a.[i - 1] * pow2 (pbits * (i - 1)) + v b.[i - 1] * pow2 (pbits * (i - 1));
(==) { bn_eval_unfold_i #t #aLen a i }
eval_ aLen a i + eval_ aLen b (i - 1) + v b.[i - 1] * pow2 (pbits * (i - 1));
(==) { bn_eval_unfold_i #t #aLen b i }
eval_ aLen a i + eval_ aLen b i;
};
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i)
val bn_add_lemma_loop:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> b:lbignum t aLen
-> i:nat{i <= aLen} ->
Lemma (let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_f a b) (uint #t 0) in
v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i)
let rec bn_add_lemma_loop #t #aLen a b i =
let pbits = bits t in
let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_f a b) (uint #t 0) in
if i = 0 then begin
eq_generate_elems0 aLen i (bn_add_f a b) (uint #t 0);
assert (c == uint #t 0 /\ res == Seq.empty);
bn_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
bn_eval0 b;
() end
else begin
let (c1, res1) : generate_elem_a (limb t) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_add_f a b) (uint #t 0) in
generate_elems_unfold aLen i (bn_add_f a b) (uint #t 0) (i - 1);
assert (generate_elems aLen i (bn_add_f a b) (uint #t 0) ==
generate_elem_f aLen (bn_add_f a b) (i - 1) (generate_elems aLen (i - 1) (bn_add_f a b) (uint #t 0)));
assert ((c, res) == generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1));
bn_add_lemma_loop a b (i - 1);
assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + eval_ aLen b (i - 1));
bn_add_lemma_loop_step a b i (c1, res1);
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i);
() end
val bn_add_concat_lemma:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat{bLen < aLen}
-> a:lbignum t aLen
-> b:lbignum t bLen
-> c0:carry t
-> res0:lbignum t bLen -> Lemma
(requires
v c0 * pow2 (bits t * bLen) + bn_v #t #bLen res0 == eval_ bLen (sub a 0 bLen) bLen + eval_ bLen b bLen)
(ensures
(let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in
let res = concat #_ #bLen res0 res1 in
bn_v res == eval_ aLen a aLen + eval_ bLen b bLen - v c1 * pow2 (bits t * aLen)))
let bn_add_concat_lemma #t #aLen #bLen a b c0 res0 =
let pbits = bits t in
let a0 = sub a 0 bLen in
let a1 = sub a bLen (aLen - bLen) in
let c1, res1 = bn_add_carry a1 c0 in
bn_add_carry_lemma a1 c0;
assert (v c1 * pow2 (pbits * (aLen - bLen)) + bn_v res1 == bn_v a1 + v c0);
let res = concat #_ #bLen res0 res1 in
bn_concat_lemma res0 res1;
assert (bn_v res == bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1);
calc (==) {
bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1;
(==) { }
eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0 - v c1 * pow2 (pbits * (aLen - bLen)));
(==) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * bLen)) (bn_v a1 + v c0) (v c1 * pow2 (pbits * (aLen - bLen))) }
eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0) - pow2 (pbits * bLen) * v c1 * pow2 (pbits * (aLen - bLen));
(==) { Math.Lemmas.paren_mul_right (pow2 (pbits * bLen)) (v c1) (pow2 (pbits * (aLen - bLen))); Math.Lemmas.pow2_plus (pbits * bLen) (pbits * (aLen - bLen)) }
eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0) - v c1 * pow2 (pbits * aLen);
(==) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * bLen)) (bn_v a1) (v c0) }
eval_ bLen a0 bLen + eval_ bLen b bLen + pow2 (pbits * bLen) * bn_v a1 - v c1 * pow2 (pbits * aLen);
(==) { bn_eval_split_i a bLen; bn_eval_extensionality_j a (sub a 0 bLen) bLen }
eval_ aLen a aLen + eval_ bLen b bLen - v c1 * pow2 (pbits * aLen);
}
val bn_add_lemma:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat{bLen <= aLen}
-> a:lbignum t aLen
-> b:lbignum t bLen ->
Lemma (let (c, res) = bn_add a b in
v c * pow2 (bits t * aLen) + bn_v res == bn_v a + bn_v b)
let bn_add_lemma #t #aLen #bLen a b =
let pbits = bits t in
let (c, res) = bn_add a b in
if bLen = aLen then
bn_add_lemma_loop a b aLen
else begin
let a0 = sub a 0 bLen in
let a1 = sub a bLen (aLen - bLen) in
let c0, res0 = generate_elems bLen bLen (bn_add_f a0 b) (uint #t 0) in
bn_add_lemma_loop a0 b bLen;
assert (v c0 * pow2 (pbits * bLen) + bn_v #t #bLen res0 == eval_ bLen a0 bLen + eval_ bLen b bLen);
bn_add_concat_lemma #t #aLen #bLen a b c0 res0 end
val bn_add1_lemma:
#t:limb_t
-> #aLen:size_pos
-> a:lbignum t aLen
-> b1:limb t ->
Lemma (let (c, res) = bn_add1 a b1 in
v c * pow2 (bits t * aLen) + bn_v res == bn_v a + v b1)
let bn_add1_lemma #t #aLen a b1 =
let pbits = bits t in
let c0, r0 = addcarry (uint #t 0) a.[0] b1 in
assert (v c0 * pow2 pbits + v r0 = v a.[0] + v b1);
let res0 = create 1 r0 in
let b = create 1 b1 in
bn_eval1 res0;
bn_eval1 b;
if aLen = 1 then
bn_eval1 a
else begin
let bLen = 1 in
let a0 = sub a 0 bLen in
bn_eval1 a0;
assert (v c0 * pow2 (pbits * bLen) + bn_v #t #1 res0 == eval_ bLen a0 bLen + eval_ bLen b bLen);
bn_add_concat_lemma a b c0 res0 end
val bn_sub_carry_lemma_loop_step:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> c_in:carry t
-> i:pos{i <= aLen}
-> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma
(requires
(let (c1, res1) = c1_res1 in
bn_v #t #(i - 1) res1 - v c1 * pow2 (bits t * (i - 1)) == eval_ aLen a (i - 1) - v c_in))
(ensures
(let (c_out, res) = generate_elem_f aLen (bn_sub_carry_f a) (i - 1) c1_res1 in
bn_v #t #i res - v c_out * pow2 (bits t * i) == eval_ aLen a i - v c_in))
let bn_sub_carry_lemma_loop_step #t #aLen a c_in i (c1, res1) =
let pbits = bits t in
let (c_out, res) = generate_elem_f aLen (bn_sub_carry_f a) (i - 1) (c1, res1) in
let c, e = bn_sub_carry_f a (i - 1) c1 in
assert (v e - v c * pow2 pbits == v a.[i - 1] - v c1);
calc (==) {
bn_v #t #i res - v c * pow2 (pbits * i);
(==) { bn_eval_snoc #t #(i - 1) res1 e }
bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i);
(==) { }
eval_ aLen a (i - 1) - v c_in + (v a.[i - 1] - v e + v c * pow2 pbits) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i);
(==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1] + v c * pow2 pbits) (v e) (pow2 (pbits * (i - 1))) }
eval_ aLen a (i - 1) - v c_in + (v a.[i - 1] + v c * pow2 pbits) * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i);
(==) { Math.Lemmas.distributivity_add_left (v a.[i - 1]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) }
eval_ aLen a (i - 1) - v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)) + v c * pow2 pbits * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i);
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen a (i - 1) - v c_in + v a.[i - 1] * pow2 (pbits * (i - 1));
(==) { bn_eval_unfold_i a i }
eval_ aLen a i - v c_in;
};
assert (bn_v #t #i res - v c * pow2 (pbits * i) == eval_ aLen a i - v c_in)
val bn_sub_carry_lemma_loop:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> c_in:carry t
-> i:nat{i <= aLen} ->
Lemma (let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_sub_carry_f a) c_in in
bn_v #t #i res - v c_out * pow2 (bits t * i) == eval_ aLen a i - v c_in)
let rec bn_sub_carry_lemma_loop #t #aLen a c_in i =
let pbits = bits t in
let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_sub_carry_f a) c_in in
if i = 0 then begin
eq_generate_elems0 aLen i (bn_sub_carry_f a) c_in;
assert (c_out == c_in /\ res == Seq.empty);
bn_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
() end
else begin
let (c1, res1) : generate_elem_a (limb t) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_sub_carry_f a) c_in in
generate_elems_unfold aLen i (bn_sub_carry_f a) c_in (i - 1);
assert (generate_elems aLen i (bn_sub_carry_f a) c_in ==
generate_elem_f aLen (bn_sub_carry_f a) (i - 1) (generate_elems aLen (i - 1) (bn_sub_carry_f a) c_in));
assert ((c_out, res) == generate_elem_f aLen (bn_sub_carry_f a) (i - 1) (c1, res1));
bn_sub_carry_lemma_loop a c_in (i - 1);
assert (bn_v #t #(i - 1) res1 - v c1 * pow2 (pbits * (i - 1)) == eval_ aLen a (i - 1) - v c_in);
bn_sub_carry_lemma_loop_step a c_in i (c1, res1);
assert (bn_v #t #i res - v c_out * pow2 (pbits * i) == eval_ aLen a i - v c_in);
() end
val bn_sub_carry_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t ->
Lemma (let (c_out, res) = bn_sub_carry a c_in in
bn_v res - v c_out * pow2 (bits t * aLen) == bn_v a - v c_in)
let bn_sub_carry_lemma #t #aLen a c_in =
let (c_out, res) = bn_sub_carry a c_in in
bn_sub_carry_lemma_loop a c_in aLen
val bn_sub_lemma_loop_step:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> b:lbignum t aLen
-> i:pos{i <= aLen}
-> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma
(requires
(let (c1, res1) = c1_res1 in
bn_v #t #(i - 1) res1 - v c1 * pow2 (bits t * (i - 1)) == eval_ aLen a (i - 1) - eval_ aLen b (i - 1)))
(ensures
(let (c, res) = generate_elem_f aLen (bn_sub_f a b) (i - 1) c1_res1 in
bn_v #t #i res - v c * pow2 (bits t * i) == eval_ aLen a i - eval_ aLen b i))
let bn_sub_lemma_loop_step #t #aLen a b i (c1, res1) =
let pbits = bits t in
let (c, res) = generate_elem_f aLen (bn_sub_f a b) (i - 1) (c1, res1) in
let c, e = bn_sub_f a b (i - 1) c1 in
assert (v e - v c * pow2 pbits == v a.[i - 1] - v b.[i - 1] - v c1);
calc (==) {
bn_v #t #i res - v c * pow2 (pbits * i);
(==) { bn_eval_snoc #t #(i - 1) res1 e }
bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i);
(==) { }
eval_ aLen a (i - 1) - eval_ aLen b (i - 1) + (v a.[i - 1] - v b.[i - 1] + v c * pow2 pbits - v e) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i);
(==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1] - v b.[i - 1] + v c * pow2 pbits) (v e) (pow2 (pbits * (i - 1))) }
eval_ aLen a (i - 1) - eval_ aLen b (i - 1) + (v a.[i - 1] - v b.[i - 1] + v c * pow2 pbits) * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i);
(==) { Math.Lemmas.distributivity_add_left (v a.[i - 1] - v b.[i - 1]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) }
eval_ aLen a (i - 1) - eval_ aLen b (i - 1) + (v a.[i - 1] - v b.[i - 1]) * pow2 (pbits * (i - 1)) + v c * pow2 pbits * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i);
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen a (i - 1) - eval_ aLen b (i - 1) + (v a.[i - 1] - v b.[i - 1]) * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1]) (v b.[i - 1]) (pow2 (pbits * (i - 1))) }
eval_ aLen a (i - 1) - eval_ aLen b (i - 1) + v a.[i - 1] * pow2 (pbits * (i - 1)) - v b.[i - 1] * pow2 (pbits * (i - 1));
(==) { bn_eval_unfold_i a i }
eval_ aLen a i - eval_ aLen b (i - 1) - v b.[i - 1] * pow2 (pbits * (i - 1));
(==) { bn_eval_unfold_i b i }
eval_ aLen a i - eval_ aLen b i;
};
assert (bn_v #t #i res - v c * pow2 (pbits * i) == eval_ aLen a i - eval_ aLen b i)
val bn_sub_lemma_loop:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> b:lbignum t aLen
-> i:nat{i <= aLen} ->
Lemma (let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_sub_f a b) (uint #t 0) in
bn_v #t #i res - v c * pow2 (bits t * i) == eval_ aLen a i - eval_ aLen b i) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Addition.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Hacl.Spec.Bignum.Definitions.lbignum t aLen ->
b: Hacl.Spec.Bignum.Definitions.lbignum t aLen ->
i: Prims.nat{i <= aLen}
-> FStar.Pervasives.Lemma
(ensures
(let _ =
Hacl.Spec.Lib.generate_elems aLen
i
(Hacl.Spec.Bignum.Addition.bn_sub_f a b)
(Lib.IntTypes.uint 0)
in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ c res = _ in
let _ = _ in
Hacl.Spec.Bignum.Definitions.bn_v res -
Lib.IntTypes.v c * Prims.pow2 (Lib.IntTypes.bits t * i) ==
Hacl.Spec.Bignum.Definitions.eval_ aLen a i - Hacl.Spec.Bignum.Definitions.eval_ aLen b i)
<:
Type0)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Hacl.Spec.Bignum.Base.carry",
"Lib.Sequence.seq",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.eq2",
"Lib.Sequence.length",
"Prims.op_Equality",
"Prims.int",
"Prims.unit",
"Hacl.Spec.Bignum.Definitions.bn_eval0",
"FStar.Pervasives.assert_norm",
"Prims.pow2",
"Prims._assert",
"Prims.l_and",
"Lib.IntTypes.int_t",
"Lib.IntTypes.SEC",
"Prims.l_or",
"Lib.IntTypes.uint_v",
"Lib.IntTypes.range",
"Lib.IntTypes.v",
"Lib.IntTypes.uint",
"FStar.Seq.Base.seq",
"FStar.Seq.Base.length",
"FStar.Seq.Base.empty",
"Hacl.Spec.Lib.eq_generate_elems0",
"Hacl.Spec.Bignum.Addition.bn_sub_f",
"Prims.bool",
"Prims.op_Subtraction",
"Hacl.Spec.Bignum.Definitions.bn_v",
"FStar.Mul.op_Star",
"Lib.IntTypes.bits",
"Hacl.Spec.Bignum.Definitions.eval_",
"Hacl.Spec.Bignum.Addition.bn_sub_lemma_loop_step",
"FStar.Pervasives.Native.Mktuple2",
"Hacl.Spec.Bignum.Addition.bn_sub_lemma_loop",
"FStar.Pervasives.Native.tuple2",
"Prims.op_Addition",
"Hacl.Spec.Lib.generate_elem_f",
"Hacl.Spec.Lib.generate_elems",
"Hacl.Spec.Lib.generate_elems_unfold",
"Hacl.Spec.Lib.generate_elem_a"
] | [
"recursion"
] | false | false | true | false | false | let rec bn_sub_lemma_loop #t #aLen a b i =
| let c, res:generate_elem_a (limb t) (carry t) aLen i =
generate_elems aLen i (bn_sub_f a b) (uint #t 0)
in
if i = 0
then
(eq_generate_elems0 aLen i (bn_sub_f a b) (uint #t 0);
assert (c == uint #t 0 /\ res == Seq.empty);
bn_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
bn_eval0 b;
())
else
let c1, res1:generate_elem_a (limb t) (carry t) aLen (i - 1) =
generate_elems aLen (i - 1) (bn_sub_f a b) (uint #t 0)
in
generate_elems_unfold aLen i (bn_sub_f a b) (uint #t 0) (i - 1);
assert (generate_elems aLen i (bn_sub_f a b) (uint #t 0) ==
generate_elem_f aLen
(bn_sub_f a b)
(i - 1)
(generate_elems aLen (i - 1) (bn_sub_f a b) (uint #t 0)));
assert ((c, res) == generate_elem_f aLen (bn_sub_f a b) (i - 1) (c1, res1));
bn_sub_lemma_loop a b (i - 1);
assert (bn_v #t #(i - 1) res1 - v c1 * pow2 (bits t * (i - 1)) ==
eval_ aLen a (i - 1) - eval_ aLen b (i - 1));
bn_sub_lemma_loop_step a b i (c1, res1);
assert (bn_v #t #i res - v c * pow2 (bits t * i) == eval_ aLen a i - eval_ aLen b i);
() | false |
Hacl.Impl.Ed25519.Verify.fst | Hacl.Impl.Ed25519.Verify.point_inv_full_t | val point_inv_full_t : h: FStar.Monotonic.HyperStack.mem -> p: Hacl.Bignum25519.point -> Prims.logical | let point_inv_full_t (h:mem) (p:point) =
F51.point_inv_t h p /\ F51.inv_ext_point (as_seq h p) | {
"file_name": "code/ed25519/Hacl.Impl.Ed25519.Verify.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 55,
"end_line": 21,
"start_col": 0,
"start_line": 20
} | module Hacl.Impl.Ed25519.Verify
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
module ST = FStar.HyperStack.ST
module BSeq = Lib.ByteSequence
open Hacl.Bignum25519
module F51 = Hacl.Impl.Ed25519.Field51
module PM = Hacl.Impl.Ed25519.Ladder
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.Lemmas.fsti.checked",
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.SHA512.ModQ.fst.checked",
"Hacl.Impl.Load56.fst.checked",
"Hacl.Impl.Ed25519.PointEqual.fst.checked",
"Hacl.Impl.Ed25519.PointDecompress.fst.checked",
"Hacl.Impl.Ed25519.Ladder.fsti.checked",
"Hacl.Impl.Ed25519.Field51.fst.checked",
"Hacl.Bignum25519.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Ed25519.Verify.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Impl.Ed25519.Ladder",
"short_module": "PM"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Ed25519.Field51",
"short_module": "F51"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum25519",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | h: FStar.Monotonic.HyperStack.mem -> p: Hacl.Bignum25519.point -> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"FStar.Monotonic.HyperStack.mem",
"Hacl.Bignum25519.point",
"Prims.l_and",
"Hacl.Impl.Ed25519.Field51.point_inv_t",
"Hacl.Impl.Ed25519.Field51.inv_ext_point",
"Lib.Buffer.as_seq",
"Lib.Buffer.MUT",
"Lib.IntTypes.uint64",
"FStar.UInt32.__uint_to_t",
"Prims.logical"
] | [] | false | false | false | true | true | let point_inv_full_t (h: mem) (p: point) =
| F51.point_inv_t h p /\ F51.inv_ext_point (as_seq h p) | false |
|
Hacl.Spec.Bignum.Addition.fst | Hacl.Spec.Bignum.Addition.bn_sub_carry_lemma_loop_step | val bn_sub_carry_lemma_loop_step:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> c_in:carry t
-> i:pos{i <= aLen}
-> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma
(requires
(let (c1, res1) = c1_res1 in
bn_v #t #(i - 1) res1 - v c1 * pow2 (bits t * (i - 1)) == eval_ aLen a (i - 1) - v c_in))
(ensures
(let (c_out, res) = generate_elem_f aLen (bn_sub_carry_f a) (i - 1) c1_res1 in
bn_v #t #i res - v c_out * pow2 (bits t * i) == eval_ aLen a i - v c_in)) | val bn_sub_carry_lemma_loop_step:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> c_in:carry t
-> i:pos{i <= aLen}
-> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma
(requires
(let (c1, res1) = c1_res1 in
bn_v #t #(i - 1) res1 - v c1 * pow2 (bits t * (i - 1)) == eval_ aLen a (i - 1) - v c_in))
(ensures
(let (c_out, res) = generate_elem_f aLen (bn_sub_carry_f a) (i - 1) c1_res1 in
bn_v #t #i res - v c_out * pow2 (bits t * i) == eval_ aLen a i - v c_in)) | let bn_sub_carry_lemma_loop_step #t #aLen a c_in i (c1, res1) =
let pbits = bits t in
let (c_out, res) = generate_elem_f aLen (bn_sub_carry_f a) (i - 1) (c1, res1) in
let c, e = bn_sub_carry_f a (i - 1) c1 in
assert (v e - v c * pow2 pbits == v a.[i - 1] - v c1);
calc (==) {
bn_v #t #i res - v c * pow2 (pbits * i);
(==) { bn_eval_snoc #t #(i - 1) res1 e }
bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i);
(==) { }
eval_ aLen a (i - 1) - v c_in + (v a.[i - 1] - v e + v c * pow2 pbits) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i);
(==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1] + v c * pow2 pbits) (v e) (pow2 (pbits * (i - 1))) }
eval_ aLen a (i - 1) - v c_in + (v a.[i - 1] + v c * pow2 pbits) * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i);
(==) { Math.Lemmas.distributivity_add_left (v a.[i - 1]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) }
eval_ aLen a (i - 1) - v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)) + v c * pow2 pbits * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i);
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen a (i - 1) - v c_in + v a.[i - 1] * pow2 (pbits * (i - 1));
(==) { bn_eval_unfold_i a i }
eval_ aLen a i - v c_in;
};
assert (bn_v #t #i res - v c * pow2 (pbits * i) == eval_ aLen a i - v c_in) | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Addition.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 77,
"end_line": 358,
"start_col": 0,
"start_line": 337
} | module Hacl.Spec.Bignum.Addition
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_sub_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t
let bn_sub_carry_f #t #aLen a i c_in = subborrow c_in a.[i] (uint #t 0)
val bn_sub_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen)
let bn_sub_carry #t #aLen a c_in = generate_elems aLen aLen (bn_sub_carry_f a) c_in
val bn_sub_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t
let bn_sub_f #t #aLen a b i c = subborrow c a.[i] b.[i]
val bn_sub: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> tuple2 (carry t) (lbignum t aLen)
let bn_sub #t #aLen #bLen a b =
let c0, res0 = generate_elems bLen bLen (bn_sub_f (sub a 0 bLen) b) (uint #t 0) in
if bLen < aLen then
let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in
c1, concat #_ #bLen res0 res1
else c0, res0
val bn_sub1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen)
let bn_sub1 #t #aLen a b1 =
let c0, r0 = subborrow (uint #t 0) a.[0] b1 in
let res0 = create 1 r0 in
if 1 < aLen then
let c1, res1 = bn_sub_carry (sub a 1 (aLen - 1)) c0 in
c1, concat res0 res1
else c0, res0
val bn_add_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t
let bn_add_carry_f #t #aLen a i c_in = addcarry c_in a.[i] (uint #t 0)
val bn_add_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen)
let bn_add_carry #t #aLen a c_in = generate_elems aLen aLen (bn_add_carry_f a) c_in
val bn_add_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t
let bn_add_f #t #aLen a b i c = addcarry c a.[i] b.[i]
val bn_add: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> carry t & lbignum t aLen
let bn_add #t #aLen #bLen a b =
let c0, res0 = generate_elems bLen bLen (bn_add_f (sub a 0 bLen) b) (uint #t 0) in
if bLen < aLen then
let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in
c1, concat #_ #bLen res0 res1
else c0, res0
val bn_add1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen)
let bn_add1 #t #aLen a b1 =
let c0, r0 = addcarry (uint #t 0) a.[0] b1 in
let res0 = create 1 r0 in
if 1 < aLen then
let c1, res1 = bn_add_carry (sub a 1 (aLen - 1)) c0 in
c1, concat res0 res1
else c0, res0
val bn_add_carry_lemma_loop_step:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> c_in:carry t
-> i:pos{i <= aLen}
-> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma
(requires
(let (c1, res1) = c1_res1 in
v c1 * pow2 (bits t * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + v c_in))
(ensures
(let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) c1_res1 in
v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in))
let bn_add_carry_lemma_loop_step #t #aLen a c_in i (c1, res1) =
let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1) in
let c, e = bn_add_carry_f a (i - 1) c1 in
assert (v e + v c * pow2 (bits t) == v a.[i - 1] + v c1);
let pbits = bits t in
calc (==) {
v c * pow2 (pbits * i) + bn_v #t #i res;
(==) { bn_eval_snoc #t #(i - 1) res1 e }
v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1));
(==) { }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in - (v e + v c * pow2 pbits - v a.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1]) (pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + (v e - v e - v c * pow2 pbits + v a.[i - 1]) * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1));
(==) { bn_eval_unfold_i #t #aLen a i }
eval_ aLen a i + v c_in;
};
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in)
val bn_add_carry_lemma_loop:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> c_in:carry t
-> i:nat{i <= aLen} ->
Lemma (let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in
v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in)
let rec bn_add_carry_lemma_loop #t #aLen a c_in i =
let pbits = bits t in
let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in
if i = 0 then begin
eq_generate_elems0 aLen i (bn_add_carry_f a) c_in;
assert (c_out == c_in /\ res == Seq.empty);
bn_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
() end
else begin
let (c1, res1) : generate_elem_a (limb t) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_add_carry_f a) c_in in
generate_elems_unfold aLen i (bn_add_carry_f a) c_in (i - 1);
assert (generate_elems aLen i (bn_add_carry_f a) c_in ==
generate_elem_f aLen (bn_add_carry_f a) (i - 1) (generate_elems aLen (i - 1) (bn_add_carry_f a) c_in));
assert ((c_out, res) == generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1));
bn_add_carry_lemma_loop a c_in (i - 1);
assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + v c_in);
bn_add_carry_lemma_loop_step a c_in i (c1, res1);
assert (v c_out * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in);
() end
val bn_add_carry_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t ->
Lemma (let (c_out, res) = bn_add_carry a c_in in
v c_out * pow2 (bits t * aLen) + bn_v res == bn_v a + v c_in)
let bn_add_carry_lemma #t #aLen a c_in =
let (c_out, res) = bn_add_carry a c_in in
bn_add_carry_lemma_loop a c_in aLen
val bn_add_lemma_loop_step:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> b:lbignum t aLen
-> i:pos{i <= aLen}
-> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma
(requires
(let (c1, res1) = c1_res1 in
v c1 * pow2 (bits t * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + eval_ aLen b (i - 1)))
(ensures
(let (c1, res1) = c1_res1 in
let (c, res) = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in
v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i))
let bn_add_lemma_loop_step #t #aLen a b i (c1, res1) =
let pbits = bits t in
let (c, res) = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in
let c, e = bn_add_f a b (i - 1) c1 in
assert (v e + v c * pow2 pbits == v a.[i - 1] + v b.[i - 1] + v c1);
calc (==) {
v c * pow2 (pbits * i) + bn_v #t #i res;
(==) { bn_eval_snoc #t #(i - 1) res1 e }
v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1));
(==) { }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) - (v e + v c * pow2 pbits - v a.[i - 1] - v b.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1] - v b.[i - 1]) (pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v e - v e - v c * pow2 pbits + v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1] + v b.[i - 1]) (v c1 * pow2 pbits) (pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_add_left (v a.[i - 1]) (v b.[i - 1]) (pow2 (pbits * (i - 1))) }
eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + v a.[i - 1] * pow2 (pbits * (i - 1)) + v b.[i - 1] * pow2 (pbits * (i - 1));
(==) { bn_eval_unfold_i #t #aLen a i }
eval_ aLen a i + eval_ aLen b (i - 1) + v b.[i - 1] * pow2 (pbits * (i - 1));
(==) { bn_eval_unfold_i #t #aLen b i }
eval_ aLen a i + eval_ aLen b i;
};
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i)
val bn_add_lemma_loop:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> b:lbignum t aLen
-> i:nat{i <= aLen} ->
Lemma (let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_f a b) (uint #t 0) in
v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i)
let rec bn_add_lemma_loop #t #aLen a b i =
let pbits = bits t in
let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_f a b) (uint #t 0) in
if i = 0 then begin
eq_generate_elems0 aLen i (bn_add_f a b) (uint #t 0);
assert (c == uint #t 0 /\ res == Seq.empty);
bn_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
bn_eval0 b;
() end
else begin
let (c1, res1) : generate_elem_a (limb t) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_add_f a b) (uint #t 0) in
generate_elems_unfold aLen i (bn_add_f a b) (uint #t 0) (i - 1);
assert (generate_elems aLen i (bn_add_f a b) (uint #t 0) ==
generate_elem_f aLen (bn_add_f a b) (i - 1) (generate_elems aLen (i - 1) (bn_add_f a b) (uint #t 0)));
assert ((c, res) == generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1));
bn_add_lemma_loop a b (i - 1);
assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + eval_ aLen b (i - 1));
bn_add_lemma_loop_step a b i (c1, res1);
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i);
() end
val bn_add_concat_lemma:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat{bLen < aLen}
-> a:lbignum t aLen
-> b:lbignum t bLen
-> c0:carry t
-> res0:lbignum t bLen -> Lemma
(requires
v c0 * pow2 (bits t * bLen) + bn_v #t #bLen res0 == eval_ bLen (sub a 0 bLen) bLen + eval_ bLen b bLen)
(ensures
(let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in
let res = concat #_ #bLen res0 res1 in
bn_v res == eval_ aLen a aLen + eval_ bLen b bLen - v c1 * pow2 (bits t * aLen)))
let bn_add_concat_lemma #t #aLen #bLen a b c0 res0 =
let pbits = bits t in
let a0 = sub a 0 bLen in
let a1 = sub a bLen (aLen - bLen) in
let c1, res1 = bn_add_carry a1 c0 in
bn_add_carry_lemma a1 c0;
assert (v c1 * pow2 (pbits * (aLen - bLen)) + bn_v res1 == bn_v a1 + v c0);
let res = concat #_ #bLen res0 res1 in
bn_concat_lemma res0 res1;
assert (bn_v res == bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1);
calc (==) {
bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1;
(==) { }
eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0 - v c1 * pow2 (pbits * (aLen - bLen)));
(==) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * bLen)) (bn_v a1 + v c0) (v c1 * pow2 (pbits * (aLen - bLen))) }
eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0) - pow2 (pbits * bLen) * v c1 * pow2 (pbits * (aLen - bLen));
(==) { Math.Lemmas.paren_mul_right (pow2 (pbits * bLen)) (v c1) (pow2 (pbits * (aLen - bLen))); Math.Lemmas.pow2_plus (pbits * bLen) (pbits * (aLen - bLen)) }
eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0) - v c1 * pow2 (pbits * aLen);
(==) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * bLen)) (bn_v a1) (v c0) }
eval_ bLen a0 bLen + eval_ bLen b bLen + pow2 (pbits * bLen) * bn_v a1 - v c1 * pow2 (pbits * aLen);
(==) { bn_eval_split_i a bLen; bn_eval_extensionality_j a (sub a 0 bLen) bLen }
eval_ aLen a aLen + eval_ bLen b bLen - v c1 * pow2 (pbits * aLen);
}
val bn_add_lemma:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat{bLen <= aLen}
-> a:lbignum t aLen
-> b:lbignum t bLen ->
Lemma (let (c, res) = bn_add a b in
v c * pow2 (bits t * aLen) + bn_v res == bn_v a + bn_v b)
let bn_add_lemma #t #aLen #bLen a b =
let pbits = bits t in
let (c, res) = bn_add a b in
if bLen = aLen then
bn_add_lemma_loop a b aLen
else begin
let a0 = sub a 0 bLen in
let a1 = sub a bLen (aLen - bLen) in
let c0, res0 = generate_elems bLen bLen (bn_add_f a0 b) (uint #t 0) in
bn_add_lemma_loop a0 b bLen;
assert (v c0 * pow2 (pbits * bLen) + bn_v #t #bLen res0 == eval_ bLen a0 bLen + eval_ bLen b bLen);
bn_add_concat_lemma #t #aLen #bLen a b c0 res0 end
val bn_add1_lemma:
#t:limb_t
-> #aLen:size_pos
-> a:lbignum t aLen
-> b1:limb t ->
Lemma (let (c, res) = bn_add1 a b1 in
v c * pow2 (bits t * aLen) + bn_v res == bn_v a + v b1)
let bn_add1_lemma #t #aLen a b1 =
let pbits = bits t in
let c0, r0 = addcarry (uint #t 0) a.[0] b1 in
assert (v c0 * pow2 pbits + v r0 = v a.[0] + v b1);
let res0 = create 1 r0 in
let b = create 1 b1 in
bn_eval1 res0;
bn_eval1 b;
if aLen = 1 then
bn_eval1 a
else begin
let bLen = 1 in
let a0 = sub a 0 bLen in
bn_eval1 a0;
assert (v c0 * pow2 (pbits * bLen) + bn_v #t #1 res0 == eval_ bLen a0 bLen + eval_ bLen b bLen);
bn_add_concat_lemma a b c0 res0 end
val bn_sub_carry_lemma_loop_step:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> c_in:carry t
-> i:pos{i <= aLen}
-> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma
(requires
(let (c1, res1) = c1_res1 in
bn_v #t #(i - 1) res1 - v c1 * pow2 (bits t * (i - 1)) == eval_ aLen a (i - 1) - v c_in))
(ensures
(let (c_out, res) = generate_elem_f aLen (bn_sub_carry_f a) (i - 1) c1_res1 in
bn_v #t #i res - v c_out * pow2 (bits t * i) == eval_ aLen a i - v c_in)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Addition.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Hacl.Spec.Bignum.Definitions.lbignum t aLen ->
c_in: Hacl.Spec.Bignum.Base.carry t ->
i: Prims.pos{i <= aLen} ->
c1_res1:
Hacl.Spec.Lib.generate_elem_a (Hacl.Spec.Bignum.Definitions.limb t)
(Hacl.Spec.Bignum.Base.carry t)
aLen
(i - 1)
-> FStar.Pervasives.Lemma
(requires
(let _ = c1_res1 in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ c1 res1 = _ in
Hacl.Spec.Bignum.Definitions.bn_v res1 -
Lib.IntTypes.v c1 * Prims.pow2 (Lib.IntTypes.bits t * (i - 1)) ==
Hacl.Spec.Bignum.Definitions.eval_ aLen a (i - 1) - Lib.IntTypes.v c_in)
<:
Type0))
(ensures
(let _ =
Hacl.Spec.Lib.generate_elem_f aLen
(Hacl.Spec.Bignum.Addition.bn_sub_carry_f a)
(i - 1)
c1_res1
in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ c_out res = _ in
Hacl.Spec.Bignum.Definitions.bn_v res -
Lib.IntTypes.v c_out * Prims.pow2 (Lib.IntTypes.bits t * i) ==
Hacl.Spec.Bignum.Definitions.eval_ aLen a i - Lib.IntTypes.v c_in)
<:
Type0)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Base.carry",
"Prims.pos",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Hacl.Spec.Lib.generate_elem_a",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.op_Subtraction",
"Lib.Sequence.seq",
"Prims.eq2",
"Prims.nat",
"Lib.Sequence.length",
"Prims.op_Addition",
"Prims._assert",
"Prims.int",
"Hacl.Spec.Bignum.Definitions.bn_v",
"FStar.Mul.op_Star",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Prims.pow2",
"Hacl.Spec.Bignum.Definitions.eval_",
"Prims.unit",
"FStar.Calc.calc_finish",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"FStar.Calc.calc_step",
"Lib.Sequence.op_String_Access",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Hacl.Spec.Bignum.Definitions.bn_eval_snoc",
"Prims.squash",
"FStar.Math.Lemmas.distributivity_sub_left",
"FStar.Math.Lemmas.distributivity_add_left",
"FStar.Math.Lemmas.pow2_plus",
"FStar.Math.Lemmas.paren_mul_right",
"Hacl.Spec.Bignum.Definitions.bn_eval_unfold_i",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.Bignum.Addition.bn_sub_carry_f",
"Hacl.Spec.Lib.generate_elem_f",
"FStar.Pervasives.Native.Mktuple2",
"Lib.IntTypes.bits"
] | [] | false | false | true | false | false | let bn_sub_carry_lemma_loop_step #t #aLen a c_in i (c1, res1) =
| let pbits = bits t in
let c_out, res = generate_elem_f aLen (bn_sub_carry_f a) (i - 1) (c1, res1) in
let c, e = bn_sub_carry_f a (i - 1) c1 in
assert (v e - v c * pow2 pbits == v a.[ i - 1 ] - v c1);
calc ( == ) {
bn_v #t #i res - v c * pow2 (pbits * i);
( == ) { bn_eval_snoc #t #(i - 1) res1 e }
bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i);
( == ) { () }
eval_ aLen a (i - 1) - v c_in + (v a.[ i - 1 ] - v e + v c * pow2 pbits) * pow2 (pbits * (i - 1)) +
v e * pow2 (pbits * (i - 1)) -
v c * pow2 (pbits * i);
( == ) { Math.Lemmas.distributivity_sub_left (v a.[ i - 1 ] + v c * pow2 pbits)
(v e)
(pow2 (pbits * (i - 1))) }
eval_ aLen a (i - 1) - v c_in + (v a.[ i - 1 ] + v c * pow2 pbits) * pow2 (pbits * (i - 1)) -
v c * pow2 (pbits * i);
( == ) { Math.Lemmas.distributivity_add_left (v a.[ i - 1 ])
(v c * pow2 pbits)
(pow2 (pbits * (i - 1))) }
eval_ aLen a (i - 1) - v c_in + v a.[ i - 1 ] * pow2 (pbits * (i - 1)) +
(v c * pow2 pbits) * pow2 (pbits * (i - 1)) -
v c * pow2 (pbits * i);
( == ) { (Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1)));
Math.Lemmas.pow2_plus pbits (pbits * (i - 1))) }
eval_ aLen a (i - 1) - v c_in + v a.[ i - 1 ] * pow2 (pbits * (i - 1));
( == ) { bn_eval_unfold_i a i }
eval_ aLen a i - v c_in;
};
assert (bn_v #t #i res - v c * pow2 (pbits * i) == eval_ aLen a i - v c_in) | false |
Hacl.Spec.Bignum.Addition.fst | Hacl.Spec.Bignum.Addition.bn_add_carry_lemma_loop_step | val bn_add_carry_lemma_loop_step:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> c_in:carry t
-> i:pos{i <= aLen}
-> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma
(requires
(let (c1, res1) = c1_res1 in
v c1 * pow2 (bits t * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + v c_in))
(ensures
(let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) c1_res1 in
v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in)) | val bn_add_carry_lemma_loop_step:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> c_in:carry t
-> i:pos{i <= aLen}
-> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma
(requires
(let (c1, res1) = c1_res1 in
v c1 * pow2 (bits t * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + v c_in))
(ensures
(let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) c1_res1 in
v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in)) | let bn_add_carry_lemma_loop_step #t #aLen a c_in i (c1, res1) =
let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1) in
let c, e = bn_add_carry_f a (i - 1) c1 in
assert (v e + v c * pow2 (bits t) == v a.[i - 1] + v c1);
let pbits = bits t in
calc (==) {
v c * pow2 (pbits * i) + bn_v #t #i res;
(==) { bn_eval_snoc #t #(i - 1) res1 e }
v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1));
(==) { }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in - (v e + v c * pow2 pbits - v a.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1]) (pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + (v e - v e - v c * pow2 pbits + v a.[i - 1]) * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1));
(==) { bn_eval_unfold_i #t #aLen a i }
eval_ aLen a i + v c_in;
};
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in) | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Addition.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 77,
"end_line": 108,
"start_col": 0,
"start_line": 87
} | module Hacl.Spec.Bignum.Addition
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_sub_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t
let bn_sub_carry_f #t #aLen a i c_in = subborrow c_in a.[i] (uint #t 0)
val bn_sub_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen)
let bn_sub_carry #t #aLen a c_in = generate_elems aLen aLen (bn_sub_carry_f a) c_in
val bn_sub_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t
let bn_sub_f #t #aLen a b i c = subborrow c a.[i] b.[i]
val bn_sub: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> tuple2 (carry t) (lbignum t aLen)
let bn_sub #t #aLen #bLen a b =
let c0, res0 = generate_elems bLen bLen (bn_sub_f (sub a 0 bLen) b) (uint #t 0) in
if bLen < aLen then
let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in
c1, concat #_ #bLen res0 res1
else c0, res0
val bn_sub1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen)
let bn_sub1 #t #aLen a b1 =
let c0, r0 = subborrow (uint #t 0) a.[0] b1 in
let res0 = create 1 r0 in
if 1 < aLen then
let c1, res1 = bn_sub_carry (sub a 1 (aLen - 1)) c0 in
c1, concat res0 res1
else c0, res0
val bn_add_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t
let bn_add_carry_f #t #aLen a i c_in = addcarry c_in a.[i] (uint #t 0)
val bn_add_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen)
let bn_add_carry #t #aLen a c_in = generate_elems aLen aLen (bn_add_carry_f a) c_in
val bn_add_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t
let bn_add_f #t #aLen a b i c = addcarry c a.[i] b.[i]
val bn_add: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> carry t & lbignum t aLen
let bn_add #t #aLen #bLen a b =
let c0, res0 = generate_elems bLen bLen (bn_add_f (sub a 0 bLen) b) (uint #t 0) in
if bLen < aLen then
let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in
c1, concat #_ #bLen res0 res1
else c0, res0
val bn_add1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen)
let bn_add1 #t #aLen a b1 =
let c0, r0 = addcarry (uint #t 0) a.[0] b1 in
let res0 = create 1 r0 in
if 1 < aLen then
let c1, res1 = bn_add_carry (sub a 1 (aLen - 1)) c0 in
c1, concat res0 res1
else c0, res0
val bn_add_carry_lemma_loop_step:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> c_in:carry t
-> i:pos{i <= aLen}
-> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma
(requires
(let (c1, res1) = c1_res1 in
v c1 * pow2 (bits t * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + v c_in))
(ensures
(let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) c1_res1 in
v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Addition.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Hacl.Spec.Bignum.Definitions.lbignum t aLen ->
c_in: Hacl.Spec.Bignum.Base.carry t ->
i: Prims.pos{i <= aLen} ->
c1_res1:
Hacl.Spec.Lib.generate_elem_a (Hacl.Spec.Bignum.Definitions.limb t)
(Hacl.Spec.Bignum.Base.carry t)
aLen
(i - 1)
-> FStar.Pervasives.Lemma
(requires
(let _ = c1_res1 in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ c1 res1 = _ in
Lib.IntTypes.v c1 * Prims.pow2 (Lib.IntTypes.bits t * (i - 1)) +
Hacl.Spec.Bignum.Definitions.bn_v res1 ==
Hacl.Spec.Bignum.Definitions.eval_ aLen a (i - 1) + Lib.IntTypes.v c_in)
<:
Type0))
(ensures
(let _ =
Hacl.Spec.Lib.generate_elem_f aLen
(Hacl.Spec.Bignum.Addition.bn_add_carry_f a)
(i - 1)
c1_res1
in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ c_out res = _ in
Lib.IntTypes.v c_out * Prims.pow2 (Lib.IntTypes.bits t * i) +
Hacl.Spec.Bignum.Definitions.bn_v res ==
Hacl.Spec.Bignum.Definitions.eval_ aLen a i + Lib.IntTypes.v c_in)
<:
Type0)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Base.carry",
"Prims.pos",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Hacl.Spec.Lib.generate_elem_a",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.op_Subtraction",
"Lib.Sequence.seq",
"Prims.eq2",
"Prims.nat",
"Lib.Sequence.length",
"Prims.op_Addition",
"Prims._assert",
"Prims.int",
"FStar.Mul.op_Star",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Prims.pow2",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Hacl.Spec.Bignum.Definitions.eval_",
"Prims.unit",
"FStar.Calc.calc_finish",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"FStar.Calc.calc_step",
"Lib.Sequence.op_String_Access",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Hacl.Spec.Bignum.Definitions.bn_eval_snoc",
"Prims.squash",
"FStar.Math.Lemmas.distributivity_sub_left",
"FStar.Math.Lemmas.pow2_plus",
"FStar.Math.Lemmas.paren_mul_right",
"Hacl.Spec.Bignum.Definitions.bn_eval_unfold_i",
"Lib.IntTypes.bits",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.Bignum.Addition.bn_add_carry_f",
"Hacl.Spec.Lib.generate_elem_f",
"FStar.Pervasives.Native.Mktuple2"
] | [] | false | false | true | false | false | let bn_add_carry_lemma_loop_step #t #aLen a c_in i (c1, res1) =
| let c_out, res = generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1) in
let c, e = bn_add_carry_f a (i - 1) c1 in
assert (v e + v c * pow2 (bits t) == v a.[ i - 1 ] + v c1);
let pbits = bits t in
calc ( == ) {
v c * pow2 (pbits * i) + bn_v #t #i res;
( == ) { bn_eval_snoc #t #(i - 1) res1 e }
v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1));
( == ) { () }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in -
(v e + v c * pow2 pbits - v a.[ i - 1 ]) * pow2 (pbits * (i - 1)) +
v e * pow2 (pbits * (i - 1));
( == ) { Math.Lemmas.distributivity_sub_left (v e)
(v e + v c * pow2 pbits - v a.[ i - 1 ])
(pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in +
(v e - v e - v c * pow2 pbits + v a.[ i - 1 ]) * pow2 (pbits * (i - 1));
( == ) { Math.Lemmas.distributivity_sub_left (v a.[ i - 1 ])
(v c * pow2 pbits)
(pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + v a.[ i - 1 ] * pow2 (pbits * (i - 1)) -
(v c * pow2 pbits) * pow2 (pbits * (i - 1));
( == ) { (Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1)));
Math.Lemmas.pow2_plus pbits (pbits * (i - 1))) }
eval_ aLen a (i - 1) + v c_in + v a.[ i - 1 ] * pow2 (pbits * (i - 1));
( == ) { bn_eval_unfold_i #t #aLen a i }
eval_ aLen a i + v c_in;
};
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in) | false |
Hacl.Spec.Bignum.Addition.fst | Hacl.Spec.Bignum.Addition.bn_add_concat_lemma | val bn_add_concat_lemma:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat{bLen < aLen}
-> a:lbignum t aLen
-> b:lbignum t bLen
-> c0:carry t
-> res0:lbignum t bLen -> Lemma
(requires
v c0 * pow2 (bits t * bLen) + bn_v #t #bLen res0 == eval_ bLen (sub a 0 bLen) bLen + eval_ bLen b bLen)
(ensures
(let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in
let res = concat #_ #bLen res0 res1 in
bn_v res == eval_ aLen a aLen + eval_ bLen b bLen - v c1 * pow2 (bits t * aLen))) | val bn_add_concat_lemma:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat{bLen < aLen}
-> a:lbignum t aLen
-> b:lbignum t bLen
-> c0:carry t
-> res0:lbignum t bLen -> Lemma
(requires
v c0 * pow2 (bits t * bLen) + bn_v #t #bLen res0 == eval_ bLen (sub a 0 bLen) bLen + eval_ bLen b bLen)
(ensures
(let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in
let res = concat #_ #bLen res0 res1 in
bn_v res == eval_ aLen a aLen + eval_ bLen b bLen - v c1 * pow2 (bits t * aLen))) | let bn_add_concat_lemma #t #aLen #bLen a b c0 res0 =
let pbits = bits t in
let a0 = sub a 0 bLen in
let a1 = sub a bLen (aLen - bLen) in
let c1, res1 = bn_add_carry a1 c0 in
bn_add_carry_lemma a1 c0;
assert (v c1 * pow2 (pbits * (aLen - bLen)) + bn_v res1 == bn_v a1 + v c0);
let res = concat #_ #bLen res0 res1 in
bn_concat_lemma res0 res1;
assert (bn_v res == bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1);
calc (==) {
bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1;
(==) { }
eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0 - v c1 * pow2 (pbits * (aLen - bLen)));
(==) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * bLen)) (bn_v a1 + v c0) (v c1 * pow2 (pbits * (aLen - bLen))) }
eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0) - pow2 (pbits * bLen) * v c1 * pow2 (pbits * (aLen - bLen));
(==) { Math.Lemmas.paren_mul_right (pow2 (pbits * bLen)) (v c1) (pow2 (pbits * (aLen - bLen))); Math.Lemmas.pow2_plus (pbits * bLen) (pbits * (aLen - bLen)) }
eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0) - v c1 * pow2 (pbits * aLen);
(==) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * bLen)) (bn_v a1) (v c0) }
eval_ bLen a0 bLen + eval_ bLen b bLen + pow2 (pbits * bLen) * bn_v a1 - v c1 * pow2 (pbits * aLen);
(==) { bn_eval_split_i a bLen; bn_eval_extensionality_j a (sub a 0 bLen) bLen }
eval_ aLen a aLen + eval_ bLen b bLen - v c1 * pow2 (pbits * aLen);
} | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Addition.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 267,
"start_col": 0,
"start_line": 243
} | module Hacl.Spec.Bignum.Addition
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_sub_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t
let bn_sub_carry_f #t #aLen a i c_in = subborrow c_in a.[i] (uint #t 0)
val bn_sub_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen)
let bn_sub_carry #t #aLen a c_in = generate_elems aLen aLen (bn_sub_carry_f a) c_in
val bn_sub_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t
let bn_sub_f #t #aLen a b i c = subborrow c a.[i] b.[i]
val bn_sub: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> tuple2 (carry t) (lbignum t aLen)
let bn_sub #t #aLen #bLen a b =
let c0, res0 = generate_elems bLen bLen (bn_sub_f (sub a 0 bLen) b) (uint #t 0) in
if bLen < aLen then
let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in
c1, concat #_ #bLen res0 res1
else c0, res0
val bn_sub1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen)
let bn_sub1 #t #aLen a b1 =
let c0, r0 = subborrow (uint #t 0) a.[0] b1 in
let res0 = create 1 r0 in
if 1 < aLen then
let c1, res1 = bn_sub_carry (sub a 1 (aLen - 1)) c0 in
c1, concat res0 res1
else c0, res0
val bn_add_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t
let bn_add_carry_f #t #aLen a i c_in = addcarry c_in a.[i] (uint #t 0)
val bn_add_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen)
let bn_add_carry #t #aLen a c_in = generate_elems aLen aLen (bn_add_carry_f a) c_in
val bn_add_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t
let bn_add_f #t #aLen a b i c = addcarry c a.[i] b.[i]
val bn_add: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> carry t & lbignum t aLen
let bn_add #t #aLen #bLen a b =
let c0, res0 = generate_elems bLen bLen (bn_add_f (sub a 0 bLen) b) (uint #t 0) in
if bLen < aLen then
let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in
c1, concat #_ #bLen res0 res1
else c0, res0
val bn_add1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen)
let bn_add1 #t #aLen a b1 =
let c0, r0 = addcarry (uint #t 0) a.[0] b1 in
let res0 = create 1 r0 in
if 1 < aLen then
let c1, res1 = bn_add_carry (sub a 1 (aLen - 1)) c0 in
c1, concat res0 res1
else c0, res0
val bn_add_carry_lemma_loop_step:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> c_in:carry t
-> i:pos{i <= aLen}
-> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma
(requires
(let (c1, res1) = c1_res1 in
v c1 * pow2 (bits t * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + v c_in))
(ensures
(let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) c1_res1 in
v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in))
let bn_add_carry_lemma_loop_step #t #aLen a c_in i (c1, res1) =
let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1) in
let c, e = bn_add_carry_f a (i - 1) c1 in
assert (v e + v c * pow2 (bits t) == v a.[i - 1] + v c1);
let pbits = bits t in
calc (==) {
v c * pow2 (pbits * i) + bn_v #t #i res;
(==) { bn_eval_snoc #t #(i - 1) res1 e }
v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1));
(==) { }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in - (v e + v c * pow2 pbits - v a.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1]) (pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + (v e - v e - v c * pow2 pbits + v a.[i - 1]) * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1));
(==) { bn_eval_unfold_i #t #aLen a i }
eval_ aLen a i + v c_in;
};
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in)
val bn_add_carry_lemma_loop:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> c_in:carry t
-> i:nat{i <= aLen} ->
Lemma (let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in
v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in)
let rec bn_add_carry_lemma_loop #t #aLen a c_in i =
let pbits = bits t in
let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in
if i = 0 then begin
eq_generate_elems0 aLen i (bn_add_carry_f a) c_in;
assert (c_out == c_in /\ res == Seq.empty);
bn_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
() end
else begin
let (c1, res1) : generate_elem_a (limb t) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_add_carry_f a) c_in in
generate_elems_unfold aLen i (bn_add_carry_f a) c_in (i - 1);
assert (generate_elems aLen i (bn_add_carry_f a) c_in ==
generate_elem_f aLen (bn_add_carry_f a) (i - 1) (generate_elems aLen (i - 1) (bn_add_carry_f a) c_in));
assert ((c_out, res) == generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1));
bn_add_carry_lemma_loop a c_in (i - 1);
assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + v c_in);
bn_add_carry_lemma_loop_step a c_in i (c1, res1);
assert (v c_out * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in);
() end
val bn_add_carry_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t ->
Lemma (let (c_out, res) = bn_add_carry a c_in in
v c_out * pow2 (bits t * aLen) + bn_v res == bn_v a + v c_in)
let bn_add_carry_lemma #t #aLen a c_in =
let (c_out, res) = bn_add_carry a c_in in
bn_add_carry_lemma_loop a c_in aLen
val bn_add_lemma_loop_step:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> b:lbignum t aLen
-> i:pos{i <= aLen}
-> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma
(requires
(let (c1, res1) = c1_res1 in
v c1 * pow2 (bits t * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + eval_ aLen b (i - 1)))
(ensures
(let (c1, res1) = c1_res1 in
let (c, res) = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in
v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i))
let bn_add_lemma_loop_step #t #aLen a b i (c1, res1) =
let pbits = bits t in
let (c, res) = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in
let c, e = bn_add_f a b (i - 1) c1 in
assert (v e + v c * pow2 pbits == v a.[i - 1] + v b.[i - 1] + v c1);
calc (==) {
v c * pow2 (pbits * i) + bn_v #t #i res;
(==) { bn_eval_snoc #t #(i - 1) res1 e }
v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1));
(==) { }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) - (v e + v c * pow2 pbits - v a.[i - 1] - v b.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1] - v b.[i - 1]) (pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v e - v e - v c * pow2 pbits + v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1] + v b.[i - 1]) (v c1 * pow2 pbits) (pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_add_left (v a.[i - 1]) (v b.[i - 1]) (pow2 (pbits * (i - 1))) }
eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + v a.[i - 1] * pow2 (pbits * (i - 1)) + v b.[i - 1] * pow2 (pbits * (i - 1));
(==) { bn_eval_unfold_i #t #aLen a i }
eval_ aLen a i + eval_ aLen b (i - 1) + v b.[i - 1] * pow2 (pbits * (i - 1));
(==) { bn_eval_unfold_i #t #aLen b i }
eval_ aLen a i + eval_ aLen b i;
};
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i)
val bn_add_lemma_loop:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> b:lbignum t aLen
-> i:nat{i <= aLen} ->
Lemma (let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_f a b) (uint #t 0) in
v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i)
let rec bn_add_lemma_loop #t #aLen a b i =
let pbits = bits t in
let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_f a b) (uint #t 0) in
if i = 0 then begin
eq_generate_elems0 aLen i (bn_add_f a b) (uint #t 0);
assert (c == uint #t 0 /\ res == Seq.empty);
bn_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
bn_eval0 b;
() end
else begin
let (c1, res1) : generate_elem_a (limb t) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_add_f a b) (uint #t 0) in
generate_elems_unfold aLen i (bn_add_f a b) (uint #t 0) (i - 1);
assert (generate_elems aLen i (bn_add_f a b) (uint #t 0) ==
generate_elem_f aLen (bn_add_f a b) (i - 1) (generate_elems aLen (i - 1) (bn_add_f a b) (uint #t 0)));
assert ((c, res) == generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1));
bn_add_lemma_loop a b (i - 1);
assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + eval_ aLen b (i - 1));
bn_add_lemma_loop_step a b i (c1, res1);
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i);
() end
val bn_add_concat_lemma:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat{bLen < aLen}
-> a:lbignum t aLen
-> b:lbignum t bLen
-> c0:carry t
-> res0:lbignum t bLen -> Lemma
(requires
v c0 * pow2 (bits t * bLen) + bn_v #t #bLen res0 == eval_ bLen (sub a 0 bLen) bLen + eval_ bLen b bLen)
(ensures
(let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in
let res = concat #_ #bLen res0 res1 in
bn_v res == eval_ aLen a aLen + eval_ bLen b bLen - v c1 * pow2 (bits t * aLen))) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Addition.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Hacl.Spec.Bignum.Definitions.lbignum t aLen ->
b: Hacl.Spec.Bignum.Definitions.lbignum t bLen ->
c0: Hacl.Spec.Bignum.Base.carry t ->
res0: Hacl.Spec.Bignum.Definitions.lbignum t bLen
-> FStar.Pervasives.Lemma
(requires
Lib.IntTypes.v c0 * Prims.pow2 (Lib.IntTypes.bits t * bLen) +
Hacl.Spec.Bignum.Definitions.bn_v res0 ==
Hacl.Spec.Bignum.Definitions.eval_ bLen (Lib.Sequence.sub a 0 bLen) bLen +
Hacl.Spec.Bignum.Definitions.eval_ bLen b bLen)
(ensures
(let _ =
Hacl.Spec.Bignum.Addition.bn_add_carry (Lib.Sequence.sub a bLen (aLen - bLen)) c0
in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ c1 res1 = _ in
let res = Lib.Sequence.concat res0 res1 in
Hacl.Spec.Bignum.Definitions.bn_v res ==
Hacl.Spec.Bignum.Definitions.eval_ aLen a aLen +
Hacl.Spec.Bignum.Definitions.eval_ bLen b bLen -
Lib.IntTypes.v c1 * Prims.pow2 (Lib.IntTypes.bits t * aLen))
<:
Type0)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThan",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Base.carry",
"Prims.op_Subtraction",
"FStar.Calc.calc_finish",
"Prims.int",
"Prims.eq2",
"Prims.op_Addition",
"Hacl.Spec.Bignum.Definitions.bn_v",
"FStar.Mul.op_Star",
"Prims.pow2",
"Hacl.Spec.Bignum.Definitions.eval_",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Prims.squash",
"FStar.Math.Lemmas.distributivity_sub_right",
"FStar.Math.Lemmas.pow2_plus",
"FStar.Math.Lemmas.paren_mul_right",
"Hacl.Spec.Bignum.Definitions.bn_eval_extensionality_j",
"Lib.Sequence.sub",
"Hacl.Spec.Bignum.Definitions.limb",
"Hacl.Spec.Bignum.Definitions.bn_eval_split_i",
"Prims._assert",
"Hacl.Spec.Bignum.Definitions.bn_concat_lemma",
"Lib.Sequence.lseq",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.append",
"Lib.Sequence.concat",
"Hacl.Spec.Bignum.Addition.bn_add_carry_lemma",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.Bignum.Addition.bn_add_carry",
"Prims.l_and",
"FStar.Seq.Base.slice",
"Prims.l_Forall",
"Prims.nat",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.index",
"Lib.IntTypes.bits"
] | [] | false | false | true | false | false | let bn_add_concat_lemma #t #aLen #bLen a b c0 res0 =
| let pbits = bits t in
let a0 = sub a 0 bLen in
let a1 = sub a bLen (aLen - bLen) in
let c1, res1 = bn_add_carry a1 c0 in
bn_add_carry_lemma a1 c0;
assert (v c1 * pow2 (pbits * (aLen - bLen)) + bn_v res1 == bn_v a1 + v c0);
let res = concat #_ #bLen res0 res1 in
bn_concat_lemma res0 res1;
assert (bn_v res == bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1);
calc ( == ) {
bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1;
( == ) { () }
eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) +
pow2 (pbits * bLen) * (bn_v a1 + v c0 - v c1 * pow2 (pbits * (aLen - bLen)));
( == ) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * bLen))
(bn_v a1 + v c0)
(v c1 * pow2 (pbits * (aLen - bLen))) }
eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) +
pow2 (pbits * bLen) * (bn_v a1 + v c0) -
(pow2 (pbits * bLen) * v c1) * pow2 (pbits * (aLen - bLen));
( == ) { (Math.Lemmas.paren_mul_right (pow2 (pbits * bLen)) (v c1) (pow2 (pbits * (aLen - bLen)));
Math.Lemmas.pow2_plus (pbits * bLen) (pbits * (aLen - bLen))) }
eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) +
pow2 (pbits * bLen) * (bn_v a1 + v c0) -
v c1 * pow2 (pbits * aLen);
( == ) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * bLen)) (bn_v a1) (v c0) }
eval_ bLen a0 bLen + eval_ bLen b bLen + pow2 (pbits * bLen) * bn_v a1 -
v c1 * pow2 (pbits * aLen);
( == ) { (bn_eval_split_i a bLen;
bn_eval_extensionality_j a (sub a 0 bLen) bLen) }
eval_ aLen a aLen + eval_ bLen b bLen - v c1 * pow2 (pbits * aLen);
} | false |
Hacl.Spec.Bignum.Addition.fst | Hacl.Spec.Bignum.Addition.bn_sub_concat_lemma | val bn_sub_concat_lemma:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat{bLen < aLen}
-> a:lbignum t aLen
-> b:lbignum t bLen
-> c0:carry t
-> res0:lbignum t bLen -> Lemma
(requires
bn_v #t #bLen res0 - v c0 * pow2 (bits t * bLen) == eval_ bLen (sub a 0 bLen) bLen - eval_ bLen b bLen)
(ensures
(let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in
let res = concat #_ #bLen res0 res1 in
bn_v res == eval_ aLen a aLen - eval_ bLen b bLen + v c1 * pow2 (bits t * aLen))) | val bn_sub_concat_lemma:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat{bLen < aLen}
-> a:lbignum t aLen
-> b:lbignum t bLen
-> c0:carry t
-> res0:lbignum t bLen -> Lemma
(requires
bn_v #t #bLen res0 - v c0 * pow2 (bits t * bLen) == eval_ bLen (sub a 0 bLen) bLen - eval_ bLen b bLen)
(ensures
(let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in
let res = concat #_ #bLen res0 res1 in
bn_v res == eval_ aLen a aLen - eval_ bLen b bLen + v c1 * pow2 (bits t * aLen))) | let bn_sub_concat_lemma #t #aLen #bLen a b c0 res0 =
let pbits = bits t in
let a0 = sub a 0 bLen in
let a1 = sub a bLen (aLen - bLen) in
let c1, res1 = bn_sub_carry a1 c0 in
bn_sub_carry_lemma a1 c0;
assert (bn_v res1 - v c1 * pow2 (pbits * (aLen - bLen)) == bn_v a1 - v c0);
let res = concat #_ #bLen res0 res1 in
bn_concat_lemma res0 res1;
assert (bn_v res == bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1);
calc (==) {
bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1;
(==) { }
eval_ bLen a0 bLen - eval_ bLen b bLen + v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 - v c0 + v c1 * pow2 (pbits * (aLen - bLen)));
(==) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * bLen)) (bn_v a1 + v c1 * pow2 (pbits * (aLen - bLen))) (v c0) }
eval_ bLen a0 bLen - eval_ bLen b bLen + v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c1 * pow2 (pbits * (aLen - bLen))) - pow2 (pbits * bLen) * v c0;
(==) { Math.Lemmas.distributivity_add_right (pow2 (pbits * bLen)) (bn_v a1) (v c1 * pow2 (pbits * (aLen - bLen))) }
eval_ bLen a0 bLen - eval_ bLen b bLen + pow2 (pbits * bLen) * bn_v a1 + pow2 (pbits * bLen) * v c1 * pow2 (pbits * (aLen - bLen));
(==) { Math.Lemmas.paren_mul_right (pow2 (pbits * bLen)) (v c1) (pow2 (pbits * (aLen - bLen))); Math.Lemmas.pow2_plus (pbits * bLen) (pbits * (aLen - bLen)) }
eval_ bLen a0 bLen - eval_ bLen b bLen + pow2 (pbits * bLen) * bn_v a1 + v c1 * pow2 (pbits * aLen);
(==) { bn_eval_split_i a bLen; bn_eval_extensionality_j a (sub a 0 bLen) bLen }
eval_ aLen a aLen - eval_ bLen b bLen + v c1 * pow2 (pbits * aLen);
} | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Addition.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 515,
"start_col": 0,
"start_line": 491
} | module Hacl.Spec.Bignum.Addition
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_sub_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t
let bn_sub_carry_f #t #aLen a i c_in = subborrow c_in a.[i] (uint #t 0)
val bn_sub_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen)
let bn_sub_carry #t #aLen a c_in = generate_elems aLen aLen (bn_sub_carry_f a) c_in
val bn_sub_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t
let bn_sub_f #t #aLen a b i c = subborrow c a.[i] b.[i]
val bn_sub: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> tuple2 (carry t) (lbignum t aLen)
let bn_sub #t #aLen #bLen a b =
let c0, res0 = generate_elems bLen bLen (bn_sub_f (sub a 0 bLen) b) (uint #t 0) in
if bLen < aLen then
let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in
c1, concat #_ #bLen res0 res1
else c0, res0
val bn_sub1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen)
let bn_sub1 #t #aLen a b1 =
let c0, r0 = subborrow (uint #t 0) a.[0] b1 in
let res0 = create 1 r0 in
if 1 < aLen then
let c1, res1 = bn_sub_carry (sub a 1 (aLen - 1)) c0 in
c1, concat res0 res1
else c0, res0
val bn_add_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t
let bn_add_carry_f #t #aLen a i c_in = addcarry c_in a.[i] (uint #t 0)
val bn_add_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen)
let bn_add_carry #t #aLen a c_in = generate_elems aLen aLen (bn_add_carry_f a) c_in
val bn_add_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t
let bn_add_f #t #aLen a b i c = addcarry c a.[i] b.[i]
val bn_add: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> carry t & lbignum t aLen
let bn_add #t #aLen #bLen a b =
let c0, res0 = generate_elems bLen bLen (bn_add_f (sub a 0 bLen) b) (uint #t 0) in
if bLen < aLen then
let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in
c1, concat #_ #bLen res0 res1
else c0, res0
val bn_add1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen)
let bn_add1 #t #aLen a b1 =
let c0, r0 = addcarry (uint #t 0) a.[0] b1 in
let res0 = create 1 r0 in
if 1 < aLen then
let c1, res1 = bn_add_carry (sub a 1 (aLen - 1)) c0 in
c1, concat res0 res1
else c0, res0
val bn_add_carry_lemma_loop_step:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> c_in:carry t
-> i:pos{i <= aLen}
-> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma
(requires
(let (c1, res1) = c1_res1 in
v c1 * pow2 (bits t * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + v c_in))
(ensures
(let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) c1_res1 in
v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in))
let bn_add_carry_lemma_loop_step #t #aLen a c_in i (c1, res1) =
let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1) in
let c, e = bn_add_carry_f a (i - 1) c1 in
assert (v e + v c * pow2 (bits t) == v a.[i - 1] + v c1);
let pbits = bits t in
calc (==) {
v c * pow2 (pbits * i) + bn_v #t #i res;
(==) { bn_eval_snoc #t #(i - 1) res1 e }
v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1));
(==) { }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in - (v e + v c * pow2 pbits - v a.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1]) (pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + (v e - v e - v c * pow2 pbits + v a.[i - 1]) * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1));
(==) { bn_eval_unfold_i #t #aLen a i }
eval_ aLen a i + v c_in;
};
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in)
val bn_add_carry_lemma_loop:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> c_in:carry t
-> i:nat{i <= aLen} ->
Lemma (let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in
v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in)
let rec bn_add_carry_lemma_loop #t #aLen a c_in i =
let pbits = bits t in
let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in
if i = 0 then begin
eq_generate_elems0 aLen i (bn_add_carry_f a) c_in;
assert (c_out == c_in /\ res == Seq.empty);
bn_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
() end
else begin
let (c1, res1) : generate_elem_a (limb t) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_add_carry_f a) c_in in
generate_elems_unfold aLen i (bn_add_carry_f a) c_in (i - 1);
assert (generate_elems aLen i (bn_add_carry_f a) c_in ==
generate_elem_f aLen (bn_add_carry_f a) (i - 1) (generate_elems aLen (i - 1) (bn_add_carry_f a) c_in));
assert ((c_out, res) == generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1));
bn_add_carry_lemma_loop a c_in (i - 1);
assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + v c_in);
bn_add_carry_lemma_loop_step a c_in i (c1, res1);
assert (v c_out * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in);
() end
val bn_add_carry_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t ->
Lemma (let (c_out, res) = bn_add_carry a c_in in
v c_out * pow2 (bits t * aLen) + bn_v res == bn_v a + v c_in)
let bn_add_carry_lemma #t #aLen a c_in =
let (c_out, res) = bn_add_carry a c_in in
bn_add_carry_lemma_loop a c_in aLen
val bn_add_lemma_loop_step:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> b:lbignum t aLen
-> i:pos{i <= aLen}
-> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma
(requires
(let (c1, res1) = c1_res1 in
v c1 * pow2 (bits t * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + eval_ aLen b (i - 1)))
(ensures
(let (c1, res1) = c1_res1 in
let (c, res) = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in
v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i))
let bn_add_lemma_loop_step #t #aLen a b i (c1, res1) =
let pbits = bits t in
let (c, res) = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in
let c, e = bn_add_f a b (i - 1) c1 in
assert (v e + v c * pow2 pbits == v a.[i - 1] + v b.[i - 1] + v c1);
calc (==) {
v c * pow2 (pbits * i) + bn_v #t #i res;
(==) { bn_eval_snoc #t #(i - 1) res1 e }
v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1));
(==) { }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) - (v e + v c * pow2 pbits - v a.[i - 1] - v b.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1] - v b.[i - 1]) (pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v e - v e - v c * pow2 pbits + v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1] + v b.[i - 1]) (v c1 * pow2 pbits) (pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_add_left (v a.[i - 1]) (v b.[i - 1]) (pow2 (pbits * (i - 1))) }
eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + v a.[i - 1] * pow2 (pbits * (i - 1)) + v b.[i - 1] * pow2 (pbits * (i - 1));
(==) { bn_eval_unfold_i #t #aLen a i }
eval_ aLen a i + eval_ aLen b (i - 1) + v b.[i - 1] * pow2 (pbits * (i - 1));
(==) { bn_eval_unfold_i #t #aLen b i }
eval_ aLen a i + eval_ aLen b i;
};
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i)
val bn_add_lemma_loop:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> b:lbignum t aLen
-> i:nat{i <= aLen} ->
Lemma (let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_f a b) (uint #t 0) in
v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i)
let rec bn_add_lemma_loop #t #aLen a b i =
let pbits = bits t in
let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_f a b) (uint #t 0) in
if i = 0 then begin
eq_generate_elems0 aLen i (bn_add_f a b) (uint #t 0);
assert (c == uint #t 0 /\ res == Seq.empty);
bn_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
bn_eval0 b;
() end
else begin
let (c1, res1) : generate_elem_a (limb t) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_add_f a b) (uint #t 0) in
generate_elems_unfold aLen i (bn_add_f a b) (uint #t 0) (i - 1);
assert (generate_elems aLen i (bn_add_f a b) (uint #t 0) ==
generate_elem_f aLen (bn_add_f a b) (i - 1) (generate_elems aLen (i - 1) (bn_add_f a b) (uint #t 0)));
assert ((c, res) == generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1));
bn_add_lemma_loop a b (i - 1);
assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + eval_ aLen b (i - 1));
bn_add_lemma_loop_step a b i (c1, res1);
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i);
() end
val bn_add_concat_lemma:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat{bLen < aLen}
-> a:lbignum t aLen
-> b:lbignum t bLen
-> c0:carry t
-> res0:lbignum t bLen -> Lemma
(requires
v c0 * pow2 (bits t * bLen) + bn_v #t #bLen res0 == eval_ bLen (sub a 0 bLen) bLen + eval_ bLen b bLen)
(ensures
(let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in
let res = concat #_ #bLen res0 res1 in
bn_v res == eval_ aLen a aLen + eval_ bLen b bLen - v c1 * pow2 (bits t * aLen)))
let bn_add_concat_lemma #t #aLen #bLen a b c0 res0 =
let pbits = bits t in
let a0 = sub a 0 bLen in
let a1 = sub a bLen (aLen - bLen) in
let c1, res1 = bn_add_carry a1 c0 in
bn_add_carry_lemma a1 c0;
assert (v c1 * pow2 (pbits * (aLen - bLen)) + bn_v res1 == bn_v a1 + v c0);
let res = concat #_ #bLen res0 res1 in
bn_concat_lemma res0 res1;
assert (bn_v res == bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1);
calc (==) {
bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1;
(==) { }
eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0 - v c1 * pow2 (pbits * (aLen - bLen)));
(==) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * bLen)) (bn_v a1 + v c0) (v c1 * pow2 (pbits * (aLen - bLen))) }
eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0) - pow2 (pbits * bLen) * v c1 * pow2 (pbits * (aLen - bLen));
(==) { Math.Lemmas.paren_mul_right (pow2 (pbits * bLen)) (v c1) (pow2 (pbits * (aLen - bLen))); Math.Lemmas.pow2_plus (pbits * bLen) (pbits * (aLen - bLen)) }
eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0) - v c1 * pow2 (pbits * aLen);
(==) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * bLen)) (bn_v a1) (v c0) }
eval_ bLen a0 bLen + eval_ bLen b bLen + pow2 (pbits * bLen) * bn_v a1 - v c1 * pow2 (pbits * aLen);
(==) { bn_eval_split_i a bLen; bn_eval_extensionality_j a (sub a 0 bLen) bLen }
eval_ aLen a aLen + eval_ bLen b bLen - v c1 * pow2 (pbits * aLen);
}
val bn_add_lemma:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat{bLen <= aLen}
-> a:lbignum t aLen
-> b:lbignum t bLen ->
Lemma (let (c, res) = bn_add a b in
v c * pow2 (bits t * aLen) + bn_v res == bn_v a + bn_v b)
let bn_add_lemma #t #aLen #bLen a b =
let pbits = bits t in
let (c, res) = bn_add a b in
if bLen = aLen then
bn_add_lemma_loop a b aLen
else begin
let a0 = sub a 0 bLen in
let a1 = sub a bLen (aLen - bLen) in
let c0, res0 = generate_elems bLen bLen (bn_add_f a0 b) (uint #t 0) in
bn_add_lemma_loop a0 b bLen;
assert (v c0 * pow2 (pbits * bLen) + bn_v #t #bLen res0 == eval_ bLen a0 bLen + eval_ bLen b bLen);
bn_add_concat_lemma #t #aLen #bLen a b c0 res0 end
val bn_add1_lemma:
#t:limb_t
-> #aLen:size_pos
-> a:lbignum t aLen
-> b1:limb t ->
Lemma (let (c, res) = bn_add1 a b1 in
v c * pow2 (bits t * aLen) + bn_v res == bn_v a + v b1)
let bn_add1_lemma #t #aLen a b1 =
let pbits = bits t in
let c0, r0 = addcarry (uint #t 0) a.[0] b1 in
assert (v c0 * pow2 pbits + v r0 = v a.[0] + v b1);
let res0 = create 1 r0 in
let b = create 1 b1 in
bn_eval1 res0;
bn_eval1 b;
if aLen = 1 then
bn_eval1 a
else begin
let bLen = 1 in
let a0 = sub a 0 bLen in
bn_eval1 a0;
assert (v c0 * pow2 (pbits * bLen) + bn_v #t #1 res0 == eval_ bLen a0 bLen + eval_ bLen b bLen);
bn_add_concat_lemma a b c0 res0 end
val bn_sub_carry_lemma_loop_step:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> c_in:carry t
-> i:pos{i <= aLen}
-> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma
(requires
(let (c1, res1) = c1_res1 in
bn_v #t #(i - 1) res1 - v c1 * pow2 (bits t * (i - 1)) == eval_ aLen a (i - 1) - v c_in))
(ensures
(let (c_out, res) = generate_elem_f aLen (bn_sub_carry_f a) (i - 1) c1_res1 in
bn_v #t #i res - v c_out * pow2 (bits t * i) == eval_ aLen a i - v c_in))
let bn_sub_carry_lemma_loop_step #t #aLen a c_in i (c1, res1) =
let pbits = bits t in
let (c_out, res) = generate_elem_f aLen (bn_sub_carry_f a) (i - 1) (c1, res1) in
let c, e = bn_sub_carry_f a (i - 1) c1 in
assert (v e - v c * pow2 pbits == v a.[i - 1] - v c1);
calc (==) {
bn_v #t #i res - v c * pow2 (pbits * i);
(==) { bn_eval_snoc #t #(i - 1) res1 e }
bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i);
(==) { }
eval_ aLen a (i - 1) - v c_in + (v a.[i - 1] - v e + v c * pow2 pbits) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i);
(==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1] + v c * pow2 pbits) (v e) (pow2 (pbits * (i - 1))) }
eval_ aLen a (i - 1) - v c_in + (v a.[i - 1] + v c * pow2 pbits) * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i);
(==) { Math.Lemmas.distributivity_add_left (v a.[i - 1]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) }
eval_ aLen a (i - 1) - v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)) + v c * pow2 pbits * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i);
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen a (i - 1) - v c_in + v a.[i - 1] * pow2 (pbits * (i - 1));
(==) { bn_eval_unfold_i a i }
eval_ aLen a i - v c_in;
};
assert (bn_v #t #i res - v c * pow2 (pbits * i) == eval_ aLen a i - v c_in)
val bn_sub_carry_lemma_loop:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> c_in:carry t
-> i:nat{i <= aLen} ->
Lemma (let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_sub_carry_f a) c_in in
bn_v #t #i res - v c_out * pow2 (bits t * i) == eval_ aLen a i - v c_in)
let rec bn_sub_carry_lemma_loop #t #aLen a c_in i =
let pbits = bits t in
let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_sub_carry_f a) c_in in
if i = 0 then begin
eq_generate_elems0 aLen i (bn_sub_carry_f a) c_in;
assert (c_out == c_in /\ res == Seq.empty);
bn_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
() end
else begin
let (c1, res1) : generate_elem_a (limb t) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_sub_carry_f a) c_in in
generate_elems_unfold aLen i (bn_sub_carry_f a) c_in (i - 1);
assert (generate_elems aLen i (bn_sub_carry_f a) c_in ==
generate_elem_f aLen (bn_sub_carry_f a) (i - 1) (generate_elems aLen (i - 1) (bn_sub_carry_f a) c_in));
assert ((c_out, res) == generate_elem_f aLen (bn_sub_carry_f a) (i - 1) (c1, res1));
bn_sub_carry_lemma_loop a c_in (i - 1);
assert (bn_v #t #(i - 1) res1 - v c1 * pow2 (pbits * (i - 1)) == eval_ aLen a (i - 1) - v c_in);
bn_sub_carry_lemma_loop_step a c_in i (c1, res1);
assert (bn_v #t #i res - v c_out * pow2 (pbits * i) == eval_ aLen a i - v c_in);
() end
val bn_sub_carry_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t ->
Lemma (let (c_out, res) = bn_sub_carry a c_in in
bn_v res - v c_out * pow2 (bits t * aLen) == bn_v a - v c_in)
let bn_sub_carry_lemma #t #aLen a c_in =
let (c_out, res) = bn_sub_carry a c_in in
bn_sub_carry_lemma_loop a c_in aLen
val bn_sub_lemma_loop_step:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> b:lbignum t aLen
-> i:pos{i <= aLen}
-> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma
(requires
(let (c1, res1) = c1_res1 in
bn_v #t #(i - 1) res1 - v c1 * pow2 (bits t * (i - 1)) == eval_ aLen a (i - 1) - eval_ aLen b (i - 1)))
(ensures
(let (c, res) = generate_elem_f aLen (bn_sub_f a b) (i - 1) c1_res1 in
bn_v #t #i res - v c * pow2 (bits t * i) == eval_ aLen a i - eval_ aLen b i))
let bn_sub_lemma_loop_step #t #aLen a b i (c1, res1) =
let pbits = bits t in
let (c, res) = generate_elem_f aLen (bn_sub_f a b) (i - 1) (c1, res1) in
let c, e = bn_sub_f a b (i - 1) c1 in
assert (v e - v c * pow2 pbits == v a.[i - 1] - v b.[i - 1] - v c1);
calc (==) {
bn_v #t #i res - v c * pow2 (pbits * i);
(==) { bn_eval_snoc #t #(i - 1) res1 e }
bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i);
(==) { }
eval_ aLen a (i - 1) - eval_ aLen b (i - 1) + (v a.[i - 1] - v b.[i - 1] + v c * pow2 pbits - v e) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i);
(==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1] - v b.[i - 1] + v c * pow2 pbits) (v e) (pow2 (pbits * (i - 1))) }
eval_ aLen a (i - 1) - eval_ aLen b (i - 1) + (v a.[i - 1] - v b.[i - 1] + v c * pow2 pbits) * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i);
(==) { Math.Lemmas.distributivity_add_left (v a.[i - 1] - v b.[i - 1]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) }
eval_ aLen a (i - 1) - eval_ aLen b (i - 1) + (v a.[i - 1] - v b.[i - 1]) * pow2 (pbits * (i - 1)) + v c * pow2 pbits * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i);
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen a (i - 1) - eval_ aLen b (i - 1) + (v a.[i - 1] - v b.[i - 1]) * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1]) (v b.[i - 1]) (pow2 (pbits * (i - 1))) }
eval_ aLen a (i - 1) - eval_ aLen b (i - 1) + v a.[i - 1] * pow2 (pbits * (i - 1)) - v b.[i - 1] * pow2 (pbits * (i - 1));
(==) { bn_eval_unfold_i a i }
eval_ aLen a i - eval_ aLen b (i - 1) - v b.[i - 1] * pow2 (pbits * (i - 1));
(==) { bn_eval_unfold_i b i }
eval_ aLen a i - eval_ aLen b i;
};
assert (bn_v #t #i res - v c * pow2 (pbits * i) == eval_ aLen a i - eval_ aLen b i)
val bn_sub_lemma_loop:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> b:lbignum t aLen
-> i:nat{i <= aLen} ->
Lemma (let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_sub_f a b) (uint #t 0) in
bn_v #t #i res - v c * pow2 (bits t * i) == eval_ aLen a i - eval_ aLen b i)
let rec bn_sub_lemma_loop #t #aLen a b i =
let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_sub_f a b) (uint #t 0) in
if i = 0 then begin
eq_generate_elems0 aLen i (bn_sub_f a b) (uint #t 0);
assert (c == uint #t 0 /\ res == Seq.empty);
bn_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
bn_eval0 b;
() end
else begin
let (c1, res1) : generate_elem_a (limb t) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_sub_f a b) (uint #t 0) in
generate_elems_unfold aLen i (bn_sub_f a b) (uint #t 0) (i - 1);
assert (generate_elems aLen i (bn_sub_f a b) (uint #t 0) ==
generate_elem_f aLen (bn_sub_f a b) (i - 1) (generate_elems aLen (i - 1) (bn_sub_f a b) (uint #t 0)));
assert ((c, res) == generate_elem_f aLen (bn_sub_f a b) (i - 1) (c1, res1));
bn_sub_lemma_loop a b (i - 1);
assert (bn_v #t #(i - 1) res1 - v c1 * pow2 (bits t * (i - 1)) == eval_ aLen a (i - 1) - eval_ aLen b (i - 1));
bn_sub_lemma_loop_step a b i (c1, res1);
assert (bn_v #t #i res - v c * pow2 (bits t * i) == eval_ aLen a i - eval_ aLen b i);
() end
val bn_sub_concat_lemma:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat{bLen < aLen}
-> a:lbignum t aLen
-> b:lbignum t bLen
-> c0:carry t
-> res0:lbignum t bLen -> Lemma
(requires
bn_v #t #bLen res0 - v c0 * pow2 (bits t * bLen) == eval_ bLen (sub a 0 bLen) bLen - eval_ bLen b bLen)
(ensures
(let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in
let res = concat #_ #bLen res0 res1 in
bn_v res == eval_ aLen a aLen - eval_ bLen b bLen + v c1 * pow2 (bits t * aLen))) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Addition.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Hacl.Spec.Bignum.Definitions.lbignum t aLen ->
b: Hacl.Spec.Bignum.Definitions.lbignum t bLen ->
c0: Hacl.Spec.Bignum.Base.carry t ->
res0: Hacl.Spec.Bignum.Definitions.lbignum t bLen
-> FStar.Pervasives.Lemma
(requires
Hacl.Spec.Bignum.Definitions.bn_v res0 -
Lib.IntTypes.v c0 * Prims.pow2 (Lib.IntTypes.bits t * bLen) ==
Hacl.Spec.Bignum.Definitions.eval_ bLen (Lib.Sequence.sub a 0 bLen) bLen -
Hacl.Spec.Bignum.Definitions.eval_ bLen b bLen)
(ensures
(let _ =
Hacl.Spec.Bignum.Addition.bn_sub_carry (Lib.Sequence.sub a bLen (aLen - bLen)) c0
in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ c1 res1 = _ in
let res = Lib.Sequence.concat res0 res1 in
Hacl.Spec.Bignum.Definitions.bn_v res ==
Hacl.Spec.Bignum.Definitions.eval_ aLen a aLen -
Hacl.Spec.Bignum.Definitions.eval_ bLen b bLen +
Lib.IntTypes.v c1 * Prims.pow2 (Lib.IntTypes.bits t * aLen))
<:
Type0)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThan",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Base.carry",
"Prims.op_Subtraction",
"FStar.Calc.calc_finish",
"Prims.int",
"Prims.eq2",
"Prims.op_Addition",
"Hacl.Spec.Bignum.Definitions.bn_v",
"FStar.Mul.op_Star",
"Prims.pow2",
"Hacl.Spec.Bignum.Definitions.eval_",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Prims.squash",
"FStar.Math.Lemmas.distributivity_sub_right",
"FStar.Math.Lemmas.distributivity_add_right",
"FStar.Math.Lemmas.pow2_plus",
"FStar.Math.Lemmas.paren_mul_right",
"Hacl.Spec.Bignum.Definitions.bn_eval_extensionality_j",
"Lib.Sequence.sub",
"Hacl.Spec.Bignum.Definitions.limb",
"Hacl.Spec.Bignum.Definitions.bn_eval_split_i",
"Prims._assert",
"Hacl.Spec.Bignum.Definitions.bn_concat_lemma",
"Lib.Sequence.lseq",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.append",
"Lib.Sequence.concat",
"Hacl.Spec.Bignum.Addition.bn_sub_carry_lemma",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.Bignum.Addition.bn_sub_carry",
"Prims.l_and",
"FStar.Seq.Base.slice",
"Prims.l_Forall",
"Prims.nat",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.index",
"Lib.IntTypes.bits"
] | [] | false | false | true | false | false | let bn_sub_concat_lemma #t #aLen #bLen a b c0 res0 =
| let pbits = bits t in
let a0 = sub a 0 bLen in
let a1 = sub a bLen (aLen - bLen) in
let c1, res1 = bn_sub_carry a1 c0 in
bn_sub_carry_lemma a1 c0;
assert (bn_v res1 - v c1 * pow2 (pbits * (aLen - bLen)) == bn_v a1 - v c0);
let res = concat #_ #bLen res0 res1 in
bn_concat_lemma res0 res1;
assert (bn_v res == bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1);
calc ( == ) {
bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1;
( == ) { () }
eval_ bLen a0 bLen - eval_ bLen b bLen + v c0 * pow2 (pbits * bLen) +
pow2 (pbits * bLen) * (bn_v a1 - v c0 + v c1 * pow2 (pbits * (aLen - bLen)));
( == ) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * bLen))
(bn_v a1 + v c1 * pow2 (pbits * (aLen - bLen)))
(v c0) }
eval_ bLen a0 bLen - eval_ bLen b bLen + v c0 * pow2 (pbits * bLen) +
pow2 (pbits * bLen) * (bn_v a1 + v c1 * pow2 (pbits * (aLen - bLen))) -
pow2 (pbits * bLen) * v c0;
( == ) { Math.Lemmas.distributivity_add_right (pow2 (pbits * bLen))
(bn_v a1)
(v c1 * pow2 (pbits * (aLen - bLen))) }
eval_ bLen a0 bLen - eval_ bLen b bLen + pow2 (pbits * bLen) * bn_v a1 +
(pow2 (pbits * bLen) * v c1) * pow2 (pbits * (aLen - bLen));
( == ) { (Math.Lemmas.paren_mul_right (pow2 (pbits * bLen)) (v c1) (pow2 (pbits * (aLen - bLen)));
Math.Lemmas.pow2_plus (pbits * bLen) (pbits * (aLen - bLen))) }
eval_ bLen a0 bLen - eval_ bLen b bLen + pow2 (pbits * bLen) * bn_v a1 +
v c1 * pow2 (pbits * aLen);
( == ) { (bn_eval_split_i a bLen;
bn_eval_extensionality_j a (sub a 0 bLen) bLen) }
eval_ aLen a aLen - eval_ bLen b bLen + v c1 * pow2 (pbits * aLen);
} | false |
Hacl.Impl.Blake2.Constants.fst | Hacl.Impl.Blake2.Constants.pp_sigmaTable | val pp_sigmaTable: Prims.unit -> Tactics.Tac unit | val pp_sigmaTable: Prims.unit -> Tactics.Tac unit | let pp_sigmaTable () : Tactics.Tac unit =
Tactics.norm [delta_only [`%Spec.list_sigma]]; Tactics.trefl () | {
"file_name": "code/blake2/Hacl.Impl.Blake2.Constants.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 65,
"end_line": 25,
"start_col": 0,
"start_line": 24
} | module Hacl.Impl.Blake2.Constants
open FStar.Mul
open FStar.HyperStack
open FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Lib.ByteBuffer
open Lib.LoopCombinators
module ST = FStar.HyperStack.ST
module Seq = Lib.Sequence
module Loops = Lib.LoopCombinators
module Spec = Spec.Blake2
/// We need to unfold manually the definition of the sigma table. This definition
/// was not declared as `inline_for_extraction` because otherwise it creates a lot
/// of work for the normalizer during the KaRaMeL extraction (which also explores
/// the ghost code, including the content of the assertions). However, we can't do
/// that by inserting manual calls to `norm` inside the code, because it blocks
/// the normalization performed by KaRaMeL, and we can't normalize as much as we
/// want because of the interface abstractions. The solution is to use post-processing. | {
"checked_file": "/",
"dependencies": [
"Spec.Blake2.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Blake2.Constants.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Blake2",
"short_module": "Spec"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteBuffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Blake2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Blake2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: Prims.unit -> FStar.Tactics.Effect.Tac Prims.unit | FStar.Tactics.Effect.Tac | [] | [] | [
"Prims.unit",
"FStar.Tactics.V1.Derived.trefl",
"FStar.Stubs.Tactics.V1.Builtins.norm",
"Prims.Cons",
"FStar.Pervasives.norm_step",
"FStar.Pervasives.delta_only",
"Prims.string",
"Prims.Nil"
] | [] | false | true | false | false | false | let pp_sigmaTable () : Tactics.Tac unit =
| Tactics.norm [delta_only [`%Spec.list_sigma]];
Tactics.trefl () | false |
Hacl.Impl.Ed25519.Verify.fst | Hacl.Impl.Ed25519.Verify.verify_sb | val verify_sb: sb:lbuffer uint8 32ul -> Stack bool
(requires fun h -> live h sb)
(ensures fun h0 b h1 -> modifies0 h0 h1 /\
(b <==> (BSeq.nat_from_bytes_le (as_seq h0 sb) >= Spec.Ed25519.q))) | val verify_sb: sb:lbuffer uint8 32ul -> Stack bool
(requires fun h -> live h sb)
(ensures fun h0 b h1 -> modifies0 h0 h1 /\
(b <==> (BSeq.nat_from_bytes_le (as_seq h0 sb) >= Spec.Ed25519.q))) | let verify_sb sb =
push_frame ();
let tmp = create 5ul (u64 0) in
Hacl.Impl.Load56.load_32_bytes tmp sb;
let b = Hacl.Impl.Ed25519.PointEqual.gte_q tmp in
pop_frame ();
b | {
"file_name": "code/ed25519/Hacl.Impl.Ed25519.Verify.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 60,
"start_col": 0,
"start_line": 54
} | module Hacl.Impl.Ed25519.Verify
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
module ST = FStar.HyperStack.ST
module BSeq = Lib.ByteSequence
open Hacl.Bignum25519
module F51 = Hacl.Impl.Ed25519.Field51
module PM = Hacl.Impl.Ed25519.Ladder
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let point_inv_full_t (h:mem) (p:point) =
F51.point_inv_t h p /\ F51.inv_ext_point (as_seq h p)
inline_for_extraction noextract
val verify_all_valid_hb (sb hb:lbuffer uint8 32ul) (a' r':point) : Stack bool
(requires fun h ->
live h sb /\ live h hb /\ live h a' /\ live h r' /\
point_inv_full_t h a' /\ point_inv_full_t h r')
(ensures fun h0 z h1 -> modifies0 h0 h1 /\
(z == Spec.Ed25519.(
let exp_d = point_negate_mul_double_g (as_seq h0 sb) (as_seq h0 hb) (F51.point_eval h0 a') in
point_equal exp_d (F51.point_eval h0 r'))))
let verify_all_valid_hb sb hb a' r' =
push_frame ();
let exp_d = create 20ul (u64 0) in
PM.point_negate_mul_double_g_vartime exp_d sb hb a';
let b = Hacl.Impl.Ed25519.PointEqual.point_equal exp_d r' in
let h0 = ST.get () in
Spec.Ed25519.Lemmas.point_equal_lemma
(F51.point_eval h0 exp_d)
(Spec.Ed25519.point_negate_mul_double_g (as_seq h0 sb) (as_seq h0 hb) (F51.point_eval h0 a'))
(F51.point_eval h0 r');
pop_frame ();
b
inline_for_extraction noextract
val verify_sb: sb:lbuffer uint8 32ul -> Stack bool
(requires fun h -> live h sb)
(ensures fun h0 b h1 -> modifies0 h0 h1 /\
(b <==> (BSeq.nat_from_bytes_le (as_seq h0 sb) >= Spec.Ed25519.q))) | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.Lemmas.fsti.checked",
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.SHA512.ModQ.fst.checked",
"Hacl.Impl.Load56.fst.checked",
"Hacl.Impl.Ed25519.PointEqual.fst.checked",
"Hacl.Impl.Ed25519.PointDecompress.fst.checked",
"Hacl.Impl.Ed25519.Ladder.fsti.checked",
"Hacl.Impl.Ed25519.Field51.fst.checked",
"Hacl.Bignum25519.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Ed25519.Verify.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Impl.Ed25519.Ladder",
"short_module": "PM"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Ed25519.Field51",
"short_module": "F51"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum25519",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | sb: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul -> FStar.HyperStack.ST.Stack Prims.bool | FStar.HyperStack.ST.Stack | [] | [] | [
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"FStar.UInt32.__uint_to_t",
"Prims.bool",
"Prims.unit",
"FStar.HyperStack.ST.pop_frame",
"Hacl.Impl.Ed25519.PointEqual.gte_q",
"Hacl.Impl.Load56.load_32_bytes",
"Lib.Buffer.lbuffer_t",
"Lib.Buffer.MUT",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"FStar.UInt32.uint_to_t",
"FStar.UInt32.t",
"Lib.Buffer.create",
"Lib.IntTypes.uint64",
"Lib.IntTypes.u64",
"FStar.HyperStack.ST.push_frame"
] | [] | false | true | false | false | false | let verify_sb sb =
| push_frame ();
let tmp = create 5ul (u64 0) in
Hacl.Impl.Load56.load_32_bytes tmp sb;
let b = Hacl.Impl.Ed25519.PointEqual.gte_q tmp in
pop_frame ();
b | false |
Vale.Transformers.Common.fsti | Vale.Transformers.Common.equiv_states | val equiv_states : s1: Vale.X64.Decls.va_state -> s2: Vale.X64.Decls.va_state -> Prims.logical | let equiv_states (s1 s2:va_state) =
let open Vale.X64.State in
s1.vs_ok == s2.vs_ok /\
Vale.X64.Regs.equal s1.vs_regs s2.vs_regs /\
Vale.X64.Flags.sel fCarry s1.vs_flags == Vale.X64.Flags.sel fCarry s2.vs_flags /\
Vale.X64.Flags.sel fOverflow s1.vs_flags == Vale.X64.Flags.sel fOverflow s2.vs_flags /\
s1.vs_heap == s2.vs_heap /\
s1.vs_stack == s2.vs_stack /\
s1.vs_stackTaint == s2.vs_stackTaint | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.Common.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 38,
"end_line": 17,
"start_col": 0,
"start_line": 9
} | module Vale.Transformers.Common
open Vale.X64.Machine_s
open Vale.Def.PossiblyMonad
open Vale.X64.Decls
/// Common definitions amongst transformations. | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Regs.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Def.PossiblyMonad.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Transformers.Common.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.PossiblyMonad",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | s1: Vale.X64.Decls.va_state -> s2: Vale.X64.Decls.va_state -> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_state",
"Prims.l_and",
"Prims.eq2",
"Prims.bool",
"Vale.X64.State.__proj__Mkvale_state__item__vs_ok",
"Vale.X64.Regs.equal",
"Vale.X64.State.__proj__Mkvale_state__item__vs_regs",
"Vale.X64.Flags.flag_val_t",
"Vale.X64.Flags.sel",
"Vale.X64.Machine_s.fCarry",
"Vale.X64.State.__proj__Mkvale_state__item__vs_flags",
"Vale.X64.Machine_s.fOverflow",
"Vale.X64.Memory.vale_full_heap",
"Vale.X64.State.__proj__Mkvale_state__item__vs_heap",
"Vale.X64.Stack_i.vale_stack",
"Vale.X64.State.__proj__Mkvale_state__item__vs_stack",
"Vale.X64.Memory.memtaint",
"Vale.X64.State.__proj__Mkvale_state__item__vs_stackTaint",
"Prims.logical"
] | [] | false | false | false | true | true | let equiv_states (s1 s2: va_state) =
| let open Vale.X64.State in
s1.vs_ok == s2.vs_ok /\ Vale.X64.Regs.equal s1.vs_regs s2.vs_regs /\
Vale.X64.Flags.sel fCarry s1.vs_flags == Vale.X64.Flags.sel fCarry s2.vs_flags /\
Vale.X64.Flags.sel fOverflow s1.vs_flags == Vale.X64.Flags.sel fOverflow s2.vs_flags /\
s1.vs_heap == s2.vs_heap /\ s1.vs_stack == s2.vs_stack /\ s1.vs_stackTaint == s2.vs_stackTaint | false |
|
Hacl.Impl.Blake2.Constants.fst | Hacl.Impl.Blake2.Constants.ivTable_B | val ivTable_B:(x:
glbuffer (Spec.pub_word_t Spec.Blake2B) 8ul
{witnessed x (Spec.ivTable Spec.Blake2B) /\ recallable x}) | val ivTable_B:(x:
glbuffer (Spec.pub_word_t Spec.Blake2B) 8ul
{witnessed x (Spec.ivTable Spec.Blake2B) /\ recallable x}) | let ivTable_B: (x:glbuffer (Spec.pub_word_t Spec.Blake2B) 8ul{witnessed x (Spec.ivTable Spec.Blake2B) /\ recallable x}) =
createL_global Spec.list_iv_B | {
"file_name": "code/blake2/Hacl.Impl.Blake2.Constants.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 31,
"end_line": 35,
"start_col": 0,
"start_line": 34
} | module Hacl.Impl.Blake2.Constants
open FStar.Mul
open FStar.HyperStack
open FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Lib.ByteBuffer
open Lib.LoopCombinators
module ST = FStar.HyperStack.ST
module Seq = Lib.Sequence
module Loops = Lib.LoopCombinators
module Spec = Spec.Blake2
/// We need to unfold manually the definition of the sigma table. This definition
/// was not declared as `inline_for_extraction` because otherwise it creates a lot
/// of work for the normalizer during the KaRaMeL extraction (which also explores
/// the ghost code, including the content of the assertions). However, we can't do
/// that by inserting manual calls to `norm` inside the code, because it blocks
/// the normalization performed by KaRaMeL, and we can't normalize as much as we
/// want because of the interface abstractions. The solution is to use post-processing.
noextract
let pp_sigmaTable () : Tactics.Tac unit =
Tactics.norm [delta_only [`%Spec.list_sigma]]; Tactics.trefl ()
[@(Tactics.postprocess_with pp_sigmaTable)]
let sigmaTable : x:glbuffer Spec.sigma_elt_t 160ul{witnessed x Spec.sigmaTable /\ recallable x} =
createL_global Spec.list_sigma
let ivTable_S: (x:glbuffer (Spec.pub_word_t Spec.Blake2S) 8ul{witnessed x (Spec.ivTable Spec.Blake2S) /\ recallable x}) =
createL_global Spec.list_iv_S | {
"checked_file": "/",
"dependencies": [
"Spec.Blake2.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Blake2.Constants.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Blake2",
"short_module": "Spec"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteBuffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Blake2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Blake2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | x:
(c:
Lib.Buffer.lbuffer_t Lib.Buffer.CONST
(Spec.Blake2.Definitions.pub_word_t Spec.Blake2.Definitions.Blake2B)
(8ul <: FStar.UInt32.t) {LowStar.ConstBuffer.qual_of c == LowStar.ConstBuffer.IMMUTABLE})
{ Lib.Buffer.witnessed x (Spec.Blake2.ivTable Spec.Blake2.Definitions.Blake2B) /\
Lib.Buffer.recallable x } | Prims.Tot | [
"total"
] | [] | [
"Lib.Buffer.createL_global",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.PUB",
"Spec.Blake2.list_iv_B",
"Lib.Buffer.glbuffer",
"Lib.IntTypes.size",
"FStar.Pervasives.normalize_term",
"Lib.IntTypes.size_nat",
"FStar.List.Tot.Base.length"
] | [] | false | false | false | false | false | let ivTable_B:(x:
glbuffer (Spec.pub_word_t Spec.Blake2B) 8ul
{witnessed x (Spec.ivTable Spec.Blake2B) /\ recallable x}) =
| createL_global Spec.list_iv_B | false |
Hacl.Impl.Blake2.Constants.fst | Hacl.Impl.Blake2.Constants.rTable_B | val rTable_B:x: glbuffer (rotval U64) 4ul {witnessed x (Spec.rTable Spec.Blake2B) /\ recallable x} | val rTable_B:x: glbuffer (rotval U64) 4ul {witnessed x (Spec.rTable Spec.Blake2B) /\ recallable x} | let rTable_B : x:glbuffer (rotval U64) 4ul{witnessed x (Spec.rTable Spec.Blake2B) /\ recallable x} =
createL_global Spec.rTable_list_B | {
"file_name": "code/blake2/Hacl.Impl.Blake2.Constants.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 35,
"end_line": 38,
"start_col": 0,
"start_line": 37
} | module Hacl.Impl.Blake2.Constants
open FStar.Mul
open FStar.HyperStack
open FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Lib.ByteBuffer
open Lib.LoopCombinators
module ST = FStar.HyperStack.ST
module Seq = Lib.Sequence
module Loops = Lib.LoopCombinators
module Spec = Spec.Blake2
/// We need to unfold manually the definition of the sigma table. This definition
/// was not declared as `inline_for_extraction` because otherwise it creates a lot
/// of work for the normalizer during the KaRaMeL extraction (which also explores
/// the ghost code, including the content of the assertions). However, we can't do
/// that by inserting manual calls to `norm` inside the code, because it blocks
/// the normalization performed by KaRaMeL, and we can't normalize as much as we
/// want because of the interface abstractions. The solution is to use post-processing.
noextract
let pp_sigmaTable () : Tactics.Tac unit =
Tactics.norm [delta_only [`%Spec.list_sigma]]; Tactics.trefl ()
[@(Tactics.postprocess_with pp_sigmaTable)]
let sigmaTable : x:glbuffer Spec.sigma_elt_t 160ul{witnessed x Spec.sigmaTable /\ recallable x} =
createL_global Spec.list_sigma
let ivTable_S: (x:glbuffer (Spec.pub_word_t Spec.Blake2S) 8ul{witnessed x (Spec.ivTable Spec.Blake2S) /\ recallable x}) =
createL_global Spec.list_iv_S
let ivTable_B: (x:glbuffer (Spec.pub_word_t Spec.Blake2B) 8ul{witnessed x (Spec.ivTable Spec.Blake2B) /\ recallable x}) =
createL_global Spec.list_iv_B | {
"checked_file": "/",
"dependencies": [
"Spec.Blake2.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Blake2.Constants.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Blake2",
"short_module": "Spec"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "Seq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteBuffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Blake2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Blake2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | x:
(c:
Lib.Buffer.lbuffer_t Lib.Buffer.CONST
(Lib.IntTypes.rotval Lib.IntTypes.U64)
(4ul <: FStar.UInt32.t) {LowStar.ConstBuffer.qual_of c == LowStar.ConstBuffer.IMMUTABLE})
{ Lib.Buffer.witnessed x (Spec.Blake2.rTable Spec.Blake2.Definitions.Blake2B) /\
Lib.Buffer.recallable x } | Prims.Tot | [
"total"
] | [] | [
"Lib.Buffer.createL_global",
"Lib.IntTypes.rotval",
"Lib.IntTypes.U64",
"Spec.Blake2.rTable_list_B",
"Lib.Buffer.glbuffer",
"Lib.IntTypes.size",
"FStar.Pervasives.normalize_term",
"Lib.IntTypes.size_nat",
"FStar.List.Tot.Base.length"
] | [] | false | false | false | false | false | let rTable_B:x: glbuffer (rotval U64) 4ul {witnessed x (Spec.rTable Spec.Blake2B) /\ recallable x} =
| createL_global Spec.rTable_list_B | false |
PulseCore.Semantics.fst | PulseCore.Semantics.associative | val associative : f: (_: a -> _: a -> a) -> Prims.logical | let associative #a (f: a -> a -> a) =
forall x y z. f x (f y z) == f (f x y) z | {
"file_name": "lib/pulse_core/PulseCore.Semantics.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 42,
"end_line": 31,
"start_col": 0,
"start_line": 30
} | (*
Copyright 2024 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module PulseCore.Semantics
module U = FStar.Universe
module M = PulseCore.MonotonicStateMonad
module NM = PulseCore.NondeterministicMonotonicStateMonad
module F = FStar.FunctionalExtensionality
open FStar.FunctionalExtensionality
open PulseCore.NondeterministicMonotonicStateMonad
open FStar.Preorder
/// We start by defining some basic notions for a commutative monoid.
///
/// We could reuse FStar.Algebra.CommMonoid, but this style with
/// quantifiers is more convenient for the proof done here. | {
"checked_file": "/",
"dependencies": [
"PulseCore.NondeterministicMonotonicStateMonad.fsti.checked",
"PulseCore.MonotonicStateMonad.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "PulseCore.Semantics.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.NondeterministicMonotonicStateMonad",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "PulseCore.NondeterministicMonotonicStateMonad",
"short_module": "NM"
},
{
"abbrev": true,
"full_module": "PulseCore.MonotonicStateMonad",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | f: (_: a -> _: a -> a) -> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"Prims.l_Forall",
"Prims.eq2",
"Prims.logical"
] | [] | false | false | false | true | true | let associative #a (f: (a -> a -> a)) =
| forall x y z. f x (f y z) == f (f x y) z | false |
|
PulseCore.Semantics.fst | PulseCore.Semantics.is_unit | val is_unit : x: a -> f: (_: a -> _: a -> a) -> Prims.logical | let is_unit #a (x:a) (f:a -> a -> a) =
forall y. f x y == y /\ f y x == y | {
"file_name": "lib/pulse_core/PulseCore.Semantics.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 36,
"end_line": 37,
"start_col": 0,
"start_line": 36
} | (*
Copyright 2024 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module PulseCore.Semantics
module U = FStar.Universe
module M = PulseCore.MonotonicStateMonad
module NM = PulseCore.NondeterministicMonotonicStateMonad
module F = FStar.FunctionalExtensionality
open FStar.FunctionalExtensionality
open PulseCore.NondeterministicMonotonicStateMonad
open FStar.Preorder
/// We start by defining some basic notions for a commutative monoid.
///
/// We could reuse FStar.Algebra.CommMonoid, but this style with
/// quantifiers is more convenient for the proof done here.
let associative #a (f: a -> a -> a) =
forall x y z. f x (f y z) == f (f x y) z
let commutative #a (f: a -> a -> a) =
forall x y. f x y == f y x | {
"checked_file": "/",
"dependencies": [
"PulseCore.NondeterministicMonotonicStateMonad.fsti.checked",
"PulseCore.MonotonicStateMonad.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "PulseCore.Semantics.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.NondeterministicMonotonicStateMonad",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "PulseCore.NondeterministicMonotonicStateMonad",
"short_module": "NM"
},
{
"abbrev": true,
"full_module": "PulseCore.MonotonicStateMonad",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | x: a -> f: (_: a -> _: a -> a) -> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"Prims.l_Forall",
"Prims.l_and",
"Prims.eq2",
"Prims.logical"
] | [] | false | false | false | true | true | let is_unit #a (x: a) (f: (a -> a -> a)) =
| forall y. f x y == y /\ f y x == y | false |
|
PulseCore.Semantics.fst | PulseCore.Semantics.commutative | val commutative : f: (_: a -> _: a -> a) -> Prims.logical | let commutative #a (f: a -> a -> a) =
forall x y. f x y == f y x | {
"file_name": "lib/pulse_core/PulseCore.Semantics.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 28,
"end_line": 34,
"start_col": 0,
"start_line": 33
} | (*
Copyright 2024 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module PulseCore.Semantics
module U = FStar.Universe
module M = PulseCore.MonotonicStateMonad
module NM = PulseCore.NondeterministicMonotonicStateMonad
module F = FStar.FunctionalExtensionality
open FStar.FunctionalExtensionality
open PulseCore.NondeterministicMonotonicStateMonad
open FStar.Preorder
/// We start by defining some basic notions for a commutative monoid.
///
/// We could reuse FStar.Algebra.CommMonoid, but this style with
/// quantifiers is more convenient for the proof done here.
let associative #a (f: a -> a -> a) =
forall x y z. f x (f y z) == f (f x y) z | {
"checked_file": "/",
"dependencies": [
"PulseCore.NondeterministicMonotonicStateMonad.fsti.checked",
"PulseCore.MonotonicStateMonad.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "PulseCore.Semantics.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.NondeterministicMonotonicStateMonad",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "PulseCore.NondeterministicMonotonicStateMonad",
"short_module": "NM"
},
{
"abbrev": true,
"full_module": "PulseCore.MonotonicStateMonad",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | f: (_: a -> _: a -> a) -> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"Prims.l_Forall",
"Prims.eq2",
"Prims.logical"
] | [] | false | false | false | true | true | let commutative #a (f: (a -> a -> a)) =
| forall x y. f x y == f y x | false |
|
PulseCore.Semantics.fst | PulseCore.Semantics.full_mem | val full_mem (st: state u#s u#act) : Type u#s | val full_mem (st: state u#s u#act) : Type u#s | let full_mem (st:state u#s u#act) : Type u#s = m:st.s { st.is_full_mem m } | {
"file_name": "lib/pulse_core/PulseCore.Semantics.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 74,
"end_line": 66,
"start_col": 0,
"start_line": 66
} | (*
Copyright 2024 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module PulseCore.Semantics
module U = FStar.Universe
module M = PulseCore.MonotonicStateMonad
module NM = PulseCore.NondeterministicMonotonicStateMonad
module F = FStar.FunctionalExtensionality
open FStar.FunctionalExtensionality
open PulseCore.NondeterministicMonotonicStateMonad
open FStar.Preorder
/// We start by defining some basic notions for a commutative monoid.
///
/// We could reuse FStar.Algebra.CommMonoid, but this style with
/// quantifiers is more convenient for the proof done here.
let associative #a (f: a -> a -> a) =
forall x y z. f x (f y z) == f (f x y) z
let commutative #a (f: a -> a -> a) =
forall x y. f x y == f y x
let is_unit #a (x:a) (f:a -> a -> a) =
forall y. f x y == y /\ f y x == y
(**
* A state typeclass:
* - [s] is the type of states
* - [is_full_mem] a refinement on states to the entire heap used at runtime
* - [pred] is the type of state assertions
* - [emp] is the empty state assertion
* - [star] is the separating conjunction of state assertions
* - [interp p s] is the interpretation of a state assertion [p] in a state [s]
* - [evolves] is a preorder on states, constraining how it evolves
* - [invariant] is an internal invariant that a caller can instantiate and is maintained
* by every action and the semantics as a whole
* - [laws] state that {pred, emp, star} are a commutative monoid
*)
noeq
type state : Type u#(max (s + 1) (act + 1)) = {
max_act:Type u#act;
s:Type u#s;
is_full_mem: s -> prop;
pred:Type u#s;
emp: pred;
star: pred -> pred -> pred;
interp: pred -> s -> prop;
evolves: FStar.Preorder.preorder (s:s { is_full_mem s });
invariant: s -> pred;
laws: squash (associative star /\ commutative star /\ is_unit emp star)
} | {
"checked_file": "/",
"dependencies": [
"PulseCore.NondeterministicMonotonicStateMonad.fsti.checked",
"PulseCore.MonotonicStateMonad.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "PulseCore.Semantics.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.NondeterministicMonotonicStateMonad",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "PulseCore.NondeterministicMonotonicStateMonad",
"short_module": "NM"
},
{
"abbrev": true,
"full_module": "PulseCore.MonotonicStateMonad",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | st: PulseCore.Semantics.state -> Type | Prims.Tot | [
"total"
] | [] | [
"PulseCore.Semantics.state",
"PulseCore.Semantics.__proj__Mkstate__item__s",
"PulseCore.Semantics.__proj__Mkstate__item__is_full_mem"
] | [] | false | false | false | true | true | let full_mem (st: state u#s u#act) : Type u#s =
| m: st.s{st.is_full_mem m} | false |
PulseCore.Semantics.fst | PulseCore.Semantics.mst_sep | val mst_sep : st: PulseCore.Semantics.state ->
a: Type ->
pre: Mkstate?.pred st ->
post: (_: a -> Mkstate?.pred st)
-> Type | let mst_sep st a pre post = mst_sep_aux st (fun _ -> True) st.invariant a pre post | {
"file_name": "lib/pulse_core/PulseCore.Semantics.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 82,
"end_line": 86,
"start_col": 0,
"start_line": 86
} | (*
Copyright 2024 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module PulseCore.Semantics
module U = FStar.Universe
module M = PulseCore.MonotonicStateMonad
module NM = PulseCore.NondeterministicMonotonicStateMonad
module F = FStar.FunctionalExtensionality
open FStar.FunctionalExtensionality
open PulseCore.NondeterministicMonotonicStateMonad
open FStar.Preorder
/// We start by defining some basic notions for a commutative monoid.
///
/// We could reuse FStar.Algebra.CommMonoid, but this style with
/// quantifiers is more convenient for the proof done here.
let associative #a (f: a -> a -> a) =
forall x y z. f x (f y z) == f (f x y) z
let commutative #a (f: a -> a -> a) =
forall x y. f x y == f y x
let is_unit #a (x:a) (f:a -> a -> a) =
forall y. f x y == y /\ f y x == y
(**
* A state typeclass:
* - [s] is the type of states
* - [is_full_mem] a refinement on states to the entire heap used at runtime
* - [pred] is the type of state assertions
* - [emp] is the empty state assertion
* - [star] is the separating conjunction of state assertions
* - [interp p s] is the interpretation of a state assertion [p] in a state [s]
* - [evolves] is a preorder on states, constraining how it evolves
* - [invariant] is an internal invariant that a caller can instantiate and is maintained
* by every action and the semantics as a whole
* - [laws] state that {pred, emp, star} are a commutative monoid
*)
noeq
type state : Type u#(max (s + 1) (act + 1)) = {
max_act:Type u#act;
s:Type u#s;
is_full_mem: s -> prop;
pred:Type u#s;
emp: pred;
star: pred -> pred -> pred;
interp: pred -> s -> prop;
evolves: FStar.Preorder.preorder (s:s { is_full_mem s });
invariant: s -> pred;
laws: squash (associative star /\ commutative star /\ is_unit emp star)
}
let full_mem (st:state u#s u#act) : Type u#s = m:st.s { st.is_full_mem m }
(** [post a c] is a postcondition on [a]-typed result *)
let post (s:state) a = a ^-> s.pred
(** We interpret computations into the nmst monad,
for partial, nondeterministic, monotonic-state transfomers.
nmst_sep provides separation-logic specifications for those computations.
mst_sep is analogous, except computation in mst_sep are also total
**)
let mst_sep_aux (st:state u#s u#act)
(aux:full_mem st -> prop)
(inv:full_mem st -> st.pred)
(a:Type u#a)
(pre:st.pred)
(post:a -> st.pred) =
M.mst #(full_mem st) st.evolves a
(fun s0 -> aux s0 /\ st.interp (pre `st.star` inv s0) s0 )
(fun _ x s1 -> aux s1 /\ st.interp (post x `st.star` inv s1) s1) | {
"checked_file": "/",
"dependencies": [
"PulseCore.NondeterministicMonotonicStateMonad.fsti.checked",
"PulseCore.MonotonicStateMonad.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "PulseCore.Semantics.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.NondeterministicMonotonicStateMonad",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "PulseCore.NondeterministicMonotonicStateMonad",
"short_module": "NM"
},
{
"abbrev": true,
"full_module": "PulseCore.MonotonicStateMonad",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
st: PulseCore.Semantics.state ->
a: Type ->
pre: Mkstate?.pred st ->
post: (_: a -> Mkstate?.pred st)
-> Type | Prims.Tot | [
"total"
] | [] | [
"PulseCore.Semantics.state",
"PulseCore.Semantics.__proj__Mkstate__item__pred",
"PulseCore.Semantics.mst_sep_aux",
"PulseCore.Semantics.full_mem",
"Prims.l_True",
"Prims.prop",
"PulseCore.Semantics.__proj__Mkstate__item__invariant"
] | [] | false | false | false | false | true | let mst_sep st a pre post =
| mst_sep_aux st (fun _ -> True) st.invariant a pre post | false |
|
PulseCore.Semantics.fst | PulseCore.Semantics.mst_sep_aux | val mst_sep_aux : st: PulseCore.Semantics.state ->
aux: (_: PulseCore.Semantics.full_mem st -> Prims.prop) ->
inv: (_: PulseCore.Semantics.full_mem st -> Mkstate?.pred st) ->
a: Type ->
pre: Mkstate?.pred st ->
post: (_: a -> Mkstate?.pred st)
-> Type | let mst_sep_aux (st:state u#s u#act)
(aux:full_mem st -> prop)
(inv:full_mem st -> st.pred)
(a:Type u#a)
(pre:st.pred)
(post:a -> st.pred) =
M.mst #(full_mem st) st.evolves a
(fun s0 -> aux s0 /\ st.interp (pre `st.star` inv s0) s0 )
(fun _ x s1 -> aux s1 /\ st.interp (post x `st.star` inv s1) s1) | {
"file_name": "lib/pulse_core/PulseCore.Semantics.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 68,
"end_line": 84,
"start_col": 0,
"start_line": 76
} | (*
Copyright 2024 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module PulseCore.Semantics
module U = FStar.Universe
module M = PulseCore.MonotonicStateMonad
module NM = PulseCore.NondeterministicMonotonicStateMonad
module F = FStar.FunctionalExtensionality
open FStar.FunctionalExtensionality
open PulseCore.NondeterministicMonotonicStateMonad
open FStar.Preorder
/// We start by defining some basic notions for a commutative monoid.
///
/// We could reuse FStar.Algebra.CommMonoid, but this style with
/// quantifiers is more convenient for the proof done here.
let associative #a (f: a -> a -> a) =
forall x y z. f x (f y z) == f (f x y) z
let commutative #a (f: a -> a -> a) =
forall x y. f x y == f y x
let is_unit #a (x:a) (f:a -> a -> a) =
forall y. f x y == y /\ f y x == y
(**
* A state typeclass:
* - [s] is the type of states
* - [is_full_mem] a refinement on states to the entire heap used at runtime
* - [pred] is the type of state assertions
* - [emp] is the empty state assertion
* - [star] is the separating conjunction of state assertions
* - [interp p s] is the interpretation of a state assertion [p] in a state [s]
* - [evolves] is a preorder on states, constraining how it evolves
* - [invariant] is an internal invariant that a caller can instantiate and is maintained
* by every action and the semantics as a whole
* - [laws] state that {pred, emp, star} are a commutative monoid
*)
noeq
type state : Type u#(max (s + 1) (act + 1)) = {
max_act:Type u#act;
s:Type u#s;
is_full_mem: s -> prop;
pred:Type u#s;
emp: pred;
star: pred -> pred -> pred;
interp: pred -> s -> prop;
evolves: FStar.Preorder.preorder (s:s { is_full_mem s });
invariant: s -> pred;
laws: squash (associative star /\ commutative star /\ is_unit emp star)
}
let full_mem (st:state u#s u#act) : Type u#s = m:st.s { st.is_full_mem m }
(** [post a c] is a postcondition on [a]-typed result *)
let post (s:state) a = a ^-> s.pred
(** We interpret computations into the nmst monad,
for partial, nondeterministic, monotonic-state transfomers.
nmst_sep provides separation-logic specifications for those computations.
mst_sep is analogous, except computation in mst_sep are also total | {
"checked_file": "/",
"dependencies": [
"PulseCore.NondeterministicMonotonicStateMonad.fsti.checked",
"PulseCore.MonotonicStateMonad.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "PulseCore.Semantics.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.NondeterministicMonotonicStateMonad",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "PulseCore.NondeterministicMonotonicStateMonad",
"short_module": "NM"
},
{
"abbrev": true,
"full_module": "PulseCore.MonotonicStateMonad",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
st: PulseCore.Semantics.state ->
aux: (_: PulseCore.Semantics.full_mem st -> Prims.prop) ->
inv: (_: PulseCore.Semantics.full_mem st -> Mkstate?.pred st) ->
a: Type ->
pre: Mkstate?.pred st ->
post: (_: a -> Mkstate?.pred st)
-> Type | Prims.Tot | [
"total"
] | [] | [
"PulseCore.Semantics.state",
"PulseCore.Semantics.full_mem",
"Prims.prop",
"PulseCore.Semantics.__proj__Mkstate__item__pred",
"PulseCore.MonotonicStateMonad.mst",
"PulseCore.Semantics.__proj__Mkstate__item__evolves",
"Prims.l_and",
"PulseCore.Semantics.__proj__Mkstate__item__interp",
"PulseCore.Semantics.__proj__Mkstate__item__star"
] | [] | false | false | false | false | true | let mst_sep_aux
(st: state u#s u#act)
(aux: (full_mem st -> prop))
(inv: (full_mem st -> st.pred))
(a: Type u#a)
(pre: st.pred)
(post: (a -> st.pred))
=
| M.mst #(full_mem st)
st.evolves
a
(fun s0 -> aux s0 /\ st.interp (pre `st.star` (inv s0)) s0)
(fun _ x s1 -> aux s1 /\ st.interp ((post x) `st.star` (inv s1)) s1) | false |
|
Hacl.Spec.Bignum.Addition.fst | Hacl.Spec.Bignum.Addition.bn_add_lemma_loop_step | val bn_add_lemma_loop_step:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> b:lbignum t aLen
-> i:pos{i <= aLen}
-> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma
(requires
(let (c1, res1) = c1_res1 in
v c1 * pow2 (bits t * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + eval_ aLen b (i - 1)))
(ensures
(let (c1, res1) = c1_res1 in
let (c, res) = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in
v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i)) | val bn_add_lemma_loop_step:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> b:lbignum t aLen
-> i:pos{i <= aLen}
-> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma
(requires
(let (c1, res1) = c1_res1 in
v c1 * pow2 (bits t * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + eval_ aLen b (i - 1)))
(ensures
(let (c1, res1) = c1_res1 in
let (c, res) = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in
v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i)) | let bn_add_lemma_loop_step #t #aLen a b i (c1, res1) =
let pbits = bits t in
let (c, res) = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in
let c, e = bn_add_f a b (i - 1) c1 in
assert (v e + v c * pow2 pbits == v a.[i - 1] + v b.[i - 1] + v c1);
calc (==) {
v c * pow2 (pbits * i) + bn_v #t #i res;
(==) { bn_eval_snoc #t #(i - 1) res1 e }
v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1));
(==) { }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) - (v e + v c * pow2 pbits - v a.[i - 1] - v b.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1] - v b.[i - 1]) (pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v e - v e - v c * pow2 pbits + v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1] + v b.[i - 1]) (v c1 * pow2 pbits) (pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_add_left (v a.[i - 1]) (v b.[i - 1]) (pow2 (pbits * (i - 1))) }
eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + v a.[i - 1] * pow2 (pbits * (i - 1)) + v b.[i - 1] * pow2 (pbits * (i - 1));
(==) { bn_eval_unfold_i #t #aLen a i }
eval_ aLen a i + eval_ aLen b (i - 1) + v b.[i - 1] * pow2 (pbits * (i - 1));
(==) { bn_eval_unfold_i #t #aLen b i }
eval_ aLen a i + eval_ aLen b i;
};
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i) | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Addition.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 85,
"end_line": 192,
"start_col": 0,
"start_line": 167
} | module Hacl.Spec.Bignum.Addition
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_sub_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t
let bn_sub_carry_f #t #aLen a i c_in = subborrow c_in a.[i] (uint #t 0)
val bn_sub_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen)
let bn_sub_carry #t #aLen a c_in = generate_elems aLen aLen (bn_sub_carry_f a) c_in
val bn_sub_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t
let bn_sub_f #t #aLen a b i c = subborrow c a.[i] b.[i]
val bn_sub: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> tuple2 (carry t) (lbignum t aLen)
let bn_sub #t #aLen #bLen a b =
let c0, res0 = generate_elems bLen bLen (bn_sub_f (sub a 0 bLen) b) (uint #t 0) in
if bLen < aLen then
let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in
c1, concat #_ #bLen res0 res1
else c0, res0
val bn_sub1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen)
let bn_sub1 #t #aLen a b1 =
let c0, r0 = subborrow (uint #t 0) a.[0] b1 in
let res0 = create 1 r0 in
if 1 < aLen then
let c1, res1 = bn_sub_carry (sub a 1 (aLen - 1)) c0 in
c1, concat res0 res1
else c0, res0
val bn_add_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t
let bn_add_carry_f #t #aLen a i c_in = addcarry c_in a.[i] (uint #t 0)
val bn_add_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen)
let bn_add_carry #t #aLen a c_in = generate_elems aLen aLen (bn_add_carry_f a) c_in
val bn_add_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t
let bn_add_f #t #aLen a b i c = addcarry c a.[i] b.[i]
val bn_add: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> carry t & lbignum t aLen
let bn_add #t #aLen #bLen a b =
let c0, res0 = generate_elems bLen bLen (bn_add_f (sub a 0 bLen) b) (uint #t 0) in
if bLen < aLen then
let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in
c1, concat #_ #bLen res0 res1
else c0, res0
val bn_add1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen)
let bn_add1 #t #aLen a b1 =
let c0, r0 = addcarry (uint #t 0) a.[0] b1 in
let res0 = create 1 r0 in
if 1 < aLen then
let c1, res1 = bn_add_carry (sub a 1 (aLen - 1)) c0 in
c1, concat res0 res1
else c0, res0
val bn_add_carry_lemma_loop_step:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> c_in:carry t
-> i:pos{i <= aLen}
-> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma
(requires
(let (c1, res1) = c1_res1 in
v c1 * pow2 (bits t * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + v c_in))
(ensures
(let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) c1_res1 in
v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in))
let bn_add_carry_lemma_loop_step #t #aLen a c_in i (c1, res1) =
let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1) in
let c, e = bn_add_carry_f a (i - 1) c1 in
assert (v e + v c * pow2 (bits t) == v a.[i - 1] + v c1);
let pbits = bits t in
calc (==) {
v c * pow2 (pbits * i) + bn_v #t #i res;
(==) { bn_eval_snoc #t #(i - 1) res1 e }
v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1));
(==) { }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in - (v e + v c * pow2 pbits - v a.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1]) (pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + (v e - v e - v c * pow2 pbits + v a.[i - 1]) * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1));
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1));
(==) { bn_eval_unfold_i #t #aLen a i }
eval_ aLen a i + v c_in;
};
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in)
val bn_add_carry_lemma_loop:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> c_in:carry t
-> i:nat{i <= aLen} ->
Lemma (let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in
v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in)
let rec bn_add_carry_lemma_loop #t #aLen a c_in i =
let pbits = bits t in
let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in
if i = 0 then begin
eq_generate_elems0 aLen i (bn_add_carry_f a) c_in;
assert (c_out == c_in /\ res == Seq.empty);
bn_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
() end
else begin
let (c1, res1) : generate_elem_a (limb t) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_add_carry_f a) c_in in
generate_elems_unfold aLen i (bn_add_carry_f a) c_in (i - 1);
assert (generate_elems aLen i (bn_add_carry_f a) c_in ==
generate_elem_f aLen (bn_add_carry_f a) (i - 1) (generate_elems aLen (i - 1) (bn_add_carry_f a) c_in));
assert ((c_out, res) == generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1));
bn_add_carry_lemma_loop a c_in (i - 1);
assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + v c_in);
bn_add_carry_lemma_loop_step a c_in i (c1, res1);
assert (v c_out * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in);
() end
val bn_add_carry_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t ->
Lemma (let (c_out, res) = bn_add_carry a c_in in
v c_out * pow2 (bits t * aLen) + bn_v res == bn_v a + v c_in)
let bn_add_carry_lemma #t #aLen a c_in =
let (c_out, res) = bn_add_carry a c_in in
bn_add_carry_lemma_loop a c_in aLen
val bn_add_lemma_loop_step:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> b:lbignum t aLen
-> i:pos{i <= aLen}
-> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma
(requires
(let (c1, res1) = c1_res1 in
v c1 * pow2 (bits t * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + eval_ aLen b (i - 1)))
(ensures
(let (c1, res1) = c1_res1 in
let (c, res) = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in
v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Base.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Addition.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a: Hacl.Spec.Bignum.Definitions.lbignum t aLen ->
b: Hacl.Spec.Bignum.Definitions.lbignum t aLen ->
i: Prims.pos{i <= aLen} ->
c1_res1:
Hacl.Spec.Lib.generate_elem_a (Hacl.Spec.Bignum.Definitions.limb t)
(Hacl.Spec.Bignum.Base.carry t)
aLen
(i - 1)
-> FStar.Pervasives.Lemma
(requires
(let _ = c1_res1 in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ c1 res1 = _ in
Lib.IntTypes.v c1 * Prims.pow2 (Lib.IntTypes.bits t * (i - 1)) +
Hacl.Spec.Bignum.Definitions.bn_v res1 ==
Hacl.Spec.Bignum.Definitions.eval_ aLen a (i - 1) +
Hacl.Spec.Bignum.Definitions.eval_ aLen b (i - 1))
<:
Type0))
(ensures
(let _ = c1_res1 in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ c1 res1 = _ in
let _ =
Hacl.Spec.Lib.generate_elem_f aLen
(Hacl.Spec.Bignum.Addition.bn_add_f a b)
(i - 1)
(c1,
res1)
in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ c res = _ in
Lib.IntTypes.v c * Prims.pow2 (Lib.IntTypes.bits t * i) +
Hacl.Spec.Bignum.Definitions.bn_v res ==
Hacl.Spec.Bignum.Definitions.eval_ aLen a i +
Hacl.Spec.Bignum.Definitions.eval_ aLen b i)
<:
Type0)
<:
Type0)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.pos",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Hacl.Spec.Lib.generate_elem_a",
"Hacl.Spec.Bignum.Definitions.limb",
"Hacl.Spec.Bignum.Base.carry",
"Prims.op_Subtraction",
"Lib.Sequence.seq",
"Prims.eq2",
"Prims.nat",
"Lib.Sequence.length",
"Prims.op_Addition",
"Prims._assert",
"Prims.int",
"FStar.Mul.op_Star",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Prims.pow2",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Hacl.Spec.Bignum.Definitions.eval_",
"Prims.unit",
"FStar.Calc.calc_finish",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"FStar.Calc.calc_step",
"Lib.Sequence.op_String_Access",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Hacl.Spec.Bignum.Definitions.bn_eval_snoc",
"Prims.squash",
"FStar.Math.Lemmas.distributivity_sub_left",
"FStar.Math.Lemmas.pow2_plus",
"FStar.Math.Lemmas.paren_mul_right",
"FStar.Math.Lemmas.distributivity_add_left",
"Hacl.Spec.Bignum.Definitions.bn_eval_unfold_i",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.Bignum.Addition.bn_add_f",
"Hacl.Spec.Lib.generate_elem_f",
"FStar.Pervasives.Native.Mktuple2",
"Lib.IntTypes.bits"
] | [] | false | false | true | false | false | let bn_add_lemma_loop_step #t #aLen a b i (c1, res1) =
| let pbits = bits t in
let c, res = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in
let c, e = bn_add_f a b (i - 1) c1 in
assert (v e + v c * pow2 pbits == v a.[ i - 1 ] + v b.[ i - 1 ] + v c1);
calc ( == ) {
v c * pow2 (pbits * i) + bn_v #t #i res;
( == ) { bn_eval_snoc #t #(i - 1) res1 e }
v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1));
( == ) { () }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) -
(v e + v c * pow2 pbits - v a.[ i - 1 ] - v b.[ i - 1 ]) * pow2 (pbits * (i - 1)) +
v e * pow2 (pbits * (i - 1));
( == ) { Math.Lemmas.distributivity_sub_left (v e)
(v e + v c * pow2 pbits - v a.[ i - 1 ] - v b.[ i - 1 ])
(pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) +
(v e - v e - v c * pow2 pbits + v a.[ i - 1 ] + v b.[ i - 1 ]) * pow2 (pbits * (i - 1));
( == ) { Math.Lemmas.distributivity_sub_left (v a.[ i - 1 ] + v b.[ i - 1 ])
(v c1 * pow2 pbits)
(pow2 (pbits * (i - 1))) }
v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) +
(v a.[ i - 1 ] + v b.[ i - 1 ]) * pow2 (pbits * (i - 1)) -
(v c * pow2 pbits) * pow2 (pbits * (i - 1));
( == ) { (Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1)));
Math.Lemmas.pow2_plus pbits (pbits * (i - 1))) }
eval_ aLen a (i - 1) + eval_ aLen b (i - 1) +
(v a.[ i - 1 ] + v b.[ i - 1 ]) * pow2 (pbits * (i - 1));
( == ) { Math.Lemmas.distributivity_add_left (v a.[ i - 1 ])
(v b.[ i - 1 ])
(pow2 (pbits * (i - 1))) }
eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + v a.[ i - 1 ] * pow2 (pbits * (i - 1)) +
v b.[ i - 1 ] * pow2 (pbits * (i - 1));
( == ) { bn_eval_unfold_i #t #aLen a i }
eval_ aLen a i + eval_ aLen b (i - 1) + v b.[ i - 1 ] * pow2 (pbits * (i - 1));
( == ) { bn_eval_unfold_i #t #aLen b i }
eval_ aLen a i + eval_ aLen b i;
};
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i) | false |
PulseCore.Semantics.fst | PulseCore.Semantics.post | val post : s: PulseCore.Semantics.state -> a: Type -> Type | let post (s:state) a = a ^-> s.pred | {
"file_name": "lib/pulse_core/PulseCore.Semantics.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 35,
"end_line": 69,
"start_col": 0,
"start_line": 69
} | (*
Copyright 2024 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module PulseCore.Semantics
module U = FStar.Universe
module M = PulseCore.MonotonicStateMonad
module NM = PulseCore.NondeterministicMonotonicStateMonad
module F = FStar.FunctionalExtensionality
open FStar.FunctionalExtensionality
open PulseCore.NondeterministicMonotonicStateMonad
open FStar.Preorder
/// We start by defining some basic notions for a commutative monoid.
///
/// We could reuse FStar.Algebra.CommMonoid, but this style with
/// quantifiers is more convenient for the proof done here.
let associative #a (f: a -> a -> a) =
forall x y z. f x (f y z) == f (f x y) z
let commutative #a (f: a -> a -> a) =
forall x y. f x y == f y x
let is_unit #a (x:a) (f:a -> a -> a) =
forall y. f x y == y /\ f y x == y
(**
* A state typeclass:
* - [s] is the type of states
* - [is_full_mem] a refinement on states to the entire heap used at runtime
* - [pred] is the type of state assertions
* - [emp] is the empty state assertion
* - [star] is the separating conjunction of state assertions
* - [interp p s] is the interpretation of a state assertion [p] in a state [s]
* - [evolves] is a preorder on states, constraining how it evolves
* - [invariant] is an internal invariant that a caller can instantiate and is maintained
* by every action and the semantics as a whole
* - [laws] state that {pred, emp, star} are a commutative monoid
*)
noeq
type state : Type u#(max (s + 1) (act + 1)) = {
max_act:Type u#act;
s:Type u#s;
is_full_mem: s -> prop;
pred:Type u#s;
emp: pred;
star: pred -> pred -> pred;
interp: pred -> s -> prop;
evolves: FStar.Preorder.preorder (s:s { is_full_mem s });
invariant: s -> pred;
laws: squash (associative star /\ commutative star /\ is_unit emp star)
}
let full_mem (st:state u#s u#act) : Type u#s = m:st.s { st.is_full_mem m } | {
"checked_file": "/",
"dependencies": [
"PulseCore.NondeterministicMonotonicStateMonad.fsti.checked",
"PulseCore.MonotonicStateMonad.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "PulseCore.Semantics.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.NondeterministicMonotonicStateMonad",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "PulseCore.NondeterministicMonotonicStateMonad",
"short_module": "NM"
},
{
"abbrev": true,
"full_module": "PulseCore.MonotonicStateMonad",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | s: PulseCore.Semantics.state -> a: Type -> Type | Prims.Tot | [
"total"
] | [] | [
"PulseCore.Semantics.state",
"FStar.FunctionalExtensionality.op_Hat_Subtraction_Greater",
"PulseCore.Semantics.__proj__Mkstate__item__pred"
] | [] | false | false | false | true | true | let post (s: state) a =
| a ^-> s.pred | false |
|
PulseCore.Semantics.fst | PulseCore.Semantics.nmst_sep | val nmst_sep : st: PulseCore.Semantics.state ->
a: Type ->
pre: Mkstate?.pred st ->
post: (_: a -> Mkstate?.pred st)
-> Type0 | let nmst_sep (st:state u#s u#act) (a:Type u#a) (pre:st.pred) (post:a -> st.pred) =
nmst #(full_mem st) st.evolves a
(fun s0 -> st.interp (pre `st.star` st.invariant s0) s0 )
(fun _ x s1 -> st.interp (post x `st.star` st.invariant s1) s1) | {
"file_name": "lib/pulse_core/PulseCore.Semantics.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 67,
"end_line": 91,
"start_col": 0,
"start_line": 88
} | (*
Copyright 2024 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module PulseCore.Semantics
module U = FStar.Universe
module M = PulseCore.MonotonicStateMonad
module NM = PulseCore.NondeterministicMonotonicStateMonad
module F = FStar.FunctionalExtensionality
open FStar.FunctionalExtensionality
open PulseCore.NondeterministicMonotonicStateMonad
open FStar.Preorder
/// We start by defining some basic notions for a commutative monoid.
///
/// We could reuse FStar.Algebra.CommMonoid, but this style with
/// quantifiers is more convenient for the proof done here.
let associative #a (f: a -> a -> a) =
forall x y z. f x (f y z) == f (f x y) z
let commutative #a (f: a -> a -> a) =
forall x y. f x y == f y x
let is_unit #a (x:a) (f:a -> a -> a) =
forall y. f x y == y /\ f y x == y
(**
* A state typeclass:
* - [s] is the type of states
* - [is_full_mem] a refinement on states to the entire heap used at runtime
* - [pred] is the type of state assertions
* - [emp] is the empty state assertion
* - [star] is the separating conjunction of state assertions
* - [interp p s] is the interpretation of a state assertion [p] in a state [s]
* - [evolves] is a preorder on states, constraining how it evolves
* - [invariant] is an internal invariant that a caller can instantiate and is maintained
* by every action and the semantics as a whole
* - [laws] state that {pred, emp, star} are a commutative monoid
*)
noeq
type state : Type u#(max (s + 1) (act + 1)) = {
max_act:Type u#act;
s:Type u#s;
is_full_mem: s -> prop;
pred:Type u#s;
emp: pred;
star: pred -> pred -> pred;
interp: pred -> s -> prop;
evolves: FStar.Preorder.preorder (s:s { is_full_mem s });
invariant: s -> pred;
laws: squash (associative star /\ commutative star /\ is_unit emp star)
}
let full_mem (st:state u#s u#act) : Type u#s = m:st.s { st.is_full_mem m }
(** [post a c] is a postcondition on [a]-typed result *)
let post (s:state) a = a ^-> s.pred
(** We interpret computations into the nmst monad,
for partial, nondeterministic, monotonic-state transfomers.
nmst_sep provides separation-logic specifications for those computations.
mst_sep is analogous, except computation in mst_sep are also total
**)
let mst_sep_aux (st:state u#s u#act)
(aux:full_mem st -> prop)
(inv:full_mem st -> st.pred)
(a:Type u#a)
(pre:st.pred)
(post:a -> st.pred) =
M.mst #(full_mem st) st.evolves a
(fun s0 -> aux s0 /\ st.interp (pre `st.star` inv s0) s0 )
(fun _ x s1 -> aux s1 /\ st.interp (post x `st.star` inv s1) s1)
let mst_sep st a pre post = mst_sep_aux st (fun _ -> True) st.invariant a pre post | {
"checked_file": "/",
"dependencies": [
"PulseCore.NondeterministicMonotonicStateMonad.fsti.checked",
"PulseCore.MonotonicStateMonad.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "PulseCore.Semantics.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.NondeterministicMonotonicStateMonad",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "PulseCore.NondeterministicMonotonicStateMonad",
"short_module": "NM"
},
{
"abbrev": true,
"full_module": "PulseCore.MonotonicStateMonad",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
st: PulseCore.Semantics.state ->
a: Type ->
pre: Mkstate?.pred st ->
post: (_: a -> Mkstate?.pred st)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"PulseCore.Semantics.state",
"PulseCore.Semantics.__proj__Mkstate__item__pred",
"PulseCore.NondeterministicMonotonicStateMonad.nmst",
"PulseCore.Semantics.full_mem",
"PulseCore.Semantics.__proj__Mkstate__item__evolves",
"PulseCore.Semantics.__proj__Mkstate__item__interp",
"PulseCore.Semantics.__proj__Mkstate__item__star",
"PulseCore.Semantics.__proj__Mkstate__item__invariant",
"Prims.prop"
] | [] | false | false | false | false | true | let nmst_sep (st: state u#s u#act) (a: Type u#a) (pre: st.pred) (post: (a -> st.pred)) =
| nmst #(full_mem st)
st.evolves
a
(fun s0 -> st.interp (pre `st.star` (st.invariant s0)) s0)
(fun _ x s1 -> st.interp ((post x) `st.star` (st.invariant s1)) s1) | false |
|
PulseCore.Semantics.fst | PulseCore.Semantics.as_post | val as_post (#st: state u#s u#act) (#a: Type u#a) (p: st.pred) : post st a | val as_post (#st: state u#s u#act) (#a: Type u#a) (p: st.pred) : post st a | let as_post (#st:state u#s u#act) (#a:Type u#a) (p:st.pred)
: post st a
= F.on_dom a (fun _ -> p) | {
"file_name": "lib/pulse_core/PulseCore.Semantics.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 25,
"end_line": 116,
"start_col": 0,
"start_line": 114
} | (*
Copyright 2024 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module PulseCore.Semantics
module U = FStar.Universe
module M = PulseCore.MonotonicStateMonad
module NM = PulseCore.NondeterministicMonotonicStateMonad
module F = FStar.FunctionalExtensionality
open FStar.FunctionalExtensionality
open PulseCore.NondeterministicMonotonicStateMonad
open FStar.Preorder
/// We start by defining some basic notions for a commutative monoid.
///
/// We could reuse FStar.Algebra.CommMonoid, but this style with
/// quantifiers is more convenient for the proof done here.
let associative #a (f: a -> a -> a) =
forall x y z. f x (f y z) == f (f x y) z
let commutative #a (f: a -> a -> a) =
forall x y. f x y == f y x
let is_unit #a (x:a) (f:a -> a -> a) =
forall y. f x y == y /\ f y x == y
(**
* A state typeclass:
* - [s] is the type of states
* - [is_full_mem] a refinement on states to the entire heap used at runtime
* - [pred] is the type of state assertions
* - [emp] is the empty state assertion
* - [star] is the separating conjunction of state assertions
* - [interp p s] is the interpretation of a state assertion [p] in a state [s]
* - [evolves] is a preorder on states, constraining how it evolves
* - [invariant] is an internal invariant that a caller can instantiate and is maintained
* by every action and the semantics as a whole
* - [laws] state that {pred, emp, star} are a commutative monoid
*)
noeq
type state : Type u#(max (s + 1) (act + 1)) = {
max_act:Type u#act;
s:Type u#s;
is_full_mem: s -> prop;
pred:Type u#s;
emp: pred;
star: pred -> pred -> pred;
interp: pred -> s -> prop;
evolves: FStar.Preorder.preorder (s:s { is_full_mem s });
invariant: s -> pred;
laws: squash (associative star /\ commutative star /\ is_unit emp star)
}
let full_mem (st:state u#s u#act) : Type u#s = m:st.s { st.is_full_mem m }
(** [post a c] is a postcondition on [a]-typed result *)
let post (s:state) a = a ^-> s.pred
(** We interpret computations into the nmst monad,
for partial, nondeterministic, monotonic-state transfomers.
nmst_sep provides separation-logic specifications for those computations.
mst_sep is analogous, except computation in mst_sep are also total
**)
let mst_sep_aux (st:state u#s u#act)
(aux:full_mem st -> prop)
(inv:full_mem st -> st.pred)
(a:Type u#a)
(pre:st.pred)
(post:a -> st.pred) =
M.mst #(full_mem st) st.evolves a
(fun s0 -> aux s0 /\ st.interp (pre `st.star` inv s0) s0 )
(fun _ x s1 -> aux s1 /\ st.interp (post x `st.star` inv s1) s1)
let mst_sep st a pre post = mst_sep_aux st (fun _ -> True) st.invariant a pre post
let nmst_sep (st:state u#s u#act) (a:Type u#a) (pre:st.pred) (post:a -> st.pred) =
nmst #(full_mem st) st.evolves a
(fun s0 -> st.interp (pre `st.star` st.invariant s0) s0 )
(fun _ x s1 -> st.interp (post x `st.star` st.invariant s1) s1)
(** [action c s]: atomic actions are, intuitively, single steps of
* state-transforming computations (in the nmst monad).
* However, we augment them with two features:
* 1. they have pre-condition [pre] and post-condition [post]
* 2. their type guarantees that they are frameable
* Thanks to Matt Parkinson for suggesting to set up atomic actions
* as frame-preserving steps.
* Also see: https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/views.pdf
*)
noeq
type action (st:state u#s u#act) (a:Type u#a) : Type u#(max a s) = {
pre: st.pred;
post: post st a; //a -> st.pred;
step: (
frame:st.pred ->
mst_sep st a (st.star pre frame)
(fun x -> st.star (post x) frame)
)
} | {
"checked_file": "/",
"dependencies": [
"PulseCore.NondeterministicMonotonicStateMonad.fsti.checked",
"PulseCore.MonotonicStateMonad.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "PulseCore.Semantics.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.NondeterministicMonotonicStateMonad",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "PulseCore.NondeterministicMonotonicStateMonad",
"short_module": "NM"
},
{
"abbrev": true,
"full_module": "PulseCore.MonotonicStateMonad",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | p: Mkstate?.pred st -> PulseCore.Semantics.post st a | Prims.Tot | [
"total"
] | [] | [
"PulseCore.Semantics.state",
"PulseCore.Semantics.__proj__Mkstate__item__pred",
"FStar.FunctionalExtensionality.on_dom",
"PulseCore.Semantics.post"
] | [] | false | false | false | false | false | let as_post (#st: state u#s u#act) (#a: Type u#a) (p: st.pred) : post st a =
| F.on_dom a (fun _ -> p) | false |
PulseCore.Semantics.fst | PulseCore.Semantics.ret | val ret (#st: state u#s u#act) (#a: Type u#a) (x: a) (post: post st a) : m a (post x) post | val ret (#st: state u#s u#act) (#a: Type u#a) (x: a) (post: post st a) : m a (post x) post | let ret (#st:state u#s u#act) (#a:Type u#a) (x:a) (post:post st a)
: m a (post x) post
= Ret x | {
"file_name": "lib/pulse_core/PulseCore.Semantics.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 9,
"end_line": 248,
"start_col": 0,
"start_line": 246
} | (*
Copyright 2024 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module PulseCore.Semantics
module U = FStar.Universe
module M = PulseCore.MonotonicStateMonad
module NM = PulseCore.NondeterministicMonotonicStateMonad
module F = FStar.FunctionalExtensionality
open FStar.FunctionalExtensionality
open PulseCore.NondeterministicMonotonicStateMonad
open FStar.Preorder
/// We start by defining some basic notions for a commutative monoid.
///
/// We could reuse FStar.Algebra.CommMonoid, but this style with
/// quantifiers is more convenient for the proof done here.
let associative #a (f: a -> a -> a) =
forall x y z. f x (f y z) == f (f x y) z
let commutative #a (f: a -> a -> a) =
forall x y. f x y == f y x
let is_unit #a (x:a) (f:a -> a -> a) =
forall y. f x y == y /\ f y x == y
(**
* A state typeclass:
* - [s] is the type of states
* - [is_full_mem] a refinement on states to the entire heap used at runtime
* - [pred] is the type of state assertions
* - [emp] is the empty state assertion
* - [star] is the separating conjunction of state assertions
* - [interp p s] is the interpretation of a state assertion [p] in a state [s]
* - [evolves] is a preorder on states, constraining how it evolves
* - [invariant] is an internal invariant that a caller can instantiate and is maintained
* by every action and the semantics as a whole
* - [laws] state that {pred, emp, star} are a commutative monoid
*)
noeq
type state : Type u#(max (s + 1) (act + 1)) = {
max_act:Type u#act;
s:Type u#s;
is_full_mem: s -> prop;
pred:Type u#s;
emp: pred;
star: pred -> pred -> pred;
interp: pred -> s -> prop;
evolves: FStar.Preorder.preorder (s:s { is_full_mem s });
invariant: s -> pred;
laws: squash (associative star /\ commutative star /\ is_unit emp star)
}
let full_mem (st:state u#s u#act) : Type u#s = m:st.s { st.is_full_mem m }
(** [post a c] is a postcondition on [a]-typed result *)
let post (s:state) a = a ^-> s.pred
(** We interpret computations into the nmst monad,
for partial, nondeterministic, monotonic-state transfomers.
nmst_sep provides separation-logic specifications for those computations.
mst_sep is analogous, except computation in mst_sep are also total
**)
let mst_sep_aux (st:state u#s u#act)
(aux:full_mem st -> prop)
(inv:full_mem st -> st.pred)
(a:Type u#a)
(pre:st.pred)
(post:a -> st.pred) =
M.mst #(full_mem st) st.evolves a
(fun s0 -> aux s0 /\ st.interp (pre `st.star` inv s0) s0 )
(fun _ x s1 -> aux s1 /\ st.interp (post x `st.star` inv s1) s1)
let mst_sep st a pre post = mst_sep_aux st (fun _ -> True) st.invariant a pre post
let nmst_sep (st:state u#s u#act) (a:Type u#a) (pre:st.pred) (post:a -> st.pred) =
nmst #(full_mem st) st.evolves a
(fun s0 -> st.interp (pre `st.star` st.invariant s0) s0 )
(fun _ x s1 -> st.interp (post x `st.star` st.invariant s1) s1)
(** [action c s]: atomic actions are, intuitively, single steps of
* state-transforming computations (in the nmst monad).
* However, we augment them with two features:
* 1. they have pre-condition [pre] and post-condition [post]
* 2. their type guarantees that they are frameable
* Thanks to Matt Parkinson for suggesting to set up atomic actions
* as frame-preserving steps.
* Also see: https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/views.pdf
*)
noeq
type action (st:state u#s u#act) (a:Type u#a) : Type u#(max a s) = {
pre: st.pred;
post: post st a; //a -> st.pred;
step: (
frame:st.pred ->
mst_sep st a (st.star pre frame)
(fun x -> st.star (post x) frame)
)
}
let as_post (#st:state u#s u#act) (#a:Type u#a) (p:st.pred)
: post st a
= F.on_dom a (fun _ -> p)
(** [m #st a pre post]:
* A free monad for divergence, state and parallel composition
* with generic actions. The main idea:
*
* Every continuation may be divergent. As such, [m] is indexed by
* pre- and post-conditions so that we can do proofs
* intrinsically.
*
* Universe-polymorphic im both the state and result type
*
*)
noeq
type m (#st:state u#s u#act) : (a:Type u#a) -> st.pred -> post st a -> Type u#(max (act + 1) s (a + 1)) =
| Ret:
#a:Type u#a ->
#post:post st a ->
x:a ->
m a (post x) post
| Act:
#a:Type u#a ->
#post:post st a ->
#b:Type u#act ->
f:action st b ->
k:(x:b -> Dv (m a (f.post x) post)) ->
m a f.pre post
| Par:
#pre0:_ ->
#post0:_ ->
m0:m (U.raise_t unit) pre0 (as_post post0) ->
#pre1:_ ->
#post1:_ ->
m1:m (U.raise_t unit) pre1 (as_post post1) ->
#a:_ ->
#post:_ ->
k:m a (st.star post0 post1) post ->
m a (st.star pre0 pre1) post
/// The semantics comes in two levels:
///
/// 1. A single-step relation [step] which selects an atomic action to
/// execute in the tree of threads
///
/// 2. A top-level driver [run] which repeatedly invokes [step]
/// until it returns with a result and final state.
(**
* [step_result #st a q frame]:
* The result of evaluating a single step of a program
* - s, c: The state and its monoid
* - a : the result type
* - q : the postcondition to be satisfied after fully reducing the programs
* - frame: a framed assertion to carry through the proof
*)
noeq
type step_result (#st:state u#s u#act) (a:Type u#a) (q:post st a) (frame:st.pred) =
| Step: next:_ -> //precondition of the reduct
m:m a next q -> //the reduct
step_result a q frame
(**
* [step f frame]: Reduces a single step of [f], while framing
* the assertion [frame]
*)
let rec step
(#st:state u#s u#act)
(#p:st.pred)
(#a:Type u#a)
(#q:post st a)
(f:m a p q)
(frame:st.pred)
: Tot (nmst_sep st
(step_result a q frame)
(p `st.star` frame)
(fun x -> Step?.next x `st.star` frame))
(decreases f)
= match f with
| Ret x ->
weaken <| return <| Step (q x) (Ret x)
| Act f k ->
let k (x:_)
: Dv (nmst_sep st (step_result a q frame)
(f.post x `st.star` frame)
(fun v -> Step?.next v `st.star` frame))
= let n : m a (f.post x) q = k x in
weaken (return (Step _ n))
in
weaken <| bind (lift <| f.step frame) k
| Par #_ #pre0 #post0 (Ret x0) #pre1 #post1 (Ret x1) #a #post k ->
weaken <| return <| Step _ k
| Par #_ #pre0 #post0 m0 #pre1 #post1 m1 #a #postk k ->
let q : post st a = coerce_eq () q in
let choose (b:bool)
: nmst_sep st
(step_result a q frame)
(p `st.star` frame)
(fun x -> (Step?.next x `st.star` frame))
= if b
then weaken <|
bind (step m0 (pre1 `st.star` frame))
(fun x -> return <| Step _ <| Par (Step?.m x) m1 k)
else weaken <|
bind (step m1 (pre0 `st.star` frame))
(fun x -> return <| Step _ <| Par m0 (Step?.m x) k)
in
weaken <| bind (flip()) choose
(** The main partial correctness result:
* m computations can be interpreted into nmst_sep computations
*)
let rec run (#st:state u#s u#act)
(#pre:st.pred)
(#a:Type u#a)
(#post:post st a)
(f:m a pre post)
: Dv (nmst_sep st a pre post)
= match f with
| Ret x ->
weaken <| return x
| _ ->
let k (s:step_result a post st.emp)
: Dv (nmst_sep st a (Step?.next s) post)
= let Step _ f = s in
run f
in
weaken <| bind (step f st.emp) k | {
"checked_file": "/",
"dependencies": [
"PulseCore.NondeterministicMonotonicStateMonad.fsti.checked",
"PulseCore.MonotonicStateMonad.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "PulseCore.Semantics.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore.NondeterministicMonotonicStateMonad",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "PulseCore.NondeterministicMonotonicStateMonad",
"short_module": "NM"
},
{
"abbrev": true,
"full_module": "PulseCore.MonotonicStateMonad",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "PulseCore",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | x: a -> post: PulseCore.Semantics.post st a -> PulseCore.Semantics.m a (post x) post | Prims.Tot | [
"total"
] | [] | [
"PulseCore.Semantics.state",
"PulseCore.Semantics.post",
"PulseCore.Semantics.Ret",
"PulseCore.Semantics.m"
] | [] | false | false | false | false | false | let ret (#st: state u#s u#act) (#a: Type u#a) (x: a) (post: post st a) : m a (post x) post =
| Ret x | false |
Subsets and Splits