microsoft/FStarDataSet-V2 · Datasets at Hugging Face

Steel.Memory.fst

Steel.Memory.frame_preserving_respects_preorder

val frame_preserving_respects_preorder (#a #e #fp #fp': _) ($f: tot_action_nf_except e fp a fp') (m0: hmem_with_inv_except e fp) : Lemma (let (| x , m1 |) = f m0 in mem_evolves m0 m1)

let frame_preserving_respects_preorder #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (m0:hmem_with_inv_except e fp) : Lemma (let (| x, m1 |) = f m0 in mem_evolves m0 m1) = let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1) = () in H.emp_unit fp; assert (interp (fp `star` linv e m0) m0); H.star_congruence (fp `star` emp) (linv e m0) fp (linv e m0); assert (interp ((fp `star` emp) `star` linv e m0) m0); aux emp m0

{ "file_name": "lib/steel/Steel.Memory.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 14, "end_line": 744, "start_col": 0, "start_line": 729 }

(* 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.Memory module F = FStar.FunctionalExtensionality open FStar.FunctionalExtensionality open FStar.PCM module H = Steel.Heap noeq type lock_state : Type u#(a + 1) = | Invariant : inv:H.slprop u#a -> lock_state let lock_store : Type u#(a+1) = list (lock_state u#a) noeq type mem : Type u#(a + 1) = { ctr: nat; heap: H.heap u#a; locks: lock_store u#a; } let heap_of_mem (x:mem) : H.heap = x.heap let mem_of_heap (h:H.heap) : mem = { ctr = 0; heap = h; locks = [] } let mem_set_heap (m:mem) (h:H.heap) : mem = { ctr = m.ctr; heap = h; locks = m.locks; } let core_mem (m:mem) : mem = mem_of_heap (heap_of_mem m) let core_mem_invol m = () let disjoint (m0 m1:mem u#h) : prop = m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks let disjoint_sym m0 m1 = () let join m0 m1 = { ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = m0.locks } let join_commutative m0 m1 = H.join_commutative m0.heap m1.heap let disjoint_join m0 m1 m2 = H.disjoint_join m0.heap m1.heap m2.heap let join_associative m0 m1 m2 = H.join_associative m0.heap m1.heap m2.heap let slprop = H.slprop let interp p m = H.interp p m.heap let equiv p1 p2 = forall m. interp p1 m <==> interp p2 m let slprop_extensionality p q = assert (forall m. interp p m <==> interp q m); let aux (h:H.heap) : Lemma (H.interp p h <==> H.interp q h) [SMTPat (H.interp p h)] = let m : mem = { ctr = 0; heap = h; locks = [] } in assert (interp p m <==> interp q m) in assert (forall h. H.interp p h <==> H.interp q h); Steel.Heap.slprop_extensionality p q let reveal_equiv p1 p2 = () let core_ref = H.core_ref let core_ref_null = H.core_ref_null let core_ref_is_null r = H.core_ref_is_null r let emp : slprop u#a = H.emp let pure = H.pure let pts_to = H.pts_to let h_and = H.h_and let h_or = H.h_or let star = H.star let wand = H.wand let h_exists = H.h_exists let h_forall = H.h_forall //////////////////////////////////////////////////////////////////////////////// //properties of equiv //////////////////////////////////////////////////////////////////////////////// let equiv_symmetric (p1 p2:slprop u#a) = H.equiv_symmetric p1 p2 #push-options "--warn_error -271" let equiv_heap_iff_equiv (p1 p2:slprop u#a) : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat (equiv p1 p2)] = let aux_lr () : Lemma (requires H.equiv p1 p2) (ensures equiv p1 p2) [SMTPat ()] = () in let aux_rl_helper1 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p1 h) (ensures H.interp p2 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl_helper2 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p2 h) (ensures H.interp p1 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl () : Lemma (requires equiv p1 p2) (ensures H.equiv p1 p2) [SMTPat ()] = () in () let equiv_heap_iff_equiv_forall () : Lemma (ensures (forall p1 p2. H.equiv p1 p2 <==> equiv p1 p2)) = let aux p1 p2 : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat ()] = equiv_heap_iff_equiv p1 p2 in () #pop-options let equiv_extensional_on_star (p1 p2 p3:slprop u#a) = equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3 let emp_unit p = H.emp_unit p let intro_emp m = H.intro_emp (heap_of_mem m) let pure_equiv p q = H.pure_equiv p q let pure_interp q m = H.pure_interp q (heap_of_mem m) let pure_star_interp p q m = H.pure_star_interp p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// //pts_to //////////////////////////////////////////////////////////////////////////////// let pts_to_compatible #a #pcm x v0 v1 m = H.pts_to_compatible #a #pcm x v0 v1 (heap_of_mem m) let pts_to_compatible_equiv #a #pcm x v0 v1 = H.pts_to_compatible_equiv #a #pcm x v0 v1 let pts_to_not_null #a #pcm x v m = H.pts_to_not_null #a #pcm x v (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // star //////////////////////////////////////////////////////////////////////////////// let intro_star p q mp mq = H.intro_star p q (heap_of_mem mp) (heap_of_mem mq) let elim_star p q m = let h = heap_of_mem m in H.elim_star p q h; assert (exists hl hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr); let hl = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hl -> exists hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let hr = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hr -> H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let ml = mem_set_heap m hl in let mr = mem_set_heap m hr in assert (disjoint ml mr); assert (m == join ml mr); assert (interp p ml); assert (interp q mr); () let interp_star (p q: slprop) (m: mem) : Lemma (interp (p `star` q) m <==> (exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m)) = let left = interp (p `star` q) m in let right = exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m in let f () : Lemma (requires left) (ensures right) = elim_star p q m in let g () : Lemma (requires right) (ensures left) = Classical.exists_elim left #_ #(fun mp -> exists (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mp -> Classical.exists_elim left #_ #(fun mq -> disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mq -> intro_star p q mp mq ) ) in Classical.move_requires f (); Classical.move_requires g () let star_commutative (p1 p2:slprop) = H.star_commutative p1 p2 let star_associative (p1 p2 p3:slprop) = H.star_associative p1 p2 p3 let star_congruence (p1 p2 p3 p4:slprop) = equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4 let affine_star (p q:slprop) (m:mem) = H.affine_star p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // Invariants on the lock store //////////////////////////////////////////////////////////////////////////////// let iname = nat module S = FStar.Set module L = FStar.List.Tot module W = FStar.Witnessed.Core let rec lock_store_invariant (e:inames) (l:lock_store u#a) : slprop u#a = let current_addr = L.length l - 1 in match l with | [] -> emp | Invariant p :: tl -> if current_addr `S.mem` e then lock_store_invariant e tl else p `star` lock_store_invariant e tl let lock_i (i:iname) (l:lock_store { i < L.length l }) = let ix = L.length l - i - 1 in L.index l ix let iname_for_p (i:iname) (p:slprop) : W.s_predicate lock_store = fun l -> i < L.length l /\ (lock_i i l).inv == p let lock_store_evolves : FStar.Preorder.preorder lock_store = fun (l1 l2 : lock_store) -> L.length l2 >= L.length l1 /\ (forall (i:nat{i < L.length l1}). (lock_i i l1).inv == (lock_i i l2).inv) let inames_in (e:inames) (l:lock_store) : prop = forall i. Set.mem i e ==> i < L.length l let inames_ok e m = inames_in e m.locks let inames_ok_empty m = () let extend_lock_store (e:inames) (l:lock_store{e `inames_in` l}) (p:slprop) : i:iname & l':lock_store { lock_store_invariant e l' == p `star` lock_store_invariant e l /\ iname_for_p i p l' } = (| L.length l, Invariant p :: l |) let set_add (i:iname) (s:inames) = Set.union (Set.singleton i) s let rec move_invariant (e:inames) (l:lock_store) (p:slprop) (i:iname{iname_for_p i p l /\ ~(i `Set.mem` e)}) : Lemma (H.equiv (lock_store_invariant e l) (p `star` lock_store_invariant (set_add i e) l)) = let rec aux (i:iname) (m:lock_store) : Lemma (requires i >= L.length m) (ensures (lock_store_invariant e m `H.equiv` lock_store_invariant (set_add i e) m)) = match m with | [] -> () | Invariant p::tl -> aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl) in let current_addr = L.length l - 1 in match l with | [] -> () | Invariant q::tl -> if i = current_addr then begin assert (lock_store_invariant e l == p `star` lock_store_invariant e tl); aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl); () end else begin move_invariant e tl p i; assert (lock_store_invariant e tl `equiv` (p `star` lock_store_invariant (set_add i e) tl)); H.star_congruence q (lock_store_invariant e tl) q (p `star` lock_store_invariant (set_add i e) tl); if Set.mem current_addr e then () else begin let r = lock_store_invariant (set_add i e) tl in assert (lock_store_invariant e l `equiv` (q `star` (p `star` r))); H.star_associative q p r; H.star_commutative q p; H.star_congruence (q `star` p) r (p `star` q) r; H.star_associative p q r end end let heap_ctr_valid (ctr:nat) (h:H.heap u#a) : prop = h `H.free_above_addr` ctr let ctr_validity (ctr:nat) (h:H.heap) : slprop = H.pure (heap_ctr_valid ctr h) let locks_invariant (e:inames) (m:mem u#a) : slprop u#a = lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m) let full_mem_pred (m:mem) = H.full_heap_pred (heap_of_mem m) (***** Following lemmas are needed in Steel.Effect *****) let core_mem_interp (hp:slprop u#a) (m:mem u#a) = () let interp_depends_only_on (hp:slprop u#a) = H.interp_depends_only_on hp let a_mem_prop_as_a_heap_prop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (H.a_heap_prop u#a) = let g (h: H.heap u#a) : Tot prop = interp sl (mem_of_heap h) /\ f (mem_of_heap h) in let phi0 (h0 h1: H.heap u#a) : Lemma (requires (g h0 /\ H.disjoint h0 h1)) (ensures (g h0 /\ H.disjoint h0 h1 /\ g (H.join h0 h1))) = assert (mem_of_heap (H.join h0 h1) == mem_of_heap h0 `join` mem_of_heap h1); interp_depends_only_on sl in let phi1 (h0 h1: H.heap u#a) : Lemma (ensures ((g h0 /\ H.disjoint h0 h1) ==> g (H.join h0 h1))) = Classical.move_requires (phi0 h0) h1 in Classical.forall_intro_2 phi1; g let refine_slprop sl f = H.as_slprop (a_mem_prop_as_a_heap_prop sl f) let interp_refine_slprop sl f m = assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_mem m)) let dep_hprop (s: slprop) (f: (hmem s -> Tot slprop)) (h: H.heap) : Tot prop = exists (h1: H.heap) . exists (h2: H.heap) . interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 let dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq' : squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h')) = let p2 (h h1 h2: H.heap) : Tot prop = interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 in let p1 (h h1: H.heap) : Tot prop = (exists h2 . p2 h h1 h2) in let h1 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p1 h) in let h2 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p2 h h1) in H.disjoint_join h' h1 h2; assert (H.disjoint h2 h'); let h2' = H.join h2 h' in H.join_commutative h2 h' ; assert (h2' == H.join h' h2); assert (H.disjoint h1 h2'); assert (mem_of_heap h2' == mem_of_heap h2 `join` mem_of_heap h'); interp_depends_only_on (f (mem_of_heap h1)); assert (interp (f (mem_of_heap h1)) (mem_of_heap h2')); H.join_commutative h1 h2; H.join_associative h' h2 h1; H.join_commutative h' h; H.join_commutative h2' h1; assert (H.join h h' == h1 `H.join` h2') let impl_intro_gen (#p: Type0) (#q: Type0) ($prf: (squash p -> Lemma (q ))) : Lemma (p ==> q) = Classical.impl_intro_gen #p #(fun _ -> q) prf let dep_hprop_is_affine1 (s: slprop) (f: (hmem s -> Tot slprop)) (h0 h1: H.heap) : Lemma ((dep_hprop s f h0 /\ H.disjoint h0 h1) ==> (H.disjoint h0 h1 /\ dep_hprop s f (H.join h0 h1))) = impl_intro_gen (dep_hprop_is_affine0 s f h0 h1) let dep_hprop_is_affine (s: slprop) (f: (hmem s -> Tot slprop)) : Lemma (H.heap_prop_is_affine (dep_hprop s f)) = Classical.forall_intro_2 (dep_hprop_is_affine1 s f) let sdep (s: slprop) (f: (hmem s -> Tot slprop)) : Tot slprop = dep_hprop_is_affine s f; H.as_slprop (dep_hprop s f) let interp_sdep (s: slprop) (f: (hmem s -> Tot slprop)) (m: mem) : Lemma (requires (dep_slprop_is_affine s f)) (ensures ( interp (sdep s f) m <==> (exists m1 m2 . interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) )) = dep_hprop_is_affine s f; assert (forall m1 m2 . (interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) ==> ( interp s (mem_of_heap m1.heap) /\ interp (f (mem_of_heap m1.heap)) (mem_of_heap m2.heap) /\ H.disjoint m1.heap m2.heap /\ H.join m1.heap m2.heap == m.heap )); interp_depends_only_on s; Classical.forall_intro (fun m -> interp_depends_only_on (f m)); assert (forall h1 h2 . (interp s (mem_of_heap h1) /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ H.disjoint h1 h2 /\ H.join h1 h2 == m.heap) ==> ( core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ interp s (core_mem (mem_of_heap h1)) /\ interp s (mem_set_heap m h1) /\ core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ f (mem_set_heap m h1) `equiv` f (mem_of_heap h1) /\ interp (f (mem_set_heap m h1)) (mem_of_heap h2) /\ interp (f (mem_set_heap m h1)) (mem_set_heap m h2) /\ disjoint (mem_set_heap m h1) (mem_set_heap m h2) /\ join (mem_set_heap m h1) (mem_set_heap m h2) == m )); () let h_exists_cong (#a:Type) (p q : a -> slprop) : Lemma (requires (forall x. p x `equiv` q x)) (ensures (h_exists p `equiv` h_exists q)) = equiv_heap_iff_equiv_forall (); H.h_exists_cong p q let intro_h_exists #a x p m = H.intro_h_exists x p (heap_of_mem m) let elim_h_exists (#a:_) (p:a -> slprop) (m:mem) = H.elim_h_exists p (heap_of_mem m) let intro_h_forall (#a:_) (p:a -> slprop) (m:mem) = H.intro_h_forall p (heap_of_mem m) let elim_h_forall (#a:_) (p:a -> slprop) (m:mem) (x:a) = H.elim_h_forall p (heap_of_mem m) x let intro_h_and (p q: slprop) (m:mem) = H.intro_h_and p q (heap_of_mem m) let elim_h_and (p q: slprop) (m:mem) = H.elim_h_and p q (heap_of_mem m) let intro_h_or_left (p q: slprop) (m:mem) = H.intro_h_or_left p q (heap_of_mem m) let intro_h_or_right (p q: slprop) (m:mem) = H.intro_h_or_right p q (heap_of_mem m) let elim_h_or (p q: slprop) (m:mem) = H.elim_h_or p q (heap_of_mem m) let intro_wand (p1 p2: slprop u#a) (m:mem) = introduce (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)) ==> interp (wand p1 p2) m with _. ( assert (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)); H.intro_wand p1 p2 (heap_of_mem m); let h = heap_of_mem m in assert ((forall h1. h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) ==> H.interp (wand p1 p2) h); introduce forall h1. (h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) with ( introduce (h `H.disjoint` h1 /\ H.interp p1 h1) ==> H.interp p2 (H.join h h1) with _. ( assert (h `H.disjoint` h1); let m1 = { ctr = m.ctr; heap = h1; locks = m.locks } in assert (m `disjoint` m1) ) ) ) (** Eliminating a wand by proving a heap that satisfies the LHS **) let elim_wand (p1 p2: slprop u#a) (m:mem) (m1:mem) = H.elim_wand p1 p2 (heap_of_mem m) (heap_of_mem m1) //////////////////////////////////////////////////////////////////////////////// // Preorders and effects //////////////////////////////////////////////////////////////////////////////// module PP = Steel.Preorder let mem_evolves = fun (m0 m1:full_mem) -> H.heap_evolves (heap_of_mem m0) (heap_of_mem m1) /\ m0.ctr <= m1.ctr /\ lock_store_evolves m0.locks m1.locks (** See [Steel.Heap.is_frame_preserving]. We add in [lock_invariants] now *) let preserves_frame (e:inames) (pre post:slprop) (m0 m1:mem) = forall (frame:slprop). interp ((pre `star` frame) `star` locks_invariant e m0) m0 ==> (interp ((post `star` frame) `star` locks_invariant e m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) (** This is a version of MstTot with frame quantified, as part of preserves_frame *) effect MstTotNF (a:Type u#a) (except:inames) (expects:slprop u#1) (provides: a -> slprop u#1) = NMSTTotal.NMSTATETOT a (full_mem u#1) mem_evolves (requires fun m0 -> inames_ok except m0 /\ interp (expects `star` locks_invariant except m0) m0) (ensures fun m0 x m1 -> inames_ok except m1 /\ interp (provides x `star` locks_invariant except m1) m1 /\ preserves_frame except expects (provides x) m0 m1) //////////////////////////////////////////////////////////////////////////////// // Lifting heap actions //////////////////////////////////////////////////////////////////////////////// (** Heap actions come in two equivalent flavors: - one that take an explicit frame as argument (action_with_frame) - and one that quantify over all the frame We therefore define two lift routes: - a direct route for those with explicit frame - via MstTotNF for the rest *) let tot_pre_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = hmem_with_inv_except e fp -> (x:a & hmem_with_inv_except e (fp' x)) let tot_pre_action_nf = tot_pre_action_nf_except S.empty let ac_reasoning_for_m_frame_preserving (p q r:slprop u#a) (m:mem u#a) : Lemma (requires interp ((p `star` q) `star` r) m) (ensures interp (p `star` r) m) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_commutative p q; equiv_extensional_on_star (p `star` q) (q `star` p) r } (q `star` p) `star` r; (equiv) { star_associative q p r } q `star` (p `star` r); }; assert (interp (q `star` (p `star` r)) m); affine_star q (p `star` r) m let is_frame_preserving (#e:inames) (#a:Type u#b) (#fp:slprop u#a) (#fp':a -> slprop u#a) (f:tot_pre_action_nf_except e fp a fp') = forall (frame:slprop u#a) (m0:hmem_with_inv_except e (fp `star` frame)). (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = f:tot_pre_action_nf_except e fp a fp'{ is_frame_preserving f } let tot_action_nf = tot_action_nf_except S.empty let linv e (m:mem) = locks_invariant e m let hheap_of_hmem #fp #e (m:hmem_with_inv_except e fp) : h:H.hheap (fp `star` linv e m) { h `H.free_above_addr` m.ctr} = let h = heap_of_mem m in H.pure_interp (heap_ctr_valid m.ctr (heap_of_mem m)) h; h let hmem_of_hheap #e (#fp0 #fp1:slprop) (m:hmem_with_inv_except e fp0) (h:H.full_hheap (fp1 `star` linv e m) { h `Heap.free_above_addr` m.ctr }) : m1:hmem_with_inv_except e fp1{linv e m `equiv` linv e m1} = let m1 : mem = { m with heap = h } in assert (interp (fp1 `star` linv e m) m1); star_commutative fp1 (linv e m); assert (interp (linv e m `star` fp1) m1); assert (linv e m1 == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); assert (linv e m == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m)); H.pure_interp (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_of_mem m); assert (heap_ctr_valid m1.ctr (heap_of_mem m) <==> heap_ctr_valid m1.ctr (heap_of_mem m1)); H.pure_equiv (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_ctr_valid m1.ctr (heap_of_mem m1)); H.star_congruence (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m)); assert (linv e m `equiv` linv e m1); let _ = equiv_extensional_on_star (linv e m) (linv e m1) fp1 in assert ((linv e m `star` fp1) `equiv` (linv e m1 `star` fp1)); assert (interp (linv e m1 `star` fp1) m1); star_commutative (linv e m1) fp1; assert (interp (fp1 `star` linv e m1) m1); m1 let with_inv_except (m:mem) e (fp:slprop) = interp (fp `star` locks_invariant e m) m #push-options "--warn_error -271" let as_hprop (frame:slprop) (mp:mprop frame) : hp:H.hprop frame{forall m. mp (core_mem m) == hp (heap_of_mem m)} = let f = fun h -> mp (mem_of_heap h) in assert (forall m. mp (core_mem m) == f (heap_of_mem m)); let aux (m0:H.hheap frame) (m1:H.heap{H.disjoint m0 m1}) : Lemma (ensures (mem_of_heap (H.join m0 m1) == join (mem_of_heap m0) (mem_of_heap m1))) [SMTPat ()] = () in f let mprop_preservation_of_hprop_preservation (p:slprop) (m0 m1:mem) : Lemma (requires (forall (hp:H.hprop p). hp (heap_of_mem m0) == hp (heap_of_mem m1))) (ensures (forall (mp:mprop p). mp (core_mem m0) == mp (core_mem m1))) = let aux (mp:mprop p) : Lemma (mp (core_mem m0) == mp (core_mem m1)) [SMTPat()] = assert (as_hprop p mp (heap_of_mem m0) == as_hprop p mp (heap_of_mem m1)) in () let lift_heap_action (#fp:slprop) (#a:Type) (#fp':a -> slprop) (e:inames) ($f:H.action fp a fp') : tot_action_nf_except e fp a fp' = let g : tot_pre_action_nf_except e fp a fp' = fun m -> let h0 = hheap_of_hmem m in let (| x, h' |) = f h0 in (| x, hmem_of_hheap m h' |) in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in let h0 = hheap_of_hmem m0 in let (| x', h1 |) = f h0 in H.action_framing f (linv e m0) h0; assert (x == x'); star_associative fp frame (linv e m0); H.action_framing f (frame `star` linv e m0) h0; assert (H.interp ((fp' x) `star` (frame `star` linv e m0)) h1); star_associative (fp' x) frame (linv e m0); assert (H.interp ((fp' x `star` frame) `star` linv e m0) h1); let h1' : H.hheap ((fp' x `star` frame) `star` linv e m0) = h1 in assert (m1 == hmem_of_hheap m0 h1'); assert (with_inv_except m1 e (fp' x `star` frame)); assert (forall (hp:H.hprop frame). hp h0 == hp h1); mprop_preservation_of_hprop_preservation frame m0 m1; () in assert (is_frame_preserving g); g

{ "checked_file": "/", "dependencies": [ "Steel.Preorder.fst.checked", "Steel.Heap.fsti.checked", "prims.fst.checked", "FStar.Witnessed.Core.fsti.checked", "FStar.Set.fsti.checked", "FStar.Preorder.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.PCM.fst.checked", "FStar.NMSTTotal.fst.checked", "FStar.List.Tot.fst.checked", "FStar.IndefiniteDescription.fsti.checked", "FStar.Ghost.fsti.checked", "FStar.FunctionalExtensionality.fsti.checked", "FStar.Classical.Sugar.fsti.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Steel.Memory.fst" }

[ { "abbrev": true, "full_module": "Steel.Preorder", "short_module": "PP" }, { "abbrev": true, "full_module": "FStar.Witnessed.Core", "short_module": "W" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": true, "full_module": "Steel.Heap", "short_module": "H" }, { "abbrev": false, "full_module": "FStar.PCM", "short_module": null }, { "abbrev": false, "full_module": "FStar.FunctionalExtensionality", "short_module": null }, { "abbrev": true, "full_module": "FStar.FunctionalExtensionality", "short_module": "F" }, { "abbrev": false, "full_module": "FStar.PCM", "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

$f: Steel.Memory.tot_action_nf_except e fp a fp' -> m0: Steel.Memory.hmem_with_inv_except e fp -> FStar.Pervasives.Lemma (ensures (let _ = f m0 in (let Prims.Mkdtuple2 #_ #_ _ m1 = _ in Steel.Memory.mem_evolves m0 m1) <: Type0))

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Steel.Memory.inames", "Steel.Memory.slprop", "Steel.Memory.tot_action_nf_except", "Steel.Memory.hmem_with_inv_except", "Steel.Memory.emp", "Prims.unit", "Prims._assert", "Steel.Memory.interp", "Steel.Memory.star", "Steel.Memory.linv", "Steel.Heap.star_congruence", "Steel.Heap.emp_unit", "Prims.l_True", "Prims.squash", "Prims.l_and", "Steel.Memory.locks_invariant", "Steel.Memory.mem_evolves", "Prims.Nil", "FStar.Pervasives.pattern", "Prims.dtuple2", "Steel.Memory.ac_reasoning_for_m_frame_preserving" ]

[]

false

true

false

let frame_preserving_respects_preorder #a #e #fp #fp' ($f: tot_action_nf_except e fp a fp') (m0: hmem_with_inv_except e fp) : Lemma (let (| x , m1 |) = f m0 in mem_evolves m0 m1) =

let aux (frame: slprop) (m0: hmem_with_inv_except e (fp `star` frame)) : Lemma (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x , m1 |) = f m0 in interp (((fp' x) `star` frame) `star` (locks_invariant e m1)) m1 /\ mem_evolves m0 m1) = () in H.emp_unit fp; assert (interp (fp `star` (linv e m0)) m0); H.star_congruence (fp `star` emp) (linv e m0) fp (linv e m0); assert (interp ((fp `star` emp) `star` (linv e m0)) m0); aux emp m0

false

Steel.Memory.fst

Steel.Memory.dep_hprop_is_affine0

val dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq': squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h'))

let dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq' : squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h')) = let p2 (h h1 h2: H.heap) : Tot prop = interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 in let p1 (h h1: H.heap) : Tot prop = (exists h2 . p2 h h1 h2) in let h1 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p1 h) in let h2 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p2 h h1) in H.disjoint_join h' h1 h2; assert (H.disjoint h2 h'); let h2' = H.join h2 h' in H.join_commutative h2 h' ; assert (h2' == H.join h' h2); assert (H.disjoint h1 h2'); assert (mem_of_heap h2' == mem_of_heap h2 `join` mem_of_heap h'); interp_depends_only_on (f (mem_of_heap h1)); assert (interp (f (mem_of_heap h1)) (mem_of_heap h2')); H.join_commutative h1 h2; H.join_associative h' h2 h1; H.join_commutative h' h; H.join_commutative h2' h1; assert (H.join h h' == h1 `H.join` h2')

{ "file_name": "lib/steel/Steel.Memory.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 41, "end_line": 423, "start_col": 0, "start_line": 389 }

(* 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.Memory module F = FStar.FunctionalExtensionality open FStar.FunctionalExtensionality open FStar.PCM module H = Steel.Heap noeq type lock_state : Type u#(a + 1) = | Invariant : inv:H.slprop u#a -> lock_state let lock_store : Type u#(a+1) = list (lock_state u#a) noeq type mem : Type u#(a + 1) = { ctr: nat; heap: H.heap u#a; locks: lock_store u#a; } let heap_of_mem (x:mem) : H.heap = x.heap let mem_of_heap (h:H.heap) : mem = { ctr = 0; heap = h; locks = [] } let mem_set_heap (m:mem) (h:H.heap) : mem = { ctr = m.ctr; heap = h; locks = m.locks; } let core_mem (m:mem) : mem = mem_of_heap (heap_of_mem m) let core_mem_invol m = () let disjoint (m0 m1:mem u#h) : prop = m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks let disjoint_sym m0 m1 = () let join m0 m1 = { ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = m0.locks } let join_commutative m0 m1 = H.join_commutative m0.heap m1.heap let disjoint_join m0 m1 m2 = H.disjoint_join m0.heap m1.heap m2.heap let join_associative m0 m1 m2 = H.join_associative m0.heap m1.heap m2.heap let slprop = H.slprop let interp p m = H.interp p m.heap let equiv p1 p2 = forall m. interp p1 m <==> interp p2 m let slprop_extensionality p q = assert (forall m. interp p m <==> interp q m); let aux (h:H.heap) : Lemma (H.interp p h <==> H.interp q h) [SMTPat (H.interp p h)] = let m : mem = { ctr = 0; heap = h; locks = [] } in assert (interp p m <==> interp q m) in assert (forall h. H.interp p h <==> H.interp q h); Steel.Heap.slprop_extensionality p q let reveal_equiv p1 p2 = () let core_ref = H.core_ref let core_ref_null = H.core_ref_null let core_ref_is_null r = H.core_ref_is_null r let emp : slprop u#a = H.emp let pure = H.pure let pts_to = H.pts_to let h_and = H.h_and let h_or = H.h_or let star = H.star let wand = H.wand let h_exists = H.h_exists let h_forall = H.h_forall //////////////////////////////////////////////////////////////////////////////// //properties of equiv //////////////////////////////////////////////////////////////////////////////// let equiv_symmetric (p1 p2:slprop u#a) = H.equiv_symmetric p1 p2 #push-options "--warn_error -271" let equiv_heap_iff_equiv (p1 p2:slprop u#a) : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat (equiv p1 p2)] = let aux_lr () : Lemma (requires H.equiv p1 p2) (ensures equiv p1 p2) [SMTPat ()] = () in let aux_rl_helper1 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p1 h) (ensures H.interp p2 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl_helper2 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p2 h) (ensures H.interp p1 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl () : Lemma (requires equiv p1 p2) (ensures H.equiv p1 p2) [SMTPat ()] = () in () let equiv_heap_iff_equiv_forall () : Lemma (ensures (forall p1 p2. H.equiv p1 p2 <==> equiv p1 p2)) = let aux p1 p2 : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat ()] = equiv_heap_iff_equiv p1 p2 in () #pop-options let equiv_extensional_on_star (p1 p2 p3:slprop u#a) = equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3 let emp_unit p = H.emp_unit p let intro_emp m = H.intro_emp (heap_of_mem m) let pure_equiv p q = H.pure_equiv p q let pure_interp q m = H.pure_interp q (heap_of_mem m) let pure_star_interp p q m = H.pure_star_interp p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// //pts_to //////////////////////////////////////////////////////////////////////////////// let pts_to_compatible #a #pcm x v0 v1 m = H.pts_to_compatible #a #pcm x v0 v1 (heap_of_mem m) let pts_to_compatible_equiv #a #pcm x v0 v1 = H.pts_to_compatible_equiv #a #pcm x v0 v1 let pts_to_not_null #a #pcm x v m = H.pts_to_not_null #a #pcm x v (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // star //////////////////////////////////////////////////////////////////////////////// let intro_star p q mp mq = H.intro_star p q (heap_of_mem mp) (heap_of_mem mq) let elim_star p q m = let h = heap_of_mem m in H.elim_star p q h; assert (exists hl hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr); let hl = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hl -> exists hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let hr = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hr -> H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let ml = mem_set_heap m hl in let mr = mem_set_heap m hr in assert (disjoint ml mr); assert (m == join ml mr); assert (interp p ml); assert (interp q mr); () let interp_star (p q: slprop) (m: mem) : Lemma (interp (p `star` q) m <==> (exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m)) = let left = interp (p `star` q) m in let right = exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m in let f () : Lemma (requires left) (ensures right) = elim_star p q m in let g () : Lemma (requires right) (ensures left) = Classical.exists_elim left #_ #(fun mp -> exists (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mp -> Classical.exists_elim left #_ #(fun mq -> disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mq -> intro_star p q mp mq ) ) in Classical.move_requires f (); Classical.move_requires g () let star_commutative (p1 p2:slprop) = H.star_commutative p1 p2 let star_associative (p1 p2 p3:slprop) = H.star_associative p1 p2 p3 let star_congruence (p1 p2 p3 p4:slprop) = equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4 let affine_star (p q:slprop) (m:mem) = H.affine_star p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // Invariants on the lock store //////////////////////////////////////////////////////////////////////////////// let iname = nat module S = FStar.Set module L = FStar.List.Tot module W = FStar.Witnessed.Core let rec lock_store_invariant (e:inames) (l:lock_store u#a) : slprop u#a = let current_addr = L.length l - 1 in match l with | [] -> emp | Invariant p :: tl -> if current_addr `S.mem` e then lock_store_invariant e tl else p `star` lock_store_invariant e tl let lock_i (i:iname) (l:lock_store { i < L.length l }) = let ix = L.length l - i - 1 in L.index l ix let iname_for_p (i:iname) (p:slprop) : W.s_predicate lock_store = fun l -> i < L.length l /\ (lock_i i l).inv == p let lock_store_evolves : FStar.Preorder.preorder lock_store = fun (l1 l2 : lock_store) -> L.length l2 >= L.length l1 /\ (forall (i:nat{i < L.length l1}). (lock_i i l1).inv == (lock_i i l2).inv) let inames_in (e:inames) (l:lock_store) : prop = forall i. Set.mem i e ==> i < L.length l let inames_ok e m = inames_in e m.locks let inames_ok_empty m = () let extend_lock_store (e:inames) (l:lock_store{e `inames_in` l}) (p:slprop) : i:iname & l':lock_store { lock_store_invariant e l' == p `star` lock_store_invariant e l /\ iname_for_p i p l' } = (| L.length l, Invariant p :: l |) let set_add (i:iname) (s:inames) = Set.union (Set.singleton i) s let rec move_invariant (e:inames) (l:lock_store) (p:slprop) (i:iname{iname_for_p i p l /\ ~(i `Set.mem` e)}) : Lemma (H.equiv (lock_store_invariant e l) (p `star` lock_store_invariant (set_add i e) l)) = let rec aux (i:iname) (m:lock_store) : Lemma (requires i >= L.length m) (ensures (lock_store_invariant e m `H.equiv` lock_store_invariant (set_add i e) m)) = match m with | [] -> () | Invariant p::tl -> aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl) in let current_addr = L.length l - 1 in match l with | [] -> () | Invariant q::tl -> if i = current_addr then begin assert (lock_store_invariant e l == p `star` lock_store_invariant e tl); aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl); () end else begin move_invariant e tl p i; assert (lock_store_invariant e tl `equiv` (p `star` lock_store_invariant (set_add i e) tl)); H.star_congruence q (lock_store_invariant e tl) q (p `star` lock_store_invariant (set_add i e) tl); if Set.mem current_addr e then () else begin let r = lock_store_invariant (set_add i e) tl in assert (lock_store_invariant e l `equiv` (q `star` (p `star` r))); H.star_associative q p r; H.star_commutative q p; H.star_congruence (q `star` p) r (p `star` q) r; H.star_associative p q r end end let heap_ctr_valid (ctr:nat) (h:H.heap u#a) : prop = h `H.free_above_addr` ctr let ctr_validity (ctr:nat) (h:H.heap) : slprop = H.pure (heap_ctr_valid ctr h) let locks_invariant (e:inames) (m:mem u#a) : slprop u#a = lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m) let full_mem_pred (m:mem) = H.full_heap_pred (heap_of_mem m) (***** Following lemmas are needed in Steel.Effect *****) let core_mem_interp (hp:slprop u#a) (m:mem u#a) = () let interp_depends_only_on (hp:slprop u#a) = H.interp_depends_only_on hp let a_mem_prop_as_a_heap_prop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (H.a_heap_prop u#a) = let g (h: H.heap u#a) : Tot prop = interp sl (mem_of_heap h) /\ f (mem_of_heap h) in let phi0 (h0 h1: H.heap u#a) : Lemma (requires (g h0 /\ H.disjoint h0 h1)) (ensures (g h0 /\ H.disjoint h0 h1 /\ g (H.join h0 h1))) = assert (mem_of_heap (H.join h0 h1) == mem_of_heap h0 `join` mem_of_heap h1); interp_depends_only_on sl in let phi1 (h0 h1: H.heap u#a) : Lemma (ensures ((g h0 /\ H.disjoint h0 h1) ==> g (H.join h0 h1))) = Classical.move_requires (phi0 h0) h1 in Classical.forall_intro_2 phi1; g let refine_slprop sl f = H.as_slprop (a_mem_prop_as_a_heap_prop sl f) let interp_refine_slprop sl f m = assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_mem m)) let dep_hprop (s: slprop) (f: (hmem s -> Tot slprop)) (h: H.heap) : Tot prop = exists (h1: H.heap) . exists (h2: H.heap) . interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2

{ "checked_file": "/", "dependencies": [ "Steel.Preorder.fst.checked", "Steel.Heap.fsti.checked", "prims.fst.checked", "FStar.Witnessed.Core.fsti.checked", "FStar.Set.fsti.checked", "FStar.Preorder.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.PCM.fst.checked", "FStar.NMSTTotal.fst.checked", "FStar.List.Tot.fst.checked", "FStar.IndefiniteDescription.fsti.checked", "FStar.Ghost.fsti.checked", "FStar.FunctionalExtensionality.fsti.checked", "FStar.Classical.Sugar.fsti.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Steel.Memory.fst" }

[ { "abbrev": true, "full_module": "FStar.Witnessed.Core", "short_module": "W" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": true, "full_module": "Steel.Heap", "short_module": "H" }, { "abbrev": false, "full_module": "FStar.PCM", "short_module": null }, { "abbrev": false, "full_module": "FStar.FunctionalExtensionality", "short_module": null }, { "abbrev": true, "full_module": "FStar.FunctionalExtensionality", "short_module": "F" }, { "abbrev": false, "full_module": "FStar.PCM", "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

s: Steel.Memory.slprop -> f: (_: Steel.Memory.hmem s -> Steel.Memory.slprop) -> h: Steel.Heap.heap -> h': Steel.Heap.heap -> sq': Prims.squash (Steel.Memory.dep_hprop s f h /\ Steel.Heap.disjoint h h') -> FStar.Pervasives.Lemma (ensures Steel.Heap.disjoint h h' /\ Steel.Memory.dep_hprop s f (Steel.Heap.join h h'))

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Steel.Memory.slprop", "Steel.Memory.hmem", "Steel.Heap.heap", "Prims.squash", "Prims.l_and", "Steel.Memory.dep_hprop", "Steel.Heap.disjoint", "Prims._assert", "Prims.eq2", "Steel.Heap.join", "Prims.unit", "Steel.Heap.join_commutative", "Steel.Heap.join_associative", "Steel.Memory.interp", "Steel.Memory.mem_of_heap", "Steel.Memory.interp_depends_only_on", "Steel.Memory.mem", "Steel.Memory.join", "Steel.Heap.disjoint_join", "FStar.IndefiniteDescription.indefinite_description_ghost", "Prims.prop", "Prims.l_Exists", "Prims.l_True", "Prims.Nil", "FStar.Pervasives.pattern" ]

[]

false

true

false

let dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq': squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h')) =

let p2 (h h1 h2: H.heap) : Tot prop = interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 in let p1 (h h1: H.heap) : Tot prop = (exists h2. p2 h h1 h2) in let h1 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p1 h) in let h2 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p2 h h1) in H.disjoint_join h' h1 h2; assert (H.disjoint h2 h'); let h2' = H.join h2 h' in H.join_commutative h2 h'; assert (h2' == H.join h' h2); assert (H.disjoint h1 h2'); assert (mem_of_heap h2' == (mem_of_heap h2) `join` (mem_of_heap h')); interp_depends_only_on (f (mem_of_heap h1)); assert (interp (f (mem_of_heap h1)) (mem_of_heap h2')); H.join_commutative h1 h2; H.join_associative h' h2 h1; H.join_commutative h' h; H.join_commutative h2' h1; assert (H.join h h' == h1 `H.join` h2')

false

Steel.Memory.fst

Steel.Memory.witnessed

val witnessed (#a:Type u#1) (#pcm:pcm a) (r:ref a pcm) (fact:property a) : Type0

let witnessed (#a:Type u#1) (#pcm:pcm a) (r:ref a pcm) (fact:property a) = W.witnessed _ mem_evolves (witnessed_ref r fact)

{ "file_name": "lib/steel/Steel.Memory.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 52, "end_line": 1008, "start_col": 0, "start_line": 1004 }

(* 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.Memory module F = FStar.FunctionalExtensionality open FStar.FunctionalExtensionality open FStar.PCM module H = Steel.Heap noeq type lock_state : Type u#(a + 1) = | Invariant : inv:H.slprop u#a -> lock_state let lock_store : Type u#(a+1) = list (lock_state u#a) noeq type mem : Type u#(a + 1) = { ctr: nat; heap: H.heap u#a; locks: lock_store u#a; } let heap_of_mem (x:mem) : H.heap = x.heap let mem_of_heap (h:H.heap) : mem = { ctr = 0; heap = h; locks = [] } let mem_set_heap (m:mem) (h:H.heap) : mem = { ctr = m.ctr; heap = h; locks = m.locks; } let core_mem (m:mem) : mem = mem_of_heap (heap_of_mem m) let core_mem_invol m = () let disjoint (m0 m1:mem u#h) : prop = m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks let disjoint_sym m0 m1 = () let join m0 m1 = { ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = m0.locks } let join_commutative m0 m1 = H.join_commutative m0.heap m1.heap let disjoint_join m0 m1 m2 = H.disjoint_join m0.heap m1.heap m2.heap let join_associative m0 m1 m2 = H.join_associative m0.heap m1.heap m2.heap let slprop = H.slprop let interp p m = H.interp p m.heap let equiv p1 p2 = forall m. interp p1 m <==> interp p2 m let slprop_extensionality p q = assert (forall m. interp p m <==> interp q m); let aux (h:H.heap) : Lemma (H.interp p h <==> H.interp q h) [SMTPat (H.interp p h)] = let m : mem = { ctr = 0; heap = h; locks = [] } in assert (interp p m <==> interp q m) in assert (forall h. H.interp p h <==> H.interp q h); Steel.Heap.slprop_extensionality p q let reveal_equiv p1 p2 = () let core_ref = H.core_ref let core_ref_null = H.core_ref_null let core_ref_is_null r = H.core_ref_is_null r let emp : slprop u#a = H.emp let pure = H.pure let pts_to = H.pts_to let h_and = H.h_and let h_or = H.h_or let star = H.star let wand = H.wand let h_exists = H.h_exists let h_forall = H.h_forall //////////////////////////////////////////////////////////////////////////////// //properties of equiv //////////////////////////////////////////////////////////////////////////////// let equiv_symmetric (p1 p2:slprop u#a) = H.equiv_symmetric p1 p2 #push-options "--warn_error -271" let equiv_heap_iff_equiv (p1 p2:slprop u#a) : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat (equiv p1 p2)] = let aux_lr () : Lemma (requires H.equiv p1 p2) (ensures equiv p1 p2) [SMTPat ()] = () in let aux_rl_helper1 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p1 h) (ensures H.interp p2 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl_helper2 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p2 h) (ensures H.interp p1 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl () : Lemma (requires equiv p1 p2) (ensures H.equiv p1 p2) [SMTPat ()] = () in () let equiv_heap_iff_equiv_forall () : Lemma (ensures (forall p1 p2. H.equiv p1 p2 <==> equiv p1 p2)) = let aux p1 p2 : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat ()] = equiv_heap_iff_equiv p1 p2 in () #pop-options let equiv_extensional_on_star (p1 p2 p3:slprop u#a) = equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3 let emp_unit p = H.emp_unit p let intro_emp m = H.intro_emp (heap_of_mem m) let pure_equiv p q = H.pure_equiv p q let pure_interp q m = H.pure_interp q (heap_of_mem m) let pure_star_interp p q m = H.pure_star_interp p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// //pts_to //////////////////////////////////////////////////////////////////////////////// let pts_to_compatible #a #pcm x v0 v1 m = H.pts_to_compatible #a #pcm x v0 v1 (heap_of_mem m) let pts_to_compatible_equiv #a #pcm x v0 v1 = H.pts_to_compatible_equiv #a #pcm x v0 v1 let pts_to_not_null #a #pcm x v m = H.pts_to_not_null #a #pcm x v (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // star //////////////////////////////////////////////////////////////////////////////// let intro_star p q mp mq = H.intro_star p q (heap_of_mem mp) (heap_of_mem mq) let elim_star p q m = let h = heap_of_mem m in H.elim_star p q h; assert (exists hl hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr); let hl = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hl -> exists hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let hr = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hr -> H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let ml = mem_set_heap m hl in let mr = mem_set_heap m hr in assert (disjoint ml mr); assert (m == join ml mr); assert (interp p ml); assert (interp q mr); () let interp_star (p q: slprop) (m: mem) : Lemma (interp (p `star` q) m <==> (exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m)) = let left = interp (p `star` q) m in let right = exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m in let f () : Lemma (requires left) (ensures right) = elim_star p q m in let g () : Lemma (requires right) (ensures left) = Classical.exists_elim left #_ #(fun mp -> exists (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mp -> Classical.exists_elim left #_ #(fun mq -> disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mq -> intro_star p q mp mq ) ) in Classical.move_requires f (); Classical.move_requires g () let star_commutative (p1 p2:slprop) = H.star_commutative p1 p2 let star_associative (p1 p2 p3:slprop) = H.star_associative p1 p2 p3 let star_congruence (p1 p2 p3 p4:slprop) = equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4 let affine_star (p q:slprop) (m:mem) = H.affine_star p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // Invariants on the lock store //////////////////////////////////////////////////////////////////////////////// let iname = nat module S = FStar.Set module L = FStar.List.Tot module W = FStar.Witnessed.Core let rec lock_store_invariant (e:inames) (l:lock_store u#a) : slprop u#a = let current_addr = L.length l - 1 in match l with | [] -> emp | Invariant p :: tl -> if current_addr `S.mem` e then lock_store_invariant e tl else p `star` lock_store_invariant e tl let lock_i (i:iname) (l:lock_store { i < L.length l }) = let ix = L.length l - i - 1 in L.index l ix let iname_for_p (i:iname) (p:slprop) : W.s_predicate lock_store = fun l -> i < L.length l /\ (lock_i i l).inv == p let lock_store_evolves : FStar.Preorder.preorder lock_store = fun (l1 l2 : lock_store) -> L.length l2 >= L.length l1 /\ (forall (i:nat{i < L.length l1}). (lock_i i l1).inv == (lock_i i l2).inv) let inames_in (e:inames) (l:lock_store) : prop = forall i. Set.mem i e ==> i < L.length l let inames_ok e m = inames_in e m.locks let inames_ok_empty m = () let extend_lock_store (e:inames) (l:lock_store{e `inames_in` l}) (p:slprop) : i:iname & l':lock_store { lock_store_invariant e l' == p `star` lock_store_invariant e l /\ iname_for_p i p l' } = (| L.length l, Invariant p :: l |) let set_add (i:iname) (s:inames) = Set.union (Set.singleton i) s let rec move_invariant (e:inames) (l:lock_store) (p:slprop) (i:iname{iname_for_p i p l /\ ~(i `Set.mem` e)}) : Lemma (H.equiv (lock_store_invariant e l) (p `star` lock_store_invariant (set_add i e) l)) = let rec aux (i:iname) (m:lock_store) : Lemma (requires i >= L.length m) (ensures (lock_store_invariant e m `H.equiv` lock_store_invariant (set_add i e) m)) = match m with | [] -> () | Invariant p::tl -> aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl) in let current_addr = L.length l - 1 in match l with | [] -> () | Invariant q::tl -> if i = current_addr then begin assert (lock_store_invariant e l == p `star` lock_store_invariant e tl); aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl); () end else begin move_invariant e tl p i; assert (lock_store_invariant e tl `equiv` (p `star` lock_store_invariant (set_add i e) tl)); H.star_congruence q (lock_store_invariant e tl) q (p `star` lock_store_invariant (set_add i e) tl); if Set.mem current_addr e then () else begin let r = lock_store_invariant (set_add i e) tl in assert (lock_store_invariant e l `equiv` (q `star` (p `star` r))); H.star_associative q p r; H.star_commutative q p; H.star_congruence (q `star` p) r (p `star` q) r; H.star_associative p q r end end let heap_ctr_valid (ctr:nat) (h:H.heap u#a) : prop = h `H.free_above_addr` ctr let ctr_validity (ctr:nat) (h:H.heap) : slprop = H.pure (heap_ctr_valid ctr h) let locks_invariant (e:inames) (m:mem u#a) : slprop u#a = lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m) let full_mem_pred (m:mem) = H.full_heap_pred (heap_of_mem m) (***** Following lemmas are needed in Steel.Effect *****) let core_mem_interp (hp:slprop u#a) (m:mem u#a) = () let interp_depends_only_on (hp:slprop u#a) = H.interp_depends_only_on hp let a_mem_prop_as_a_heap_prop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (H.a_heap_prop u#a) = let g (h: H.heap u#a) : Tot prop = interp sl (mem_of_heap h) /\ f (mem_of_heap h) in let phi0 (h0 h1: H.heap u#a) : Lemma (requires (g h0 /\ H.disjoint h0 h1)) (ensures (g h0 /\ H.disjoint h0 h1 /\ g (H.join h0 h1))) = assert (mem_of_heap (H.join h0 h1) == mem_of_heap h0 `join` mem_of_heap h1); interp_depends_only_on sl in let phi1 (h0 h1: H.heap u#a) : Lemma (ensures ((g h0 /\ H.disjoint h0 h1) ==> g (H.join h0 h1))) = Classical.move_requires (phi0 h0) h1 in Classical.forall_intro_2 phi1; g let refine_slprop sl f = H.as_slprop (a_mem_prop_as_a_heap_prop sl f) let interp_refine_slprop sl f m = assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_mem m)) let dep_hprop (s: slprop) (f: (hmem s -> Tot slprop)) (h: H.heap) : Tot prop = exists (h1: H.heap) . exists (h2: H.heap) . interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 let dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq' : squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h')) = let p2 (h h1 h2: H.heap) : Tot prop = interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 in let p1 (h h1: H.heap) : Tot prop = (exists h2 . p2 h h1 h2) in let h1 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p1 h) in let h2 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p2 h h1) in H.disjoint_join h' h1 h2; assert (H.disjoint h2 h'); let h2' = H.join h2 h' in H.join_commutative h2 h' ; assert (h2' == H.join h' h2); assert (H.disjoint h1 h2'); assert (mem_of_heap h2' == mem_of_heap h2 `join` mem_of_heap h'); interp_depends_only_on (f (mem_of_heap h1)); assert (interp (f (mem_of_heap h1)) (mem_of_heap h2')); H.join_commutative h1 h2; H.join_associative h' h2 h1; H.join_commutative h' h; H.join_commutative h2' h1; assert (H.join h h' == h1 `H.join` h2') let impl_intro_gen (#p: Type0) (#q: Type0) ($prf: (squash p -> Lemma (q ))) : Lemma (p ==> q) = Classical.impl_intro_gen #p #(fun _ -> q) prf let dep_hprop_is_affine1 (s: slprop) (f: (hmem s -> Tot slprop)) (h0 h1: H.heap) : Lemma ((dep_hprop s f h0 /\ H.disjoint h0 h1) ==> (H.disjoint h0 h1 /\ dep_hprop s f (H.join h0 h1))) = impl_intro_gen (dep_hprop_is_affine0 s f h0 h1) let dep_hprop_is_affine (s: slprop) (f: (hmem s -> Tot slprop)) : Lemma (H.heap_prop_is_affine (dep_hprop s f)) = Classical.forall_intro_2 (dep_hprop_is_affine1 s f) let sdep (s: slprop) (f: (hmem s -> Tot slprop)) : Tot slprop = dep_hprop_is_affine s f; H.as_slprop (dep_hprop s f) let interp_sdep (s: slprop) (f: (hmem s -> Tot slprop)) (m: mem) : Lemma (requires (dep_slprop_is_affine s f)) (ensures ( interp (sdep s f) m <==> (exists m1 m2 . interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) )) = dep_hprop_is_affine s f; assert (forall m1 m2 . (interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) ==> ( interp s (mem_of_heap m1.heap) /\ interp (f (mem_of_heap m1.heap)) (mem_of_heap m2.heap) /\ H.disjoint m1.heap m2.heap /\ H.join m1.heap m2.heap == m.heap )); interp_depends_only_on s; Classical.forall_intro (fun m -> interp_depends_only_on (f m)); assert (forall h1 h2 . (interp s (mem_of_heap h1) /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ H.disjoint h1 h2 /\ H.join h1 h2 == m.heap) ==> ( core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ interp s (core_mem (mem_of_heap h1)) /\ interp s (mem_set_heap m h1) /\ core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ f (mem_set_heap m h1) `equiv` f (mem_of_heap h1) /\ interp (f (mem_set_heap m h1)) (mem_of_heap h2) /\ interp (f (mem_set_heap m h1)) (mem_set_heap m h2) /\ disjoint (mem_set_heap m h1) (mem_set_heap m h2) /\ join (mem_set_heap m h1) (mem_set_heap m h2) == m )); () let h_exists_cong (#a:Type) (p q : a -> slprop) : Lemma (requires (forall x. p x `equiv` q x)) (ensures (h_exists p `equiv` h_exists q)) = equiv_heap_iff_equiv_forall (); H.h_exists_cong p q let intro_h_exists #a x p m = H.intro_h_exists x p (heap_of_mem m) let elim_h_exists (#a:_) (p:a -> slprop) (m:mem) = H.elim_h_exists p (heap_of_mem m) let intro_h_forall (#a:_) (p:a -> slprop) (m:mem) = H.intro_h_forall p (heap_of_mem m) let elim_h_forall (#a:_) (p:a -> slprop) (m:mem) (x:a) = H.elim_h_forall p (heap_of_mem m) x let intro_h_and (p q: slprop) (m:mem) = H.intro_h_and p q (heap_of_mem m) let elim_h_and (p q: slprop) (m:mem) = H.elim_h_and p q (heap_of_mem m) let intro_h_or_left (p q: slprop) (m:mem) = H.intro_h_or_left p q (heap_of_mem m) let intro_h_or_right (p q: slprop) (m:mem) = H.intro_h_or_right p q (heap_of_mem m) let elim_h_or (p q: slprop) (m:mem) = H.elim_h_or p q (heap_of_mem m) let intro_wand (p1 p2: slprop u#a) (m:mem) = introduce (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)) ==> interp (wand p1 p2) m with _. ( assert (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)); H.intro_wand p1 p2 (heap_of_mem m); let h = heap_of_mem m in assert ((forall h1. h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) ==> H.interp (wand p1 p2) h); introduce forall h1. (h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) with ( introduce (h `H.disjoint` h1 /\ H.interp p1 h1) ==> H.interp p2 (H.join h h1) with _. ( assert (h `H.disjoint` h1); let m1 = { ctr = m.ctr; heap = h1; locks = m.locks } in assert (m `disjoint` m1) ) ) ) (** Eliminating a wand by proving a heap that satisfies the LHS **) let elim_wand (p1 p2: slprop u#a) (m:mem) (m1:mem) = H.elim_wand p1 p2 (heap_of_mem m) (heap_of_mem m1) //////////////////////////////////////////////////////////////////////////////// // Preorders and effects //////////////////////////////////////////////////////////////////////////////// module PP = Steel.Preorder let mem_evolves = fun (m0 m1:full_mem) -> H.heap_evolves (heap_of_mem m0) (heap_of_mem m1) /\ m0.ctr <= m1.ctr /\ lock_store_evolves m0.locks m1.locks (** See [Steel.Heap.is_frame_preserving]. We add in [lock_invariants] now *) let preserves_frame (e:inames) (pre post:slprop) (m0 m1:mem) = forall (frame:slprop). interp ((pre `star` frame) `star` locks_invariant e m0) m0 ==> (interp ((post `star` frame) `star` locks_invariant e m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) (** This is a version of MstTot with frame quantified, as part of preserves_frame *) effect MstTotNF (a:Type u#a) (except:inames) (expects:slprop u#1) (provides: a -> slprop u#1) = NMSTTotal.NMSTATETOT a (full_mem u#1) mem_evolves (requires fun m0 -> inames_ok except m0 /\ interp (expects `star` locks_invariant except m0) m0) (ensures fun m0 x m1 -> inames_ok except m1 /\ interp (provides x `star` locks_invariant except m1) m1 /\ preserves_frame except expects (provides x) m0 m1) //////////////////////////////////////////////////////////////////////////////// // Lifting heap actions //////////////////////////////////////////////////////////////////////////////// (** Heap actions come in two equivalent flavors: - one that take an explicit frame as argument (action_with_frame) - and one that quantify over all the frame We therefore define two lift routes: - a direct route for those with explicit frame - via MstTotNF for the rest *) let tot_pre_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = hmem_with_inv_except e fp -> (x:a & hmem_with_inv_except e (fp' x)) let tot_pre_action_nf = tot_pre_action_nf_except S.empty let ac_reasoning_for_m_frame_preserving (p q r:slprop u#a) (m:mem u#a) : Lemma (requires interp ((p `star` q) `star` r) m) (ensures interp (p `star` r) m) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_commutative p q; equiv_extensional_on_star (p `star` q) (q `star` p) r } (q `star` p) `star` r; (equiv) { star_associative q p r } q `star` (p `star` r); }; assert (interp (q `star` (p `star` r)) m); affine_star q (p `star` r) m let is_frame_preserving (#e:inames) (#a:Type u#b) (#fp:slprop u#a) (#fp':a -> slprop u#a) (f:tot_pre_action_nf_except e fp a fp') = forall (frame:slprop u#a) (m0:hmem_with_inv_except e (fp `star` frame)). (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = f:tot_pre_action_nf_except e fp a fp'{ is_frame_preserving f } let tot_action_nf = tot_action_nf_except S.empty let linv e (m:mem) = locks_invariant e m let hheap_of_hmem #fp #e (m:hmem_with_inv_except e fp) : h:H.hheap (fp `star` linv e m) { h `H.free_above_addr` m.ctr} = let h = heap_of_mem m in H.pure_interp (heap_ctr_valid m.ctr (heap_of_mem m)) h; h let hmem_of_hheap #e (#fp0 #fp1:slprop) (m:hmem_with_inv_except e fp0) (h:H.full_hheap (fp1 `star` linv e m) { h `Heap.free_above_addr` m.ctr }) : m1:hmem_with_inv_except e fp1{linv e m `equiv` linv e m1} = let m1 : mem = { m with heap = h } in assert (interp (fp1 `star` linv e m) m1); star_commutative fp1 (linv e m); assert (interp (linv e m `star` fp1) m1); assert (linv e m1 == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); assert (linv e m == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m)); H.pure_interp (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_of_mem m); assert (heap_ctr_valid m1.ctr (heap_of_mem m) <==> heap_ctr_valid m1.ctr (heap_of_mem m1)); H.pure_equiv (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_ctr_valid m1.ctr (heap_of_mem m1)); H.star_congruence (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m)); assert (linv e m `equiv` linv e m1); let _ = equiv_extensional_on_star (linv e m) (linv e m1) fp1 in assert ((linv e m `star` fp1) `equiv` (linv e m1 `star` fp1)); assert (interp (linv e m1 `star` fp1) m1); star_commutative (linv e m1) fp1; assert (interp (fp1 `star` linv e m1) m1); m1 let with_inv_except (m:mem) e (fp:slprop) = interp (fp `star` locks_invariant e m) m #push-options "--warn_error -271" let as_hprop (frame:slprop) (mp:mprop frame) : hp:H.hprop frame{forall m. mp (core_mem m) == hp (heap_of_mem m)} = let f = fun h -> mp (mem_of_heap h) in assert (forall m. mp (core_mem m) == f (heap_of_mem m)); let aux (m0:H.hheap frame) (m1:H.heap{H.disjoint m0 m1}) : Lemma (ensures (mem_of_heap (H.join m0 m1) == join (mem_of_heap m0) (mem_of_heap m1))) [SMTPat ()] = () in f let mprop_preservation_of_hprop_preservation (p:slprop) (m0 m1:mem) : Lemma (requires (forall (hp:H.hprop p). hp (heap_of_mem m0) == hp (heap_of_mem m1))) (ensures (forall (mp:mprop p). mp (core_mem m0) == mp (core_mem m1))) = let aux (mp:mprop p) : Lemma (mp (core_mem m0) == mp (core_mem m1)) [SMTPat()] = assert (as_hprop p mp (heap_of_mem m0) == as_hprop p mp (heap_of_mem m1)) in () let lift_heap_action (#fp:slprop) (#a:Type) (#fp':a -> slprop) (e:inames) ($f:H.action fp a fp') : tot_action_nf_except e fp a fp' = let g : tot_pre_action_nf_except e fp a fp' = fun m -> let h0 = hheap_of_hmem m in let (| x, h' |) = f h0 in (| x, hmem_of_hheap m h' |) in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in let h0 = hheap_of_hmem m0 in let (| x', h1 |) = f h0 in H.action_framing f (linv e m0) h0; assert (x == x'); star_associative fp frame (linv e m0); H.action_framing f (frame `star` linv e m0) h0; assert (H.interp ((fp' x) `star` (frame `star` linv e m0)) h1); star_associative (fp' x) frame (linv e m0); assert (H.interp ((fp' x `star` frame) `star` linv e m0) h1); let h1' : H.hheap ((fp' x `star` frame) `star` linv e m0) = h1 in assert (m1 == hmem_of_hheap m0 h1'); assert (with_inv_except m1 e (fp' x `star` frame)); assert (forall (hp:H.hprop frame). hp h0 == hp h1); mprop_preservation_of_hprop_preservation frame m0 m1; () in assert (is_frame_preserving g); g let frame_preserving_respects_preorder #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (m0:hmem_with_inv_except e fp) : Lemma (let (| x, m1 |) = f m0 in mem_evolves m0 m1) = let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1) = () in H.emp_unit fp; assert (interp (fp `star` linv e m0) m0); H.star_congruence (fp `star` emp) (linv e m0) fp (linv e m0); assert (interp ((fp `star` emp) `star` linv e m0) m0); aux emp m0 let lift_tot_action_nf #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') : MstTotNF a e fp fp' = let m0 = NMSTTotal.get () in let m0' : hmem_with_inv_except e fp = m0 in let r = f m0' in let (| x, m1 |) = r in let m1' : hmem_with_inv_except e (fp' x) = m1 in assert (is_frame_preserving f); assert (m1 == dsnd (f m0)); frame_preserving_respects_preorder f m0; NMSTTotal.put #_ #(mem_evolves) m1; x let lift_tot_action #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get #(full_mem) #_ () in ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); lift_tot_action_nf f (** Now defining the lift for heap actions with explicit frame *) let tot_action_with_frame_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = frame:slprop u#a -> m0:hmem_with_inv_except e (fp `star` frame) -> Pure (x:a & hmem_with_inv_except e (fp' x `star` frame)) (requires True) (ensures fun (| x, m1 |) -> mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_with_frame = tot_action_with_frame_except S.empty let lift_heap_action_with_frame (#fp:slprop u#a) (#a:Type u#b) (#fp':a -> slprop u#a) (e:inames) ($f:H.action_with_frame fp a fp') : tot_action_with_frame_except e fp a fp' = fun frame m0 -> let h0 = hheap_of_hmem m0 in calc (equiv) { fp `star` frame `star` locks_invariant e m0; (equiv) { star_associative fp frame (locks_invariant e m0) } fp `star` (frame `star` locks_invariant e m0); }; assert (H.interp (fp `star` frame `star` locks_invariant e m0) h0); assert (H.interp (fp `star` (frame `star` locks_invariant e m0)) h0); //key: apply the heap action with frame * locks_invariant e m0 let (| x, h1 |) = f (frame `star` locks_invariant e m0) h0 in calc (equiv) { fp' x `star` (frame `star` locks_invariant e m0); (equiv) { star_associative (fp' x) frame (locks_invariant e m0) } fp' x `star` frame `star` locks_invariant e m0; }; assert (H.interp (fp' x `star` (frame `star` locks_invariant e m0)) h1); assert (H.interp (fp' x `star` frame `star` locks_invariant e m0) h1); let m1 = hmem_of_hheap m0 h1 in assert (mem_evolves m0 m1); mprop_preservation_of_hprop_preservation (frame `star` locks_invariant e m0) m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)); (| x, m1 |) let lift_tot_action_with_frame #a #e #fp #fp' ($f:tot_action_with_frame_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in assert (inames_ok e m0); ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); let m0' : hmem_with_inv_except e fp = m0 in let r = f frame m0' in let (| x, m1 |) = r in ac_reasoning_for_m_frame_preserving (fp' x) frame (locks_invariant e m1) m1; assert (interp (fp' x `star` frame `star` locks_invariant e m1) m1); assert (interp (fp' x `star` locks_invariant e m1) m1); let m1' : hmem_with_inv_except e (fp' x) = m1 in NMSTTotal.put #_ #(mem_evolves) m1; x let sel_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.sel_action #a #pcm r v0)) let upd_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.upd_action #a #pcm r v0 v1)) let free_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.free_action #a #pcm r v0)) let split_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.split_action #a #pcm r v0 v1)) let gather_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.gather_action #a #pcm r v0 v1)) let weaken (p q r:slprop) (h:H.hheap (p `star` q) { H.stronger q r }) : H.hheap (p `star` r) = H.weaken p q r h; h let weaken_pure (q r: prop) : Lemma (requires (q ==> r)) (ensures H.stronger (H.pure q) (H.pure r)) = let aux (h:H.heap) : Lemma (ensures (H.interp (H.pure q) h ==> H.interp (H.pure r) h)) [SMTPat ()] = H.pure_interp q h; H.pure_interp r h in () let inc_ctr (#p:slprop) #e (m:hmem_with_inv_except e p) : m':hmem_with_inv_except e p{m'.ctr = m.ctr + 1 /\ H.stronger (linv e m) (linv e m')} = let m' : mem = { m with ctr = m.ctr + 1} in assert (interp (p `star` linv e m) m'); assert (linv e m == lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m)); assert (linv e m' == lock_store_invariant e m.locks `star` ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken_free_above (heap_of_mem m) m.ctr (m.ctr + 1); weaken_pure (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_ctr_valid (m.ctr + 1) (heap_of_mem m)); assert (H.stronger (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m))); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)); H.stronger_star (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken (p `star` lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)) (heap_of_mem m'); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity (m.ctr + 1) (heap_of_mem m)); let m' : hmem_with_inv_except e p = m' in m' let frame_related_mems (fp0 fp1:slprop u#a) e (m0:hmem_with_inv_except e fp0) (m1:hmem_with_inv_except e fp1) = forall (frame:slprop u#a). interp ((fp0 `star` frame) `star` linv e m0) m0 ==> interp ((fp1 `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) let refined_pre_action e (fp0:slprop) (a:Type) (fp1:a -> slprop) = m0:hmem_with_inv_except e fp0 -> Pure (x:a & hmem_with_inv_except e (fp1 x)) (requires True) (ensures fun (| x, m1 |) -> frame_related_mems fp0 (fp1 x) e m0 m1) let refined_pre_action_as_action (#fp0:slprop) (#a:Type) (#fp1:a -> slprop) #e ($f:refined_pre_action e fp0 a fp1) : tot_action_nf_except e fp0 a fp1 = let g : tot_pre_action_nf_except e fp0 a fp1 = fun m -> f m in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp0 `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp1 x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x', m1' |) = g m0 in let (| x, m1 |) = f m0 in assert (x == x' /\ m1 == m1') in g let alloc_action #a #pcm e x = let f : refined_pre_action e emp (ref a pcm) (fun r -> pts_to r x) = fun m0 -> (* NS: 9/29/22 I needed to annotate h : Heap.full_heap, for use with the Core checker which generates a guard for checking the implicit pattern "dot" term in the dependent pair pattern on the next line. That guard expects `h` to be a full_heap, which is it, because it is a projection of m0. However, this is not reflected in `h`'s type. So, the Core checker, which produces a guard for the pat_dot_term in isolation, cannot recheck the term. If we were to fold in the checking of pat_dot_terms and their guards with the rest of the VC, this would work. *) let h : Heap.full_heap = hheap_of_hmem m0 in let (|r, h'|) = H.extend #a #pcm x m0.ctr h in let m' : hmem_with_inv_except e emp = inc_ctr m0 in let h' : H.hheap (pts_to #a #pcm r x `star` linv e m') = weaken _ (linv e m0) (linv e m') h' in let m1 : hmem_with_inv_except e (pts_to #a #pcm r x) = hmem_of_hheap m' h' in assert (forall frame. H.frame_related_heaps h h' emp (pts_to #a #pcm r x) frame true); let aux (frame:slprop) : Lemma (requires interp ((emp `star` frame) `star` linv e m0) m0) (ensures interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) [SMTPat (emp `star` frame)] = star_associative emp frame (linv e m0); assert (H.interp (emp `star` (frame `star` linv e m0)) h); assert (H.interp (pts_to #a #pcm r x `star` (frame `star` linv e m0)) h'); star_associative (pts_to #a #pcm r x) frame (linv e m0); assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m0) h'); assert (H.stronger (linv e m0) (linv e m')); assert (H.equiv (linv e m') (linv e m1)); assert (H.stronger (linv e m0) (linv e m1)); let h' : H.hheap ((pts_to #a #pcm r x `star` frame) `star` linv e m1) = weaken _ (linv e m0) (linv e m1) h' in assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) h'); assert (forall (mp:H.hprop frame). mp h == mp h'); mprop_preservation_of_hprop_preservation frame m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) in assert (frame_related_mems emp (pts_to r x) e m0 m1); (| r, m1 |) in lift_tot_action (refined_pre_action_as_action f) let select_refine #a #p e r x f = lift_tot_action (lift_heap_action e (H.select_refine #a #p r x f)) let upd_gen #a #p e r x y f = lift_tot_action (lift_heap_action e (H.upd_gen_action r x y f)) //////////////////////////////////////////////////////////////////////////////// // witness / recall //////////////////////////////////////////////////////////////////////////////// let witnessed_ref #a #pcm (r:ref a pcm) (fact:property a) (m:full_mem) = H.witnessed_ref #a #pcm r fact (heap_of_mem m) let witnessed_ref_stability #a #pcm (r:ref a pcm) (fact:property a) : Lemma (requires FStar.Preorder.stable fact (Steel.Preorder.preorder_of_pcm pcm)) (ensures FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) = H.witnessed_ref_stability #a #pcm r fact

{ "checked_file": "/", "dependencies": [ "Steel.Preorder.fst.checked", "Steel.Heap.fsti.checked", "prims.fst.checked", "FStar.Witnessed.Core.fsti.checked", "FStar.Set.fsti.checked", "FStar.Preorder.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.PCM.fst.checked", "FStar.NMSTTotal.fst.checked", "FStar.List.Tot.fst.checked", "FStar.IndefiniteDescription.fsti.checked", "FStar.Ghost.fsti.checked", "FStar.FunctionalExtensionality.fsti.checked", "FStar.Classical.Sugar.fsti.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Steel.Memory.fst" }

[ { "abbrev": true, "full_module": "Steel.Preorder", "short_module": "PP" }, { "abbrev": true, "full_module": "FStar.Witnessed.Core", "short_module": "W" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": true, "full_module": "Steel.Heap", "short_module": "H" }, { "abbrev": false, "full_module": "FStar.FunctionalExtensionality", "short_module": null }, { "abbrev": true, "full_module": "FStar.FunctionalExtensionality", "short_module": "F" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": false, "full_module": "FStar.PCM", "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.Memory.ref a pcm -> fact: Steel.Memory.property a -> Type0

Prims.Tot

[ "total" ]

[]

[ "FStar.PCM.pcm", "Steel.Memory.ref", "Steel.Memory.property", "FStar.Witnessed.Core.witnessed", "Steel.Memory.full_mem", "Steel.Memory.mem_evolves", "Steel.Memory.witnessed_ref" ]

[]

false

true

let witnessed (#a: Type u#1) (#pcm: pcm a) (r: ref a pcm) (fact: property a) =

W.witnessed _ mem_evolves (witnessed_ref r fact)

false

Steel.Memory.fst

Steel.Memory.weaken_pure

val weaken_pure (q r: prop) : Lemma (requires (q ==> r)) (ensures H.stronger (H.pure q) (H.pure r))

let weaken_pure (q r: prop) : Lemma (requires (q ==> r)) (ensures H.stronger (H.pure q) (H.pure r)) = let aux (h:H.heap) : Lemma (ensures (H.interp (H.pure q) h ==> H.interp (H.pure r) h)) [SMTPat ()] = H.pure_interp q h; H.pure_interp r h in ()

{ "file_name": "lib/steel/Steel.Memory.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 6, "end_line": 872, "start_col": 0, "start_line": 862 }

(* 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.Memory module F = FStar.FunctionalExtensionality open FStar.FunctionalExtensionality open FStar.PCM module H = Steel.Heap noeq type lock_state : Type u#(a + 1) = | Invariant : inv:H.slprop u#a -> lock_state let lock_store : Type u#(a+1) = list (lock_state u#a) noeq type mem : Type u#(a + 1) = { ctr: nat; heap: H.heap u#a; locks: lock_store u#a; } let heap_of_mem (x:mem) : H.heap = x.heap let mem_of_heap (h:H.heap) : mem = { ctr = 0; heap = h; locks = [] } let mem_set_heap (m:mem) (h:H.heap) : mem = { ctr = m.ctr; heap = h; locks = m.locks; } let core_mem (m:mem) : mem = mem_of_heap (heap_of_mem m) let core_mem_invol m = () let disjoint (m0 m1:mem u#h) : prop = m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks let disjoint_sym m0 m1 = () let join m0 m1 = { ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = m0.locks } let join_commutative m0 m1 = H.join_commutative m0.heap m1.heap let disjoint_join m0 m1 m2 = H.disjoint_join m0.heap m1.heap m2.heap let join_associative m0 m1 m2 = H.join_associative m0.heap m1.heap m2.heap let slprop = H.slprop let interp p m = H.interp p m.heap let equiv p1 p2 = forall m. interp p1 m <==> interp p2 m let slprop_extensionality p q = assert (forall m. interp p m <==> interp q m); let aux (h:H.heap) : Lemma (H.interp p h <==> H.interp q h) [SMTPat (H.interp p h)] = let m : mem = { ctr = 0; heap = h; locks = [] } in assert (interp p m <==> interp q m) in assert (forall h. H.interp p h <==> H.interp q h); Steel.Heap.slprop_extensionality p q let reveal_equiv p1 p2 = () let core_ref = H.core_ref let core_ref_null = H.core_ref_null let core_ref_is_null r = H.core_ref_is_null r let emp : slprop u#a = H.emp let pure = H.pure let pts_to = H.pts_to let h_and = H.h_and let h_or = H.h_or let star = H.star let wand = H.wand let h_exists = H.h_exists let h_forall = H.h_forall //////////////////////////////////////////////////////////////////////////////// //properties of equiv //////////////////////////////////////////////////////////////////////////////// let equiv_symmetric (p1 p2:slprop u#a) = H.equiv_symmetric p1 p2 #push-options "--warn_error -271" let equiv_heap_iff_equiv (p1 p2:slprop u#a) : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat (equiv p1 p2)] = let aux_lr () : Lemma (requires H.equiv p1 p2) (ensures equiv p1 p2) [SMTPat ()] = () in let aux_rl_helper1 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p1 h) (ensures H.interp p2 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl_helper2 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p2 h) (ensures H.interp p1 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl () : Lemma (requires equiv p1 p2) (ensures H.equiv p1 p2) [SMTPat ()] = () in () let equiv_heap_iff_equiv_forall () : Lemma (ensures (forall p1 p2. H.equiv p1 p2 <==> equiv p1 p2)) = let aux p1 p2 : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat ()] = equiv_heap_iff_equiv p1 p2 in () #pop-options let equiv_extensional_on_star (p1 p2 p3:slprop u#a) = equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3 let emp_unit p = H.emp_unit p let intro_emp m = H.intro_emp (heap_of_mem m) let pure_equiv p q = H.pure_equiv p q let pure_interp q m = H.pure_interp q (heap_of_mem m) let pure_star_interp p q m = H.pure_star_interp p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// //pts_to //////////////////////////////////////////////////////////////////////////////// let pts_to_compatible #a #pcm x v0 v1 m = H.pts_to_compatible #a #pcm x v0 v1 (heap_of_mem m) let pts_to_compatible_equiv #a #pcm x v0 v1 = H.pts_to_compatible_equiv #a #pcm x v0 v1 let pts_to_not_null #a #pcm x v m = H.pts_to_not_null #a #pcm x v (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // star //////////////////////////////////////////////////////////////////////////////// let intro_star p q mp mq = H.intro_star p q (heap_of_mem mp) (heap_of_mem mq) let elim_star p q m = let h = heap_of_mem m in H.elim_star p q h; assert (exists hl hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr); let hl = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hl -> exists hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let hr = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hr -> H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let ml = mem_set_heap m hl in let mr = mem_set_heap m hr in assert (disjoint ml mr); assert (m == join ml mr); assert (interp p ml); assert (interp q mr); () let interp_star (p q: slprop) (m: mem) : Lemma (interp (p `star` q) m <==> (exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m)) = let left = interp (p `star` q) m in let right = exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m in let f () : Lemma (requires left) (ensures right) = elim_star p q m in let g () : Lemma (requires right) (ensures left) = Classical.exists_elim left #_ #(fun mp -> exists (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mp -> Classical.exists_elim left #_ #(fun mq -> disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mq -> intro_star p q mp mq ) ) in Classical.move_requires f (); Classical.move_requires g () let star_commutative (p1 p2:slprop) = H.star_commutative p1 p2 let star_associative (p1 p2 p3:slprop) = H.star_associative p1 p2 p3 let star_congruence (p1 p2 p3 p4:slprop) = equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4 let affine_star (p q:slprop) (m:mem) = H.affine_star p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // Invariants on the lock store //////////////////////////////////////////////////////////////////////////////// let iname = nat module S = FStar.Set module L = FStar.List.Tot module W = FStar.Witnessed.Core let rec lock_store_invariant (e:inames) (l:lock_store u#a) : slprop u#a = let current_addr = L.length l - 1 in match l with | [] -> emp | Invariant p :: tl -> if current_addr `S.mem` e then lock_store_invariant e tl else p `star` lock_store_invariant e tl let lock_i (i:iname) (l:lock_store { i < L.length l }) = let ix = L.length l - i - 1 in L.index l ix let iname_for_p (i:iname) (p:slprop) : W.s_predicate lock_store = fun l -> i < L.length l /\ (lock_i i l).inv == p let lock_store_evolves : FStar.Preorder.preorder lock_store = fun (l1 l2 : lock_store) -> L.length l2 >= L.length l1 /\ (forall (i:nat{i < L.length l1}). (lock_i i l1).inv == (lock_i i l2).inv) let inames_in (e:inames) (l:lock_store) : prop = forall i. Set.mem i e ==> i < L.length l let inames_ok e m = inames_in e m.locks let inames_ok_empty m = () let extend_lock_store (e:inames) (l:lock_store{e `inames_in` l}) (p:slprop) : i:iname & l':lock_store { lock_store_invariant e l' == p `star` lock_store_invariant e l /\ iname_for_p i p l' } = (| L.length l, Invariant p :: l |) let set_add (i:iname) (s:inames) = Set.union (Set.singleton i) s let rec move_invariant (e:inames) (l:lock_store) (p:slprop) (i:iname{iname_for_p i p l /\ ~(i `Set.mem` e)}) : Lemma (H.equiv (lock_store_invariant e l) (p `star` lock_store_invariant (set_add i e) l)) = let rec aux (i:iname) (m:lock_store) : Lemma (requires i >= L.length m) (ensures (lock_store_invariant e m `H.equiv` lock_store_invariant (set_add i e) m)) = match m with | [] -> () | Invariant p::tl -> aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl) in let current_addr = L.length l - 1 in match l with | [] -> () | Invariant q::tl -> if i = current_addr then begin assert (lock_store_invariant e l == p `star` lock_store_invariant e tl); aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl); () end else begin move_invariant e tl p i; assert (lock_store_invariant e tl `equiv` (p `star` lock_store_invariant (set_add i e) tl)); H.star_congruence q (lock_store_invariant e tl) q (p `star` lock_store_invariant (set_add i e) tl); if Set.mem current_addr e then () else begin let r = lock_store_invariant (set_add i e) tl in assert (lock_store_invariant e l `equiv` (q `star` (p `star` r))); H.star_associative q p r; H.star_commutative q p; H.star_congruence (q `star` p) r (p `star` q) r; H.star_associative p q r end end let heap_ctr_valid (ctr:nat) (h:H.heap u#a) : prop = h `H.free_above_addr` ctr let ctr_validity (ctr:nat) (h:H.heap) : slprop = H.pure (heap_ctr_valid ctr h) let locks_invariant (e:inames) (m:mem u#a) : slprop u#a = lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m) let full_mem_pred (m:mem) = H.full_heap_pred (heap_of_mem m) (***** Following lemmas are needed in Steel.Effect *****) let core_mem_interp (hp:slprop u#a) (m:mem u#a) = () let interp_depends_only_on (hp:slprop u#a) = H.interp_depends_only_on hp let a_mem_prop_as_a_heap_prop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (H.a_heap_prop u#a) = let g (h: H.heap u#a) : Tot prop = interp sl (mem_of_heap h) /\ f (mem_of_heap h) in let phi0 (h0 h1: H.heap u#a) : Lemma (requires (g h0 /\ H.disjoint h0 h1)) (ensures (g h0 /\ H.disjoint h0 h1 /\ g (H.join h0 h1))) = assert (mem_of_heap (H.join h0 h1) == mem_of_heap h0 `join` mem_of_heap h1); interp_depends_only_on sl in let phi1 (h0 h1: H.heap u#a) : Lemma (ensures ((g h0 /\ H.disjoint h0 h1) ==> g (H.join h0 h1))) = Classical.move_requires (phi0 h0) h1 in Classical.forall_intro_2 phi1; g let refine_slprop sl f = H.as_slprop (a_mem_prop_as_a_heap_prop sl f) let interp_refine_slprop sl f m = assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_mem m)) let dep_hprop (s: slprop) (f: (hmem s -> Tot slprop)) (h: H.heap) : Tot prop = exists (h1: H.heap) . exists (h2: H.heap) . interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 let dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq' : squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h')) = let p2 (h h1 h2: H.heap) : Tot prop = interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 in let p1 (h h1: H.heap) : Tot prop = (exists h2 . p2 h h1 h2) in let h1 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p1 h) in let h2 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p2 h h1) in H.disjoint_join h' h1 h2; assert (H.disjoint h2 h'); let h2' = H.join h2 h' in H.join_commutative h2 h' ; assert (h2' == H.join h' h2); assert (H.disjoint h1 h2'); assert (mem_of_heap h2' == mem_of_heap h2 `join` mem_of_heap h'); interp_depends_only_on (f (mem_of_heap h1)); assert (interp (f (mem_of_heap h1)) (mem_of_heap h2')); H.join_commutative h1 h2; H.join_associative h' h2 h1; H.join_commutative h' h; H.join_commutative h2' h1; assert (H.join h h' == h1 `H.join` h2') let impl_intro_gen (#p: Type0) (#q: Type0) ($prf: (squash p -> Lemma (q ))) : Lemma (p ==> q) = Classical.impl_intro_gen #p #(fun _ -> q) prf let dep_hprop_is_affine1 (s: slprop) (f: (hmem s -> Tot slprop)) (h0 h1: H.heap) : Lemma ((dep_hprop s f h0 /\ H.disjoint h0 h1) ==> (H.disjoint h0 h1 /\ dep_hprop s f (H.join h0 h1))) = impl_intro_gen (dep_hprop_is_affine0 s f h0 h1) let dep_hprop_is_affine (s: slprop) (f: (hmem s -> Tot slprop)) : Lemma (H.heap_prop_is_affine (dep_hprop s f)) = Classical.forall_intro_2 (dep_hprop_is_affine1 s f) let sdep (s: slprop) (f: (hmem s -> Tot slprop)) : Tot slprop = dep_hprop_is_affine s f; H.as_slprop (dep_hprop s f) let interp_sdep (s: slprop) (f: (hmem s -> Tot slprop)) (m: mem) : Lemma (requires (dep_slprop_is_affine s f)) (ensures ( interp (sdep s f) m <==> (exists m1 m2 . interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) )) = dep_hprop_is_affine s f; assert (forall m1 m2 . (interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) ==> ( interp s (mem_of_heap m1.heap) /\ interp (f (mem_of_heap m1.heap)) (mem_of_heap m2.heap) /\ H.disjoint m1.heap m2.heap /\ H.join m1.heap m2.heap == m.heap )); interp_depends_only_on s; Classical.forall_intro (fun m -> interp_depends_only_on (f m)); assert (forall h1 h2 . (interp s (mem_of_heap h1) /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ H.disjoint h1 h2 /\ H.join h1 h2 == m.heap) ==> ( core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ interp s (core_mem (mem_of_heap h1)) /\ interp s (mem_set_heap m h1) /\ core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ f (mem_set_heap m h1) `equiv` f (mem_of_heap h1) /\ interp (f (mem_set_heap m h1)) (mem_of_heap h2) /\ interp (f (mem_set_heap m h1)) (mem_set_heap m h2) /\ disjoint (mem_set_heap m h1) (mem_set_heap m h2) /\ join (mem_set_heap m h1) (mem_set_heap m h2) == m )); () let h_exists_cong (#a:Type) (p q : a -> slprop) : Lemma (requires (forall x. p x `equiv` q x)) (ensures (h_exists p `equiv` h_exists q)) = equiv_heap_iff_equiv_forall (); H.h_exists_cong p q let intro_h_exists #a x p m = H.intro_h_exists x p (heap_of_mem m) let elim_h_exists (#a:_) (p:a -> slprop) (m:mem) = H.elim_h_exists p (heap_of_mem m) let intro_h_forall (#a:_) (p:a -> slprop) (m:mem) = H.intro_h_forall p (heap_of_mem m) let elim_h_forall (#a:_) (p:a -> slprop) (m:mem) (x:a) = H.elim_h_forall p (heap_of_mem m) x let intro_h_and (p q: slprop) (m:mem) = H.intro_h_and p q (heap_of_mem m) let elim_h_and (p q: slprop) (m:mem) = H.elim_h_and p q (heap_of_mem m) let intro_h_or_left (p q: slprop) (m:mem) = H.intro_h_or_left p q (heap_of_mem m) let intro_h_or_right (p q: slprop) (m:mem) = H.intro_h_or_right p q (heap_of_mem m) let elim_h_or (p q: slprop) (m:mem) = H.elim_h_or p q (heap_of_mem m) let intro_wand (p1 p2: slprop u#a) (m:mem) = introduce (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)) ==> interp (wand p1 p2) m with _. ( assert (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)); H.intro_wand p1 p2 (heap_of_mem m); let h = heap_of_mem m in assert ((forall h1. h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) ==> H.interp (wand p1 p2) h); introduce forall h1. (h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) with ( introduce (h `H.disjoint` h1 /\ H.interp p1 h1) ==> H.interp p2 (H.join h h1) with _. ( assert (h `H.disjoint` h1); let m1 = { ctr = m.ctr; heap = h1; locks = m.locks } in assert (m `disjoint` m1) ) ) ) (** Eliminating a wand by proving a heap that satisfies the LHS **) let elim_wand (p1 p2: slprop u#a) (m:mem) (m1:mem) = H.elim_wand p1 p2 (heap_of_mem m) (heap_of_mem m1) //////////////////////////////////////////////////////////////////////////////// // Preorders and effects //////////////////////////////////////////////////////////////////////////////// module PP = Steel.Preorder let mem_evolves = fun (m0 m1:full_mem) -> H.heap_evolves (heap_of_mem m0) (heap_of_mem m1) /\ m0.ctr <= m1.ctr /\ lock_store_evolves m0.locks m1.locks (** See [Steel.Heap.is_frame_preserving]. We add in [lock_invariants] now *) let preserves_frame (e:inames) (pre post:slprop) (m0 m1:mem) = forall (frame:slprop). interp ((pre `star` frame) `star` locks_invariant e m0) m0 ==> (interp ((post `star` frame) `star` locks_invariant e m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) (** This is a version of MstTot with frame quantified, as part of preserves_frame *) effect MstTotNF (a:Type u#a) (except:inames) (expects:slprop u#1) (provides: a -> slprop u#1) = NMSTTotal.NMSTATETOT a (full_mem u#1) mem_evolves (requires fun m0 -> inames_ok except m0 /\ interp (expects `star` locks_invariant except m0) m0) (ensures fun m0 x m1 -> inames_ok except m1 /\ interp (provides x `star` locks_invariant except m1) m1 /\ preserves_frame except expects (provides x) m0 m1) //////////////////////////////////////////////////////////////////////////////// // Lifting heap actions //////////////////////////////////////////////////////////////////////////////// (** Heap actions come in two equivalent flavors: - one that take an explicit frame as argument (action_with_frame) - and one that quantify over all the frame We therefore define two lift routes: - a direct route for those with explicit frame - via MstTotNF for the rest *) let tot_pre_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = hmem_with_inv_except e fp -> (x:a & hmem_with_inv_except e (fp' x)) let tot_pre_action_nf = tot_pre_action_nf_except S.empty let ac_reasoning_for_m_frame_preserving (p q r:slprop u#a) (m:mem u#a) : Lemma (requires interp ((p `star` q) `star` r) m) (ensures interp (p `star` r) m) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_commutative p q; equiv_extensional_on_star (p `star` q) (q `star` p) r } (q `star` p) `star` r; (equiv) { star_associative q p r } q `star` (p `star` r); }; assert (interp (q `star` (p `star` r)) m); affine_star q (p `star` r) m let is_frame_preserving (#e:inames) (#a:Type u#b) (#fp:slprop u#a) (#fp':a -> slprop u#a) (f:tot_pre_action_nf_except e fp a fp') = forall (frame:slprop u#a) (m0:hmem_with_inv_except e (fp `star` frame)). (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = f:tot_pre_action_nf_except e fp a fp'{ is_frame_preserving f } let tot_action_nf = tot_action_nf_except S.empty let linv e (m:mem) = locks_invariant e m let hheap_of_hmem #fp #e (m:hmem_with_inv_except e fp) : h:H.hheap (fp `star` linv e m) { h `H.free_above_addr` m.ctr} = let h = heap_of_mem m in H.pure_interp (heap_ctr_valid m.ctr (heap_of_mem m)) h; h let hmem_of_hheap #e (#fp0 #fp1:slprop) (m:hmem_with_inv_except e fp0) (h:H.full_hheap (fp1 `star` linv e m) { h `Heap.free_above_addr` m.ctr }) : m1:hmem_with_inv_except e fp1{linv e m `equiv` linv e m1} = let m1 : mem = { m with heap = h } in assert (interp (fp1 `star` linv e m) m1); star_commutative fp1 (linv e m); assert (interp (linv e m `star` fp1) m1); assert (linv e m1 == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); assert (linv e m == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m)); H.pure_interp (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_of_mem m); assert (heap_ctr_valid m1.ctr (heap_of_mem m) <==> heap_ctr_valid m1.ctr (heap_of_mem m1)); H.pure_equiv (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_ctr_valid m1.ctr (heap_of_mem m1)); H.star_congruence (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m)); assert (linv e m `equiv` linv e m1); let _ = equiv_extensional_on_star (linv e m) (linv e m1) fp1 in assert ((linv e m `star` fp1) `equiv` (linv e m1 `star` fp1)); assert (interp (linv e m1 `star` fp1) m1); star_commutative (linv e m1) fp1; assert (interp (fp1 `star` linv e m1) m1); m1 let with_inv_except (m:mem) e (fp:slprop) = interp (fp `star` locks_invariant e m) m #push-options "--warn_error -271" let as_hprop (frame:slprop) (mp:mprop frame) : hp:H.hprop frame{forall m. mp (core_mem m) == hp (heap_of_mem m)} = let f = fun h -> mp (mem_of_heap h) in assert (forall m. mp (core_mem m) == f (heap_of_mem m)); let aux (m0:H.hheap frame) (m1:H.heap{H.disjoint m0 m1}) : Lemma (ensures (mem_of_heap (H.join m0 m1) == join (mem_of_heap m0) (mem_of_heap m1))) [SMTPat ()] = () in f let mprop_preservation_of_hprop_preservation (p:slprop) (m0 m1:mem) : Lemma (requires (forall (hp:H.hprop p). hp (heap_of_mem m0) == hp (heap_of_mem m1))) (ensures (forall (mp:mprop p). mp (core_mem m0) == mp (core_mem m1))) = let aux (mp:mprop p) : Lemma (mp (core_mem m0) == mp (core_mem m1)) [SMTPat()] = assert (as_hprop p mp (heap_of_mem m0) == as_hprop p mp (heap_of_mem m1)) in () let lift_heap_action (#fp:slprop) (#a:Type) (#fp':a -> slprop) (e:inames) ($f:H.action fp a fp') : tot_action_nf_except e fp a fp' = let g : tot_pre_action_nf_except e fp a fp' = fun m -> let h0 = hheap_of_hmem m in let (| x, h' |) = f h0 in (| x, hmem_of_hheap m h' |) in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in let h0 = hheap_of_hmem m0 in let (| x', h1 |) = f h0 in H.action_framing f (linv e m0) h0; assert (x == x'); star_associative fp frame (linv e m0); H.action_framing f (frame `star` linv e m0) h0; assert (H.interp ((fp' x) `star` (frame `star` linv e m0)) h1); star_associative (fp' x) frame (linv e m0); assert (H.interp ((fp' x `star` frame) `star` linv e m0) h1); let h1' : H.hheap ((fp' x `star` frame) `star` linv e m0) = h1 in assert (m1 == hmem_of_hheap m0 h1'); assert (with_inv_except m1 e (fp' x `star` frame)); assert (forall (hp:H.hprop frame). hp h0 == hp h1); mprop_preservation_of_hprop_preservation frame m0 m1; () in assert (is_frame_preserving g); g let frame_preserving_respects_preorder #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (m0:hmem_with_inv_except e fp) : Lemma (let (| x, m1 |) = f m0 in mem_evolves m0 m1) = let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1) = () in H.emp_unit fp; assert (interp (fp `star` linv e m0) m0); H.star_congruence (fp `star` emp) (linv e m0) fp (linv e m0); assert (interp ((fp `star` emp) `star` linv e m0) m0); aux emp m0 let lift_tot_action_nf #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') : MstTotNF a e fp fp' = let m0 = NMSTTotal.get () in let m0' : hmem_with_inv_except e fp = m0 in let r = f m0' in let (| x, m1 |) = r in let m1' : hmem_with_inv_except e (fp' x) = m1 in assert (is_frame_preserving f); assert (m1 == dsnd (f m0)); frame_preserving_respects_preorder f m0; NMSTTotal.put #_ #(mem_evolves) m1; x let lift_tot_action #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get #(full_mem) #_ () in ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); lift_tot_action_nf f (** Now defining the lift for heap actions with explicit frame *) let tot_action_with_frame_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = frame:slprop u#a -> m0:hmem_with_inv_except e (fp `star` frame) -> Pure (x:a & hmem_with_inv_except e (fp' x `star` frame)) (requires True) (ensures fun (| x, m1 |) -> mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_with_frame = tot_action_with_frame_except S.empty let lift_heap_action_with_frame (#fp:slprop u#a) (#a:Type u#b) (#fp':a -> slprop u#a) (e:inames) ($f:H.action_with_frame fp a fp') : tot_action_with_frame_except e fp a fp' = fun frame m0 -> let h0 = hheap_of_hmem m0 in calc (equiv) { fp `star` frame `star` locks_invariant e m0; (equiv) { star_associative fp frame (locks_invariant e m0) } fp `star` (frame `star` locks_invariant e m0); }; assert (H.interp (fp `star` frame `star` locks_invariant e m0) h0); assert (H.interp (fp `star` (frame `star` locks_invariant e m0)) h0); //key: apply the heap action with frame * locks_invariant e m0 let (| x, h1 |) = f (frame `star` locks_invariant e m0) h0 in calc (equiv) { fp' x `star` (frame `star` locks_invariant e m0); (equiv) { star_associative (fp' x) frame (locks_invariant e m0) } fp' x `star` frame `star` locks_invariant e m0; }; assert (H.interp (fp' x `star` (frame `star` locks_invariant e m0)) h1); assert (H.interp (fp' x `star` frame `star` locks_invariant e m0) h1); let m1 = hmem_of_hheap m0 h1 in assert (mem_evolves m0 m1); mprop_preservation_of_hprop_preservation (frame `star` locks_invariant e m0) m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)); (| x, m1 |) let lift_tot_action_with_frame #a #e #fp #fp' ($f:tot_action_with_frame_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in assert (inames_ok e m0); ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); let m0' : hmem_with_inv_except e fp = m0 in let r = f frame m0' in let (| x, m1 |) = r in ac_reasoning_for_m_frame_preserving (fp' x) frame (locks_invariant e m1) m1; assert (interp (fp' x `star` frame `star` locks_invariant e m1) m1); assert (interp (fp' x `star` locks_invariant e m1) m1); let m1' : hmem_with_inv_except e (fp' x) = m1 in NMSTTotal.put #_ #(mem_evolves) m1; x let sel_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.sel_action #a #pcm r v0)) let upd_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.upd_action #a #pcm r v0 v1)) let free_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.free_action #a #pcm r v0)) let split_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.split_action #a #pcm r v0 v1)) let gather_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.gather_action #a #pcm r v0 v1)) let weaken (p q r:slprop) (h:H.hheap (p `star` q) { H.stronger q r }) : H.hheap (p `star` r) = H.weaken p q r h; h

{ "checked_file": "/", "dependencies": [ "Steel.Preorder.fst.checked", "Steel.Heap.fsti.checked", "prims.fst.checked", "FStar.Witnessed.Core.fsti.checked", "FStar.Set.fsti.checked", "FStar.Preorder.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.PCM.fst.checked", "FStar.NMSTTotal.fst.checked", "FStar.List.Tot.fst.checked", "FStar.IndefiniteDescription.fsti.checked", "FStar.Ghost.fsti.checked", "FStar.FunctionalExtensionality.fsti.checked", "FStar.Classical.Sugar.fsti.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Steel.Memory.fst" }

[ { "abbrev": true, "full_module": "Steel.Preorder", "short_module": "PP" }, { "abbrev": true, "full_module": "FStar.Witnessed.Core", "short_module": "W" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": true, "full_module": "Steel.Heap", "short_module": "H" }, { "abbrev": false, "full_module": "FStar.PCM", "short_module": null }, { "abbrev": false, "full_module": "FStar.FunctionalExtensionality", "short_module": null }, { "abbrev": true, "full_module": "FStar.FunctionalExtensionality", "short_module": "F" }, { "abbrev": false, "full_module": "FStar.PCM", "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

q: Prims.prop -> r: Prims.prop -> FStar.Pervasives.Lemma (requires q ==> r) (ensures Steel.Heap.stronger (Steel.Heap.pure q) (Steel.Heap.pure r))

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Prims.prop", "Steel.Heap.heap", "Prims.unit", "Prims.l_True", "Prims.squash", "Prims.l_imp", "Steel.Heap.interp", "Steel.Heap.pure", "Prims.Cons", "FStar.Pervasives.pattern", "FStar.Pervasives.smt_pat", "Prims.Nil", "Steel.Heap.pure_interp", "Steel.Heap.stronger" ]

[]

false

true

false

let weaken_pure (q r: prop) : Lemma (requires (q ==> r)) (ensures H.stronger (H.pure q) (H.pure r)) =

let aux (h: H.heap) : Lemma (ensures (H.interp (H.pure q) h ==> H.interp (H.pure r) h)) [SMTPat ()] = H.pure_interp q h; H.pure_interp r h in ()

false

Steel.Memory.fst

Steel.Memory.witnessed_name_is_ok

val witnessed_name_is_ok : i: Steel.Memory.iname -> Type0

let witnessed_name_is_ok (i:iname) = W.witnessed full_mem mem_evolves (name_is_ok i)

{ "file_name": "lib/steel/Steel.Memory.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 84, "end_line": 1252, "start_col": 0, "start_line": 1252 }

(* 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.Memory module F = FStar.FunctionalExtensionality open FStar.FunctionalExtensionality open FStar.PCM module H = Steel.Heap noeq type lock_state : Type u#(a + 1) = | Invariant : inv:H.slprop u#a -> lock_state let lock_store : Type u#(a+1) = list (lock_state u#a) noeq type mem : Type u#(a + 1) = { ctr: nat; heap: H.heap u#a; locks: lock_store u#a; } let heap_of_mem (x:mem) : H.heap = x.heap let mem_of_heap (h:H.heap) : mem = { ctr = 0; heap = h; locks = [] } let mem_set_heap (m:mem) (h:H.heap) : mem = { ctr = m.ctr; heap = h; locks = m.locks; } let core_mem (m:mem) : mem = mem_of_heap (heap_of_mem m) let core_mem_invol m = () let disjoint (m0 m1:mem u#h) : prop = m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks let disjoint_sym m0 m1 = () let join m0 m1 = { ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = m0.locks } let join_commutative m0 m1 = H.join_commutative m0.heap m1.heap let disjoint_join m0 m1 m2 = H.disjoint_join m0.heap m1.heap m2.heap let join_associative m0 m1 m2 = H.join_associative m0.heap m1.heap m2.heap let slprop = H.slprop let interp p m = H.interp p m.heap let equiv p1 p2 = forall m. interp p1 m <==> interp p2 m let slprop_extensionality p q = assert (forall m. interp p m <==> interp q m); let aux (h:H.heap) : Lemma (H.interp p h <==> H.interp q h) [SMTPat (H.interp p h)] = let m : mem = { ctr = 0; heap = h; locks = [] } in assert (interp p m <==> interp q m) in assert (forall h. H.interp p h <==> H.interp q h); Steel.Heap.slprop_extensionality p q let reveal_equiv p1 p2 = () let core_ref = H.core_ref let core_ref_null = H.core_ref_null let core_ref_is_null r = H.core_ref_is_null r let emp : slprop u#a = H.emp let pure = H.pure let pts_to = H.pts_to let h_and = H.h_and let h_or = H.h_or let star = H.star let wand = H.wand let h_exists = H.h_exists let h_forall = H.h_forall //////////////////////////////////////////////////////////////////////////////// //properties of equiv //////////////////////////////////////////////////////////////////////////////// let equiv_symmetric (p1 p2:slprop u#a) = H.equiv_symmetric p1 p2 #push-options "--warn_error -271" let equiv_heap_iff_equiv (p1 p2:slprop u#a) : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat (equiv p1 p2)] = let aux_lr () : Lemma (requires H.equiv p1 p2) (ensures equiv p1 p2) [SMTPat ()] = () in let aux_rl_helper1 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p1 h) (ensures H.interp p2 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl_helper2 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p2 h) (ensures H.interp p1 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl () : Lemma (requires equiv p1 p2) (ensures H.equiv p1 p2) [SMTPat ()] = () in () let equiv_heap_iff_equiv_forall () : Lemma (ensures (forall p1 p2. H.equiv p1 p2 <==> equiv p1 p2)) = let aux p1 p2 : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat ()] = equiv_heap_iff_equiv p1 p2 in () #pop-options let equiv_extensional_on_star (p1 p2 p3:slprop u#a) = equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3 let emp_unit p = H.emp_unit p let intro_emp m = H.intro_emp (heap_of_mem m) let pure_equiv p q = H.pure_equiv p q let pure_interp q m = H.pure_interp q (heap_of_mem m) let pure_star_interp p q m = H.pure_star_interp p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// //pts_to //////////////////////////////////////////////////////////////////////////////// let pts_to_compatible #a #pcm x v0 v1 m = H.pts_to_compatible #a #pcm x v0 v1 (heap_of_mem m) let pts_to_compatible_equiv #a #pcm x v0 v1 = H.pts_to_compatible_equiv #a #pcm x v0 v1 let pts_to_not_null #a #pcm x v m = H.pts_to_not_null #a #pcm x v (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // star //////////////////////////////////////////////////////////////////////////////// let intro_star p q mp mq = H.intro_star p q (heap_of_mem mp) (heap_of_mem mq) let elim_star p q m = let h = heap_of_mem m in H.elim_star p q h; assert (exists hl hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr); let hl = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hl -> exists hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let hr = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hr -> H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let ml = mem_set_heap m hl in let mr = mem_set_heap m hr in assert (disjoint ml mr); assert (m == join ml mr); assert (interp p ml); assert (interp q mr); () let interp_star (p q: slprop) (m: mem) : Lemma (interp (p `star` q) m <==> (exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m)) = let left = interp (p `star` q) m in let right = exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m in let f () : Lemma (requires left) (ensures right) = elim_star p q m in let g () : Lemma (requires right) (ensures left) = Classical.exists_elim left #_ #(fun mp -> exists (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mp -> Classical.exists_elim left #_ #(fun mq -> disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mq -> intro_star p q mp mq ) ) in Classical.move_requires f (); Classical.move_requires g () let star_commutative (p1 p2:slprop) = H.star_commutative p1 p2 let star_associative (p1 p2 p3:slprop) = H.star_associative p1 p2 p3 let star_congruence (p1 p2 p3 p4:slprop) = equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4 let affine_star (p q:slprop) (m:mem) = H.affine_star p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // Invariants on the lock store //////////////////////////////////////////////////////////////////////////////// let iname = nat module S = FStar.Set module L = FStar.List.Tot module W = FStar.Witnessed.Core let rec lock_store_invariant (e:inames) (l:lock_store u#a) : slprop u#a = let current_addr = L.length l - 1 in match l with | [] -> emp | Invariant p :: tl -> if current_addr `S.mem` e then lock_store_invariant e tl else p `star` lock_store_invariant e tl let lock_i (i:iname) (l:lock_store { i < L.length l }) = let ix = L.length l - i - 1 in L.index l ix let iname_for_p (i:iname) (p:slprop) : W.s_predicate lock_store = fun l -> i < L.length l /\ (lock_i i l).inv == p let lock_store_evolves : FStar.Preorder.preorder lock_store = fun (l1 l2 : lock_store) -> L.length l2 >= L.length l1 /\ (forall (i:nat{i < L.length l1}). (lock_i i l1).inv == (lock_i i l2).inv) let inames_in (e:inames) (l:lock_store) : prop = forall i. Set.mem i e ==> i < L.length l let inames_ok e m = inames_in e m.locks let inames_ok_empty m = () let extend_lock_store (e:inames) (l:lock_store{e `inames_in` l}) (p:slprop) : i:iname & l':lock_store { lock_store_invariant e l' == p `star` lock_store_invariant e l /\ iname_for_p i p l' } = (| L.length l, Invariant p :: l |) let set_add (i:iname) (s:inames) = Set.union (Set.singleton i) s let rec move_invariant (e:inames) (l:lock_store) (p:slprop) (i:iname{iname_for_p i p l /\ ~(i `Set.mem` e)}) : Lemma (H.equiv (lock_store_invariant e l) (p `star` lock_store_invariant (set_add i e) l)) = let rec aux (i:iname) (m:lock_store) : Lemma (requires i >= L.length m) (ensures (lock_store_invariant e m `H.equiv` lock_store_invariant (set_add i e) m)) = match m with | [] -> () | Invariant p::tl -> aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl) in let current_addr = L.length l - 1 in match l with | [] -> () | Invariant q::tl -> if i = current_addr then begin assert (lock_store_invariant e l == p `star` lock_store_invariant e tl); aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl); () end else begin move_invariant e tl p i; assert (lock_store_invariant e tl `equiv` (p `star` lock_store_invariant (set_add i e) tl)); H.star_congruence q (lock_store_invariant e tl) q (p `star` lock_store_invariant (set_add i e) tl); if Set.mem current_addr e then () else begin let r = lock_store_invariant (set_add i e) tl in assert (lock_store_invariant e l `equiv` (q `star` (p `star` r))); H.star_associative q p r; H.star_commutative q p; H.star_congruence (q `star` p) r (p `star` q) r; H.star_associative p q r end end let heap_ctr_valid (ctr:nat) (h:H.heap u#a) : prop = h `H.free_above_addr` ctr let ctr_validity (ctr:nat) (h:H.heap) : slprop = H.pure (heap_ctr_valid ctr h) let locks_invariant (e:inames) (m:mem u#a) : slprop u#a = lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m) let full_mem_pred (m:mem) = H.full_heap_pred (heap_of_mem m) (***** Following lemmas are needed in Steel.Effect *****) let core_mem_interp (hp:slprop u#a) (m:mem u#a) = () let interp_depends_only_on (hp:slprop u#a) = H.interp_depends_only_on hp let a_mem_prop_as_a_heap_prop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (H.a_heap_prop u#a) = let g (h: H.heap u#a) : Tot prop = interp sl (mem_of_heap h) /\ f (mem_of_heap h) in let phi0 (h0 h1: H.heap u#a) : Lemma (requires (g h0 /\ H.disjoint h0 h1)) (ensures (g h0 /\ H.disjoint h0 h1 /\ g (H.join h0 h1))) = assert (mem_of_heap (H.join h0 h1) == mem_of_heap h0 `join` mem_of_heap h1); interp_depends_only_on sl in let phi1 (h0 h1: H.heap u#a) : Lemma (ensures ((g h0 /\ H.disjoint h0 h1) ==> g (H.join h0 h1))) = Classical.move_requires (phi0 h0) h1 in Classical.forall_intro_2 phi1; g let refine_slprop sl f = H.as_slprop (a_mem_prop_as_a_heap_prop sl f) let interp_refine_slprop sl f m = assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_mem m)) let dep_hprop (s: slprop) (f: (hmem s -> Tot slprop)) (h: H.heap) : Tot prop = exists (h1: H.heap) . exists (h2: H.heap) . interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 let dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq' : squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h')) = let p2 (h h1 h2: H.heap) : Tot prop = interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 in let p1 (h h1: H.heap) : Tot prop = (exists h2 . p2 h h1 h2) in let h1 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p1 h) in let h2 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p2 h h1) in H.disjoint_join h' h1 h2; assert (H.disjoint h2 h'); let h2' = H.join h2 h' in H.join_commutative h2 h' ; assert (h2' == H.join h' h2); assert (H.disjoint h1 h2'); assert (mem_of_heap h2' == mem_of_heap h2 `join` mem_of_heap h'); interp_depends_only_on (f (mem_of_heap h1)); assert (interp (f (mem_of_heap h1)) (mem_of_heap h2')); H.join_commutative h1 h2; H.join_associative h' h2 h1; H.join_commutative h' h; H.join_commutative h2' h1; assert (H.join h h' == h1 `H.join` h2') let impl_intro_gen (#p: Type0) (#q: Type0) ($prf: (squash p -> Lemma (q ))) : Lemma (p ==> q) = Classical.impl_intro_gen #p #(fun _ -> q) prf let dep_hprop_is_affine1 (s: slprop) (f: (hmem s -> Tot slprop)) (h0 h1: H.heap) : Lemma ((dep_hprop s f h0 /\ H.disjoint h0 h1) ==> (H.disjoint h0 h1 /\ dep_hprop s f (H.join h0 h1))) = impl_intro_gen (dep_hprop_is_affine0 s f h0 h1) let dep_hprop_is_affine (s: slprop) (f: (hmem s -> Tot slprop)) : Lemma (H.heap_prop_is_affine (dep_hprop s f)) = Classical.forall_intro_2 (dep_hprop_is_affine1 s f) let sdep (s: slprop) (f: (hmem s -> Tot slprop)) : Tot slprop = dep_hprop_is_affine s f; H.as_slprop (dep_hprop s f) let interp_sdep (s: slprop) (f: (hmem s -> Tot slprop)) (m: mem) : Lemma (requires (dep_slprop_is_affine s f)) (ensures ( interp (sdep s f) m <==> (exists m1 m2 . interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) )) = dep_hprop_is_affine s f; assert (forall m1 m2 . (interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) ==> ( interp s (mem_of_heap m1.heap) /\ interp (f (mem_of_heap m1.heap)) (mem_of_heap m2.heap) /\ H.disjoint m1.heap m2.heap /\ H.join m1.heap m2.heap == m.heap )); interp_depends_only_on s; Classical.forall_intro (fun m -> interp_depends_only_on (f m)); assert (forall h1 h2 . (interp s (mem_of_heap h1) /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ H.disjoint h1 h2 /\ H.join h1 h2 == m.heap) ==> ( core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ interp s (core_mem (mem_of_heap h1)) /\ interp s (mem_set_heap m h1) /\ core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ f (mem_set_heap m h1) `equiv` f (mem_of_heap h1) /\ interp (f (mem_set_heap m h1)) (mem_of_heap h2) /\ interp (f (mem_set_heap m h1)) (mem_set_heap m h2) /\ disjoint (mem_set_heap m h1) (mem_set_heap m h2) /\ join (mem_set_heap m h1) (mem_set_heap m h2) == m )); () let h_exists_cong (#a:Type) (p q : a -> slprop) : Lemma (requires (forall x. p x `equiv` q x)) (ensures (h_exists p `equiv` h_exists q)) = equiv_heap_iff_equiv_forall (); H.h_exists_cong p q let intro_h_exists #a x p m = H.intro_h_exists x p (heap_of_mem m) let elim_h_exists (#a:_) (p:a -> slprop) (m:mem) = H.elim_h_exists p (heap_of_mem m) let intro_h_forall (#a:_) (p:a -> slprop) (m:mem) = H.intro_h_forall p (heap_of_mem m) let elim_h_forall (#a:_) (p:a -> slprop) (m:mem) (x:a) = H.elim_h_forall p (heap_of_mem m) x let intro_h_and (p q: slprop) (m:mem) = H.intro_h_and p q (heap_of_mem m) let elim_h_and (p q: slprop) (m:mem) = H.elim_h_and p q (heap_of_mem m) let intro_h_or_left (p q: slprop) (m:mem) = H.intro_h_or_left p q (heap_of_mem m) let intro_h_or_right (p q: slprop) (m:mem) = H.intro_h_or_right p q (heap_of_mem m) let elim_h_or (p q: slprop) (m:mem) = H.elim_h_or p q (heap_of_mem m) let intro_wand (p1 p2: slprop u#a) (m:mem) = introduce (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)) ==> interp (wand p1 p2) m with _. ( assert (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)); H.intro_wand p1 p2 (heap_of_mem m); let h = heap_of_mem m in assert ((forall h1. h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) ==> H.interp (wand p1 p2) h); introduce forall h1. (h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) with ( introduce (h `H.disjoint` h1 /\ H.interp p1 h1) ==> H.interp p2 (H.join h h1) with _. ( assert (h `H.disjoint` h1); let m1 = { ctr = m.ctr; heap = h1; locks = m.locks } in assert (m `disjoint` m1) ) ) ) (** Eliminating a wand by proving a heap that satisfies the LHS **) let elim_wand (p1 p2: slprop u#a) (m:mem) (m1:mem) = H.elim_wand p1 p2 (heap_of_mem m) (heap_of_mem m1) //////////////////////////////////////////////////////////////////////////////// // Preorders and effects //////////////////////////////////////////////////////////////////////////////// module PP = Steel.Preorder let mem_evolves = fun (m0 m1:full_mem) -> H.heap_evolves (heap_of_mem m0) (heap_of_mem m1) /\ m0.ctr <= m1.ctr /\ lock_store_evolves m0.locks m1.locks (** See [Steel.Heap.is_frame_preserving]. We add in [lock_invariants] now *) let preserves_frame (e:inames) (pre post:slprop) (m0 m1:mem) = forall (frame:slprop). interp ((pre `star` frame) `star` locks_invariant e m0) m0 ==> (interp ((post `star` frame) `star` locks_invariant e m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) (** This is a version of MstTot with frame quantified, as part of preserves_frame *) effect MstTotNF (a:Type u#a) (except:inames) (expects:slprop u#1) (provides: a -> slprop u#1) = NMSTTotal.NMSTATETOT a (full_mem u#1) mem_evolves (requires fun m0 -> inames_ok except m0 /\ interp (expects `star` locks_invariant except m0) m0) (ensures fun m0 x m1 -> inames_ok except m1 /\ interp (provides x `star` locks_invariant except m1) m1 /\ preserves_frame except expects (provides x) m0 m1) //////////////////////////////////////////////////////////////////////////////// // Lifting heap actions //////////////////////////////////////////////////////////////////////////////// (** Heap actions come in two equivalent flavors: - one that take an explicit frame as argument (action_with_frame) - and one that quantify over all the frame We therefore define two lift routes: - a direct route for those with explicit frame - via MstTotNF for the rest *) let tot_pre_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = hmem_with_inv_except e fp -> (x:a & hmem_with_inv_except e (fp' x)) let tot_pre_action_nf = tot_pre_action_nf_except S.empty let ac_reasoning_for_m_frame_preserving (p q r:slprop u#a) (m:mem u#a) : Lemma (requires interp ((p `star` q) `star` r) m) (ensures interp (p `star` r) m) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_commutative p q; equiv_extensional_on_star (p `star` q) (q `star` p) r } (q `star` p) `star` r; (equiv) { star_associative q p r } q `star` (p `star` r); }; assert (interp (q `star` (p `star` r)) m); affine_star q (p `star` r) m let is_frame_preserving (#e:inames) (#a:Type u#b) (#fp:slprop u#a) (#fp':a -> slprop u#a) (f:tot_pre_action_nf_except e fp a fp') = forall (frame:slprop u#a) (m0:hmem_with_inv_except e (fp `star` frame)). (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = f:tot_pre_action_nf_except e fp a fp'{ is_frame_preserving f } let tot_action_nf = tot_action_nf_except S.empty let linv e (m:mem) = locks_invariant e m let hheap_of_hmem #fp #e (m:hmem_with_inv_except e fp) : h:H.hheap (fp `star` linv e m) { h `H.free_above_addr` m.ctr} = let h = heap_of_mem m in H.pure_interp (heap_ctr_valid m.ctr (heap_of_mem m)) h; h let hmem_of_hheap #e (#fp0 #fp1:slprop) (m:hmem_with_inv_except e fp0) (h:H.full_hheap (fp1 `star` linv e m) { h `Heap.free_above_addr` m.ctr }) : m1:hmem_with_inv_except e fp1{linv e m `equiv` linv e m1} = let m1 : mem = { m with heap = h } in assert (interp (fp1 `star` linv e m) m1); star_commutative fp1 (linv e m); assert (interp (linv e m `star` fp1) m1); assert (linv e m1 == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); assert (linv e m == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m)); H.pure_interp (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_of_mem m); assert (heap_ctr_valid m1.ctr (heap_of_mem m) <==> heap_ctr_valid m1.ctr (heap_of_mem m1)); H.pure_equiv (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_ctr_valid m1.ctr (heap_of_mem m1)); H.star_congruence (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m)); assert (linv e m `equiv` linv e m1); let _ = equiv_extensional_on_star (linv e m) (linv e m1) fp1 in assert ((linv e m `star` fp1) `equiv` (linv e m1 `star` fp1)); assert (interp (linv e m1 `star` fp1) m1); star_commutative (linv e m1) fp1; assert (interp (fp1 `star` linv e m1) m1); m1 let with_inv_except (m:mem) e (fp:slprop) = interp (fp `star` locks_invariant e m) m #push-options "--warn_error -271" let as_hprop (frame:slprop) (mp:mprop frame) : hp:H.hprop frame{forall m. mp (core_mem m) == hp (heap_of_mem m)} = let f = fun h -> mp (mem_of_heap h) in assert (forall m. mp (core_mem m) == f (heap_of_mem m)); let aux (m0:H.hheap frame) (m1:H.heap{H.disjoint m0 m1}) : Lemma (ensures (mem_of_heap (H.join m0 m1) == join (mem_of_heap m0) (mem_of_heap m1))) [SMTPat ()] = () in f let mprop_preservation_of_hprop_preservation (p:slprop) (m0 m1:mem) : Lemma (requires (forall (hp:H.hprop p). hp (heap_of_mem m0) == hp (heap_of_mem m1))) (ensures (forall (mp:mprop p). mp (core_mem m0) == mp (core_mem m1))) = let aux (mp:mprop p) : Lemma (mp (core_mem m0) == mp (core_mem m1)) [SMTPat()] = assert (as_hprop p mp (heap_of_mem m0) == as_hprop p mp (heap_of_mem m1)) in () let lift_heap_action (#fp:slprop) (#a:Type) (#fp':a -> slprop) (e:inames) ($f:H.action fp a fp') : tot_action_nf_except e fp a fp' = let g : tot_pre_action_nf_except e fp a fp' = fun m -> let h0 = hheap_of_hmem m in let (| x, h' |) = f h0 in (| x, hmem_of_hheap m h' |) in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in let h0 = hheap_of_hmem m0 in let (| x', h1 |) = f h0 in H.action_framing f (linv e m0) h0; assert (x == x'); star_associative fp frame (linv e m0); H.action_framing f (frame `star` linv e m0) h0; assert (H.interp ((fp' x) `star` (frame `star` linv e m0)) h1); star_associative (fp' x) frame (linv e m0); assert (H.interp ((fp' x `star` frame) `star` linv e m0) h1); let h1' : H.hheap ((fp' x `star` frame) `star` linv e m0) = h1 in assert (m1 == hmem_of_hheap m0 h1'); assert (with_inv_except m1 e (fp' x `star` frame)); assert (forall (hp:H.hprop frame). hp h0 == hp h1); mprop_preservation_of_hprop_preservation frame m0 m1; () in assert (is_frame_preserving g); g let frame_preserving_respects_preorder #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (m0:hmem_with_inv_except e fp) : Lemma (let (| x, m1 |) = f m0 in mem_evolves m0 m1) = let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1) = () in H.emp_unit fp; assert (interp (fp `star` linv e m0) m0); H.star_congruence (fp `star` emp) (linv e m0) fp (linv e m0); assert (interp ((fp `star` emp) `star` linv e m0) m0); aux emp m0 let lift_tot_action_nf #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') : MstTotNF a e fp fp' = let m0 = NMSTTotal.get () in let m0' : hmem_with_inv_except e fp = m0 in let r = f m0' in let (| x, m1 |) = r in let m1' : hmem_with_inv_except e (fp' x) = m1 in assert (is_frame_preserving f); assert (m1 == dsnd (f m0)); frame_preserving_respects_preorder f m0; NMSTTotal.put #_ #(mem_evolves) m1; x let lift_tot_action #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get #(full_mem) #_ () in ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); lift_tot_action_nf f (** Now defining the lift for heap actions with explicit frame *) let tot_action_with_frame_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = frame:slprop u#a -> m0:hmem_with_inv_except e (fp `star` frame) -> Pure (x:a & hmem_with_inv_except e (fp' x `star` frame)) (requires True) (ensures fun (| x, m1 |) -> mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_with_frame = tot_action_with_frame_except S.empty let lift_heap_action_with_frame (#fp:slprop u#a) (#a:Type u#b) (#fp':a -> slprop u#a) (e:inames) ($f:H.action_with_frame fp a fp') : tot_action_with_frame_except e fp a fp' = fun frame m0 -> let h0 = hheap_of_hmem m0 in calc (equiv) { fp `star` frame `star` locks_invariant e m0; (equiv) { star_associative fp frame (locks_invariant e m0) } fp `star` (frame `star` locks_invariant e m0); }; assert (H.interp (fp `star` frame `star` locks_invariant e m0) h0); assert (H.interp (fp `star` (frame `star` locks_invariant e m0)) h0); //key: apply the heap action with frame * locks_invariant e m0 let (| x, h1 |) = f (frame `star` locks_invariant e m0) h0 in calc (equiv) { fp' x `star` (frame `star` locks_invariant e m0); (equiv) { star_associative (fp' x) frame (locks_invariant e m0) } fp' x `star` frame `star` locks_invariant e m0; }; assert (H.interp (fp' x `star` (frame `star` locks_invariant e m0)) h1); assert (H.interp (fp' x `star` frame `star` locks_invariant e m0) h1); let m1 = hmem_of_hheap m0 h1 in assert (mem_evolves m0 m1); mprop_preservation_of_hprop_preservation (frame `star` locks_invariant e m0) m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)); (| x, m1 |) let lift_tot_action_with_frame #a #e #fp #fp' ($f:tot_action_with_frame_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in assert (inames_ok e m0); ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); let m0' : hmem_with_inv_except e fp = m0 in let r = f frame m0' in let (| x, m1 |) = r in ac_reasoning_for_m_frame_preserving (fp' x) frame (locks_invariant e m1) m1; assert (interp (fp' x `star` frame `star` locks_invariant e m1) m1); assert (interp (fp' x `star` locks_invariant e m1) m1); let m1' : hmem_with_inv_except e (fp' x) = m1 in NMSTTotal.put #_ #(mem_evolves) m1; x let sel_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.sel_action #a #pcm r v0)) let upd_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.upd_action #a #pcm r v0 v1)) let free_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.free_action #a #pcm r v0)) let split_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.split_action #a #pcm r v0 v1)) let gather_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.gather_action #a #pcm r v0 v1)) let weaken (p q r:slprop) (h:H.hheap (p `star` q) { H.stronger q r }) : H.hheap (p `star` r) = H.weaken p q r h; h let weaken_pure (q r: prop) : Lemma (requires (q ==> r)) (ensures H.stronger (H.pure q) (H.pure r)) = let aux (h:H.heap) : Lemma (ensures (H.interp (H.pure q) h ==> H.interp (H.pure r) h)) [SMTPat ()] = H.pure_interp q h; H.pure_interp r h in () let inc_ctr (#p:slprop) #e (m:hmem_with_inv_except e p) : m':hmem_with_inv_except e p{m'.ctr = m.ctr + 1 /\ H.stronger (linv e m) (linv e m')} = let m' : mem = { m with ctr = m.ctr + 1} in assert (interp (p `star` linv e m) m'); assert (linv e m == lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m)); assert (linv e m' == lock_store_invariant e m.locks `star` ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken_free_above (heap_of_mem m) m.ctr (m.ctr + 1); weaken_pure (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_ctr_valid (m.ctr + 1) (heap_of_mem m)); assert (H.stronger (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m))); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)); H.stronger_star (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken (p `star` lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)) (heap_of_mem m'); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity (m.ctr + 1) (heap_of_mem m)); let m' : hmem_with_inv_except e p = m' in m' let frame_related_mems (fp0 fp1:slprop u#a) e (m0:hmem_with_inv_except e fp0) (m1:hmem_with_inv_except e fp1) = forall (frame:slprop u#a). interp ((fp0 `star` frame) `star` linv e m0) m0 ==> interp ((fp1 `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) let refined_pre_action e (fp0:slprop) (a:Type) (fp1:a -> slprop) = m0:hmem_with_inv_except e fp0 -> Pure (x:a & hmem_with_inv_except e (fp1 x)) (requires True) (ensures fun (| x, m1 |) -> frame_related_mems fp0 (fp1 x) e m0 m1) let refined_pre_action_as_action (#fp0:slprop) (#a:Type) (#fp1:a -> slprop) #e ($f:refined_pre_action e fp0 a fp1) : tot_action_nf_except e fp0 a fp1 = let g : tot_pre_action_nf_except e fp0 a fp1 = fun m -> f m in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp0 `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp1 x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x', m1' |) = g m0 in let (| x, m1 |) = f m0 in assert (x == x' /\ m1 == m1') in g let alloc_action #a #pcm e x = let f : refined_pre_action e emp (ref a pcm) (fun r -> pts_to r x) = fun m0 -> (* NS: 9/29/22 I needed to annotate h : Heap.full_heap, for use with the Core checker which generates a guard for checking the implicit pattern "dot" term in the dependent pair pattern on the next line. That guard expects `h` to be a full_heap, which is it, because it is a projection of m0. However, this is not reflected in `h`'s type. So, the Core checker, which produces a guard for the pat_dot_term in isolation, cannot recheck the term. If we were to fold in the checking of pat_dot_terms and their guards with the rest of the VC, this would work. *) let h : Heap.full_heap = hheap_of_hmem m0 in let (|r, h'|) = H.extend #a #pcm x m0.ctr h in let m' : hmem_with_inv_except e emp = inc_ctr m0 in let h' : H.hheap (pts_to #a #pcm r x `star` linv e m') = weaken _ (linv e m0) (linv e m') h' in let m1 : hmem_with_inv_except e (pts_to #a #pcm r x) = hmem_of_hheap m' h' in assert (forall frame. H.frame_related_heaps h h' emp (pts_to #a #pcm r x) frame true); let aux (frame:slprop) : Lemma (requires interp ((emp `star` frame) `star` linv e m0) m0) (ensures interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) [SMTPat (emp `star` frame)] = star_associative emp frame (linv e m0); assert (H.interp (emp `star` (frame `star` linv e m0)) h); assert (H.interp (pts_to #a #pcm r x `star` (frame `star` linv e m0)) h'); star_associative (pts_to #a #pcm r x) frame (linv e m0); assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m0) h'); assert (H.stronger (linv e m0) (linv e m')); assert (H.equiv (linv e m') (linv e m1)); assert (H.stronger (linv e m0) (linv e m1)); let h' : H.hheap ((pts_to #a #pcm r x `star` frame) `star` linv e m1) = weaken _ (linv e m0) (linv e m1) h' in assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) h'); assert (forall (mp:H.hprop frame). mp h == mp h'); mprop_preservation_of_hprop_preservation frame m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) in assert (frame_related_mems emp (pts_to r x) e m0 m1); (| r, m1 |) in lift_tot_action (refined_pre_action_as_action f) let select_refine #a #p e r x f = lift_tot_action (lift_heap_action e (H.select_refine #a #p r x f)) let upd_gen #a #p e r x y f = lift_tot_action (lift_heap_action e (H.upd_gen_action r x y f)) //////////////////////////////////////////////////////////////////////////////// // witness / recall //////////////////////////////////////////////////////////////////////////////// let witnessed_ref #a #pcm (r:ref a pcm) (fact:property a) (m:full_mem) = H.witnessed_ref #a #pcm r fact (heap_of_mem m) let witnessed_ref_stability #a #pcm (r:ref a pcm) (fact:property a) : Lemma (requires FStar.Preorder.stable fact (Steel.Preorder.preorder_of_pcm pcm)) (ensures FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) = H.witnessed_ref_stability #a #pcm r fact let witnessed (#a:Type u#1) (#pcm:pcm a) (r:ref a pcm) (fact:property a) = W.witnessed _ mem_evolves (witnessed_ref r fact) let rearrange_pqr_prq (p q r:slprop) : Lemma (((p `star` q) `star` r) `equiv` ((p `star` r) `star` q)) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_associative p q r } p `star` (q `star` r); (equiv) { star_commutative q r; star_congruence p (q `star` r) p (r `star` q) } p `star` (r `star` q); (equiv) { star_associative p r q } (p `star` r) `star` q; } let preserves_frame_cong (e:inames) (p q:slprop) (r s:slprop) (m0 m1:mem) : Lemma (requires p `equiv` r /\ q `equiv` s /\ preserves_frame e p q m0 m1) (ensures preserves_frame e r s m0 m1) = let aux0 (p q r s:slprop) : Lemma (requires p `equiv` s) (ensures (((p `star` q) `star` r) `equiv` ((s `star` q) `star` r))) = star_congruence p q s q; star_congruence (p `star` q) r (s `star` q) r in let aux (frame:slprop) : Lemma (requires interp ((r `star` frame) `star` locks_invariant e m0) m0) (ensures interp ((s `star` frame) `star` locks_invariant e m1) m1 /\ interp ((p `star` frame) `star` locks_invariant e m0) m0) [SMTPat (r `star` frame)] = aux0 p frame (locks_invariant e m0) r; aux0 q frame (locks_invariant e m1) s; assert (((p `star` frame) `star` locks_invariant e m0) `equiv` ((r `star` frame) `star` locks_invariant e m0)); assert (interp ((p `star` frame) `star` locks_invariant e m0) m0); assert (interp ((q `star` frame) `star` locks_invariant e m1) m1); assert (((q `star` frame) `star` locks_invariant e m1) `equiv` ((s `star` frame) `star` locks_invariant e m1)); () in () let pure_true_equiv (p:slprop) : Lemma ((p `star` pure True) `equiv` p) = FStar.Classical.forall_intro (pure_star_interp p True); emp_unit p; assert ((p `star` pure True) `equiv` p) let preserves_frame_star_pure (e:inames) (p q:slprop) (r s:prop) (m:mem) : Lemma (requires r /\ s) (ensures preserves_frame e p q m m <==> preserves_frame e (p `star` pure r) (q `star` pure s) m m) = pure_equiv r True; star_congruence p (pure r) p (pure True); pure_equiv s True; star_congruence q (pure s) q (pure True); pure_true_equiv p; pure_true_equiv q; let fwd () : Lemma (requires preserves_frame e p q m m) (ensures preserves_frame e (p `star` pure r) (q `star` pure s) m m) [SMTPat ()] = preserves_frame_cong e p q (p `star` pure r) (q `star` pure s) m m in let bk () : Lemma (requires preserves_frame e (p `star` pure r) (q `star` pure s) m m) (ensures preserves_frame e p q m m) [SMTPat ()] = preserves_frame_cong e (p `star` pure r) (q `star` pure s) p q m m in () let witness (#a:Type) (#pcm:pcm a) (e:inames) (r:erased (ref a pcm)) (fact:stable_property pcm) (v:Ghost.erased a) (_:squash (forall z. compatible pcm v z ==> fact z)) (frame:slprop) : MstTot (witnessed r fact) e (pts_to r v) (fun _ -> pts_to r v) frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in let _ : unit = let hr : H.ref a pcm = r in let v' = H.sel_v hr v (heap_of_mem m0) in assert (interp (H.ptr hr) m0 /\ H.sel #a #pcm hr (heap_of_mem m0) == v'); assert (compatible pcm v v'); assert (fact v'); assert (witnessed_ref r fact m0); witnessed_ref_stability r fact; assert (FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) in let w = NMSTTotal.witness _ mem_evolves (witnessed_ref r fact) in w let recall (#a:Type u#1) (#pcm:pcm a) (#fact:property a) (e:inames) (r:erased (ref a pcm)) (v:Ghost.erased a) (w:witnessed r fact) (frame:slprop) = let m0 = NMSTTotal.get () in NMSTTotal.recall _ mem_evolves (witnessed_ref r fact) w; let hr : H.ref a pcm = r in assert (witnessed_ref r fact m0); let v1 = H.sel_v hr v (heap_of_mem m0) in assert (compatible pcm v v1); assert (H.sel hr (heap_of_mem m0) == v1); assert (fact v1); assert (interp ((pts_to r v `star` frame) `star` locks_invariant e m0) m0); emp_unit ((pts_to r v `star` frame) `star` locks_invariant e m0); pure_star_interp ((pts_to r v `star` frame) `star` locks_invariant e m0) (fact v1) m0; assert (interp (((pts_to r v `star` frame) `star` locks_invariant e m0) `star` pure (fact v1)) m0); rearrange_pqr_prq (pts_to r v `star` frame) (locks_invariant e m0) (pure (fact v1)); assert (interp (((pts_to r v `star` frame) `star` pure (fact v1)) `star` locks_invariant e m0) m0); rearrange_pqr_prq (pts_to r v) frame (pure (fact v1)); star_congruence ((pts_to r v `star` frame) `star` pure (fact v1)) (locks_invariant e m0) ((pts_to r v `star` pure (fact v1)) `star` frame) (locks_invariant e m0); Ghost.hide v1 let iname_for_p_mem (i:iname) (p:slprop) : W.s_predicate mem = fun m -> iname_for_p i p m.locks let iname_for_p_stable (i:iname) (p:slprop) : Lemma (W.stable full_mem mem_evolves (iname_for_p_mem i p)) = () let ( >--> ) (i:iname) (p:slprop) : Type0 = W.witnessed full_mem mem_evolves (iname_for_p_mem i p) let hmem_with_inv_equiv e (m:mem) (p:slprop) : Lemma (interp (p `star` linv e m) m <==> interp (p `star` lock_store_invariant e m.locks) m /\ heap_ctr_valid m.ctr (heap_of_mem m)) = calc (<==>) { interp (p `star` linv e m) m; (<==>) { H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) } interp ((p `star` lock_store_invariant e m.locks) `star` ctr_validity m.ctr (heap_of_mem m)) m; (<==>) { H.pure_star_interp (p `star` lock_store_invariant e m.locks) (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_of_mem m) } interp ((p `star` lock_store_invariant e m.locks) `star` emp) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); (<==>) { H.emp_unit (p `star` lock_store_invariant e m.locks) } interp (p `star` lock_store_invariant e m.locks) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); } let new_invariant_tot_action (e:inames) (p:slprop) (m0:hmem_with_inv_except e p{ e `inames_in` m0.locks }) : Pure (iname & hmem_with_inv_except e emp) (requires True) (ensures fun (i, m1) -> iname_for_p_mem i p m1 /\ frame_related_mems p emp e m0 m1 /\ mem_evolves m0 m1) = let (| i, l1 |) = extend_lock_store e m0.locks p in let m1 = { m0 with locks = l1 } in assert (lock_store_invariant e m1.locks == p `star` lock_store_invariant e m0.locks); calc (equiv) { linv e m1; (equiv) {} (lock_store_invariant e m1.locks `star` ctr_validity m1.ctr (heap_of_mem m1)); (equiv) {} ((p `star` lock_store_invariant e m0.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); (equiv) { H.star_associative p (lock_store_invariant e m0.locks) (ctr_validity m1.ctr (heap_of_mem m1)) } (p `star` (lock_store_invariant e m0.locks `star` ctr_validity m1.ctr (heap_of_mem m1))); (equiv) { } (p `star` linv e m0); }; assert (iname_for_p_mem i p m1); assert (lock_store_evolves m0.locks l1); assert (mem_evolves m0 m1); hmem_with_inv_equiv e m0 p; assert (interp (p `star` lock_store_invariant e m0.locks) m1); assert (interp (lock_store_invariant e m1.locks) m1); H.emp_unit (lock_store_invariant e m1.locks); H.star_commutative (lock_store_invariant e m1.locks) emp; assert (interp (emp `star` lock_store_invariant e m1.locks) m1); hmem_with_inv_equiv e m1 emp; let m1 : hmem_with_inv_except e emp = m1 in let aux (frame:slprop) : Lemma (requires interp ((p `star` frame) `star` linv e m0) m0) (ensures interp ((emp `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) <==> mp (core_mem m1))) [SMTPat (p `star` frame)] = assert (interp ((p `star` frame) `star` linv e m0) m1); calc (equiv) { ((p `star` frame) `star` linv e m0); (equiv) { H.star_commutative p frame; H.star_congruence (p `star` frame) (linv e m0) (frame `star` p) (linv e m0); H.star_associative frame p (linv e m0) } (frame `star` (p `star` linv e m0)); (equiv) { H.star_congruence frame (p `star` linv e m0) frame (linv e m1) } (frame `star` linv e m1); (equiv) { H.emp_unit (frame `star` linv e m1); H.star_commutative (frame `star` linv e m1) emp; H.star_associative emp frame (linv e m1) } ((emp `star` frame) `star` linv e m1); }; assert (interp ((emp `star` frame) `star` linv e m1) m1) in assert (frame_related_mems p emp e m0 m1); ( i, m1 ) let name_is_ok (i:iname) (m0:full_mem u#1) : prop = i < List.Tot.length m0.locks

{ "checked_file": "/", "dependencies": [ "Steel.Preorder.fst.checked", "Steel.Heap.fsti.checked", "prims.fst.checked", "FStar.Witnessed.Core.fsti.checked", "FStar.Set.fsti.checked", "FStar.Preorder.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.PCM.fst.checked", "FStar.NMSTTotal.fst.checked", "FStar.List.Tot.fst.checked", "FStar.IndefiniteDescription.fsti.checked", "FStar.Ghost.fsti.checked", "FStar.FunctionalExtensionality.fsti.checked", "FStar.Classical.Sugar.fsti.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Steel.Memory.fst" }

[ { "abbrev": true, "full_module": "Steel.Preorder", "short_module": "PP" }, { "abbrev": true, "full_module": "FStar.Witnessed.Core", "short_module": "W" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": true, "full_module": "Steel.Heap", "short_module": "H" }, { "abbrev": false, "full_module": "FStar.PCM", "short_module": null }, { "abbrev": false, "full_module": "FStar.FunctionalExtensionality", "short_module": null }, { "abbrev": true, "full_module": "FStar.FunctionalExtensionality", "short_module": "F" }, { "abbrev": false, "full_module": "FStar.PCM", "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

i: Steel.Memory.iname -> Type0

Prims.Tot

[ "total" ]

[]

[ "Steel.Memory.iname", "FStar.Witnessed.Core.witnessed", "Steel.Memory.full_mem", "Steel.Memory.mem_evolves", "Steel.Memory.name_is_ok" ]

[]

false

true

let witnessed_name_is_ok (i: iname) =

W.witnessed full_mem mem_evolves (name_is_ok i)

false

Steel.Memory.fst

Steel.Memory.mprop_preservation_of_hprop_preservation

val mprop_preservation_of_hprop_preservation (p: slprop) (m0 m1: mem) : Lemma (requires (forall (hp: H.hprop p). hp (heap_of_mem m0) == hp (heap_of_mem m1))) (ensures (forall (mp: mprop p). mp (core_mem m0) == mp (core_mem m1)))

let mprop_preservation_of_hprop_preservation (p:slprop) (m0 m1:mem) : Lemma (requires (forall (hp:H.hprop p). hp (heap_of_mem m0) == hp (heap_of_mem m1))) (ensures (forall (mp:mprop p). mp (core_mem m0) == mp (core_mem m1))) = let aux (mp:mprop p) : Lemma (mp (core_mem m0) == mp (core_mem m1)) [SMTPat()] = assert (as_hprop p mp (heap_of_mem m0) == as_hprop p mp (heap_of_mem m1)) in ()

{ "file_name": "lib/steel/Steel.Memory.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 8, "end_line": 688, "start_col": 0, "start_line": 678 }

(* 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.Memory module F = FStar.FunctionalExtensionality open FStar.FunctionalExtensionality open FStar.PCM module H = Steel.Heap noeq type lock_state : Type u#(a + 1) = | Invariant : inv:H.slprop u#a -> lock_state let lock_store : Type u#(a+1) = list (lock_state u#a) noeq type mem : Type u#(a + 1) = { ctr: nat; heap: H.heap u#a; locks: lock_store u#a; } let heap_of_mem (x:mem) : H.heap = x.heap let mem_of_heap (h:H.heap) : mem = { ctr = 0; heap = h; locks = [] } let mem_set_heap (m:mem) (h:H.heap) : mem = { ctr = m.ctr; heap = h; locks = m.locks; } let core_mem (m:mem) : mem = mem_of_heap (heap_of_mem m) let core_mem_invol m = () let disjoint (m0 m1:mem u#h) : prop = m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks let disjoint_sym m0 m1 = () let join m0 m1 = { ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = m0.locks } let join_commutative m0 m1 = H.join_commutative m0.heap m1.heap let disjoint_join m0 m1 m2 = H.disjoint_join m0.heap m1.heap m2.heap let join_associative m0 m1 m2 = H.join_associative m0.heap m1.heap m2.heap let slprop = H.slprop let interp p m = H.interp p m.heap let equiv p1 p2 = forall m. interp p1 m <==> interp p2 m let slprop_extensionality p q = assert (forall m. interp p m <==> interp q m); let aux (h:H.heap) : Lemma (H.interp p h <==> H.interp q h) [SMTPat (H.interp p h)] = let m : mem = { ctr = 0; heap = h; locks = [] } in assert (interp p m <==> interp q m) in assert (forall h. H.interp p h <==> H.interp q h); Steel.Heap.slprop_extensionality p q let reveal_equiv p1 p2 = () let core_ref = H.core_ref let core_ref_null = H.core_ref_null let core_ref_is_null r = H.core_ref_is_null r let emp : slprop u#a = H.emp let pure = H.pure let pts_to = H.pts_to let h_and = H.h_and let h_or = H.h_or let star = H.star let wand = H.wand let h_exists = H.h_exists let h_forall = H.h_forall //////////////////////////////////////////////////////////////////////////////// //properties of equiv //////////////////////////////////////////////////////////////////////////////// let equiv_symmetric (p1 p2:slprop u#a) = H.equiv_symmetric p1 p2 #push-options "--warn_error -271" let equiv_heap_iff_equiv (p1 p2:slprop u#a) : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat (equiv p1 p2)] = let aux_lr () : Lemma (requires H.equiv p1 p2) (ensures equiv p1 p2) [SMTPat ()] = () in let aux_rl_helper1 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p1 h) (ensures H.interp p2 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl_helper2 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p2 h) (ensures H.interp p1 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl () : Lemma (requires equiv p1 p2) (ensures H.equiv p1 p2) [SMTPat ()] = () in () let equiv_heap_iff_equiv_forall () : Lemma (ensures (forall p1 p2. H.equiv p1 p2 <==> equiv p1 p2)) = let aux p1 p2 : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat ()] = equiv_heap_iff_equiv p1 p2 in () #pop-options let equiv_extensional_on_star (p1 p2 p3:slprop u#a) = equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3 let emp_unit p = H.emp_unit p let intro_emp m = H.intro_emp (heap_of_mem m) let pure_equiv p q = H.pure_equiv p q let pure_interp q m = H.pure_interp q (heap_of_mem m) let pure_star_interp p q m = H.pure_star_interp p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// //pts_to //////////////////////////////////////////////////////////////////////////////// let pts_to_compatible #a #pcm x v0 v1 m = H.pts_to_compatible #a #pcm x v0 v1 (heap_of_mem m) let pts_to_compatible_equiv #a #pcm x v0 v1 = H.pts_to_compatible_equiv #a #pcm x v0 v1 let pts_to_not_null #a #pcm x v m = H.pts_to_not_null #a #pcm x v (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // star //////////////////////////////////////////////////////////////////////////////// let intro_star p q mp mq = H.intro_star p q (heap_of_mem mp) (heap_of_mem mq) let elim_star p q m = let h = heap_of_mem m in H.elim_star p q h; assert (exists hl hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr); let hl = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hl -> exists hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let hr = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hr -> H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let ml = mem_set_heap m hl in let mr = mem_set_heap m hr in assert (disjoint ml mr); assert (m == join ml mr); assert (interp p ml); assert (interp q mr); () let interp_star (p q: slprop) (m: mem) : Lemma (interp (p `star` q) m <==> (exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m)) = let left = interp (p `star` q) m in let right = exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m in let f () : Lemma (requires left) (ensures right) = elim_star p q m in let g () : Lemma (requires right) (ensures left) = Classical.exists_elim left #_ #(fun mp -> exists (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mp -> Classical.exists_elim left #_ #(fun mq -> disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mq -> intro_star p q mp mq ) ) in Classical.move_requires f (); Classical.move_requires g () let star_commutative (p1 p2:slprop) = H.star_commutative p1 p2 let star_associative (p1 p2 p3:slprop) = H.star_associative p1 p2 p3 let star_congruence (p1 p2 p3 p4:slprop) = equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4 let affine_star (p q:slprop) (m:mem) = H.affine_star p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // Invariants on the lock store //////////////////////////////////////////////////////////////////////////////// let iname = nat module S = FStar.Set module L = FStar.List.Tot module W = FStar.Witnessed.Core let rec lock_store_invariant (e:inames) (l:lock_store u#a) : slprop u#a = let current_addr = L.length l - 1 in match l with | [] -> emp | Invariant p :: tl -> if current_addr `S.mem` e then lock_store_invariant e tl else p `star` lock_store_invariant e tl let lock_i (i:iname) (l:lock_store { i < L.length l }) = let ix = L.length l - i - 1 in L.index l ix let iname_for_p (i:iname) (p:slprop) : W.s_predicate lock_store = fun l -> i < L.length l /\ (lock_i i l).inv == p let lock_store_evolves : FStar.Preorder.preorder lock_store = fun (l1 l2 : lock_store) -> L.length l2 >= L.length l1 /\ (forall (i:nat{i < L.length l1}). (lock_i i l1).inv == (lock_i i l2).inv) let inames_in (e:inames) (l:lock_store) : prop = forall i. Set.mem i e ==> i < L.length l let inames_ok e m = inames_in e m.locks let inames_ok_empty m = () let extend_lock_store (e:inames) (l:lock_store{e `inames_in` l}) (p:slprop) : i:iname & l':lock_store { lock_store_invariant e l' == p `star` lock_store_invariant e l /\ iname_for_p i p l' } = (| L.length l, Invariant p :: l |) let set_add (i:iname) (s:inames) = Set.union (Set.singleton i) s let rec move_invariant (e:inames) (l:lock_store) (p:slprop) (i:iname{iname_for_p i p l /\ ~(i `Set.mem` e)}) : Lemma (H.equiv (lock_store_invariant e l) (p `star` lock_store_invariant (set_add i e) l)) = let rec aux (i:iname) (m:lock_store) : Lemma (requires i >= L.length m) (ensures (lock_store_invariant e m `H.equiv` lock_store_invariant (set_add i e) m)) = match m with | [] -> () | Invariant p::tl -> aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl) in let current_addr = L.length l - 1 in match l with | [] -> () | Invariant q::tl -> if i = current_addr then begin assert (lock_store_invariant e l == p `star` lock_store_invariant e tl); aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl); () end else begin move_invariant e tl p i; assert (lock_store_invariant e tl `equiv` (p `star` lock_store_invariant (set_add i e) tl)); H.star_congruence q (lock_store_invariant e tl) q (p `star` lock_store_invariant (set_add i e) tl); if Set.mem current_addr e then () else begin let r = lock_store_invariant (set_add i e) tl in assert (lock_store_invariant e l `equiv` (q `star` (p `star` r))); H.star_associative q p r; H.star_commutative q p; H.star_congruence (q `star` p) r (p `star` q) r; H.star_associative p q r end end let heap_ctr_valid (ctr:nat) (h:H.heap u#a) : prop = h `H.free_above_addr` ctr let ctr_validity (ctr:nat) (h:H.heap) : slprop = H.pure (heap_ctr_valid ctr h) let locks_invariant (e:inames) (m:mem u#a) : slprop u#a = lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m) let full_mem_pred (m:mem) = H.full_heap_pred (heap_of_mem m) (***** Following lemmas are needed in Steel.Effect *****) let core_mem_interp (hp:slprop u#a) (m:mem u#a) = () let interp_depends_only_on (hp:slprop u#a) = H.interp_depends_only_on hp let a_mem_prop_as_a_heap_prop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (H.a_heap_prop u#a) = let g (h: H.heap u#a) : Tot prop = interp sl (mem_of_heap h) /\ f (mem_of_heap h) in let phi0 (h0 h1: H.heap u#a) : Lemma (requires (g h0 /\ H.disjoint h0 h1)) (ensures (g h0 /\ H.disjoint h0 h1 /\ g (H.join h0 h1))) = assert (mem_of_heap (H.join h0 h1) == mem_of_heap h0 `join` mem_of_heap h1); interp_depends_only_on sl in let phi1 (h0 h1: H.heap u#a) : Lemma (ensures ((g h0 /\ H.disjoint h0 h1) ==> g (H.join h0 h1))) = Classical.move_requires (phi0 h0) h1 in Classical.forall_intro_2 phi1; g let refine_slprop sl f = H.as_slprop (a_mem_prop_as_a_heap_prop sl f) let interp_refine_slprop sl f m = assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_mem m)) let dep_hprop (s: slprop) (f: (hmem s -> Tot slprop)) (h: H.heap) : Tot prop = exists (h1: H.heap) . exists (h2: H.heap) . interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 let dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq' : squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h')) = let p2 (h h1 h2: H.heap) : Tot prop = interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 in let p1 (h h1: H.heap) : Tot prop = (exists h2 . p2 h h1 h2) in let h1 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p1 h) in let h2 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p2 h h1) in H.disjoint_join h' h1 h2; assert (H.disjoint h2 h'); let h2' = H.join h2 h' in H.join_commutative h2 h' ; assert (h2' == H.join h' h2); assert (H.disjoint h1 h2'); assert (mem_of_heap h2' == mem_of_heap h2 `join` mem_of_heap h'); interp_depends_only_on (f (mem_of_heap h1)); assert (interp (f (mem_of_heap h1)) (mem_of_heap h2')); H.join_commutative h1 h2; H.join_associative h' h2 h1; H.join_commutative h' h; H.join_commutative h2' h1; assert (H.join h h' == h1 `H.join` h2') let impl_intro_gen (#p: Type0) (#q: Type0) ($prf: (squash p -> Lemma (q ))) : Lemma (p ==> q) = Classical.impl_intro_gen #p #(fun _ -> q) prf let dep_hprop_is_affine1 (s: slprop) (f: (hmem s -> Tot slprop)) (h0 h1: H.heap) : Lemma ((dep_hprop s f h0 /\ H.disjoint h0 h1) ==> (H.disjoint h0 h1 /\ dep_hprop s f (H.join h0 h1))) = impl_intro_gen (dep_hprop_is_affine0 s f h0 h1) let dep_hprop_is_affine (s: slprop) (f: (hmem s -> Tot slprop)) : Lemma (H.heap_prop_is_affine (dep_hprop s f)) = Classical.forall_intro_2 (dep_hprop_is_affine1 s f) let sdep (s: slprop) (f: (hmem s -> Tot slprop)) : Tot slprop = dep_hprop_is_affine s f; H.as_slprop (dep_hprop s f) let interp_sdep (s: slprop) (f: (hmem s -> Tot slprop)) (m: mem) : Lemma (requires (dep_slprop_is_affine s f)) (ensures ( interp (sdep s f) m <==> (exists m1 m2 . interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) )) = dep_hprop_is_affine s f; assert (forall m1 m2 . (interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) ==> ( interp s (mem_of_heap m1.heap) /\ interp (f (mem_of_heap m1.heap)) (mem_of_heap m2.heap) /\ H.disjoint m1.heap m2.heap /\ H.join m1.heap m2.heap == m.heap )); interp_depends_only_on s; Classical.forall_intro (fun m -> interp_depends_only_on (f m)); assert (forall h1 h2 . (interp s (mem_of_heap h1) /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ H.disjoint h1 h2 /\ H.join h1 h2 == m.heap) ==> ( core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ interp s (core_mem (mem_of_heap h1)) /\ interp s (mem_set_heap m h1) /\ core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ f (mem_set_heap m h1) `equiv` f (mem_of_heap h1) /\ interp (f (mem_set_heap m h1)) (mem_of_heap h2) /\ interp (f (mem_set_heap m h1)) (mem_set_heap m h2) /\ disjoint (mem_set_heap m h1) (mem_set_heap m h2) /\ join (mem_set_heap m h1) (mem_set_heap m h2) == m )); () let h_exists_cong (#a:Type) (p q : a -> slprop) : Lemma (requires (forall x. p x `equiv` q x)) (ensures (h_exists p `equiv` h_exists q)) = equiv_heap_iff_equiv_forall (); H.h_exists_cong p q let intro_h_exists #a x p m = H.intro_h_exists x p (heap_of_mem m) let elim_h_exists (#a:_) (p:a -> slprop) (m:mem) = H.elim_h_exists p (heap_of_mem m) let intro_h_forall (#a:_) (p:a -> slprop) (m:mem) = H.intro_h_forall p (heap_of_mem m) let elim_h_forall (#a:_) (p:a -> slprop) (m:mem) (x:a) = H.elim_h_forall p (heap_of_mem m) x let intro_h_and (p q: slprop) (m:mem) = H.intro_h_and p q (heap_of_mem m) let elim_h_and (p q: slprop) (m:mem) = H.elim_h_and p q (heap_of_mem m) let intro_h_or_left (p q: slprop) (m:mem) = H.intro_h_or_left p q (heap_of_mem m) let intro_h_or_right (p q: slprop) (m:mem) = H.intro_h_or_right p q (heap_of_mem m) let elim_h_or (p q: slprop) (m:mem) = H.elim_h_or p q (heap_of_mem m) let intro_wand (p1 p2: slprop u#a) (m:mem) = introduce (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)) ==> interp (wand p1 p2) m with _. ( assert (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)); H.intro_wand p1 p2 (heap_of_mem m); let h = heap_of_mem m in assert ((forall h1. h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) ==> H.interp (wand p1 p2) h); introduce forall h1. (h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) with ( introduce (h `H.disjoint` h1 /\ H.interp p1 h1) ==> H.interp p2 (H.join h h1) with _. ( assert (h `H.disjoint` h1); let m1 = { ctr = m.ctr; heap = h1; locks = m.locks } in assert (m `disjoint` m1) ) ) ) (** Eliminating a wand by proving a heap that satisfies the LHS **) let elim_wand (p1 p2: slprop u#a) (m:mem) (m1:mem) = H.elim_wand p1 p2 (heap_of_mem m) (heap_of_mem m1) //////////////////////////////////////////////////////////////////////////////// // Preorders and effects //////////////////////////////////////////////////////////////////////////////// module PP = Steel.Preorder let mem_evolves = fun (m0 m1:full_mem) -> H.heap_evolves (heap_of_mem m0) (heap_of_mem m1) /\ m0.ctr <= m1.ctr /\ lock_store_evolves m0.locks m1.locks (** See [Steel.Heap.is_frame_preserving]. We add in [lock_invariants] now *) let preserves_frame (e:inames) (pre post:slprop) (m0 m1:mem) = forall (frame:slprop). interp ((pre `star` frame) `star` locks_invariant e m0) m0 ==> (interp ((post `star` frame) `star` locks_invariant e m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) (** This is a version of MstTot with frame quantified, as part of preserves_frame *) effect MstTotNF (a:Type u#a) (except:inames) (expects:slprop u#1) (provides: a -> slprop u#1) = NMSTTotal.NMSTATETOT a (full_mem u#1) mem_evolves (requires fun m0 -> inames_ok except m0 /\ interp (expects `star` locks_invariant except m0) m0) (ensures fun m0 x m1 -> inames_ok except m1 /\ interp (provides x `star` locks_invariant except m1) m1 /\ preserves_frame except expects (provides x) m0 m1) //////////////////////////////////////////////////////////////////////////////// // Lifting heap actions //////////////////////////////////////////////////////////////////////////////// (** Heap actions come in two equivalent flavors: - one that take an explicit frame as argument (action_with_frame) - and one that quantify over all the frame We therefore define two lift routes: - a direct route for those with explicit frame - via MstTotNF for the rest *) let tot_pre_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = hmem_with_inv_except e fp -> (x:a & hmem_with_inv_except e (fp' x)) let tot_pre_action_nf = tot_pre_action_nf_except S.empty let ac_reasoning_for_m_frame_preserving (p q r:slprop u#a) (m:mem u#a) : Lemma (requires interp ((p `star` q) `star` r) m) (ensures interp (p `star` r) m) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_commutative p q; equiv_extensional_on_star (p `star` q) (q `star` p) r } (q `star` p) `star` r; (equiv) { star_associative q p r } q `star` (p `star` r); }; assert (interp (q `star` (p `star` r)) m); affine_star q (p `star` r) m let is_frame_preserving (#e:inames) (#a:Type u#b) (#fp:slprop u#a) (#fp':a -> slprop u#a) (f:tot_pre_action_nf_except e fp a fp') = forall (frame:slprop u#a) (m0:hmem_with_inv_except e (fp `star` frame)). (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = f:tot_pre_action_nf_except e fp a fp'{ is_frame_preserving f } let tot_action_nf = tot_action_nf_except S.empty let linv e (m:mem) = locks_invariant e m let hheap_of_hmem #fp #e (m:hmem_with_inv_except e fp) : h:H.hheap (fp `star` linv e m) { h `H.free_above_addr` m.ctr} = let h = heap_of_mem m in H.pure_interp (heap_ctr_valid m.ctr (heap_of_mem m)) h; h let hmem_of_hheap #e (#fp0 #fp1:slprop) (m:hmem_with_inv_except e fp0) (h:H.full_hheap (fp1 `star` linv e m) { h `Heap.free_above_addr` m.ctr }) : m1:hmem_with_inv_except e fp1{linv e m `equiv` linv e m1} = let m1 : mem = { m with heap = h } in assert (interp (fp1 `star` linv e m) m1); star_commutative fp1 (linv e m); assert (interp (linv e m `star` fp1) m1); assert (linv e m1 == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); assert (linv e m == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m)); H.pure_interp (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_of_mem m); assert (heap_ctr_valid m1.ctr (heap_of_mem m) <==> heap_ctr_valid m1.ctr (heap_of_mem m1)); H.pure_equiv (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_ctr_valid m1.ctr (heap_of_mem m1)); H.star_congruence (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m)); assert (linv e m `equiv` linv e m1); let _ = equiv_extensional_on_star (linv e m) (linv e m1) fp1 in assert ((linv e m `star` fp1) `equiv` (linv e m1 `star` fp1)); assert (interp (linv e m1 `star` fp1) m1); star_commutative (linv e m1) fp1; assert (interp (fp1 `star` linv e m1) m1); m1 let with_inv_except (m:mem) e (fp:slprop) = interp (fp `star` locks_invariant e m) m #push-options "--warn_error -271" let as_hprop (frame:slprop) (mp:mprop frame) : hp:H.hprop frame{forall m. mp (core_mem m) == hp (heap_of_mem m)} = let f = fun h -> mp (mem_of_heap h) in assert (forall m. mp (core_mem m) == f (heap_of_mem m)); let aux (m0:H.hheap frame) (m1:H.heap{H.disjoint m0 m1}) : Lemma (ensures (mem_of_heap (H.join m0 m1) == join (mem_of_heap m0) (mem_of_heap m1))) [SMTPat ()] = () in f

{ "checked_file": "/", "dependencies": [ "Steel.Preorder.fst.checked", "Steel.Heap.fsti.checked", "prims.fst.checked", "FStar.Witnessed.Core.fsti.checked", "FStar.Set.fsti.checked", "FStar.Preorder.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.PCM.fst.checked", "FStar.NMSTTotal.fst.checked", "FStar.List.Tot.fst.checked", "FStar.IndefiniteDescription.fsti.checked", "FStar.Ghost.fsti.checked", "FStar.FunctionalExtensionality.fsti.checked", "FStar.Classical.Sugar.fsti.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Steel.Memory.fst" }

[ { "abbrev": true, "full_module": "Steel.Preorder", "short_module": "PP" }, { "abbrev": true, "full_module": "FStar.Witnessed.Core", "short_module": "W" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": true, "full_module": "Steel.Heap", "short_module": "H" }, { "abbrev": false, "full_module": "FStar.PCM", "short_module": null }, { "abbrev": false, "full_module": "FStar.FunctionalExtensionality", "short_module": null }, { "abbrev": true, "full_module": "FStar.FunctionalExtensionality", "short_module": "F" }, { "abbrev": false, "full_module": "FStar.PCM", "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

p: Steel.Memory.slprop -> m0: Steel.Memory.mem -> m1: Steel.Memory.mem -> FStar.Pervasives.Lemma (requires forall (hp: Steel.Heap.hprop p). hp (Steel.Memory.heap_of_mem m0) == hp (Steel.Memory.heap_of_mem m1)) (ensures forall (mp: Steel.Memory.mprop p). mp (Steel.Memory.core_mem m0) == mp (Steel.Memory.core_mem m1))

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Steel.Memory.slprop", "Steel.Memory.mem", "Steel.Memory.mprop", "Prims.unit", "Prims.l_True", "Prims.squash", "Prims.eq2", "Prims.prop", "Steel.Memory.core_mem", "Prims.Cons", "FStar.Pervasives.pattern", "FStar.Pervasives.smt_pat", "Prims.Nil", "Prims._assert", "Steel.Memory.as_hprop", "Steel.Memory.heap_of_mem", "Prims.l_Forall", "Steel.Heap.hprop" ]

[]

false

true

false

let mprop_preservation_of_hprop_preservation (p: slprop) (m0 m1: mem) : Lemma (requires (forall (hp: H.hprop p). hp (heap_of_mem m0) == hp (heap_of_mem m1))) (ensures (forall (mp: mprop p). mp (core_mem m0) == mp (core_mem m1))) =

let aux (mp: mprop p) : Lemma (mp (core_mem m0) == mp (core_mem m1)) [SMTPat ()] = assert (as_hprop p mp (heap_of_mem m0) == as_hprop p mp (heap_of_mem m1)) in ()

false

Steel.Memory.fst

Steel.Memory.upd_action

val upd_action (#a:Type u#1) (#pcm:_) (e:inames) (r:ref a pcm) (v0:FStar.Ghost.erased a) (v1:a {FStar.PCM.frame_preserving pcm v0 v1 /\ pcm.refine v1}) : action_except unit e (pts_to r v0) (fun _ -> pts_to r v1)

let upd_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.upd_action #a #pcm r v0 v1))

{ "file_name": "lib/steel/Steel.Memory.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 71, "end_line": 847, "start_col": 0, "start_line": 846 }

(* 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.Memory module F = FStar.FunctionalExtensionality open FStar.FunctionalExtensionality open FStar.PCM module H = Steel.Heap noeq type lock_state : Type u#(a + 1) = | Invariant : inv:H.slprop u#a -> lock_state let lock_store : Type u#(a+1) = list (lock_state u#a) noeq type mem : Type u#(a + 1) = { ctr: nat; heap: H.heap u#a; locks: lock_store u#a; } let heap_of_mem (x:mem) : H.heap = x.heap let mem_of_heap (h:H.heap) : mem = { ctr = 0; heap = h; locks = [] } let mem_set_heap (m:mem) (h:H.heap) : mem = { ctr = m.ctr; heap = h; locks = m.locks; } let core_mem (m:mem) : mem = mem_of_heap (heap_of_mem m) let core_mem_invol m = () let disjoint (m0 m1:mem u#h) : prop = m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks let disjoint_sym m0 m1 = () let join m0 m1 = { ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = m0.locks } let join_commutative m0 m1 = H.join_commutative m0.heap m1.heap let disjoint_join m0 m1 m2 = H.disjoint_join m0.heap m1.heap m2.heap let join_associative m0 m1 m2 = H.join_associative m0.heap m1.heap m2.heap let slprop = H.slprop let interp p m = H.interp p m.heap let equiv p1 p2 = forall m. interp p1 m <==> interp p2 m let slprop_extensionality p q = assert (forall m. interp p m <==> interp q m); let aux (h:H.heap) : Lemma (H.interp p h <==> H.interp q h) [SMTPat (H.interp p h)] = let m : mem = { ctr = 0; heap = h; locks = [] } in assert (interp p m <==> interp q m) in assert (forall h. H.interp p h <==> H.interp q h); Steel.Heap.slprop_extensionality p q let reveal_equiv p1 p2 = () let core_ref = H.core_ref let core_ref_null = H.core_ref_null let core_ref_is_null r = H.core_ref_is_null r let emp : slprop u#a = H.emp let pure = H.pure let pts_to = H.pts_to let h_and = H.h_and let h_or = H.h_or let star = H.star let wand = H.wand let h_exists = H.h_exists let h_forall = H.h_forall //////////////////////////////////////////////////////////////////////////////// //properties of equiv //////////////////////////////////////////////////////////////////////////////// let equiv_symmetric (p1 p2:slprop u#a) = H.equiv_symmetric p1 p2 #push-options "--warn_error -271" let equiv_heap_iff_equiv (p1 p2:slprop u#a) : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat (equiv p1 p2)] = let aux_lr () : Lemma (requires H.equiv p1 p2) (ensures equiv p1 p2) [SMTPat ()] = () in let aux_rl_helper1 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p1 h) (ensures H.interp p2 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl_helper2 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p2 h) (ensures H.interp p1 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl () : Lemma (requires equiv p1 p2) (ensures H.equiv p1 p2) [SMTPat ()] = () in () let equiv_heap_iff_equiv_forall () : Lemma (ensures (forall p1 p2. H.equiv p1 p2 <==> equiv p1 p2)) = let aux p1 p2 : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat ()] = equiv_heap_iff_equiv p1 p2 in () #pop-options let equiv_extensional_on_star (p1 p2 p3:slprop u#a) = equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3 let emp_unit p = H.emp_unit p let intro_emp m = H.intro_emp (heap_of_mem m) let pure_equiv p q = H.pure_equiv p q let pure_interp q m = H.pure_interp q (heap_of_mem m) let pure_star_interp p q m = H.pure_star_interp p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// //pts_to //////////////////////////////////////////////////////////////////////////////// let pts_to_compatible #a #pcm x v0 v1 m = H.pts_to_compatible #a #pcm x v0 v1 (heap_of_mem m) let pts_to_compatible_equiv #a #pcm x v0 v1 = H.pts_to_compatible_equiv #a #pcm x v0 v1 let pts_to_not_null #a #pcm x v m = H.pts_to_not_null #a #pcm x v (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // star //////////////////////////////////////////////////////////////////////////////// let intro_star p q mp mq = H.intro_star p q (heap_of_mem mp) (heap_of_mem mq) let elim_star p q m = let h = heap_of_mem m in H.elim_star p q h; assert (exists hl hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr); let hl = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hl -> exists hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let hr = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hr -> H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let ml = mem_set_heap m hl in let mr = mem_set_heap m hr in assert (disjoint ml mr); assert (m == join ml mr); assert (interp p ml); assert (interp q mr); () let interp_star (p q: slprop) (m: mem) : Lemma (interp (p `star` q) m <==> (exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m)) = let left = interp (p `star` q) m in let right = exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m in let f () : Lemma (requires left) (ensures right) = elim_star p q m in let g () : Lemma (requires right) (ensures left) = Classical.exists_elim left #_ #(fun mp -> exists (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mp -> Classical.exists_elim left #_ #(fun mq -> disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mq -> intro_star p q mp mq ) ) in Classical.move_requires f (); Classical.move_requires g () let star_commutative (p1 p2:slprop) = H.star_commutative p1 p2 let star_associative (p1 p2 p3:slprop) = H.star_associative p1 p2 p3 let star_congruence (p1 p2 p3 p4:slprop) = equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4 let affine_star (p q:slprop) (m:mem) = H.affine_star p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // Invariants on the lock store //////////////////////////////////////////////////////////////////////////////// let iname = nat module S = FStar.Set module L = FStar.List.Tot module W = FStar.Witnessed.Core let rec lock_store_invariant (e:inames) (l:lock_store u#a) : slprop u#a = let current_addr = L.length l - 1 in match l with | [] -> emp | Invariant p :: tl -> if current_addr `S.mem` e then lock_store_invariant e tl else p `star` lock_store_invariant e tl let lock_i (i:iname) (l:lock_store { i < L.length l }) = let ix = L.length l - i - 1 in L.index l ix let iname_for_p (i:iname) (p:slprop) : W.s_predicate lock_store = fun l -> i < L.length l /\ (lock_i i l).inv == p let lock_store_evolves : FStar.Preorder.preorder lock_store = fun (l1 l2 : lock_store) -> L.length l2 >= L.length l1 /\ (forall (i:nat{i < L.length l1}). (lock_i i l1).inv == (lock_i i l2).inv) let inames_in (e:inames) (l:lock_store) : prop = forall i. Set.mem i e ==> i < L.length l let inames_ok e m = inames_in e m.locks let inames_ok_empty m = () let extend_lock_store (e:inames) (l:lock_store{e `inames_in` l}) (p:slprop) : i:iname & l':lock_store { lock_store_invariant e l' == p `star` lock_store_invariant e l /\ iname_for_p i p l' } = (| L.length l, Invariant p :: l |) let set_add (i:iname) (s:inames) = Set.union (Set.singleton i) s let rec move_invariant (e:inames) (l:lock_store) (p:slprop) (i:iname{iname_for_p i p l /\ ~(i `Set.mem` e)}) : Lemma (H.equiv (lock_store_invariant e l) (p `star` lock_store_invariant (set_add i e) l)) = let rec aux (i:iname) (m:lock_store) : Lemma (requires i >= L.length m) (ensures (lock_store_invariant e m `H.equiv` lock_store_invariant (set_add i e) m)) = match m with | [] -> () | Invariant p::tl -> aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl) in let current_addr = L.length l - 1 in match l with | [] -> () | Invariant q::tl -> if i = current_addr then begin assert (lock_store_invariant e l == p `star` lock_store_invariant e tl); aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl); () end else begin move_invariant e tl p i; assert (lock_store_invariant e tl `equiv` (p `star` lock_store_invariant (set_add i e) tl)); H.star_congruence q (lock_store_invariant e tl) q (p `star` lock_store_invariant (set_add i e) tl); if Set.mem current_addr e then () else begin let r = lock_store_invariant (set_add i e) tl in assert (lock_store_invariant e l `equiv` (q `star` (p `star` r))); H.star_associative q p r; H.star_commutative q p; H.star_congruence (q `star` p) r (p `star` q) r; H.star_associative p q r end end let heap_ctr_valid (ctr:nat) (h:H.heap u#a) : prop = h `H.free_above_addr` ctr let ctr_validity (ctr:nat) (h:H.heap) : slprop = H.pure (heap_ctr_valid ctr h) let locks_invariant (e:inames) (m:mem u#a) : slprop u#a = lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m) let full_mem_pred (m:mem) = H.full_heap_pred (heap_of_mem m) (***** Following lemmas are needed in Steel.Effect *****) let core_mem_interp (hp:slprop u#a) (m:mem u#a) = () let interp_depends_only_on (hp:slprop u#a) = H.interp_depends_only_on hp let a_mem_prop_as_a_heap_prop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (H.a_heap_prop u#a) = let g (h: H.heap u#a) : Tot prop = interp sl (mem_of_heap h) /\ f (mem_of_heap h) in let phi0 (h0 h1: H.heap u#a) : Lemma (requires (g h0 /\ H.disjoint h0 h1)) (ensures (g h0 /\ H.disjoint h0 h1 /\ g (H.join h0 h1))) = assert (mem_of_heap (H.join h0 h1) == mem_of_heap h0 `join` mem_of_heap h1); interp_depends_only_on sl in let phi1 (h0 h1: H.heap u#a) : Lemma (ensures ((g h0 /\ H.disjoint h0 h1) ==> g (H.join h0 h1))) = Classical.move_requires (phi0 h0) h1 in Classical.forall_intro_2 phi1; g let refine_slprop sl f = H.as_slprop (a_mem_prop_as_a_heap_prop sl f) let interp_refine_slprop sl f m = assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_mem m)) let dep_hprop (s: slprop) (f: (hmem s -> Tot slprop)) (h: H.heap) : Tot prop = exists (h1: H.heap) . exists (h2: H.heap) . interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 let dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq' : squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h')) = let p2 (h h1 h2: H.heap) : Tot prop = interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 in let p1 (h h1: H.heap) : Tot prop = (exists h2 . p2 h h1 h2) in let h1 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p1 h) in let h2 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p2 h h1) in H.disjoint_join h' h1 h2; assert (H.disjoint h2 h'); let h2' = H.join h2 h' in H.join_commutative h2 h' ; assert (h2' == H.join h' h2); assert (H.disjoint h1 h2'); assert (mem_of_heap h2' == mem_of_heap h2 `join` mem_of_heap h'); interp_depends_only_on (f (mem_of_heap h1)); assert (interp (f (mem_of_heap h1)) (mem_of_heap h2')); H.join_commutative h1 h2; H.join_associative h' h2 h1; H.join_commutative h' h; H.join_commutative h2' h1; assert (H.join h h' == h1 `H.join` h2') let impl_intro_gen (#p: Type0) (#q: Type0) ($prf: (squash p -> Lemma (q ))) : Lemma (p ==> q) = Classical.impl_intro_gen #p #(fun _ -> q) prf let dep_hprop_is_affine1 (s: slprop) (f: (hmem s -> Tot slprop)) (h0 h1: H.heap) : Lemma ((dep_hprop s f h0 /\ H.disjoint h0 h1) ==> (H.disjoint h0 h1 /\ dep_hprop s f (H.join h0 h1))) = impl_intro_gen (dep_hprop_is_affine0 s f h0 h1) let dep_hprop_is_affine (s: slprop) (f: (hmem s -> Tot slprop)) : Lemma (H.heap_prop_is_affine (dep_hprop s f)) = Classical.forall_intro_2 (dep_hprop_is_affine1 s f) let sdep (s: slprop) (f: (hmem s -> Tot slprop)) : Tot slprop = dep_hprop_is_affine s f; H.as_slprop (dep_hprop s f) let interp_sdep (s: slprop) (f: (hmem s -> Tot slprop)) (m: mem) : Lemma (requires (dep_slprop_is_affine s f)) (ensures ( interp (sdep s f) m <==> (exists m1 m2 . interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) )) = dep_hprop_is_affine s f; assert (forall m1 m2 . (interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) ==> ( interp s (mem_of_heap m1.heap) /\ interp (f (mem_of_heap m1.heap)) (mem_of_heap m2.heap) /\ H.disjoint m1.heap m2.heap /\ H.join m1.heap m2.heap == m.heap )); interp_depends_only_on s; Classical.forall_intro (fun m -> interp_depends_only_on (f m)); assert (forall h1 h2 . (interp s (mem_of_heap h1) /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ H.disjoint h1 h2 /\ H.join h1 h2 == m.heap) ==> ( core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ interp s (core_mem (mem_of_heap h1)) /\ interp s (mem_set_heap m h1) /\ core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ f (mem_set_heap m h1) `equiv` f (mem_of_heap h1) /\ interp (f (mem_set_heap m h1)) (mem_of_heap h2) /\ interp (f (mem_set_heap m h1)) (mem_set_heap m h2) /\ disjoint (mem_set_heap m h1) (mem_set_heap m h2) /\ join (mem_set_heap m h1) (mem_set_heap m h2) == m )); () let h_exists_cong (#a:Type) (p q : a -> slprop) : Lemma (requires (forall x. p x `equiv` q x)) (ensures (h_exists p `equiv` h_exists q)) = equiv_heap_iff_equiv_forall (); H.h_exists_cong p q let intro_h_exists #a x p m = H.intro_h_exists x p (heap_of_mem m) let elim_h_exists (#a:_) (p:a -> slprop) (m:mem) = H.elim_h_exists p (heap_of_mem m) let intro_h_forall (#a:_) (p:a -> slprop) (m:mem) = H.intro_h_forall p (heap_of_mem m) let elim_h_forall (#a:_) (p:a -> slprop) (m:mem) (x:a) = H.elim_h_forall p (heap_of_mem m) x let intro_h_and (p q: slprop) (m:mem) = H.intro_h_and p q (heap_of_mem m) let elim_h_and (p q: slprop) (m:mem) = H.elim_h_and p q (heap_of_mem m) let intro_h_or_left (p q: slprop) (m:mem) = H.intro_h_or_left p q (heap_of_mem m) let intro_h_or_right (p q: slprop) (m:mem) = H.intro_h_or_right p q (heap_of_mem m) let elim_h_or (p q: slprop) (m:mem) = H.elim_h_or p q (heap_of_mem m) let intro_wand (p1 p2: slprop u#a) (m:mem) = introduce (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)) ==> interp (wand p1 p2) m with _. ( assert (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)); H.intro_wand p1 p2 (heap_of_mem m); let h = heap_of_mem m in assert ((forall h1. h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) ==> H.interp (wand p1 p2) h); introduce forall h1. (h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) with ( introduce (h `H.disjoint` h1 /\ H.interp p1 h1) ==> H.interp p2 (H.join h h1) with _. ( assert (h `H.disjoint` h1); let m1 = { ctr = m.ctr; heap = h1; locks = m.locks } in assert (m `disjoint` m1) ) ) ) (** Eliminating a wand by proving a heap that satisfies the LHS **) let elim_wand (p1 p2: slprop u#a) (m:mem) (m1:mem) = H.elim_wand p1 p2 (heap_of_mem m) (heap_of_mem m1) //////////////////////////////////////////////////////////////////////////////// // Preorders and effects //////////////////////////////////////////////////////////////////////////////// module PP = Steel.Preorder let mem_evolves = fun (m0 m1:full_mem) -> H.heap_evolves (heap_of_mem m0) (heap_of_mem m1) /\ m0.ctr <= m1.ctr /\ lock_store_evolves m0.locks m1.locks (** See [Steel.Heap.is_frame_preserving]. We add in [lock_invariants] now *) let preserves_frame (e:inames) (pre post:slprop) (m0 m1:mem) = forall (frame:slprop). interp ((pre `star` frame) `star` locks_invariant e m0) m0 ==> (interp ((post `star` frame) `star` locks_invariant e m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) (** This is a version of MstTot with frame quantified, as part of preserves_frame *) effect MstTotNF (a:Type u#a) (except:inames) (expects:slprop u#1) (provides: a -> slprop u#1) = NMSTTotal.NMSTATETOT a (full_mem u#1) mem_evolves (requires fun m0 -> inames_ok except m0 /\ interp (expects `star` locks_invariant except m0) m0) (ensures fun m0 x m1 -> inames_ok except m1 /\ interp (provides x `star` locks_invariant except m1) m1 /\ preserves_frame except expects (provides x) m0 m1) //////////////////////////////////////////////////////////////////////////////// // Lifting heap actions //////////////////////////////////////////////////////////////////////////////// (** Heap actions come in two equivalent flavors: - one that take an explicit frame as argument (action_with_frame) - and one that quantify over all the frame We therefore define two lift routes: - a direct route for those with explicit frame - via MstTotNF for the rest *) let tot_pre_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = hmem_with_inv_except e fp -> (x:a & hmem_with_inv_except e (fp' x)) let tot_pre_action_nf = tot_pre_action_nf_except S.empty let ac_reasoning_for_m_frame_preserving (p q r:slprop u#a) (m:mem u#a) : Lemma (requires interp ((p `star` q) `star` r) m) (ensures interp (p `star` r) m) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_commutative p q; equiv_extensional_on_star (p `star` q) (q `star` p) r } (q `star` p) `star` r; (equiv) { star_associative q p r } q `star` (p `star` r); }; assert (interp (q `star` (p `star` r)) m); affine_star q (p `star` r) m let is_frame_preserving (#e:inames) (#a:Type u#b) (#fp:slprop u#a) (#fp':a -> slprop u#a) (f:tot_pre_action_nf_except e fp a fp') = forall (frame:slprop u#a) (m0:hmem_with_inv_except e (fp `star` frame)). (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = f:tot_pre_action_nf_except e fp a fp'{ is_frame_preserving f } let tot_action_nf = tot_action_nf_except S.empty let linv e (m:mem) = locks_invariant e m let hheap_of_hmem #fp #e (m:hmem_with_inv_except e fp) : h:H.hheap (fp `star` linv e m) { h `H.free_above_addr` m.ctr} = let h = heap_of_mem m in H.pure_interp (heap_ctr_valid m.ctr (heap_of_mem m)) h; h let hmem_of_hheap #e (#fp0 #fp1:slprop) (m:hmem_with_inv_except e fp0) (h:H.full_hheap (fp1 `star` linv e m) { h `Heap.free_above_addr` m.ctr }) : m1:hmem_with_inv_except e fp1{linv e m `equiv` linv e m1} = let m1 : mem = { m with heap = h } in assert (interp (fp1 `star` linv e m) m1); star_commutative fp1 (linv e m); assert (interp (linv e m `star` fp1) m1); assert (linv e m1 == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); assert (linv e m == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m)); H.pure_interp (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_of_mem m); assert (heap_ctr_valid m1.ctr (heap_of_mem m) <==> heap_ctr_valid m1.ctr (heap_of_mem m1)); H.pure_equiv (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_ctr_valid m1.ctr (heap_of_mem m1)); H.star_congruence (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m)); assert (linv e m `equiv` linv e m1); let _ = equiv_extensional_on_star (linv e m) (linv e m1) fp1 in assert ((linv e m `star` fp1) `equiv` (linv e m1 `star` fp1)); assert (interp (linv e m1 `star` fp1) m1); star_commutative (linv e m1) fp1; assert (interp (fp1 `star` linv e m1) m1); m1 let with_inv_except (m:mem) e (fp:slprop) = interp (fp `star` locks_invariant e m) m #push-options "--warn_error -271" let as_hprop (frame:slprop) (mp:mprop frame) : hp:H.hprop frame{forall m. mp (core_mem m) == hp (heap_of_mem m)} = let f = fun h -> mp (mem_of_heap h) in assert (forall m. mp (core_mem m) == f (heap_of_mem m)); let aux (m0:H.hheap frame) (m1:H.heap{H.disjoint m0 m1}) : Lemma (ensures (mem_of_heap (H.join m0 m1) == join (mem_of_heap m0) (mem_of_heap m1))) [SMTPat ()] = () in f let mprop_preservation_of_hprop_preservation (p:slprop) (m0 m1:mem) : Lemma (requires (forall (hp:H.hprop p). hp (heap_of_mem m0) == hp (heap_of_mem m1))) (ensures (forall (mp:mprop p). mp (core_mem m0) == mp (core_mem m1))) = let aux (mp:mprop p) : Lemma (mp (core_mem m0) == mp (core_mem m1)) [SMTPat()] = assert (as_hprop p mp (heap_of_mem m0) == as_hprop p mp (heap_of_mem m1)) in () let lift_heap_action (#fp:slprop) (#a:Type) (#fp':a -> slprop) (e:inames) ($f:H.action fp a fp') : tot_action_nf_except e fp a fp' = let g : tot_pre_action_nf_except e fp a fp' = fun m -> let h0 = hheap_of_hmem m in let (| x, h' |) = f h0 in (| x, hmem_of_hheap m h' |) in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in let h0 = hheap_of_hmem m0 in let (| x', h1 |) = f h0 in H.action_framing f (linv e m0) h0; assert (x == x'); star_associative fp frame (linv e m0); H.action_framing f (frame `star` linv e m0) h0; assert (H.interp ((fp' x) `star` (frame `star` linv e m0)) h1); star_associative (fp' x) frame (linv e m0); assert (H.interp ((fp' x `star` frame) `star` linv e m0) h1); let h1' : H.hheap ((fp' x `star` frame) `star` linv e m0) = h1 in assert (m1 == hmem_of_hheap m0 h1'); assert (with_inv_except m1 e (fp' x `star` frame)); assert (forall (hp:H.hprop frame). hp h0 == hp h1); mprop_preservation_of_hprop_preservation frame m0 m1; () in assert (is_frame_preserving g); g let frame_preserving_respects_preorder #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (m0:hmem_with_inv_except e fp) : Lemma (let (| x, m1 |) = f m0 in mem_evolves m0 m1) = let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1) = () in H.emp_unit fp; assert (interp (fp `star` linv e m0) m0); H.star_congruence (fp `star` emp) (linv e m0) fp (linv e m0); assert (interp ((fp `star` emp) `star` linv e m0) m0); aux emp m0 let lift_tot_action_nf #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') : MstTotNF a e fp fp' = let m0 = NMSTTotal.get () in let m0' : hmem_with_inv_except e fp = m0 in let r = f m0' in let (| x, m1 |) = r in let m1' : hmem_with_inv_except e (fp' x) = m1 in assert (is_frame_preserving f); assert (m1 == dsnd (f m0)); frame_preserving_respects_preorder f m0; NMSTTotal.put #_ #(mem_evolves) m1; x let lift_tot_action #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get #(full_mem) #_ () in ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); lift_tot_action_nf f (** Now defining the lift for heap actions with explicit frame *) let tot_action_with_frame_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = frame:slprop u#a -> m0:hmem_with_inv_except e (fp `star` frame) -> Pure (x:a & hmem_with_inv_except e (fp' x `star` frame)) (requires True) (ensures fun (| x, m1 |) -> mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_with_frame = tot_action_with_frame_except S.empty let lift_heap_action_with_frame (#fp:slprop u#a) (#a:Type u#b) (#fp':a -> slprop u#a) (e:inames) ($f:H.action_with_frame fp a fp') : tot_action_with_frame_except e fp a fp' = fun frame m0 -> let h0 = hheap_of_hmem m0 in calc (equiv) { fp `star` frame `star` locks_invariant e m0; (equiv) { star_associative fp frame (locks_invariant e m0) } fp `star` (frame `star` locks_invariant e m0); }; assert (H.interp (fp `star` frame `star` locks_invariant e m0) h0); assert (H.interp (fp `star` (frame `star` locks_invariant e m0)) h0); //key: apply the heap action with frame * locks_invariant e m0 let (| x, h1 |) = f (frame `star` locks_invariant e m0) h0 in calc (equiv) { fp' x `star` (frame `star` locks_invariant e m0); (equiv) { star_associative (fp' x) frame (locks_invariant e m0) } fp' x `star` frame `star` locks_invariant e m0; }; assert (H.interp (fp' x `star` (frame `star` locks_invariant e m0)) h1); assert (H.interp (fp' x `star` frame `star` locks_invariant e m0) h1); let m1 = hmem_of_hheap m0 h1 in assert (mem_evolves m0 m1); mprop_preservation_of_hprop_preservation (frame `star` locks_invariant e m0) m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)); (| x, m1 |) let lift_tot_action_with_frame #a #e #fp #fp' ($f:tot_action_with_frame_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in assert (inames_ok e m0); ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); let m0' : hmem_with_inv_except e fp = m0 in let r = f frame m0' in let (| x, m1 |) = r in ac_reasoning_for_m_frame_preserving (fp' x) frame (locks_invariant e m1) m1; assert (interp (fp' x `star` frame `star` locks_invariant e m1) m1); assert (interp (fp' x `star` locks_invariant e m1) m1); let m1' : hmem_with_inv_except e (fp' x) = m1 in NMSTTotal.put #_ #(mem_evolves) m1; x let sel_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.sel_action #a #pcm r v0))

{ "checked_file": "/", "dependencies": [ "Steel.Preorder.fst.checked", "Steel.Heap.fsti.checked", "prims.fst.checked", "FStar.Witnessed.Core.fsti.checked", "FStar.Set.fsti.checked", "FStar.Preorder.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.PCM.fst.checked", "FStar.NMSTTotal.fst.checked", "FStar.List.Tot.fst.checked", "FStar.IndefiniteDescription.fsti.checked", "FStar.Ghost.fsti.checked", "FStar.FunctionalExtensionality.fsti.checked", "FStar.Classical.Sugar.fsti.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Steel.Memory.fst" }

[ { "abbrev": true, "full_module": "Steel.Preorder", "short_module": "PP" }, { "abbrev": true, "full_module": "FStar.Witnessed.Core", "short_module": "W" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": true, "full_module": "Steel.Heap", "short_module": "H" }, { "abbrev": false, "full_module": "FStar.FunctionalExtensionality", "short_module": null }, { "abbrev": true, "full_module": "FStar.FunctionalExtensionality", "short_module": "F" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": false, "full_module": "FStar.PCM", "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

e: Steel.Memory.inames -> r: Steel.Memory.ref a pcm -> v0: FStar.Ghost.erased a -> v1: a{FStar.PCM.frame_preserving pcm (FStar.Ghost.reveal v0) v1 /\ Mkpcm?.refine pcm v1} -> Steel.Memory.action_except Prims.unit e (Steel.Memory.pts_to r (FStar.Ghost.reveal v0)) (fun _ -> Steel.Memory.pts_to r v1)

Prims.Tot

[ "total" ]

[]

[ "FStar.PCM.pcm", "Steel.Memory.inames", "Steel.Memory.ref", "FStar.Ghost.erased", "Prims.l_and", "FStar.PCM.frame_preserving", "FStar.Ghost.reveal", "FStar.PCM.__proj__Mkpcm__item__refine", "Steel.Memory.lift_tot_action", "Prims.unit", "Steel.Heap.pts_to", "Steel.Memory.slprop", "Steel.Memory.lift_heap_action", "Steel.Heap.upd_action", "Steel.Memory.action_except", "Steel.Memory.pts_to" ]

[]

false

let upd_action #a #pcm e r v0 v1 =

lift_tot_action (lift_heap_action e (H.upd_action #a #pcm r v0 v1))

false

Steel.Memory.fst

Steel.Memory.inv

val inv (p:slprop u#1) : Type0

let inv (p:slprop u#1) = i:erased iname & witnessed_name_is_ok i & (i >--> p)

{ "file_name": "lib/steel/Steel.Memory.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 77, "end_line": 1256, "start_col": 0, "start_line": 1256 }

(* 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.Memory module F = FStar.FunctionalExtensionality open FStar.FunctionalExtensionality open FStar.PCM module H = Steel.Heap noeq type lock_state : Type u#(a + 1) = | Invariant : inv:H.slprop u#a -> lock_state let lock_store : Type u#(a+1) = list (lock_state u#a) noeq type mem : Type u#(a + 1) = { ctr: nat; heap: H.heap u#a; locks: lock_store u#a; } let heap_of_mem (x:mem) : H.heap = x.heap let mem_of_heap (h:H.heap) : mem = { ctr = 0; heap = h; locks = [] } let mem_set_heap (m:mem) (h:H.heap) : mem = { ctr = m.ctr; heap = h; locks = m.locks; } let core_mem (m:mem) : mem = mem_of_heap (heap_of_mem m) let core_mem_invol m = () let disjoint (m0 m1:mem u#h) : prop = m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks let disjoint_sym m0 m1 = () let join m0 m1 = { ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = m0.locks } let join_commutative m0 m1 = H.join_commutative m0.heap m1.heap let disjoint_join m0 m1 m2 = H.disjoint_join m0.heap m1.heap m2.heap let join_associative m0 m1 m2 = H.join_associative m0.heap m1.heap m2.heap let slprop = H.slprop let interp p m = H.interp p m.heap let equiv p1 p2 = forall m. interp p1 m <==> interp p2 m let slprop_extensionality p q = assert (forall m. interp p m <==> interp q m); let aux (h:H.heap) : Lemma (H.interp p h <==> H.interp q h) [SMTPat (H.interp p h)] = let m : mem = { ctr = 0; heap = h; locks = [] } in assert (interp p m <==> interp q m) in assert (forall h. H.interp p h <==> H.interp q h); Steel.Heap.slprop_extensionality p q let reveal_equiv p1 p2 = () let core_ref = H.core_ref let core_ref_null = H.core_ref_null let core_ref_is_null r = H.core_ref_is_null r let emp : slprop u#a = H.emp let pure = H.pure let pts_to = H.pts_to let h_and = H.h_and let h_or = H.h_or let star = H.star let wand = H.wand let h_exists = H.h_exists let h_forall = H.h_forall //////////////////////////////////////////////////////////////////////////////// //properties of equiv //////////////////////////////////////////////////////////////////////////////// let equiv_symmetric (p1 p2:slprop u#a) = H.equiv_symmetric p1 p2 #push-options "--warn_error -271" let equiv_heap_iff_equiv (p1 p2:slprop u#a) : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat (equiv p1 p2)] = let aux_lr () : Lemma (requires H.equiv p1 p2) (ensures equiv p1 p2) [SMTPat ()] = () in let aux_rl_helper1 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p1 h) (ensures H.interp p2 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl_helper2 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p2 h) (ensures H.interp p1 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl () : Lemma (requires equiv p1 p2) (ensures H.equiv p1 p2) [SMTPat ()] = () in () let equiv_heap_iff_equiv_forall () : Lemma (ensures (forall p1 p2. H.equiv p1 p2 <==> equiv p1 p2)) = let aux p1 p2 : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat ()] = equiv_heap_iff_equiv p1 p2 in () #pop-options let equiv_extensional_on_star (p1 p2 p3:slprop u#a) = equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3 let emp_unit p = H.emp_unit p let intro_emp m = H.intro_emp (heap_of_mem m) let pure_equiv p q = H.pure_equiv p q let pure_interp q m = H.pure_interp q (heap_of_mem m) let pure_star_interp p q m = H.pure_star_interp p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// //pts_to //////////////////////////////////////////////////////////////////////////////// let pts_to_compatible #a #pcm x v0 v1 m = H.pts_to_compatible #a #pcm x v0 v1 (heap_of_mem m) let pts_to_compatible_equiv #a #pcm x v0 v1 = H.pts_to_compatible_equiv #a #pcm x v0 v1 let pts_to_not_null #a #pcm x v m = H.pts_to_not_null #a #pcm x v (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // star //////////////////////////////////////////////////////////////////////////////// let intro_star p q mp mq = H.intro_star p q (heap_of_mem mp) (heap_of_mem mq) let elim_star p q m = let h = heap_of_mem m in H.elim_star p q h; assert (exists hl hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr); let hl = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hl -> exists hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let hr = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hr -> H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let ml = mem_set_heap m hl in let mr = mem_set_heap m hr in assert (disjoint ml mr); assert (m == join ml mr); assert (interp p ml); assert (interp q mr); () let interp_star (p q: slprop) (m: mem) : Lemma (interp (p `star` q) m <==> (exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m)) = let left = interp (p `star` q) m in let right = exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m in let f () : Lemma (requires left) (ensures right) = elim_star p q m in let g () : Lemma (requires right) (ensures left) = Classical.exists_elim left #_ #(fun mp -> exists (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mp -> Classical.exists_elim left #_ #(fun mq -> disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mq -> intro_star p q mp mq ) ) in Classical.move_requires f (); Classical.move_requires g () let star_commutative (p1 p2:slprop) = H.star_commutative p1 p2 let star_associative (p1 p2 p3:slprop) = H.star_associative p1 p2 p3 let star_congruence (p1 p2 p3 p4:slprop) = equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4 let affine_star (p q:slprop) (m:mem) = H.affine_star p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // Invariants on the lock store //////////////////////////////////////////////////////////////////////////////// let iname = nat module S = FStar.Set module L = FStar.List.Tot module W = FStar.Witnessed.Core let rec lock_store_invariant (e:inames) (l:lock_store u#a) : slprop u#a = let current_addr = L.length l - 1 in match l with | [] -> emp | Invariant p :: tl -> if current_addr `S.mem` e then lock_store_invariant e tl else p `star` lock_store_invariant e tl let lock_i (i:iname) (l:lock_store { i < L.length l }) = let ix = L.length l - i - 1 in L.index l ix let iname_for_p (i:iname) (p:slprop) : W.s_predicate lock_store = fun l -> i < L.length l /\ (lock_i i l).inv == p let lock_store_evolves : FStar.Preorder.preorder lock_store = fun (l1 l2 : lock_store) -> L.length l2 >= L.length l1 /\ (forall (i:nat{i < L.length l1}). (lock_i i l1).inv == (lock_i i l2).inv) let inames_in (e:inames) (l:lock_store) : prop = forall i. Set.mem i e ==> i < L.length l let inames_ok e m = inames_in e m.locks let inames_ok_empty m = () let extend_lock_store (e:inames) (l:lock_store{e `inames_in` l}) (p:slprop) : i:iname & l':lock_store { lock_store_invariant e l' == p `star` lock_store_invariant e l /\ iname_for_p i p l' } = (| L.length l, Invariant p :: l |) let set_add (i:iname) (s:inames) = Set.union (Set.singleton i) s let rec move_invariant (e:inames) (l:lock_store) (p:slprop) (i:iname{iname_for_p i p l /\ ~(i `Set.mem` e)}) : Lemma (H.equiv (lock_store_invariant e l) (p `star` lock_store_invariant (set_add i e) l)) = let rec aux (i:iname) (m:lock_store) : Lemma (requires i >= L.length m) (ensures (lock_store_invariant e m `H.equiv` lock_store_invariant (set_add i e) m)) = match m with | [] -> () | Invariant p::tl -> aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl) in let current_addr = L.length l - 1 in match l with | [] -> () | Invariant q::tl -> if i = current_addr then begin assert (lock_store_invariant e l == p `star` lock_store_invariant e tl); aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl); () end else begin move_invariant e tl p i; assert (lock_store_invariant e tl `equiv` (p `star` lock_store_invariant (set_add i e) tl)); H.star_congruence q (lock_store_invariant e tl) q (p `star` lock_store_invariant (set_add i e) tl); if Set.mem current_addr e then () else begin let r = lock_store_invariant (set_add i e) tl in assert (lock_store_invariant e l `equiv` (q `star` (p `star` r))); H.star_associative q p r; H.star_commutative q p; H.star_congruence (q `star` p) r (p `star` q) r; H.star_associative p q r end end let heap_ctr_valid (ctr:nat) (h:H.heap u#a) : prop = h `H.free_above_addr` ctr let ctr_validity (ctr:nat) (h:H.heap) : slprop = H.pure (heap_ctr_valid ctr h) let locks_invariant (e:inames) (m:mem u#a) : slprop u#a = lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m) let full_mem_pred (m:mem) = H.full_heap_pred (heap_of_mem m) (***** Following lemmas are needed in Steel.Effect *****) let core_mem_interp (hp:slprop u#a) (m:mem u#a) = () let interp_depends_only_on (hp:slprop u#a) = H.interp_depends_only_on hp let a_mem_prop_as_a_heap_prop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (H.a_heap_prop u#a) = let g (h: H.heap u#a) : Tot prop = interp sl (mem_of_heap h) /\ f (mem_of_heap h) in let phi0 (h0 h1: H.heap u#a) : Lemma (requires (g h0 /\ H.disjoint h0 h1)) (ensures (g h0 /\ H.disjoint h0 h1 /\ g (H.join h0 h1))) = assert (mem_of_heap (H.join h0 h1) == mem_of_heap h0 `join` mem_of_heap h1); interp_depends_only_on sl in let phi1 (h0 h1: H.heap u#a) : Lemma (ensures ((g h0 /\ H.disjoint h0 h1) ==> g (H.join h0 h1))) = Classical.move_requires (phi0 h0) h1 in Classical.forall_intro_2 phi1; g let refine_slprop sl f = H.as_slprop (a_mem_prop_as_a_heap_prop sl f) let interp_refine_slprop sl f m = assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_mem m)) let dep_hprop (s: slprop) (f: (hmem s -> Tot slprop)) (h: H.heap) : Tot prop = exists (h1: H.heap) . exists (h2: H.heap) . interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 let dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq' : squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h')) = let p2 (h h1 h2: H.heap) : Tot prop = interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 in let p1 (h h1: H.heap) : Tot prop = (exists h2 . p2 h h1 h2) in let h1 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p1 h) in let h2 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p2 h h1) in H.disjoint_join h' h1 h2; assert (H.disjoint h2 h'); let h2' = H.join h2 h' in H.join_commutative h2 h' ; assert (h2' == H.join h' h2); assert (H.disjoint h1 h2'); assert (mem_of_heap h2' == mem_of_heap h2 `join` mem_of_heap h'); interp_depends_only_on (f (mem_of_heap h1)); assert (interp (f (mem_of_heap h1)) (mem_of_heap h2')); H.join_commutative h1 h2; H.join_associative h' h2 h1; H.join_commutative h' h; H.join_commutative h2' h1; assert (H.join h h' == h1 `H.join` h2') let impl_intro_gen (#p: Type0) (#q: Type0) ($prf: (squash p -> Lemma (q ))) : Lemma (p ==> q) = Classical.impl_intro_gen #p #(fun _ -> q) prf let dep_hprop_is_affine1 (s: slprop) (f: (hmem s -> Tot slprop)) (h0 h1: H.heap) : Lemma ((dep_hprop s f h0 /\ H.disjoint h0 h1) ==> (H.disjoint h0 h1 /\ dep_hprop s f (H.join h0 h1))) = impl_intro_gen (dep_hprop_is_affine0 s f h0 h1) let dep_hprop_is_affine (s: slprop) (f: (hmem s -> Tot slprop)) : Lemma (H.heap_prop_is_affine (dep_hprop s f)) = Classical.forall_intro_2 (dep_hprop_is_affine1 s f) let sdep (s: slprop) (f: (hmem s -> Tot slprop)) : Tot slprop = dep_hprop_is_affine s f; H.as_slprop (dep_hprop s f) let interp_sdep (s: slprop) (f: (hmem s -> Tot slprop)) (m: mem) : Lemma (requires (dep_slprop_is_affine s f)) (ensures ( interp (sdep s f) m <==> (exists m1 m2 . interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) )) = dep_hprop_is_affine s f; assert (forall m1 m2 . (interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) ==> ( interp s (mem_of_heap m1.heap) /\ interp (f (mem_of_heap m1.heap)) (mem_of_heap m2.heap) /\ H.disjoint m1.heap m2.heap /\ H.join m1.heap m2.heap == m.heap )); interp_depends_only_on s; Classical.forall_intro (fun m -> interp_depends_only_on (f m)); assert (forall h1 h2 . (interp s (mem_of_heap h1) /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ H.disjoint h1 h2 /\ H.join h1 h2 == m.heap) ==> ( core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ interp s (core_mem (mem_of_heap h1)) /\ interp s (mem_set_heap m h1) /\ core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ f (mem_set_heap m h1) `equiv` f (mem_of_heap h1) /\ interp (f (mem_set_heap m h1)) (mem_of_heap h2) /\ interp (f (mem_set_heap m h1)) (mem_set_heap m h2) /\ disjoint (mem_set_heap m h1) (mem_set_heap m h2) /\ join (mem_set_heap m h1) (mem_set_heap m h2) == m )); () let h_exists_cong (#a:Type) (p q : a -> slprop) : Lemma (requires (forall x. p x `equiv` q x)) (ensures (h_exists p `equiv` h_exists q)) = equiv_heap_iff_equiv_forall (); H.h_exists_cong p q let intro_h_exists #a x p m = H.intro_h_exists x p (heap_of_mem m) let elim_h_exists (#a:_) (p:a -> slprop) (m:mem) = H.elim_h_exists p (heap_of_mem m) let intro_h_forall (#a:_) (p:a -> slprop) (m:mem) = H.intro_h_forall p (heap_of_mem m) let elim_h_forall (#a:_) (p:a -> slprop) (m:mem) (x:a) = H.elim_h_forall p (heap_of_mem m) x let intro_h_and (p q: slprop) (m:mem) = H.intro_h_and p q (heap_of_mem m) let elim_h_and (p q: slprop) (m:mem) = H.elim_h_and p q (heap_of_mem m) let intro_h_or_left (p q: slprop) (m:mem) = H.intro_h_or_left p q (heap_of_mem m) let intro_h_or_right (p q: slprop) (m:mem) = H.intro_h_or_right p q (heap_of_mem m) let elim_h_or (p q: slprop) (m:mem) = H.elim_h_or p q (heap_of_mem m) let intro_wand (p1 p2: slprop u#a) (m:mem) = introduce (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)) ==> interp (wand p1 p2) m with _. ( assert (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)); H.intro_wand p1 p2 (heap_of_mem m); let h = heap_of_mem m in assert ((forall h1. h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) ==> H.interp (wand p1 p2) h); introduce forall h1. (h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) with ( introduce (h `H.disjoint` h1 /\ H.interp p1 h1) ==> H.interp p2 (H.join h h1) with _. ( assert (h `H.disjoint` h1); let m1 = { ctr = m.ctr; heap = h1; locks = m.locks } in assert (m `disjoint` m1) ) ) ) (** Eliminating a wand by proving a heap that satisfies the LHS **) let elim_wand (p1 p2: slprop u#a) (m:mem) (m1:mem) = H.elim_wand p1 p2 (heap_of_mem m) (heap_of_mem m1) //////////////////////////////////////////////////////////////////////////////// // Preorders and effects //////////////////////////////////////////////////////////////////////////////// module PP = Steel.Preorder let mem_evolves = fun (m0 m1:full_mem) -> H.heap_evolves (heap_of_mem m0) (heap_of_mem m1) /\ m0.ctr <= m1.ctr /\ lock_store_evolves m0.locks m1.locks (** See [Steel.Heap.is_frame_preserving]. We add in [lock_invariants] now *) let preserves_frame (e:inames) (pre post:slprop) (m0 m1:mem) = forall (frame:slprop). interp ((pre `star` frame) `star` locks_invariant e m0) m0 ==> (interp ((post `star` frame) `star` locks_invariant e m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) (** This is a version of MstTot with frame quantified, as part of preserves_frame *) effect MstTotNF (a:Type u#a) (except:inames) (expects:slprop u#1) (provides: a -> slprop u#1) = NMSTTotal.NMSTATETOT a (full_mem u#1) mem_evolves (requires fun m0 -> inames_ok except m0 /\ interp (expects `star` locks_invariant except m0) m0) (ensures fun m0 x m1 -> inames_ok except m1 /\ interp (provides x `star` locks_invariant except m1) m1 /\ preserves_frame except expects (provides x) m0 m1) //////////////////////////////////////////////////////////////////////////////// // Lifting heap actions //////////////////////////////////////////////////////////////////////////////// (** Heap actions come in two equivalent flavors: - one that take an explicit frame as argument (action_with_frame) - and one that quantify over all the frame We therefore define two lift routes: - a direct route for those with explicit frame - via MstTotNF for the rest *) let tot_pre_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = hmem_with_inv_except e fp -> (x:a & hmem_with_inv_except e (fp' x)) let tot_pre_action_nf = tot_pre_action_nf_except S.empty let ac_reasoning_for_m_frame_preserving (p q r:slprop u#a) (m:mem u#a) : Lemma (requires interp ((p `star` q) `star` r) m) (ensures interp (p `star` r) m) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_commutative p q; equiv_extensional_on_star (p `star` q) (q `star` p) r } (q `star` p) `star` r; (equiv) { star_associative q p r } q `star` (p `star` r); }; assert (interp (q `star` (p `star` r)) m); affine_star q (p `star` r) m let is_frame_preserving (#e:inames) (#a:Type u#b) (#fp:slprop u#a) (#fp':a -> slprop u#a) (f:tot_pre_action_nf_except e fp a fp') = forall (frame:slprop u#a) (m0:hmem_with_inv_except e (fp `star` frame)). (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = f:tot_pre_action_nf_except e fp a fp'{ is_frame_preserving f } let tot_action_nf = tot_action_nf_except S.empty let linv e (m:mem) = locks_invariant e m let hheap_of_hmem #fp #e (m:hmem_with_inv_except e fp) : h:H.hheap (fp `star` linv e m) { h `H.free_above_addr` m.ctr} = let h = heap_of_mem m in H.pure_interp (heap_ctr_valid m.ctr (heap_of_mem m)) h; h let hmem_of_hheap #e (#fp0 #fp1:slprop) (m:hmem_with_inv_except e fp0) (h:H.full_hheap (fp1 `star` linv e m) { h `Heap.free_above_addr` m.ctr }) : m1:hmem_with_inv_except e fp1{linv e m `equiv` linv e m1} = let m1 : mem = { m with heap = h } in assert (interp (fp1 `star` linv e m) m1); star_commutative fp1 (linv e m); assert (interp (linv e m `star` fp1) m1); assert (linv e m1 == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); assert (linv e m == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m)); H.pure_interp (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_of_mem m); assert (heap_ctr_valid m1.ctr (heap_of_mem m) <==> heap_ctr_valid m1.ctr (heap_of_mem m1)); H.pure_equiv (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_ctr_valid m1.ctr (heap_of_mem m1)); H.star_congruence (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m)); assert (linv e m `equiv` linv e m1); let _ = equiv_extensional_on_star (linv e m) (linv e m1) fp1 in assert ((linv e m `star` fp1) `equiv` (linv e m1 `star` fp1)); assert (interp (linv e m1 `star` fp1) m1); star_commutative (linv e m1) fp1; assert (interp (fp1 `star` linv e m1) m1); m1 let with_inv_except (m:mem) e (fp:slprop) = interp (fp `star` locks_invariant e m) m #push-options "--warn_error -271" let as_hprop (frame:slprop) (mp:mprop frame) : hp:H.hprop frame{forall m. mp (core_mem m) == hp (heap_of_mem m)} = let f = fun h -> mp (mem_of_heap h) in assert (forall m. mp (core_mem m) == f (heap_of_mem m)); let aux (m0:H.hheap frame) (m1:H.heap{H.disjoint m0 m1}) : Lemma (ensures (mem_of_heap (H.join m0 m1) == join (mem_of_heap m0) (mem_of_heap m1))) [SMTPat ()] = () in f let mprop_preservation_of_hprop_preservation (p:slprop) (m0 m1:mem) : Lemma (requires (forall (hp:H.hprop p). hp (heap_of_mem m0) == hp (heap_of_mem m1))) (ensures (forall (mp:mprop p). mp (core_mem m0) == mp (core_mem m1))) = let aux (mp:mprop p) : Lemma (mp (core_mem m0) == mp (core_mem m1)) [SMTPat()] = assert (as_hprop p mp (heap_of_mem m0) == as_hprop p mp (heap_of_mem m1)) in () let lift_heap_action (#fp:slprop) (#a:Type) (#fp':a -> slprop) (e:inames) ($f:H.action fp a fp') : tot_action_nf_except e fp a fp' = let g : tot_pre_action_nf_except e fp a fp' = fun m -> let h0 = hheap_of_hmem m in let (| x, h' |) = f h0 in (| x, hmem_of_hheap m h' |) in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in let h0 = hheap_of_hmem m0 in let (| x', h1 |) = f h0 in H.action_framing f (linv e m0) h0; assert (x == x'); star_associative fp frame (linv e m0); H.action_framing f (frame `star` linv e m0) h0; assert (H.interp ((fp' x) `star` (frame `star` linv e m0)) h1); star_associative (fp' x) frame (linv e m0); assert (H.interp ((fp' x `star` frame) `star` linv e m0) h1); let h1' : H.hheap ((fp' x `star` frame) `star` linv e m0) = h1 in assert (m1 == hmem_of_hheap m0 h1'); assert (with_inv_except m1 e (fp' x `star` frame)); assert (forall (hp:H.hprop frame). hp h0 == hp h1); mprop_preservation_of_hprop_preservation frame m0 m1; () in assert (is_frame_preserving g); g let frame_preserving_respects_preorder #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (m0:hmem_with_inv_except e fp) : Lemma (let (| x, m1 |) = f m0 in mem_evolves m0 m1) = let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1) = () in H.emp_unit fp; assert (interp (fp `star` linv e m0) m0); H.star_congruence (fp `star` emp) (linv e m0) fp (linv e m0); assert (interp ((fp `star` emp) `star` linv e m0) m0); aux emp m0 let lift_tot_action_nf #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') : MstTotNF a e fp fp' = let m0 = NMSTTotal.get () in let m0' : hmem_with_inv_except e fp = m0 in let r = f m0' in let (| x, m1 |) = r in let m1' : hmem_with_inv_except e (fp' x) = m1 in assert (is_frame_preserving f); assert (m1 == dsnd (f m0)); frame_preserving_respects_preorder f m0; NMSTTotal.put #_ #(mem_evolves) m1; x let lift_tot_action #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get #(full_mem) #_ () in ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); lift_tot_action_nf f (** Now defining the lift for heap actions with explicit frame *) let tot_action_with_frame_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = frame:slprop u#a -> m0:hmem_with_inv_except e (fp `star` frame) -> Pure (x:a & hmem_with_inv_except e (fp' x `star` frame)) (requires True) (ensures fun (| x, m1 |) -> mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_with_frame = tot_action_with_frame_except S.empty let lift_heap_action_with_frame (#fp:slprop u#a) (#a:Type u#b) (#fp':a -> slprop u#a) (e:inames) ($f:H.action_with_frame fp a fp') : tot_action_with_frame_except e fp a fp' = fun frame m0 -> let h0 = hheap_of_hmem m0 in calc (equiv) { fp `star` frame `star` locks_invariant e m0; (equiv) { star_associative fp frame (locks_invariant e m0) } fp `star` (frame `star` locks_invariant e m0); }; assert (H.interp (fp `star` frame `star` locks_invariant e m0) h0); assert (H.interp (fp `star` (frame `star` locks_invariant e m0)) h0); //key: apply the heap action with frame * locks_invariant e m0 let (| x, h1 |) = f (frame `star` locks_invariant e m0) h0 in calc (equiv) { fp' x `star` (frame `star` locks_invariant e m0); (equiv) { star_associative (fp' x) frame (locks_invariant e m0) } fp' x `star` frame `star` locks_invariant e m0; }; assert (H.interp (fp' x `star` (frame `star` locks_invariant e m0)) h1); assert (H.interp (fp' x `star` frame `star` locks_invariant e m0) h1); let m1 = hmem_of_hheap m0 h1 in assert (mem_evolves m0 m1); mprop_preservation_of_hprop_preservation (frame `star` locks_invariant e m0) m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)); (| x, m1 |) let lift_tot_action_with_frame #a #e #fp #fp' ($f:tot_action_with_frame_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in assert (inames_ok e m0); ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); let m0' : hmem_with_inv_except e fp = m0 in let r = f frame m0' in let (| x, m1 |) = r in ac_reasoning_for_m_frame_preserving (fp' x) frame (locks_invariant e m1) m1; assert (interp (fp' x `star` frame `star` locks_invariant e m1) m1); assert (interp (fp' x `star` locks_invariant e m1) m1); let m1' : hmem_with_inv_except e (fp' x) = m1 in NMSTTotal.put #_ #(mem_evolves) m1; x let sel_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.sel_action #a #pcm r v0)) let upd_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.upd_action #a #pcm r v0 v1)) let free_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.free_action #a #pcm r v0)) let split_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.split_action #a #pcm r v0 v1)) let gather_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.gather_action #a #pcm r v0 v1)) let weaken (p q r:slprop) (h:H.hheap (p `star` q) { H.stronger q r }) : H.hheap (p `star` r) = H.weaken p q r h; h let weaken_pure (q r: prop) : Lemma (requires (q ==> r)) (ensures H.stronger (H.pure q) (H.pure r)) = let aux (h:H.heap) : Lemma (ensures (H.interp (H.pure q) h ==> H.interp (H.pure r) h)) [SMTPat ()] = H.pure_interp q h; H.pure_interp r h in () let inc_ctr (#p:slprop) #e (m:hmem_with_inv_except e p) : m':hmem_with_inv_except e p{m'.ctr = m.ctr + 1 /\ H.stronger (linv e m) (linv e m')} = let m' : mem = { m with ctr = m.ctr + 1} in assert (interp (p `star` linv e m) m'); assert (linv e m == lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m)); assert (linv e m' == lock_store_invariant e m.locks `star` ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken_free_above (heap_of_mem m) m.ctr (m.ctr + 1); weaken_pure (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_ctr_valid (m.ctr + 1) (heap_of_mem m)); assert (H.stronger (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m))); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)); H.stronger_star (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken (p `star` lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)) (heap_of_mem m'); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity (m.ctr + 1) (heap_of_mem m)); let m' : hmem_with_inv_except e p = m' in m' let frame_related_mems (fp0 fp1:slprop u#a) e (m0:hmem_with_inv_except e fp0) (m1:hmem_with_inv_except e fp1) = forall (frame:slprop u#a). interp ((fp0 `star` frame) `star` linv e m0) m0 ==> interp ((fp1 `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) let refined_pre_action e (fp0:slprop) (a:Type) (fp1:a -> slprop) = m0:hmem_with_inv_except e fp0 -> Pure (x:a & hmem_with_inv_except e (fp1 x)) (requires True) (ensures fun (| x, m1 |) -> frame_related_mems fp0 (fp1 x) e m0 m1) let refined_pre_action_as_action (#fp0:slprop) (#a:Type) (#fp1:a -> slprop) #e ($f:refined_pre_action e fp0 a fp1) : tot_action_nf_except e fp0 a fp1 = let g : tot_pre_action_nf_except e fp0 a fp1 = fun m -> f m in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp0 `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp1 x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x', m1' |) = g m0 in let (| x, m1 |) = f m0 in assert (x == x' /\ m1 == m1') in g let alloc_action #a #pcm e x = let f : refined_pre_action e emp (ref a pcm) (fun r -> pts_to r x) = fun m0 -> (* NS: 9/29/22 I needed to annotate h : Heap.full_heap, for use with the Core checker which generates a guard for checking the implicit pattern "dot" term in the dependent pair pattern on the next line. That guard expects `h` to be a full_heap, which is it, because it is a projection of m0. However, this is not reflected in `h`'s type. So, the Core checker, which produces a guard for the pat_dot_term in isolation, cannot recheck the term. If we were to fold in the checking of pat_dot_terms and their guards with the rest of the VC, this would work. *) let h : Heap.full_heap = hheap_of_hmem m0 in let (|r, h'|) = H.extend #a #pcm x m0.ctr h in let m' : hmem_with_inv_except e emp = inc_ctr m0 in let h' : H.hheap (pts_to #a #pcm r x `star` linv e m') = weaken _ (linv e m0) (linv e m') h' in let m1 : hmem_with_inv_except e (pts_to #a #pcm r x) = hmem_of_hheap m' h' in assert (forall frame. H.frame_related_heaps h h' emp (pts_to #a #pcm r x) frame true); let aux (frame:slprop) : Lemma (requires interp ((emp `star` frame) `star` linv e m0) m0) (ensures interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) [SMTPat (emp `star` frame)] = star_associative emp frame (linv e m0); assert (H.interp (emp `star` (frame `star` linv e m0)) h); assert (H.interp (pts_to #a #pcm r x `star` (frame `star` linv e m0)) h'); star_associative (pts_to #a #pcm r x) frame (linv e m0); assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m0) h'); assert (H.stronger (linv e m0) (linv e m')); assert (H.equiv (linv e m') (linv e m1)); assert (H.stronger (linv e m0) (linv e m1)); let h' : H.hheap ((pts_to #a #pcm r x `star` frame) `star` linv e m1) = weaken _ (linv e m0) (linv e m1) h' in assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) h'); assert (forall (mp:H.hprop frame). mp h == mp h'); mprop_preservation_of_hprop_preservation frame m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) in assert (frame_related_mems emp (pts_to r x) e m0 m1); (| r, m1 |) in lift_tot_action (refined_pre_action_as_action f) let select_refine #a #p e r x f = lift_tot_action (lift_heap_action e (H.select_refine #a #p r x f)) let upd_gen #a #p e r x y f = lift_tot_action (lift_heap_action e (H.upd_gen_action r x y f)) //////////////////////////////////////////////////////////////////////////////// // witness / recall //////////////////////////////////////////////////////////////////////////////// let witnessed_ref #a #pcm (r:ref a pcm) (fact:property a) (m:full_mem) = H.witnessed_ref #a #pcm r fact (heap_of_mem m) let witnessed_ref_stability #a #pcm (r:ref a pcm) (fact:property a) : Lemma (requires FStar.Preorder.stable fact (Steel.Preorder.preorder_of_pcm pcm)) (ensures FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) = H.witnessed_ref_stability #a #pcm r fact let witnessed (#a:Type u#1) (#pcm:pcm a) (r:ref a pcm) (fact:property a) = W.witnessed _ mem_evolves (witnessed_ref r fact) let rearrange_pqr_prq (p q r:slprop) : Lemma (((p `star` q) `star` r) `equiv` ((p `star` r) `star` q)) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_associative p q r } p `star` (q `star` r); (equiv) { star_commutative q r; star_congruence p (q `star` r) p (r `star` q) } p `star` (r `star` q); (equiv) { star_associative p r q } (p `star` r) `star` q; } let preserves_frame_cong (e:inames) (p q:slprop) (r s:slprop) (m0 m1:mem) : Lemma (requires p `equiv` r /\ q `equiv` s /\ preserves_frame e p q m0 m1) (ensures preserves_frame e r s m0 m1) = let aux0 (p q r s:slprop) : Lemma (requires p `equiv` s) (ensures (((p `star` q) `star` r) `equiv` ((s `star` q) `star` r))) = star_congruence p q s q; star_congruence (p `star` q) r (s `star` q) r in let aux (frame:slprop) : Lemma (requires interp ((r `star` frame) `star` locks_invariant e m0) m0) (ensures interp ((s `star` frame) `star` locks_invariant e m1) m1 /\ interp ((p `star` frame) `star` locks_invariant e m0) m0) [SMTPat (r `star` frame)] = aux0 p frame (locks_invariant e m0) r; aux0 q frame (locks_invariant e m1) s; assert (((p `star` frame) `star` locks_invariant e m0) `equiv` ((r `star` frame) `star` locks_invariant e m0)); assert (interp ((p `star` frame) `star` locks_invariant e m0) m0); assert (interp ((q `star` frame) `star` locks_invariant e m1) m1); assert (((q `star` frame) `star` locks_invariant e m1) `equiv` ((s `star` frame) `star` locks_invariant e m1)); () in () let pure_true_equiv (p:slprop) : Lemma ((p `star` pure True) `equiv` p) = FStar.Classical.forall_intro (pure_star_interp p True); emp_unit p; assert ((p `star` pure True) `equiv` p) let preserves_frame_star_pure (e:inames) (p q:slprop) (r s:prop) (m:mem) : Lemma (requires r /\ s) (ensures preserves_frame e p q m m <==> preserves_frame e (p `star` pure r) (q `star` pure s) m m) = pure_equiv r True; star_congruence p (pure r) p (pure True); pure_equiv s True; star_congruence q (pure s) q (pure True); pure_true_equiv p; pure_true_equiv q; let fwd () : Lemma (requires preserves_frame e p q m m) (ensures preserves_frame e (p `star` pure r) (q `star` pure s) m m) [SMTPat ()] = preserves_frame_cong e p q (p `star` pure r) (q `star` pure s) m m in let bk () : Lemma (requires preserves_frame e (p `star` pure r) (q `star` pure s) m m) (ensures preserves_frame e p q m m) [SMTPat ()] = preserves_frame_cong e (p `star` pure r) (q `star` pure s) p q m m in () let witness (#a:Type) (#pcm:pcm a) (e:inames) (r:erased (ref a pcm)) (fact:stable_property pcm) (v:Ghost.erased a) (_:squash (forall z. compatible pcm v z ==> fact z)) (frame:slprop) : MstTot (witnessed r fact) e (pts_to r v) (fun _ -> pts_to r v) frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in let _ : unit = let hr : H.ref a pcm = r in let v' = H.sel_v hr v (heap_of_mem m0) in assert (interp (H.ptr hr) m0 /\ H.sel #a #pcm hr (heap_of_mem m0) == v'); assert (compatible pcm v v'); assert (fact v'); assert (witnessed_ref r fact m0); witnessed_ref_stability r fact; assert (FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) in let w = NMSTTotal.witness _ mem_evolves (witnessed_ref r fact) in w let recall (#a:Type u#1) (#pcm:pcm a) (#fact:property a) (e:inames) (r:erased (ref a pcm)) (v:Ghost.erased a) (w:witnessed r fact) (frame:slprop) = let m0 = NMSTTotal.get () in NMSTTotal.recall _ mem_evolves (witnessed_ref r fact) w; let hr : H.ref a pcm = r in assert (witnessed_ref r fact m0); let v1 = H.sel_v hr v (heap_of_mem m0) in assert (compatible pcm v v1); assert (H.sel hr (heap_of_mem m0) == v1); assert (fact v1); assert (interp ((pts_to r v `star` frame) `star` locks_invariant e m0) m0); emp_unit ((pts_to r v `star` frame) `star` locks_invariant e m0); pure_star_interp ((pts_to r v `star` frame) `star` locks_invariant e m0) (fact v1) m0; assert (interp (((pts_to r v `star` frame) `star` locks_invariant e m0) `star` pure (fact v1)) m0); rearrange_pqr_prq (pts_to r v `star` frame) (locks_invariant e m0) (pure (fact v1)); assert (interp (((pts_to r v `star` frame) `star` pure (fact v1)) `star` locks_invariant e m0) m0); rearrange_pqr_prq (pts_to r v) frame (pure (fact v1)); star_congruence ((pts_to r v `star` frame) `star` pure (fact v1)) (locks_invariant e m0) ((pts_to r v `star` pure (fact v1)) `star` frame) (locks_invariant e m0); Ghost.hide v1 let iname_for_p_mem (i:iname) (p:slprop) : W.s_predicate mem = fun m -> iname_for_p i p m.locks let iname_for_p_stable (i:iname) (p:slprop) : Lemma (W.stable full_mem mem_evolves (iname_for_p_mem i p)) = () let ( >--> ) (i:iname) (p:slprop) : Type0 = W.witnessed full_mem mem_evolves (iname_for_p_mem i p) let hmem_with_inv_equiv e (m:mem) (p:slprop) : Lemma (interp (p `star` linv e m) m <==> interp (p `star` lock_store_invariant e m.locks) m /\ heap_ctr_valid m.ctr (heap_of_mem m)) = calc (<==>) { interp (p `star` linv e m) m; (<==>) { H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) } interp ((p `star` lock_store_invariant e m.locks) `star` ctr_validity m.ctr (heap_of_mem m)) m; (<==>) { H.pure_star_interp (p `star` lock_store_invariant e m.locks) (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_of_mem m) } interp ((p `star` lock_store_invariant e m.locks) `star` emp) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); (<==>) { H.emp_unit (p `star` lock_store_invariant e m.locks) } interp (p `star` lock_store_invariant e m.locks) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); } let new_invariant_tot_action (e:inames) (p:slprop) (m0:hmem_with_inv_except e p{ e `inames_in` m0.locks }) : Pure (iname & hmem_with_inv_except e emp) (requires True) (ensures fun (i, m1) -> iname_for_p_mem i p m1 /\ frame_related_mems p emp e m0 m1 /\ mem_evolves m0 m1) = let (| i, l1 |) = extend_lock_store e m0.locks p in let m1 = { m0 with locks = l1 } in assert (lock_store_invariant e m1.locks == p `star` lock_store_invariant e m0.locks); calc (equiv) { linv e m1; (equiv) {} (lock_store_invariant e m1.locks `star` ctr_validity m1.ctr (heap_of_mem m1)); (equiv) {} ((p `star` lock_store_invariant e m0.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); (equiv) { H.star_associative p (lock_store_invariant e m0.locks) (ctr_validity m1.ctr (heap_of_mem m1)) } (p `star` (lock_store_invariant e m0.locks `star` ctr_validity m1.ctr (heap_of_mem m1))); (equiv) { } (p `star` linv e m0); }; assert (iname_for_p_mem i p m1); assert (lock_store_evolves m0.locks l1); assert (mem_evolves m0 m1); hmem_with_inv_equiv e m0 p; assert (interp (p `star` lock_store_invariant e m0.locks) m1); assert (interp (lock_store_invariant e m1.locks) m1); H.emp_unit (lock_store_invariant e m1.locks); H.star_commutative (lock_store_invariant e m1.locks) emp; assert (interp (emp `star` lock_store_invariant e m1.locks) m1); hmem_with_inv_equiv e m1 emp; let m1 : hmem_with_inv_except e emp = m1 in let aux (frame:slprop) : Lemma (requires interp ((p `star` frame) `star` linv e m0) m0) (ensures interp ((emp `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) <==> mp (core_mem m1))) [SMTPat (p `star` frame)] = assert (interp ((p `star` frame) `star` linv e m0) m1); calc (equiv) { ((p `star` frame) `star` linv e m0); (equiv) { H.star_commutative p frame; H.star_congruence (p `star` frame) (linv e m0) (frame `star` p) (linv e m0); H.star_associative frame p (linv e m0) } (frame `star` (p `star` linv e m0)); (equiv) { H.star_congruence frame (p `star` linv e m0) frame (linv e m1) } (frame `star` linv e m1); (equiv) { H.emp_unit (frame `star` linv e m1); H.star_commutative (frame `star` linv e m1) emp; H.star_associative emp frame (linv e m1) } ((emp `star` frame) `star` linv e m1); }; assert (interp ((emp `star` frame) `star` linv e m1) m1) in assert (frame_related_mems p emp e m0 m1); ( i, m1 ) let name_is_ok (i:iname) (m0:full_mem u#1) : prop = i < List.Tot.length m0.locks let witnessed_name_is_ok (i:iname) = W.witnessed full_mem mem_evolves (name_is_ok i) let pre_inv = i:erased iname & witnessed_name_is_ok i

{ "checked_file": "/", "dependencies": [ "Steel.Preorder.fst.checked", "Steel.Heap.fsti.checked", "prims.fst.checked", "FStar.Witnessed.Core.fsti.checked", "FStar.Set.fsti.checked", "FStar.Preorder.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.PCM.fst.checked", "FStar.NMSTTotal.fst.checked", "FStar.List.Tot.fst.checked", "FStar.IndefiniteDescription.fsti.checked", "FStar.Ghost.fsti.checked", "FStar.FunctionalExtensionality.fsti.checked", "FStar.Classical.Sugar.fsti.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Steel.Memory.fst" }

[ { "abbrev": true, "full_module": "Steel.Preorder", "short_module": "PP" }, { "abbrev": true, "full_module": "FStar.Witnessed.Core", "short_module": "W" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": true, "full_module": "Steel.Heap", "short_module": "H" }, { "abbrev": false, "full_module": "FStar.FunctionalExtensionality", "short_module": null }, { "abbrev": true, "full_module": "FStar.FunctionalExtensionality", "short_module": "F" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": false, "full_module": "FStar.PCM", "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

p: Steel.Memory.slprop -> Type0

Prims.Tot

[ "total" ]

[]

[ "Steel.Memory.slprop", "FStar.Pervasives.dtuple3", "FStar.Ghost.erased", "Steel.Memory.iname", "Steel.Memory.witnessed_name_is_ok", "FStar.Ghost.reveal", "Steel.Memory.op_Greater_Subtraction_Subtraction_Greater" ]

[]

false

true

let inv (p: slprop u#1) =

i: erased iname & witnessed_name_is_ok i & (i >--> p)

false

Steel.Memory.fst

Steel.Memory.split_action

val split_action (#a:Type u#1) (#pcm:pcm a) (e:inames) (r:ref a pcm) (v0:FStar.Ghost.erased a) (v1:FStar.Ghost.erased a{composable pcm v0 v1}) : action_except unit e (pts_to r (v0 `op pcm` v1)) (fun _ -> pts_to r v0 `star` pts_to r v1)

let split_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.split_action #a #pcm r v0 v1))

{ "file_name": "lib/steel/Steel.Memory.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 73, "end_line": 853, "start_col": 0, "start_line": 852 }

(* 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.Memory module F = FStar.FunctionalExtensionality open FStar.FunctionalExtensionality open FStar.PCM module H = Steel.Heap noeq type lock_state : Type u#(a + 1) = | Invariant : inv:H.slprop u#a -> lock_state let lock_store : Type u#(a+1) = list (lock_state u#a) noeq type mem : Type u#(a + 1) = { ctr: nat; heap: H.heap u#a; locks: lock_store u#a; } let heap_of_mem (x:mem) : H.heap = x.heap let mem_of_heap (h:H.heap) : mem = { ctr = 0; heap = h; locks = [] } let mem_set_heap (m:mem) (h:H.heap) : mem = { ctr = m.ctr; heap = h; locks = m.locks; } let core_mem (m:mem) : mem = mem_of_heap (heap_of_mem m) let core_mem_invol m = () let disjoint (m0 m1:mem u#h) : prop = m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks let disjoint_sym m0 m1 = () let join m0 m1 = { ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = m0.locks } let join_commutative m0 m1 = H.join_commutative m0.heap m1.heap let disjoint_join m0 m1 m2 = H.disjoint_join m0.heap m1.heap m2.heap let join_associative m0 m1 m2 = H.join_associative m0.heap m1.heap m2.heap let slprop = H.slprop let interp p m = H.interp p m.heap let equiv p1 p2 = forall m. interp p1 m <==> interp p2 m let slprop_extensionality p q = assert (forall m. interp p m <==> interp q m); let aux (h:H.heap) : Lemma (H.interp p h <==> H.interp q h) [SMTPat (H.interp p h)] = let m : mem = { ctr = 0; heap = h; locks = [] } in assert (interp p m <==> interp q m) in assert (forall h. H.interp p h <==> H.interp q h); Steel.Heap.slprop_extensionality p q let reveal_equiv p1 p2 = () let core_ref = H.core_ref let core_ref_null = H.core_ref_null let core_ref_is_null r = H.core_ref_is_null r let emp : slprop u#a = H.emp let pure = H.pure let pts_to = H.pts_to let h_and = H.h_and let h_or = H.h_or let star = H.star let wand = H.wand let h_exists = H.h_exists let h_forall = H.h_forall //////////////////////////////////////////////////////////////////////////////// //properties of equiv //////////////////////////////////////////////////////////////////////////////// let equiv_symmetric (p1 p2:slprop u#a) = H.equiv_symmetric p1 p2 #push-options "--warn_error -271" let equiv_heap_iff_equiv (p1 p2:slprop u#a) : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat (equiv p1 p2)] = let aux_lr () : Lemma (requires H.equiv p1 p2) (ensures equiv p1 p2) [SMTPat ()] = () in let aux_rl_helper1 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p1 h) (ensures H.interp p2 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl_helper2 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p2 h) (ensures H.interp p1 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl () : Lemma (requires equiv p1 p2) (ensures H.equiv p1 p2) [SMTPat ()] = () in () let equiv_heap_iff_equiv_forall () : Lemma (ensures (forall p1 p2. H.equiv p1 p2 <==> equiv p1 p2)) = let aux p1 p2 : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat ()] = equiv_heap_iff_equiv p1 p2 in () #pop-options let equiv_extensional_on_star (p1 p2 p3:slprop u#a) = equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3 let emp_unit p = H.emp_unit p let intro_emp m = H.intro_emp (heap_of_mem m) let pure_equiv p q = H.pure_equiv p q let pure_interp q m = H.pure_interp q (heap_of_mem m) let pure_star_interp p q m = H.pure_star_interp p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// //pts_to //////////////////////////////////////////////////////////////////////////////// let pts_to_compatible #a #pcm x v0 v1 m = H.pts_to_compatible #a #pcm x v0 v1 (heap_of_mem m) let pts_to_compatible_equiv #a #pcm x v0 v1 = H.pts_to_compatible_equiv #a #pcm x v0 v1 let pts_to_not_null #a #pcm x v m = H.pts_to_not_null #a #pcm x v (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // star //////////////////////////////////////////////////////////////////////////////// let intro_star p q mp mq = H.intro_star p q (heap_of_mem mp) (heap_of_mem mq) let elim_star p q m = let h = heap_of_mem m in H.elim_star p q h; assert (exists hl hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr); let hl = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hl -> exists hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let hr = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hr -> H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let ml = mem_set_heap m hl in let mr = mem_set_heap m hr in assert (disjoint ml mr); assert (m == join ml mr); assert (interp p ml); assert (interp q mr); () let interp_star (p q: slprop) (m: mem) : Lemma (interp (p `star` q) m <==> (exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m)) = let left = interp (p `star` q) m in let right = exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m in let f () : Lemma (requires left) (ensures right) = elim_star p q m in let g () : Lemma (requires right) (ensures left) = Classical.exists_elim left #_ #(fun mp -> exists (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mp -> Classical.exists_elim left #_ #(fun mq -> disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mq -> intro_star p q mp mq ) ) in Classical.move_requires f (); Classical.move_requires g () let star_commutative (p1 p2:slprop) = H.star_commutative p1 p2 let star_associative (p1 p2 p3:slprop) = H.star_associative p1 p2 p3 let star_congruence (p1 p2 p3 p4:slprop) = equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4 let affine_star (p q:slprop) (m:mem) = H.affine_star p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // Invariants on the lock store //////////////////////////////////////////////////////////////////////////////// let iname = nat module S = FStar.Set module L = FStar.List.Tot module W = FStar.Witnessed.Core let rec lock_store_invariant (e:inames) (l:lock_store u#a) : slprop u#a = let current_addr = L.length l - 1 in match l with | [] -> emp | Invariant p :: tl -> if current_addr `S.mem` e then lock_store_invariant e tl else p `star` lock_store_invariant e tl let lock_i (i:iname) (l:lock_store { i < L.length l }) = let ix = L.length l - i - 1 in L.index l ix let iname_for_p (i:iname) (p:slprop) : W.s_predicate lock_store = fun l -> i < L.length l /\ (lock_i i l).inv == p let lock_store_evolves : FStar.Preorder.preorder lock_store = fun (l1 l2 : lock_store) -> L.length l2 >= L.length l1 /\ (forall (i:nat{i < L.length l1}). (lock_i i l1).inv == (lock_i i l2).inv) let inames_in (e:inames) (l:lock_store) : prop = forall i. Set.mem i e ==> i < L.length l let inames_ok e m = inames_in e m.locks let inames_ok_empty m = () let extend_lock_store (e:inames) (l:lock_store{e `inames_in` l}) (p:slprop) : i:iname & l':lock_store { lock_store_invariant e l' == p `star` lock_store_invariant e l /\ iname_for_p i p l' } = (| L.length l, Invariant p :: l |) let set_add (i:iname) (s:inames) = Set.union (Set.singleton i) s let rec move_invariant (e:inames) (l:lock_store) (p:slprop) (i:iname{iname_for_p i p l /\ ~(i `Set.mem` e)}) : Lemma (H.equiv (lock_store_invariant e l) (p `star` lock_store_invariant (set_add i e) l)) = let rec aux (i:iname) (m:lock_store) : Lemma (requires i >= L.length m) (ensures (lock_store_invariant e m `H.equiv` lock_store_invariant (set_add i e) m)) = match m with | [] -> () | Invariant p::tl -> aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl) in let current_addr = L.length l - 1 in match l with | [] -> () | Invariant q::tl -> if i = current_addr then begin assert (lock_store_invariant e l == p `star` lock_store_invariant e tl); aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl); () end else begin move_invariant e tl p i; assert (lock_store_invariant e tl `equiv` (p `star` lock_store_invariant (set_add i e) tl)); H.star_congruence q (lock_store_invariant e tl) q (p `star` lock_store_invariant (set_add i e) tl); if Set.mem current_addr e then () else begin let r = lock_store_invariant (set_add i e) tl in assert (lock_store_invariant e l `equiv` (q `star` (p `star` r))); H.star_associative q p r; H.star_commutative q p; H.star_congruence (q `star` p) r (p `star` q) r; H.star_associative p q r end end let heap_ctr_valid (ctr:nat) (h:H.heap u#a) : prop = h `H.free_above_addr` ctr let ctr_validity (ctr:nat) (h:H.heap) : slprop = H.pure (heap_ctr_valid ctr h) let locks_invariant (e:inames) (m:mem u#a) : slprop u#a = lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m) let full_mem_pred (m:mem) = H.full_heap_pred (heap_of_mem m) (***** Following lemmas are needed in Steel.Effect *****) let core_mem_interp (hp:slprop u#a) (m:mem u#a) = () let interp_depends_only_on (hp:slprop u#a) = H.interp_depends_only_on hp let a_mem_prop_as_a_heap_prop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (H.a_heap_prop u#a) = let g (h: H.heap u#a) : Tot prop = interp sl (mem_of_heap h) /\ f (mem_of_heap h) in let phi0 (h0 h1: H.heap u#a) : Lemma (requires (g h0 /\ H.disjoint h0 h1)) (ensures (g h0 /\ H.disjoint h0 h1 /\ g (H.join h0 h1))) = assert (mem_of_heap (H.join h0 h1) == mem_of_heap h0 `join` mem_of_heap h1); interp_depends_only_on sl in let phi1 (h0 h1: H.heap u#a) : Lemma (ensures ((g h0 /\ H.disjoint h0 h1) ==> g (H.join h0 h1))) = Classical.move_requires (phi0 h0) h1 in Classical.forall_intro_2 phi1; g let refine_slprop sl f = H.as_slprop (a_mem_prop_as_a_heap_prop sl f) let interp_refine_slprop sl f m = assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_mem m)) let dep_hprop (s: slprop) (f: (hmem s -> Tot slprop)) (h: H.heap) : Tot prop = exists (h1: H.heap) . exists (h2: H.heap) . interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 let dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq' : squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h')) = let p2 (h h1 h2: H.heap) : Tot prop = interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 in let p1 (h h1: H.heap) : Tot prop = (exists h2 . p2 h h1 h2) in let h1 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p1 h) in let h2 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p2 h h1) in H.disjoint_join h' h1 h2; assert (H.disjoint h2 h'); let h2' = H.join h2 h' in H.join_commutative h2 h' ; assert (h2' == H.join h' h2); assert (H.disjoint h1 h2'); assert (mem_of_heap h2' == mem_of_heap h2 `join` mem_of_heap h'); interp_depends_only_on (f (mem_of_heap h1)); assert (interp (f (mem_of_heap h1)) (mem_of_heap h2')); H.join_commutative h1 h2; H.join_associative h' h2 h1; H.join_commutative h' h; H.join_commutative h2' h1; assert (H.join h h' == h1 `H.join` h2') let impl_intro_gen (#p: Type0) (#q: Type0) ($prf: (squash p -> Lemma (q ))) : Lemma (p ==> q) = Classical.impl_intro_gen #p #(fun _ -> q) prf let dep_hprop_is_affine1 (s: slprop) (f: (hmem s -> Tot slprop)) (h0 h1: H.heap) : Lemma ((dep_hprop s f h0 /\ H.disjoint h0 h1) ==> (H.disjoint h0 h1 /\ dep_hprop s f (H.join h0 h1))) = impl_intro_gen (dep_hprop_is_affine0 s f h0 h1) let dep_hprop_is_affine (s: slprop) (f: (hmem s -> Tot slprop)) : Lemma (H.heap_prop_is_affine (dep_hprop s f)) = Classical.forall_intro_2 (dep_hprop_is_affine1 s f) let sdep (s: slprop) (f: (hmem s -> Tot slprop)) : Tot slprop = dep_hprop_is_affine s f; H.as_slprop (dep_hprop s f) let interp_sdep (s: slprop) (f: (hmem s -> Tot slprop)) (m: mem) : Lemma (requires (dep_slprop_is_affine s f)) (ensures ( interp (sdep s f) m <==> (exists m1 m2 . interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) )) = dep_hprop_is_affine s f; assert (forall m1 m2 . (interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) ==> ( interp s (mem_of_heap m1.heap) /\ interp (f (mem_of_heap m1.heap)) (mem_of_heap m2.heap) /\ H.disjoint m1.heap m2.heap /\ H.join m1.heap m2.heap == m.heap )); interp_depends_only_on s; Classical.forall_intro (fun m -> interp_depends_only_on (f m)); assert (forall h1 h2 . (interp s (mem_of_heap h1) /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ H.disjoint h1 h2 /\ H.join h1 h2 == m.heap) ==> ( core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ interp s (core_mem (mem_of_heap h1)) /\ interp s (mem_set_heap m h1) /\ core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ f (mem_set_heap m h1) `equiv` f (mem_of_heap h1) /\ interp (f (mem_set_heap m h1)) (mem_of_heap h2) /\ interp (f (mem_set_heap m h1)) (mem_set_heap m h2) /\ disjoint (mem_set_heap m h1) (mem_set_heap m h2) /\ join (mem_set_heap m h1) (mem_set_heap m h2) == m )); () let h_exists_cong (#a:Type) (p q : a -> slprop) : Lemma (requires (forall x. p x `equiv` q x)) (ensures (h_exists p `equiv` h_exists q)) = equiv_heap_iff_equiv_forall (); H.h_exists_cong p q let intro_h_exists #a x p m = H.intro_h_exists x p (heap_of_mem m) let elim_h_exists (#a:_) (p:a -> slprop) (m:mem) = H.elim_h_exists p (heap_of_mem m) let intro_h_forall (#a:_) (p:a -> slprop) (m:mem) = H.intro_h_forall p (heap_of_mem m) let elim_h_forall (#a:_) (p:a -> slprop) (m:mem) (x:a) = H.elim_h_forall p (heap_of_mem m) x let intro_h_and (p q: slprop) (m:mem) = H.intro_h_and p q (heap_of_mem m) let elim_h_and (p q: slprop) (m:mem) = H.elim_h_and p q (heap_of_mem m) let intro_h_or_left (p q: slprop) (m:mem) = H.intro_h_or_left p q (heap_of_mem m) let intro_h_or_right (p q: slprop) (m:mem) = H.intro_h_or_right p q (heap_of_mem m) let elim_h_or (p q: slprop) (m:mem) = H.elim_h_or p q (heap_of_mem m) let intro_wand (p1 p2: slprop u#a) (m:mem) = introduce (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)) ==> interp (wand p1 p2) m with _. ( assert (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)); H.intro_wand p1 p2 (heap_of_mem m); let h = heap_of_mem m in assert ((forall h1. h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) ==> H.interp (wand p1 p2) h); introduce forall h1. (h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) with ( introduce (h `H.disjoint` h1 /\ H.interp p1 h1) ==> H.interp p2 (H.join h h1) with _. ( assert (h `H.disjoint` h1); let m1 = { ctr = m.ctr; heap = h1; locks = m.locks } in assert (m `disjoint` m1) ) ) ) (** Eliminating a wand by proving a heap that satisfies the LHS **) let elim_wand (p1 p2: slprop u#a) (m:mem) (m1:mem) = H.elim_wand p1 p2 (heap_of_mem m) (heap_of_mem m1) //////////////////////////////////////////////////////////////////////////////// // Preorders and effects //////////////////////////////////////////////////////////////////////////////// module PP = Steel.Preorder let mem_evolves = fun (m0 m1:full_mem) -> H.heap_evolves (heap_of_mem m0) (heap_of_mem m1) /\ m0.ctr <= m1.ctr /\ lock_store_evolves m0.locks m1.locks (** See [Steel.Heap.is_frame_preserving]. We add in [lock_invariants] now *) let preserves_frame (e:inames) (pre post:slprop) (m0 m1:mem) = forall (frame:slprop). interp ((pre `star` frame) `star` locks_invariant e m0) m0 ==> (interp ((post `star` frame) `star` locks_invariant e m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) (** This is a version of MstTot with frame quantified, as part of preserves_frame *) effect MstTotNF (a:Type u#a) (except:inames) (expects:slprop u#1) (provides: a -> slprop u#1) = NMSTTotal.NMSTATETOT a (full_mem u#1) mem_evolves (requires fun m0 -> inames_ok except m0 /\ interp (expects `star` locks_invariant except m0) m0) (ensures fun m0 x m1 -> inames_ok except m1 /\ interp (provides x `star` locks_invariant except m1) m1 /\ preserves_frame except expects (provides x) m0 m1) //////////////////////////////////////////////////////////////////////////////// // Lifting heap actions //////////////////////////////////////////////////////////////////////////////// (** Heap actions come in two equivalent flavors: - one that take an explicit frame as argument (action_with_frame) - and one that quantify over all the frame We therefore define two lift routes: - a direct route for those with explicit frame - via MstTotNF for the rest *) let tot_pre_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = hmem_with_inv_except e fp -> (x:a & hmem_with_inv_except e (fp' x)) let tot_pre_action_nf = tot_pre_action_nf_except S.empty let ac_reasoning_for_m_frame_preserving (p q r:slprop u#a) (m:mem u#a) : Lemma (requires interp ((p `star` q) `star` r) m) (ensures interp (p `star` r) m) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_commutative p q; equiv_extensional_on_star (p `star` q) (q `star` p) r } (q `star` p) `star` r; (equiv) { star_associative q p r } q `star` (p `star` r); }; assert (interp (q `star` (p `star` r)) m); affine_star q (p `star` r) m let is_frame_preserving (#e:inames) (#a:Type u#b) (#fp:slprop u#a) (#fp':a -> slprop u#a) (f:tot_pre_action_nf_except e fp a fp') = forall (frame:slprop u#a) (m0:hmem_with_inv_except e (fp `star` frame)). (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = f:tot_pre_action_nf_except e fp a fp'{ is_frame_preserving f } let tot_action_nf = tot_action_nf_except S.empty let linv e (m:mem) = locks_invariant e m let hheap_of_hmem #fp #e (m:hmem_with_inv_except e fp) : h:H.hheap (fp `star` linv e m) { h `H.free_above_addr` m.ctr} = let h = heap_of_mem m in H.pure_interp (heap_ctr_valid m.ctr (heap_of_mem m)) h; h let hmem_of_hheap #e (#fp0 #fp1:slprop) (m:hmem_with_inv_except e fp0) (h:H.full_hheap (fp1 `star` linv e m) { h `Heap.free_above_addr` m.ctr }) : m1:hmem_with_inv_except e fp1{linv e m `equiv` linv e m1} = let m1 : mem = { m with heap = h } in assert (interp (fp1 `star` linv e m) m1); star_commutative fp1 (linv e m); assert (interp (linv e m `star` fp1) m1); assert (linv e m1 == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); assert (linv e m == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m)); H.pure_interp (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_of_mem m); assert (heap_ctr_valid m1.ctr (heap_of_mem m) <==> heap_ctr_valid m1.ctr (heap_of_mem m1)); H.pure_equiv (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_ctr_valid m1.ctr (heap_of_mem m1)); H.star_congruence (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m)); assert (linv e m `equiv` linv e m1); let _ = equiv_extensional_on_star (linv e m) (linv e m1) fp1 in assert ((linv e m `star` fp1) `equiv` (linv e m1 `star` fp1)); assert (interp (linv e m1 `star` fp1) m1); star_commutative (linv e m1) fp1; assert (interp (fp1 `star` linv e m1) m1); m1 let with_inv_except (m:mem) e (fp:slprop) = interp (fp `star` locks_invariant e m) m #push-options "--warn_error -271" let as_hprop (frame:slprop) (mp:mprop frame) : hp:H.hprop frame{forall m. mp (core_mem m) == hp (heap_of_mem m)} = let f = fun h -> mp (mem_of_heap h) in assert (forall m. mp (core_mem m) == f (heap_of_mem m)); let aux (m0:H.hheap frame) (m1:H.heap{H.disjoint m0 m1}) : Lemma (ensures (mem_of_heap (H.join m0 m1) == join (mem_of_heap m0) (mem_of_heap m1))) [SMTPat ()] = () in f let mprop_preservation_of_hprop_preservation (p:slprop) (m0 m1:mem) : Lemma (requires (forall (hp:H.hprop p). hp (heap_of_mem m0) == hp (heap_of_mem m1))) (ensures (forall (mp:mprop p). mp (core_mem m0) == mp (core_mem m1))) = let aux (mp:mprop p) : Lemma (mp (core_mem m0) == mp (core_mem m1)) [SMTPat()] = assert (as_hprop p mp (heap_of_mem m0) == as_hprop p mp (heap_of_mem m1)) in () let lift_heap_action (#fp:slprop) (#a:Type) (#fp':a -> slprop) (e:inames) ($f:H.action fp a fp') : tot_action_nf_except e fp a fp' = let g : tot_pre_action_nf_except e fp a fp' = fun m -> let h0 = hheap_of_hmem m in let (| x, h' |) = f h0 in (| x, hmem_of_hheap m h' |) in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in let h0 = hheap_of_hmem m0 in let (| x', h1 |) = f h0 in H.action_framing f (linv e m0) h0; assert (x == x'); star_associative fp frame (linv e m0); H.action_framing f (frame `star` linv e m0) h0; assert (H.interp ((fp' x) `star` (frame `star` linv e m0)) h1); star_associative (fp' x) frame (linv e m0); assert (H.interp ((fp' x `star` frame) `star` linv e m0) h1); let h1' : H.hheap ((fp' x `star` frame) `star` linv e m0) = h1 in assert (m1 == hmem_of_hheap m0 h1'); assert (with_inv_except m1 e (fp' x `star` frame)); assert (forall (hp:H.hprop frame). hp h0 == hp h1); mprop_preservation_of_hprop_preservation frame m0 m1; () in assert (is_frame_preserving g); g let frame_preserving_respects_preorder #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (m0:hmem_with_inv_except e fp) : Lemma (let (| x, m1 |) = f m0 in mem_evolves m0 m1) = let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1) = () in H.emp_unit fp; assert (interp (fp `star` linv e m0) m0); H.star_congruence (fp `star` emp) (linv e m0) fp (linv e m0); assert (interp ((fp `star` emp) `star` linv e m0) m0); aux emp m0 let lift_tot_action_nf #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') : MstTotNF a e fp fp' = let m0 = NMSTTotal.get () in let m0' : hmem_with_inv_except e fp = m0 in let r = f m0' in let (| x, m1 |) = r in let m1' : hmem_with_inv_except e (fp' x) = m1 in assert (is_frame_preserving f); assert (m1 == dsnd (f m0)); frame_preserving_respects_preorder f m0; NMSTTotal.put #_ #(mem_evolves) m1; x let lift_tot_action #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get #(full_mem) #_ () in ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); lift_tot_action_nf f (** Now defining the lift for heap actions with explicit frame *) let tot_action_with_frame_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = frame:slprop u#a -> m0:hmem_with_inv_except e (fp `star` frame) -> Pure (x:a & hmem_with_inv_except e (fp' x `star` frame)) (requires True) (ensures fun (| x, m1 |) -> mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_with_frame = tot_action_with_frame_except S.empty let lift_heap_action_with_frame (#fp:slprop u#a) (#a:Type u#b) (#fp':a -> slprop u#a) (e:inames) ($f:H.action_with_frame fp a fp') : tot_action_with_frame_except e fp a fp' = fun frame m0 -> let h0 = hheap_of_hmem m0 in calc (equiv) { fp `star` frame `star` locks_invariant e m0; (equiv) { star_associative fp frame (locks_invariant e m0) } fp `star` (frame `star` locks_invariant e m0); }; assert (H.interp (fp `star` frame `star` locks_invariant e m0) h0); assert (H.interp (fp `star` (frame `star` locks_invariant e m0)) h0); //key: apply the heap action with frame * locks_invariant e m0 let (| x, h1 |) = f (frame `star` locks_invariant e m0) h0 in calc (equiv) { fp' x `star` (frame `star` locks_invariant e m0); (equiv) { star_associative (fp' x) frame (locks_invariant e m0) } fp' x `star` frame `star` locks_invariant e m0; }; assert (H.interp (fp' x `star` (frame `star` locks_invariant e m0)) h1); assert (H.interp (fp' x `star` frame `star` locks_invariant e m0) h1); let m1 = hmem_of_hheap m0 h1 in assert (mem_evolves m0 m1); mprop_preservation_of_hprop_preservation (frame `star` locks_invariant e m0) m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)); (| x, m1 |) let lift_tot_action_with_frame #a #e #fp #fp' ($f:tot_action_with_frame_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in assert (inames_ok e m0); ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); let m0' : hmem_with_inv_except e fp = m0 in let r = f frame m0' in let (| x, m1 |) = r in ac_reasoning_for_m_frame_preserving (fp' x) frame (locks_invariant e m1) m1; assert (interp (fp' x `star` frame `star` locks_invariant e m1) m1); assert (interp (fp' x `star` locks_invariant e m1) m1); let m1' : hmem_with_inv_except e (fp' x) = m1 in NMSTTotal.put #_ #(mem_evolves) m1; x let sel_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.sel_action #a #pcm r v0)) let upd_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.upd_action #a #pcm r v0 v1)) let free_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.free_action #a #pcm r v0))

{ "checked_file": "/", "dependencies": [ "Steel.Preorder.fst.checked", "Steel.Heap.fsti.checked", "prims.fst.checked", "FStar.Witnessed.Core.fsti.checked", "FStar.Set.fsti.checked", "FStar.Preorder.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.PCM.fst.checked", "FStar.NMSTTotal.fst.checked", "FStar.List.Tot.fst.checked", "FStar.IndefiniteDescription.fsti.checked", "FStar.Ghost.fsti.checked", "FStar.FunctionalExtensionality.fsti.checked", "FStar.Classical.Sugar.fsti.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Steel.Memory.fst" }

[ { "abbrev": true, "full_module": "Steel.Preorder", "short_module": "PP" }, { "abbrev": true, "full_module": "FStar.Witnessed.Core", "short_module": "W" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": true, "full_module": "Steel.Heap", "short_module": "H" }, { "abbrev": false, "full_module": "FStar.FunctionalExtensionality", "short_module": null }, { "abbrev": true, "full_module": "FStar.FunctionalExtensionality", "short_module": "F" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": false, "full_module": "FStar.PCM", "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

e: Steel.Memory.inames -> r: Steel.Memory.ref a pcm -> v0: FStar.Ghost.erased a -> v1: FStar.Ghost.erased a {FStar.PCM.composable pcm (FStar.Ghost.reveal v0) (FStar.Ghost.reveal v1)} -> Steel.Memory.action_except Prims.unit e (Steel.Memory.pts_to r (FStar.PCM.op pcm (FStar.Ghost.reveal v0) (FStar.Ghost.reveal v1))) (fun _ -> Steel.Memory.star (Steel.Memory.pts_to r (FStar.Ghost.reveal v0)) (Steel.Memory.pts_to r (FStar.Ghost.reveal v1)))

Prims.Tot

[ "total" ]

[]

[ "FStar.PCM.pcm", "Steel.Memory.inames", "Steel.Memory.ref", "FStar.Ghost.erased", "FStar.PCM.composable", "FStar.Ghost.reveal", "Steel.Memory.lift_tot_action", "Prims.unit", "Steel.Heap.pts_to", "FStar.PCM.op", "Steel.Heap.star", "Steel.Memory.slprop", "Steel.Memory.lift_heap_action", "Steel.Heap.split_action", "Steel.Memory.action_except", "Steel.Memory.pts_to", "Steel.Memory.star" ]

[]

false

let split_action #a #pcm e r v0 v1 =

lift_tot_action (lift_heap_action e (H.split_action #a #pcm r v0 v1))

false

Steel.Memory.fst

Steel.Memory.free_action

val free_action (#a:Type u#1) (#pcm:pcm a) (e:inames) (r:ref a pcm) (x:FStar.Ghost.erased a{FStar.PCM.exclusive pcm x /\ pcm.refine pcm.FStar.PCM.p.one}) : action_except unit e (pts_to r x) (fun _ -> pts_to r pcm.FStar.PCM.p.one)

let free_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.free_action #a #pcm r v0))

{ "file_name": "lib/steel/Steel.Memory.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 69, "end_line": 850, "start_col": 0, "start_line": 849 }

(* 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.Memory module F = FStar.FunctionalExtensionality open FStar.FunctionalExtensionality open FStar.PCM module H = Steel.Heap noeq type lock_state : Type u#(a + 1) = | Invariant : inv:H.slprop u#a -> lock_state let lock_store : Type u#(a+1) = list (lock_state u#a) noeq type mem : Type u#(a + 1) = { ctr: nat; heap: H.heap u#a; locks: lock_store u#a; } let heap_of_mem (x:mem) : H.heap = x.heap let mem_of_heap (h:H.heap) : mem = { ctr = 0; heap = h; locks = [] } let mem_set_heap (m:mem) (h:H.heap) : mem = { ctr = m.ctr; heap = h; locks = m.locks; } let core_mem (m:mem) : mem = mem_of_heap (heap_of_mem m) let core_mem_invol m = () let disjoint (m0 m1:mem u#h) : prop = m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks let disjoint_sym m0 m1 = () let join m0 m1 = { ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = m0.locks } let join_commutative m0 m1 = H.join_commutative m0.heap m1.heap let disjoint_join m0 m1 m2 = H.disjoint_join m0.heap m1.heap m2.heap let join_associative m0 m1 m2 = H.join_associative m0.heap m1.heap m2.heap let slprop = H.slprop let interp p m = H.interp p m.heap let equiv p1 p2 = forall m. interp p1 m <==> interp p2 m let slprop_extensionality p q = assert (forall m. interp p m <==> interp q m); let aux (h:H.heap) : Lemma (H.interp p h <==> H.interp q h) [SMTPat (H.interp p h)] = let m : mem = { ctr = 0; heap = h; locks = [] } in assert (interp p m <==> interp q m) in assert (forall h. H.interp p h <==> H.interp q h); Steel.Heap.slprop_extensionality p q let reveal_equiv p1 p2 = () let core_ref = H.core_ref let core_ref_null = H.core_ref_null let core_ref_is_null r = H.core_ref_is_null r let emp : slprop u#a = H.emp let pure = H.pure let pts_to = H.pts_to let h_and = H.h_and let h_or = H.h_or let star = H.star let wand = H.wand let h_exists = H.h_exists let h_forall = H.h_forall //////////////////////////////////////////////////////////////////////////////// //properties of equiv //////////////////////////////////////////////////////////////////////////////// let equiv_symmetric (p1 p2:slprop u#a) = H.equiv_symmetric p1 p2 #push-options "--warn_error -271" let equiv_heap_iff_equiv (p1 p2:slprop u#a) : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat (equiv p1 p2)] = let aux_lr () : Lemma (requires H.equiv p1 p2) (ensures equiv p1 p2) [SMTPat ()] = () in let aux_rl_helper1 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p1 h) (ensures H.interp p2 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl_helper2 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p2 h) (ensures H.interp p1 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl () : Lemma (requires equiv p1 p2) (ensures H.equiv p1 p2) [SMTPat ()] = () in () let equiv_heap_iff_equiv_forall () : Lemma (ensures (forall p1 p2. H.equiv p1 p2 <==> equiv p1 p2)) = let aux p1 p2 : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat ()] = equiv_heap_iff_equiv p1 p2 in () #pop-options let equiv_extensional_on_star (p1 p2 p3:slprop u#a) = equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3 let emp_unit p = H.emp_unit p let intro_emp m = H.intro_emp (heap_of_mem m) let pure_equiv p q = H.pure_equiv p q let pure_interp q m = H.pure_interp q (heap_of_mem m) let pure_star_interp p q m = H.pure_star_interp p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// //pts_to //////////////////////////////////////////////////////////////////////////////// let pts_to_compatible #a #pcm x v0 v1 m = H.pts_to_compatible #a #pcm x v0 v1 (heap_of_mem m) let pts_to_compatible_equiv #a #pcm x v0 v1 = H.pts_to_compatible_equiv #a #pcm x v0 v1 let pts_to_not_null #a #pcm x v m = H.pts_to_not_null #a #pcm x v (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // star //////////////////////////////////////////////////////////////////////////////// let intro_star p q mp mq = H.intro_star p q (heap_of_mem mp) (heap_of_mem mq) let elim_star p q m = let h = heap_of_mem m in H.elim_star p q h; assert (exists hl hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr); let hl = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hl -> exists hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let hr = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hr -> H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let ml = mem_set_heap m hl in let mr = mem_set_heap m hr in assert (disjoint ml mr); assert (m == join ml mr); assert (interp p ml); assert (interp q mr); () let interp_star (p q: slprop) (m: mem) : Lemma (interp (p `star` q) m <==> (exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m)) = let left = interp (p `star` q) m in let right = exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m in let f () : Lemma (requires left) (ensures right) = elim_star p q m in let g () : Lemma (requires right) (ensures left) = Classical.exists_elim left #_ #(fun mp -> exists (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mp -> Classical.exists_elim left #_ #(fun mq -> disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mq -> intro_star p q mp mq ) ) in Classical.move_requires f (); Classical.move_requires g () let star_commutative (p1 p2:slprop) = H.star_commutative p1 p2 let star_associative (p1 p2 p3:slprop) = H.star_associative p1 p2 p3 let star_congruence (p1 p2 p3 p4:slprop) = equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4 let affine_star (p q:slprop) (m:mem) = H.affine_star p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // Invariants on the lock store //////////////////////////////////////////////////////////////////////////////// let iname = nat module S = FStar.Set module L = FStar.List.Tot module W = FStar.Witnessed.Core let rec lock_store_invariant (e:inames) (l:lock_store u#a) : slprop u#a = let current_addr = L.length l - 1 in match l with | [] -> emp | Invariant p :: tl -> if current_addr `S.mem` e then lock_store_invariant e tl else p `star` lock_store_invariant e tl let lock_i (i:iname) (l:lock_store { i < L.length l }) = let ix = L.length l - i - 1 in L.index l ix let iname_for_p (i:iname) (p:slprop) : W.s_predicate lock_store = fun l -> i < L.length l /\ (lock_i i l).inv == p let lock_store_evolves : FStar.Preorder.preorder lock_store = fun (l1 l2 : lock_store) -> L.length l2 >= L.length l1 /\ (forall (i:nat{i < L.length l1}). (lock_i i l1).inv == (lock_i i l2).inv) let inames_in (e:inames) (l:lock_store) : prop = forall i. Set.mem i e ==> i < L.length l let inames_ok e m = inames_in e m.locks let inames_ok_empty m = () let extend_lock_store (e:inames) (l:lock_store{e `inames_in` l}) (p:slprop) : i:iname & l':lock_store { lock_store_invariant e l' == p `star` lock_store_invariant e l /\ iname_for_p i p l' } = (| L.length l, Invariant p :: l |) let set_add (i:iname) (s:inames) = Set.union (Set.singleton i) s let rec move_invariant (e:inames) (l:lock_store) (p:slprop) (i:iname{iname_for_p i p l /\ ~(i `Set.mem` e)}) : Lemma (H.equiv (lock_store_invariant e l) (p `star` lock_store_invariant (set_add i e) l)) = let rec aux (i:iname) (m:lock_store) : Lemma (requires i >= L.length m) (ensures (lock_store_invariant e m `H.equiv` lock_store_invariant (set_add i e) m)) = match m with | [] -> () | Invariant p::tl -> aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl) in let current_addr = L.length l - 1 in match l with | [] -> () | Invariant q::tl -> if i = current_addr then begin assert (lock_store_invariant e l == p `star` lock_store_invariant e tl); aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl); () end else begin move_invariant e tl p i; assert (lock_store_invariant e tl `equiv` (p `star` lock_store_invariant (set_add i e) tl)); H.star_congruence q (lock_store_invariant e tl) q (p `star` lock_store_invariant (set_add i e) tl); if Set.mem current_addr e then () else begin let r = lock_store_invariant (set_add i e) tl in assert (lock_store_invariant e l `equiv` (q `star` (p `star` r))); H.star_associative q p r; H.star_commutative q p; H.star_congruence (q `star` p) r (p `star` q) r; H.star_associative p q r end end let heap_ctr_valid (ctr:nat) (h:H.heap u#a) : prop = h `H.free_above_addr` ctr let ctr_validity (ctr:nat) (h:H.heap) : slprop = H.pure (heap_ctr_valid ctr h) let locks_invariant (e:inames) (m:mem u#a) : slprop u#a = lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m) let full_mem_pred (m:mem) = H.full_heap_pred (heap_of_mem m) (***** Following lemmas are needed in Steel.Effect *****) let core_mem_interp (hp:slprop u#a) (m:mem u#a) = () let interp_depends_only_on (hp:slprop u#a) = H.interp_depends_only_on hp let a_mem_prop_as_a_heap_prop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (H.a_heap_prop u#a) = let g (h: H.heap u#a) : Tot prop = interp sl (mem_of_heap h) /\ f (mem_of_heap h) in let phi0 (h0 h1: H.heap u#a) : Lemma (requires (g h0 /\ H.disjoint h0 h1)) (ensures (g h0 /\ H.disjoint h0 h1 /\ g (H.join h0 h1))) = assert (mem_of_heap (H.join h0 h1) == mem_of_heap h0 `join` mem_of_heap h1); interp_depends_only_on sl in let phi1 (h0 h1: H.heap u#a) : Lemma (ensures ((g h0 /\ H.disjoint h0 h1) ==> g (H.join h0 h1))) = Classical.move_requires (phi0 h0) h1 in Classical.forall_intro_2 phi1; g let refine_slprop sl f = H.as_slprop (a_mem_prop_as_a_heap_prop sl f) let interp_refine_slprop sl f m = assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_mem m)) let dep_hprop (s: slprop) (f: (hmem s -> Tot slprop)) (h: H.heap) : Tot prop = exists (h1: H.heap) . exists (h2: H.heap) . interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 let dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq' : squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h')) = let p2 (h h1 h2: H.heap) : Tot prop = interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 in let p1 (h h1: H.heap) : Tot prop = (exists h2 . p2 h h1 h2) in let h1 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p1 h) in let h2 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p2 h h1) in H.disjoint_join h' h1 h2; assert (H.disjoint h2 h'); let h2' = H.join h2 h' in H.join_commutative h2 h' ; assert (h2' == H.join h' h2); assert (H.disjoint h1 h2'); assert (mem_of_heap h2' == mem_of_heap h2 `join` mem_of_heap h'); interp_depends_only_on (f (mem_of_heap h1)); assert (interp (f (mem_of_heap h1)) (mem_of_heap h2')); H.join_commutative h1 h2; H.join_associative h' h2 h1; H.join_commutative h' h; H.join_commutative h2' h1; assert (H.join h h' == h1 `H.join` h2') let impl_intro_gen (#p: Type0) (#q: Type0) ($prf: (squash p -> Lemma (q ))) : Lemma (p ==> q) = Classical.impl_intro_gen #p #(fun _ -> q) prf let dep_hprop_is_affine1 (s: slprop) (f: (hmem s -> Tot slprop)) (h0 h1: H.heap) : Lemma ((dep_hprop s f h0 /\ H.disjoint h0 h1) ==> (H.disjoint h0 h1 /\ dep_hprop s f (H.join h0 h1))) = impl_intro_gen (dep_hprop_is_affine0 s f h0 h1) let dep_hprop_is_affine (s: slprop) (f: (hmem s -> Tot slprop)) : Lemma (H.heap_prop_is_affine (dep_hprop s f)) = Classical.forall_intro_2 (dep_hprop_is_affine1 s f) let sdep (s: slprop) (f: (hmem s -> Tot slprop)) : Tot slprop = dep_hprop_is_affine s f; H.as_slprop (dep_hprop s f) let interp_sdep (s: slprop) (f: (hmem s -> Tot slprop)) (m: mem) : Lemma (requires (dep_slprop_is_affine s f)) (ensures ( interp (sdep s f) m <==> (exists m1 m2 . interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) )) = dep_hprop_is_affine s f; assert (forall m1 m2 . (interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) ==> ( interp s (mem_of_heap m1.heap) /\ interp (f (mem_of_heap m1.heap)) (mem_of_heap m2.heap) /\ H.disjoint m1.heap m2.heap /\ H.join m1.heap m2.heap == m.heap )); interp_depends_only_on s; Classical.forall_intro (fun m -> interp_depends_only_on (f m)); assert (forall h1 h2 . (interp s (mem_of_heap h1) /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ H.disjoint h1 h2 /\ H.join h1 h2 == m.heap) ==> ( core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ interp s (core_mem (mem_of_heap h1)) /\ interp s (mem_set_heap m h1) /\ core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ f (mem_set_heap m h1) `equiv` f (mem_of_heap h1) /\ interp (f (mem_set_heap m h1)) (mem_of_heap h2) /\ interp (f (mem_set_heap m h1)) (mem_set_heap m h2) /\ disjoint (mem_set_heap m h1) (mem_set_heap m h2) /\ join (mem_set_heap m h1) (mem_set_heap m h2) == m )); () let h_exists_cong (#a:Type) (p q : a -> slprop) : Lemma (requires (forall x. p x `equiv` q x)) (ensures (h_exists p `equiv` h_exists q)) = equiv_heap_iff_equiv_forall (); H.h_exists_cong p q let intro_h_exists #a x p m = H.intro_h_exists x p (heap_of_mem m) let elim_h_exists (#a:_) (p:a -> slprop) (m:mem) = H.elim_h_exists p (heap_of_mem m) let intro_h_forall (#a:_) (p:a -> slprop) (m:mem) = H.intro_h_forall p (heap_of_mem m) let elim_h_forall (#a:_) (p:a -> slprop) (m:mem) (x:a) = H.elim_h_forall p (heap_of_mem m) x let intro_h_and (p q: slprop) (m:mem) = H.intro_h_and p q (heap_of_mem m) let elim_h_and (p q: slprop) (m:mem) = H.elim_h_and p q (heap_of_mem m) let intro_h_or_left (p q: slprop) (m:mem) = H.intro_h_or_left p q (heap_of_mem m) let intro_h_or_right (p q: slprop) (m:mem) = H.intro_h_or_right p q (heap_of_mem m) let elim_h_or (p q: slprop) (m:mem) = H.elim_h_or p q (heap_of_mem m) let intro_wand (p1 p2: slprop u#a) (m:mem) = introduce (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)) ==> interp (wand p1 p2) m with _. ( assert (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)); H.intro_wand p1 p2 (heap_of_mem m); let h = heap_of_mem m in assert ((forall h1. h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) ==> H.interp (wand p1 p2) h); introduce forall h1. (h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) with ( introduce (h `H.disjoint` h1 /\ H.interp p1 h1) ==> H.interp p2 (H.join h h1) with _. ( assert (h `H.disjoint` h1); let m1 = { ctr = m.ctr; heap = h1; locks = m.locks } in assert (m `disjoint` m1) ) ) ) (** Eliminating a wand by proving a heap that satisfies the LHS **) let elim_wand (p1 p2: slprop u#a) (m:mem) (m1:mem) = H.elim_wand p1 p2 (heap_of_mem m) (heap_of_mem m1) //////////////////////////////////////////////////////////////////////////////// // Preorders and effects //////////////////////////////////////////////////////////////////////////////// module PP = Steel.Preorder let mem_evolves = fun (m0 m1:full_mem) -> H.heap_evolves (heap_of_mem m0) (heap_of_mem m1) /\ m0.ctr <= m1.ctr /\ lock_store_evolves m0.locks m1.locks (** See [Steel.Heap.is_frame_preserving]. We add in [lock_invariants] now *) let preserves_frame (e:inames) (pre post:slprop) (m0 m1:mem) = forall (frame:slprop). interp ((pre `star` frame) `star` locks_invariant e m0) m0 ==> (interp ((post `star` frame) `star` locks_invariant e m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) (** This is a version of MstTot with frame quantified, as part of preserves_frame *) effect MstTotNF (a:Type u#a) (except:inames) (expects:slprop u#1) (provides: a -> slprop u#1) = NMSTTotal.NMSTATETOT a (full_mem u#1) mem_evolves (requires fun m0 -> inames_ok except m0 /\ interp (expects `star` locks_invariant except m0) m0) (ensures fun m0 x m1 -> inames_ok except m1 /\ interp (provides x `star` locks_invariant except m1) m1 /\ preserves_frame except expects (provides x) m0 m1) //////////////////////////////////////////////////////////////////////////////// // Lifting heap actions //////////////////////////////////////////////////////////////////////////////// (** Heap actions come in two equivalent flavors: - one that take an explicit frame as argument (action_with_frame) - and one that quantify over all the frame We therefore define two lift routes: - a direct route for those with explicit frame - via MstTotNF for the rest *) let tot_pre_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = hmem_with_inv_except e fp -> (x:a & hmem_with_inv_except e (fp' x)) let tot_pre_action_nf = tot_pre_action_nf_except S.empty let ac_reasoning_for_m_frame_preserving (p q r:slprop u#a) (m:mem u#a) : Lemma (requires interp ((p `star` q) `star` r) m) (ensures interp (p `star` r) m) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_commutative p q; equiv_extensional_on_star (p `star` q) (q `star` p) r } (q `star` p) `star` r; (equiv) { star_associative q p r } q `star` (p `star` r); }; assert (interp (q `star` (p `star` r)) m); affine_star q (p `star` r) m let is_frame_preserving (#e:inames) (#a:Type u#b) (#fp:slprop u#a) (#fp':a -> slprop u#a) (f:tot_pre_action_nf_except e fp a fp') = forall (frame:slprop u#a) (m0:hmem_with_inv_except e (fp `star` frame)). (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = f:tot_pre_action_nf_except e fp a fp'{ is_frame_preserving f } let tot_action_nf = tot_action_nf_except S.empty let linv e (m:mem) = locks_invariant e m let hheap_of_hmem #fp #e (m:hmem_with_inv_except e fp) : h:H.hheap (fp `star` linv e m) { h `H.free_above_addr` m.ctr} = let h = heap_of_mem m in H.pure_interp (heap_ctr_valid m.ctr (heap_of_mem m)) h; h let hmem_of_hheap #e (#fp0 #fp1:slprop) (m:hmem_with_inv_except e fp0) (h:H.full_hheap (fp1 `star` linv e m) { h `Heap.free_above_addr` m.ctr }) : m1:hmem_with_inv_except e fp1{linv e m `equiv` linv e m1} = let m1 : mem = { m with heap = h } in assert (interp (fp1 `star` linv e m) m1); star_commutative fp1 (linv e m); assert (interp (linv e m `star` fp1) m1); assert (linv e m1 == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); assert (linv e m == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m)); H.pure_interp (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_of_mem m); assert (heap_ctr_valid m1.ctr (heap_of_mem m) <==> heap_ctr_valid m1.ctr (heap_of_mem m1)); H.pure_equiv (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_ctr_valid m1.ctr (heap_of_mem m1)); H.star_congruence (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m)); assert (linv e m `equiv` linv e m1); let _ = equiv_extensional_on_star (linv e m) (linv e m1) fp1 in assert ((linv e m `star` fp1) `equiv` (linv e m1 `star` fp1)); assert (interp (linv e m1 `star` fp1) m1); star_commutative (linv e m1) fp1; assert (interp (fp1 `star` linv e m1) m1); m1 let with_inv_except (m:mem) e (fp:slprop) = interp (fp `star` locks_invariant e m) m #push-options "--warn_error -271" let as_hprop (frame:slprop) (mp:mprop frame) : hp:H.hprop frame{forall m. mp (core_mem m) == hp (heap_of_mem m)} = let f = fun h -> mp (mem_of_heap h) in assert (forall m. mp (core_mem m) == f (heap_of_mem m)); let aux (m0:H.hheap frame) (m1:H.heap{H.disjoint m0 m1}) : Lemma (ensures (mem_of_heap (H.join m0 m1) == join (mem_of_heap m0) (mem_of_heap m1))) [SMTPat ()] = () in f let mprop_preservation_of_hprop_preservation (p:slprop) (m0 m1:mem) : Lemma (requires (forall (hp:H.hprop p). hp (heap_of_mem m0) == hp (heap_of_mem m1))) (ensures (forall (mp:mprop p). mp (core_mem m0) == mp (core_mem m1))) = let aux (mp:mprop p) : Lemma (mp (core_mem m0) == mp (core_mem m1)) [SMTPat()] = assert (as_hprop p mp (heap_of_mem m0) == as_hprop p mp (heap_of_mem m1)) in () let lift_heap_action (#fp:slprop) (#a:Type) (#fp':a -> slprop) (e:inames) ($f:H.action fp a fp') : tot_action_nf_except e fp a fp' = let g : tot_pre_action_nf_except e fp a fp' = fun m -> let h0 = hheap_of_hmem m in let (| x, h' |) = f h0 in (| x, hmem_of_hheap m h' |) in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in let h0 = hheap_of_hmem m0 in let (| x', h1 |) = f h0 in H.action_framing f (linv e m0) h0; assert (x == x'); star_associative fp frame (linv e m0); H.action_framing f (frame `star` linv e m0) h0; assert (H.interp ((fp' x) `star` (frame `star` linv e m0)) h1); star_associative (fp' x) frame (linv e m0); assert (H.interp ((fp' x `star` frame) `star` linv e m0) h1); let h1' : H.hheap ((fp' x `star` frame) `star` linv e m0) = h1 in assert (m1 == hmem_of_hheap m0 h1'); assert (with_inv_except m1 e (fp' x `star` frame)); assert (forall (hp:H.hprop frame). hp h0 == hp h1); mprop_preservation_of_hprop_preservation frame m0 m1; () in assert (is_frame_preserving g); g let frame_preserving_respects_preorder #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (m0:hmem_with_inv_except e fp) : Lemma (let (| x, m1 |) = f m0 in mem_evolves m0 m1) = let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1) = () in H.emp_unit fp; assert (interp (fp `star` linv e m0) m0); H.star_congruence (fp `star` emp) (linv e m0) fp (linv e m0); assert (interp ((fp `star` emp) `star` linv e m0) m0); aux emp m0 let lift_tot_action_nf #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') : MstTotNF a e fp fp' = let m0 = NMSTTotal.get () in let m0' : hmem_with_inv_except e fp = m0 in let r = f m0' in let (| x, m1 |) = r in let m1' : hmem_with_inv_except e (fp' x) = m1 in assert (is_frame_preserving f); assert (m1 == dsnd (f m0)); frame_preserving_respects_preorder f m0; NMSTTotal.put #_ #(mem_evolves) m1; x let lift_tot_action #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get #(full_mem) #_ () in ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); lift_tot_action_nf f (** Now defining the lift for heap actions with explicit frame *) let tot_action_with_frame_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = frame:slprop u#a -> m0:hmem_with_inv_except e (fp `star` frame) -> Pure (x:a & hmem_with_inv_except e (fp' x `star` frame)) (requires True) (ensures fun (| x, m1 |) -> mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_with_frame = tot_action_with_frame_except S.empty let lift_heap_action_with_frame (#fp:slprop u#a) (#a:Type u#b) (#fp':a -> slprop u#a) (e:inames) ($f:H.action_with_frame fp a fp') : tot_action_with_frame_except e fp a fp' = fun frame m0 -> let h0 = hheap_of_hmem m0 in calc (equiv) { fp `star` frame `star` locks_invariant e m0; (equiv) { star_associative fp frame (locks_invariant e m0) } fp `star` (frame `star` locks_invariant e m0); }; assert (H.interp (fp `star` frame `star` locks_invariant e m0) h0); assert (H.interp (fp `star` (frame `star` locks_invariant e m0)) h0); //key: apply the heap action with frame * locks_invariant e m0 let (| x, h1 |) = f (frame `star` locks_invariant e m0) h0 in calc (equiv) { fp' x `star` (frame `star` locks_invariant e m0); (equiv) { star_associative (fp' x) frame (locks_invariant e m0) } fp' x `star` frame `star` locks_invariant e m0; }; assert (H.interp (fp' x `star` (frame `star` locks_invariant e m0)) h1); assert (H.interp (fp' x `star` frame `star` locks_invariant e m0) h1); let m1 = hmem_of_hheap m0 h1 in assert (mem_evolves m0 m1); mprop_preservation_of_hprop_preservation (frame `star` locks_invariant e m0) m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)); (| x, m1 |) let lift_tot_action_with_frame #a #e #fp #fp' ($f:tot_action_with_frame_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in assert (inames_ok e m0); ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); let m0' : hmem_with_inv_except e fp = m0 in let r = f frame m0' in let (| x, m1 |) = r in ac_reasoning_for_m_frame_preserving (fp' x) frame (locks_invariant e m1) m1; assert (interp (fp' x `star` frame `star` locks_invariant e m1) m1); assert (interp (fp' x `star` locks_invariant e m1) m1); let m1' : hmem_with_inv_except e (fp' x) = m1 in NMSTTotal.put #_ #(mem_evolves) m1; x let sel_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.sel_action #a #pcm r v0)) let upd_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.upd_action #a #pcm r v0 v1))

{ "checked_file": "/", "dependencies": [ "Steel.Preorder.fst.checked", "Steel.Heap.fsti.checked", "prims.fst.checked", "FStar.Witnessed.Core.fsti.checked", "FStar.Set.fsti.checked", "FStar.Preorder.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.PCM.fst.checked", "FStar.NMSTTotal.fst.checked", "FStar.List.Tot.fst.checked", "FStar.IndefiniteDescription.fsti.checked", "FStar.Ghost.fsti.checked", "FStar.FunctionalExtensionality.fsti.checked", "FStar.Classical.Sugar.fsti.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Steel.Memory.fst" }

[ { "abbrev": true, "full_module": "Steel.Preorder", "short_module": "PP" }, { "abbrev": true, "full_module": "FStar.Witnessed.Core", "short_module": "W" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": true, "full_module": "Steel.Heap", "short_module": "H" }, { "abbrev": false, "full_module": "FStar.FunctionalExtensionality", "short_module": null }, { "abbrev": true, "full_module": "FStar.FunctionalExtensionality", "short_module": "F" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": false, "full_module": "FStar.PCM", "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

e: Steel.Memory.inames -> r: Steel.Memory.ref a pcm -> x: FStar.Ghost.erased a { FStar.PCM.exclusive pcm (FStar.Ghost.reveal x) /\ Mkpcm?.refine pcm (Mkpcm'?.one (Mkpcm?.p pcm)) } -> Steel.Memory.action_except Prims.unit e (Steel.Memory.pts_to r (FStar.Ghost.reveal x)) (fun _ -> Steel.Memory.pts_to r (Mkpcm'?.one (Mkpcm?.p pcm)))

Prims.Tot

[ "total" ]

[]

[ "FStar.PCM.pcm", "Steel.Memory.inames", "Steel.Memory.ref", "FStar.Ghost.erased", "Prims.l_and", "FStar.PCM.exclusive", "FStar.Ghost.reveal", "FStar.PCM.__proj__Mkpcm__item__refine", "FStar.PCM.__proj__Mkpcm'__item__one", "FStar.PCM.__proj__Mkpcm__item__p", "Steel.Memory.lift_tot_action", "Prims.unit", "Steel.Heap.pts_to", "Steel.Memory.slprop", "Steel.Memory.lift_heap_action", "Steel.Heap.free_action", "Steel.Memory.action_except", "Steel.Memory.pts_to" ]

[]

false

let free_action #a #pcm e r v0 =

lift_tot_action (lift_heap_action e (H.free_action #a #pcm r v0))

false

Steel.Memory.fst

Steel.Memory.name_is_ok

val name_is_ok (i: iname) (m0: full_mem u#1) : prop

let name_is_ok (i:iname) (m0:full_mem u#1) : prop = i < List.Tot.length m0.locks

{ "file_name": "lib/steel/Steel.Memory.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 80, "end_line": 1250, "start_col": 0, "start_line": 1250 }

(* 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.Memory module F = FStar.FunctionalExtensionality open FStar.FunctionalExtensionality open FStar.PCM module H = Steel.Heap noeq type lock_state : Type u#(a + 1) = | Invariant : inv:H.slprop u#a -> lock_state let lock_store : Type u#(a+1) = list (lock_state u#a) noeq type mem : Type u#(a + 1) = { ctr: nat; heap: H.heap u#a; locks: lock_store u#a; } let heap_of_mem (x:mem) : H.heap = x.heap let mem_of_heap (h:H.heap) : mem = { ctr = 0; heap = h; locks = [] } let mem_set_heap (m:mem) (h:H.heap) : mem = { ctr = m.ctr; heap = h; locks = m.locks; } let core_mem (m:mem) : mem = mem_of_heap (heap_of_mem m) let core_mem_invol m = () let disjoint (m0 m1:mem u#h) : prop = m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks let disjoint_sym m0 m1 = () let join m0 m1 = { ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = m0.locks } let join_commutative m0 m1 = H.join_commutative m0.heap m1.heap let disjoint_join m0 m1 m2 = H.disjoint_join m0.heap m1.heap m2.heap let join_associative m0 m1 m2 = H.join_associative m0.heap m1.heap m2.heap let slprop = H.slprop let interp p m = H.interp p m.heap let equiv p1 p2 = forall m. interp p1 m <==> interp p2 m let slprop_extensionality p q = assert (forall m. interp p m <==> interp q m); let aux (h:H.heap) : Lemma (H.interp p h <==> H.interp q h) [SMTPat (H.interp p h)] = let m : mem = { ctr = 0; heap = h; locks = [] } in assert (interp p m <==> interp q m) in assert (forall h. H.interp p h <==> H.interp q h); Steel.Heap.slprop_extensionality p q let reveal_equiv p1 p2 = () let core_ref = H.core_ref let core_ref_null = H.core_ref_null let core_ref_is_null r = H.core_ref_is_null r let emp : slprop u#a = H.emp let pure = H.pure let pts_to = H.pts_to let h_and = H.h_and let h_or = H.h_or let star = H.star let wand = H.wand let h_exists = H.h_exists let h_forall = H.h_forall //////////////////////////////////////////////////////////////////////////////// //properties of equiv //////////////////////////////////////////////////////////////////////////////// let equiv_symmetric (p1 p2:slprop u#a) = H.equiv_symmetric p1 p2 #push-options "--warn_error -271" let equiv_heap_iff_equiv (p1 p2:slprop u#a) : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat (equiv p1 p2)] = let aux_lr () : Lemma (requires H.equiv p1 p2) (ensures equiv p1 p2) [SMTPat ()] = () in let aux_rl_helper1 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p1 h) (ensures H.interp p2 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl_helper2 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p2 h) (ensures H.interp p1 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl () : Lemma (requires equiv p1 p2) (ensures H.equiv p1 p2) [SMTPat ()] = () in () let equiv_heap_iff_equiv_forall () : Lemma (ensures (forall p1 p2. H.equiv p1 p2 <==> equiv p1 p2)) = let aux p1 p2 : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat ()] = equiv_heap_iff_equiv p1 p2 in () #pop-options let equiv_extensional_on_star (p1 p2 p3:slprop u#a) = equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3 let emp_unit p = H.emp_unit p let intro_emp m = H.intro_emp (heap_of_mem m) let pure_equiv p q = H.pure_equiv p q let pure_interp q m = H.pure_interp q (heap_of_mem m) let pure_star_interp p q m = H.pure_star_interp p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// //pts_to //////////////////////////////////////////////////////////////////////////////// let pts_to_compatible #a #pcm x v0 v1 m = H.pts_to_compatible #a #pcm x v0 v1 (heap_of_mem m) let pts_to_compatible_equiv #a #pcm x v0 v1 = H.pts_to_compatible_equiv #a #pcm x v0 v1 let pts_to_not_null #a #pcm x v m = H.pts_to_not_null #a #pcm x v (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // star //////////////////////////////////////////////////////////////////////////////// let intro_star p q mp mq = H.intro_star p q (heap_of_mem mp) (heap_of_mem mq) let elim_star p q m = let h = heap_of_mem m in H.elim_star p q h; assert (exists hl hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr); let hl = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hl -> exists hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let hr = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hr -> H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let ml = mem_set_heap m hl in let mr = mem_set_heap m hr in assert (disjoint ml mr); assert (m == join ml mr); assert (interp p ml); assert (interp q mr); () let interp_star (p q: slprop) (m: mem) : Lemma (interp (p `star` q) m <==> (exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m)) = let left = interp (p `star` q) m in let right = exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m in let f () : Lemma (requires left) (ensures right) = elim_star p q m in let g () : Lemma (requires right) (ensures left) = Classical.exists_elim left #_ #(fun mp -> exists (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mp -> Classical.exists_elim left #_ #(fun mq -> disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mq -> intro_star p q mp mq ) ) in Classical.move_requires f (); Classical.move_requires g () let star_commutative (p1 p2:slprop) = H.star_commutative p1 p2 let star_associative (p1 p2 p3:slprop) = H.star_associative p1 p2 p3 let star_congruence (p1 p2 p3 p4:slprop) = equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4 let affine_star (p q:slprop) (m:mem) = H.affine_star p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // Invariants on the lock store //////////////////////////////////////////////////////////////////////////////// let iname = nat module S = FStar.Set module L = FStar.List.Tot module W = FStar.Witnessed.Core let rec lock_store_invariant (e:inames) (l:lock_store u#a) : slprop u#a = let current_addr = L.length l - 1 in match l with | [] -> emp | Invariant p :: tl -> if current_addr `S.mem` e then lock_store_invariant e tl else p `star` lock_store_invariant e tl let lock_i (i:iname) (l:lock_store { i < L.length l }) = let ix = L.length l - i - 1 in L.index l ix let iname_for_p (i:iname) (p:slprop) : W.s_predicate lock_store = fun l -> i < L.length l /\ (lock_i i l).inv == p let lock_store_evolves : FStar.Preorder.preorder lock_store = fun (l1 l2 : lock_store) -> L.length l2 >= L.length l1 /\ (forall (i:nat{i < L.length l1}). (lock_i i l1).inv == (lock_i i l2).inv) let inames_in (e:inames) (l:lock_store) : prop = forall i. Set.mem i e ==> i < L.length l let inames_ok e m = inames_in e m.locks let inames_ok_empty m = () let extend_lock_store (e:inames) (l:lock_store{e `inames_in` l}) (p:slprop) : i:iname & l':lock_store { lock_store_invariant e l' == p `star` lock_store_invariant e l /\ iname_for_p i p l' } = (| L.length l, Invariant p :: l |) let set_add (i:iname) (s:inames) = Set.union (Set.singleton i) s let rec move_invariant (e:inames) (l:lock_store) (p:slprop) (i:iname{iname_for_p i p l /\ ~(i `Set.mem` e)}) : Lemma (H.equiv (lock_store_invariant e l) (p `star` lock_store_invariant (set_add i e) l)) = let rec aux (i:iname) (m:lock_store) : Lemma (requires i >= L.length m) (ensures (lock_store_invariant e m `H.equiv` lock_store_invariant (set_add i e) m)) = match m with | [] -> () | Invariant p::tl -> aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl) in let current_addr = L.length l - 1 in match l with | [] -> () | Invariant q::tl -> if i = current_addr then begin assert (lock_store_invariant e l == p `star` lock_store_invariant e tl); aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl); () end else begin move_invariant e tl p i; assert (lock_store_invariant e tl `equiv` (p `star` lock_store_invariant (set_add i e) tl)); H.star_congruence q (lock_store_invariant e tl) q (p `star` lock_store_invariant (set_add i e) tl); if Set.mem current_addr e then () else begin let r = lock_store_invariant (set_add i e) tl in assert (lock_store_invariant e l `equiv` (q `star` (p `star` r))); H.star_associative q p r; H.star_commutative q p; H.star_congruence (q `star` p) r (p `star` q) r; H.star_associative p q r end end let heap_ctr_valid (ctr:nat) (h:H.heap u#a) : prop = h `H.free_above_addr` ctr let ctr_validity (ctr:nat) (h:H.heap) : slprop = H.pure (heap_ctr_valid ctr h) let locks_invariant (e:inames) (m:mem u#a) : slprop u#a = lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m) let full_mem_pred (m:mem) = H.full_heap_pred (heap_of_mem m) (***** Following lemmas are needed in Steel.Effect *****) let core_mem_interp (hp:slprop u#a) (m:mem u#a) = () let interp_depends_only_on (hp:slprop u#a) = H.interp_depends_only_on hp let a_mem_prop_as_a_heap_prop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (H.a_heap_prop u#a) = let g (h: H.heap u#a) : Tot prop = interp sl (mem_of_heap h) /\ f (mem_of_heap h) in let phi0 (h0 h1: H.heap u#a) : Lemma (requires (g h0 /\ H.disjoint h0 h1)) (ensures (g h0 /\ H.disjoint h0 h1 /\ g (H.join h0 h1))) = assert (mem_of_heap (H.join h0 h1) == mem_of_heap h0 `join` mem_of_heap h1); interp_depends_only_on sl in let phi1 (h0 h1: H.heap u#a) : Lemma (ensures ((g h0 /\ H.disjoint h0 h1) ==> g (H.join h0 h1))) = Classical.move_requires (phi0 h0) h1 in Classical.forall_intro_2 phi1; g let refine_slprop sl f = H.as_slprop (a_mem_prop_as_a_heap_prop sl f) let interp_refine_slprop sl f m = assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_mem m)) let dep_hprop (s: slprop) (f: (hmem s -> Tot slprop)) (h: H.heap) : Tot prop = exists (h1: H.heap) . exists (h2: H.heap) . interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 let dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq' : squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h')) = let p2 (h h1 h2: H.heap) : Tot prop = interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 in let p1 (h h1: H.heap) : Tot prop = (exists h2 . p2 h h1 h2) in let h1 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p1 h) in let h2 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p2 h h1) in H.disjoint_join h' h1 h2; assert (H.disjoint h2 h'); let h2' = H.join h2 h' in H.join_commutative h2 h' ; assert (h2' == H.join h' h2); assert (H.disjoint h1 h2'); assert (mem_of_heap h2' == mem_of_heap h2 `join` mem_of_heap h'); interp_depends_only_on (f (mem_of_heap h1)); assert (interp (f (mem_of_heap h1)) (mem_of_heap h2')); H.join_commutative h1 h2; H.join_associative h' h2 h1; H.join_commutative h' h; H.join_commutative h2' h1; assert (H.join h h' == h1 `H.join` h2') let impl_intro_gen (#p: Type0) (#q: Type0) ($prf: (squash p -> Lemma (q ))) : Lemma (p ==> q) = Classical.impl_intro_gen #p #(fun _ -> q) prf let dep_hprop_is_affine1 (s: slprop) (f: (hmem s -> Tot slprop)) (h0 h1: H.heap) : Lemma ((dep_hprop s f h0 /\ H.disjoint h0 h1) ==> (H.disjoint h0 h1 /\ dep_hprop s f (H.join h0 h1))) = impl_intro_gen (dep_hprop_is_affine0 s f h0 h1) let dep_hprop_is_affine (s: slprop) (f: (hmem s -> Tot slprop)) : Lemma (H.heap_prop_is_affine (dep_hprop s f)) = Classical.forall_intro_2 (dep_hprop_is_affine1 s f) let sdep (s: slprop) (f: (hmem s -> Tot slprop)) : Tot slprop = dep_hprop_is_affine s f; H.as_slprop (dep_hprop s f) let interp_sdep (s: slprop) (f: (hmem s -> Tot slprop)) (m: mem) : Lemma (requires (dep_slprop_is_affine s f)) (ensures ( interp (sdep s f) m <==> (exists m1 m2 . interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) )) = dep_hprop_is_affine s f; assert (forall m1 m2 . (interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) ==> ( interp s (mem_of_heap m1.heap) /\ interp (f (mem_of_heap m1.heap)) (mem_of_heap m2.heap) /\ H.disjoint m1.heap m2.heap /\ H.join m1.heap m2.heap == m.heap )); interp_depends_only_on s; Classical.forall_intro (fun m -> interp_depends_only_on (f m)); assert (forall h1 h2 . (interp s (mem_of_heap h1) /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ H.disjoint h1 h2 /\ H.join h1 h2 == m.heap) ==> ( core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ interp s (core_mem (mem_of_heap h1)) /\ interp s (mem_set_heap m h1) /\ core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ f (mem_set_heap m h1) `equiv` f (mem_of_heap h1) /\ interp (f (mem_set_heap m h1)) (mem_of_heap h2) /\ interp (f (mem_set_heap m h1)) (mem_set_heap m h2) /\ disjoint (mem_set_heap m h1) (mem_set_heap m h2) /\ join (mem_set_heap m h1) (mem_set_heap m h2) == m )); () let h_exists_cong (#a:Type) (p q : a -> slprop) : Lemma (requires (forall x. p x `equiv` q x)) (ensures (h_exists p `equiv` h_exists q)) = equiv_heap_iff_equiv_forall (); H.h_exists_cong p q let intro_h_exists #a x p m = H.intro_h_exists x p (heap_of_mem m) let elim_h_exists (#a:_) (p:a -> slprop) (m:mem) = H.elim_h_exists p (heap_of_mem m) let intro_h_forall (#a:_) (p:a -> slprop) (m:mem) = H.intro_h_forall p (heap_of_mem m) let elim_h_forall (#a:_) (p:a -> slprop) (m:mem) (x:a) = H.elim_h_forall p (heap_of_mem m) x let intro_h_and (p q: slprop) (m:mem) = H.intro_h_and p q (heap_of_mem m) let elim_h_and (p q: slprop) (m:mem) = H.elim_h_and p q (heap_of_mem m) let intro_h_or_left (p q: slprop) (m:mem) = H.intro_h_or_left p q (heap_of_mem m) let intro_h_or_right (p q: slprop) (m:mem) = H.intro_h_or_right p q (heap_of_mem m) let elim_h_or (p q: slprop) (m:mem) = H.elim_h_or p q (heap_of_mem m) let intro_wand (p1 p2: slprop u#a) (m:mem) = introduce (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)) ==> interp (wand p1 p2) m with _. ( assert (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)); H.intro_wand p1 p2 (heap_of_mem m); let h = heap_of_mem m in assert ((forall h1. h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) ==> H.interp (wand p1 p2) h); introduce forall h1. (h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) with ( introduce (h `H.disjoint` h1 /\ H.interp p1 h1) ==> H.interp p2 (H.join h h1) with _. ( assert (h `H.disjoint` h1); let m1 = { ctr = m.ctr; heap = h1; locks = m.locks } in assert (m `disjoint` m1) ) ) ) (** Eliminating a wand by proving a heap that satisfies the LHS **) let elim_wand (p1 p2: slprop u#a) (m:mem) (m1:mem) = H.elim_wand p1 p2 (heap_of_mem m) (heap_of_mem m1) //////////////////////////////////////////////////////////////////////////////// // Preorders and effects //////////////////////////////////////////////////////////////////////////////// module PP = Steel.Preorder let mem_evolves = fun (m0 m1:full_mem) -> H.heap_evolves (heap_of_mem m0) (heap_of_mem m1) /\ m0.ctr <= m1.ctr /\ lock_store_evolves m0.locks m1.locks (** See [Steel.Heap.is_frame_preserving]. We add in [lock_invariants] now *) let preserves_frame (e:inames) (pre post:slprop) (m0 m1:mem) = forall (frame:slprop). interp ((pre `star` frame) `star` locks_invariant e m0) m0 ==> (interp ((post `star` frame) `star` locks_invariant e m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) (** This is a version of MstTot with frame quantified, as part of preserves_frame *) effect MstTotNF (a:Type u#a) (except:inames) (expects:slprop u#1) (provides: a -> slprop u#1) = NMSTTotal.NMSTATETOT a (full_mem u#1) mem_evolves (requires fun m0 -> inames_ok except m0 /\ interp (expects `star` locks_invariant except m0) m0) (ensures fun m0 x m1 -> inames_ok except m1 /\ interp (provides x `star` locks_invariant except m1) m1 /\ preserves_frame except expects (provides x) m0 m1) //////////////////////////////////////////////////////////////////////////////// // Lifting heap actions //////////////////////////////////////////////////////////////////////////////// (** Heap actions come in two equivalent flavors: - one that take an explicit frame as argument (action_with_frame) - and one that quantify over all the frame We therefore define two lift routes: - a direct route for those with explicit frame - via MstTotNF for the rest *) let tot_pre_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = hmem_with_inv_except e fp -> (x:a & hmem_with_inv_except e (fp' x)) let tot_pre_action_nf = tot_pre_action_nf_except S.empty let ac_reasoning_for_m_frame_preserving (p q r:slprop u#a) (m:mem u#a) : Lemma (requires interp ((p `star` q) `star` r) m) (ensures interp (p `star` r) m) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_commutative p q; equiv_extensional_on_star (p `star` q) (q `star` p) r } (q `star` p) `star` r; (equiv) { star_associative q p r } q `star` (p `star` r); }; assert (interp (q `star` (p `star` r)) m); affine_star q (p `star` r) m let is_frame_preserving (#e:inames) (#a:Type u#b) (#fp:slprop u#a) (#fp':a -> slprop u#a) (f:tot_pre_action_nf_except e fp a fp') = forall (frame:slprop u#a) (m0:hmem_with_inv_except e (fp `star` frame)). (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = f:tot_pre_action_nf_except e fp a fp'{ is_frame_preserving f } let tot_action_nf = tot_action_nf_except S.empty let linv e (m:mem) = locks_invariant e m let hheap_of_hmem #fp #e (m:hmem_with_inv_except e fp) : h:H.hheap (fp `star` linv e m) { h `H.free_above_addr` m.ctr} = let h = heap_of_mem m in H.pure_interp (heap_ctr_valid m.ctr (heap_of_mem m)) h; h let hmem_of_hheap #e (#fp0 #fp1:slprop) (m:hmem_with_inv_except e fp0) (h:H.full_hheap (fp1 `star` linv e m) { h `Heap.free_above_addr` m.ctr }) : m1:hmem_with_inv_except e fp1{linv e m `equiv` linv e m1} = let m1 : mem = { m with heap = h } in assert (interp (fp1 `star` linv e m) m1); star_commutative fp1 (linv e m); assert (interp (linv e m `star` fp1) m1); assert (linv e m1 == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); assert (linv e m == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m)); H.pure_interp (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_of_mem m); assert (heap_ctr_valid m1.ctr (heap_of_mem m) <==> heap_ctr_valid m1.ctr (heap_of_mem m1)); H.pure_equiv (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_ctr_valid m1.ctr (heap_of_mem m1)); H.star_congruence (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m)); assert (linv e m `equiv` linv e m1); let _ = equiv_extensional_on_star (linv e m) (linv e m1) fp1 in assert ((linv e m `star` fp1) `equiv` (linv e m1 `star` fp1)); assert (interp (linv e m1 `star` fp1) m1); star_commutative (linv e m1) fp1; assert (interp (fp1 `star` linv e m1) m1); m1 let with_inv_except (m:mem) e (fp:slprop) = interp (fp `star` locks_invariant e m) m #push-options "--warn_error -271" let as_hprop (frame:slprop) (mp:mprop frame) : hp:H.hprop frame{forall m. mp (core_mem m) == hp (heap_of_mem m)} = let f = fun h -> mp (mem_of_heap h) in assert (forall m. mp (core_mem m) == f (heap_of_mem m)); let aux (m0:H.hheap frame) (m1:H.heap{H.disjoint m0 m1}) : Lemma (ensures (mem_of_heap (H.join m0 m1) == join (mem_of_heap m0) (mem_of_heap m1))) [SMTPat ()] = () in f let mprop_preservation_of_hprop_preservation (p:slprop) (m0 m1:mem) : Lemma (requires (forall (hp:H.hprop p). hp (heap_of_mem m0) == hp (heap_of_mem m1))) (ensures (forall (mp:mprop p). mp (core_mem m0) == mp (core_mem m1))) = let aux (mp:mprop p) : Lemma (mp (core_mem m0) == mp (core_mem m1)) [SMTPat()] = assert (as_hprop p mp (heap_of_mem m0) == as_hprop p mp (heap_of_mem m1)) in () let lift_heap_action (#fp:slprop) (#a:Type) (#fp':a -> slprop) (e:inames) ($f:H.action fp a fp') : tot_action_nf_except e fp a fp' = let g : tot_pre_action_nf_except e fp a fp' = fun m -> let h0 = hheap_of_hmem m in let (| x, h' |) = f h0 in (| x, hmem_of_hheap m h' |) in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in let h0 = hheap_of_hmem m0 in let (| x', h1 |) = f h0 in H.action_framing f (linv e m0) h0; assert (x == x'); star_associative fp frame (linv e m0); H.action_framing f (frame `star` linv e m0) h0; assert (H.interp ((fp' x) `star` (frame `star` linv e m0)) h1); star_associative (fp' x) frame (linv e m0); assert (H.interp ((fp' x `star` frame) `star` linv e m0) h1); let h1' : H.hheap ((fp' x `star` frame) `star` linv e m0) = h1 in assert (m1 == hmem_of_hheap m0 h1'); assert (with_inv_except m1 e (fp' x `star` frame)); assert (forall (hp:H.hprop frame). hp h0 == hp h1); mprop_preservation_of_hprop_preservation frame m0 m1; () in assert (is_frame_preserving g); g let frame_preserving_respects_preorder #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (m0:hmem_with_inv_except e fp) : Lemma (let (| x, m1 |) = f m0 in mem_evolves m0 m1) = let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1) = () in H.emp_unit fp; assert (interp (fp `star` linv e m0) m0); H.star_congruence (fp `star` emp) (linv e m0) fp (linv e m0); assert (interp ((fp `star` emp) `star` linv e m0) m0); aux emp m0 let lift_tot_action_nf #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') : MstTotNF a e fp fp' = let m0 = NMSTTotal.get () in let m0' : hmem_with_inv_except e fp = m0 in let r = f m0' in let (| x, m1 |) = r in let m1' : hmem_with_inv_except e (fp' x) = m1 in assert (is_frame_preserving f); assert (m1 == dsnd (f m0)); frame_preserving_respects_preorder f m0; NMSTTotal.put #_ #(mem_evolves) m1; x let lift_tot_action #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get #(full_mem) #_ () in ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); lift_tot_action_nf f (** Now defining the lift for heap actions with explicit frame *) let tot_action_with_frame_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = frame:slprop u#a -> m0:hmem_with_inv_except e (fp `star` frame) -> Pure (x:a & hmem_with_inv_except e (fp' x `star` frame)) (requires True) (ensures fun (| x, m1 |) -> mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_with_frame = tot_action_with_frame_except S.empty let lift_heap_action_with_frame (#fp:slprop u#a) (#a:Type u#b) (#fp':a -> slprop u#a) (e:inames) ($f:H.action_with_frame fp a fp') : tot_action_with_frame_except e fp a fp' = fun frame m0 -> let h0 = hheap_of_hmem m0 in calc (equiv) { fp `star` frame `star` locks_invariant e m0; (equiv) { star_associative fp frame (locks_invariant e m0) } fp `star` (frame `star` locks_invariant e m0); }; assert (H.interp (fp `star` frame `star` locks_invariant e m0) h0); assert (H.interp (fp `star` (frame `star` locks_invariant e m0)) h0); //key: apply the heap action with frame * locks_invariant e m0 let (| x, h1 |) = f (frame `star` locks_invariant e m0) h0 in calc (equiv) { fp' x `star` (frame `star` locks_invariant e m0); (equiv) { star_associative (fp' x) frame (locks_invariant e m0) } fp' x `star` frame `star` locks_invariant e m0; }; assert (H.interp (fp' x `star` (frame `star` locks_invariant e m0)) h1); assert (H.interp (fp' x `star` frame `star` locks_invariant e m0) h1); let m1 = hmem_of_hheap m0 h1 in assert (mem_evolves m0 m1); mprop_preservation_of_hprop_preservation (frame `star` locks_invariant e m0) m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)); (| x, m1 |) let lift_tot_action_with_frame #a #e #fp #fp' ($f:tot_action_with_frame_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in assert (inames_ok e m0); ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); let m0' : hmem_with_inv_except e fp = m0 in let r = f frame m0' in let (| x, m1 |) = r in ac_reasoning_for_m_frame_preserving (fp' x) frame (locks_invariant e m1) m1; assert (interp (fp' x `star` frame `star` locks_invariant e m1) m1); assert (interp (fp' x `star` locks_invariant e m1) m1); let m1' : hmem_with_inv_except e (fp' x) = m1 in NMSTTotal.put #_ #(mem_evolves) m1; x let sel_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.sel_action #a #pcm r v0)) let upd_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.upd_action #a #pcm r v0 v1)) let free_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.free_action #a #pcm r v0)) let split_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.split_action #a #pcm r v0 v1)) let gather_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.gather_action #a #pcm r v0 v1)) let weaken (p q r:slprop) (h:H.hheap (p `star` q) { H.stronger q r }) : H.hheap (p `star` r) = H.weaken p q r h; h let weaken_pure (q r: prop) : Lemma (requires (q ==> r)) (ensures H.stronger (H.pure q) (H.pure r)) = let aux (h:H.heap) : Lemma (ensures (H.interp (H.pure q) h ==> H.interp (H.pure r) h)) [SMTPat ()] = H.pure_interp q h; H.pure_interp r h in () let inc_ctr (#p:slprop) #e (m:hmem_with_inv_except e p) : m':hmem_with_inv_except e p{m'.ctr = m.ctr + 1 /\ H.stronger (linv e m) (linv e m')} = let m' : mem = { m with ctr = m.ctr + 1} in assert (interp (p `star` linv e m) m'); assert (linv e m == lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m)); assert (linv e m' == lock_store_invariant e m.locks `star` ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken_free_above (heap_of_mem m) m.ctr (m.ctr + 1); weaken_pure (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_ctr_valid (m.ctr + 1) (heap_of_mem m)); assert (H.stronger (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m))); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)); H.stronger_star (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken (p `star` lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)) (heap_of_mem m'); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity (m.ctr + 1) (heap_of_mem m)); let m' : hmem_with_inv_except e p = m' in m' let frame_related_mems (fp0 fp1:slprop u#a) e (m0:hmem_with_inv_except e fp0) (m1:hmem_with_inv_except e fp1) = forall (frame:slprop u#a). interp ((fp0 `star` frame) `star` linv e m0) m0 ==> interp ((fp1 `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) let refined_pre_action e (fp0:slprop) (a:Type) (fp1:a -> slprop) = m0:hmem_with_inv_except e fp0 -> Pure (x:a & hmem_with_inv_except e (fp1 x)) (requires True) (ensures fun (| x, m1 |) -> frame_related_mems fp0 (fp1 x) e m0 m1) let refined_pre_action_as_action (#fp0:slprop) (#a:Type) (#fp1:a -> slprop) #e ($f:refined_pre_action e fp0 a fp1) : tot_action_nf_except e fp0 a fp1 = let g : tot_pre_action_nf_except e fp0 a fp1 = fun m -> f m in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp0 `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp1 x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x', m1' |) = g m0 in let (| x, m1 |) = f m0 in assert (x == x' /\ m1 == m1') in g let alloc_action #a #pcm e x = let f : refined_pre_action e emp (ref a pcm) (fun r -> pts_to r x) = fun m0 -> (* NS: 9/29/22 I needed to annotate h : Heap.full_heap, for use with the Core checker which generates a guard for checking the implicit pattern "dot" term in the dependent pair pattern on the next line. That guard expects `h` to be a full_heap, which is it, because it is a projection of m0. However, this is not reflected in `h`'s type. So, the Core checker, which produces a guard for the pat_dot_term in isolation, cannot recheck the term. If we were to fold in the checking of pat_dot_terms and their guards with the rest of the VC, this would work. *) let h : Heap.full_heap = hheap_of_hmem m0 in let (|r, h'|) = H.extend #a #pcm x m0.ctr h in let m' : hmem_with_inv_except e emp = inc_ctr m0 in let h' : H.hheap (pts_to #a #pcm r x `star` linv e m') = weaken _ (linv e m0) (linv e m') h' in let m1 : hmem_with_inv_except e (pts_to #a #pcm r x) = hmem_of_hheap m' h' in assert (forall frame. H.frame_related_heaps h h' emp (pts_to #a #pcm r x) frame true); let aux (frame:slprop) : Lemma (requires interp ((emp `star` frame) `star` linv e m0) m0) (ensures interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) [SMTPat (emp `star` frame)] = star_associative emp frame (linv e m0); assert (H.interp (emp `star` (frame `star` linv e m0)) h); assert (H.interp (pts_to #a #pcm r x `star` (frame `star` linv e m0)) h'); star_associative (pts_to #a #pcm r x) frame (linv e m0); assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m0) h'); assert (H.stronger (linv e m0) (linv e m')); assert (H.equiv (linv e m') (linv e m1)); assert (H.stronger (linv e m0) (linv e m1)); let h' : H.hheap ((pts_to #a #pcm r x `star` frame) `star` linv e m1) = weaken _ (linv e m0) (linv e m1) h' in assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) h'); assert (forall (mp:H.hprop frame). mp h == mp h'); mprop_preservation_of_hprop_preservation frame m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) in assert (frame_related_mems emp (pts_to r x) e m0 m1); (| r, m1 |) in lift_tot_action (refined_pre_action_as_action f) let select_refine #a #p e r x f = lift_tot_action (lift_heap_action e (H.select_refine #a #p r x f)) let upd_gen #a #p e r x y f = lift_tot_action (lift_heap_action e (H.upd_gen_action r x y f)) //////////////////////////////////////////////////////////////////////////////// // witness / recall //////////////////////////////////////////////////////////////////////////////// let witnessed_ref #a #pcm (r:ref a pcm) (fact:property a) (m:full_mem) = H.witnessed_ref #a #pcm r fact (heap_of_mem m) let witnessed_ref_stability #a #pcm (r:ref a pcm) (fact:property a) : Lemma (requires FStar.Preorder.stable fact (Steel.Preorder.preorder_of_pcm pcm)) (ensures FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) = H.witnessed_ref_stability #a #pcm r fact let witnessed (#a:Type u#1) (#pcm:pcm a) (r:ref a pcm) (fact:property a) = W.witnessed _ mem_evolves (witnessed_ref r fact) let rearrange_pqr_prq (p q r:slprop) : Lemma (((p `star` q) `star` r) `equiv` ((p `star` r) `star` q)) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_associative p q r } p `star` (q `star` r); (equiv) { star_commutative q r; star_congruence p (q `star` r) p (r `star` q) } p `star` (r `star` q); (equiv) { star_associative p r q } (p `star` r) `star` q; } let preserves_frame_cong (e:inames) (p q:slprop) (r s:slprop) (m0 m1:mem) : Lemma (requires p `equiv` r /\ q `equiv` s /\ preserves_frame e p q m0 m1) (ensures preserves_frame e r s m0 m1) = let aux0 (p q r s:slprop) : Lemma (requires p `equiv` s) (ensures (((p `star` q) `star` r) `equiv` ((s `star` q) `star` r))) = star_congruence p q s q; star_congruence (p `star` q) r (s `star` q) r in let aux (frame:slprop) : Lemma (requires interp ((r `star` frame) `star` locks_invariant e m0) m0) (ensures interp ((s `star` frame) `star` locks_invariant e m1) m1 /\ interp ((p `star` frame) `star` locks_invariant e m0) m0) [SMTPat (r `star` frame)] = aux0 p frame (locks_invariant e m0) r; aux0 q frame (locks_invariant e m1) s; assert (((p `star` frame) `star` locks_invariant e m0) `equiv` ((r `star` frame) `star` locks_invariant e m0)); assert (interp ((p `star` frame) `star` locks_invariant e m0) m0); assert (interp ((q `star` frame) `star` locks_invariant e m1) m1); assert (((q `star` frame) `star` locks_invariant e m1) `equiv` ((s `star` frame) `star` locks_invariant e m1)); () in () let pure_true_equiv (p:slprop) : Lemma ((p `star` pure True) `equiv` p) = FStar.Classical.forall_intro (pure_star_interp p True); emp_unit p; assert ((p `star` pure True) `equiv` p) let preserves_frame_star_pure (e:inames) (p q:slprop) (r s:prop) (m:mem) : Lemma (requires r /\ s) (ensures preserves_frame e p q m m <==> preserves_frame e (p `star` pure r) (q `star` pure s) m m) = pure_equiv r True; star_congruence p (pure r) p (pure True); pure_equiv s True; star_congruence q (pure s) q (pure True); pure_true_equiv p; pure_true_equiv q; let fwd () : Lemma (requires preserves_frame e p q m m) (ensures preserves_frame e (p `star` pure r) (q `star` pure s) m m) [SMTPat ()] = preserves_frame_cong e p q (p `star` pure r) (q `star` pure s) m m in let bk () : Lemma (requires preserves_frame e (p `star` pure r) (q `star` pure s) m m) (ensures preserves_frame e p q m m) [SMTPat ()] = preserves_frame_cong e (p `star` pure r) (q `star` pure s) p q m m in () let witness (#a:Type) (#pcm:pcm a) (e:inames) (r:erased (ref a pcm)) (fact:stable_property pcm) (v:Ghost.erased a) (_:squash (forall z. compatible pcm v z ==> fact z)) (frame:slprop) : MstTot (witnessed r fact) e (pts_to r v) (fun _ -> pts_to r v) frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in let _ : unit = let hr : H.ref a pcm = r in let v' = H.sel_v hr v (heap_of_mem m0) in assert (interp (H.ptr hr) m0 /\ H.sel #a #pcm hr (heap_of_mem m0) == v'); assert (compatible pcm v v'); assert (fact v'); assert (witnessed_ref r fact m0); witnessed_ref_stability r fact; assert (FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) in let w = NMSTTotal.witness _ mem_evolves (witnessed_ref r fact) in w let recall (#a:Type u#1) (#pcm:pcm a) (#fact:property a) (e:inames) (r:erased (ref a pcm)) (v:Ghost.erased a) (w:witnessed r fact) (frame:slprop) = let m0 = NMSTTotal.get () in NMSTTotal.recall _ mem_evolves (witnessed_ref r fact) w; let hr : H.ref a pcm = r in assert (witnessed_ref r fact m0); let v1 = H.sel_v hr v (heap_of_mem m0) in assert (compatible pcm v v1); assert (H.sel hr (heap_of_mem m0) == v1); assert (fact v1); assert (interp ((pts_to r v `star` frame) `star` locks_invariant e m0) m0); emp_unit ((pts_to r v `star` frame) `star` locks_invariant e m0); pure_star_interp ((pts_to r v `star` frame) `star` locks_invariant e m0) (fact v1) m0; assert (interp (((pts_to r v `star` frame) `star` locks_invariant e m0) `star` pure (fact v1)) m0); rearrange_pqr_prq (pts_to r v `star` frame) (locks_invariant e m0) (pure (fact v1)); assert (interp (((pts_to r v `star` frame) `star` pure (fact v1)) `star` locks_invariant e m0) m0); rearrange_pqr_prq (pts_to r v) frame (pure (fact v1)); star_congruence ((pts_to r v `star` frame) `star` pure (fact v1)) (locks_invariant e m0) ((pts_to r v `star` pure (fact v1)) `star` frame) (locks_invariant e m0); Ghost.hide v1 let iname_for_p_mem (i:iname) (p:slprop) : W.s_predicate mem = fun m -> iname_for_p i p m.locks let iname_for_p_stable (i:iname) (p:slprop) : Lemma (W.stable full_mem mem_evolves (iname_for_p_mem i p)) = () let ( >--> ) (i:iname) (p:slprop) : Type0 = W.witnessed full_mem mem_evolves (iname_for_p_mem i p) let hmem_with_inv_equiv e (m:mem) (p:slprop) : Lemma (interp (p `star` linv e m) m <==> interp (p `star` lock_store_invariant e m.locks) m /\ heap_ctr_valid m.ctr (heap_of_mem m)) = calc (<==>) { interp (p `star` linv e m) m; (<==>) { H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) } interp ((p `star` lock_store_invariant e m.locks) `star` ctr_validity m.ctr (heap_of_mem m)) m; (<==>) { H.pure_star_interp (p `star` lock_store_invariant e m.locks) (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_of_mem m) } interp ((p `star` lock_store_invariant e m.locks) `star` emp) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); (<==>) { H.emp_unit (p `star` lock_store_invariant e m.locks) } interp (p `star` lock_store_invariant e m.locks) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); } let new_invariant_tot_action (e:inames) (p:slprop) (m0:hmem_with_inv_except e p{ e `inames_in` m0.locks }) : Pure (iname & hmem_with_inv_except e emp) (requires True) (ensures fun (i, m1) -> iname_for_p_mem i p m1 /\ frame_related_mems p emp e m0 m1 /\ mem_evolves m0 m1) = let (| i, l1 |) = extend_lock_store e m0.locks p in let m1 = { m0 with locks = l1 } in assert (lock_store_invariant e m1.locks == p `star` lock_store_invariant e m0.locks); calc (equiv) { linv e m1; (equiv) {} (lock_store_invariant e m1.locks `star` ctr_validity m1.ctr (heap_of_mem m1)); (equiv) {} ((p `star` lock_store_invariant e m0.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); (equiv) { H.star_associative p (lock_store_invariant e m0.locks) (ctr_validity m1.ctr (heap_of_mem m1)) } (p `star` (lock_store_invariant e m0.locks `star` ctr_validity m1.ctr (heap_of_mem m1))); (equiv) { } (p `star` linv e m0); }; assert (iname_for_p_mem i p m1); assert (lock_store_evolves m0.locks l1); assert (mem_evolves m0 m1); hmem_with_inv_equiv e m0 p; assert (interp (p `star` lock_store_invariant e m0.locks) m1); assert (interp (lock_store_invariant e m1.locks) m1); H.emp_unit (lock_store_invariant e m1.locks); H.star_commutative (lock_store_invariant e m1.locks) emp; assert (interp (emp `star` lock_store_invariant e m1.locks) m1); hmem_with_inv_equiv e m1 emp; let m1 : hmem_with_inv_except e emp = m1 in let aux (frame:slprop) : Lemma (requires interp ((p `star` frame) `star` linv e m0) m0) (ensures interp ((emp `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) <==> mp (core_mem m1))) [SMTPat (p `star` frame)] = assert (interp ((p `star` frame) `star` linv e m0) m1); calc (equiv) { ((p `star` frame) `star` linv e m0); (equiv) { H.star_commutative p frame; H.star_congruence (p `star` frame) (linv e m0) (frame `star` p) (linv e m0); H.star_associative frame p (linv e m0) } (frame `star` (p `star` linv e m0)); (equiv) { H.star_congruence frame (p `star` linv e m0) frame (linv e m1) } (frame `star` linv e m1); (equiv) { H.emp_unit (frame `star` linv e m1); H.star_commutative (frame `star` linv e m1) emp; H.star_associative emp frame (linv e m1) } ((emp `star` frame) `star` linv e m1); }; assert (interp ((emp `star` frame) `star` linv e m1) m1) in assert (frame_related_mems p emp e m0 m1); ( i, m1 )

{ "checked_file": "/", "dependencies": [ "Steel.Preorder.fst.checked", "Steel.Heap.fsti.checked", "prims.fst.checked", "FStar.Witnessed.Core.fsti.checked", "FStar.Set.fsti.checked", "FStar.Preorder.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.PCM.fst.checked", "FStar.NMSTTotal.fst.checked", "FStar.List.Tot.fst.checked", "FStar.IndefiniteDescription.fsti.checked", "FStar.Ghost.fsti.checked", "FStar.FunctionalExtensionality.fsti.checked", "FStar.Classical.Sugar.fsti.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Steel.Memory.fst" }

[ { "abbrev": true, "full_module": "Steel.Preorder", "short_module": "PP" }, { "abbrev": true, "full_module": "FStar.Witnessed.Core", "short_module": "W" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": true, "full_module": "Steel.Heap", "short_module": "H" }, { "abbrev": false, "full_module": "FStar.PCM", "short_module": null }, { "abbrev": false, "full_module": "FStar.FunctionalExtensionality", "short_module": null }, { "abbrev": true, "full_module": "FStar.FunctionalExtensionality", "short_module": "F" }, { "abbrev": false, "full_module": "FStar.PCM", "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

i: Steel.Memory.iname -> m0: Steel.Memory.full_mem -> Prims.prop

Prims.Tot

[ "total" ]

[]

[ "Steel.Memory.iname", "Steel.Memory.full_mem", "Prims.b2t", "Prims.op_LessThan", "FStar.List.Tot.Base.length", "Steel.Memory.lock_state", "Steel.Memory.__proj__Mkmem__item__locks", "Prims.prop" ]

[]

false

true

let name_is_ok (i: iname) (m0: full_mem u#1) : prop =

i < List.Tot.length m0.locks

false

Steel.Memory.fst

Steel.Memory.name_of_pre_inv

val name_of_pre_inv (i:pre_inv) : GTot iname

let name_of_pre_inv (i:pre_inv) = dfst i

{ "file_name": "lib/steel/Steel.Memory.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 40, "end_line": 1259, "start_col": 0, "start_line": 1259 }

(* 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.Memory module F = FStar.FunctionalExtensionality open FStar.FunctionalExtensionality open FStar.PCM module H = Steel.Heap noeq type lock_state : Type u#(a + 1) = | Invariant : inv:H.slprop u#a -> lock_state let lock_store : Type u#(a+1) = list (lock_state u#a) noeq type mem : Type u#(a + 1) = { ctr: nat; heap: H.heap u#a; locks: lock_store u#a; } let heap_of_mem (x:mem) : H.heap = x.heap let mem_of_heap (h:H.heap) : mem = { ctr = 0; heap = h; locks = [] } let mem_set_heap (m:mem) (h:H.heap) : mem = { ctr = m.ctr; heap = h; locks = m.locks; } let core_mem (m:mem) : mem = mem_of_heap (heap_of_mem m) let core_mem_invol m = () let disjoint (m0 m1:mem u#h) : prop = m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks let disjoint_sym m0 m1 = () let join m0 m1 = { ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = m0.locks } let join_commutative m0 m1 = H.join_commutative m0.heap m1.heap let disjoint_join m0 m1 m2 = H.disjoint_join m0.heap m1.heap m2.heap let join_associative m0 m1 m2 = H.join_associative m0.heap m1.heap m2.heap let slprop = H.slprop let interp p m = H.interp p m.heap let equiv p1 p2 = forall m. interp p1 m <==> interp p2 m let slprop_extensionality p q = assert (forall m. interp p m <==> interp q m); let aux (h:H.heap) : Lemma (H.interp p h <==> H.interp q h) [SMTPat (H.interp p h)] = let m : mem = { ctr = 0; heap = h; locks = [] } in assert (interp p m <==> interp q m) in assert (forall h. H.interp p h <==> H.interp q h); Steel.Heap.slprop_extensionality p q let reveal_equiv p1 p2 = () let core_ref = H.core_ref let core_ref_null = H.core_ref_null let core_ref_is_null r = H.core_ref_is_null r let emp : slprop u#a = H.emp let pure = H.pure let pts_to = H.pts_to let h_and = H.h_and let h_or = H.h_or let star = H.star let wand = H.wand let h_exists = H.h_exists let h_forall = H.h_forall //////////////////////////////////////////////////////////////////////////////// //properties of equiv //////////////////////////////////////////////////////////////////////////////// let equiv_symmetric (p1 p2:slprop u#a) = H.equiv_symmetric p1 p2 #push-options "--warn_error -271" let equiv_heap_iff_equiv (p1 p2:slprop u#a) : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat (equiv p1 p2)] = let aux_lr () : Lemma (requires H.equiv p1 p2) (ensures equiv p1 p2) [SMTPat ()] = () in let aux_rl_helper1 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p1 h) (ensures H.interp p2 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl_helper2 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p2 h) (ensures H.interp p1 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl () : Lemma (requires equiv p1 p2) (ensures H.equiv p1 p2) [SMTPat ()] = () in () let equiv_heap_iff_equiv_forall () : Lemma (ensures (forall p1 p2. H.equiv p1 p2 <==> equiv p1 p2)) = let aux p1 p2 : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat ()] = equiv_heap_iff_equiv p1 p2 in () #pop-options let equiv_extensional_on_star (p1 p2 p3:slprop u#a) = equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3 let emp_unit p = H.emp_unit p let intro_emp m = H.intro_emp (heap_of_mem m) let pure_equiv p q = H.pure_equiv p q let pure_interp q m = H.pure_interp q (heap_of_mem m) let pure_star_interp p q m = H.pure_star_interp p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// //pts_to //////////////////////////////////////////////////////////////////////////////// let pts_to_compatible #a #pcm x v0 v1 m = H.pts_to_compatible #a #pcm x v0 v1 (heap_of_mem m) let pts_to_compatible_equiv #a #pcm x v0 v1 = H.pts_to_compatible_equiv #a #pcm x v0 v1 let pts_to_not_null #a #pcm x v m = H.pts_to_not_null #a #pcm x v (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // star //////////////////////////////////////////////////////////////////////////////// let intro_star p q mp mq = H.intro_star p q (heap_of_mem mp) (heap_of_mem mq) let elim_star p q m = let h = heap_of_mem m in H.elim_star p q h; assert (exists hl hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr); let hl = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hl -> exists hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let hr = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hr -> H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let ml = mem_set_heap m hl in let mr = mem_set_heap m hr in assert (disjoint ml mr); assert (m == join ml mr); assert (interp p ml); assert (interp q mr); () let interp_star (p q: slprop) (m: mem) : Lemma (interp (p `star` q) m <==> (exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m)) = let left = interp (p `star` q) m in let right = exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m in let f () : Lemma (requires left) (ensures right) = elim_star p q m in let g () : Lemma (requires right) (ensures left) = Classical.exists_elim left #_ #(fun mp -> exists (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mp -> Classical.exists_elim left #_ #(fun mq -> disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mq -> intro_star p q mp mq ) ) in Classical.move_requires f (); Classical.move_requires g () let star_commutative (p1 p2:slprop) = H.star_commutative p1 p2 let star_associative (p1 p2 p3:slprop) = H.star_associative p1 p2 p3 let star_congruence (p1 p2 p3 p4:slprop) = equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4 let affine_star (p q:slprop) (m:mem) = H.affine_star p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // Invariants on the lock store //////////////////////////////////////////////////////////////////////////////// let iname = nat module S = FStar.Set module L = FStar.List.Tot module W = FStar.Witnessed.Core let rec lock_store_invariant (e:inames) (l:lock_store u#a) : slprop u#a = let current_addr = L.length l - 1 in match l with | [] -> emp | Invariant p :: tl -> if current_addr `S.mem` e then lock_store_invariant e tl else p `star` lock_store_invariant e tl let lock_i (i:iname) (l:lock_store { i < L.length l }) = let ix = L.length l - i - 1 in L.index l ix let iname_for_p (i:iname) (p:slprop) : W.s_predicate lock_store = fun l -> i < L.length l /\ (lock_i i l).inv == p let lock_store_evolves : FStar.Preorder.preorder lock_store = fun (l1 l2 : lock_store) -> L.length l2 >= L.length l1 /\ (forall (i:nat{i < L.length l1}). (lock_i i l1).inv == (lock_i i l2).inv) let inames_in (e:inames) (l:lock_store) : prop = forall i. Set.mem i e ==> i < L.length l let inames_ok e m = inames_in e m.locks let inames_ok_empty m = () let extend_lock_store (e:inames) (l:lock_store{e `inames_in` l}) (p:slprop) : i:iname & l':lock_store { lock_store_invariant e l' == p `star` lock_store_invariant e l /\ iname_for_p i p l' } = (| L.length l, Invariant p :: l |) let set_add (i:iname) (s:inames) = Set.union (Set.singleton i) s let rec move_invariant (e:inames) (l:lock_store) (p:slprop) (i:iname{iname_for_p i p l /\ ~(i `Set.mem` e)}) : Lemma (H.equiv (lock_store_invariant e l) (p `star` lock_store_invariant (set_add i e) l)) = let rec aux (i:iname) (m:lock_store) : Lemma (requires i >= L.length m) (ensures (lock_store_invariant e m `H.equiv` lock_store_invariant (set_add i e) m)) = match m with | [] -> () | Invariant p::tl -> aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl) in let current_addr = L.length l - 1 in match l with | [] -> () | Invariant q::tl -> if i = current_addr then begin assert (lock_store_invariant e l == p `star` lock_store_invariant e tl); aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl); () end else begin move_invariant e tl p i; assert (lock_store_invariant e tl `equiv` (p `star` lock_store_invariant (set_add i e) tl)); H.star_congruence q (lock_store_invariant e tl) q (p `star` lock_store_invariant (set_add i e) tl); if Set.mem current_addr e then () else begin let r = lock_store_invariant (set_add i e) tl in assert (lock_store_invariant e l `equiv` (q `star` (p `star` r))); H.star_associative q p r; H.star_commutative q p; H.star_congruence (q `star` p) r (p `star` q) r; H.star_associative p q r end end let heap_ctr_valid (ctr:nat) (h:H.heap u#a) : prop = h `H.free_above_addr` ctr let ctr_validity (ctr:nat) (h:H.heap) : slprop = H.pure (heap_ctr_valid ctr h) let locks_invariant (e:inames) (m:mem u#a) : slprop u#a = lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m) let full_mem_pred (m:mem) = H.full_heap_pred (heap_of_mem m) (***** Following lemmas are needed in Steel.Effect *****) let core_mem_interp (hp:slprop u#a) (m:mem u#a) = () let interp_depends_only_on (hp:slprop u#a) = H.interp_depends_only_on hp let a_mem_prop_as_a_heap_prop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (H.a_heap_prop u#a) = let g (h: H.heap u#a) : Tot prop = interp sl (mem_of_heap h) /\ f (mem_of_heap h) in let phi0 (h0 h1: H.heap u#a) : Lemma (requires (g h0 /\ H.disjoint h0 h1)) (ensures (g h0 /\ H.disjoint h0 h1 /\ g (H.join h0 h1))) = assert (mem_of_heap (H.join h0 h1) == mem_of_heap h0 `join` mem_of_heap h1); interp_depends_only_on sl in let phi1 (h0 h1: H.heap u#a) : Lemma (ensures ((g h0 /\ H.disjoint h0 h1) ==> g (H.join h0 h1))) = Classical.move_requires (phi0 h0) h1 in Classical.forall_intro_2 phi1; g let refine_slprop sl f = H.as_slprop (a_mem_prop_as_a_heap_prop sl f) let interp_refine_slprop sl f m = assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_mem m)) let dep_hprop (s: slprop) (f: (hmem s -> Tot slprop)) (h: H.heap) : Tot prop = exists (h1: H.heap) . exists (h2: H.heap) . interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 let dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq' : squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h')) = let p2 (h h1 h2: H.heap) : Tot prop = interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 in let p1 (h h1: H.heap) : Tot prop = (exists h2 . p2 h h1 h2) in let h1 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p1 h) in let h2 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p2 h h1) in H.disjoint_join h' h1 h2; assert (H.disjoint h2 h'); let h2' = H.join h2 h' in H.join_commutative h2 h' ; assert (h2' == H.join h' h2); assert (H.disjoint h1 h2'); assert (mem_of_heap h2' == mem_of_heap h2 `join` mem_of_heap h'); interp_depends_only_on (f (mem_of_heap h1)); assert (interp (f (mem_of_heap h1)) (mem_of_heap h2')); H.join_commutative h1 h2; H.join_associative h' h2 h1; H.join_commutative h' h; H.join_commutative h2' h1; assert (H.join h h' == h1 `H.join` h2') let impl_intro_gen (#p: Type0) (#q: Type0) ($prf: (squash p -> Lemma (q ))) : Lemma (p ==> q) = Classical.impl_intro_gen #p #(fun _ -> q) prf let dep_hprop_is_affine1 (s: slprop) (f: (hmem s -> Tot slprop)) (h0 h1: H.heap) : Lemma ((dep_hprop s f h0 /\ H.disjoint h0 h1) ==> (H.disjoint h0 h1 /\ dep_hprop s f (H.join h0 h1))) = impl_intro_gen (dep_hprop_is_affine0 s f h0 h1) let dep_hprop_is_affine (s: slprop) (f: (hmem s -> Tot slprop)) : Lemma (H.heap_prop_is_affine (dep_hprop s f)) = Classical.forall_intro_2 (dep_hprop_is_affine1 s f) let sdep (s: slprop) (f: (hmem s -> Tot slprop)) : Tot slprop = dep_hprop_is_affine s f; H.as_slprop (dep_hprop s f) let interp_sdep (s: slprop) (f: (hmem s -> Tot slprop)) (m: mem) : Lemma (requires (dep_slprop_is_affine s f)) (ensures ( interp (sdep s f) m <==> (exists m1 m2 . interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) )) = dep_hprop_is_affine s f; assert (forall m1 m2 . (interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) ==> ( interp s (mem_of_heap m1.heap) /\ interp (f (mem_of_heap m1.heap)) (mem_of_heap m2.heap) /\ H.disjoint m1.heap m2.heap /\ H.join m1.heap m2.heap == m.heap )); interp_depends_only_on s; Classical.forall_intro (fun m -> interp_depends_only_on (f m)); assert (forall h1 h2 . (interp s (mem_of_heap h1) /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ H.disjoint h1 h2 /\ H.join h1 h2 == m.heap) ==> ( core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ interp s (core_mem (mem_of_heap h1)) /\ interp s (mem_set_heap m h1) /\ core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ f (mem_set_heap m h1) `equiv` f (mem_of_heap h1) /\ interp (f (mem_set_heap m h1)) (mem_of_heap h2) /\ interp (f (mem_set_heap m h1)) (mem_set_heap m h2) /\ disjoint (mem_set_heap m h1) (mem_set_heap m h2) /\ join (mem_set_heap m h1) (mem_set_heap m h2) == m )); () let h_exists_cong (#a:Type) (p q : a -> slprop) : Lemma (requires (forall x. p x `equiv` q x)) (ensures (h_exists p `equiv` h_exists q)) = equiv_heap_iff_equiv_forall (); H.h_exists_cong p q let intro_h_exists #a x p m = H.intro_h_exists x p (heap_of_mem m) let elim_h_exists (#a:_) (p:a -> slprop) (m:mem) = H.elim_h_exists p (heap_of_mem m) let intro_h_forall (#a:_) (p:a -> slprop) (m:mem) = H.intro_h_forall p (heap_of_mem m) let elim_h_forall (#a:_) (p:a -> slprop) (m:mem) (x:a) = H.elim_h_forall p (heap_of_mem m) x let intro_h_and (p q: slprop) (m:mem) = H.intro_h_and p q (heap_of_mem m) let elim_h_and (p q: slprop) (m:mem) = H.elim_h_and p q (heap_of_mem m) let intro_h_or_left (p q: slprop) (m:mem) = H.intro_h_or_left p q (heap_of_mem m) let intro_h_or_right (p q: slprop) (m:mem) = H.intro_h_or_right p q (heap_of_mem m) let elim_h_or (p q: slprop) (m:mem) = H.elim_h_or p q (heap_of_mem m) let intro_wand (p1 p2: slprop u#a) (m:mem) = introduce (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)) ==> interp (wand p1 p2) m with _. ( assert (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)); H.intro_wand p1 p2 (heap_of_mem m); let h = heap_of_mem m in assert ((forall h1. h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) ==> H.interp (wand p1 p2) h); introduce forall h1. (h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) with ( introduce (h `H.disjoint` h1 /\ H.interp p1 h1) ==> H.interp p2 (H.join h h1) with _. ( assert (h `H.disjoint` h1); let m1 = { ctr = m.ctr; heap = h1; locks = m.locks } in assert (m `disjoint` m1) ) ) ) (** Eliminating a wand by proving a heap that satisfies the LHS **) let elim_wand (p1 p2: slprop u#a) (m:mem) (m1:mem) = H.elim_wand p1 p2 (heap_of_mem m) (heap_of_mem m1) //////////////////////////////////////////////////////////////////////////////// // Preorders and effects //////////////////////////////////////////////////////////////////////////////// module PP = Steel.Preorder let mem_evolves = fun (m0 m1:full_mem) -> H.heap_evolves (heap_of_mem m0) (heap_of_mem m1) /\ m0.ctr <= m1.ctr /\ lock_store_evolves m0.locks m1.locks (** See [Steel.Heap.is_frame_preserving]. We add in [lock_invariants] now *) let preserves_frame (e:inames) (pre post:slprop) (m0 m1:mem) = forall (frame:slprop). interp ((pre `star` frame) `star` locks_invariant e m0) m0 ==> (interp ((post `star` frame) `star` locks_invariant e m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) (** This is a version of MstTot with frame quantified, as part of preserves_frame *) effect MstTotNF (a:Type u#a) (except:inames) (expects:slprop u#1) (provides: a -> slprop u#1) = NMSTTotal.NMSTATETOT a (full_mem u#1) mem_evolves (requires fun m0 -> inames_ok except m0 /\ interp (expects `star` locks_invariant except m0) m0) (ensures fun m0 x m1 -> inames_ok except m1 /\ interp (provides x `star` locks_invariant except m1) m1 /\ preserves_frame except expects (provides x) m0 m1) //////////////////////////////////////////////////////////////////////////////// // Lifting heap actions //////////////////////////////////////////////////////////////////////////////// (** Heap actions come in two equivalent flavors: - one that take an explicit frame as argument (action_with_frame) - and one that quantify over all the frame We therefore define two lift routes: - a direct route for those with explicit frame - via MstTotNF for the rest *) let tot_pre_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = hmem_with_inv_except e fp -> (x:a & hmem_with_inv_except e (fp' x)) let tot_pre_action_nf = tot_pre_action_nf_except S.empty let ac_reasoning_for_m_frame_preserving (p q r:slprop u#a) (m:mem u#a) : Lemma (requires interp ((p `star` q) `star` r) m) (ensures interp (p `star` r) m) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_commutative p q; equiv_extensional_on_star (p `star` q) (q `star` p) r } (q `star` p) `star` r; (equiv) { star_associative q p r } q `star` (p `star` r); }; assert (interp (q `star` (p `star` r)) m); affine_star q (p `star` r) m let is_frame_preserving (#e:inames) (#a:Type u#b) (#fp:slprop u#a) (#fp':a -> slprop u#a) (f:tot_pre_action_nf_except e fp a fp') = forall (frame:slprop u#a) (m0:hmem_with_inv_except e (fp `star` frame)). (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = f:tot_pre_action_nf_except e fp a fp'{ is_frame_preserving f } let tot_action_nf = tot_action_nf_except S.empty let linv e (m:mem) = locks_invariant e m let hheap_of_hmem #fp #e (m:hmem_with_inv_except e fp) : h:H.hheap (fp `star` linv e m) { h `H.free_above_addr` m.ctr} = let h = heap_of_mem m in H.pure_interp (heap_ctr_valid m.ctr (heap_of_mem m)) h; h let hmem_of_hheap #e (#fp0 #fp1:slprop) (m:hmem_with_inv_except e fp0) (h:H.full_hheap (fp1 `star` linv e m) { h `Heap.free_above_addr` m.ctr }) : m1:hmem_with_inv_except e fp1{linv e m `equiv` linv e m1} = let m1 : mem = { m with heap = h } in assert (interp (fp1 `star` linv e m) m1); star_commutative fp1 (linv e m); assert (interp (linv e m `star` fp1) m1); assert (linv e m1 == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); assert (linv e m == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m)); H.pure_interp (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_of_mem m); assert (heap_ctr_valid m1.ctr (heap_of_mem m) <==> heap_ctr_valid m1.ctr (heap_of_mem m1)); H.pure_equiv (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_ctr_valid m1.ctr (heap_of_mem m1)); H.star_congruence (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m)); assert (linv e m `equiv` linv e m1); let _ = equiv_extensional_on_star (linv e m) (linv e m1) fp1 in assert ((linv e m `star` fp1) `equiv` (linv e m1 `star` fp1)); assert (interp (linv e m1 `star` fp1) m1); star_commutative (linv e m1) fp1; assert (interp (fp1 `star` linv e m1) m1); m1 let with_inv_except (m:mem) e (fp:slprop) = interp (fp `star` locks_invariant e m) m #push-options "--warn_error -271" let as_hprop (frame:slprop) (mp:mprop frame) : hp:H.hprop frame{forall m. mp (core_mem m) == hp (heap_of_mem m)} = let f = fun h -> mp (mem_of_heap h) in assert (forall m. mp (core_mem m) == f (heap_of_mem m)); let aux (m0:H.hheap frame) (m1:H.heap{H.disjoint m0 m1}) : Lemma (ensures (mem_of_heap (H.join m0 m1) == join (mem_of_heap m0) (mem_of_heap m1))) [SMTPat ()] = () in f let mprop_preservation_of_hprop_preservation (p:slprop) (m0 m1:mem) : Lemma (requires (forall (hp:H.hprop p). hp (heap_of_mem m0) == hp (heap_of_mem m1))) (ensures (forall (mp:mprop p). mp (core_mem m0) == mp (core_mem m1))) = let aux (mp:mprop p) : Lemma (mp (core_mem m0) == mp (core_mem m1)) [SMTPat()] = assert (as_hprop p mp (heap_of_mem m0) == as_hprop p mp (heap_of_mem m1)) in () let lift_heap_action (#fp:slprop) (#a:Type) (#fp':a -> slprop) (e:inames) ($f:H.action fp a fp') : tot_action_nf_except e fp a fp' = let g : tot_pre_action_nf_except e fp a fp' = fun m -> let h0 = hheap_of_hmem m in let (| x, h' |) = f h0 in (| x, hmem_of_hheap m h' |) in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in let h0 = hheap_of_hmem m0 in let (| x', h1 |) = f h0 in H.action_framing f (linv e m0) h0; assert (x == x'); star_associative fp frame (linv e m0); H.action_framing f (frame `star` linv e m0) h0; assert (H.interp ((fp' x) `star` (frame `star` linv e m0)) h1); star_associative (fp' x) frame (linv e m0); assert (H.interp ((fp' x `star` frame) `star` linv e m0) h1); let h1' : H.hheap ((fp' x `star` frame) `star` linv e m0) = h1 in assert (m1 == hmem_of_hheap m0 h1'); assert (with_inv_except m1 e (fp' x `star` frame)); assert (forall (hp:H.hprop frame). hp h0 == hp h1); mprop_preservation_of_hprop_preservation frame m0 m1; () in assert (is_frame_preserving g); g let frame_preserving_respects_preorder #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (m0:hmem_with_inv_except e fp) : Lemma (let (| x, m1 |) = f m0 in mem_evolves m0 m1) = let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1) = () in H.emp_unit fp; assert (interp (fp `star` linv e m0) m0); H.star_congruence (fp `star` emp) (linv e m0) fp (linv e m0); assert (interp ((fp `star` emp) `star` linv e m0) m0); aux emp m0 let lift_tot_action_nf #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') : MstTotNF a e fp fp' = let m0 = NMSTTotal.get () in let m0' : hmem_with_inv_except e fp = m0 in let r = f m0' in let (| x, m1 |) = r in let m1' : hmem_with_inv_except e (fp' x) = m1 in assert (is_frame_preserving f); assert (m1 == dsnd (f m0)); frame_preserving_respects_preorder f m0; NMSTTotal.put #_ #(mem_evolves) m1; x let lift_tot_action #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get #(full_mem) #_ () in ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); lift_tot_action_nf f (** Now defining the lift for heap actions with explicit frame *) let tot_action_with_frame_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = frame:slprop u#a -> m0:hmem_with_inv_except e (fp `star` frame) -> Pure (x:a & hmem_with_inv_except e (fp' x `star` frame)) (requires True) (ensures fun (| x, m1 |) -> mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_with_frame = tot_action_with_frame_except S.empty let lift_heap_action_with_frame (#fp:slprop u#a) (#a:Type u#b) (#fp':a -> slprop u#a) (e:inames) ($f:H.action_with_frame fp a fp') : tot_action_with_frame_except e fp a fp' = fun frame m0 -> let h0 = hheap_of_hmem m0 in calc (equiv) { fp `star` frame `star` locks_invariant e m0; (equiv) { star_associative fp frame (locks_invariant e m0) } fp `star` (frame `star` locks_invariant e m0); }; assert (H.interp (fp `star` frame `star` locks_invariant e m0) h0); assert (H.interp (fp `star` (frame `star` locks_invariant e m0)) h0); //key: apply the heap action with frame * locks_invariant e m0 let (| x, h1 |) = f (frame `star` locks_invariant e m0) h0 in calc (equiv) { fp' x `star` (frame `star` locks_invariant e m0); (equiv) { star_associative (fp' x) frame (locks_invariant e m0) } fp' x `star` frame `star` locks_invariant e m0; }; assert (H.interp (fp' x `star` (frame `star` locks_invariant e m0)) h1); assert (H.interp (fp' x `star` frame `star` locks_invariant e m0) h1); let m1 = hmem_of_hheap m0 h1 in assert (mem_evolves m0 m1); mprop_preservation_of_hprop_preservation (frame `star` locks_invariant e m0) m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)); (| x, m1 |) let lift_tot_action_with_frame #a #e #fp #fp' ($f:tot_action_with_frame_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in assert (inames_ok e m0); ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); let m0' : hmem_with_inv_except e fp = m0 in let r = f frame m0' in let (| x, m1 |) = r in ac_reasoning_for_m_frame_preserving (fp' x) frame (locks_invariant e m1) m1; assert (interp (fp' x `star` frame `star` locks_invariant e m1) m1); assert (interp (fp' x `star` locks_invariant e m1) m1); let m1' : hmem_with_inv_except e (fp' x) = m1 in NMSTTotal.put #_ #(mem_evolves) m1; x let sel_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.sel_action #a #pcm r v0)) let upd_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.upd_action #a #pcm r v0 v1)) let free_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.free_action #a #pcm r v0)) let split_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.split_action #a #pcm r v0 v1)) let gather_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.gather_action #a #pcm r v0 v1)) let weaken (p q r:slprop) (h:H.hheap (p `star` q) { H.stronger q r }) : H.hheap (p `star` r) = H.weaken p q r h; h let weaken_pure (q r: prop) : Lemma (requires (q ==> r)) (ensures H.stronger (H.pure q) (H.pure r)) = let aux (h:H.heap) : Lemma (ensures (H.interp (H.pure q) h ==> H.interp (H.pure r) h)) [SMTPat ()] = H.pure_interp q h; H.pure_interp r h in () let inc_ctr (#p:slprop) #e (m:hmem_with_inv_except e p) : m':hmem_with_inv_except e p{m'.ctr = m.ctr + 1 /\ H.stronger (linv e m) (linv e m')} = let m' : mem = { m with ctr = m.ctr + 1} in assert (interp (p `star` linv e m) m'); assert (linv e m == lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m)); assert (linv e m' == lock_store_invariant e m.locks `star` ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken_free_above (heap_of_mem m) m.ctr (m.ctr + 1); weaken_pure (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_ctr_valid (m.ctr + 1) (heap_of_mem m)); assert (H.stronger (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m))); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)); H.stronger_star (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken (p `star` lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)) (heap_of_mem m'); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity (m.ctr + 1) (heap_of_mem m)); let m' : hmem_with_inv_except e p = m' in m' let frame_related_mems (fp0 fp1:slprop u#a) e (m0:hmem_with_inv_except e fp0) (m1:hmem_with_inv_except e fp1) = forall (frame:slprop u#a). interp ((fp0 `star` frame) `star` linv e m0) m0 ==> interp ((fp1 `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) let refined_pre_action e (fp0:slprop) (a:Type) (fp1:a -> slprop) = m0:hmem_with_inv_except e fp0 -> Pure (x:a & hmem_with_inv_except e (fp1 x)) (requires True) (ensures fun (| x, m1 |) -> frame_related_mems fp0 (fp1 x) e m0 m1) let refined_pre_action_as_action (#fp0:slprop) (#a:Type) (#fp1:a -> slprop) #e ($f:refined_pre_action e fp0 a fp1) : tot_action_nf_except e fp0 a fp1 = let g : tot_pre_action_nf_except e fp0 a fp1 = fun m -> f m in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp0 `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp1 x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x', m1' |) = g m0 in let (| x, m1 |) = f m0 in assert (x == x' /\ m1 == m1') in g let alloc_action #a #pcm e x = let f : refined_pre_action e emp (ref a pcm) (fun r -> pts_to r x) = fun m0 -> (* NS: 9/29/22 I needed to annotate h : Heap.full_heap, for use with the Core checker which generates a guard for checking the implicit pattern "dot" term in the dependent pair pattern on the next line. That guard expects `h` to be a full_heap, which is it, because it is a projection of m0. However, this is not reflected in `h`'s type. So, the Core checker, which produces a guard for the pat_dot_term in isolation, cannot recheck the term. If we were to fold in the checking of pat_dot_terms and their guards with the rest of the VC, this would work. *) let h : Heap.full_heap = hheap_of_hmem m0 in let (|r, h'|) = H.extend #a #pcm x m0.ctr h in let m' : hmem_with_inv_except e emp = inc_ctr m0 in let h' : H.hheap (pts_to #a #pcm r x `star` linv e m') = weaken _ (linv e m0) (linv e m') h' in let m1 : hmem_with_inv_except e (pts_to #a #pcm r x) = hmem_of_hheap m' h' in assert (forall frame. H.frame_related_heaps h h' emp (pts_to #a #pcm r x) frame true); let aux (frame:slprop) : Lemma (requires interp ((emp `star` frame) `star` linv e m0) m0) (ensures interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) [SMTPat (emp `star` frame)] = star_associative emp frame (linv e m0); assert (H.interp (emp `star` (frame `star` linv e m0)) h); assert (H.interp (pts_to #a #pcm r x `star` (frame `star` linv e m0)) h'); star_associative (pts_to #a #pcm r x) frame (linv e m0); assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m0) h'); assert (H.stronger (linv e m0) (linv e m')); assert (H.equiv (linv e m') (linv e m1)); assert (H.stronger (linv e m0) (linv e m1)); let h' : H.hheap ((pts_to #a #pcm r x `star` frame) `star` linv e m1) = weaken _ (linv e m0) (linv e m1) h' in assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) h'); assert (forall (mp:H.hprop frame). mp h == mp h'); mprop_preservation_of_hprop_preservation frame m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) in assert (frame_related_mems emp (pts_to r x) e m0 m1); (| r, m1 |) in lift_tot_action (refined_pre_action_as_action f) let select_refine #a #p e r x f = lift_tot_action (lift_heap_action e (H.select_refine #a #p r x f)) let upd_gen #a #p e r x y f = lift_tot_action (lift_heap_action e (H.upd_gen_action r x y f)) //////////////////////////////////////////////////////////////////////////////// // witness / recall //////////////////////////////////////////////////////////////////////////////// let witnessed_ref #a #pcm (r:ref a pcm) (fact:property a) (m:full_mem) = H.witnessed_ref #a #pcm r fact (heap_of_mem m) let witnessed_ref_stability #a #pcm (r:ref a pcm) (fact:property a) : Lemma (requires FStar.Preorder.stable fact (Steel.Preorder.preorder_of_pcm pcm)) (ensures FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) = H.witnessed_ref_stability #a #pcm r fact let witnessed (#a:Type u#1) (#pcm:pcm a) (r:ref a pcm) (fact:property a) = W.witnessed _ mem_evolves (witnessed_ref r fact) let rearrange_pqr_prq (p q r:slprop) : Lemma (((p `star` q) `star` r) `equiv` ((p `star` r) `star` q)) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_associative p q r } p `star` (q `star` r); (equiv) { star_commutative q r; star_congruence p (q `star` r) p (r `star` q) } p `star` (r `star` q); (equiv) { star_associative p r q } (p `star` r) `star` q; } let preserves_frame_cong (e:inames) (p q:slprop) (r s:slprop) (m0 m1:mem) : Lemma (requires p `equiv` r /\ q `equiv` s /\ preserves_frame e p q m0 m1) (ensures preserves_frame e r s m0 m1) = let aux0 (p q r s:slprop) : Lemma (requires p `equiv` s) (ensures (((p `star` q) `star` r) `equiv` ((s `star` q) `star` r))) = star_congruence p q s q; star_congruence (p `star` q) r (s `star` q) r in let aux (frame:slprop) : Lemma (requires interp ((r `star` frame) `star` locks_invariant e m0) m0) (ensures interp ((s `star` frame) `star` locks_invariant e m1) m1 /\ interp ((p `star` frame) `star` locks_invariant e m0) m0) [SMTPat (r `star` frame)] = aux0 p frame (locks_invariant e m0) r; aux0 q frame (locks_invariant e m1) s; assert (((p `star` frame) `star` locks_invariant e m0) `equiv` ((r `star` frame) `star` locks_invariant e m0)); assert (interp ((p `star` frame) `star` locks_invariant e m0) m0); assert (interp ((q `star` frame) `star` locks_invariant e m1) m1); assert (((q `star` frame) `star` locks_invariant e m1) `equiv` ((s `star` frame) `star` locks_invariant e m1)); () in () let pure_true_equiv (p:slprop) : Lemma ((p `star` pure True) `equiv` p) = FStar.Classical.forall_intro (pure_star_interp p True); emp_unit p; assert ((p `star` pure True) `equiv` p) let preserves_frame_star_pure (e:inames) (p q:slprop) (r s:prop) (m:mem) : Lemma (requires r /\ s) (ensures preserves_frame e p q m m <==> preserves_frame e (p `star` pure r) (q `star` pure s) m m) = pure_equiv r True; star_congruence p (pure r) p (pure True); pure_equiv s True; star_congruence q (pure s) q (pure True); pure_true_equiv p; pure_true_equiv q; let fwd () : Lemma (requires preserves_frame e p q m m) (ensures preserves_frame e (p `star` pure r) (q `star` pure s) m m) [SMTPat ()] = preserves_frame_cong e p q (p `star` pure r) (q `star` pure s) m m in let bk () : Lemma (requires preserves_frame e (p `star` pure r) (q `star` pure s) m m) (ensures preserves_frame e p q m m) [SMTPat ()] = preserves_frame_cong e (p `star` pure r) (q `star` pure s) p q m m in () let witness (#a:Type) (#pcm:pcm a) (e:inames) (r:erased (ref a pcm)) (fact:stable_property pcm) (v:Ghost.erased a) (_:squash (forall z. compatible pcm v z ==> fact z)) (frame:slprop) : MstTot (witnessed r fact) e (pts_to r v) (fun _ -> pts_to r v) frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in let _ : unit = let hr : H.ref a pcm = r in let v' = H.sel_v hr v (heap_of_mem m0) in assert (interp (H.ptr hr) m0 /\ H.sel #a #pcm hr (heap_of_mem m0) == v'); assert (compatible pcm v v'); assert (fact v'); assert (witnessed_ref r fact m0); witnessed_ref_stability r fact; assert (FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) in let w = NMSTTotal.witness _ mem_evolves (witnessed_ref r fact) in w let recall (#a:Type u#1) (#pcm:pcm a) (#fact:property a) (e:inames) (r:erased (ref a pcm)) (v:Ghost.erased a) (w:witnessed r fact) (frame:slprop) = let m0 = NMSTTotal.get () in NMSTTotal.recall _ mem_evolves (witnessed_ref r fact) w; let hr : H.ref a pcm = r in assert (witnessed_ref r fact m0); let v1 = H.sel_v hr v (heap_of_mem m0) in assert (compatible pcm v v1); assert (H.sel hr (heap_of_mem m0) == v1); assert (fact v1); assert (interp ((pts_to r v `star` frame) `star` locks_invariant e m0) m0); emp_unit ((pts_to r v `star` frame) `star` locks_invariant e m0); pure_star_interp ((pts_to r v `star` frame) `star` locks_invariant e m0) (fact v1) m0; assert (interp (((pts_to r v `star` frame) `star` locks_invariant e m0) `star` pure (fact v1)) m0); rearrange_pqr_prq (pts_to r v `star` frame) (locks_invariant e m0) (pure (fact v1)); assert (interp (((pts_to r v `star` frame) `star` pure (fact v1)) `star` locks_invariant e m0) m0); rearrange_pqr_prq (pts_to r v) frame (pure (fact v1)); star_congruence ((pts_to r v `star` frame) `star` pure (fact v1)) (locks_invariant e m0) ((pts_to r v `star` pure (fact v1)) `star` frame) (locks_invariant e m0); Ghost.hide v1 let iname_for_p_mem (i:iname) (p:slprop) : W.s_predicate mem = fun m -> iname_for_p i p m.locks let iname_for_p_stable (i:iname) (p:slprop) : Lemma (W.stable full_mem mem_evolves (iname_for_p_mem i p)) = () let ( >--> ) (i:iname) (p:slprop) : Type0 = W.witnessed full_mem mem_evolves (iname_for_p_mem i p) let hmem_with_inv_equiv e (m:mem) (p:slprop) : Lemma (interp (p `star` linv e m) m <==> interp (p `star` lock_store_invariant e m.locks) m /\ heap_ctr_valid m.ctr (heap_of_mem m)) = calc (<==>) { interp (p `star` linv e m) m; (<==>) { H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) } interp ((p `star` lock_store_invariant e m.locks) `star` ctr_validity m.ctr (heap_of_mem m)) m; (<==>) { H.pure_star_interp (p `star` lock_store_invariant e m.locks) (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_of_mem m) } interp ((p `star` lock_store_invariant e m.locks) `star` emp) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); (<==>) { H.emp_unit (p `star` lock_store_invariant e m.locks) } interp (p `star` lock_store_invariant e m.locks) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); } let new_invariant_tot_action (e:inames) (p:slprop) (m0:hmem_with_inv_except e p{ e `inames_in` m0.locks }) : Pure (iname & hmem_with_inv_except e emp) (requires True) (ensures fun (i, m1) -> iname_for_p_mem i p m1 /\ frame_related_mems p emp e m0 m1 /\ mem_evolves m0 m1) = let (| i, l1 |) = extend_lock_store e m0.locks p in let m1 = { m0 with locks = l1 } in assert (lock_store_invariant e m1.locks == p `star` lock_store_invariant e m0.locks); calc (equiv) { linv e m1; (equiv) {} (lock_store_invariant e m1.locks `star` ctr_validity m1.ctr (heap_of_mem m1)); (equiv) {} ((p `star` lock_store_invariant e m0.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); (equiv) { H.star_associative p (lock_store_invariant e m0.locks) (ctr_validity m1.ctr (heap_of_mem m1)) } (p `star` (lock_store_invariant e m0.locks `star` ctr_validity m1.ctr (heap_of_mem m1))); (equiv) { } (p `star` linv e m0); }; assert (iname_for_p_mem i p m1); assert (lock_store_evolves m0.locks l1); assert (mem_evolves m0 m1); hmem_with_inv_equiv e m0 p; assert (interp (p `star` lock_store_invariant e m0.locks) m1); assert (interp (lock_store_invariant e m1.locks) m1); H.emp_unit (lock_store_invariant e m1.locks); H.star_commutative (lock_store_invariant e m1.locks) emp; assert (interp (emp `star` lock_store_invariant e m1.locks) m1); hmem_with_inv_equiv e m1 emp; let m1 : hmem_with_inv_except e emp = m1 in let aux (frame:slprop) : Lemma (requires interp ((p `star` frame) `star` linv e m0) m0) (ensures interp ((emp `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) <==> mp (core_mem m1))) [SMTPat (p `star` frame)] = assert (interp ((p `star` frame) `star` linv e m0) m1); calc (equiv) { ((p `star` frame) `star` linv e m0); (equiv) { H.star_commutative p frame; H.star_congruence (p `star` frame) (linv e m0) (frame `star` p) (linv e m0); H.star_associative frame p (linv e m0) } (frame `star` (p `star` linv e m0)); (equiv) { H.star_congruence frame (p `star` linv e m0) frame (linv e m1) } (frame `star` linv e m1); (equiv) { H.emp_unit (frame `star` linv e m1); H.star_commutative (frame `star` linv e m1) emp; H.star_associative emp frame (linv e m1) } ((emp `star` frame) `star` linv e m1); }; assert (interp ((emp `star` frame) `star` linv e m1) m1) in assert (frame_related_mems p emp e m0 m1); ( i, m1 ) let name_is_ok (i:iname) (m0:full_mem u#1) : prop = i < List.Tot.length m0.locks let witnessed_name_is_ok (i:iname) = W.witnessed full_mem mem_evolves (name_is_ok i) let pre_inv = i:erased iname & witnessed_name_is_ok i let inv (p:slprop u#1) = i:erased iname & witnessed_name_is_ok i & (i >--> p)

{ "checked_file": "/", "dependencies": [ "Steel.Preorder.fst.checked", "Steel.Heap.fsti.checked", "prims.fst.checked", "FStar.Witnessed.Core.fsti.checked", "FStar.Set.fsti.checked", "FStar.Preorder.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.PCM.fst.checked", "FStar.NMSTTotal.fst.checked", "FStar.List.Tot.fst.checked", "FStar.IndefiniteDescription.fsti.checked", "FStar.Ghost.fsti.checked", "FStar.FunctionalExtensionality.fsti.checked", "FStar.Classical.Sugar.fsti.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Steel.Memory.fst" }

[ { "abbrev": true, "full_module": "Steel.Preorder", "short_module": "PP" }, { "abbrev": true, "full_module": "FStar.Witnessed.Core", "short_module": "W" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": true, "full_module": "Steel.Heap", "short_module": "H" }, { "abbrev": false, "full_module": "FStar.FunctionalExtensionality", "short_module": null }, { "abbrev": true, "full_module": "FStar.FunctionalExtensionality", "short_module": "F" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": false, "full_module": "FStar.PCM", "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

i: Steel.Memory.pre_inv -> Prims.GTot Steel.Memory.iname

Prims.GTot

[ "sometrivial" ]

[]

[ "Steel.Memory.pre_inv", "FStar.Ghost.reveal", "Steel.Memory.iname", "FStar.Pervasives.dfst", "FStar.Ghost.erased", "Steel.Memory.witnessed_name_is_ok" ]

[]

false

let name_of_pre_inv (i: pre_inv) =

dfst i

false

Steel.Memory.fst

Steel.Memory.pre_inv_of_inv

val pre_inv_of_inv (#p:slprop) (i:inv p) : pre_inv

let pre_inv_of_inv #p (i:inv p) = let (|i, w, _|) = i in (|i,w|)

{ "file_name": "lib/steel/Steel.Memory.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 64, "end_line": 1258, "start_col": 0, "start_line": 1258 }

(* 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.Memory module F = FStar.FunctionalExtensionality open FStar.FunctionalExtensionality open FStar.PCM module H = Steel.Heap noeq type lock_state : Type u#(a + 1) = | Invariant : inv:H.slprop u#a -> lock_state let lock_store : Type u#(a+1) = list (lock_state u#a) noeq type mem : Type u#(a + 1) = { ctr: nat; heap: H.heap u#a; locks: lock_store u#a; } let heap_of_mem (x:mem) : H.heap = x.heap let mem_of_heap (h:H.heap) : mem = { ctr = 0; heap = h; locks = [] } let mem_set_heap (m:mem) (h:H.heap) : mem = { ctr = m.ctr; heap = h; locks = m.locks; } let core_mem (m:mem) : mem = mem_of_heap (heap_of_mem m) let core_mem_invol m = () let disjoint (m0 m1:mem u#h) : prop = m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks let disjoint_sym m0 m1 = () let join m0 m1 = { ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = m0.locks } let join_commutative m0 m1 = H.join_commutative m0.heap m1.heap let disjoint_join m0 m1 m2 = H.disjoint_join m0.heap m1.heap m2.heap let join_associative m0 m1 m2 = H.join_associative m0.heap m1.heap m2.heap let slprop = H.slprop let interp p m = H.interp p m.heap let equiv p1 p2 = forall m. interp p1 m <==> interp p2 m let slprop_extensionality p q = assert (forall m. interp p m <==> interp q m); let aux (h:H.heap) : Lemma (H.interp p h <==> H.interp q h) [SMTPat (H.interp p h)] = let m : mem = { ctr = 0; heap = h; locks = [] } in assert (interp p m <==> interp q m) in assert (forall h. H.interp p h <==> H.interp q h); Steel.Heap.slprop_extensionality p q let reveal_equiv p1 p2 = () let core_ref = H.core_ref let core_ref_null = H.core_ref_null let core_ref_is_null r = H.core_ref_is_null r let emp : slprop u#a = H.emp let pure = H.pure let pts_to = H.pts_to let h_and = H.h_and let h_or = H.h_or let star = H.star let wand = H.wand let h_exists = H.h_exists let h_forall = H.h_forall //////////////////////////////////////////////////////////////////////////////// //properties of equiv //////////////////////////////////////////////////////////////////////////////// let equiv_symmetric (p1 p2:slprop u#a) = H.equiv_symmetric p1 p2 #push-options "--warn_error -271" let equiv_heap_iff_equiv (p1 p2:slprop u#a) : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat (equiv p1 p2)] = let aux_lr () : Lemma (requires H.equiv p1 p2) (ensures equiv p1 p2) [SMTPat ()] = () in let aux_rl_helper1 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p1 h) (ensures H.interp p2 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl_helper2 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p2 h) (ensures H.interp p1 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl () : Lemma (requires equiv p1 p2) (ensures H.equiv p1 p2) [SMTPat ()] = () in () let equiv_heap_iff_equiv_forall () : Lemma (ensures (forall p1 p2. H.equiv p1 p2 <==> equiv p1 p2)) = let aux p1 p2 : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat ()] = equiv_heap_iff_equiv p1 p2 in () #pop-options let equiv_extensional_on_star (p1 p2 p3:slprop u#a) = equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3 let emp_unit p = H.emp_unit p let intro_emp m = H.intro_emp (heap_of_mem m) let pure_equiv p q = H.pure_equiv p q let pure_interp q m = H.pure_interp q (heap_of_mem m) let pure_star_interp p q m = H.pure_star_interp p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// //pts_to //////////////////////////////////////////////////////////////////////////////// let pts_to_compatible #a #pcm x v0 v1 m = H.pts_to_compatible #a #pcm x v0 v1 (heap_of_mem m) let pts_to_compatible_equiv #a #pcm x v0 v1 = H.pts_to_compatible_equiv #a #pcm x v0 v1 let pts_to_not_null #a #pcm x v m = H.pts_to_not_null #a #pcm x v (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // star //////////////////////////////////////////////////////////////////////////////// let intro_star p q mp mq = H.intro_star p q (heap_of_mem mp) (heap_of_mem mq) let elim_star p q m = let h = heap_of_mem m in H.elim_star p q h; assert (exists hl hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr); let hl = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hl -> exists hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let hr = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hr -> H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let ml = mem_set_heap m hl in let mr = mem_set_heap m hr in assert (disjoint ml mr); assert (m == join ml mr); assert (interp p ml); assert (interp q mr); () let interp_star (p q: slprop) (m: mem) : Lemma (interp (p `star` q) m <==> (exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m)) = let left = interp (p `star` q) m in let right = exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m in let f () : Lemma (requires left) (ensures right) = elim_star p q m in let g () : Lemma (requires right) (ensures left) = Classical.exists_elim left #_ #(fun mp -> exists (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mp -> Classical.exists_elim left #_ #(fun mq -> disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mq -> intro_star p q mp mq ) ) in Classical.move_requires f (); Classical.move_requires g () let star_commutative (p1 p2:slprop) = H.star_commutative p1 p2 let star_associative (p1 p2 p3:slprop) = H.star_associative p1 p2 p3 let star_congruence (p1 p2 p3 p4:slprop) = equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4 let affine_star (p q:slprop) (m:mem) = H.affine_star p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // Invariants on the lock store //////////////////////////////////////////////////////////////////////////////// let iname = nat module S = FStar.Set module L = FStar.List.Tot module W = FStar.Witnessed.Core let rec lock_store_invariant (e:inames) (l:lock_store u#a) : slprop u#a = let current_addr = L.length l - 1 in match l with | [] -> emp | Invariant p :: tl -> if current_addr `S.mem` e then lock_store_invariant e tl else p `star` lock_store_invariant e tl let lock_i (i:iname) (l:lock_store { i < L.length l }) = let ix = L.length l - i - 1 in L.index l ix let iname_for_p (i:iname) (p:slprop) : W.s_predicate lock_store = fun l -> i < L.length l /\ (lock_i i l).inv == p let lock_store_evolves : FStar.Preorder.preorder lock_store = fun (l1 l2 : lock_store) -> L.length l2 >= L.length l1 /\ (forall (i:nat{i < L.length l1}). (lock_i i l1).inv == (lock_i i l2).inv) let inames_in (e:inames) (l:lock_store) : prop = forall i. Set.mem i e ==> i < L.length l let inames_ok e m = inames_in e m.locks let inames_ok_empty m = () let extend_lock_store (e:inames) (l:lock_store{e `inames_in` l}) (p:slprop) : i:iname & l':lock_store { lock_store_invariant e l' == p `star` lock_store_invariant e l /\ iname_for_p i p l' } = (| L.length l, Invariant p :: l |) let set_add (i:iname) (s:inames) = Set.union (Set.singleton i) s let rec move_invariant (e:inames) (l:lock_store) (p:slprop) (i:iname{iname_for_p i p l /\ ~(i `Set.mem` e)}) : Lemma (H.equiv (lock_store_invariant e l) (p `star` lock_store_invariant (set_add i e) l)) = let rec aux (i:iname) (m:lock_store) : Lemma (requires i >= L.length m) (ensures (lock_store_invariant e m `H.equiv` lock_store_invariant (set_add i e) m)) = match m with | [] -> () | Invariant p::tl -> aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl) in let current_addr = L.length l - 1 in match l with | [] -> () | Invariant q::tl -> if i = current_addr then begin assert (lock_store_invariant e l == p `star` lock_store_invariant e tl); aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl); () end else begin move_invariant e tl p i; assert (lock_store_invariant e tl `equiv` (p `star` lock_store_invariant (set_add i e) tl)); H.star_congruence q (lock_store_invariant e tl) q (p `star` lock_store_invariant (set_add i e) tl); if Set.mem current_addr e then () else begin let r = lock_store_invariant (set_add i e) tl in assert (lock_store_invariant e l `equiv` (q `star` (p `star` r))); H.star_associative q p r; H.star_commutative q p; H.star_congruence (q `star` p) r (p `star` q) r; H.star_associative p q r end end let heap_ctr_valid (ctr:nat) (h:H.heap u#a) : prop = h `H.free_above_addr` ctr let ctr_validity (ctr:nat) (h:H.heap) : slprop = H.pure (heap_ctr_valid ctr h) let locks_invariant (e:inames) (m:mem u#a) : slprop u#a = lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m) let full_mem_pred (m:mem) = H.full_heap_pred (heap_of_mem m) (***** Following lemmas are needed in Steel.Effect *****) let core_mem_interp (hp:slprop u#a) (m:mem u#a) = () let interp_depends_only_on (hp:slprop u#a) = H.interp_depends_only_on hp let a_mem_prop_as_a_heap_prop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (H.a_heap_prop u#a) = let g (h: H.heap u#a) : Tot prop = interp sl (mem_of_heap h) /\ f (mem_of_heap h) in let phi0 (h0 h1: H.heap u#a) : Lemma (requires (g h0 /\ H.disjoint h0 h1)) (ensures (g h0 /\ H.disjoint h0 h1 /\ g (H.join h0 h1))) = assert (mem_of_heap (H.join h0 h1) == mem_of_heap h0 `join` mem_of_heap h1); interp_depends_only_on sl in let phi1 (h0 h1: H.heap u#a) : Lemma (ensures ((g h0 /\ H.disjoint h0 h1) ==> g (H.join h0 h1))) = Classical.move_requires (phi0 h0) h1 in Classical.forall_intro_2 phi1; g let refine_slprop sl f = H.as_slprop (a_mem_prop_as_a_heap_prop sl f) let interp_refine_slprop sl f m = assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_mem m)) let dep_hprop (s: slprop) (f: (hmem s -> Tot slprop)) (h: H.heap) : Tot prop = exists (h1: H.heap) . exists (h2: H.heap) . interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 let dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq' : squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h')) = let p2 (h h1 h2: H.heap) : Tot prop = interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 in let p1 (h h1: H.heap) : Tot prop = (exists h2 . p2 h h1 h2) in let h1 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p1 h) in let h2 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p2 h h1) in H.disjoint_join h' h1 h2; assert (H.disjoint h2 h'); let h2' = H.join h2 h' in H.join_commutative h2 h' ; assert (h2' == H.join h' h2); assert (H.disjoint h1 h2'); assert (mem_of_heap h2' == mem_of_heap h2 `join` mem_of_heap h'); interp_depends_only_on (f (mem_of_heap h1)); assert (interp (f (mem_of_heap h1)) (mem_of_heap h2')); H.join_commutative h1 h2; H.join_associative h' h2 h1; H.join_commutative h' h; H.join_commutative h2' h1; assert (H.join h h' == h1 `H.join` h2') let impl_intro_gen (#p: Type0) (#q: Type0) ($prf: (squash p -> Lemma (q ))) : Lemma (p ==> q) = Classical.impl_intro_gen #p #(fun _ -> q) prf let dep_hprop_is_affine1 (s: slprop) (f: (hmem s -> Tot slprop)) (h0 h1: H.heap) : Lemma ((dep_hprop s f h0 /\ H.disjoint h0 h1) ==> (H.disjoint h0 h1 /\ dep_hprop s f (H.join h0 h1))) = impl_intro_gen (dep_hprop_is_affine0 s f h0 h1) let dep_hprop_is_affine (s: slprop) (f: (hmem s -> Tot slprop)) : Lemma (H.heap_prop_is_affine (dep_hprop s f)) = Classical.forall_intro_2 (dep_hprop_is_affine1 s f) let sdep (s: slprop) (f: (hmem s -> Tot slprop)) : Tot slprop = dep_hprop_is_affine s f; H.as_slprop (dep_hprop s f) let interp_sdep (s: slprop) (f: (hmem s -> Tot slprop)) (m: mem) : Lemma (requires (dep_slprop_is_affine s f)) (ensures ( interp (sdep s f) m <==> (exists m1 m2 . interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) )) = dep_hprop_is_affine s f; assert (forall m1 m2 . (interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) ==> ( interp s (mem_of_heap m1.heap) /\ interp (f (mem_of_heap m1.heap)) (mem_of_heap m2.heap) /\ H.disjoint m1.heap m2.heap /\ H.join m1.heap m2.heap == m.heap )); interp_depends_only_on s; Classical.forall_intro (fun m -> interp_depends_only_on (f m)); assert (forall h1 h2 . (interp s (mem_of_heap h1) /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ H.disjoint h1 h2 /\ H.join h1 h2 == m.heap) ==> ( core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ interp s (core_mem (mem_of_heap h1)) /\ interp s (mem_set_heap m h1) /\ core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ f (mem_set_heap m h1) `equiv` f (mem_of_heap h1) /\ interp (f (mem_set_heap m h1)) (mem_of_heap h2) /\ interp (f (mem_set_heap m h1)) (mem_set_heap m h2) /\ disjoint (mem_set_heap m h1) (mem_set_heap m h2) /\ join (mem_set_heap m h1) (mem_set_heap m h2) == m )); () let h_exists_cong (#a:Type) (p q : a -> slprop) : Lemma (requires (forall x. p x `equiv` q x)) (ensures (h_exists p `equiv` h_exists q)) = equiv_heap_iff_equiv_forall (); H.h_exists_cong p q let intro_h_exists #a x p m = H.intro_h_exists x p (heap_of_mem m) let elim_h_exists (#a:_) (p:a -> slprop) (m:mem) = H.elim_h_exists p (heap_of_mem m) let intro_h_forall (#a:_) (p:a -> slprop) (m:mem) = H.intro_h_forall p (heap_of_mem m) let elim_h_forall (#a:_) (p:a -> slprop) (m:mem) (x:a) = H.elim_h_forall p (heap_of_mem m) x let intro_h_and (p q: slprop) (m:mem) = H.intro_h_and p q (heap_of_mem m) let elim_h_and (p q: slprop) (m:mem) = H.elim_h_and p q (heap_of_mem m) let intro_h_or_left (p q: slprop) (m:mem) = H.intro_h_or_left p q (heap_of_mem m) let intro_h_or_right (p q: slprop) (m:mem) = H.intro_h_or_right p q (heap_of_mem m) let elim_h_or (p q: slprop) (m:mem) = H.elim_h_or p q (heap_of_mem m) let intro_wand (p1 p2: slprop u#a) (m:mem) = introduce (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)) ==> interp (wand p1 p2) m with _. ( assert (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)); H.intro_wand p1 p2 (heap_of_mem m); let h = heap_of_mem m in assert ((forall h1. h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) ==> H.interp (wand p1 p2) h); introduce forall h1. (h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) with ( introduce (h `H.disjoint` h1 /\ H.interp p1 h1) ==> H.interp p2 (H.join h h1) with _. ( assert (h `H.disjoint` h1); let m1 = { ctr = m.ctr; heap = h1; locks = m.locks } in assert (m `disjoint` m1) ) ) ) (** Eliminating a wand by proving a heap that satisfies the LHS **) let elim_wand (p1 p2: slprop u#a) (m:mem) (m1:mem) = H.elim_wand p1 p2 (heap_of_mem m) (heap_of_mem m1) //////////////////////////////////////////////////////////////////////////////// // Preorders and effects //////////////////////////////////////////////////////////////////////////////// module PP = Steel.Preorder let mem_evolves = fun (m0 m1:full_mem) -> H.heap_evolves (heap_of_mem m0) (heap_of_mem m1) /\ m0.ctr <= m1.ctr /\ lock_store_evolves m0.locks m1.locks (** See [Steel.Heap.is_frame_preserving]. We add in [lock_invariants] now *) let preserves_frame (e:inames) (pre post:slprop) (m0 m1:mem) = forall (frame:slprop). interp ((pre `star` frame) `star` locks_invariant e m0) m0 ==> (interp ((post `star` frame) `star` locks_invariant e m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) (** This is a version of MstTot with frame quantified, as part of preserves_frame *) effect MstTotNF (a:Type u#a) (except:inames) (expects:slprop u#1) (provides: a -> slprop u#1) = NMSTTotal.NMSTATETOT a (full_mem u#1) mem_evolves (requires fun m0 -> inames_ok except m0 /\ interp (expects `star` locks_invariant except m0) m0) (ensures fun m0 x m1 -> inames_ok except m1 /\ interp (provides x `star` locks_invariant except m1) m1 /\ preserves_frame except expects (provides x) m0 m1) //////////////////////////////////////////////////////////////////////////////// // Lifting heap actions //////////////////////////////////////////////////////////////////////////////// (** Heap actions come in two equivalent flavors: - one that take an explicit frame as argument (action_with_frame) - and one that quantify over all the frame We therefore define two lift routes: - a direct route for those with explicit frame - via MstTotNF for the rest *) let tot_pre_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = hmem_with_inv_except e fp -> (x:a & hmem_with_inv_except e (fp' x)) let tot_pre_action_nf = tot_pre_action_nf_except S.empty let ac_reasoning_for_m_frame_preserving (p q r:slprop u#a) (m:mem u#a) : Lemma (requires interp ((p `star` q) `star` r) m) (ensures interp (p `star` r) m) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_commutative p q; equiv_extensional_on_star (p `star` q) (q `star` p) r } (q `star` p) `star` r; (equiv) { star_associative q p r } q `star` (p `star` r); }; assert (interp (q `star` (p `star` r)) m); affine_star q (p `star` r) m let is_frame_preserving (#e:inames) (#a:Type u#b) (#fp:slprop u#a) (#fp':a -> slprop u#a) (f:tot_pre_action_nf_except e fp a fp') = forall (frame:slprop u#a) (m0:hmem_with_inv_except e (fp `star` frame)). (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = f:tot_pre_action_nf_except e fp a fp'{ is_frame_preserving f } let tot_action_nf = tot_action_nf_except S.empty let linv e (m:mem) = locks_invariant e m let hheap_of_hmem #fp #e (m:hmem_with_inv_except e fp) : h:H.hheap (fp `star` linv e m) { h `H.free_above_addr` m.ctr} = let h = heap_of_mem m in H.pure_interp (heap_ctr_valid m.ctr (heap_of_mem m)) h; h let hmem_of_hheap #e (#fp0 #fp1:slprop) (m:hmem_with_inv_except e fp0) (h:H.full_hheap (fp1 `star` linv e m) { h `Heap.free_above_addr` m.ctr }) : m1:hmem_with_inv_except e fp1{linv e m `equiv` linv e m1} = let m1 : mem = { m with heap = h } in assert (interp (fp1 `star` linv e m) m1); star_commutative fp1 (linv e m); assert (interp (linv e m `star` fp1) m1); assert (linv e m1 == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); assert (linv e m == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m)); H.pure_interp (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_of_mem m); assert (heap_ctr_valid m1.ctr (heap_of_mem m) <==> heap_ctr_valid m1.ctr (heap_of_mem m1)); H.pure_equiv (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_ctr_valid m1.ctr (heap_of_mem m1)); H.star_congruence (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m)); assert (linv e m `equiv` linv e m1); let _ = equiv_extensional_on_star (linv e m) (linv e m1) fp1 in assert ((linv e m `star` fp1) `equiv` (linv e m1 `star` fp1)); assert (interp (linv e m1 `star` fp1) m1); star_commutative (linv e m1) fp1; assert (interp (fp1 `star` linv e m1) m1); m1 let with_inv_except (m:mem) e (fp:slprop) = interp (fp `star` locks_invariant e m) m #push-options "--warn_error -271" let as_hprop (frame:slprop) (mp:mprop frame) : hp:H.hprop frame{forall m. mp (core_mem m) == hp (heap_of_mem m)} = let f = fun h -> mp (mem_of_heap h) in assert (forall m. mp (core_mem m) == f (heap_of_mem m)); let aux (m0:H.hheap frame) (m1:H.heap{H.disjoint m0 m1}) : Lemma (ensures (mem_of_heap (H.join m0 m1) == join (mem_of_heap m0) (mem_of_heap m1))) [SMTPat ()] = () in f let mprop_preservation_of_hprop_preservation (p:slprop) (m0 m1:mem) : Lemma (requires (forall (hp:H.hprop p). hp (heap_of_mem m0) == hp (heap_of_mem m1))) (ensures (forall (mp:mprop p). mp (core_mem m0) == mp (core_mem m1))) = let aux (mp:mprop p) : Lemma (mp (core_mem m0) == mp (core_mem m1)) [SMTPat()] = assert (as_hprop p mp (heap_of_mem m0) == as_hprop p mp (heap_of_mem m1)) in () let lift_heap_action (#fp:slprop) (#a:Type) (#fp':a -> slprop) (e:inames) ($f:H.action fp a fp') : tot_action_nf_except e fp a fp' = let g : tot_pre_action_nf_except e fp a fp' = fun m -> let h0 = hheap_of_hmem m in let (| x, h' |) = f h0 in (| x, hmem_of_hheap m h' |) in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in let h0 = hheap_of_hmem m0 in let (| x', h1 |) = f h0 in H.action_framing f (linv e m0) h0; assert (x == x'); star_associative fp frame (linv e m0); H.action_framing f (frame `star` linv e m0) h0; assert (H.interp ((fp' x) `star` (frame `star` linv e m0)) h1); star_associative (fp' x) frame (linv e m0); assert (H.interp ((fp' x `star` frame) `star` linv e m0) h1); let h1' : H.hheap ((fp' x `star` frame) `star` linv e m0) = h1 in assert (m1 == hmem_of_hheap m0 h1'); assert (with_inv_except m1 e (fp' x `star` frame)); assert (forall (hp:H.hprop frame). hp h0 == hp h1); mprop_preservation_of_hprop_preservation frame m0 m1; () in assert (is_frame_preserving g); g let frame_preserving_respects_preorder #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (m0:hmem_with_inv_except e fp) : Lemma (let (| x, m1 |) = f m0 in mem_evolves m0 m1) = let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1) = () in H.emp_unit fp; assert (interp (fp `star` linv e m0) m0); H.star_congruence (fp `star` emp) (linv e m0) fp (linv e m0); assert (interp ((fp `star` emp) `star` linv e m0) m0); aux emp m0 let lift_tot_action_nf #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') : MstTotNF a e fp fp' = let m0 = NMSTTotal.get () in let m0' : hmem_with_inv_except e fp = m0 in let r = f m0' in let (| x, m1 |) = r in let m1' : hmem_with_inv_except e (fp' x) = m1 in assert (is_frame_preserving f); assert (m1 == dsnd (f m0)); frame_preserving_respects_preorder f m0; NMSTTotal.put #_ #(mem_evolves) m1; x let lift_tot_action #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get #(full_mem) #_ () in ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); lift_tot_action_nf f (** Now defining the lift for heap actions with explicit frame *) let tot_action_with_frame_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = frame:slprop u#a -> m0:hmem_with_inv_except e (fp `star` frame) -> Pure (x:a & hmem_with_inv_except e (fp' x `star` frame)) (requires True) (ensures fun (| x, m1 |) -> mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_with_frame = tot_action_with_frame_except S.empty let lift_heap_action_with_frame (#fp:slprop u#a) (#a:Type u#b) (#fp':a -> slprop u#a) (e:inames) ($f:H.action_with_frame fp a fp') : tot_action_with_frame_except e fp a fp' = fun frame m0 -> let h0 = hheap_of_hmem m0 in calc (equiv) { fp `star` frame `star` locks_invariant e m0; (equiv) { star_associative fp frame (locks_invariant e m0) } fp `star` (frame `star` locks_invariant e m0); }; assert (H.interp (fp `star` frame `star` locks_invariant e m0) h0); assert (H.interp (fp `star` (frame `star` locks_invariant e m0)) h0); //key: apply the heap action with frame * locks_invariant e m0 let (| x, h1 |) = f (frame `star` locks_invariant e m0) h0 in calc (equiv) { fp' x `star` (frame `star` locks_invariant e m0); (equiv) { star_associative (fp' x) frame (locks_invariant e m0) } fp' x `star` frame `star` locks_invariant e m0; }; assert (H.interp (fp' x `star` (frame `star` locks_invariant e m0)) h1); assert (H.interp (fp' x `star` frame `star` locks_invariant e m0) h1); let m1 = hmem_of_hheap m0 h1 in assert (mem_evolves m0 m1); mprop_preservation_of_hprop_preservation (frame `star` locks_invariant e m0) m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)); (| x, m1 |) let lift_tot_action_with_frame #a #e #fp #fp' ($f:tot_action_with_frame_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in assert (inames_ok e m0); ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); let m0' : hmem_with_inv_except e fp = m0 in let r = f frame m0' in let (| x, m1 |) = r in ac_reasoning_for_m_frame_preserving (fp' x) frame (locks_invariant e m1) m1; assert (interp (fp' x `star` frame `star` locks_invariant e m1) m1); assert (interp (fp' x `star` locks_invariant e m1) m1); let m1' : hmem_with_inv_except e (fp' x) = m1 in NMSTTotal.put #_ #(mem_evolves) m1; x let sel_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.sel_action #a #pcm r v0)) let upd_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.upd_action #a #pcm r v0 v1)) let free_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.free_action #a #pcm r v0)) let split_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.split_action #a #pcm r v0 v1)) let gather_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.gather_action #a #pcm r v0 v1)) let weaken (p q r:slprop) (h:H.hheap (p `star` q) { H.stronger q r }) : H.hheap (p `star` r) = H.weaken p q r h; h let weaken_pure (q r: prop) : Lemma (requires (q ==> r)) (ensures H.stronger (H.pure q) (H.pure r)) = let aux (h:H.heap) : Lemma (ensures (H.interp (H.pure q) h ==> H.interp (H.pure r) h)) [SMTPat ()] = H.pure_interp q h; H.pure_interp r h in () let inc_ctr (#p:slprop) #e (m:hmem_with_inv_except e p) : m':hmem_with_inv_except e p{m'.ctr = m.ctr + 1 /\ H.stronger (linv e m) (linv e m')} = let m' : mem = { m with ctr = m.ctr + 1} in assert (interp (p `star` linv e m) m'); assert (linv e m == lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m)); assert (linv e m' == lock_store_invariant e m.locks `star` ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken_free_above (heap_of_mem m) m.ctr (m.ctr + 1); weaken_pure (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_ctr_valid (m.ctr + 1) (heap_of_mem m)); assert (H.stronger (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m))); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)); H.stronger_star (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken (p `star` lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)) (heap_of_mem m'); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity (m.ctr + 1) (heap_of_mem m)); let m' : hmem_with_inv_except e p = m' in m' let frame_related_mems (fp0 fp1:slprop u#a) e (m0:hmem_with_inv_except e fp0) (m1:hmem_with_inv_except e fp1) = forall (frame:slprop u#a). interp ((fp0 `star` frame) `star` linv e m0) m0 ==> interp ((fp1 `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) let refined_pre_action e (fp0:slprop) (a:Type) (fp1:a -> slprop) = m0:hmem_with_inv_except e fp0 -> Pure (x:a & hmem_with_inv_except e (fp1 x)) (requires True) (ensures fun (| x, m1 |) -> frame_related_mems fp0 (fp1 x) e m0 m1) let refined_pre_action_as_action (#fp0:slprop) (#a:Type) (#fp1:a -> slprop) #e ($f:refined_pre_action e fp0 a fp1) : tot_action_nf_except e fp0 a fp1 = let g : tot_pre_action_nf_except e fp0 a fp1 = fun m -> f m in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp0 `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp1 x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x', m1' |) = g m0 in let (| x, m1 |) = f m0 in assert (x == x' /\ m1 == m1') in g let alloc_action #a #pcm e x = let f : refined_pre_action e emp (ref a pcm) (fun r -> pts_to r x) = fun m0 -> (* NS: 9/29/22 I needed to annotate h : Heap.full_heap, for use with the Core checker which generates a guard for checking the implicit pattern "dot" term in the dependent pair pattern on the next line. That guard expects `h` to be a full_heap, which is it, because it is a projection of m0. However, this is not reflected in `h`'s type. So, the Core checker, which produces a guard for the pat_dot_term in isolation, cannot recheck the term. If we were to fold in the checking of pat_dot_terms and their guards with the rest of the VC, this would work. *) let h : Heap.full_heap = hheap_of_hmem m0 in let (|r, h'|) = H.extend #a #pcm x m0.ctr h in let m' : hmem_with_inv_except e emp = inc_ctr m0 in let h' : H.hheap (pts_to #a #pcm r x `star` linv e m') = weaken _ (linv e m0) (linv e m') h' in let m1 : hmem_with_inv_except e (pts_to #a #pcm r x) = hmem_of_hheap m' h' in assert (forall frame. H.frame_related_heaps h h' emp (pts_to #a #pcm r x) frame true); let aux (frame:slprop) : Lemma (requires interp ((emp `star` frame) `star` linv e m0) m0) (ensures interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) [SMTPat (emp `star` frame)] = star_associative emp frame (linv e m0); assert (H.interp (emp `star` (frame `star` linv e m0)) h); assert (H.interp (pts_to #a #pcm r x `star` (frame `star` linv e m0)) h'); star_associative (pts_to #a #pcm r x) frame (linv e m0); assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m0) h'); assert (H.stronger (linv e m0) (linv e m')); assert (H.equiv (linv e m') (linv e m1)); assert (H.stronger (linv e m0) (linv e m1)); let h' : H.hheap ((pts_to #a #pcm r x `star` frame) `star` linv e m1) = weaken _ (linv e m0) (linv e m1) h' in assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) h'); assert (forall (mp:H.hprop frame). mp h == mp h'); mprop_preservation_of_hprop_preservation frame m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) in assert (frame_related_mems emp (pts_to r x) e m0 m1); (| r, m1 |) in lift_tot_action (refined_pre_action_as_action f) let select_refine #a #p e r x f = lift_tot_action (lift_heap_action e (H.select_refine #a #p r x f)) let upd_gen #a #p e r x y f = lift_tot_action (lift_heap_action e (H.upd_gen_action r x y f)) //////////////////////////////////////////////////////////////////////////////// // witness / recall //////////////////////////////////////////////////////////////////////////////// let witnessed_ref #a #pcm (r:ref a pcm) (fact:property a) (m:full_mem) = H.witnessed_ref #a #pcm r fact (heap_of_mem m) let witnessed_ref_stability #a #pcm (r:ref a pcm) (fact:property a) : Lemma (requires FStar.Preorder.stable fact (Steel.Preorder.preorder_of_pcm pcm)) (ensures FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) = H.witnessed_ref_stability #a #pcm r fact let witnessed (#a:Type u#1) (#pcm:pcm a) (r:ref a pcm) (fact:property a) = W.witnessed _ mem_evolves (witnessed_ref r fact) let rearrange_pqr_prq (p q r:slprop) : Lemma (((p `star` q) `star` r) `equiv` ((p `star` r) `star` q)) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_associative p q r } p `star` (q `star` r); (equiv) { star_commutative q r; star_congruence p (q `star` r) p (r `star` q) } p `star` (r `star` q); (equiv) { star_associative p r q } (p `star` r) `star` q; } let preserves_frame_cong (e:inames) (p q:slprop) (r s:slprop) (m0 m1:mem) : Lemma (requires p `equiv` r /\ q `equiv` s /\ preserves_frame e p q m0 m1) (ensures preserves_frame e r s m0 m1) = let aux0 (p q r s:slprop) : Lemma (requires p `equiv` s) (ensures (((p `star` q) `star` r) `equiv` ((s `star` q) `star` r))) = star_congruence p q s q; star_congruence (p `star` q) r (s `star` q) r in let aux (frame:slprop) : Lemma (requires interp ((r `star` frame) `star` locks_invariant e m0) m0) (ensures interp ((s `star` frame) `star` locks_invariant e m1) m1 /\ interp ((p `star` frame) `star` locks_invariant e m0) m0) [SMTPat (r `star` frame)] = aux0 p frame (locks_invariant e m0) r; aux0 q frame (locks_invariant e m1) s; assert (((p `star` frame) `star` locks_invariant e m0) `equiv` ((r `star` frame) `star` locks_invariant e m0)); assert (interp ((p `star` frame) `star` locks_invariant e m0) m0); assert (interp ((q `star` frame) `star` locks_invariant e m1) m1); assert (((q `star` frame) `star` locks_invariant e m1) `equiv` ((s `star` frame) `star` locks_invariant e m1)); () in () let pure_true_equiv (p:slprop) : Lemma ((p `star` pure True) `equiv` p) = FStar.Classical.forall_intro (pure_star_interp p True); emp_unit p; assert ((p `star` pure True) `equiv` p) let preserves_frame_star_pure (e:inames) (p q:slprop) (r s:prop) (m:mem) : Lemma (requires r /\ s) (ensures preserves_frame e p q m m <==> preserves_frame e (p `star` pure r) (q `star` pure s) m m) = pure_equiv r True; star_congruence p (pure r) p (pure True); pure_equiv s True; star_congruence q (pure s) q (pure True); pure_true_equiv p; pure_true_equiv q; let fwd () : Lemma (requires preserves_frame e p q m m) (ensures preserves_frame e (p `star` pure r) (q `star` pure s) m m) [SMTPat ()] = preserves_frame_cong e p q (p `star` pure r) (q `star` pure s) m m in let bk () : Lemma (requires preserves_frame e (p `star` pure r) (q `star` pure s) m m) (ensures preserves_frame e p q m m) [SMTPat ()] = preserves_frame_cong e (p `star` pure r) (q `star` pure s) p q m m in () let witness (#a:Type) (#pcm:pcm a) (e:inames) (r:erased (ref a pcm)) (fact:stable_property pcm) (v:Ghost.erased a) (_:squash (forall z. compatible pcm v z ==> fact z)) (frame:slprop) : MstTot (witnessed r fact) e (pts_to r v) (fun _ -> pts_to r v) frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in let _ : unit = let hr : H.ref a pcm = r in let v' = H.sel_v hr v (heap_of_mem m0) in assert (interp (H.ptr hr) m0 /\ H.sel #a #pcm hr (heap_of_mem m0) == v'); assert (compatible pcm v v'); assert (fact v'); assert (witnessed_ref r fact m0); witnessed_ref_stability r fact; assert (FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) in let w = NMSTTotal.witness _ mem_evolves (witnessed_ref r fact) in w let recall (#a:Type u#1) (#pcm:pcm a) (#fact:property a) (e:inames) (r:erased (ref a pcm)) (v:Ghost.erased a) (w:witnessed r fact) (frame:slprop) = let m0 = NMSTTotal.get () in NMSTTotal.recall _ mem_evolves (witnessed_ref r fact) w; let hr : H.ref a pcm = r in assert (witnessed_ref r fact m0); let v1 = H.sel_v hr v (heap_of_mem m0) in assert (compatible pcm v v1); assert (H.sel hr (heap_of_mem m0) == v1); assert (fact v1); assert (interp ((pts_to r v `star` frame) `star` locks_invariant e m0) m0); emp_unit ((pts_to r v `star` frame) `star` locks_invariant e m0); pure_star_interp ((pts_to r v `star` frame) `star` locks_invariant e m0) (fact v1) m0; assert (interp (((pts_to r v `star` frame) `star` locks_invariant e m0) `star` pure (fact v1)) m0); rearrange_pqr_prq (pts_to r v `star` frame) (locks_invariant e m0) (pure (fact v1)); assert (interp (((pts_to r v `star` frame) `star` pure (fact v1)) `star` locks_invariant e m0) m0); rearrange_pqr_prq (pts_to r v) frame (pure (fact v1)); star_congruence ((pts_to r v `star` frame) `star` pure (fact v1)) (locks_invariant e m0) ((pts_to r v `star` pure (fact v1)) `star` frame) (locks_invariant e m0); Ghost.hide v1 let iname_for_p_mem (i:iname) (p:slprop) : W.s_predicate mem = fun m -> iname_for_p i p m.locks let iname_for_p_stable (i:iname) (p:slprop) : Lemma (W.stable full_mem mem_evolves (iname_for_p_mem i p)) = () let ( >--> ) (i:iname) (p:slprop) : Type0 = W.witnessed full_mem mem_evolves (iname_for_p_mem i p) let hmem_with_inv_equiv e (m:mem) (p:slprop) : Lemma (interp (p `star` linv e m) m <==> interp (p `star` lock_store_invariant e m.locks) m /\ heap_ctr_valid m.ctr (heap_of_mem m)) = calc (<==>) { interp (p `star` linv e m) m; (<==>) { H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) } interp ((p `star` lock_store_invariant e m.locks) `star` ctr_validity m.ctr (heap_of_mem m)) m; (<==>) { H.pure_star_interp (p `star` lock_store_invariant e m.locks) (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_of_mem m) } interp ((p `star` lock_store_invariant e m.locks) `star` emp) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); (<==>) { H.emp_unit (p `star` lock_store_invariant e m.locks) } interp (p `star` lock_store_invariant e m.locks) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); } let new_invariant_tot_action (e:inames) (p:slprop) (m0:hmem_with_inv_except e p{ e `inames_in` m0.locks }) : Pure (iname & hmem_with_inv_except e emp) (requires True) (ensures fun (i, m1) -> iname_for_p_mem i p m1 /\ frame_related_mems p emp e m0 m1 /\ mem_evolves m0 m1) = let (| i, l1 |) = extend_lock_store e m0.locks p in let m1 = { m0 with locks = l1 } in assert (lock_store_invariant e m1.locks == p `star` lock_store_invariant e m0.locks); calc (equiv) { linv e m1; (equiv) {} (lock_store_invariant e m1.locks `star` ctr_validity m1.ctr (heap_of_mem m1)); (equiv) {} ((p `star` lock_store_invariant e m0.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); (equiv) { H.star_associative p (lock_store_invariant e m0.locks) (ctr_validity m1.ctr (heap_of_mem m1)) } (p `star` (lock_store_invariant e m0.locks `star` ctr_validity m1.ctr (heap_of_mem m1))); (equiv) { } (p `star` linv e m0); }; assert (iname_for_p_mem i p m1); assert (lock_store_evolves m0.locks l1); assert (mem_evolves m0 m1); hmem_with_inv_equiv e m0 p; assert (interp (p `star` lock_store_invariant e m0.locks) m1); assert (interp (lock_store_invariant e m1.locks) m1); H.emp_unit (lock_store_invariant e m1.locks); H.star_commutative (lock_store_invariant e m1.locks) emp; assert (interp (emp `star` lock_store_invariant e m1.locks) m1); hmem_with_inv_equiv e m1 emp; let m1 : hmem_with_inv_except e emp = m1 in let aux (frame:slprop) : Lemma (requires interp ((p `star` frame) `star` linv e m0) m0) (ensures interp ((emp `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) <==> mp (core_mem m1))) [SMTPat (p `star` frame)] = assert (interp ((p `star` frame) `star` linv e m0) m1); calc (equiv) { ((p `star` frame) `star` linv e m0); (equiv) { H.star_commutative p frame; H.star_congruence (p `star` frame) (linv e m0) (frame `star` p) (linv e m0); H.star_associative frame p (linv e m0) } (frame `star` (p `star` linv e m0)); (equiv) { H.star_congruence frame (p `star` linv e m0) frame (linv e m1) } (frame `star` linv e m1); (equiv) { H.emp_unit (frame `star` linv e m1); H.star_commutative (frame `star` linv e m1) emp; H.star_associative emp frame (linv e m1) } ((emp `star` frame) `star` linv e m1); }; assert (interp ((emp `star` frame) `star` linv e m1) m1) in assert (frame_related_mems p emp e m0 m1); ( i, m1 ) let name_is_ok (i:iname) (m0:full_mem u#1) : prop = i < List.Tot.length m0.locks let witnessed_name_is_ok (i:iname) = W.witnessed full_mem mem_evolves (name_is_ok i) let pre_inv = i:erased iname & witnessed_name_is_ok i let inv (p:slprop u#1) = i:erased iname & witnessed_name_is_ok i & (i >--> p)

{ "checked_file": "/", "dependencies": [ "Steel.Preorder.fst.checked", "Steel.Heap.fsti.checked", "prims.fst.checked", "FStar.Witnessed.Core.fsti.checked", "FStar.Set.fsti.checked", "FStar.Preorder.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.PCM.fst.checked", "FStar.NMSTTotal.fst.checked", "FStar.List.Tot.fst.checked", "FStar.IndefiniteDescription.fsti.checked", "FStar.Ghost.fsti.checked", "FStar.FunctionalExtensionality.fsti.checked", "FStar.Classical.Sugar.fsti.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Steel.Memory.fst" }

[ { "abbrev": true, "full_module": "Steel.Preorder", "short_module": "PP" }, { "abbrev": true, "full_module": "FStar.Witnessed.Core", "short_module": "W" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": true, "full_module": "Steel.Heap", "short_module": "H" }, { "abbrev": false, "full_module": "FStar.FunctionalExtensionality", "short_module": null }, { "abbrev": true, "full_module": "FStar.FunctionalExtensionality", "short_module": "F" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": false, "full_module": "FStar.PCM", "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

i: Steel.Memory.inv p -> Steel.Memory.pre_inv

Prims.Tot

[ "total" ]

[]

[ "Steel.Memory.slprop", "Steel.Memory.inv", "FStar.Ghost.erased", "Steel.Memory.iname", "Steel.Memory.witnessed_name_is_ok", "FStar.Ghost.reveal", "Steel.Memory.op_Greater_Subtraction_Subtraction_Greater", "Prims.Mkdtuple2", "Steel.Memory.pre_inv" ]

[]

false

let pre_inv_of_inv #p (i: inv p) =

let (| i , w , _ |) = i in (| i, w |)

false

Steel.HigherReference.fst

Steel.HigherReference.atomic_read

val atomic_read (#opened:_) (#a:Type) (#p:perm) (#v:erased a) (r:ref a) : SteelAtomic a opened (pts_to r p v) (fun x -> pts_to r p x) (requires fun h -> True) (ensures fun _ x _ -> x == Ghost.reveal v)

let atomic_read (#opened:_) (#a:Type) (#p:perm) (#v:erased a) (r:ref a) = let v1 : erased (fractional a) = Ghost.hide (Some (Ghost.reveal v, p)) in rewrite_slprop (pts_to r p v) (RP.pts_to r v1 `star` pure (perm_ok p)) (fun _ -> ()); elim_pure (perm_ok p); let v2 = RP.atomic_read r v1 in rewrite_slprop (RP.pts_to r v1) (pts_to r p v) (fun m -> emp_unit (hp_of (pts_to_raw r p v)); pure_star_interp (hp_of (pts_to_raw r p v)) (perm_ok p) m); assert (compatible pcm_frac v1 v2); let Some (x, _) = v2 in rewrite_slprop (pts_to r p v) (pts_to r p x) (fun _ -> ()); return x

{ "file_name": "lib/steel/Steel.HigherReference.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 12, "end_line": 173, "start_col": 0, "start_line": 160 }

(* 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.HigherReference open FStar.Ghost open Steel.Memory open Steel.Effect.Atomic open Steel.Effect open FStar.PCM open Steel.PCMFrac open FStar.Real module RP = Steel.PCMReference #set-options "--ide_id_info_off" module Mem = Steel.Memory let ref a = Mem.ref (fractional a) pcm_frac let null #a = Mem.null #(fractional a) #pcm_frac let is_null #a r = Mem.is_null #(fractional a) #pcm_frac r let perm_ok p : prop = (p.v <=. one == true) /\ True let pts_to_raw_sl (#a:Type) (r:ref a) (p:perm) (v:erased a) : slprop = Mem.pts_to r (Some (Ghost.reveal v, p)) let pts_to_raw (#a:Type) (r:ref a) (p:perm) (v:erased a) : vprop = to_vprop (Mem.pts_to r (Some (Ghost.reveal v, p))) [@@__reduce__] let pts_to' (#a:Type u#1) (r:ref a) (p:perm) (v:erased a) : vprop = pts_to_raw r p v `star` pure (perm_ok p) let pts_to_sl #a r p v = hp_of (pts_to' r p v) let abcd_acbd (a b c d:slprop) : Lemma (Mem.(((a `star` b) `star` (c `star` d)) `equiv` ((a `star` c) `star` (b `star` d)))) = let open Steel.Memory in calc (equiv) { ((a `star` b) `star` (c `star` d)); (equiv) { star_associative a b (c `star` d) } ((a `star` (b `star` (c `star` d)))); (equiv) { star_associative b c d; star_congruence a (b `star` (c `star` d)) a ((b `star` c) `star` d) } (a `star` ((b `star` c) `star` d)); (equiv) { star_commutative b c; star_congruence (b `star` c) d (c `star` b) d; star_congruence a ((b `star` c) `star` d) a ((c `star` b) `star` d) } (a `star` ((c `star` b) `star` d)); (equiv) { star_associative c b d; star_congruence a ((c `star` b) `star` d) a (c `star` (b `star` d)) } (a `star` (c `star` (b `star` d))); (equiv) { star_associative a c (b `star` d) } ((a `star` c) `star` (b `star` d)); } let pts_to_ref_injective (#a: Type u#1) (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 open Steel.Memory in abcd_acbd (hp_of (pts_to_raw r p0 v0)) (pure (perm_ok p0)) (hp_of (pts_to_raw r p1 v1)) (pure (perm_ok p1)); Mem.affine_star (hp_of (pts_to_raw r p0 v0) `star` hp_of (pts_to_raw r p1 v1)) (pure (perm_ok p0) `star` pure (perm_ok p1)) m; Mem.pts_to_compatible r (Some (Ghost.reveal v0, p0)) (Some (Ghost.reveal v1, p1)) m let pts_to_not_null (#a:Type u#1) (r:ref a) (p:perm) (v:a) (m:mem) : Lemma (requires interp (pts_to_sl r p v) m) (ensures r =!= null) = Mem.affine_star (hp_of (pts_to_raw r p v)) (Mem.pure (perm_ok p)) m; Mem.pts_to_not_null r (Some (Ghost.reveal v, p)) m let pts_to_witinv (#a:Type) (r:ref a) (p:perm) : Lemma (is_witness_invariant (pts_to_sl r p)) = let aux (x y : erased a) (m:mem) : Lemma (requires (interp (pts_to_sl r p x) m /\ interp (pts_to_sl r p y) m)) (ensures (x == y)) = Mem.pts_to_join r (Some (Ghost.reveal x, p)) (Some (Ghost.reveal y, p)) m in Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y)) let higher_ref_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_framon (#a:Type) (r:ref a) (p:perm) : Lemma (is_frame_monotonic (pts_to_sl r p)) = pts_to_witinv r p let intro_pts_to (p:perm) #a #uses (#v:erased a) (r:ref a) : SteelGhost unit uses (pts_to_raw r p v) (fun _ -> pts_to r p v) (requires fun _ -> perm_ok p) (ensures fun _ _ _ -> True) = intro_pure (perm_ok p); rewrite_slprop (pts_to' r p v) (pts_to r p v) (fun _ -> ()) let pts_to_perm #_ #_ #p #v r = rewrite_slprop (pts_to r p v) (pts_to' r p v) (fun _ -> ()); elim_pure (perm_ok p); intro_pure (perm_ok p); rewrite_slprop (pts_to' r p v) (pts_to r p v) (fun _ -> ()) let alloc #a x = let v = Some (x, full_perm) in assert (FStar.PCM.composable pcm_frac v None); assert (compatible pcm_frac v v); let r = RP.alloc v in rewrite_slprop (RP.pts_to r v) (pts_to r full_perm x) (fun m -> emp_unit (hp_of (pts_to_raw r full_perm x)); pure_star_interp (hp_of (pts_to_raw r full_perm x)) (perm_ok full_perm) m ); extract_info_raw (pts_to r full_perm x) (~ (is_null r)) (fun m -> pts_to_not_null r full_perm x m); return r let read (#a:Type) (#p:perm) (#v:erased a) (r:ref a) = let v1 : erased (fractional a) = Ghost.hide (Some (Ghost.reveal v, p)) in rewrite_slprop (pts_to r p v) (RP.pts_to r v1 `star` pure (perm_ok p)) (fun _ -> ()); elim_pure (perm_ok p); let v2 = RP.read r v1 in rewrite_slprop (RP.pts_to r v1) (pts_to r p v) (fun m -> emp_unit (hp_of (pts_to_raw r p v)); pure_star_interp (hp_of (pts_to_raw r p v)) (perm_ok p) m); assert (compatible pcm_frac v1 v2); let Some (x, _) = v2 in rewrite_slprop (pts_to r p v) (pts_to r p x) (fun _ -> ()); return x

{ "checked_file": "/", "dependencies": [ "Steel.PCMReference.fsti.checked", "Steel.PCMFrac.fst.checked", "Steel.Memory.fsti.checked", "Steel.Effect.Atomic.fsti.checked", "Steel.Effect.fsti.checked", "prims.fst.checked", "FStar.Real.fsti.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.PCM.fst.checked", "FStar.NMSTTotal.fst.checked", "FStar.Ghost.fsti.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Steel.HigherReference.fst" }

[ { "abbrev": true, "full_module": "Steel.Memory", "short_module": "Mem" }, { "abbrev": true, "full_module": "Steel.PCMReference", "short_module": "RP" }, { "abbrev": false, "full_module": "FStar.Real", "short_module": null }, { "abbrev": false, "full_module": "Steel.PCMFrac", "short_module": null }, { "abbrev": false, "full_module": "FStar.PCM", "short_module": null }, { "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": 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": false, "full_module": "Steel.FractionalPermission", "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.HigherReference.ref a -> Steel.Effect.Atomic.SteelAtomic a

Steel.Effect.Atomic.SteelAtomic

[]

[ "Steel.Memory.inames", "Steel.FractionalPermission.perm", "FStar.Ghost.erased", "Steel.HigherReference.ref", "Steel.Effect.Atomic.return", "Steel.HigherReference.pts_to", "Steel.Effect.Common.vprop", "Prims.unit", "Steel.Effect.Atomic.rewrite_slprop", "FStar.Ghost.reveal", "Steel.Memory.mem", "Steel.PCMFrac.fractional", "Prims._assert", "FStar.PCM.compatible", "Steel.PCMFrac.pcm_frac", "Steel.PCMReference.pts_to", "Steel.Memory.pure_star_interp", "Steel.Effect.Common.hp_of", "Steel.HigherReference.pts_to_raw", "Steel.HigherReference.perm_ok", "Steel.Memory.emp_unit", "Steel.PCMReference.atomic_read", "Steel.Effect.Atomic.elim_pure", "Steel.Effect.Common.star", "Steel.Effect.Common.pure", "FStar.Ghost.hide", "FStar.Pervasives.Native.Some", "FStar.Pervasives.Native.tuple2", "FStar.Pervasives.Native.Mktuple2" ]

[]

false

true

false

let atomic_read (#opened: _) (#a: Type) (#p: perm) (#v: erased a) (r: ref a) =

let v1:erased (fractional a) = Ghost.hide (Some (Ghost.reveal v, p)) in rewrite_slprop (pts_to r p v) ((RP.pts_to r v1) `star` (pure (perm_ok p))) (fun _ -> ()); elim_pure (perm_ok p); let v2 = RP.atomic_read r v1 in rewrite_slprop (RP.pts_to r v1) (pts_to r p v) (fun m -> emp_unit (hp_of (pts_to_raw r p v)); pure_star_interp (hp_of (pts_to_raw r p v)) (perm_ok p) m); assert (compatible pcm_frac v1 v2); let Some (x, _) = v2 in rewrite_slprop (pts_to r p v) (pts_to r p x) (fun _ -> ()); return x

false

Steel.Memory.fst

Steel.Memory.lift_heap_action_with_frame

val lift_heap_action_with_frame (#fp: slprop u#a) (#a: Type u#b) (#fp': (a -> slprop u#a)) (e: inames) ($f: H.action_with_frame fp a fp') : tot_action_with_frame_except e fp a fp'

let lift_heap_action_with_frame (#fp:slprop u#a) (#a:Type u#b) (#fp':a -> slprop u#a) (e:inames) ($f:H.action_with_frame fp a fp') : tot_action_with_frame_except e fp a fp' = fun frame m0 -> let h0 = hheap_of_hmem m0 in calc (equiv) { fp `star` frame `star` locks_invariant e m0; (equiv) { star_associative fp frame (locks_invariant e m0) } fp `star` (frame `star` locks_invariant e m0); }; assert (H.interp (fp `star` frame `star` locks_invariant e m0) h0); assert (H.interp (fp `star` (frame `star` locks_invariant e m0)) h0); //key: apply the heap action with frame * locks_invariant e m0 let (| x, h1 |) = f (frame `star` locks_invariant e m0) h0 in calc (equiv) { fp' x `star` (frame `star` locks_invariant e m0); (equiv) { star_associative (fp' x) frame (locks_invariant e m0) } fp' x `star` frame `star` locks_invariant e m0; }; assert (H.interp (fp' x `star` (frame `star` locks_invariant e m0)) h1); assert (H.interp (fp' x `star` frame `star` locks_invariant e m0) h1); let m1 = hmem_of_hheap m0 h1 in assert (mem_evolves m0 m1); mprop_preservation_of_hprop_preservation (frame `star` locks_invariant e m0) m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)); (| x, m1 |)

{ "file_name": "lib/steel/Steel.Memory.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 15, "end_line": 822, "start_col": 0, "start_line": 789 }

(* 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.Memory module F = FStar.FunctionalExtensionality open FStar.FunctionalExtensionality open FStar.PCM module H = Steel.Heap noeq type lock_state : Type u#(a + 1) = | Invariant : inv:H.slprop u#a -> lock_state let lock_store : Type u#(a+1) = list (lock_state u#a) noeq type mem : Type u#(a + 1) = { ctr: nat; heap: H.heap u#a; locks: lock_store u#a; } let heap_of_mem (x:mem) : H.heap = x.heap let mem_of_heap (h:H.heap) : mem = { ctr = 0; heap = h; locks = [] } let mem_set_heap (m:mem) (h:H.heap) : mem = { ctr = m.ctr; heap = h; locks = m.locks; } let core_mem (m:mem) : mem = mem_of_heap (heap_of_mem m) let core_mem_invol m = () let disjoint (m0 m1:mem u#h) : prop = m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks let disjoint_sym m0 m1 = () let join m0 m1 = { ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = m0.locks } let join_commutative m0 m1 = H.join_commutative m0.heap m1.heap let disjoint_join m0 m1 m2 = H.disjoint_join m0.heap m1.heap m2.heap let join_associative m0 m1 m2 = H.join_associative m0.heap m1.heap m2.heap let slprop = H.slprop let interp p m = H.interp p m.heap let equiv p1 p2 = forall m. interp p1 m <==> interp p2 m let slprop_extensionality p q = assert (forall m. interp p m <==> interp q m); let aux (h:H.heap) : Lemma (H.interp p h <==> H.interp q h) [SMTPat (H.interp p h)] = let m : mem = { ctr = 0; heap = h; locks = [] } in assert (interp p m <==> interp q m) in assert (forall h. H.interp p h <==> H.interp q h); Steel.Heap.slprop_extensionality p q let reveal_equiv p1 p2 = () let core_ref = H.core_ref let core_ref_null = H.core_ref_null let core_ref_is_null r = H.core_ref_is_null r let emp : slprop u#a = H.emp let pure = H.pure let pts_to = H.pts_to let h_and = H.h_and let h_or = H.h_or let star = H.star let wand = H.wand let h_exists = H.h_exists let h_forall = H.h_forall //////////////////////////////////////////////////////////////////////////////// //properties of equiv //////////////////////////////////////////////////////////////////////////////// let equiv_symmetric (p1 p2:slprop u#a) = H.equiv_symmetric p1 p2 #push-options "--warn_error -271" let equiv_heap_iff_equiv (p1 p2:slprop u#a) : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat (equiv p1 p2)] = let aux_lr () : Lemma (requires H.equiv p1 p2) (ensures equiv p1 p2) [SMTPat ()] = () in let aux_rl_helper1 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p1 h) (ensures H.interp p2 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl_helper2 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p2 h) (ensures H.interp p1 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl () : Lemma (requires equiv p1 p2) (ensures H.equiv p1 p2) [SMTPat ()] = () in () let equiv_heap_iff_equiv_forall () : Lemma (ensures (forall p1 p2. H.equiv p1 p2 <==> equiv p1 p2)) = let aux p1 p2 : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat ()] = equiv_heap_iff_equiv p1 p2 in () #pop-options let equiv_extensional_on_star (p1 p2 p3:slprop u#a) = equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3 let emp_unit p = H.emp_unit p let intro_emp m = H.intro_emp (heap_of_mem m) let pure_equiv p q = H.pure_equiv p q let pure_interp q m = H.pure_interp q (heap_of_mem m) let pure_star_interp p q m = H.pure_star_interp p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// //pts_to //////////////////////////////////////////////////////////////////////////////// let pts_to_compatible #a #pcm x v0 v1 m = H.pts_to_compatible #a #pcm x v0 v1 (heap_of_mem m) let pts_to_compatible_equiv #a #pcm x v0 v1 = H.pts_to_compatible_equiv #a #pcm x v0 v1 let pts_to_not_null #a #pcm x v m = H.pts_to_not_null #a #pcm x v (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // star //////////////////////////////////////////////////////////////////////////////// let intro_star p q mp mq = H.intro_star p q (heap_of_mem mp) (heap_of_mem mq) let elim_star p q m = let h = heap_of_mem m in H.elim_star p q h; assert (exists hl hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr); let hl = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hl -> exists hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let hr = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hr -> H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let ml = mem_set_heap m hl in let mr = mem_set_heap m hr in assert (disjoint ml mr); assert (m == join ml mr); assert (interp p ml); assert (interp q mr); () let interp_star (p q: slprop) (m: mem) : Lemma (interp (p `star` q) m <==> (exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m)) = let left = interp (p `star` q) m in let right = exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m in let f () : Lemma (requires left) (ensures right) = elim_star p q m in let g () : Lemma (requires right) (ensures left) = Classical.exists_elim left #_ #(fun mp -> exists (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mp -> Classical.exists_elim left #_ #(fun mq -> disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mq -> intro_star p q mp mq ) ) in Classical.move_requires f (); Classical.move_requires g () let star_commutative (p1 p2:slprop) = H.star_commutative p1 p2 let star_associative (p1 p2 p3:slprop) = H.star_associative p1 p2 p3 let star_congruence (p1 p2 p3 p4:slprop) = equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4 let affine_star (p q:slprop) (m:mem) = H.affine_star p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // Invariants on the lock store //////////////////////////////////////////////////////////////////////////////// let iname = nat module S = FStar.Set module L = FStar.List.Tot module W = FStar.Witnessed.Core let rec lock_store_invariant (e:inames) (l:lock_store u#a) : slprop u#a = let current_addr = L.length l - 1 in match l with | [] -> emp | Invariant p :: tl -> if current_addr `S.mem` e then lock_store_invariant e tl else p `star` lock_store_invariant e tl let lock_i (i:iname) (l:lock_store { i < L.length l }) = let ix = L.length l - i - 1 in L.index l ix let iname_for_p (i:iname) (p:slprop) : W.s_predicate lock_store = fun l -> i < L.length l /\ (lock_i i l).inv == p let lock_store_evolves : FStar.Preorder.preorder lock_store = fun (l1 l2 : lock_store) -> L.length l2 >= L.length l1 /\ (forall (i:nat{i < L.length l1}). (lock_i i l1).inv == (lock_i i l2).inv) let inames_in (e:inames) (l:lock_store) : prop = forall i. Set.mem i e ==> i < L.length l let inames_ok e m = inames_in e m.locks let inames_ok_empty m = () let extend_lock_store (e:inames) (l:lock_store{e `inames_in` l}) (p:slprop) : i:iname & l':lock_store { lock_store_invariant e l' == p `star` lock_store_invariant e l /\ iname_for_p i p l' } = (| L.length l, Invariant p :: l |) let set_add (i:iname) (s:inames) = Set.union (Set.singleton i) s let rec move_invariant (e:inames) (l:lock_store) (p:slprop) (i:iname{iname_for_p i p l /\ ~(i `Set.mem` e)}) : Lemma (H.equiv (lock_store_invariant e l) (p `star` lock_store_invariant (set_add i e) l)) = let rec aux (i:iname) (m:lock_store) : Lemma (requires i >= L.length m) (ensures (lock_store_invariant e m `H.equiv` lock_store_invariant (set_add i e) m)) = match m with | [] -> () | Invariant p::tl -> aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl) in let current_addr = L.length l - 1 in match l with | [] -> () | Invariant q::tl -> if i = current_addr then begin assert (lock_store_invariant e l == p `star` lock_store_invariant e tl); aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl); () end else begin move_invariant e tl p i; assert (lock_store_invariant e tl `equiv` (p `star` lock_store_invariant (set_add i e) tl)); H.star_congruence q (lock_store_invariant e tl) q (p `star` lock_store_invariant (set_add i e) tl); if Set.mem current_addr e then () else begin let r = lock_store_invariant (set_add i e) tl in assert (lock_store_invariant e l `equiv` (q `star` (p `star` r))); H.star_associative q p r; H.star_commutative q p; H.star_congruence (q `star` p) r (p `star` q) r; H.star_associative p q r end end let heap_ctr_valid (ctr:nat) (h:H.heap u#a) : prop = h `H.free_above_addr` ctr let ctr_validity (ctr:nat) (h:H.heap) : slprop = H.pure (heap_ctr_valid ctr h) let locks_invariant (e:inames) (m:mem u#a) : slprop u#a = lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m) let full_mem_pred (m:mem) = H.full_heap_pred (heap_of_mem m) (***** Following lemmas are needed in Steel.Effect *****) let core_mem_interp (hp:slprop u#a) (m:mem u#a) = () let interp_depends_only_on (hp:slprop u#a) = H.interp_depends_only_on hp let a_mem_prop_as_a_heap_prop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (H.a_heap_prop u#a) = let g (h: H.heap u#a) : Tot prop = interp sl (mem_of_heap h) /\ f (mem_of_heap h) in let phi0 (h0 h1: H.heap u#a) : Lemma (requires (g h0 /\ H.disjoint h0 h1)) (ensures (g h0 /\ H.disjoint h0 h1 /\ g (H.join h0 h1))) = assert (mem_of_heap (H.join h0 h1) == mem_of_heap h0 `join` mem_of_heap h1); interp_depends_only_on sl in let phi1 (h0 h1: H.heap u#a) : Lemma (ensures ((g h0 /\ H.disjoint h0 h1) ==> g (H.join h0 h1))) = Classical.move_requires (phi0 h0) h1 in Classical.forall_intro_2 phi1; g let refine_slprop sl f = H.as_slprop (a_mem_prop_as_a_heap_prop sl f) let interp_refine_slprop sl f m = assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_mem m)) let dep_hprop (s: slprop) (f: (hmem s -> Tot slprop)) (h: H.heap) : Tot prop = exists (h1: H.heap) . exists (h2: H.heap) . interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 let dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq' : squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h')) = let p2 (h h1 h2: H.heap) : Tot prop = interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 in let p1 (h h1: H.heap) : Tot prop = (exists h2 . p2 h h1 h2) in let h1 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p1 h) in let h2 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p2 h h1) in H.disjoint_join h' h1 h2; assert (H.disjoint h2 h'); let h2' = H.join h2 h' in H.join_commutative h2 h' ; assert (h2' == H.join h' h2); assert (H.disjoint h1 h2'); assert (mem_of_heap h2' == mem_of_heap h2 `join` mem_of_heap h'); interp_depends_only_on (f (mem_of_heap h1)); assert (interp (f (mem_of_heap h1)) (mem_of_heap h2')); H.join_commutative h1 h2; H.join_associative h' h2 h1; H.join_commutative h' h; H.join_commutative h2' h1; assert (H.join h h' == h1 `H.join` h2') let impl_intro_gen (#p: Type0) (#q: Type0) ($prf: (squash p -> Lemma (q ))) : Lemma (p ==> q) = Classical.impl_intro_gen #p #(fun _ -> q) prf let dep_hprop_is_affine1 (s: slprop) (f: (hmem s -> Tot slprop)) (h0 h1: H.heap) : Lemma ((dep_hprop s f h0 /\ H.disjoint h0 h1) ==> (H.disjoint h0 h1 /\ dep_hprop s f (H.join h0 h1))) = impl_intro_gen (dep_hprop_is_affine0 s f h0 h1) let dep_hprop_is_affine (s: slprop) (f: (hmem s -> Tot slprop)) : Lemma (H.heap_prop_is_affine (dep_hprop s f)) = Classical.forall_intro_2 (dep_hprop_is_affine1 s f) let sdep (s: slprop) (f: (hmem s -> Tot slprop)) : Tot slprop = dep_hprop_is_affine s f; H.as_slprop (dep_hprop s f) let interp_sdep (s: slprop) (f: (hmem s -> Tot slprop)) (m: mem) : Lemma (requires (dep_slprop_is_affine s f)) (ensures ( interp (sdep s f) m <==> (exists m1 m2 . interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) )) = dep_hprop_is_affine s f; assert (forall m1 m2 . (interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) ==> ( interp s (mem_of_heap m1.heap) /\ interp (f (mem_of_heap m1.heap)) (mem_of_heap m2.heap) /\ H.disjoint m1.heap m2.heap /\ H.join m1.heap m2.heap == m.heap )); interp_depends_only_on s; Classical.forall_intro (fun m -> interp_depends_only_on (f m)); assert (forall h1 h2 . (interp s (mem_of_heap h1) /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ H.disjoint h1 h2 /\ H.join h1 h2 == m.heap) ==> ( core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ interp s (core_mem (mem_of_heap h1)) /\ interp s (mem_set_heap m h1) /\ core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ f (mem_set_heap m h1) `equiv` f (mem_of_heap h1) /\ interp (f (mem_set_heap m h1)) (mem_of_heap h2) /\ interp (f (mem_set_heap m h1)) (mem_set_heap m h2) /\ disjoint (mem_set_heap m h1) (mem_set_heap m h2) /\ join (mem_set_heap m h1) (mem_set_heap m h2) == m )); () let h_exists_cong (#a:Type) (p q : a -> slprop) : Lemma (requires (forall x. p x `equiv` q x)) (ensures (h_exists p `equiv` h_exists q)) = equiv_heap_iff_equiv_forall (); H.h_exists_cong p q let intro_h_exists #a x p m = H.intro_h_exists x p (heap_of_mem m) let elim_h_exists (#a:_) (p:a -> slprop) (m:mem) = H.elim_h_exists p (heap_of_mem m) let intro_h_forall (#a:_) (p:a -> slprop) (m:mem) = H.intro_h_forall p (heap_of_mem m) let elim_h_forall (#a:_) (p:a -> slprop) (m:mem) (x:a) = H.elim_h_forall p (heap_of_mem m) x let intro_h_and (p q: slprop) (m:mem) = H.intro_h_and p q (heap_of_mem m) let elim_h_and (p q: slprop) (m:mem) = H.elim_h_and p q (heap_of_mem m) let intro_h_or_left (p q: slprop) (m:mem) = H.intro_h_or_left p q (heap_of_mem m) let intro_h_or_right (p q: slprop) (m:mem) = H.intro_h_or_right p q (heap_of_mem m) let elim_h_or (p q: slprop) (m:mem) = H.elim_h_or p q (heap_of_mem m) let intro_wand (p1 p2: slprop u#a) (m:mem) = introduce (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)) ==> interp (wand p1 p2) m with _. ( assert (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)); H.intro_wand p1 p2 (heap_of_mem m); let h = heap_of_mem m in assert ((forall h1. h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) ==> H.interp (wand p1 p2) h); introduce forall h1. (h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) with ( introduce (h `H.disjoint` h1 /\ H.interp p1 h1) ==> H.interp p2 (H.join h h1) with _. ( assert (h `H.disjoint` h1); let m1 = { ctr = m.ctr; heap = h1; locks = m.locks } in assert (m `disjoint` m1) ) ) ) (** Eliminating a wand by proving a heap that satisfies the LHS **) let elim_wand (p1 p2: slprop u#a) (m:mem) (m1:mem) = H.elim_wand p1 p2 (heap_of_mem m) (heap_of_mem m1) //////////////////////////////////////////////////////////////////////////////// // Preorders and effects //////////////////////////////////////////////////////////////////////////////// module PP = Steel.Preorder let mem_evolves = fun (m0 m1:full_mem) -> H.heap_evolves (heap_of_mem m0) (heap_of_mem m1) /\ m0.ctr <= m1.ctr /\ lock_store_evolves m0.locks m1.locks (** See [Steel.Heap.is_frame_preserving]. We add in [lock_invariants] now *) let preserves_frame (e:inames) (pre post:slprop) (m0 m1:mem) = forall (frame:slprop). interp ((pre `star` frame) `star` locks_invariant e m0) m0 ==> (interp ((post `star` frame) `star` locks_invariant e m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) (** This is a version of MstTot with frame quantified, as part of preserves_frame *) effect MstTotNF (a:Type u#a) (except:inames) (expects:slprop u#1) (provides: a -> slprop u#1) = NMSTTotal.NMSTATETOT a (full_mem u#1) mem_evolves (requires fun m0 -> inames_ok except m0 /\ interp (expects `star` locks_invariant except m0) m0) (ensures fun m0 x m1 -> inames_ok except m1 /\ interp (provides x `star` locks_invariant except m1) m1 /\ preserves_frame except expects (provides x) m0 m1) //////////////////////////////////////////////////////////////////////////////// // Lifting heap actions //////////////////////////////////////////////////////////////////////////////// (** Heap actions come in two equivalent flavors: - one that take an explicit frame as argument (action_with_frame) - and one that quantify over all the frame We therefore define two lift routes: - a direct route for those with explicit frame - via MstTotNF for the rest *) let tot_pre_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = hmem_with_inv_except e fp -> (x:a & hmem_with_inv_except e (fp' x)) let tot_pre_action_nf = tot_pre_action_nf_except S.empty let ac_reasoning_for_m_frame_preserving (p q r:slprop u#a) (m:mem u#a) : Lemma (requires interp ((p `star` q) `star` r) m) (ensures interp (p `star` r) m) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_commutative p q; equiv_extensional_on_star (p `star` q) (q `star` p) r } (q `star` p) `star` r; (equiv) { star_associative q p r } q `star` (p `star` r); }; assert (interp (q `star` (p `star` r)) m); affine_star q (p `star` r) m let is_frame_preserving (#e:inames) (#a:Type u#b) (#fp:slprop u#a) (#fp':a -> slprop u#a) (f:tot_pre_action_nf_except e fp a fp') = forall (frame:slprop u#a) (m0:hmem_with_inv_except e (fp `star` frame)). (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = f:tot_pre_action_nf_except e fp a fp'{ is_frame_preserving f } let tot_action_nf = tot_action_nf_except S.empty let linv e (m:mem) = locks_invariant e m let hheap_of_hmem #fp #e (m:hmem_with_inv_except e fp) : h:H.hheap (fp `star` linv e m) { h `H.free_above_addr` m.ctr} = let h = heap_of_mem m in H.pure_interp (heap_ctr_valid m.ctr (heap_of_mem m)) h; h let hmem_of_hheap #e (#fp0 #fp1:slprop) (m:hmem_with_inv_except e fp0) (h:H.full_hheap (fp1 `star` linv e m) { h `Heap.free_above_addr` m.ctr }) : m1:hmem_with_inv_except e fp1{linv e m `equiv` linv e m1} = let m1 : mem = { m with heap = h } in assert (interp (fp1 `star` linv e m) m1); star_commutative fp1 (linv e m); assert (interp (linv e m `star` fp1) m1); assert (linv e m1 == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); assert (linv e m == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m)); H.pure_interp (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_of_mem m); assert (heap_ctr_valid m1.ctr (heap_of_mem m) <==> heap_ctr_valid m1.ctr (heap_of_mem m1)); H.pure_equiv (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_ctr_valid m1.ctr (heap_of_mem m1)); H.star_congruence (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m)); assert (linv e m `equiv` linv e m1); let _ = equiv_extensional_on_star (linv e m) (linv e m1) fp1 in assert ((linv e m `star` fp1) `equiv` (linv e m1 `star` fp1)); assert (interp (linv e m1 `star` fp1) m1); star_commutative (linv e m1) fp1; assert (interp (fp1 `star` linv e m1) m1); m1 let with_inv_except (m:mem) e (fp:slprop) = interp (fp `star` locks_invariant e m) m #push-options "--warn_error -271" let as_hprop (frame:slprop) (mp:mprop frame) : hp:H.hprop frame{forall m. mp (core_mem m) == hp (heap_of_mem m)} = let f = fun h -> mp (mem_of_heap h) in assert (forall m. mp (core_mem m) == f (heap_of_mem m)); let aux (m0:H.hheap frame) (m1:H.heap{H.disjoint m0 m1}) : Lemma (ensures (mem_of_heap (H.join m0 m1) == join (mem_of_heap m0) (mem_of_heap m1))) [SMTPat ()] = () in f let mprop_preservation_of_hprop_preservation (p:slprop) (m0 m1:mem) : Lemma (requires (forall (hp:H.hprop p). hp (heap_of_mem m0) == hp (heap_of_mem m1))) (ensures (forall (mp:mprop p). mp (core_mem m0) == mp (core_mem m1))) = let aux (mp:mprop p) : Lemma (mp (core_mem m0) == mp (core_mem m1)) [SMTPat()] = assert (as_hprop p mp (heap_of_mem m0) == as_hprop p mp (heap_of_mem m1)) in () let lift_heap_action (#fp:slprop) (#a:Type) (#fp':a -> slprop) (e:inames) ($f:H.action fp a fp') : tot_action_nf_except e fp a fp' = let g : tot_pre_action_nf_except e fp a fp' = fun m -> let h0 = hheap_of_hmem m in let (| x, h' |) = f h0 in (| x, hmem_of_hheap m h' |) in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in let h0 = hheap_of_hmem m0 in let (| x', h1 |) = f h0 in H.action_framing f (linv e m0) h0; assert (x == x'); star_associative fp frame (linv e m0); H.action_framing f (frame `star` linv e m0) h0; assert (H.interp ((fp' x) `star` (frame `star` linv e m0)) h1); star_associative (fp' x) frame (linv e m0); assert (H.interp ((fp' x `star` frame) `star` linv e m0) h1); let h1' : H.hheap ((fp' x `star` frame) `star` linv e m0) = h1 in assert (m1 == hmem_of_hheap m0 h1'); assert (with_inv_except m1 e (fp' x `star` frame)); assert (forall (hp:H.hprop frame). hp h0 == hp h1); mprop_preservation_of_hprop_preservation frame m0 m1; () in assert (is_frame_preserving g); g let frame_preserving_respects_preorder #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (m0:hmem_with_inv_except e fp) : Lemma (let (| x, m1 |) = f m0 in mem_evolves m0 m1) = let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1) = () in H.emp_unit fp; assert (interp (fp `star` linv e m0) m0); H.star_congruence (fp `star` emp) (linv e m0) fp (linv e m0); assert (interp ((fp `star` emp) `star` linv e m0) m0); aux emp m0 let lift_tot_action_nf #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') : MstTotNF a e fp fp' = let m0 = NMSTTotal.get () in let m0' : hmem_with_inv_except e fp = m0 in let r = f m0' in let (| x, m1 |) = r in let m1' : hmem_with_inv_except e (fp' x) = m1 in assert (is_frame_preserving f); assert (m1 == dsnd (f m0)); frame_preserving_respects_preorder f m0; NMSTTotal.put #_ #(mem_evolves) m1; x let lift_tot_action #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get #(full_mem) #_ () in ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); lift_tot_action_nf f (** Now defining the lift for heap actions with explicit frame *) let tot_action_with_frame_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = frame:slprop u#a -> m0:hmem_with_inv_except e (fp `star` frame) -> Pure (x:a & hmem_with_inv_except e (fp' x `star` frame)) (requires True) (ensures fun (| x, m1 |) -> mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_with_frame = tot_action_with_frame_except S.empty

{ "checked_file": "/", "dependencies": [ "Steel.Preorder.fst.checked", "Steel.Heap.fsti.checked", "prims.fst.checked", "FStar.Witnessed.Core.fsti.checked", "FStar.Set.fsti.checked", "FStar.Preorder.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.PCM.fst.checked", "FStar.NMSTTotal.fst.checked", "FStar.List.Tot.fst.checked", "FStar.IndefiniteDescription.fsti.checked", "FStar.Ghost.fsti.checked", "FStar.FunctionalExtensionality.fsti.checked", "FStar.Classical.Sugar.fsti.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Steel.Memory.fst" }

[ { "abbrev": true, "full_module": "Steel.Preorder", "short_module": "PP" }, { "abbrev": true, "full_module": "FStar.Witnessed.Core", "short_module": "W" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": true, "full_module": "Steel.Heap", "short_module": "H" }, { "abbrev": false, "full_module": "FStar.PCM", "short_module": null }, { "abbrev": false, "full_module": "FStar.FunctionalExtensionality", "short_module": null }, { "abbrev": true, "full_module": "FStar.FunctionalExtensionality", "short_module": "F" }, { "abbrev": false, "full_module": "FStar.PCM", "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

e: Steel.Memory.inames -> $f: Steel.Heap.action_with_frame fp a fp' -> Steel.Memory.tot_action_with_frame_except e fp a fp'

Prims.Tot

[ "total" ]

[]

[ "Steel.Memory.slprop", "Steel.Memory.inames", "Steel.Heap.action_with_frame", "Steel.Memory.hmem_with_inv_except", "Steel.Memory.star", "Steel.Heap.full_hheap", "Steel.Heap.star", "Steel.Memory.locks_invariant", "Prims.Mkdtuple2", "Prims.unit", "Prims._assert", "Prims.l_Forall", "Steel.Memory.mprop", "Prims.eq2", "Prims.prop", "Steel.Memory.core_mem", "Steel.Memory.mprop_preservation_of_hprop_preservation", "Steel.Memory.mem_evolves", "Steel.Memory.equiv", "Steel.Memory.linv", "Steel.Memory.hmem_of_hheap", "Steel.Heap.interp", "FStar.Calc.calc_finish", "Prims.Cons", "FStar.Preorder.relation", "Prims.Nil", "FStar.Calc.calc_step", "FStar.Calc.calc_init", "FStar.Calc.calc_pack", "Steel.Memory.star_associative", "Prims.squash", "Prims.dtuple2", "Steel.Heap.hheap", "Steel.Heap.free_above_addr", "Steel.Memory.__proj__Mkmem__item__ctr", "Steel.Memory.hheap_of_hmem", "Steel.Memory.tot_action_with_frame_except" ]

[]

false

let lift_heap_action_with_frame (#fp: slprop u#a) (#a: Type u#b) (#fp': (a -> slprop u#a)) (e: inames) ($f: H.action_with_frame fp a fp') : tot_action_with_frame_except e fp a fp' =

fun frame m0 -> let h0 = hheap_of_hmem m0 in calc (equiv) { (fp `star` frame) `star` (locks_invariant e m0); (equiv) { star_associative fp frame (locks_invariant e m0) } fp `star` (frame `star` (locks_invariant e m0)); }; assert (H.interp ((fp `star` frame) `star` (locks_invariant e m0)) h0); assert (H.interp (fp `star` (frame `star` (locks_invariant e m0))) h0); let (| x , h1 |) = f (frame `star` (locks_invariant e m0)) h0 in calc (equiv) { (fp' x) `star` (frame `star` (locks_invariant e m0)); (equiv) { star_associative (fp' x) frame (locks_invariant e m0) } ((fp' x) `star` frame) `star` (locks_invariant e m0); }; assert (H.interp ((fp' x) `star` (frame `star` (locks_invariant e m0))) h1); assert (H.interp (((fp' x) `star` frame) `star` (locks_invariant e m0)) h1); let m1 = hmem_of_hheap m0 h1 in assert (mem_evolves m0 m1); mprop_preservation_of_hprop_preservation (frame `star` (locks_invariant e m0)) m0 m1; assert (forall (mp: mprop frame). mp (core_mem m0) == mp (core_mem m1)); (| x, m1 |)

false

Steel.Memory.fst

Steel.Memory.select_refine

val select_refine (#a:Type u#1) (#p:pcm a) (e:inames) (r:ref a p) (x:erased a) (f:(v:a{compatible p x v} -> GTot (y:a{compatible p y v /\ FStar.PCM.frame_compatible p x v y}))) : action_except (v:a{compatible p x v /\ p.refine v}) e (pts_to r x) (fun v -> pts_to r (f v))

let select_refine #a #p e r x f = lift_tot_action (lift_heap_action e (H.select_refine #a #p r x f))

{ "file_name": "lib/steel/Steel.Memory.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 70, "end_line": 986, "start_col": 0, "start_line": 985 }

(* 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.Memory module F = FStar.FunctionalExtensionality open FStar.FunctionalExtensionality open FStar.PCM module H = Steel.Heap noeq type lock_state : Type u#(a + 1) = | Invariant : inv:H.slprop u#a -> lock_state let lock_store : Type u#(a+1) = list (lock_state u#a) noeq type mem : Type u#(a + 1) = { ctr: nat; heap: H.heap u#a; locks: lock_store u#a; } let heap_of_mem (x:mem) : H.heap = x.heap let mem_of_heap (h:H.heap) : mem = { ctr = 0; heap = h; locks = [] } let mem_set_heap (m:mem) (h:H.heap) : mem = { ctr = m.ctr; heap = h; locks = m.locks; } let core_mem (m:mem) : mem = mem_of_heap (heap_of_mem m) let core_mem_invol m = () let disjoint (m0 m1:mem u#h) : prop = m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks let disjoint_sym m0 m1 = () let join m0 m1 = { ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = m0.locks } let join_commutative m0 m1 = H.join_commutative m0.heap m1.heap let disjoint_join m0 m1 m2 = H.disjoint_join m0.heap m1.heap m2.heap let join_associative m0 m1 m2 = H.join_associative m0.heap m1.heap m2.heap let slprop = H.slprop let interp p m = H.interp p m.heap let equiv p1 p2 = forall m. interp p1 m <==> interp p2 m let slprop_extensionality p q = assert (forall m. interp p m <==> interp q m); let aux (h:H.heap) : Lemma (H.interp p h <==> H.interp q h) [SMTPat (H.interp p h)] = let m : mem = { ctr = 0; heap = h; locks = [] } in assert (interp p m <==> interp q m) in assert (forall h. H.interp p h <==> H.interp q h); Steel.Heap.slprop_extensionality p q let reveal_equiv p1 p2 = () let core_ref = H.core_ref let core_ref_null = H.core_ref_null let core_ref_is_null r = H.core_ref_is_null r let emp : slprop u#a = H.emp let pure = H.pure let pts_to = H.pts_to let h_and = H.h_and let h_or = H.h_or let star = H.star let wand = H.wand let h_exists = H.h_exists let h_forall = H.h_forall //////////////////////////////////////////////////////////////////////////////// //properties of equiv //////////////////////////////////////////////////////////////////////////////// let equiv_symmetric (p1 p2:slprop u#a) = H.equiv_symmetric p1 p2 #push-options "--warn_error -271" let equiv_heap_iff_equiv (p1 p2:slprop u#a) : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat (equiv p1 p2)] = let aux_lr () : Lemma (requires H.equiv p1 p2) (ensures equiv p1 p2) [SMTPat ()] = () in let aux_rl_helper1 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p1 h) (ensures H.interp p2 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl_helper2 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p2 h) (ensures H.interp p1 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl () : Lemma (requires equiv p1 p2) (ensures H.equiv p1 p2) [SMTPat ()] = () in () let equiv_heap_iff_equiv_forall () : Lemma (ensures (forall p1 p2. H.equiv p1 p2 <==> equiv p1 p2)) = let aux p1 p2 : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat ()] = equiv_heap_iff_equiv p1 p2 in () #pop-options let equiv_extensional_on_star (p1 p2 p3:slprop u#a) = equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3 let emp_unit p = H.emp_unit p let intro_emp m = H.intro_emp (heap_of_mem m) let pure_equiv p q = H.pure_equiv p q let pure_interp q m = H.pure_interp q (heap_of_mem m) let pure_star_interp p q m = H.pure_star_interp p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// //pts_to //////////////////////////////////////////////////////////////////////////////// let pts_to_compatible #a #pcm x v0 v1 m = H.pts_to_compatible #a #pcm x v0 v1 (heap_of_mem m) let pts_to_compatible_equiv #a #pcm x v0 v1 = H.pts_to_compatible_equiv #a #pcm x v0 v1 let pts_to_not_null #a #pcm x v m = H.pts_to_not_null #a #pcm x v (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // star //////////////////////////////////////////////////////////////////////////////// let intro_star p q mp mq = H.intro_star p q (heap_of_mem mp) (heap_of_mem mq) let elim_star p q m = let h = heap_of_mem m in H.elim_star p q h; assert (exists hl hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr); let hl = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hl -> exists hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let hr = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hr -> H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let ml = mem_set_heap m hl in let mr = mem_set_heap m hr in assert (disjoint ml mr); assert (m == join ml mr); assert (interp p ml); assert (interp q mr); () let interp_star (p q: slprop) (m: mem) : Lemma (interp (p `star` q) m <==> (exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m)) = let left = interp (p `star` q) m in let right = exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m in let f () : Lemma (requires left) (ensures right) = elim_star p q m in let g () : Lemma (requires right) (ensures left) = Classical.exists_elim left #_ #(fun mp -> exists (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mp -> Classical.exists_elim left #_ #(fun mq -> disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mq -> intro_star p q mp mq ) ) in Classical.move_requires f (); Classical.move_requires g () let star_commutative (p1 p2:slprop) = H.star_commutative p1 p2 let star_associative (p1 p2 p3:slprop) = H.star_associative p1 p2 p3 let star_congruence (p1 p2 p3 p4:slprop) = equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4 let affine_star (p q:slprop) (m:mem) = H.affine_star p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // Invariants on the lock store //////////////////////////////////////////////////////////////////////////////// let iname = nat module S = FStar.Set module L = FStar.List.Tot module W = FStar.Witnessed.Core let rec lock_store_invariant (e:inames) (l:lock_store u#a) : slprop u#a = let current_addr = L.length l - 1 in match l with | [] -> emp | Invariant p :: tl -> if current_addr `S.mem` e then lock_store_invariant e tl else p `star` lock_store_invariant e tl let lock_i (i:iname) (l:lock_store { i < L.length l }) = let ix = L.length l - i - 1 in L.index l ix let iname_for_p (i:iname) (p:slprop) : W.s_predicate lock_store = fun l -> i < L.length l /\ (lock_i i l).inv == p let lock_store_evolves : FStar.Preorder.preorder lock_store = fun (l1 l2 : lock_store) -> L.length l2 >= L.length l1 /\ (forall (i:nat{i < L.length l1}). (lock_i i l1).inv == (lock_i i l2).inv) let inames_in (e:inames) (l:lock_store) : prop = forall i. Set.mem i e ==> i < L.length l let inames_ok e m = inames_in e m.locks let inames_ok_empty m = () let extend_lock_store (e:inames) (l:lock_store{e `inames_in` l}) (p:slprop) : i:iname & l':lock_store { lock_store_invariant e l' == p `star` lock_store_invariant e l /\ iname_for_p i p l' } = (| L.length l, Invariant p :: l |) let set_add (i:iname) (s:inames) = Set.union (Set.singleton i) s let rec move_invariant (e:inames) (l:lock_store) (p:slprop) (i:iname{iname_for_p i p l /\ ~(i `Set.mem` e)}) : Lemma (H.equiv (lock_store_invariant e l) (p `star` lock_store_invariant (set_add i e) l)) = let rec aux (i:iname) (m:lock_store) : Lemma (requires i >= L.length m) (ensures (lock_store_invariant e m `H.equiv` lock_store_invariant (set_add i e) m)) = match m with | [] -> () | Invariant p::tl -> aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl) in let current_addr = L.length l - 1 in match l with | [] -> () | Invariant q::tl -> if i = current_addr then begin assert (lock_store_invariant e l == p `star` lock_store_invariant e tl); aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl); () end else begin move_invariant e tl p i; assert (lock_store_invariant e tl `equiv` (p `star` lock_store_invariant (set_add i e) tl)); H.star_congruence q (lock_store_invariant e tl) q (p `star` lock_store_invariant (set_add i e) tl); if Set.mem current_addr e then () else begin let r = lock_store_invariant (set_add i e) tl in assert (lock_store_invariant e l `equiv` (q `star` (p `star` r))); H.star_associative q p r; H.star_commutative q p; H.star_congruence (q `star` p) r (p `star` q) r; H.star_associative p q r end end let heap_ctr_valid (ctr:nat) (h:H.heap u#a) : prop = h `H.free_above_addr` ctr let ctr_validity (ctr:nat) (h:H.heap) : slprop = H.pure (heap_ctr_valid ctr h) let locks_invariant (e:inames) (m:mem u#a) : slprop u#a = lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m) let full_mem_pred (m:mem) = H.full_heap_pred (heap_of_mem m) (***** Following lemmas are needed in Steel.Effect *****) let core_mem_interp (hp:slprop u#a) (m:mem u#a) = () let interp_depends_only_on (hp:slprop u#a) = H.interp_depends_only_on hp let a_mem_prop_as_a_heap_prop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (H.a_heap_prop u#a) = let g (h: H.heap u#a) : Tot prop = interp sl (mem_of_heap h) /\ f (mem_of_heap h) in let phi0 (h0 h1: H.heap u#a) : Lemma (requires (g h0 /\ H.disjoint h0 h1)) (ensures (g h0 /\ H.disjoint h0 h1 /\ g (H.join h0 h1))) = assert (mem_of_heap (H.join h0 h1) == mem_of_heap h0 `join` mem_of_heap h1); interp_depends_only_on sl in let phi1 (h0 h1: H.heap u#a) : Lemma (ensures ((g h0 /\ H.disjoint h0 h1) ==> g (H.join h0 h1))) = Classical.move_requires (phi0 h0) h1 in Classical.forall_intro_2 phi1; g let refine_slprop sl f = H.as_slprop (a_mem_prop_as_a_heap_prop sl f) let interp_refine_slprop sl f m = assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_mem m)) let dep_hprop (s: slprop) (f: (hmem s -> Tot slprop)) (h: H.heap) : Tot prop = exists (h1: H.heap) . exists (h2: H.heap) . interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 let dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq' : squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h')) = let p2 (h h1 h2: H.heap) : Tot prop = interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 in let p1 (h h1: H.heap) : Tot prop = (exists h2 . p2 h h1 h2) in let h1 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p1 h) in let h2 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p2 h h1) in H.disjoint_join h' h1 h2; assert (H.disjoint h2 h'); let h2' = H.join h2 h' in H.join_commutative h2 h' ; assert (h2' == H.join h' h2); assert (H.disjoint h1 h2'); assert (mem_of_heap h2' == mem_of_heap h2 `join` mem_of_heap h'); interp_depends_only_on (f (mem_of_heap h1)); assert (interp (f (mem_of_heap h1)) (mem_of_heap h2')); H.join_commutative h1 h2; H.join_associative h' h2 h1; H.join_commutative h' h; H.join_commutative h2' h1; assert (H.join h h' == h1 `H.join` h2') let impl_intro_gen (#p: Type0) (#q: Type0) ($prf: (squash p -> Lemma (q ))) : Lemma (p ==> q) = Classical.impl_intro_gen #p #(fun _ -> q) prf let dep_hprop_is_affine1 (s: slprop) (f: (hmem s -> Tot slprop)) (h0 h1: H.heap) : Lemma ((dep_hprop s f h0 /\ H.disjoint h0 h1) ==> (H.disjoint h0 h1 /\ dep_hprop s f (H.join h0 h1))) = impl_intro_gen (dep_hprop_is_affine0 s f h0 h1) let dep_hprop_is_affine (s: slprop) (f: (hmem s -> Tot slprop)) : Lemma (H.heap_prop_is_affine (dep_hprop s f)) = Classical.forall_intro_2 (dep_hprop_is_affine1 s f) let sdep (s: slprop) (f: (hmem s -> Tot slprop)) : Tot slprop = dep_hprop_is_affine s f; H.as_slprop (dep_hprop s f) let interp_sdep (s: slprop) (f: (hmem s -> Tot slprop)) (m: mem) : Lemma (requires (dep_slprop_is_affine s f)) (ensures ( interp (sdep s f) m <==> (exists m1 m2 . interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) )) = dep_hprop_is_affine s f; assert (forall m1 m2 . (interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) ==> ( interp s (mem_of_heap m1.heap) /\ interp (f (mem_of_heap m1.heap)) (mem_of_heap m2.heap) /\ H.disjoint m1.heap m2.heap /\ H.join m1.heap m2.heap == m.heap )); interp_depends_only_on s; Classical.forall_intro (fun m -> interp_depends_only_on (f m)); assert (forall h1 h2 . (interp s (mem_of_heap h1) /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ H.disjoint h1 h2 /\ H.join h1 h2 == m.heap) ==> ( core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ interp s (core_mem (mem_of_heap h1)) /\ interp s (mem_set_heap m h1) /\ core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ f (mem_set_heap m h1) `equiv` f (mem_of_heap h1) /\ interp (f (mem_set_heap m h1)) (mem_of_heap h2) /\ interp (f (mem_set_heap m h1)) (mem_set_heap m h2) /\ disjoint (mem_set_heap m h1) (mem_set_heap m h2) /\ join (mem_set_heap m h1) (mem_set_heap m h2) == m )); () let h_exists_cong (#a:Type) (p q : a -> slprop) : Lemma (requires (forall x. p x `equiv` q x)) (ensures (h_exists p `equiv` h_exists q)) = equiv_heap_iff_equiv_forall (); H.h_exists_cong p q let intro_h_exists #a x p m = H.intro_h_exists x p (heap_of_mem m) let elim_h_exists (#a:_) (p:a -> slprop) (m:mem) = H.elim_h_exists p (heap_of_mem m) let intro_h_forall (#a:_) (p:a -> slprop) (m:mem) = H.intro_h_forall p (heap_of_mem m) let elim_h_forall (#a:_) (p:a -> slprop) (m:mem) (x:a) = H.elim_h_forall p (heap_of_mem m) x let intro_h_and (p q: slprop) (m:mem) = H.intro_h_and p q (heap_of_mem m) let elim_h_and (p q: slprop) (m:mem) = H.elim_h_and p q (heap_of_mem m) let intro_h_or_left (p q: slprop) (m:mem) = H.intro_h_or_left p q (heap_of_mem m) let intro_h_or_right (p q: slprop) (m:mem) = H.intro_h_or_right p q (heap_of_mem m) let elim_h_or (p q: slprop) (m:mem) = H.elim_h_or p q (heap_of_mem m) let intro_wand (p1 p2: slprop u#a) (m:mem) = introduce (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)) ==> interp (wand p1 p2) m with _. ( assert (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)); H.intro_wand p1 p2 (heap_of_mem m); let h = heap_of_mem m in assert ((forall h1. h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) ==> H.interp (wand p1 p2) h); introduce forall h1. (h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) with ( introduce (h `H.disjoint` h1 /\ H.interp p1 h1) ==> H.interp p2 (H.join h h1) with _. ( assert (h `H.disjoint` h1); let m1 = { ctr = m.ctr; heap = h1; locks = m.locks } in assert (m `disjoint` m1) ) ) ) (** Eliminating a wand by proving a heap that satisfies the LHS **) let elim_wand (p1 p2: slprop u#a) (m:mem) (m1:mem) = H.elim_wand p1 p2 (heap_of_mem m) (heap_of_mem m1) //////////////////////////////////////////////////////////////////////////////// // Preorders and effects //////////////////////////////////////////////////////////////////////////////// module PP = Steel.Preorder let mem_evolves = fun (m0 m1:full_mem) -> H.heap_evolves (heap_of_mem m0) (heap_of_mem m1) /\ m0.ctr <= m1.ctr /\ lock_store_evolves m0.locks m1.locks (** See [Steel.Heap.is_frame_preserving]. We add in [lock_invariants] now *) let preserves_frame (e:inames) (pre post:slprop) (m0 m1:mem) = forall (frame:slprop). interp ((pre `star` frame) `star` locks_invariant e m0) m0 ==> (interp ((post `star` frame) `star` locks_invariant e m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) (** This is a version of MstTot with frame quantified, as part of preserves_frame *) effect MstTotNF (a:Type u#a) (except:inames) (expects:slprop u#1) (provides: a -> slprop u#1) = NMSTTotal.NMSTATETOT a (full_mem u#1) mem_evolves (requires fun m0 -> inames_ok except m0 /\ interp (expects `star` locks_invariant except m0) m0) (ensures fun m0 x m1 -> inames_ok except m1 /\ interp (provides x `star` locks_invariant except m1) m1 /\ preserves_frame except expects (provides x) m0 m1) //////////////////////////////////////////////////////////////////////////////// // Lifting heap actions //////////////////////////////////////////////////////////////////////////////// (** Heap actions come in two equivalent flavors: - one that take an explicit frame as argument (action_with_frame) - and one that quantify over all the frame We therefore define two lift routes: - a direct route for those with explicit frame - via MstTotNF for the rest *) let tot_pre_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = hmem_with_inv_except e fp -> (x:a & hmem_with_inv_except e (fp' x)) let tot_pre_action_nf = tot_pre_action_nf_except S.empty let ac_reasoning_for_m_frame_preserving (p q r:slprop u#a) (m:mem u#a) : Lemma (requires interp ((p `star` q) `star` r) m) (ensures interp (p `star` r) m) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_commutative p q; equiv_extensional_on_star (p `star` q) (q `star` p) r } (q `star` p) `star` r; (equiv) { star_associative q p r } q `star` (p `star` r); }; assert (interp (q `star` (p `star` r)) m); affine_star q (p `star` r) m let is_frame_preserving (#e:inames) (#a:Type u#b) (#fp:slprop u#a) (#fp':a -> slprop u#a) (f:tot_pre_action_nf_except e fp a fp') = forall (frame:slprop u#a) (m0:hmem_with_inv_except e (fp `star` frame)). (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = f:tot_pre_action_nf_except e fp a fp'{ is_frame_preserving f } let tot_action_nf = tot_action_nf_except S.empty let linv e (m:mem) = locks_invariant e m let hheap_of_hmem #fp #e (m:hmem_with_inv_except e fp) : h:H.hheap (fp `star` linv e m) { h `H.free_above_addr` m.ctr} = let h = heap_of_mem m in H.pure_interp (heap_ctr_valid m.ctr (heap_of_mem m)) h; h let hmem_of_hheap #e (#fp0 #fp1:slprop) (m:hmem_with_inv_except e fp0) (h:H.full_hheap (fp1 `star` linv e m) { h `Heap.free_above_addr` m.ctr }) : m1:hmem_with_inv_except e fp1{linv e m `equiv` linv e m1} = let m1 : mem = { m with heap = h } in assert (interp (fp1 `star` linv e m) m1); star_commutative fp1 (linv e m); assert (interp (linv e m `star` fp1) m1); assert (linv e m1 == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); assert (linv e m == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m)); H.pure_interp (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_of_mem m); assert (heap_ctr_valid m1.ctr (heap_of_mem m) <==> heap_ctr_valid m1.ctr (heap_of_mem m1)); H.pure_equiv (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_ctr_valid m1.ctr (heap_of_mem m1)); H.star_congruence (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m)); assert (linv e m `equiv` linv e m1); let _ = equiv_extensional_on_star (linv e m) (linv e m1) fp1 in assert ((linv e m `star` fp1) `equiv` (linv e m1 `star` fp1)); assert (interp (linv e m1 `star` fp1) m1); star_commutative (linv e m1) fp1; assert (interp (fp1 `star` linv e m1) m1); m1 let with_inv_except (m:mem) e (fp:slprop) = interp (fp `star` locks_invariant e m) m #push-options "--warn_error -271" let as_hprop (frame:slprop) (mp:mprop frame) : hp:H.hprop frame{forall m. mp (core_mem m) == hp (heap_of_mem m)} = let f = fun h -> mp (mem_of_heap h) in assert (forall m. mp (core_mem m) == f (heap_of_mem m)); let aux (m0:H.hheap frame) (m1:H.heap{H.disjoint m0 m1}) : Lemma (ensures (mem_of_heap (H.join m0 m1) == join (mem_of_heap m0) (mem_of_heap m1))) [SMTPat ()] = () in f let mprop_preservation_of_hprop_preservation (p:slprop) (m0 m1:mem) : Lemma (requires (forall (hp:H.hprop p). hp (heap_of_mem m0) == hp (heap_of_mem m1))) (ensures (forall (mp:mprop p). mp (core_mem m0) == mp (core_mem m1))) = let aux (mp:mprop p) : Lemma (mp (core_mem m0) == mp (core_mem m1)) [SMTPat()] = assert (as_hprop p mp (heap_of_mem m0) == as_hprop p mp (heap_of_mem m1)) in () let lift_heap_action (#fp:slprop) (#a:Type) (#fp':a -> slprop) (e:inames) ($f:H.action fp a fp') : tot_action_nf_except e fp a fp' = let g : tot_pre_action_nf_except e fp a fp' = fun m -> let h0 = hheap_of_hmem m in let (| x, h' |) = f h0 in (| x, hmem_of_hheap m h' |) in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in let h0 = hheap_of_hmem m0 in let (| x', h1 |) = f h0 in H.action_framing f (linv e m0) h0; assert (x == x'); star_associative fp frame (linv e m0); H.action_framing f (frame `star` linv e m0) h0; assert (H.interp ((fp' x) `star` (frame `star` linv e m0)) h1); star_associative (fp' x) frame (linv e m0); assert (H.interp ((fp' x `star` frame) `star` linv e m0) h1); let h1' : H.hheap ((fp' x `star` frame) `star` linv e m0) = h1 in assert (m1 == hmem_of_hheap m0 h1'); assert (with_inv_except m1 e (fp' x `star` frame)); assert (forall (hp:H.hprop frame). hp h0 == hp h1); mprop_preservation_of_hprop_preservation frame m0 m1; () in assert (is_frame_preserving g); g let frame_preserving_respects_preorder #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (m0:hmem_with_inv_except e fp) : Lemma (let (| x, m1 |) = f m0 in mem_evolves m0 m1) = let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1) = () in H.emp_unit fp; assert (interp (fp `star` linv e m0) m0); H.star_congruence (fp `star` emp) (linv e m0) fp (linv e m0); assert (interp ((fp `star` emp) `star` linv e m0) m0); aux emp m0 let lift_tot_action_nf #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') : MstTotNF a e fp fp' = let m0 = NMSTTotal.get () in let m0' : hmem_with_inv_except e fp = m0 in let r = f m0' in let (| x, m1 |) = r in let m1' : hmem_with_inv_except e (fp' x) = m1 in assert (is_frame_preserving f); assert (m1 == dsnd (f m0)); frame_preserving_respects_preorder f m0; NMSTTotal.put #_ #(mem_evolves) m1; x let lift_tot_action #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get #(full_mem) #_ () in ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); lift_tot_action_nf f (** Now defining the lift for heap actions with explicit frame *) let tot_action_with_frame_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = frame:slprop u#a -> m0:hmem_with_inv_except e (fp `star` frame) -> Pure (x:a & hmem_with_inv_except e (fp' x `star` frame)) (requires True) (ensures fun (| x, m1 |) -> mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_with_frame = tot_action_with_frame_except S.empty let lift_heap_action_with_frame (#fp:slprop u#a) (#a:Type u#b) (#fp':a -> slprop u#a) (e:inames) ($f:H.action_with_frame fp a fp') : tot_action_with_frame_except e fp a fp' = fun frame m0 -> let h0 = hheap_of_hmem m0 in calc (equiv) { fp `star` frame `star` locks_invariant e m0; (equiv) { star_associative fp frame (locks_invariant e m0) } fp `star` (frame `star` locks_invariant e m0); }; assert (H.interp (fp `star` frame `star` locks_invariant e m0) h0); assert (H.interp (fp `star` (frame `star` locks_invariant e m0)) h0); //key: apply the heap action with frame * locks_invariant e m0 let (| x, h1 |) = f (frame `star` locks_invariant e m0) h0 in calc (equiv) { fp' x `star` (frame `star` locks_invariant e m0); (equiv) { star_associative (fp' x) frame (locks_invariant e m0) } fp' x `star` frame `star` locks_invariant e m0; }; assert (H.interp (fp' x `star` (frame `star` locks_invariant e m0)) h1); assert (H.interp (fp' x `star` frame `star` locks_invariant e m0) h1); let m1 = hmem_of_hheap m0 h1 in assert (mem_evolves m0 m1); mprop_preservation_of_hprop_preservation (frame `star` locks_invariant e m0) m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)); (| x, m1 |) let lift_tot_action_with_frame #a #e #fp #fp' ($f:tot_action_with_frame_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in assert (inames_ok e m0); ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); let m0' : hmem_with_inv_except e fp = m0 in let r = f frame m0' in let (| x, m1 |) = r in ac_reasoning_for_m_frame_preserving (fp' x) frame (locks_invariant e m1) m1; assert (interp (fp' x `star` frame `star` locks_invariant e m1) m1); assert (interp (fp' x `star` locks_invariant e m1) m1); let m1' : hmem_with_inv_except e (fp' x) = m1 in NMSTTotal.put #_ #(mem_evolves) m1; x let sel_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.sel_action #a #pcm r v0)) let upd_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.upd_action #a #pcm r v0 v1)) let free_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.free_action #a #pcm r v0)) let split_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.split_action #a #pcm r v0 v1)) let gather_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.gather_action #a #pcm r v0 v1)) let weaken (p q r:slprop) (h:H.hheap (p `star` q) { H.stronger q r }) : H.hheap (p `star` r) = H.weaken p q r h; h let weaken_pure (q r: prop) : Lemma (requires (q ==> r)) (ensures H.stronger (H.pure q) (H.pure r)) = let aux (h:H.heap) : Lemma (ensures (H.interp (H.pure q) h ==> H.interp (H.pure r) h)) [SMTPat ()] = H.pure_interp q h; H.pure_interp r h in () let inc_ctr (#p:slprop) #e (m:hmem_with_inv_except e p) : m':hmem_with_inv_except e p{m'.ctr = m.ctr + 1 /\ H.stronger (linv e m) (linv e m')} = let m' : mem = { m with ctr = m.ctr + 1} in assert (interp (p `star` linv e m) m'); assert (linv e m == lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m)); assert (linv e m' == lock_store_invariant e m.locks `star` ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken_free_above (heap_of_mem m) m.ctr (m.ctr + 1); weaken_pure (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_ctr_valid (m.ctr + 1) (heap_of_mem m)); assert (H.stronger (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m))); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)); H.stronger_star (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken (p `star` lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)) (heap_of_mem m'); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity (m.ctr + 1) (heap_of_mem m)); let m' : hmem_with_inv_except e p = m' in m' let frame_related_mems (fp0 fp1:slprop u#a) e (m0:hmem_with_inv_except e fp0) (m1:hmem_with_inv_except e fp1) = forall (frame:slprop u#a). interp ((fp0 `star` frame) `star` linv e m0) m0 ==> interp ((fp1 `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) let refined_pre_action e (fp0:slprop) (a:Type) (fp1:a -> slprop) = m0:hmem_with_inv_except e fp0 -> Pure (x:a & hmem_with_inv_except e (fp1 x)) (requires True) (ensures fun (| x, m1 |) -> frame_related_mems fp0 (fp1 x) e m0 m1) let refined_pre_action_as_action (#fp0:slprop) (#a:Type) (#fp1:a -> slprop) #e ($f:refined_pre_action e fp0 a fp1) : tot_action_nf_except e fp0 a fp1 = let g : tot_pre_action_nf_except e fp0 a fp1 = fun m -> f m in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp0 `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp1 x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x', m1' |) = g m0 in let (| x, m1 |) = f m0 in assert (x == x' /\ m1 == m1') in g let alloc_action #a #pcm e x = let f : refined_pre_action e emp (ref a pcm) (fun r -> pts_to r x) = fun m0 -> (* NS: 9/29/22 I needed to annotate h : Heap.full_heap, for use with the Core checker which generates a guard for checking the implicit pattern "dot" term in the dependent pair pattern on the next line. That guard expects `h` to be a full_heap, which is it, because it is a projection of m0. However, this is not reflected in `h`'s type. So, the Core checker, which produces a guard for the pat_dot_term in isolation, cannot recheck the term. If we were to fold in the checking of pat_dot_terms and their guards with the rest of the VC, this would work. *) let h : Heap.full_heap = hheap_of_hmem m0 in let (|r, h'|) = H.extend #a #pcm x m0.ctr h in let m' : hmem_with_inv_except e emp = inc_ctr m0 in let h' : H.hheap (pts_to #a #pcm r x `star` linv e m') = weaken _ (linv e m0) (linv e m') h' in let m1 : hmem_with_inv_except e (pts_to #a #pcm r x) = hmem_of_hheap m' h' in assert (forall frame. H.frame_related_heaps h h' emp (pts_to #a #pcm r x) frame true); let aux (frame:slprop) : Lemma (requires interp ((emp `star` frame) `star` linv e m0) m0) (ensures interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) [SMTPat (emp `star` frame)] = star_associative emp frame (linv e m0); assert (H.interp (emp `star` (frame `star` linv e m0)) h); assert (H.interp (pts_to #a #pcm r x `star` (frame `star` linv e m0)) h'); star_associative (pts_to #a #pcm r x) frame (linv e m0); assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m0) h'); assert (H.stronger (linv e m0) (linv e m')); assert (H.equiv (linv e m') (linv e m1)); assert (H.stronger (linv e m0) (linv e m1)); let h' : H.hheap ((pts_to #a #pcm r x `star` frame) `star` linv e m1) = weaken _ (linv e m0) (linv e m1) h' in assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) h'); assert (forall (mp:H.hprop frame). mp h == mp h'); mprop_preservation_of_hprop_preservation frame m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) in assert (frame_related_mems emp (pts_to r x) e m0 m1); (| r, m1 |) in lift_tot_action (refined_pre_action_as_action f)

{ "checked_file": "/", "dependencies": [ "Steel.Preorder.fst.checked", "Steel.Heap.fsti.checked", "prims.fst.checked", "FStar.Witnessed.Core.fsti.checked", "FStar.Set.fsti.checked", "FStar.Preorder.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.PCM.fst.checked", "FStar.NMSTTotal.fst.checked", "FStar.List.Tot.fst.checked", "FStar.IndefiniteDescription.fsti.checked", "FStar.Ghost.fsti.checked", "FStar.FunctionalExtensionality.fsti.checked", "FStar.Classical.Sugar.fsti.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Steel.Memory.fst" }

[ { "abbrev": true, "full_module": "Steel.Preorder", "short_module": "PP" }, { "abbrev": true, "full_module": "FStar.Witnessed.Core", "short_module": "W" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": true, "full_module": "Steel.Heap", "short_module": "H" }, { "abbrev": false, "full_module": "FStar.FunctionalExtensionality", "short_module": null }, { "abbrev": true, "full_module": "FStar.FunctionalExtensionality", "short_module": "F" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": false, "full_module": "FStar.PCM", "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

e: Steel.Memory.inames -> r: Steel.Memory.ref a p -> x: FStar.Ghost.erased a -> f: (v: a{FStar.PCM.compatible p (FStar.Ghost.reveal x) v} -> Prims.GTot (y: a{FStar.PCM.compatible p y v /\ FStar.PCM.frame_compatible p x v y})) -> Steel.Memory.action_except (v: a{FStar.PCM.compatible p (FStar.Ghost.reveal x) v /\ Mkpcm?.refine p v}) e (Steel.Memory.pts_to r (FStar.Ghost.reveal x)) (fun v -> Steel.Memory.pts_to r (f v))

Prims.Tot

[ "total" ]

[]

[ "FStar.PCM.pcm", "Steel.Memory.inames", "Steel.Memory.ref", "FStar.Ghost.erased", "FStar.PCM.compatible", "FStar.Ghost.reveal", "Prims.l_and", "FStar.PCM.frame_compatible", "Steel.Memory.lift_tot_action", "FStar.PCM.__proj__Mkpcm__item__refine", "Steel.Heap.pts_to", "Steel.Memory.slprop", "Steel.Memory.lift_heap_action", "Steel.Heap.select_refine", "Steel.Memory.action_except", "Steel.Memory.pts_to" ]

[]

false

let select_refine #a #p e r x f =

lift_tot_action (lift_heap_action e (H.select_refine #a #p r x f))

false

Steel.Memory.fst

Steel.Memory.sel_action

val sel_action (#a:Type u#1) (#pcm:_) (e:inames) (r:ref a pcm) (v0:erased a) : action_except (v:a{compatible pcm v0 v}) e (pts_to r v0) (fun _ -> pts_to r v0)

let sel_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.sel_action #a #pcm r v0))

{ "file_name": "lib/steel/Steel.Memory.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 68, "end_line": 844, "start_col": 0, "start_line": 843 }

(* 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.Memory module F = FStar.FunctionalExtensionality open FStar.FunctionalExtensionality open FStar.PCM module H = Steel.Heap noeq type lock_state : Type u#(a + 1) = | Invariant : inv:H.slprop u#a -> lock_state let lock_store : Type u#(a+1) = list (lock_state u#a) noeq type mem : Type u#(a + 1) = { ctr: nat; heap: H.heap u#a; locks: lock_store u#a; } let heap_of_mem (x:mem) : H.heap = x.heap let mem_of_heap (h:H.heap) : mem = { ctr = 0; heap = h; locks = [] } let mem_set_heap (m:mem) (h:H.heap) : mem = { ctr = m.ctr; heap = h; locks = m.locks; } let core_mem (m:mem) : mem = mem_of_heap (heap_of_mem m) let core_mem_invol m = () let disjoint (m0 m1:mem u#h) : prop = m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks let disjoint_sym m0 m1 = () let join m0 m1 = { ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = m0.locks } let join_commutative m0 m1 = H.join_commutative m0.heap m1.heap let disjoint_join m0 m1 m2 = H.disjoint_join m0.heap m1.heap m2.heap let join_associative m0 m1 m2 = H.join_associative m0.heap m1.heap m2.heap let slprop = H.slprop let interp p m = H.interp p m.heap let equiv p1 p2 = forall m. interp p1 m <==> interp p2 m let slprop_extensionality p q = assert (forall m. interp p m <==> interp q m); let aux (h:H.heap) : Lemma (H.interp p h <==> H.interp q h) [SMTPat (H.interp p h)] = let m : mem = { ctr = 0; heap = h; locks = [] } in assert (interp p m <==> interp q m) in assert (forall h. H.interp p h <==> H.interp q h); Steel.Heap.slprop_extensionality p q let reveal_equiv p1 p2 = () let core_ref = H.core_ref let core_ref_null = H.core_ref_null let core_ref_is_null r = H.core_ref_is_null r let emp : slprop u#a = H.emp let pure = H.pure let pts_to = H.pts_to let h_and = H.h_and let h_or = H.h_or let star = H.star let wand = H.wand let h_exists = H.h_exists let h_forall = H.h_forall //////////////////////////////////////////////////////////////////////////////// //properties of equiv //////////////////////////////////////////////////////////////////////////////// let equiv_symmetric (p1 p2:slprop u#a) = H.equiv_symmetric p1 p2 #push-options "--warn_error -271" let equiv_heap_iff_equiv (p1 p2:slprop u#a) : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat (equiv p1 p2)] = let aux_lr () : Lemma (requires H.equiv p1 p2) (ensures equiv p1 p2) [SMTPat ()] = () in let aux_rl_helper1 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p1 h) (ensures H.interp p2 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl_helper2 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p2 h) (ensures H.interp p1 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl () : Lemma (requires equiv p1 p2) (ensures H.equiv p1 p2) [SMTPat ()] = () in () let equiv_heap_iff_equiv_forall () : Lemma (ensures (forall p1 p2. H.equiv p1 p2 <==> equiv p1 p2)) = let aux p1 p2 : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat ()] = equiv_heap_iff_equiv p1 p2 in () #pop-options let equiv_extensional_on_star (p1 p2 p3:slprop u#a) = equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3 let emp_unit p = H.emp_unit p let intro_emp m = H.intro_emp (heap_of_mem m) let pure_equiv p q = H.pure_equiv p q let pure_interp q m = H.pure_interp q (heap_of_mem m) let pure_star_interp p q m = H.pure_star_interp p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// //pts_to //////////////////////////////////////////////////////////////////////////////// let pts_to_compatible #a #pcm x v0 v1 m = H.pts_to_compatible #a #pcm x v0 v1 (heap_of_mem m) let pts_to_compatible_equiv #a #pcm x v0 v1 = H.pts_to_compatible_equiv #a #pcm x v0 v1 let pts_to_not_null #a #pcm x v m = H.pts_to_not_null #a #pcm x v (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // star //////////////////////////////////////////////////////////////////////////////// let intro_star p q mp mq = H.intro_star p q (heap_of_mem mp) (heap_of_mem mq) let elim_star p q m = let h = heap_of_mem m in H.elim_star p q h; assert (exists hl hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr); let hl = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hl -> exists hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let hr = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hr -> H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let ml = mem_set_heap m hl in let mr = mem_set_heap m hr in assert (disjoint ml mr); assert (m == join ml mr); assert (interp p ml); assert (interp q mr); () let interp_star (p q: slprop) (m: mem) : Lemma (interp (p `star` q) m <==> (exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m)) = let left = interp (p `star` q) m in let right = exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m in let f () : Lemma (requires left) (ensures right) = elim_star p q m in let g () : Lemma (requires right) (ensures left) = Classical.exists_elim left #_ #(fun mp -> exists (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mp -> Classical.exists_elim left #_ #(fun mq -> disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mq -> intro_star p q mp mq ) ) in Classical.move_requires f (); Classical.move_requires g () let star_commutative (p1 p2:slprop) = H.star_commutative p1 p2 let star_associative (p1 p2 p3:slprop) = H.star_associative p1 p2 p3 let star_congruence (p1 p2 p3 p4:slprop) = equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4 let affine_star (p q:slprop) (m:mem) = H.affine_star p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // Invariants on the lock store //////////////////////////////////////////////////////////////////////////////// let iname = nat module S = FStar.Set module L = FStar.List.Tot module W = FStar.Witnessed.Core let rec lock_store_invariant (e:inames) (l:lock_store u#a) : slprop u#a = let current_addr = L.length l - 1 in match l with | [] -> emp | Invariant p :: tl -> if current_addr `S.mem` e then lock_store_invariant e tl else p `star` lock_store_invariant e tl let lock_i (i:iname) (l:lock_store { i < L.length l }) = let ix = L.length l - i - 1 in L.index l ix let iname_for_p (i:iname) (p:slprop) : W.s_predicate lock_store = fun l -> i < L.length l /\ (lock_i i l).inv == p let lock_store_evolves : FStar.Preorder.preorder lock_store = fun (l1 l2 : lock_store) -> L.length l2 >= L.length l1 /\ (forall (i:nat{i < L.length l1}). (lock_i i l1).inv == (lock_i i l2).inv) let inames_in (e:inames) (l:lock_store) : prop = forall i. Set.mem i e ==> i < L.length l let inames_ok e m = inames_in e m.locks let inames_ok_empty m = () let extend_lock_store (e:inames) (l:lock_store{e `inames_in` l}) (p:slprop) : i:iname & l':lock_store { lock_store_invariant e l' == p `star` lock_store_invariant e l /\ iname_for_p i p l' } = (| L.length l, Invariant p :: l |) let set_add (i:iname) (s:inames) = Set.union (Set.singleton i) s let rec move_invariant (e:inames) (l:lock_store) (p:slprop) (i:iname{iname_for_p i p l /\ ~(i `Set.mem` e)}) : Lemma (H.equiv (lock_store_invariant e l) (p `star` lock_store_invariant (set_add i e) l)) = let rec aux (i:iname) (m:lock_store) : Lemma (requires i >= L.length m) (ensures (lock_store_invariant e m `H.equiv` lock_store_invariant (set_add i e) m)) = match m with | [] -> () | Invariant p::tl -> aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl) in let current_addr = L.length l - 1 in match l with | [] -> () | Invariant q::tl -> if i = current_addr then begin assert (lock_store_invariant e l == p `star` lock_store_invariant e tl); aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl); () end else begin move_invariant e tl p i; assert (lock_store_invariant e tl `equiv` (p `star` lock_store_invariant (set_add i e) tl)); H.star_congruence q (lock_store_invariant e tl) q (p `star` lock_store_invariant (set_add i e) tl); if Set.mem current_addr e then () else begin let r = lock_store_invariant (set_add i e) tl in assert (lock_store_invariant e l `equiv` (q `star` (p `star` r))); H.star_associative q p r; H.star_commutative q p; H.star_congruence (q `star` p) r (p `star` q) r; H.star_associative p q r end end let heap_ctr_valid (ctr:nat) (h:H.heap u#a) : prop = h `H.free_above_addr` ctr let ctr_validity (ctr:nat) (h:H.heap) : slprop = H.pure (heap_ctr_valid ctr h) let locks_invariant (e:inames) (m:mem u#a) : slprop u#a = lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m) let full_mem_pred (m:mem) = H.full_heap_pred (heap_of_mem m) (***** Following lemmas are needed in Steel.Effect *****) let core_mem_interp (hp:slprop u#a) (m:mem u#a) = () let interp_depends_only_on (hp:slprop u#a) = H.interp_depends_only_on hp let a_mem_prop_as_a_heap_prop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (H.a_heap_prop u#a) = let g (h: H.heap u#a) : Tot prop = interp sl (mem_of_heap h) /\ f (mem_of_heap h) in let phi0 (h0 h1: H.heap u#a) : Lemma (requires (g h0 /\ H.disjoint h0 h1)) (ensures (g h0 /\ H.disjoint h0 h1 /\ g (H.join h0 h1))) = assert (mem_of_heap (H.join h0 h1) == mem_of_heap h0 `join` mem_of_heap h1); interp_depends_only_on sl in let phi1 (h0 h1: H.heap u#a) : Lemma (ensures ((g h0 /\ H.disjoint h0 h1) ==> g (H.join h0 h1))) = Classical.move_requires (phi0 h0) h1 in Classical.forall_intro_2 phi1; g let refine_slprop sl f = H.as_slprop (a_mem_prop_as_a_heap_prop sl f) let interp_refine_slprop sl f m = assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_mem m)) let dep_hprop (s: slprop) (f: (hmem s -> Tot slprop)) (h: H.heap) : Tot prop = exists (h1: H.heap) . exists (h2: H.heap) . interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 let dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq' : squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h')) = let p2 (h h1 h2: H.heap) : Tot prop = interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 in let p1 (h h1: H.heap) : Tot prop = (exists h2 . p2 h h1 h2) in let h1 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p1 h) in let h2 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p2 h h1) in H.disjoint_join h' h1 h2; assert (H.disjoint h2 h'); let h2' = H.join h2 h' in H.join_commutative h2 h' ; assert (h2' == H.join h' h2); assert (H.disjoint h1 h2'); assert (mem_of_heap h2' == mem_of_heap h2 `join` mem_of_heap h'); interp_depends_only_on (f (mem_of_heap h1)); assert (interp (f (mem_of_heap h1)) (mem_of_heap h2')); H.join_commutative h1 h2; H.join_associative h' h2 h1; H.join_commutative h' h; H.join_commutative h2' h1; assert (H.join h h' == h1 `H.join` h2') let impl_intro_gen (#p: Type0) (#q: Type0) ($prf: (squash p -> Lemma (q ))) : Lemma (p ==> q) = Classical.impl_intro_gen #p #(fun _ -> q) prf let dep_hprop_is_affine1 (s: slprop) (f: (hmem s -> Tot slprop)) (h0 h1: H.heap) : Lemma ((dep_hprop s f h0 /\ H.disjoint h0 h1) ==> (H.disjoint h0 h1 /\ dep_hprop s f (H.join h0 h1))) = impl_intro_gen (dep_hprop_is_affine0 s f h0 h1) let dep_hprop_is_affine (s: slprop) (f: (hmem s -> Tot slprop)) : Lemma (H.heap_prop_is_affine (dep_hprop s f)) = Classical.forall_intro_2 (dep_hprop_is_affine1 s f) let sdep (s: slprop) (f: (hmem s -> Tot slprop)) : Tot slprop = dep_hprop_is_affine s f; H.as_slprop (dep_hprop s f) let interp_sdep (s: slprop) (f: (hmem s -> Tot slprop)) (m: mem) : Lemma (requires (dep_slprop_is_affine s f)) (ensures ( interp (sdep s f) m <==> (exists m1 m2 . interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) )) = dep_hprop_is_affine s f; assert (forall m1 m2 . (interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) ==> ( interp s (mem_of_heap m1.heap) /\ interp (f (mem_of_heap m1.heap)) (mem_of_heap m2.heap) /\ H.disjoint m1.heap m2.heap /\ H.join m1.heap m2.heap == m.heap )); interp_depends_only_on s; Classical.forall_intro (fun m -> interp_depends_only_on (f m)); assert (forall h1 h2 . (interp s (mem_of_heap h1) /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ H.disjoint h1 h2 /\ H.join h1 h2 == m.heap) ==> ( core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ interp s (core_mem (mem_of_heap h1)) /\ interp s (mem_set_heap m h1) /\ core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ f (mem_set_heap m h1) `equiv` f (mem_of_heap h1) /\ interp (f (mem_set_heap m h1)) (mem_of_heap h2) /\ interp (f (mem_set_heap m h1)) (mem_set_heap m h2) /\ disjoint (mem_set_heap m h1) (mem_set_heap m h2) /\ join (mem_set_heap m h1) (mem_set_heap m h2) == m )); () let h_exists_cong (#a:Type) (p q : a -> slprop) : Lemma (requires (forall x. p x `equiv` q x)) (ensures (h_exists p `equiv` h_exists q)) = equiv_heap_iff_equiv_forall (); H.h_exists_cong p q let intro_h_exists #a x p m = H.intro_h_exists x p (heap_of_mem m) let elim_h_exists (#a:_) (p:a -> slprop) (m:mem) = H.elim_h_exists p (heap_of_mem m) let intro_h_forall (#a:_) (p:a -> slprop) (m:mem) = H.intro_h_forall p (heap_of_mem m) let elim_h_forall (#a:_) (p:a -> slprop) (m:mem) (x:a) = H.elim_h_forall p (heap_of_mem m) x let intro_h_and (p q: slprop) (m:mem) = H.intro_h_and p q (heap_of_mem m) let elim_h_and (p q: slprop) (m:mem) = H.elim_h_and p q (heap_of_mem m) let intro_h_or_left (p q: slprop) (m:mem) = H.intro_h_or_left p q (heap_of_mem m) let intro_h_or_right (p q: slprop) (m:mem) = H.intro_h_or_right p q (heap_of_mem m) let elim_h_or (p q: slprop) (m:mem) = H.elim_h_or p q (heap_of_mem m) let intro_wand (p1 p2: slprop u#a) (m:mem) = introduce (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)) ==> interp (wand p1 p2) m with _. ( assert (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)); H.intro_wand p1 p2 (heap_of_mem m); let h = heap_of_mem m in assert ((forall h1. h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) ==> H.interp (wand p1 p2) h); introduce forall h1. (h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) with ( introduce (h `H.disjoint` h1 /\ H.interp p1 h1) ==> H.interp p2 (H.join h h1) with _. ( assert (h `H.disjoint` h1); let m1 = { ctr = m.ctr; heap = h1; locks = m.locks } in assert (m `disjoint` m1) ) ) ) (** Eliminating a wand by proving a heap that satisfies the LHS **) let elim_wand (p1 p2: slprop u#a) (m:mem) (m1:mem) = H.elim_wand p1 p2 (heap_of_mem m) (heap_of_mem m1) //////////////////////////////////////////////////////////////////////////////// // Preorders and effects //////////////////////////////////////////////////////////////////////////////// module PP = Steel.Preorder let mem_evolves = fun (m0 m1:full_mem) -> H.heap_evolves (heap_of_mem m0) (heap_of_mem m1) /\ m0.ctr <= m1.ctr /\ lock_store_evolves m0.locks m1.locks (** See [Steel.Heap.is_frame_preserving]. We add in [lock_invariants] now *) let preserves_frame (e:inames) (pre post:slprop) (m0 m1:mem) = forall (frame:slprop). interp ((pre `star` frame) `star` locks_invariant e m0) m0 ==> (interp ((post `star` frame) `star` locks_invariant e m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) (** This is a version of MstTot with frame quantified, as part of preserves_frame *) effect MstTotNF (a:Type u#a) (except:inames) (expects:slprop u#1) (provides: a -> slprop u#1) = NMSTTotal.NMSTATETOT a (full_mem u#1) mem_evolves (requires fun m0 -> inames_ok except m0 /\ interp (expects `star` locks_invariant except m0) m0) (ensures fun m0 x m1 -> inames_ok except m1 /\ interp (provides x `star` locks_invariant except m1) m1 /\ preserves_frame except expects (provides x) m0 m1) //////////////////////////////////////////////////////////////////////////////// // Lifting heap actions //////////////////////////////////////////////////////////////////////////////// (** Heap actions come in two equivalent flavors: - one that take an explicit frame as argument (action_with_frame) - and one that quantify over all the frame We therefore define two lift routes: - a direct route for those with explicit frame - via MstTotNF for the rest *) let tot_pre_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = hmem_with_inv_except e fp -> (x:a & hmem_with_inv_except e (fp' x)) let tot_pre_action_nf = tot_pre_action_nf_except S.empty let ac_reasoning_for_m_frame_preserving (p q r:slprop u#a) (m:mem u#a) : Lemma (requires interp ((p `star` q) `star` r) m) (ensures interp (p `star` r) m) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_commutative p q; equiv_extensional_on_star (p `star` q) (q `star` p) r } (q `star` p) `star` r; (equiv) { star_associative q p r } q `star` (p `star` r); }; assert (interp (q `star` (p `star` r)) m); affine_star q (p `star` r) m let is_frame_preserving (#e:inames) (#a:Type u#b) (#fp:slprop u#a) (#fp':a -> slprop u#a) (f:tot_pre_action_nf_except e fp a fp') = forall (frame:slprop u#a) (m0:hmem_with_inv_except e (fp `star` frame)). (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = f:tot_pre_action_nf_except e fp a fp'{ is_frame_preserving f } let tot_action_nf = tot_action_nf_except S.empty let linv e (m:mem) = locks_invariant e m let hheap_of_hmem #fp #e (m:hmem_with_inv_except e fp) : h:H.hheap (fp `star` linv e m) { h `H.free_above_addr` m.ctr} = let h = heap_of_mem m in H.pure_interp (heap_ctr_valid m.ctr (heap_of_mem m)) h; h let hmem_of_hheap #e (#fp0 #fp1:slprop) (m:hmem_with_inv_except e fp0) (h:H.full_hheap (fp1 `star` linv e m) { h `Heap.free_above_addr` m.ctr }) : m1:hmem_with_inv_except e fp1{linv e m `equiv` linv e m1} = let m1 : mem = { m with heap = h } in assert (interp (fp1 `star` linv e m) m1); star_commutative fp1 (linv e m); assert (interp (linv e m `star` fp1) m1); assert (linv e m1 == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); assert (linv e m == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m)); H.pure_interp (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_of_mem m); assert (heap_ctr_valid m1.ctr (heap_of_mem m) <==> heap_ctr_valid m1.ctr (heap_of_mem m1)); H.pure_equiv (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_ctr_valid m1.ctr (heap_of_mem m1)); H.star_congruence (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m)); assert (linv e m `equiv` linv e m1); let _ = equiv_extensional_on_star (linv e m) (linv e m1) fp1 in assert ((linv e m `star` fp1) `equiv` (linv e m1 `star` fp1)); assert (interp (linv e m1 `star` fp1) m1); star_commutative (linv e m1) fp1; assert (interp (fp1 `star` linv e m1) m1); m1 let with_inv_except (m:mem) e (fp:slprop) = interp (fp `star` locks_invariant e m) m #push-options "--warn_error -271" let as_hprop (frame:slprop) (mp:mprop frame) : hp:H.hprop frame{forall m. mp (core_mem m) == hp (heap_of_mem m)} = let f = fun h -> mp (mem_of_heap h) in assert (forall m. mp (core_mem m) == f (heap_of_mem m)); let aux (m0:H.hheap frame) (m1:H.heap{H.disjoint m0 m1}) : Lemma (ensures (mem_of_heap (H.join m0 m1) == join (mem_of_heap m0) (mem_of_heap m1))) [SMTPat ()] = () in f let mprop_preservation_of_hprop_preservation (p:slprop) (m0 m1:mem) : Lemma (requires (forall (hp:H.hprop p). hp (heap_of_mem m0) == hp (heap_of_mem m1))) (ensures (forall (mp:mprop p). mp (core_mem m0) == mp (core_mem m1))) = let aux (mp:mprop p) : Lemma (mp (core_mem m0) == mp (core_mem m1)) [SMTPat()] = assert (as_hprop p mp (heap_of_mem m0) == as_hprop p mp (heap_of_mem m1)) in () let lift_heap_action (#fp:slprop) (#a:Type) (#fp':a -> slprop) (e:inames) ($f:H.action fp a fp') : tot_action_nf_except e fp a fp' = let g : tot_pre_action_nf_except e fp a fp' = fun m -> let h0 = hheap_of_hmem m in let (| x, h' |) = f h0 in (| x, hmem_of_hheap m h' |) in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in let h0 = hheap_of_hmem m0 in let (| x', h1 |) = f h0 in H.action_framing f (linv e m0) h0; assert (x == x'); star_associative fp frame (linv e m0); H.action_framing f (frame `star` linv e m0) h0; assert (H.interp ((fp' x) `star` (frame `star` linv e m0)) h1); star_associative (fp' x) frame (linv e m0); assert (H.interp ((fp' x `star` frame) `star` linv e m0) h1); let h1' : H.hheap ((fp' x `star` frame) `star` linv e m0) = h1 in assert (m1 == hmem_of_hheap m0 h1'); assert (with_inv_except m1 e (fp' x `star` frame)); assert (forall (hp:H.hprop frame). hp h0 == hp h1); mprop_preservation_of_hprop_preservation frame m0 m1; () in assert (is_frame_preserving g); g let frame_preserving_respects_preorder #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (m0:hmem_with_inv_except e fp) : Lemma (let (| x, m1 |) = f m0 in mem_evolves m0 m1) = let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1) = () in H.emp_unit fp; assert (interp (fp `star` linv e m0) m0); H.star_congruence (fp `star` emp) (linv e m0) fp (linv e m0); assert (interp ((fp `star` emp) `star` linv e m0) m0); aux emp m0 let lift_tot_action_nf #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') : MstTotNF a e fp fp' = let m0 = NMSTTotal.get () in let m0' : hmem_with_inv_except e fp = m0 in let r = f m0' in let (| x, m1 |) = r in let m1' : hmem_with_inv_except e (fp' x) = m1 in assert (is_frame_preserving f); assert (m1 == dsnd (f m0)); frame_preserving_respects_preorder f m0; NMSTTotal.put #_ #(mem_evolves) m1; x let lift_tot_action #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get #(full_mem) #_ () in ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); lift_tot_action_nf f (** Now defining the lift for heap actions with explicit frame *) let tot_action_with_frame_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = frame:slprop u#a -> m0:hmem_with_inv_except e (fp `star` frame) -> Pure (x:a & hmem_with_inv_except e (fp' x `star` frame)) (requires True) (ensures fun (| x, m1 |) -> mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_with_frame = tot_action_with_frame_except S.empty let lift_heap_action_with_frame (#fp:slprop u#a) (#a:Type u#b) (#fp':a -> slprop u#a) (e:inames) ($f:H.action_with_frame fp a fp') : tot_action_with_frame_except e fp a fp' = fun frame m0 -> let h0 = hheap_of_hmem m0 in calc (equiv) { fp `star` frame `star` locks_invariant e m0; (equiv) { star_associative fp frame (locks_invariant e m0) } fp `star` (frame `star` locks_invariant e m0); }; assert (H.interp (fp `star` frame `star` locks_invariant e m0) h0); assert (H.interp (fp `star` (frame `star` locks_invariant e m0)) h0); //key: apply the heap action with frame * locks_invariant e m0 let (| x, h1 |) = f (frame `star` locks_invariant e m0) h0 in calc (equiv) { fp' x `star` (frame `star` locks_invariant e m0); (equiv) { star_associative (fp' x) frame (locks_invariant e m0) } fp' x `star` frame `star` locks_invariant e m0; }; assert (H.interp (fp' x `star` (frame `star` locks_invariant e m0)) h1); assert (H.interp (fp' x `star` frame `star` locks_invariant e m0) h1); let m1 = hmem_of_hheap m0 h1 in assert (mem_evolves m0 m1); mprop_preservation_of_hprop_preservation (frame `star` locks_invariant e m0) m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)); (| x, m1 |) let lift_tot_action_with_frame #a #e #fp #fp' ($f:tot_action_with_frame_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in assert (inames_ok e m0); ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); let m0' : hmem_with_inv_except e fp = m0 in let r = f frame m0' in let (| x, m1 |) = r in ac_reasoning_for_m_frame_preserving (fp' x) frame (locks_invariant e m1) m1; assert (interp (fp' x `star` frame `star` locks_invariant e m1) m1); assert (interp (fp' x `star` locks_invariant e m1) m1); let m1' : hmem_with_inv_except e (fp' x) = m1 in NMSTTotal.put #_ #(mem_evolves) m1; x

{ "checked_file": "/", "dependencies": [ "Steel.Preorder.fst.checked", "Steel.Heap.fsti.checked", "prims.fst.checked", "FStar.Witnessed.Core.fsti.checked", "FStar.Set.fsti.checked", "FStar.Preorder.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.PCM.fst.checked", "FStar.NMSTTotal.fst.checked", "FStar.List.Tot.fst.checked", "FStar.IndefiniteDescription.fsti.checked", "FStar.Ghost.fsti.checked", "FStar.FunctionalExtensionality.fsti.checked", "FStar.Classical.Sugar.fsti.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Steel.Memory.fst" }

[ { "abbrev": true, "full_module": "Steel.Preorder", "short_module": "PP" }, { "abbrev": true, "full_module": "FStar.Witnessed.Core", "short_module": "W" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": true, "full_module": "Steel.Heap", "short_module": "H" }, { "abbrev": false, "full_module": "FStar.FunctionalExtensionality", "short_module": null }, { "abbrev": true, "full_module": "FStar.FunctionalExtensionality", "short_module": "F" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": false, "full_module": "FStar.PCM", "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

e: Steel.Memory.inames -> r: Steel.Memory.ref a pcm -> v0: FStar.Ghost.erased a -> Steel.Memory.action_except (v: a{FStar.PCM.compatible pcm (FStar.Ghost.reveal v0) v}) e (Steel.Memory.pts_to r (FStar.Ghost.reveal v0)) (fun _ -> Steel.Memory.pts_to r (FStar.Ghost.reveal v0))

Prims.Tot

[ "total" ]

[]

[ "FStar.PCM.pcm", "Steel.Memory.inames", "Steel.Memory.ref", "FStar.Ghost.erased", "Steel.Memory.lift_tot_action", "FStar.PCM.compatible", "FStar.Ghost.reveal", "Steel.Heap.pts_to", "Steel.Memory.slprop", "Steel.Memory.lift_heap_action", "Steel.Heap.sel_action", "Steel.Memory.action_except", "Steel.Memory.pts_to" ]

[]

false

let sel_action #a #pcm e r v0 =

lift_tot_action (lift_heap_action e (H.sel_action #a #pcm r v0))

false

Steel.Memory.fst

Steel.Memory.pre_inv

val pre_inv : Type0

let pre_inv = i:erased iname & witnessed_name_is_ok i

{ "file_name": "lib/steel/Steel.Memory.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 53, "end_line": 1254, "start_col": 0, "start_line": 1254 }

(* 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.Memory module F = FStar.FunctionalExtensionality open FStar.FunctionalExtensionality open FStar.PCM module H = Steel.Heap noeq type lock_state : Type u#(a + 1) = | Invariant : inv:H.slprop u#a -> lock_state let lock_store : Type u#(a+1) = list (lock_state u#a) noeq type mem : Type u#(a + 1) = { ctr: nat; heap: H.heap u#a; locks: lock_store u#a; } let heap_of_mem (x:mem) : H.heap = x.heap let mem_of_heap (h:H.heap) : mem = { ctr = 0; heap = h; locks = [] } let mem_set_heap (m:mem) (h:H.heap) : mem = { ctr = m.ctr; heap = h; locks = m.locks; } let core_mem (m:mem) : mem = mem_of_heap (heap_of_mem m) let core_mem_invol m = () let disjoint (m0 m1:mem u#h) : prop = m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks let disjoint_sym m0 m1 = () let join m0 m1 = { ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = m0.locks } let join_commutative m0 m1 = H.join_commutative m0.heap m1.heap let disjoint_join m0 m1 m2 = H.disjoint_join m0.heap m1.heap m2.heap let join_associative m0 m1 m2 = H.join_associative m0.heap m1.heap m2.heap let slprop = H.slprop let interp p m = H.interp p m.heap let equiv p1 p2 = forall m. interp p1 m <==> interp p2 m let slprop_extensionality p q = assert (forall m. interp p m <==> interp q m); let aux (h:H.heap) : Lemma (H.interp p h <==> H.interp q h) [SMTPat (H.interp p h)] = let m : mem = { ctr = 0; heap = h; locks = [] } in assert (interp p m <==> interp q m) in assert (forall h. H.interp p h <==> H.interp q h); Steel.Heap.slprop_extensionality p q let reveal_equiv p1 p2 = () let core_ref = H.core_ref let core_ref_null = H.core_ref_null let core_ref_is_null r = H.core_ref_is_null r let emp : slprop u#a = H.emp let pure = H.pure let pts_to = H.pts_to let h_and = H.h_and let h_or = H.h_or let star = H.star let wand = H.wand let h_exists = H.h_exists let h_forall = H.h_forall //////////////////////////////////////////////////////////////////////////////// //properties of equiv //////////////////////////////////////////////////////////////////////////////// let equiv_symmetric (p1 p2:slprop u#a) = H.equiv_symmetric p1 p2 #push-options "--warn_error -271" let equiv_heap_iff_equiv (p1 p2:slprop u#a) : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat (equiv p1 p2)] = let aux_lr () : Lemma (requires H.equiv p1 p2) (ensures equiv p1 p2) [SMTPat ()] = () in let aux_rl_helper1 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p1 h) (ensures H.interp p2 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl_helper2 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p2 h) (ensures H.interp p1 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl () : Lemma (requires equiv p1 p2) (ensures H.equiv p1 p2) [SMTPat ()] = () in () let equiv_heap_iff_equiv_forall () : Lemma (ensures (forall p1 p2. H.equiv p1 p2 <==> equiv p1 p2)) = let aux p1 p2 : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat ()] = equiv_heap_iff_equiv p1 p2 in () #pop-options let equiv_extensional_on_star (p1 p2 p3:slprop u#a) = equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3 let emp_unit p = H.emp_unit p let intro_emp m = H.intro_emp (heap_of_mem m) let pure_equiv p q = H.pure_equiv p q let pure_interp q m = H.pure_interp q (heap_of_mem m) let pure_star_interp p q m = H.pure_star_interp p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// //pts_to //////////////////////////////////////////////////////////////////////////////// let pts_to_compatible #a #pcm x v0 v1 m = H.pts_to_compatible #a #pcm x v0 v1 (heap_of_mem m) let pts_to_compatible_equiv #a #pcm x v0 v1 = H.pts_to_compatible_equiv #a #pcm x v0 v1 let pts_to_not_null #a #pcm x v m = H.pts_to_not_null #a #pcm x v (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // star //////////////////////////////////////////////////////////////////////////////// let intro_star p q mp mq = H.intro_star p q (heap_of_mem mp) (heap_of_mem mq) let elim_star p q m = let h = heap_of_mem m in H.elim_star p q h; assert (exists hl hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr); let hl = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hl -> exists hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let hr = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hr -> H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let ml = mem_set_heap m hl in let mr = mem_set_heap m hr in assert (disjoint ml mr); assert (m == join ml mr); assert (interp p ml); assert (interp q mr); () let interp_star (p q: slprop) (m: mem) : Lemma (interp (p `star` q) m <==> (exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m)) = let left = interp (p `star` q) m in let right = exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m in let f () : Lemma (requires left) (ensures right) = elim_star p q m in let g () : Lemma (requires right) (ensures left) = Classical.exists_elim left #_ #(fun mp -> exists (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mp -> Classical.exists_elim left #_ #(fun mq -> disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mq -> intro_star p q mp mq ) ) in Classical.move_requires f (); Classical.move_requires g () let star_commutative (p1 p2:slprop) = H.star_commutative p1 p2 let star_associative (p1 p2 p3:slprop) = H.star_associative p1 p2 p3 let star_congruence (p1 p2 p3 p4:slprop) = equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4 let affine_star (p q:slprop) (m:mem) = H.affine_star p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // Invariants on the lock store //////////////////////////////////////////////////////////////////////////////// let iname = nat module S = FStar.Set module L = FStar.List.Tot module W = FStar.Witnessed.Core let rec lock_store_invariant (e:inames) (l:lock_store u#a) : slprop u#a = let current_addr = L.length l - 1 in match l with | [] -> emp | Invariant p :: tl -> if current_addr `S.mem` e then lock_store_invariant e tl else p `star` lock_store_invariant e tl let lock_i (i:iname) (l:lock_store { i < L.length l }) = let ix = L.length l - i - 1 in L.index l ix let iname_for_p (i:iname) (p:slprop) : W.s_predicate lock_store = fun l -> i < L.length l /\ (lock_i i l).inv == p let lock_store_evolves : FStar.Preorder.preorder lock_store = fun (l1 l2 : lock_store) -> L.length l2 >= L.length l1 /\ (forall (i:nat{i < L.length l1}). (lock_i i l1).inv == (lock_i i l2).inv) let inames_in (e:inames) (l:lock_store) : prop = forall i. Set.mem i e ==> i < L.length l let inames_ok e m = inames_in e m.locks let inames_ok_empty m = () let extend_lock_store (e:inames) (l:lock_store{e `inames_in` l}) (p:slprop) : i:iname & l':lock_store { lock_store_invariant e l' == p `star` lock_store_invariant e l /\ iname_for_p i p l' } = (| L.length l, Invariant p :: l |) let set_add (i:iname) (s:inames) = Set.union (Set.singleton i) s let rec move_invariant (e:inames) (l:lock_store) (p:slprop) (i:iname{iname_for_p i p l /\ ~(i `Set.mem` e)}) : Lemma (H.equiv (lock_store_invariant e l) (p `star` lock_store_invariant (set_add i e) l)) = let rec aux (i:iname) (m:lock_store) : Lemma (requires i >= L.length m) (ensures (lock_store_invariant e m `H.equiv` lock_store_invariant (set_add i e) m)) = match m with | [] -> () | Invariant p::tl -> aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl) in let current_addr = L.length l - 1 in match l with | [] -> () | Invariant q::tl -> if i = current_addr then begin assert (lock_store_invariant e l == p `star` lock_store_invariant e tl); aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl); () end else begin move_invariant e tl p i; assert (lock_store_invariant e tl `equiv` (p `star` lock_store_invariant (set_add i e) tl)); H.star_congruence q (lock_store_invariant e tl) q (p `star` lock_store_invariant (set_add i e) tl); if Set.mem current_addr e then () else begin let r = lock_store_invariant (set_add i e) tl in assert (lock_store_invariant e l `equiv` (q `star` (p `star` r))); H.star_associative q p r; H.star_commutative q p; H.star_congruence (q `star` p) r (p `star` q) r; H.star_associative p q r end end let heap_ctr_valid (ctr:nat) (h:H.heap u#a) : prop = h `H.free_above_addr` ctr let ctr_validity (ctr:nat) (h:H.heap) : slprop = H.pure (heap_ctr_valid ctr h) let locks_invariant (e:inames) (m:mem u#a) : slprop u#a = lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m) let full_mem_pred (m:mem) = H.full_heap_pred (heap_of_mem m) (***** Following lemmas are needed in Steel.Effect *****) let core_mem_interp (hp:slprop u#a) (m:mem u#a) = () let interp_depends_only_on (hp:slprop u#a) = H.interp_depends_only_on hp let a_mem_prop_as_a_heap_prop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (H.a_heap_prop u#a) = let g (h: H.heap u#a) : Tot prop = interp sl (mem_of_heap h) /\ f (mem_of_heap h) in let phi0 (h0 h1: H.heap u#a) : Lemma (requires (g h0 /\ H.disjoint h0 h1)) (ensures (g h0 /\ H.disjoint h0 h1 /\ g (H.join h0 h1))) = assert (mem_of_heap (H.join h0 h1) == mem_of_heap h0 `join` mem_of_heap h1); interp_depends_only_on sl in let phi1 (h0 h1: H.heap u#a) : Lemma (ensures ((g h0 /\ H.disjoint h0 h1) ==> g (H.join h0 h1))) = Classical.move_requires (phi0 h0) h1 in Classical.forall_intro_2 phi1; g let refine_slprop sl f = H.as_slprop (a_mem_prop_as_a_heap_prop sl f) let interp_refine_slprop sl f m = assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_mem m)) let dep_hprop (s: slprop) (f: (hmem s -> Tot slprop)) (h: H.heap) : Tot prop = exists (h1: H.heap) . exists (h2: H.heap) . interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 let dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq' : squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h')) = let p2 (h h1 h2: H.heap) : Tot prop = interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 in let p1 (h h1: H.heap) : Tot prop = (exists h2 . p2 h h1 h2) in let h1 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p1 h) in let h2 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p2 h h1) in H.disjoint_join h' h1 h2; assert (H.disjoint h2 h'); let h2' = H.join h2 h' in H.join_commutative h2 h' ; assert (h2' == H.join h' h2); assert (H.disjoint h1 h2'); assert (mem_of_heap h2' == mem_of_heap h2 `join` mem_of_heap h'); interp_depends_only_on (f (mem_of_heap h1)); assert (interp (f (mem_of_heap h1)) (mem_of_heap h2')); H.join_commutative h1 h2; H.join_associative h' h2 h1; H.join_commutative h' h; H.join_commutative h2' h1; assert (H.join h h' == h1 `H.join` h2') let impl_intro_gen (#p: Type0) (#q: Type0) ($prf: (squash p -> Lemma (q ))) : Lemma (p ==> q) = Classical.impl_intro_gen #p #(fun _ -> q) prf let dep_hprop_is_affine1 (s: slprop) (f: (hmem s -> Tot slprop)) (h0 h1: H.heap) : Lemma ((dep_hprop s f h0 /\ H.disjoint h0 h1) ==> (H.disjoint h0 h1 /\ dep_hprop s f (H.join h0 h1))) = impl_intro_gen (dep_hprop_is_affine0 s f h0 h1) let dep_hprop_is_affine (s: slprop) (f: (hmem s -> Tot slprop)) : Lemma (H.heap_prop_is_affine (dep_hprop s f)) = Classical.forall_intro_2 (dep_hprop_is_affine1 s f) let sdep (s: slprop) (f: (hmem s -> Tot slprop)) : Tot slprop = dep_hprop_is_affine s f; H.as_slprop (dep_hprop s f) let interp_sdep (s: slprop) (f: (hmem s -> Tot slprop)) (m: mem) : Lemma (requires (dep_slprop_is_affine s f)) (ensures ( interp (sdep s f) m <==> (exists m1 m2 . interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) )) = dep_hprop_is_affine s f; assert (forall m1 m2 . (interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) ==> ( interp s (mem_of_heap m1.heap) /\ interp (f (mem_of_heap m1.heap)) (mem_of_heap m2.heap) /\ H.disjoint m1.heap m2.heap /\ H.join m1.heap m2.heap == m.heap )); interp_depends_only_on s; Classical.forall_intro (fun m -> interp_depends_only_on (f m)); assert (forall h1 h2 . (interp s (mem_of_heap h1) /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ H.disjoint h1 h2 /\ H.join h1 h2 == m.heap) ==> ( core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ interp s (core_mem (mem_of_heap h1)) /\ interp s (mem_set_heap m h1) /\ core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ f (mem_set_heap m h1) `equiv` f (mem_of_heap h1) /\ interp (f (mem_set_heap m h1)) (mem_of_heap h2) /\ interp (f (mem_set_heap m h1)) (mem_set_heap m h2) /\ disjoint (mem_set_heap m h1) (mem_set_heap m h2) /\ join (mem_set_heap m h1) (mem_set_heap m h2) == m )); () let h_exists_cong (#a:Type) (p q : a -> slprop) : Lemma (requires (forall x. p x `equiv` q x)) (ensures (h_exists p `equiv` h_exists q)) = equiv_heap_iff_equiv_forall (); H.h_exists_cong p q let intro_h_exists #a x p m = H.intro_h_exists x p (heap_of_mem m) let elim_h_exists (#a:_) (p:a -> slprop) (m:mem) = H.elim_h_exists p (heap_of_mem m) let intro_h_forall (#a:_) (p:a -> slprop) (m:mem) = H.intro_h_forall p (heap_of_mem m) let elim_h_forall (#a:_) (p:a -> slprop) (m:mem) (x:a) = H.elim_h_forall p (heap_of_mem m) x let intro_h_and (p q: slprop) (m:mem) = H.intro_h_and p q (heap_of_mem m) let elim_h_and (p q: slprop) (m:mem) = H.elim_h_and p q (heap_of_mem m) let intro_h_or_left (p q: slprop) (m:mem) = H.intro_h_or_left p q (heap_of_mem m) let intro_h_or_right (p q: slprop) (m:mem) = H.intro_h_or_right p q (heap_of_mem m) let elim_h_or (p q: slprop) (m:mem) = H.elim_h_or p q (heap_of_mem m) let intro_wand (p1 p2: slprop u#a) (m:mem) = introduce (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)) ==> interp (wand p1 p2) m with _. ( assert (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)); H.intro_wand p1 p2 (heap_of_mem m); let h = heap_of_mem m in assert ((forall h1. h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) ==> H.interp (wand p1 p2) h); introduce forall h1. (h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) with ( introduce (h `H.disjoint` h1 /\ H.interp p1 h1) ==> H.interp p2 (H.join h h1) with _. ( assert (h `H.disjoint` h1); let m1 = { ctr = m.ctr; heap = h1; locks = m.locks } in assert (m `disjoint` m1) ) ) ) (** Eliminating a wand by proving a heap that satisfies the LHS **) let elim_wand (p1 p2: slprop u#a) (m:mem) (m1:mem) = H.elim_wand p1 p2 (heap_of_mem m) (heap_of_mem m1) //////////////////////////////////////////////////////////////////////////////// // Preorders and effects //////////////////////////////////////////////////////////////////////////////// module PP = Steel.Preorder let mem_evolves = fun (m0 m1:full_mem) -> H.heap_evolves (heap_of_mem m0) (heap_of_mem m1) /\ m0.ctr <= m1.ctr /\ lock_store_evolves m0.locks m1.locks (** See [Steel.Heap.is_frame_preserving]. We add in [lock_invariants] now *) let preserves_frame (e:inames) (pre post:slprop) (m0 m1:mem) = forall (frame:slprop). interp ((pre `star` frame) `star` locks_invariant e m0) m0 ==> (interp ((post `star` frame) `star` locks_invariant e m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) (** This is a version of MstTot with frame quantified, as part of preserves_frame *) effect MstTotNF (a:Type u#a) (except:inames) (expects:slprop u#1) (provides: a -> slprop u#1) = NMSTTotal.NMSTATETOT a (full_mem u#1) mem_evolves (requires fun m0 -> inames_ok except m0 /\ interp (expects `star` locks_invariant except m0) m0) (ensures fun m0 x m1 -> inames_ok except m1 /\ interp (provides x `star` locks_invariant except m1) m1 /\ preserves_frame except expects (provides x) m0 m1) //////////////////////////////////////////////////////////////////////////////// // Lifting heap actions //////////////////////////////////////////////////////////////////////////////// (** Heap actions come in two equivalent flavors: - one that take an explicit frame as argument (action_with_frame) - and one that quantify over all the frame We therefore define two lift routes: - a direct route for those with explicit frame - via MstTotNF for the rest *) let tot_pre_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = hmem_with_inv_except e fp -> (x:a & hmem_with_inv_except e (fp' x)) let tot_pre_action_nf = tot_pre_action_nf_except S.empty let ac_reasoning_for_m_frame_preserving (p q r:slprop u#a) (m:mem u#a) : Lemma (requires interp ((p `star` q) `star` r) m) (ensures interp (p `star` r) m) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_commutative p q; equiv_extensional_on_star (p `star` q) (q `star` p) r } (q `star` p) `star` r; (equiv) { star_associative q p r } q `star` (p `star` r); }; assert (interp (q `star` (p `star` r)) m); affine_star q (p `star` r) m let is_frame_preserving (#e:inames) (#a:Type u#b) (#fp:slprop u#a) (#fp':a -> slprop u#a) (f:tot_pre_action_nf_except e fp a fp') = forall (frame:slprop u#a) (m0:hmem_with_inv_except e (fp `star` frame)). (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = f:tot_pre_action_nf_except e fp a fp'{ is_frame_preserving f } let tot_action_nf = tot_action_nf_except S.empty let linv e (m:mem) = locks_invariant e m let hheap_of_hmem #fp #e (m:hmem_with_inv_except e fp) : h:H.hheap (fp `star` linv e m) { h `H.free_above_addr` m.ctr} = let h = heap_of_mem m in H.pure_interp (heap_ctr_valid m.ctr (heap_of_mem m)) h; h let hmem_of_hheap #e (#fp0 #fp1:slprop) (m:hmem_with_inv_except e fp0) (h:H.full_hheap (fp1 `star` linv e m) { h `Heap.free_above_addr` m.ctr }) : m1:hmem_with_inv_except e fp1{linv e m `equiv` linv e m1} = let m1 : mem = { m with heap = h } in assert (interp (fp1 `star` linv e m) m1); star_commutative fp1 (linv e m); assert (interp (linv e m `star` fp1) m1); assert (linv e m1 == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); assert (linv e m == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m)); H.pure_interp (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_of_mem m); assert (heap_ctr_valid m1.ctr (heap_of_mem m) <==> heap_ctr_valid m1.ctr (heap_of_mem m1)); H.pure_equiv (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_ctr_valid m1.ctr (heap_of_mem m1)); H.star_congruence (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m)); assert (linv e m `equiv` linv e m1); let _ = equiv_extensional_on_star (linv e m) (linv e m1) fp1 in assert ((linv e m `star` fp1) `equiv` (linv e m1 `star` fp1)); assert (interp (linv e m1 `star` fp1) m1); star_commutative (linv e m1) fp1; assert (interp (fp1 `star` linv e m1) m1); m1 let with_inv_except (m:mem) e (fp:slprop) = interp (fp `star` locks_invariant e m) m #push-options "--warn_error -271" let as_hprop (frame:slprop) (mp:mprop frame) : hp:H.hprop frame{forall m. mp (core_mem m) == hp (heap_of_mem m)} = let f = fun h -> mp (mem_of_heap h) in assert (forall m. mp (core_mem m) == f (heap_of_mem m)); let aux (m0:H.hheap frame) (m1:H.heap{H.disjoint m0 m1}) : Lemma (ensures (mem_of_heap (H.join m0 m1) == join (mem_of_heap m0) (mem_of_heap m1))) [SMTPat ()] = () in f let mprop_preservation_of_hprop_preservation (p:slprop) (m0 m1:mem) : Lemma (requires (forall (hp:H.hprop p). hp (heap_of_mem m0) == hp (heap_of_mem m1))) (ensures (forall (mp:mprop p). mp (core_mem m0) == mp (core_mem m1))) = let aux (mp:mprop p) : Lemma (mp (core_mem m0) == mp (core_mem m1)) [SMTPat()] = assert (as_hprop p mp (heap_of_mem m0) == as_hprop p mp (heap_of_mem m1)) in () let lift_heap_action (#fp:slprop) (#a:Type) (#fp':a -> slprop) (e:inames) ($f:H.action fp a fp') : tot_action_nf_except e fp a fp' = let g : tot_pre_action_nf_except e fp a fp' = fun m -> let h0 = hheap_of_hmem m in let (| x, h' |) = f h0 in (| x, hmem_of_hheap m h' |) in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in let h0 = hheap_of_hmem m0 in let (| x', h1 |) = f h0 in H.action_framing f (linv e m0) h0; assert (x == x'); star_associative fp frame (linv e m0); H.action_framing f (frame `star` linv e m0) h0; assert (H.interp ((fp' x) `star` (frame `star` linv e m0)) h1); star_associative (fp' x) frame (linv e m0); assert (H.interp ((fp' x `star` frame) `star` linv e m0) h1); let h1' : H.hheap ((fp' x `star` frame) `star` linv e m0) = h1 in assert (m1 == hmem_of_hheap m0 h1'); assert (with_inv_except m1 e (fp' x `star` frame)); assert (forall (hp:H.hprop frame). hp h0 == hp h1); mprop_preservation_of_hprop_preservation frame m0 m1; () in assert (is_frame_preserving g); g let frame_preserving_respects_preorder #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (m0:hmem_with_inv_except e fp) : Lemma (let (| x, m1 |) = f m0 in mem_evolves m0 m1) = let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1) = () in H.emp_unit fp; assert (interp (fp `star` linv e m0) m0); H.star_congruence (fp `star` emp) (linv e m0) fp (linv e m0); assert (interp ((fp `star` emp) `star` linv e m0) m0); aux emp m0 let lift_tot_action_nf #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') : MstTotNF a e fp fp' = let m0 = NMSTTotal.get () in let m0' : hmem_with_inv_except e fp = m0 in let r = f m0' in let (| x, m1 |) = r in let m1' : hmem_with_inv_except e (fp' x) = m1 in assert (is_frame_preserving f); assert (m1 == dsnd (f m0)); frame_preserving_respects_preorder f m0; NMSTTotal.put #_ #(mem_evolves) m1; x let lift_tot_action #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get #(full_mem) #_ () in ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); lift_tot_action_nf f (** Now defining the lift for heap actions with explicit frame *) let tot_action_with_frame_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = frame:slprop u#a -> m0:hmem_with_inv_except e (fp `star` frame) -> Pure (x:a & hmem_with_inv_except e (fp' x `star` frame)) (requires True) (ensures fun (| x, m1 |) -> mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_with_frame = tot_action_with_frame_except S.empty let lift_heap_action_with_frame (#fp:slprop u#a) (#a:Type u#b) (#fp':a -> slprop u#a) (e:inames) ($f:H.action_with_frame fp a fp') : tot_action_with_frame_except e fp a fp' = fun frame m0 -> let h0 = hheap_of_hmem m0 in calc (equiv) { fp `star` frame `star` locks_invariant e m0; (equiv) { star_associative fp frame (locks_invariant e m0) } fp `star` (frame `star` locks_invariant e m0); }; assert (H.interp (fp `star` frame `star` locks_invariant e m0) h0); assert (H.interp (fp `star` (frame `star` locks_invariant e m0)) h0); //key: apply the heap action with frame * locks_invariant e m0 let (| x, h1 |) = f (frame `star` locks_invariant e m0) h0 in calc (equiv) { fp' x `star` (frame `star` locks_invariant e m0); (equiv) { star_associative (fp' x) frame (locks_invariant e m0) } fp' x `star` frame `star` locks_invariant e m0; }; assert (H.interp (fp' x `star` (frame `star` locks_invariant e m0)) h1); assert (H.interp (fp' x `star` frame `star` locks_invariant e m0) h1); let m1 = hmem_of_hheap m0 h1 in assert (mem_evolves m0 m1); mprop_preservation_of_hprop_preservation (frame `star` locks_invariant e m0) m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)); (| x, m1 |) let lift_tot_action_with_frame #a #e #fp #fp' ($f:tot_action_with_frame_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in assert (inames_ok e m0); ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); let m0' : hmem_with_inv_except e fp = m0 in let r = f frame m0' in let (| x, m1 |) = r in ac_reasoning_for_m_frame_preserving (fp' x) frame (locks_invariant e m1) m1; assert (interp (fp' x `star` frame `star` locks_invariant e m1) m1); assert (interp (fp' x `star` locks_invariant e m1) m1); let m1' : hmem_with_inv_except e (fp' x) = m1 in NMSTTotal.put #_ #(mem_evolves) m1; x let sel_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.sel_action #a #pcm r v0)) let upd_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.upd_action #a #pcm r v0 v1)) let free_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.free_action #a #pcm r v0)) let split_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.split_action #a #pcm r v0 v1)) let gather_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.gather_action #a #pcm r v0 v1)) let weaken (p q r:slprop) (h:H.hheap (p `star` q) { H.stronger q r }) : H.hheap (p `star` r) = H.weaken p q r h; h let weaken_pure (q r: prop) : Lemma (requires (q ==> r)) (ensures H.stronger (H.pure q) (H.pure r)) = let aux (h:H.heap) : Lemma (ensures (H.interp (H.pure q) h ==> H.interp (H.pure r) h)) [SMTPat ()] = H.pure_interp q h; H.pure_interp r h in () let inc_ctr (#p:slprop) #e (m:hmem_with_inv_except e p) : m':hmem_with_inv_except e p{m'.ctr = m.ctr + 1 /\ H.stronger (linv e m) (linv e m')} = let m' : mem = { m with ctr = m.ctr + 1} in assert (interp (p `star` linv e m) m'); assert (linv e m == lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m)); assert (linv e m' == lock_store_invariant e m.locks `star` ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken_free_above (heap_of_mem m) m.ctr (m.ctr + 1); weaken_pure (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_ctr_valid (m.ctr + 1) (heap_of_mem m)); assert (H.stronger (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m))); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)); H.stronger_star (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken (p `star` lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)) (heap_of_mem m'); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity (m.ctr + 1) (heap_of_mem m)); let m' : hmem_with_inv_except e p = m' in m' let frame_related_mems (fp0 fp1:slprop u#a) e (m0:hmem_with_inv_except e fp0) (m1:hmem_with_inv_except e fp1) = forall (frame:slprop u#a). interp ((fp0 `star` frame) `star` linv e m0) m0 ==> interp ((fp1 `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) let refined_pre_action e (fp0:slprop) (a:Type) (fp1:a -> slprop) = m0:hmem_with_inv_except e fp0 -> Pure (x:a & hmem_with_inv_except e (fp1 x)) (requires True) (ensures fun (| x, m1 |) -> frame_related_mems fp0 (fp1 x) e m0 m1) let refined_pre_action_as_action (#fp0:slprop) (#a:Type) (#fp1:a -> slprop) #e ($f:refined_pre_action e fp0 a fp1) : tot_action_nf_except e fp0 a fp1 = let g : tot_pre_action_nf_except e fp0 a fp1 = fun m -> f m in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp0 `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp1 x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x', m1' |) = g m0 in let (| x, m1 |) = f m0 in assert (x == x' /\ m1 == m1') in g let alloc_action #a #pcm e x = let f : refined_pre_action e emp (ref a pcm) (fun r -> pts_to r x) = fun m0 -> (* NS: 9/29/22 I needed to annotate h : Heap.full_heap, for use with the Core checker which generates a guard for checking the implicit pattern "dot" term in the dependent pair pattern on the next line. That guard expects `h` to be a full_heap, which is it, because it is a projection of m0. However, this is not reflected in `h`'s type. So, the Core checker, which produces a guard for the pat_dot_term in isolation, cannot recheck the term. If we were to fold in the checking of pat_dot_terms and their guards with the rest of the VC, this would work. *) let h : Heap.full_heap = hheap_of_hmem m0 in let (|r, h'|) = H.extend #a #pcm x m0.ctr h in let m' : hmem_with_inv_except e emp = inc_ctr m0 in let h' : H.hheap (pts_to #a #pcm r x `star` linv e m') = weaken _ (linv e m0) (linv e m') h' in let m1 : hmem_with_inv_except e (pts_to #a #pcm r x) = hmem_of_hheap m' h' in assert (forall frame. H.frame_related_heaps h h' emp (pts_to #a #pcm r x) frame true); let aux (frame:slprop) : Lemma (requires interp ((emp `star` frame) `star` linv e m0) m0) (ensures interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) [SMTPat (emp `star` frame)] = star_associative emp frame (linv e m0); assert (H.interp (emp `star` (frame `star` linv e m0)) h); assert (H.interp (pts_to #a #pcm r x `star` (frame `star` linv e m0)) h'); star_associative (pts_to #a #pcm r x) frame (linv e m0); assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m0) h'); assert (H.stronger (linv e m0) (linv e m')); assert (H.equiv (linv e m') (linv e m1)); assert (H.stronger (linv e m0) (linv e m1)); let h' : H.hheap ((pts_to #a #pcm r x `star` frame) `star` linv e m1) = weaken _ (linv e m0) (linv e m1) h' in assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) h'); assert (forall (mp:H.hprop frame). mp h == mp h'); mprop_preservation_of_hprop_preservation frame m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) in assert (frame_related_mems emp (pts_to r x) e m0 m1); (| r, m1 |) in lift_tot_action (refined_pre_action_as_action f) let select_refine #a #p e r x f = lift_tot_action (lift_heap_action e (H.select_refine #a #p r x f)) let upd_gen #a #p e r x y f = lift_tot_action (lift_heap_action e (H.upd_gen_action r x y f)) //////////////////////////////////////////////////////////////////////////////// // witness / recall //////////////////////////////////////////////////////////////////////////////// let witnessed_ref #a #pcm (r:ref a pcm) (fact:property a) (m:full_mem) = H.witnessed_ref #a #pcm r fact (heap_of_mem m) let witnessed_ref_stability #a #pcm (r:ref a pcm) (fact:property a) : Lemma (requires FStar.Preorder.stable fact (Steel.Preorder.preorder_of_pcm pcm)) (ensures FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) = H.witnessed_ref_stability #a #pcm r fact let witnessed (#a:Type u#1) (#pcm:pcm a) (r:ref a pcm) (fact:property a) = W.witnessed _ mem_evolves (witnessed_ref r fact) let rearrange_pqr_prq (p q r:slprop) : Lemma (((p `star` q) `star` r) `equiv` ((p `star` r) `star` q)) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_associative p q r } p `star` (q `star` r); (equiv) { star_commutative q r; star_congruence p (q `star` r) p (r `star` q) } p `star` (r `star` q); (equiv) { star_associative p r q } (p `star` r) `star` q; } let preserves_frame_cong (e:inames) (p q:slprop) (r s:slprop) (m0 m1:mem) : Lemma (requires p `equiv` r /\ q `equiv` s /\ preserves_frame e p q m0 m1) (ensures preserves_frame e r s m0 m1) = let aux0 (p q r s:slprop) : Lemma (requires p `equiv` s) (ensures (((p `star` q) `star` r) `equiv` ((s `star` q) `star` r))) = star_congruence p q s q; star_congruence (p `star` q) r (s `star` q) r in let aux (frame:slprop) : Lemma (requires interp ((r `star` frame) `star` locks_invariant e m0) m0) (ensures interp ((s `star` frame) `star` locks_invariant e m1) m1 /\ interp ((p `star` frame) `star` locks_invariant e m0) m0) [SMTPat (r `star` frame)] = aux0 p frame (locks_invariant e m0) r; aux0 q frame (locks_invariant e m1) s; assert (((p `star` frame) `star` locks_invariant e m0) `equiv` ((r `star` frame) `star` locks_invariant e m0)); assert (interp ((p `star` frame) `star` locks_invariant e m0) m0); assert (interp ((q `star` frame) `star` locks_invariant e m1) m1); assert (((q `star` frame) `star` locks_invariant e m1) `equiv` ((s `star` frame) `star` locks_invariant e m1)); () in () let pure_true_equiv (p:slprop) : Lemma ((p `star` pure True) `equiv` p) = FStar.Classical.forall_intro (pure_star_interp p True); emp_unit p; assert ((p `star` pure True) `equiv` p) let preserves_frame_star_pure (e:inames) (p q:slprop) (r s:prop) (m:mem) : Lemma (requires r /\ s) (ensures preserves_frame e p q m m <==> preserves_frame e (p `star` pure r) (q `star` pure s) m m) = pure_equiv r True; star_congruence p (pure r) p (pure True); pure_equiv s True; star_congruence q (pure s) q (pure True); pure_true_equiv p; pure_true_equiv q; let fwd () : Lemma (requires preserves_frame e p q m m) (ensures preserves_frame e (p `star` pure r) (q `star` pure s) m m) [SMTPat ()] = preserves_frame_cong e p q (p `star` pure r) (q `star` pure s) m m in let bk () : Lemma (requires preserves_frame e (p `star` pure r) (q `star` pure s) m m) (ensures preserves_frame e p q m m) [SMTPat ()] = preserves_frame_cong e (p `star` pure r) (q `star` pure s) p q m m in () let witness (#a:Type) (#pcm:pcm a) (e:inames) (r:erased (ref a pcm)) (fact:stable_property pcm) (v:Ghost.erased a) (_:squash (forall z. compatible pcm v z ==> fact z)) (frame:slprop) : MstTot (witnessed r fact) e (pts_to r v) (fun _ -> pts_to r v) frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in let _ : unit = let hr : H.ref a pcm = r in let v' = H.sel_v hr v (heap_of_mem m0) in assert (interp (H.ptr hr) m0 /\ H.sel #a #pcm hr (heap_of_mem m0) == v'); assert (compatible pcm v v'); assert (fact v'); assert (witnessed_ref r fact m0); witnessed_ref_stability r fact; assert (FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) in let w = NMSTTotal.witness _ mem_evolves (witnessed_ref r fact) in w let recall (#a:Type u#1) (#pcm:pcm a) (#fact:property a) (e:inames) (r:erased (ref a pcm)) (v:Ghost.erased a) (w:witnessed r fact) (frame:slprop) = let m0 = NMSTTotal.get () in NMSTTotal.recall _ mem_evolves (witnessed_ref r fact) w; let hr : H.ref a pcm = r in assert (witnessed_ref r fact m0); let v1 = H.sel_v hr v (heap_of_mem m0) in assert (compatible pcm v v1); assert (H.sel hr (heap_of_mem m0) == v1); assert (fact v1); assert (interp ((pts_to r v `star` frame) `star` locks_invariant e m0) m0); emp_unit ((pts_to r v `star` frame) `star` locks_invariant e m0); pure_star_interp ((pts_to r v `star` frame) `star` locks_invariant e m0) (fact v1) m0; assert (interp (((pts_to r v `star` frame) `star` locks_invariant e m0) `star` pure (fact v1)) m0); rearrange_pqr_prq (pts_to r v `star` frame) (locks_invariant e m0) (pure (fact v1)); assert (interp (((pts_to r v `star` frame) `star` pure (fact v1)) `star` locks_invariant e m0) m0); rearrange_pqr_prq (pts_to r v) frame (pure (fact v1)); star_congruence ((pts_to r v `star` frame) `star` pure (fact v1)) (locks_invariant e m0) ((pts_to r v `star` pure (fact v1)) `star` frame) (locks_invariant e m0); Ghost.hide v1 let iname_for_p_mem (i:iname) (p:slprop) : W.s_predicate mem = fun m -> iname_for_p i p m.locks let iname_for_p_stable (i:iname) (p:slprop) : Lemma (W.stable full_mem mem_evolves (iname_for_p_mem i p)) = () let ( >--> ) (i:iname) (p:slprop) : Type0 = W.witnessed full_mem mem_evolves (iname_for_p_mem i p) let hmem_with_inv_equiv e (m:mem) (p:slprop) : Lemma (interp (p `star` linv e m) m <==> interp (p `star` lock_store_invariant e m.locks) m /\ heap_ctr_valid m.ctr (heap_of_mem m)) = calc (<==>) { interp (p `star` linv e m) m; (<==>) { H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) } interp ((p `star` lock_store_invariant e m.locks) `star` ctr_validity m.ctr (heap_of_mem m)) m; (<==>) { H.pure_star_interp (p `star` lock_store_invariant e m.locks) (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_of_mem m) } interp ((p `star` lock_store_invariant e m.locks) `star` emp) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); (<==>) { H.emp_unit (p `star` lock_store_invariant e m.locks) } interp (p `star` lock_store_invariant e m.locks) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); } let new_invariant_tot_action (e:inames) (p:slprop) (m0:hmem_with_inv_except e p{ e `inames_in` m0.locks }) : Pure (iname & hmem_with_inv_except e emp) (requires True) (ensures fun (i, m1) -> iname_for_p_mem i p m1 /\ frame_related_mems p emp e m0 m1 /\ mem_evolves m0 m1) = let (| i, l1 |) = extend_lock_store e m0.locks p in let m1 = { m0 with locks = l1 } in assert (lock_store_invariant e m1.locks == p `star` lock_store_invariant e m0.locks); calc (equiv) { linv e m1; (equiv) {} (lock_store_invariant e m1.locks `star` ctr_validity m1.ctr (heap_of_mem m1)); (equiv) {} ((p `star` lock_store_invariant e m0.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); (equiv) { H.star_associative p (lock_store_invariant e m0.locks) (ctr_validity m1.ctr (heap_of_mem m1)) } (p `star` (lock_store_invariant e m0.locks `star` ctr_validity m1.ctr (heap_of_mem m1))); (equiv) { } (p `star` linv e m0); }; assert (iname_for_p_mem i p m1); assert (lock_store_evolves m0.locks l1); assert (mem_evolves m0 m1); hmem_with_inv_equiv e m0 p; assert (interp (p `star` lock_store_invariant e m0.locks) m1); assert (interp (lock_store_invariant e m1.locks) m1); H.emp_unit (lock_store_invariant e m1.locks); H.star_commutative (lock_store_invariant e m1.locks) emp; assert (interp (emp `star` lock_store_invariant e m1.locks) m1); hmem_with_inv_equiv e m1 emp; let m1 : hmem_with_inv_except e emp = m1 in let aux (frame:slprop) : Lemma (requires interp ((p `star` frame) `star` linv e m0) m0) (ensures interp ((emp `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) <==> mp (core_mem m1))) [SMTPat (p `star` frame)] = assert (interp ((p `star` frame) `star` linv e m0) m1); calc (equiv) { ((p `star` frame) `star` linv e m0); (equiv) { H.star_commutative p frame; H.star_congruence (p `star` frame) (linv e m0) (frame `star` p) (linv e m0); H.star_associative frame p (linv e m0) } (frame `star` (p `star` linv e m0)); (equiv) { H.star_congruence frame (p `star` linv e m0) frame (linv e m1) } (frame `star` linv e m1); (equiv) { H.emp_unit (frame `star` linv e m1); H.star_commutative (frame `star` linv e m1) emp; H.star_associative emp frame (linv e m1) } ((emp `star` frame) `star` linv e m1); }; assert (interp ((emp `star` frame) `star` linv e m1) m1) in assert (frame_related_mems p emp e m0 m1); ( i, m1 ) let name_is_ok (i:iname) (m0:full_mem u#1) : prop = i < List.Tot.length m0.locks let witnessed_name_is_ok (i:iname) = W.witnessed full_mem mem_evolves (name_is_ok i)

{ "checked_file": "/", "dependencies": [ "Steel.Preorder.fst.checked", "Steel.Heap.fsti.checked", "prims.fst.checked", "FStar.Witnessed.Core.fsti.checked", "FStar.Set.fsti.checked", "FStar.Preorder.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.PCM.fst.checked", "FStar.NMSTTotal.fst.checked", "FStar.List.Tot.fst.checked", "FStar.IndefiniteDescription.fsti.checked", "FStar.Ghost.fsti.checked", "FStar.FunctionalExtensionality.fsti.checked", "FStar.Classical.Sugar.fsti.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Steel.Memory.fst" }

[ { "abbrev": true, "full_module": "Steel.Preorder", "short_module": "PP" }, { "abbrev": true, "full_module": "FStar.Witnessed.Core", "short_module": "W" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": true, "full_module": "Steel.Heap", "short_module": "H" }, { "abbrev": false, "full_module": "FStar.FunctionalExtensionality", "short_module": null }, { "abbrev": true, "full_module": "FStar.FunctionalExtensionality", "short_module": "F" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": false, "full_module": "FStar.PCM", "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

Type0

Prims.Tot

[ "total" ]

[]

[ "Prims.dtuple2", "FStar.Ghost.erased", "Steel.Memory.iname", "Steel.Memory.witnessed_name_is_ok", "FStar.Ghost.reveal" ]

[]

false

true

let pre_inv =

i: erased iname & witnessed_name_is_ok i

false

Steel.Memory.fst

Steel.Memory.refined_pre_action_as_action

val refined_pre_action_as_action (#fp0: slprop) (#a: Type) (#fp1: (a -> slprop)) (#e: _) ($f: refined_pre_action e fp0 a fp1) : tot_action_nf_except e fp0 a fp1

let refined_pre_action_as_action (#fp0:slprop) (#a:Type) (#fp1:a -> slprop) #e ($f:refined_pre_action e fp0 a fp1) : tot_action_nf_except e fp0 a fp1 = let g : tot_pre_action_nf_except e fp0 a fp1 = fun m -> f m in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp0 `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp1 x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x', m1' |) = g m0 in let (| x, m1 |) = f m0 in assert (x == x' /\ m1 == m1') in g

{ "file_name": "lib/steel/Steel.Memory.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 5, "end_line": 938, "start_col": 0, "start_line": 919 }

(* 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.Memory module F = FStar.FunctionalExtensionality open FStar.FunctionalExtensionality open FStar.PCM module H = Steel.Heap noeq type lock_state : Type u#(a + 1) = | Invariant : inv:H.slprop u#a -> lock_state let lock_store : Type u#(a+1) = list (lock_state u#a) noeq type mem : Type u#(a + 1) = { ctr: nat; heap: H.heap u#a; locks: lock_store u#a; } let heap_of_mem (x:mem) : H.heap = x.heap let mem_of_heap (h:H.heap) : mem = { ctr = 0; heap = h; locks = [] } let mem_set_heap (m:mem) (h:H.heap) : mem = { ctr = m.ctr; heap = h; locks = m.locks; } let core_mem (m:mem) : mem = mem_of_heap (heap_of_mem m) let core_mem_invol m = () let disjoint (m0 m1:mem u#h) : prop = m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks let disjoint_sym m0 m1 = () let join m0 m1 = { ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = m0.locks } let join_commutative m0 m1 = H.join_commutative m0.heap m1.heap let disjoint_join m0 m1 m2 = H.disjoint_join m0.heap m1.heap m2.heap let join_associative m0 m1 m2 = H.join_associative m0.heap m1.heap m2.heap let slprop = H.slprop let interp p m = H.interp p m.heap let equiv p1 p2 = forall m. interp p1 m <==> interp p2 m let slprop_extensionality p q = assert (forall m. interp p m <==> interp q m); let aux (h:H.heap) : Lemma (H.interp p h <==> H.interp q h) [SMTPat (H.interp p h)] = let m : mem = { ctr = 0; heap = h; locks = [] } in assert (interp p m <==> interp q m) in assert (forall h. H.interp p h <==> H.interp q h); Steel.Heap.slprop_extensionality p q let reveal_equiv p1 p2 = () let core_ref = H.core_ref let core_ref_null = H.core_ref_null let core_ref_is_null r = H.core_ref_is_null r let emp : slprop u#a = H.emp let pure = H.pure let pts_to = H.pts_to let h_and = H.h_and let h_or = H.h_or let star = H.star let wand = H.wand let h_exists = H.h_exists let h_forall = H.h_forall //////////////////////////////////////////////////////////////////////////////// //properties of equiv //////////////////////////////////////////////////////////////////////////////// let equiv_symmetric (p1 p2:slprop u#a) = H.equiv_symmetric p1 p2 #push-options "--warn_error -271" let equiv_heap_iff_equiv (p1 p2:slprop u#a) : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat (equiv p1 p2)] = let aux_lr () : Lemma (requires H.equiv p1 p2) (ensures equiv p1 p2) [SMTPat ()] = () in let aux_rl_helper1 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p1 h) (ensures H.interp p2 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl_helper2 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p2 h) (ensures H.interp p1 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl () : Lemma (requires equiv p1 p2) (ensures H.equiv p1 p2) [SMTPat ()] = () in () let equiv_heap_iff_equiv_forall () : Lemma (ensures (forall p1 p2. H.equiv p1 p2 <==> equiv p1 p2)) = let aux p1 p2 : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat ()] = equiv_heap_iff_equiv p1 p2 in () #pop-options let equiv_extensional_on_star (p1 p2 p3:slprop u#a) = equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3 let emp_unit p = H.emp_unit p let intro_emp m = H.intro_emp (heap_of_mem m) let pure_equiv p q = H.pure_equiv p q let pure_interp q m = H.pure_interp q (heap_of_mem m) let pure_star_interp p q m = H.pure_star_interp p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// //pts_to //////////////////////////////////////////////////////////////////////////////// let pts_to_compatible #a #pcm x v0 v1 m = H.pts_to_compatible #a #pcm x v0 v1 (heap_of_mem m) let pts_to_compatible_equiv #a #pcm x v0 v1 = H.pts_to_compatible_equiv #a #pcm x v0 v1 let pts_to_not_null #a #pcm x v m = H.pts_to_not_null #a #pcm x v (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // star //////////////////////////////////////////////////////////////////////////////// let intro_star p q mp mq = H.intro_star p q (heap_of_mem mp) (heap_of_mem mq) let elim_star p q m = let h = heap_of_mem m in H.elim_star p q h; assert (exists hl hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr); let hl = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hl -> exists hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let hr = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hr -> H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let ml = mem_set_heap m hl in let mr = mem_set_heap m hr in assert (disjoint ml mr); assert (m == join ml mr); assert (interp p ml); assert (interp q mr); () let interp_star (p q: slprop) (m: mem) : Lemma (interp (p `star` q) m <==> (exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m)) = let left = interp (p `star` q) m in let right = exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m in let f () : Lemma (requires left) (ensures right) = elim_star p q m in let g () : Lemma (requires right) (ensures left) = Classical.exists_elim left #_ #(fun mp -> exists (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mp -> Classical.exists_elim left #_ #(fun mq -> disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mq -> intro_star p q mp mq ) ) in Classical.move_requires f (); Classical.move_requires g () let star_commutative (p1 p2:slprop) = H.star_commutative p1 p2 let star_associative (p1 p2 p3:slprop) = H.star_associative p1 p2 p3 let star_congruence (p1 p2 p3 p4:slprop) = equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4 let affine_star (p q:slprop) (m:mem) = H.affine_star p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // Invariants on the lock store //////////////////////////////////////////////////////////////////////////////// let iname = nat module S = FStar.Set module L = FStar.List.Tot module W = FStar.Witnessed.Core let rec lock_store_invariant (e:inames) (l:lock_store u#a) : slprop u#a = let current_addr = L.length l - 1 in match l with | [] -> emp | Invariant p :: tl -> if current_addr `S.mem` e then lock_store_invariant e tl else p `star` lock_store_invariant e tl let lock_i (i:iname) (l:lock_store { i < L.length l }) = let ix = L.length l - i - 1 in L.index l ix let iname_for_p (i:iname) (p:slprop) : W.s_predicate lock_store = fun l -> i < L.length l /\ (lock_i i l).inv == p let lock_store_evolves : FStar.Preorder.preorder lock_store = fun (l1 l2 : lock_store) -> L.length l2 >= L.length l1 /\ (forall (i:nat{i < L.length l1}). (lock_i i l1).inv == (lock_i i l2).inv) let inames_in (e:inames) (l:lock_store) : prop = forall i. Set.mem i e ==> i < L.length l let inames_ok e m = inames_in e m.locks let inames_ok_empty m = () let extend_lock_store (e:inames) (l:lock_store{e `inames_in` l}) (p:slprop) : i:iname & l':lock_store { lock_store_invariant e l' == p `star` lock_store_invariant e l /\ iname_for_p i p l' } = (| L.length l, Invariant p :: l |) let set_add (i:iname) (s:inames) = Set.union (Set.singleton i) s let rec move_invariant (e:inames) (l:lock_store) (p:slprop) (i:iname{iname_for_p i p l /\ ~(i `Set.mem` e)}) : Lemma (H.equiv (lock_store_invariant e l) (p `star` lock_store_invariant (set_add i e) l)) = let rec aux (i:iname) (m:lock_store) : Lemma (requires i >= L.length m) (ensures (lock_store_invariant e m `H.equiv` lock_store_invariant (set_add i e) m)) = match m with | [] -> () | Invariant p::tl -> aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl) in let current_addr = L.length l - 1 in match l with | [] -> () | Invariant q::tl -> if i = current_addr then begin assert (lock_store_invariant e l == p `star` lock_store_invariant e tl); aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl); () end else begin move_invariant e tl p i; assert (lock_store_invariant e tl `equiv` (p `star` lock_store_invariant (set_add i e) tl)); H.star_congruence q (lock_store_invariant e tl) q (p `star` lock_store_invariant (set_add i e) tl); if Set.mem current_addr e then () else begin let r = lock_store_invariant (set_add i e) tl in assert (lock_store_invariant e l `equiv` (q `star` (p `star` r))); H.star_associative q p r; H.star_commutative q p; H.star_congruence (q `star` p) r (p `star` q) r; H.star_associative p q r end end let heap_ctr_valid (ctr:nat) (h:H.heap u#a) : prop = h `H.free_above_addr` ctr let ctr_validity (ctr:nat) (h:H.heap) : slprop = H.pure (heap_ctr_valid ctr h) let locks_invariant (e:inames) (m:mem u#a) : slprop u#a = lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m) let full_mem_pred (m:mem) = H.full_heap_pred (heap_of_mem m) (***** Following lemmas are needed in Steel.Effect *****) let core_mem_interp (hp:slprop u#a) (m:mem u#a) = () let interp_depends_only_on (hp:slprop u#a) = H.interp_depends_only_on hp let a_mem_prop_as_a_heap_prop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (H.a_heap_prop u#a) = let g (h: H.heap u#a) : Tot prop = interp sl (mem_of_heap h) /\ f (mem_of_heap h) in let phi0 (h0 h1: H.heap u#a) : Lemma (requires (g h0 /\ H.disjoint h0 h1)) (ensures (g h0 /\ H.disjoint h0 h1 /\ g (H.join h0 h1))) = assert (mem_of_heap (H.join h0 h1) == mem_of_heap h0 `join` mem_of_heap h1); interp_depends_only_on sl in let phi1 (h0 h1: H.heap u#a) : Lemma (ensures ((g h0 /\ H.disjoint h0 h1) ==> g (H.join h0 h1))) = Classical.move_requires (phi0 h0) h1 in Classical.forall_intro_2 phi1; g let refine_slprop sl f = H.as_slprop (a_mem_prop_as_a_heap_prop sl f) let interp_refine_slprop sl f m = assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_mem m)) let dep_hprop (s: slprop) (f: (hmem s -> Tot slprop)) (h: H.heap) : Tot prop = exists (h1: H.heap) . exists (h2: H.heap) . interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 let dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq' : squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h')) = let p2 (h h1 h2: H.heap) : Tot prop = interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 in let p1 (h h1: H.heap) : Tot prop = (exists h2 . p2 h h1 h2) in let h1 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p1 h) in let h2 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p2 h h1) in H.disjoint_join h' h1 h2; assert (H.disjoint h2 h'); let h2' = H.join h2 h' in H.join_commutative h2 h' ; assert (h2' == H.join h' h2); assert (H.disjoint h1 h2'); assert (mem_of_heap h2' == mem_of_heap h2 `join` mem_of_heap h'); interp_depends_only_on (f (mem_of_heap h1)); assert (interp (f (mem_of_heap h1)) (mem_of_heap h2')); H.join_commutative h1 h2; H.join_associative h' h2 h1; H.join_commutative h' h; H.join_commutative h2' h1; assert (H.join h h' == h1 `H.join` h2') let impl_intro_gen (#p: Type0) (#q: Type0) ($prf: (squash p -> Lemma (q ))) : Lemma (p ==> q) = Classical.impl_intro_gen #p #(fun _ -> q) prf let dep_hprop_is_affine1 (s: slprop) (f: (hmem s -> Tot slprop)) (h0 h1: H.heap) : Lemma ((dep_hprop s f h0 /\ H.disjoint h0 h1) ==> (H.disjoint h0 h1 /\ dep_hprop s f (H.join h0 h1))) = impl_intro_gen (dep_hprop_is_affine0 s f h0 h1) let dep_hprop_is_affine (s: slprop) (f: (hmem s -> Tot slprop)) : Lemma (H.heap_prop_is_affine (dep_hprop s f)) = Classical.forall_intro_2 (dep_hprop_is_affine1 s f) let sdep (s: slprop) (f: (hmem s -> Tot slprop)) : Tot slprop = dep_hprop_is_affine s f; H.as_slprop (dep_hprop s f) let interp_sdep (s: slprop) (f: (hmem s -> Tot slprop)) (m: mem) : Lemma (requires (dep_slprop_is_affine s f)) (ensures ( interp (sdep s f) m <==> (exists m1 m2 . interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) )) = dep_hprop_is_affine s f; assert (forall m1 m2 . (interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) ==> ( interp s (mem_of_heap m1.heap) /\ interp (f (mem_of_heap m1.heap)) (mem_of_heap m2.heap) /\ H.disjoint m1.heap m2.heap /\ H.join m1.heap m2.heap == m.heap )); interp_depends_only_on s; Classical.forall_intro (fun m -> interp_depends_only_on (f m)); assert (forall h1 h2 . (interp s (mem_of_heap h1) /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ H.disjoint h1 h2 /\ H.join h1 h2 == m.heap) ==> ( core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ interp s (core_mem (mem_of_heap h1)) /\ interp s (mem_set_heap m h1) /\ core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ f (mem_set_heap m h1) `equiv` f (mem_of_heap h1) /\ interp (f (mem_set_heap m h1)) (mem_of_heap h2) /\ interp (f (mem_set_heap m h1)) (mem_set_heap m h2) /\ disjoint (mem_set_heap m h1) (mem_set_heap m h2) /\ join (mem_set_heap m h1) (mem_set_heap m h2) == m )); () let h_exists_cong (#a:Type) (p q : a -> slprop) : Lemma (requires (forall x. p x `equiv` q x)) (ensures (h_exists p `equiv` h_exists q)) = equiv_heap_iff_equiv_forall (); H.h_exists_cong p q let intro_h_exists #a x p m = H.intro_h_exists x p (heap_of_mem m) let elim_h_exists (#a:_) (p:a -> slprop) (m:mem) = H.elim_h_exists p (heap_of_mem m) let intro_h_forall (#a:_) (p:a -> slprop) (m:mem) = H.intro_h_forall p (heap_of_mem m) let elim_h_forall (#a:_) (p:a -> slprop) (m:mem) (x:a) = H.elim_h_forall p (heap_of_mem m) x let intro_h_and (p q: slprop) (m:mem) = H.intro_h_and p q (heap_of_mem m) let elim_h_and (p q: slprop) (m:mem) = H.elim_h_and p q (heap_of_mem m) let intro_h_or_left (p q: slprop) (m:mem) = H.intro_h_or_left p q (heap_of_mem m) let intro_h_or_right (p q: slprop) (m:mem) = H.intro_h_or_right p q (heap_of_mem m) let elim_h_or (p q: slprop) (m:mem) = H.elim_h_or p q (heap_of_mem m) let intro_wand (p1 p2: slprop u#a) (m:mem) = introduce (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)) ==> interp (wand p1 p2) m with _. ( assert (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)); H.intro_wand p1 p2 (heap_of_mem m); let h = heap_of_mem m in assert ((forall h1. h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) ==> H.interp (wand p1 p2) h); introduce forall h1. (h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) with ( introduce (h `H.disjoint` h1 /\ H.interp p1 h1) ==> H.interp p2 (H.join h h1) with _. ( assert (h `H.disjoint` h1); let m1 = { ctr = m.ctr; heap = h1; locks = m.locks } in assert (m `disjoint` m1) ) ) ) (** Eliminating a wand by proving a heap that satisfies the LHS **) let elim_wand (p1 p2: slprop u#a) (m:mem) (m1:mem) = H.elim_wand p1 p2 (heap_of_mem m) (heap_of_mem m1) //////////////////////////////////////////////////////////////////////////////// // Preorders and effects //////////////////////////////////////////////////////////////////////////////// module PP = Steel.Preorder let mem_evolves = fun (m0 m1:full_mem) -> H.heap_evolves (heap_of_mem m0) (heap_of_mem m1) /\ m0.ctr <= m1.ctr /\ lock_store_evolves m0.locks m1.locks (** See [Steel.Heap.is_frame_preserving]. We add in [lock_invariants] now *) let preserves_frame (e:inames) (pre post:slprop) (m0 m1:mem) = forall (frame:slprop). interp ((pre `star` frame) `star` locks_invariant e m0) m0 ==> (interp ((post `star` frame) `star` locks_invariant e m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) (** This is a version of MstTot with frame quantified, as part of preserves_frame *) effect MstTotNF (a:Type u#a) (except:inames) (expects:slprop u#1) (provides: a -> slprop u#1) = NMSTTotal.NMSTATETOT a (full_mem u#1) mem_evolves (requires fun m0 -> inames_ok except m0 /\ interp (expects `star` locks_invariant except m0) m0) (ensures fun m0 x m1 -> inames_ok except m1 /\ interp (provides x `star` locks_invariant except m1) m1 /\ preserves_frame except expects (provides x) m0 m1) //////////////////////////////////////////////////////////////////////////////// // Lifting heap actions //////////////////////////////////////////////////////////////////////////////// (** Heap actions come in two equivalent flavors: - one that take an explicit frame as argument (action_with_frame) - and one that quantify over all the frame We therefore define two lift routes: - a direct route for those with explicit frame - via MstTotNF for the rest *) let tot_pre_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = hmem_with_inv_except e fp -> (x:a & hmem_with_inv_except e (fp' x)) let tot_pre_action_nf = tot_pre_action_nf_except S.empty let ac_reasoning_for_m_frame_preserving (p q r:slprop u#a) (m:mem u#a) : Lemma (requires interp ((p `star` q) `star` r) m) (ensures interp (p `star` r) m) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_commutative p q; equiv_extensional_on_star (p `star` q) (q `star` p) r } (q `star` p) `star` r; (equiv) { star_associative q p r } q `star` (p `star` r); }; assert (interp (q `star` (p `star` r)) m); affine_star q (p `star` r) m let is_frame_preserving (#e:inames) (#a:Type u#b) (#fp:slprop u#a) (#fp':a -> slprop u#a) (f:tot_pre_action_nf_except e fp a fp') = forall (frame:slprop u#a) (m0:hmem_with_inv_except e (fp `star` frame)). (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = f:tot_pre_action_nf_except e fp a fp'{ is_frame_preserving f } let tot_action_nf = tot_action_nf_except S.empty let linv e (m:mem) = locks_invariant e m let hheap_of_hmem #fp #e (m:hmem_with_inv_except e fp) : h:H.hheap (fp `star` linv e m) { h `H.free_above_addr` m.ctr} = let h = heap_of_mem m in H.pure_interp (heap_ctr_valid m.ctr (heap_of_mem m)) h; h let hmem_of_hheap #e (#fp0 #fp1:slprop) (m:hmem_with_inv_except e fp0) (h:H.full_hheap (fp1 `star` linv e m) { h `Heap.free_above_addr` m.ctr }) : m1:hmem_with_inv_except e fp1{linv e m `equiv` linv e m1} = let m1 : mem = { m with heap = h } in assert (interp (fp1 `star` linv e m) m1); star_commutative fp1 (linv e m); assert (interp (linv e m `star` fp1) m1); assert (linv e m1 == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); assert (linv e m == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m)); H.pure_interp (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_of_mem m); assert (heap_ctr_valid m1.ctr (heap_of_mem m) <==> heap_ctr_valid m1.ctr (heap_of_mem m1)); H.pure_equiv (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_ctr_valid m1.ctr (heap_of_mem m1)); H.star_congruence (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m)); assert (linv e m `equiv` linv e m1); let _ = equiv_extensional_on_star (linv e m) (linv e m1) fp1 in assert ((linv e m `star` fp1) `equiv` (linv e m1 `star` fp1)); assert (interp (linv e m1 `star` fp1) m1); star_commutative (linv e m1) fp1; assert (interp (fp1 `star` linv e m1) m1); m1 let with_inv_except (m:mem) e (fp:slprop) = interp (fp `star` locks_invariant e m) m #push-options "--warn_error -271" let as_hprop (frame:slprop) (mp:mprop frame) : hp:H.hprop frame{forall m. mp (core_mem m) == hp (heap_of_mem m)} = let f = fun h -> mp (mem_of_heap h) in assert (forall m. mp (core_mem m) == f (heap_of_mem m)); let aux (m0:H.hheap frame) (m1:H.heap{H.disjoint m0 m1}) : Lemma (ensures (mem_of_heap (H.join m0 m1) == join (mem_of_heap m0) (mem_of_heap m1))) [SMTPat ()] = () in f let mprop_preservation_of_hprop_preservation (p:slprop) (m0 m1:mem) : Lemma (requires (forall (hp:H.hprop p). hp (heap_of_mem m0) == hp (heap_of_mem m1))) (ensures (forall (mp:mprop p). mp (core_mem m0) == mp (core_mem m1))) = let aux (mp:mprop p) : Lemma (mp (core_mem m0) == mp (core_mem m1)) [SMTPat()] = assert (as_hprop p mp (heap_of_mem m0) == as_hprop p mp (heap_of_mem m1)) in () let lift_heap_action (#fp:slprop) (#a:Type) (#fp':a -> slprop) (e:inames) ($f:H.action fp a fp') : tot_action_nf_except e fp a fp' = let g : tot_pre_action_nf_except e fp a fp' = fun m -> let h0 = hheap_of_hmem m in let (| x, h' |) = f h0 in (| x, hmem_of_hheap m h' |) in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in let h0 = hheap_of_hmem m0 in let (| x', h1 |) = f h0 in H.action_framing f (linv e m0) h0; assert (x == x'); star_associative fp frame (linv e m0); H.action_framing f (frame `star` linv e m0) h0; assert (H.interp ((fp' x) `star` (frame `star` linv e m0)) h1); star_associative (fp' x) frame (linv e m0); assert (H.interp ((fp' x `star` frame) `star` linv e m0) h1); let h1' : H.hheap ((fp' x `star` frame) `star` linv e m0) = h1 in assert (m1 == hmem_of_hheap m0 h1'); assert (with_inv_except m1 e (fp' x `star` frame)); assert (forall (hp:H.hprop frame). hp h0 == hp h1); mprop_preservation_of_hprop_preservation frame m0 m1; () in assert (is_frame_preserving g); g let frame_preserving_respects_preorder #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (m0:hmem_with_inv_except e fp) : Lemma (let (| x, m1 |) = f m0 in mem_evolves m0 m1) = let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1) = () in H.emp_unit fp; assert (interp (fp `star` linv e m0) m0); H.star_congruence (fp `star` emp) (linv e m0) fp (linv e m0); assert (interp ((fp `star` emp) `star` linv e m0) m0); aux emp m0 let lift_tot_action_nf #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') : MstTotNF a e fp fp' = let m0 = NMSTTotal.get () in let m0' : hmem_with_inv_except e fp = m0 in let r = f m0' in let (| x, m1 |) = r in let m1' : hmem_with_inv_except e (fp' x) = m1 in assert (is_frame_preserving f); assert (m1 == dsnd (f m0)); frame_preserving_respects_preorder f m0; NMSTTotal.put #_ #(mem_evolves) m1; x let lift_tot_action #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get #(full_mem) #_ () in ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); lift_tot_action_nf f (** Now defining the lift for heap actions with explicit frame *) let tot_action_with_frame_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = frame:slprop u#a -> m0:hmem_with_inv_except e (fp `star` frame) -> Pure (x:a & hmem_with_inv_except e (fp' x `star` frame)) (requires True) (ensures fun (| x, m1 |) -> mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_with_frame = tot_action_with_frame_except S.empty let lift_heap_action_with_frame (#fp:slprop u#a) (#a:Type u#b) (#fp':a -> slprop u#a) (e:inames) ($f:H.action_with_frame fp a fp') : tot_action_with_frame_except e fp a fp' = fun frame m0 -> let h0 = hheap_of_hmem m0 in calc (equiv) { fp `star` frame `star` locks_invariant e m0; (equiv) { star_associative fp frame (locks_invariant e m0) } fp `star` (frame `star` locks_invariant e m0); }; assert (H.interp (fp `star` frame `star` locks_invariant e m0) h0); assert (H.interp (fp `star` (frame `star` locks_invariant e m0)) h0); //key: apply the heap action with frame * locks_invariant e m0 let (| x, h1 |) = f (frame `star` locks_invariant e m0) h0 in calc (equiv) { fp' x `star` (frame `star` locks_invariant e m0); (equiv) { star_associative (fp' x) frame (locks_invariant e m0) } fp' x `star` frame `star` locks_invariant e m0; }; assert (H.interp (fp' x `star` (frame `star` locks_invariant e m0)) h1); assert (H.interp (fp' x `star` frame `star` locks_invariant e m0) h1); let m1 = hmem_of_hheap m0 h1 in assert (mem_evolves m0 m1); mprop_preservation_of_hprop_preservation (frame `star` locks_invariant e m0) m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)); (| x, m1 |) let lift_tot_action_with_frame #a #e #fp #fp' ($f:tot_action_with_frame_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in assert (inames_ok e m0); ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); let m0' : hmem_with_inv_except e fp = m0 in let r = f frame m0' in let (| x, m1 |) = r in ac_reasoning_for_m_frame_preserving (fp' x) frame (locks_invariant e m1) m1; assert (interp (fp' x `star` frame `star` locks_invariant e m1) m1); assert (interp (fp' x `star` locks_invariant e m1) m1); let m1' : hmem_with_inv_except e (fp' x) = m1 in NMSTTotal.put #_ #(mem_evolves) m1; x let sel_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.sel_action #a #pcm r v0)) let upd_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.upd_action #a #pcm r v0 v1)) let free_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.free_action #a #pcm r v0)) let split_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.split_action #a #pcm r v0 v1)) let gather_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.gather_action #a #pcm r v0 v1)) let weaken (p q r:slprop) (h:H.hheap (p `star` q) { H.stronger q r }) : H.hheap (p `star` r) = H.weaken p q r h; h let weaken_pure (q r: prop) : Lemma (requires (q ==> r)) (ensures H.stronger (H.pure q) (H.pure r)) = let aux (h:H.heap) : Lemma (ensures (H.interp (H.pure q) h ==> H.interp (H.pure r) h)) [SMTPat ()] = H.pure_interp q h; H.pure_interp r h in () let inc_ctr (#p:slprop) #e (m:hmem_with_inv_except e p) : m':hmem_with_inv_except e p{m'.ctr = m.ctr + 1 /\ H.stronger (linv e m) (linv e m')} = let m' : mem = { m with ctr = m.ctr + 1} in assert (interp (p `star` linv e m) m'); assert (linv e m == lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m)); assert (linv e m' == lock_store_invariant e m.locks `star` ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken_free_above (heap_of_mem m) m.ctr (m.ctr + 1); weaken_pure (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_ctr_valid (m.ctr + 1) (heap_of_mem m)); assert (H.stronger (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m))); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)); H.stronger_star (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken (p `star` lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)) (heap_of_mem m'); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity (m.ctr + 1) (heap_of_mem m)); let m' : hmem_with_inv_except e p = m' in m' let frame_related_mems (fp0 fp1:slprop u#a) e (m0:hmem_with_inv_except e fp0) (m1:hmem_with_inv_except e fp1) = forall (frame:slprop u#a). interp ((fp0 `star` frame) `star` linv e m0) m0 ==> interp ((fp1 `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) let refined_pre_action e (fp0:slprop) (a:Type) (fp1:a -> slprop) = m0:hmem_with_inv_except e fp0 -> Pure (x:a & hmem_with_inv_except e (fp1 x)) (requires True) (ensures fun (| x, m1 |) -> frame_related_mems fp0 (fp1 x) e m0 m1)

{ "checked_file": "/", "dependencies": [ "Steel.Preorder.fst.checked", "Steel.Heap.fsti.checked", "prims.fst.checked", "FStar.Witnessed.Core.fsti.checked", "FStar.Set.fsti.checked", "FStar.Preorder.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.PCM.fst.checked", "FStar.NMSTTotal.fst.checked", "FStar.List.Tot.fst.checked", "FStar.IndefiniteDescription.fsti.checked", "FStar.Ghost.fsti.checked", "FStar.FunctionalExtensionality.fsti.checked", "FStar.Classical.Sugar.fsti.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Steel.Memory.fst" }

[ { "abbrev": true, "full_module": "Steel.Preorder", "short_module": "PP" }, { "abbrev": true, "full_module": "FStar.Witnessed.Core", "short_module": "W" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": true, "full_module": "Steel.Heap", "short_module": "H" }, { "abbrev": false, "full_module": "FStar.PCM", "short_module": null }, { "abbrev": false, "full_module": "FStar.FunctionalExtensionality", "short_module": null }, { "abbrev": true, "full_module": "FStar.FunctionalExtensionality", "short_module": "F" }, { "abbrev": false, "full_module": "FStar.PCM", "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

$f: Steel.Memory.refined_pre_action e fp0 a fp1 -> Steel.Memory.tot_action_nf_except e fp0 a fp1

Prims.Tot

[ "total" ]

[]

[ "Steel.Memory.slprop", "Steel.Memory.inames", "Steel.Memory.refined_pre_action", "Steel.Memory.hmem_with_inv_except", "Steel.Memory.star", "Prims.unit", "Prims.l_True", "Prims.squash", "Prims.l_and", "Steel.Memory.interp", "Steel.Memory.locks_invariant", "Steel.Memory.mem_evolves", "Prims.l_Forall", "Steel.Memory.mprop", "Prims.eq2", "Prims.prop", "Steel.Memory.core_mem", "Prims.Cons", "FStar.Pervasives.pattern", "FStar.Pervasives.smt_pat", "Prims.Nil", "Prims._assert", "Steel.Memory.full_mem", "Prims.l_or", "Steel.Memory.inames_ok", "Prims.dtuple2", "Steel.Memory.ac_reasoning_for_m_frame_preserving", "Steel.Memory.tot_pre_action_nf_except", "Steel.Memory.tot_action_nf_except" ]

[]

false

let refined_pre_action_as_action (#fp0: slprop) (#a: Type) (#fp1: (a -> slprop)) #e ($f: refined_pre_action e fp0 a fp1) : tot_action_nf_except e fp0 a fp1 =

let g:tot_pre_action_nf_except e fp0 a fp1 = fun m -> f m in let aux (frame: slprop) (m0: hmem_with_inv_except e (fp0 `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x , m1 |) = g m0 in interp (((fp1 x) `star` frame) `star` (locks_invariant e m1)) m1 /\ mem_evolves m0 m1 /\ (forall (mp: mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x' , m1' |) = g m0 in let (| x , m1 |) = f m0 in assert (x == x' /\ m1 == m1') in g

false

Steel.Memory.fst

Steel.Memory.inc_ctr

val inc_ctr (#p: slprop) (#e: _) (m: hmem_with_inv_except e p) : m': hmem_with_inv_except e p {m'.ctr = m.ctr + 1 /\ H.stronger (linv e m) (linv e m')}

let inc_ctr (#p:slprop) #e (m:hmem_with_inv_except e p) : m':hmem_with_inv_except e p{m'.ctr = m.ctr + 1 /\ H.stronger (linv e m) (linv e m')} = let m' : mem = { m with ctr = m.ctr + 1} in assert (interp (p `star` linv e m) m'); assert (linv e m == lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m)); assert (linv e m' == lock_store_invariant e m.locks `star` ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken_free_above (heap_of_mem m) m.ctr (m.ctr + 1); weaken_pure (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_ctr_valid (m.ctr + 1) (heap_of_mem m)); assert (H.stronger (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m))); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)); H.stronger_star (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken (p `star` lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)) (heap_of_mem m'); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity (m.ctr + 1) (heap_of_mem m)); let m' : hmem_with_inv_except e p = m' in m'

{ "file_name": "lib/steel/Steel.Memory.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 6, "end_line": 902, "start_col": 0, "start_line": 874 }

(* 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.Memory module F = FStar.FunctionalExtensionality open FStar.FunctionalExtensionality open FStar.PCM module H = Steel.Heap noeq type lock_state : Type u#(a + 1) = | Invariant : inv:H.slprop u#a -> lock_state let lock_store : Type u#(a+1) = list (lock_state u#a) noeq type mem : Type u#(a + 1) = { ctr: nat; heap: H.heap u#a; locks: lock_store u#a; } let heap_of_mem (x:mem) : H.heap = x.heap let mem_of_heap (h:H.heap) : mem = { ctr = 0; heap = h; locks = [] } let mem_set_heap (m:mem) (h:H.heap) : mem = { ctr = m.ctr; heap = h; locks = m.locks; } let core_mem (m:mem) : mem = mem_of_heap (heap_of_mem m) let core_mem_invol m = () let disjoint (m0 m1:mem u#h) : prop = m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks let disjoint_sym m0 m1 = () let join m0 m1 = { ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = m0.locks } let join_commutative m0 m1 = H.join_commutative m0.heap m1.heap let disjoint_join m0 m1 m2 = H.disjoint_join m0.heap m1.heap m2.heap let join_associative m0 m1 m2 = H.join_associative m0.heap m1.heap m2.heap let slprop = H.slprop let interp p m = H.interp p m.heap let equiv p1 p2 = forall m. interp p1 m <==> interp p2 m let slprop_extensionality p q = assert (forall m. interp p m <==> interp q m); let aux (h:H.heap) : Lemma (H.interp p h <==> H.interp q h) [SMTPat (H.interp p h)] = let m : mem = { ctr = 0; heap = h; locks = [] } in assert (interp p m <==> interp q m) in assert (forall h. H.interp p h <==> H.interp q h); Steel.Heap.slprop_extensionality p q let reveal_equiv p1 p2 = () let core_ref = H.core_ref let core_ref_null = H.core_ref_null let core_ref_is_null r = H.core_ref_is_null r let emp : slprop u#a = H.emp let pure = H.pure let pts_to = H.pts_to let h_and = H.h_and let h_or = H.h_or let star = H.star let wand = H.wand let h_exists = H.h_exists let h_forall = H.h_forall //////////////////////////////////////////////////////////////////////////////// //properties of equiv //////////////////////////////////////////////////////////////////////////////// let equiv_symmetric (p1 p2:slprop u#a) = H.equiv_symmetric p1 p2 #push-options "--warn_error -271" let equiv_heap_iff_equiv (p1 p2:slprop u#a) : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat (equiv p1 p2)] = let aux_lr () : Lemma (requires H.equiv p1 p2) (ensures equiv p1 p2) [SMTPat ()] = () in let aux_rl_helper1 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p1 h) (ensures H.interp p2 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl_helper2 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p2 h) (ensures H.interp p1 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl () : Lemma (requires equiv p1 p2) (ensures H.equiv p1 p2) [SMTPat ()] = () in () let equiv_heap_iff_equiv_forall () : Lemma (ensures (forall p1 p2. H.equiv p1 p2 <==> equiv p1 p2)) = let aux p1 p2 : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat ()] = equiv_heap_iff_equiv p1 p2 in () #pop-options let equiv_extensional_on_star (p1 p2 p3:slprop u#a) = equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3 let emp_unit p = H.emp_unit p let intro_emp m = H.intro_emp (heap_of_mem m) let pure_equiv p q = H.pure_equiv p q let pure_interp q m = H.pure_interp q (heap_of_mem m) let pure_star_interp p q m = H.pure_star_interp p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// //pts_to //////////////////////////////////////////////////////////////////////////////// let pts_to_compatible #a #pcm x v0 v1 m = H.pts_to_compatible #a #pcm x v0 v1 (heap_of_mem m) let pts_to_compatible_equiv #a #pcm x v0 v1 = H.pts_to_compatible_equiv #a #pcm x v0 v1 let pts_to_not_null #a #pcm x v m = H.pts_to_not_null #a #pcm x v (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // star //////////////////////////////////////////////////////////////////////////////// let intro_star p q mp mq = H.intro_star p q (heap_of_mem mp) (heap_of_mem mq) let elim_star p q m = let h = heap_of_mem m in H.elim_star p q h; assert (exists hl hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr); let hl = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hl -> exists hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let hr = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hr -> H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let ml = mem_set_heap m hl in let mr = mem_set_heap m hr in assert (disjoint ml mr); assert (m == join ml mr); assert (interp p ml); assert (interp q mr); () let interp_star (p q: slprop) (m: mem) : Lemma (interp (p `star` q) m <==> (exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m)) = let left = interp (p `star` q) m in let right = exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m in let f () : Lemma (requires left) (ensures right) = elim_star p q m in let g () : Lemma (requires right) (ensures left) = Classical.exists_elim left #_ #(fun mp -> exists (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mp -> Classical.exists_elim left #_ #(fun mq -> disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mq -> intro_star p q mp mq ) ) in Classical.move_requires f (); Classical.move_requires g () let star_commutative (p1 p2:slprop) = H.star_commutative p1 p2 let star_associative (p1 p2 p3:slprop) = H.star_associative p1 p2 p3 let star_congruence (p1 p2 p3 p4:slprop) = equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4 let affine_star (p q:slprop) (m:mem) = H.affine_star p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // Invariants on the lock store //////////////////////////////////////////////////////////////////////////////// let iname = nat module S = FStar.Set module L = FStar.List.Tot module W = FStar.Witnessed.Core let rec lock_store_invariant (e:inames) (l:lock_store u#a) : slprop u#a = let current_addr = L.length l - 1 in match l with | [] -> emp | Invariant p :: tl -> if current_addr `S.mem` e then lock_store_invariant e tl else p `star` lock_store_invariant e tl let lock_i (i:iname) (l:lock_store { i < L.length l }) = let ix = L.length l - i - 1 in L.index l ix let iname_for_p (i:iname) (p:slprop) : W.s_predicate lock_store = fun l -> i < L.length l /\ (lock_i i l).inv == p let lock_store_evolves : FStar.Preorder.preorder lock_store = fun (l1 l2 : lock_store) -> L.length l2 >= L.length l1 /\ (forall (i:nat{i < L.length l1}). (lock_i i l1).inv == (lock_i i l2).inv) let inames_in (e:inames) (l:lock_store) : prop = forall i. Set.mem i e ==> i < L.length l let inames_ok e m = inames_in e m.locks let inames_ok_empty m = () let extend_lock_store (e:inames) (l:lock_store{e `inames_in` l}) (p:slprop) : i:iname & l':lock_store { lock_store_invariant e l' == p `star` lock_store_invariant e l /\ iname_for_p i p l' } = (| L.length l, Invariant p :: l |) let set_add (i:iname) (s:inames) = Set.union (Set.singleton i) s let rec move_invariant (e:inames) (l:lock_store) (p:slprop) (i:iname{iname_for_p i p l /\ ~(i `Set.mem` e)}) : Lemma (H.equiv (lock_store_invariant e l) (p `star` lock_store_invariant (set_add i e) l)) = let rec aux (i:iname) (m:lock_store) : Lemma (requires i >= L.length m) (ensures (lock_store_invariant e m `H.equiv` lock_store_invariant (set_add i e) m)) = match m with | [] -> () | Invariant p::tl -> aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl) in let current_addr = L.length l - 1 in match l with | [] -> () | Invariant q::tl -> if i = current_addr then begin assert (lock_store_invariant e l == p `star` lock_store_invariant e tl); aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl); () end else begin move_invariant e tl p i; assert (lock_store_invariant e tl `equiv` (p `star` lock_store_invariant (set_add i e) tl)); H.star_congruence q (lock_store_invariant e tl) q (p `star` lock_store_invariant (set_add i e) tl); if Set.mem current_addr e then () else begin let r = lock_store_invariant (set_add i e) tl in assert (lock_store_invariant e l `equiv` (q `star` (p `star` r))); H.star_associative q p r; H.star_commutative q p; H.star_congruence (q `star` p) r (p `star` q) r; H.star_associative p q r end end let heap_ctr_valid (ctr:nat) (h:H.heap u#a) : prop = h `H.free_above_addr` ctr let ctr_validity (ctr:nat) (h:H.heap) : slprop = H.pure (heap_ctr_valid ctr h) let locks_invariant (e:inames) (m:mem u#a) : slprop u#a = lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m) let full_mem_pred (m:mem) = H.full_heap_pred (heap_of_mem m) (***** Following lemmas are needed in Steel.Effect *****) let core_mem_interp (hp:slprop u#a) (m:mem u#a) = () let interp_depends_only_on (hp:slprop u#a) = H.interp_depends_only_on hp let a_mem_prop_as_a_heap_prop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (H.a_heap_prop u#a) = let g (h: H.heap u#a) : Tot prop = interp sl (mem_of_heap h) /\ f (mem_of_heap h) in let phi0 (h0 h1: H.heap u#a) : Lemma (requires (g h0 /\ H.disjoint h0 h1)) (ensures (g h0 /\ H.disjoint h0 h1 /\ g (H.join h0 h1))) = assert (mem_of_heap (H.join h0 h1) == mem_of_heap h0 `join` mem_of_heap h1); interp_depends_only_on sl in let phi1 (h0 h1: H.heap u#a) : Lemma (ensures ((g h0 /\ H.disjoint h0 h1) ==> g (H.join h0 h1))) = Classical.move_requires (phi0 h0) h1 in Classical.forall_intro_2 phi1; g let refine_slprop sl f = H.as_slprop (a_mem_prop_as_a_heap_prop sl f) let interp_refine_slprop sl f m = assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_mem m)) let dep_hprop (s: slprop) (f: (hmem s -> Tot slprop)) (h: H.heap) : Tot prop = exists (h1: H.heap) . exists (h2: H.heap) . interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 let dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq' : squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h')) = let p2 (h h1 h2: H.heap) : Tot prop = interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 in let p1 (h h1: H.heap) : Tot prop = (exists h2 . p2 h h1 h2) in let h1 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p1 h) in let h2 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p2 h h1) in H.disjoint_join h' h1 h2; assert (H.disjoint h2 h'); let h2' = H.join h2 h' in H.join_commutative h2 h' ; assert (h2' == H.join h' h2); assert (H.disjoint h1 h2'); assert (mem_of_heap h2' == mem_of_heap h2 `join` mem_of_heap h'); interp_depends_only_on (f (mem_of_heap h1)); assert (interp (f (mem_of_heap h1)) (mem_of_heap h2')); H.join_commutative h1 h2; H.join_associative h' h2 h1; H.join_commutative h' h; H.join_commutative h2' h1; assert (H.join h h' == h1 `H.join` h2') let impl_intro_gen (#p: Type0) (#q: Type0) ($prf: (squash p -> Lemma (q ))) : Lemma (p ==> q) = Classical.impl_intro_gen #p #(fun _ -> q) prf let dep_hprop_is_affine1 (s: slprop) (f: (hmem s -> Tot slprop)) (h0 h1: H.heap) : Lemma ((dep_hprop s f h0 /\ H.disjoint h0 h1) ==> (H.disjoint h0 h1 /\ dep_hprop s f (H.join h0 h1))) = impl_intro_gen (dep_hprop_is_affine0 s f h0 h1) let dep_hprop_is_affine (s: slprop) (f: (hmem s -> Tot slprop)) : Lemma (H.heap_prop_is_affine (dep_hprop s f)) = Classical.forall_intro_2 (dep_hprop_is_affine1 s f) let sdep (s: slprop) (f: (hmem s -> Tot slprop)) : Tot slprop = dep_hprop_is_affine s f; H.as_slprop (dep_hprop s f) let interp_sdep (s: slprop) (f: (hmem s -> Tot slprop)) (m: mem) : Lemma (requires (dep_slprop_is_affine s f)) (ensures ( interp (sdep s f) m <==> (exists m1 m2 . interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) )) = dep_hprop_is_affine s f; assert (forall m1 m2 . (interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) ==> ( interp s (mem_of_heap m1.heap) /\ interp (f (mem_of_heap m1.heap)) (mem_of_heap m2.heap) /\ H.disjoint m1.heap m2.heap /\ H.join m1.heap m2.heap == m.heap )); interp_depends_only_on s; Classical.forall_intro (fun m -> interp_depends_only_on (f m)); assert (forall h1 h2 . (interp s (mem_of_heap h1) /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ H.disjoint h1 h2 /\ H.join h1 h2 == m.heap) ==> ( core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ interp s (core_mem (mem_of_heap h1)) /\ interp s (mem_set_heap m h1) /\ core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ f (mem_set_heap m h1) `equiv` f (mem_of_heap h1) /\ interp (f (mem_set_heap m h1)) (mem_of_heap h2) /\ interp (f (mem_set_heap m h1)) (mem_set_heap m h2) /\ disjoint (mem_set_heap m h1) (mem_set_heap m h2) /\ join (mem_set_heap m h1) (mem_set_heap m h2) == m )); () let h_exists_cong (#a:Type) (p q : a -> slprop) : Lemma (requires (forall x. p x `equiv` q x)) (ensures (h_exists p `equiv` h_exists q)) = equiv_heap_iff_equiv_forall (); H.h_exists_cong p q let intro_h_exists #a x p m = H.intro_h_exists x p (heap_of_mem m) let elim_h_exists (#a:_) (p:a -> slprop) (m:mem) = H.elim_h_exists p (heap_of_mem m) let intro_h_forall (#a:_) (p:a -> slprop) (m:mem) = H.intro_h_forall p (heap_of_mem m) let elim_h_forall (#a:_) (p:a -> slprop) (m:mem) (x:a) = H.elim_h_forall p (heap_of_mem m) x let intro_h_and (p q: slprop) (m:mem) = H.intro_h_and p q (heap_of_mem m) let elim_h_and (p q: slprop) (m:mem) = H.elim_h_and p q (heap_of_mem m) let intro_h_or_left (p q: slprop) (m:mem) = H.intro_h_or_left p q (heap_of_mem m) let intro_h_or_right (p q: slprop) (m:mem) = H.intro_h_or_right p q (heap_of_mem m) let elim_h_or (p q: slprop) (m:mem) = H.elim_h_or p q (heap_of_mem m) let intro_wand (p1 p2: slprop u#a) (m:mem) = introduce (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)) ==> interp (wand p1 p2) m with _. ( assert (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)); H.intro_wand p1 p2 (heap_of_mem m); let h = heap_of_mem m in assert ((forall h1. h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) ==> H.interp (wand p1 p2) h); introduce forall h1. (h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) with ( introduce (h `H.disjoint` h1 /\ H.interp p1 h1) ==> H.interp p2 (H.join h h1) with _. ( assert (h `H.disjoint` h1); let m1 = { ctr = m.ctr; heap = h1; locks = m.locks } in assert (m `disjoint` m1) ) ) ) (** Eliminating a wand by proving a heap that satisfies the LHS **) let elim_wand (p1 p2: slprop u#a) (m:mem) (m1:mem) = H.elim_wand p1 p2 (heap_of_mem m) (heap_of_mem m1) //////////////////////////////////////////////////////////////////////////////// // Preorders and effects //////////////////////////////////////////////////////////////////////////////// module PP = Steel.Preorder let mem_evolves = fun (m0 m1:full_mem) -> H.heap_evolves (heap_of_mem m0) (heap_of_mem m1) /\ m0.ctr <= m1.ctr /\ lock_store_evolves m0.locks m1.locks (** See [Steel.Heap.is_frame_preserving]. We add in [lock_invariants] now *) let preserves_frame (e:inames) (pre post:slprop) (m0 m1:mem) = forall (frame:slprop). interp ((pre `star` frame) `star` locks_invariant e m0) m0 ==> (interp ((post `star` frame) `star` locks_invariant e m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) (** This is a version of MstTot with frame quantified, as part of preserves_frame *) effect MstTotNF (a:Type u#a) (except:inames) (expects:slprop u#1) (provides: a -> slprop u#1) = NMSTTotal.NMSTATETOT a (full_mem u#1) mem_evolves (requires fun m0 -> inames_ok except m0 /\ interp (expects `star` locks_invariant except m0) m0) (ensures fun m0 x m1 -> inames_ok except m1 /\ interp (provides x `star` locks_invariant except m1) m1 /\ preserves_frame except expects (provides x) m0 m1) //////////////////////////////////////////////////////////////////////////////// // Lifting heap actions //////////////////////////////////////////////////////////////////////////////// (** Heap actions come in two equivalent flavors: - one that take an explicit frame as argument (action_with_frame) - and one that quantify over all the frame We therefore define two lift routes: - a direct route for those with explicit frame - via MstTotNF for the rest *) let tot_pre_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = hmem_with_inv_except e fp -> (x:a & hmem_with_inv_except e (fp' x)) let tot_pre_action_nf = tot_pre_action_nf_except S.empty let ac_reasoning_for_m_frame_preserving (p q r:slprop u#a) (m:mem u#a) : Lemma (requires interp ((p `star` q) `star` r) m) (ensures interp (p `star` r) m) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_commutative p q; equiv_extensional_on_star (p `star` q) (q `star` p) r } (q `star` p) `star` r; (equiv) { star_associative q p r } q `star` (p `star` r); }; assert (interp (q `star` (p `star` r)) m); affine_star q (p `star` r) m let is_frame_preserving (#e:inames) (#a:Type u#b) (#fp:slprop u#a) (#fp':a -> slprop u#a) (f:tot_pre_action_nf_except e fp a fp') = forall (frame:slprop u#a) (m0:hmem_with_inv_except e (fp `star` frame)). (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = f:tot_pre_action_nf_except e fp a fp'{ is_frame_preserving f } let tot_action_nf = tot_action_nf_except S.empty let linv e (m:mem) = locks_invariant e m let hheap_of_hmem #fp #e (m:hmem_with_inv_except e fp) : h:H.hheap (fp `star` linv e m) { h `H.free_above_addr` m.ctr} = let h = heap_of_mem m in H.pure_interp (heap_ctr_valid m.ctr (heap_of_mem m)) h; h let hmem_of_hheap #e (#fp0 #fp1:slprop) (m:hmem_with_inv_except e fp0) (h:H.full_hheap (fp1 `star` linv e m) { h `Heap.free_above_addr` m.ctr }) : m1:hmem_with_inv_except e fp1{linv e m `equiv` linv e m1} = let m1 : mem = { m with heap = h } in assert (interp (fp1 `star` linv e m) m1); star_commutative fp1 (linv e m); assert (interp (linv e m `star` fp1) m1); assert (linv e m1 == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); assert (linv e m == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m)); H.pure_interp (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_of_mem m); assert (heap_ctr_valid m1.ctr (heap_of_mem m) <==> heap_ctr_valid m1.ctr (heap_of_mem m1)); H.pure_equiv (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_ctr_valid m1.ctr (heap_of_mem m1)); H.star_congruence (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m)); assert (linv e m `equiv` linv e m1); let _ = equiv_extensional_on_star (linv e m) (linv e m1) fp1 in assert ((linv e m `star` fp1) `equiv` (linv e m1 `star` fp1)); assert (interp (linv e m1 `star` fp1) m1); star_commutative (linv e m1) fp1; assert (interp (fp1 `star` linv e m1) m1); m1 let with_inv_except (m:mem) e (fp:slprop) = interp (fp `star` locks_invariant e m) m #push-options "--warn_error -271" let as_hprop (frame:slprop) (mp:mprop frame) : hp:H.hprop frame{forall m. mp (core_mem m) == hp (heap_of_mem m)} = let f = fun h -> mp (mem_of_heap h) in assert (forall m. mp (core_mem m) == f (heap_of_mem m)); let aux (m0:H.hheap frame) (m1:H.heap{H.disjoint m0 m1}) : Lemma (ensures (mem_of_heap (H.join m0 m1) == join (mem_of_heap m0) (mem_of_heap m1))) [SMTPat ()] = () in f let mprop_preservation_of_hprop_preservation (p:slprop) (m0 m1:mem) : Lemma (requires (forall (hp:H.hprop p). hp (heap_of_mem m0) == hp (heap_of_mem m1))) (ensures (forall (mp:mprop p). mp (core_mem m0) == mp (core_mem m1))) = let aux (mp:mprop p) : Lemma (mp (core_mem m0) == mp (core_mem m1)) [SMTPat()] = assert (as_hprop p mp (heap_of_mem m0) == as_hprop p mp (heap_of_mem m1)) in () let lift_heap_action (#fp:slprop) (#a:Type) (#fp':a -> slprop) (e:inames) ($f:H.action fp a fp') : tot_action_nf_except e fp a fp' = let g : tot_pre_action_nf_except e fp a fp' = fun m -> let h0 = hheap_of_hmem m in let (| x, h' |) = f h0 in (| x, hmem_of_hheap m h' |) in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in let h0 = hheap_of_hmem m0 in let (| x', h1 |) = f h0 in H.action_framing f (linv e m0) h0; assert (x == x'); star_associative fp frame (linv e m0); H.action_framing f (frame `star` linv e m0) h0; assert (H.interp ((fp' x) `star` (frame `star` linv e m0)) h1); star_associative (fp' x) frame (linv e m0); assert (H.interp ((fp' x `star` frame) `star` linv e m0) h1); let h1' : H.hheap ((fp' x `star` frame) `star` linv e m0) = h1 in assert (m1 == hmem_of_hheap m0 h1'); assert (with_inv_except m1 e (fp' x `star` frame)); assert (forall (hp:H.hprop frame). hp h0 == hp h1); mprop_preservation_of_hprop_preservation frame m0 m1; () in assert (is_frame_preserving g); g let frame_preserving_respects_preorder #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (m0:hmem_with_inv_except e fp) : Lemma (let (| x, m1 |) = f m0 in mem_evolves m0 m1) = let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1) = () in H.emp_unit fp; assert (interp (fp `star` linv e m0) m0); H.star_congruence (fp `star` emp) (linv e m0) fp (linv e m0); assert (interp ((fp `star` emp) `star` linv e m0) m0); aux emp m0 let lift_tot_action_nf #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') : MstTotNF a e fp fp' = let m0 = NMSTTotal.get () in let m0' : hmem_with_inv_except e fp = m0 in let r = f m0' in let (| x, m1 |) = r in let m1' : hmem_with_inv_except e (fp' x) = m1 in assert (is_frame_preserving f); assert (m1 == dsnd (f m0)); frame_preserving_respects_preorder f m0; NMSTTotal.put #_ #(mem_evolves) m1; x let lift_tot_action #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get #(full_mem) #_ () in ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); lift_tot_action_nf f (** Now defining the lift for heap actions with explicit frame *) let tot_action_with_frame_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = frame:slprop u#a -> m0:hmem_with_inv_except e (fp `star` frame) -> Pure (x:a & hmem_with_inv_except e (fp' x `star` frame)) (requires True) (ensures fun (| x, m1 |) -> mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_with_frame = tot_action_with_frame_except S.empty let lift_heap_action_with_frame (#fp:slprop u#a) (#a:Type u#b) (#fp':a -> slprop u#a) (e:inames) ($f:H.action_with_frame fp a fp') : tot_action_with_frame_except e fp a fp' = fun frame m0 -> let h0 = hheap_of_hmem m0 in calc (equiv) { fp `star` frame `star` locks_invariant e m0; (equiv) { star_associative fp frame (locks_invariant e m0) } fp `star` (frame `star` locks_invariant e m0); }; assert (H.interp (fp `star` frame `star` locks_invariant e m0) h0); assert (H.interp (fp `star` (frame `star` locks_invariant e m0)) h0); //key: apply the heap action with frame * locks_invariant e m0 let (| x, h1 |) = f (frame `star` locks_invariant e m0) h0 in calc (equiv) { fp' x `star` (frame `star` locks_invariant e m0); (equiv) { star_associative (fp' x) frame (locks_invariant e m0) } fp' x `star` frame `star` locks_invariant e m0; }; assert (H.interp (fp' x `star` (frame `star` locks_invariant e m0)) h1); assert (H.interp (fp' x `star` frame `star` locks_invariant e m0) h1); let m1 = hmem_of_hheap m0 h1 in assert (mem_evolves m0 m1); mprop_preservation_of_hprop_preservation (frame `star` locks_invariant e m0) m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)); (| x, m1 |) let lift_tot_action_with_frame #a #e #fp #fp' ($f:tot_action_with_frame_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in assert (inames_ok e m0); ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); let m0' : hmem_with_inv_except e fp = m0 in let r = f frame m0' in let (| x, m1 |) = r in ac_reasoning_for_m_frame_preserving (fp' x) frame (locks_invariant e m1) m1; assert (interp (fp' x `star` frame `star` locks_invariant e m1) m1); assert (interp (fp' x `star` locks_invariant e m1) m1); let m1' : hmem_with_inv_except e (fp' x) = m1 in NMSTTotal.put #_ #(mem_evolves) m1; x let sel_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.sel_action #a #pcm r v0)) let upd_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.upd_action #a #pcm r v0 v1)) let free_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.free_action #a #pcm r v0)) let split_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.split_action #a #pcm r v0 v1)) let gather_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.gather_action #a #pcm r v0 v1)) let weaken (p q r:slprop) (h:H.hheap (p `star` q) { H.stronger q r }) : H.hheap (p `star` r) = H.weaken p q r h; h let weaken_pure (q r: prop) : Lemma (requires (q ==> r)) (ensures H.stronger (H.pure q) (H.pure r)) = let aux (h:H.heap) : Lemma (ensures (H.interp (H.pure q) h ==> H.interp (H.pure r) h)) [SMTPat ()] = H.pure_interp q h; H.pure_interp r h in ()

{ "checked_file": "/", "dependencies": [ "Steel.Preorder.fst.checked", "Steel.Heap.fsti.checked", "prims.fst.checked", "FStar.Witnessed.Core.fsti.checked", "FStar.Set.fsti.checked", "FStar.Preorder.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.PCM.fst.checked", "FStar.NMSTTotal.fst.checked", "FStar.List.Tot.fst.checked", "FStar.IndefiniteDescription.fsti.checked", "FStar.Ghost.fsti.checked", "FStar.FunctionalExtensionality.fsti.checked", "FStar.Classical.Sugar.fsti.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Steel.Memory.fst" }

[ { "abbrev": true, "full_module": "Steel.Preorder", "short_module": "PP" }, { "abbrev": true, "full_module": "FStar.Witnessed.Core", "short_module": "W" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": true, "full_module": "Steel.Heap", "short_module": "H" }, { "abbrev": false, "full_module": "FStar.PCM", "short_module": null }, { "abbrev": false, "full_module": "FStar.FunctionalExtensionality", "short_module": null }, { "abbrev": true, "full_module": "FStar.FunctionalExtensionality", "short_module": "F" }, { "abbrev": false, "full_module": "FStar.PCM", "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

m: Steel.Memory.hmem_with_inv_except e p -> m': Steel.Memory.hmem_with_inv_except e p { Mkmem?.ctr m' = Mkmem?.ctr m + 1 /\ Steel.Heap.stronger (Steel.Memory.linv e m) (Steel.Memory.linv e m') }

Prims.Tot

[ "total" ]

[]

[ "Steel.Memory.slprop", "Steel.Memory.inames", "Steel.Memory.hmem_with_inv_except", "Prims.unit", "Steel.Heap.star_associative", "Steel.Memory.lock_store_invariant", "Steel.Memory.__proj__Mkmem__item__locks", "Steel.Memory.ctr_validity", "Prims.op_Addition", "Steel.Memory.__proj__Mkmem__item__ctr", "Steel.Memory.heap_of_mem", "Steel.Heap.weaken", "Steel.Memory.star", "Steel.Heap.stronger_star", "Prims._assert", "Steel.Heap.stronger", "Steel.Memory.weaken_pure", "Steel.Memory.heap_ctr_valid", "Steel.Heap.weaken_free_above", "Prims.eq2", "Steel.Memory.linv", "Steel.Memory.interp", "Steel.Memory.mem", "Steel.Memory.Mkmem", "Steel.Memory.__proj__Mkmem__item__heap", "Prims.l_and", "Prims.b2t", "Prims.op_Equality", "Prims.int" ]

[]

false

let inc_ctr (#p: slprop) #e (m: hmem_with_inv_except e p) : m': hmem_with_inv_except e p {m'.ctr = m.ctr + 1 /\ H.stronger (linv e m) (linv e m')} =

let m':mem = { m with ctr = m.ctr + 1 } in assert (interp (p `star` (linv e m)) m'); assert (linv e m == (lock_store_invariant e m.locks) `star` (ctr_validity m.ctr (heap_of_mem m))); assert (linv e m' == (lock_store_invariant e m.locks) `star` (ctr_validity (m.ctr + 1) (heap_of_mem m))); H.weaken_free_above (heap_of_mem m) m.ctr (m.ctr + 1); weaken_pure (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_ctr_valid (m.ctr + 1) (heap_of_mem m)); assert (H.stronger (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m))); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)); H.stronger_star (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken (p `star` (lock_store_invariant e m.locks)) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)) (heap_of_mem m'); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity (m.ctr + 1) (heap_of_mem m)); let m':hmem_with_inv_except e p = m' in m'

false

Steel.Memory.fst

Steel.Memory.weaken

val weaken (p q r: slprop) (h: H.hheap (p `star` q) {H.stronger q r}) : H.hheap (p `star` r)

let weaken (p q r:slprop) (h:H.hheap (p `star` q) { H.stronger q r }) : H.hheap (p `star` r) = H.weaken p q r h; h

{ "file_name": "lib/steel/Steel.Memory.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 23, "end_line": 860, "start_col": 0, "start_line": 858 }

(* 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.Memory module F = FStar.FunctionalExtensionality open FStar.FunctionalExtensionality open FStar.PCM module H = Steel.Heap noeq type lock_state : Type u#(a + 1) = | Invariant : inv:H.slprop u#a -> lock_state let lock_store : Type u#(a+1) = list (lock_state u#a) noeq type mem : Type u#(a + 1) = { ctr: nat; heap: H.heap u#a; locks: lock_store u#a; } let heap_of_mem (x:mem) : H.heap = x.heap let mem_of_heap (h:H.heap) : mem = { ctr = 0; heap = h; locks = [] } let mem_set_heap (m:mem) (h:H.heap) : mem = { ctr = m.ctr; heap = h; locks = m.locks; } let core_mem (m:mem) : mem = mem_of_heap (heap_of_mem m) let core_mem_invol m = () let disjoint (m0 m1:mem u#h) : prop = m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks let disjoint_sym m0 m1 = () let join m0 m1 = { ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = m0.locks } let join_commutative m0 m1 = H.join_commutative m0.heap m1.heap let disjoint_join m0 m1 m2 = H.disjoint_join m0.heap m1.heap m2.heap let join_associative m0 m1 m2 = H.join_associative m0.heap m1.heap m2.heap let slprop = H.slprop let interp p m = H.interp p m.heap let equiv p1 p2 = forall m. interp p1 m <==> interp p2 m let slprop_extensionality p q = assert (forall m. interp p m <==> interp q m); let aux (h:H.heap) : Lemma (H.interp p h <==> H.interp q h) [SMTPat (H.interp p h)] = let m : mem = { ctr = 0; heap = h; locks = [] } in assert (interp p m <==> interp q m) in assert (forall h. H.interp p h <==> H.interp q h); Steel.Heap.slprop_extensionality p q let reveal_equiv p1 p2 = () let core_ref = H.core_ref let core_ref_null = H.core_ref_null let core_ref_is_null r = H.core_ref_is_null r let emp : slprop u#a = H.emp let pure = H.pure let pts_to = H.pts_to let h_and = H.h_and let h_or = H.h_or let star = H.star let wand = H.wand let h_exists = H.h_exists let h_forall = H.h_forall //////////////////////////////////////////////////////////////////////////////// //properties of equiv //////////////////////////////////////////////////////////////////////////////// let equiv_symmetric (p1 p2:slprop u#a) = H.equiv_symmetric p1 p2 #push-options "--warn_error -271" let equiv_heap_iff_equiv (p1 p2:slprop u#a) : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat (equiv p1 p2)] = let aux_lr () : Lemma (requires H.equiv p1 p2) (ensures equiv p1 p2) [SMTPat ()] = () in let aux_rl_helper1 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p1 h) (ensures H.interp p2 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl_helper2 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p2 h) (ensures H.interp p1 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl () : Lemma (requires equiv p1 p2) (ensures H.equiv p1 p2) [SMTPat ()] = () in () let equiv_heap_iff_equiv_forall () : Lemma (ensures (forall p1 p2. H.equiv p1 p2 <==> equiv p1 p2)) = let aux p1 p2 : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat ()] = equiv_heap_iff_equiv p1 p2 in () #pop-options let equiv_extensional_on_star (p1 p2 p3:slprop u#a) = equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3 let emp_unit p = H.emp_unit p let intro_emp m = H.intro_emp (heap_of_mem m) let pure_equiv p q = H.pure_equiv p q let pure_interp q m = H.pure_interp q (heap_of_mem m) let pure_star_interp p q m = H.pure_star_interp p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// //pts_to //////////////////////////////////////////////////////////////////////////////// let pts_to_compatible #a #pcm x v0 v1 m = H.pts_to_compatible #a #pcm x v0 v1 (heap_of_mem m) let pts_to_compatible_equiv #a #pcm x v0 v1 = H.pts_to_compatible_equiv #a #pcm x v0 v1 let pts_to_not_null #a #pcm x v m = H.pts_to_not_null #a #pcm x v (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // star //////////////////////////////////////////////////////////////////////////////// let intro_star p q mp mq = H.intro_star p q (heap_of_mem mp) (heap_of_mem mq) let elim_star p q m = let h = heap_of_mem m in H.elim_star p q h; assert (exists hl hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr); let hl = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hl -> exists hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let hr = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hr -> H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let ml = mem_set_heap m hl in let mr = mem_set_heap m hr in assert (disjoint ml mr); assert (m == join ml mr); assert (interp p ml); assert (interp q mr); () let interp_star (p q: slprop) (m: mem) : Lemma (interp (p `star` q) m <==> (exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m)) = let left = interp (p `star` q) m in let right = exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m in let f () : Lemma (requires left) (ensures right) = elim_star p q m in let g () : Lemma (requires right) (ensures left) = Classical.exists_elim left #_ #(fun mp -> exists (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mp -> Classical.exists_elim left #_ #(fun mq -> disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mq -> intro_star p q mp mq ) ) in Classical.move_requires f (); Classical.move_requires g () let star_commutative (p1 p2:slprop) = H.star_commutative p1 p2 let star_associative (p1 p2 p3:slprop) = H.star_associative p1 p2 p3 let star_congruence (p1 p2 p3 p4:slprop) = equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4 let affine_star (p q:slprop) (m:mem) = H.affine_star p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // Invariants on the lock store //////////////////////////////////////////////////////////////////////////////// let iname = nat module S = FStar.Set module L = FStar.List.Tot module W = FStar.Witnessed.Core let rec lock_store_invariant (e:inames) (l:lock_store u#a) : slprop u#a = let current_addr = L.length l - 1 in match l with | [] -> emp | Invariant p :: tl -> if current_addr `S.mem` e then lock_store_invariant e tl else p `star` lock_store_invariant e tl let lock_i (i:iname) (l:lock_store { i < L.length l }) = let ix = L.length l - i - 1 in L.index l ix let iname_for_p (i:iname) (p:slprop) : W.s_predicate lock_store = fun l -> i < L.length l /\ (lock_i i l).inv == p let lock_store_evolves : FStar.Preorder.preorder lock_store = fun (l1 l2 : lock_store) -> L.length l2 >= L.length l1 /\ (forall (i:nat{i < L.length l1}). (lock_i i l1).inv == (lock_i i l2).inv) let inames_in (e:inames) (l:lock_store) : prop = forall i. Set.mem i e ==> i < L.length l let inames_ok e m = inames_in e m.locks let inames_ok_empty m = () let extend_lock_store (e:inames) (l:lock_store{e `inames_in` l}) (p:slprop) : i:iname & l':lock_store { lock_store_invariant e l' == p `star` lock_store_invariant e l /\ iname_for_p i p l' } = (| L.length l, Invariant p :: l |) let set_add (i:iname) (s:inames) = Set.union (Set.singleton i) s let rec move_invariant (e:inames) (l:lock_store) (p:slprop) (i:iname{iname_for_p i p l /\ ~(i `Set.mem` e)}) : Lemma (H.equiv (lock_store_invariant e l) (p `star` lock_store_invariant (set_add i e) l)) = let rec aux (i:iname) (m:lock_store) : Lemma (requires i >= L.length m) (ensures (lock_store_invariant e m `H.equiv` lock_store_invariant (set_add i e) m)) = match m with | [] -> () | Invariant p::tl -> aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl) in let current_addr = L.length l - 1 in match l with | [] -> () | Invariant q::tl -> if i = current_addr then begin assert (lock_store_invariant e l == p `star` lock_store_invariant e tl); aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl); () end else begin move_invariant e tl p i; assert (lock_store_invariant e tl `equiv` (p `star` lock_store_invariant (set_add i e) tl)); H.star_congruence q (lock_store_invariant e tl) q (p `star` lock_store_invariant (set_add i e) tl); if Set.mem current_addr e then () else begin let r = lock_store_invariant (set_add i e) tl in assert (lock_store_invariant e l `equiv` (q `star` (p `star` r))); H.star_associative q p r; H.star_commutative q p; H.star_congruence (q `star` p) r (p `star` q) r; H.star_associative p q r end end let heap_ctr_valid (ctr:nat) (h:H.heap u#a) : prop = h `H.free_above_addr` ctr let ctr_validity (ctr:nat) (h:H.heap) : slprop = H.pure (heap_ctr_valid ctr h) let locks_invariant (e:inames) (m:mem u#a) : slprop u#a = lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m) let full_mem_pred (m:mem) = H.full_heap_pred (heap_of_mem m) (***** Following lemmas are needed in Steel.Effect *****) let core_mem_interp (hp:slprop u#a) (m:mem u#a) = () let interp_depends_only_on (hp:slprop u#a) = H.interp_depends_only_on hp let a_mem_prop_as_a_heap_prop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (H.a_heap_prop u#a) = let g (h: H.heap u#a) : Tot prop = interp sl (mem_of_heap h) /\ f (mem_of_heap h) in let phi0 (h0 h1: H.heap u#a) : Lemma (requires (g h0 /\ H.disjoint h0 h1)) (ensures (g h0 /\ H.disjoint h0 h1 /\ g (H.join h0 h1))) = assert (mem_of_heap (H.join h0 h1) == mem_of_heap h0 `join` mem_of_heap h1); interp_depends_only_on sl in let phi1 (h0 h1: H.heap u#a) : Lemma (ensures ((g h0 /\ H.disjoint h0 h1) ==> g (H.join h0 h1))) = Classical.move_requires (phi0 h0) h1 in Classical.forall_intro_2 phi1; g let refine_slprop sl f = H.as_slprop (a_mem_prop_as_a_heap_prop sl f) let interp_refine_slprop sl f m = assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_mem m)) let dep_hprop (s: slprop) (f: (hmem s -> Tot slprop)) (h: H.heap) : Tot prop = exists (h1: H.heap) . exists (h2: H.heap) . interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 let dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq' : squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h')) = let p2 (h h1 h2: H.heap) : Tot prop = interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 in let p1 (h h1: H.heap) : Tot prop = (exists h2 . p2 h h1 h2) in let h1 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p1 h) in let h2 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p2 h h1) in H.disjoint_join h' h1 h2; assert (H.disjoint h2 h'); let h2' = H.join h2 h' in H.join_commutative h2 h' ; assert (h2' == H.join h' h2); assert (H.disjoint h1 h2'); assert (mem_of_heap h2' == mem_of_heap h2 `join` mem_of_heap h'); interp_depends_only_on (f (mem_of_heap h1)); assert (interp (f (mem_of_heap h1)) (mem_of_heap h2')); H.join_commutative h1 h2; H.join_associative h' h2 h1; H.join_commutative h' h; H.join_commutative h2' h1; assert (H.join h h' == h1 `H.join` h2') let impl_intro_gen (#p: Type0) (#q: Type0) ($prf: (squash p -> Lemma (q ))) : Lemma (p ==> q) = Classical.impl_intro_gen #p #(fun _ -> q) prf let dep_hprop_is_affine1 (s: slprop) (f: (hmem s -> Tot slprop)) (h0 h1: H.heap) : Lemma ((dep_hprop s f h0 /\ H.disjoint h0 h1) ==> (H.disjoint h0 h1 /\ dep_hprop s f (H.join h0 h1))) = impl_intro_gen (dep_hprop_is_affine0 s f h0 h1) let dep_hprop_is_affine (s: slprop) (f: (hmem s -> Tot slprop)) : Lemma (H.heap_prop_is_affine (dep_hprop s f)) = Classical.forall_intro_2 (dep_hprop_is_affine1 s f) let sdep (s: slprop) (f: (hmem s -> Tot slprop)) : Tot slprop = dep_hprop_is_affine s f; H.as_slprop (dep_hprop s f) let interp_sdep (s: slprop) (f: (hmem s -> Tot slprop)) (m: mem) : Lemma (requires (dep_slprop_is_affine s f)) (ensures ( interp (sdep s f) m <==> (exists m1 m2 . interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) )) = dep_hprop_is_affine s f; assert (forall m1 m2 . (interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) ==> ( interp s (mem_of_heap m1.heap) /\ interp (f (mem_of_heap m1.heap)) (mem_of_heap m2.heap) /\ H.disjoint m1.heap m2.heap /\ H.join m1.heap m2.heap == m.heap )); interp_depends_only_on s; Classical.forall_intro (fun m -> interp_depends_only_on (f m)); assert (forall h1 h2 . (interp s (mem_of_heap h1) /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ H.disjoint h1 h2 /\ H.join h1 h2 == m.heap) ==> ( core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ interp s (core_mem (mem_of_heap h1)) /\ interp s (mem_set_heap m h1) /\ core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ f (mem_set_heap m h1) `equiv` f (mem_of_heap h1) /\ interp (f (mem_set_heap m h1)) (mem_of_heap h2) /\ interp (f (mem_set_heap m h1)) (mem_set_heap m h2) /\ disjoint (mem_set_heap m h1) (mem_set_heap m h2) /\ join (mem_set_heap m h1) (mem_set_heap m h2) == m )); () let h_exists_cong (#a:Type) (p q : a -> slprop) : Lemma (requires (forall x. p x `equiv` q x)) (ensures (h_exists p `equiv` h_exists q)) = equiv_heap_iff_equiv_forall (); H.h_exists_cong p q let intro_h_exists #a x p m = H.intro_h_exists x p (heap_of_mem m) let elim_h_exists (#a:_) (p:a -> slprop) (m:mem) = H.elim_h_exists p (heap_of_mem m) let intro_h_forall (#a:_) (p:a -> slprop) (m:mem) = H.intro_h_forall p (heap_of_mem m) let elim_h_forall (#a:_) (p:a -> slprop) (m:mem) (x:a) = H.elim_h_forall p (heap_of_mem m) x let intro_h_and (p q: slprop) (m:mem) = H.intro_h_and p q (heap_of_mem m) let elim_h_and (p q: slprop) (m:mem) = H.elim_h_and p q (heap_of_mem m) let intro_h_or_left (p q: slprop) (m:mem) = H.intro_h_or_left p q (heap_of_mem m) let intro_h_or_right (p q: slprop) (m:mem) = H.intro_h_or_right p q (heap_of_mem m) let elim_h_or (p q: slprop) (m:mem) = H.elim_h_or p q (heap_of_mem m) let intro_wand (p1 p2: slprop u#a) (m:mem) = introduce (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)) ==> interp (wand p1 p2) m with _. ( assert (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)); H.intro_wand p1 p2 (heap_of_mem m); let h = heap_of_mem m in assert ((forall h1. h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) ==> H.interp (wand p1 p2) h); introduce forall h1. (h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) with ( introduce (h `H.disjoint` h1 /\ H.interp p1 h1) ==> H.interp p2 (H.join h h1) with _. ( assert (h `H.disjoint` h1); let m1 = { ctr = m.ctr; heap = h1; locks = m.locks } in assert (m `disjoint` m1) ) ) ) (** Eliminating a wand by proving a heap that satisfies the LHS **) let elim_wand (p1 p2: slprop u#a) (m:mem) (m1:mem) = H.elim_wand p1 p2 (heap_of_mem m) (heap_of_mem m1) //////////////////////////////////////////////////////////////////////////////// // Preorders and effects //////////////////////////////////////////////////////////////////////////////// module PP = Steel.Preorder let mem_evolves = fun (m0 m1:full_mem) -> H.heap_evolves (heap_of_mem m0) (heap_of_mem m1) /\ m0.ctr <= m1.ctr /\ lock_store_evolves m0.locks m1.locks (** See [Steel.Heap.is_frame_preserving]. We add in [lock_invariants] now *) let preserves_frame (e:inames) (pre post:slprop) (m0 m1:mem) = forall (frame:slprop). interp ((pre `star` frame) `star` locks_invariant e m0) m0 ==> (interp ((post `star` frame) `star` locks_invariant e m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) (** This is a version of MstTot with frame quantified, as part of preserves_frame *) effect MstTotNF (a:Type u#a) (except:inames) (expects:slprop u#1) (provides: a -> slprop u#1) = NMSTTotal.NMSTATETOT a (full_mem u#1) mem_evolves (requires fun m0 -> inames_ok except m0 /\ interp (expects `star` locks_invariant except m0) m0) (ensures fun m0 x m1 -> inames_ok except m1 /\ interp (provides x `star` locks_invariant except m1) m1 /\ preserves_frame except expects (provides x) m0 m1) //////////////////////////////////////////////////////////////////////////////// // Lifting heap actions //////////////////////////////////////////////////////////////////////////////// (** Heap actions come in two equivalent flavors: - one that take an explicit frame as argument (action_with_frame) - and one that quantify over all the frame We therefore define two lift routes: - a direct route for those with explicit frame - via MstTotNF for the rest *) let tot_pre_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = hmem_with_inv_except e fp -> (x:a & hmem_with_inv_except e (fp' x)) let tot_pre_action_nf = tot_pre_action_nf_except S.empty let ac_reasoning_for_m_frame_preserving (p q r:slprop u#a) (m:mem u#a) : Lemma (requires interp ((p `star` q) `star` r) m) (ensures interp (p `star` r) m) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_commutative p q; equiv_extensional_on_star (p `star` q) (q `star` p) r } (q `star` p) `star` r; (equiv) { star_associative q p r } q `star` (p `star` r); }; assert (interp (q `star` (p `star` r)) m); affine_star q (p `star` r) m let is_frame_preserving (#e:inames) (#a:Type u#b) (#fp:slprop u#a) (#fp':a -> slprop u#a) (f:tot_pre_action_nf_except e fp a fp') = forall (frame:slprop u#a) (m0:hmem_with_inv_except e (fp `star` frame)). (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = f:tot_pre_action_nf_except e fp a fp'{ is_frame_preserving f } let tot_action_nf = tot_action_nf_except S.empty let linv e (m:mem) = locks_invariant e m let hheap_of_hmem #fp #e (m:hmem_with_inv_except e fp) : h:H.hheap (fp `star` linv e m) { h `H.free_above_addr` m.ctr} = let h = heap_of_mem m in H.pure_interp (heap_ctr_valid m.ctr (heap_of_mem m)) h; h let hmem_of_hheap #e (#fp0 #fp1:slprop) (m:hmem_with_inv_except e fp0) (h:H.full_hheap (fp1 `star` linv e m) { h `Heap.free_above_addr` m.ctr }) : m1:hmem_with_inv_except e fp1{linv e m `equiv` linv e m1} = let m1 : mem = { m with heap = h } in assert (interp (fp1 `star` linv e m) m1); star_commutative fp1 (linv e m); assert (interp (linv e m `star` fp1) m1); assert (linv e m1 == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); assert (linv e m == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m)); H.pure_interp (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_of_mem m); assert (heap_ctr_valid m1.ctr (heap_of_mem m) <==> heap_ctr_valid m1.ctr (heap_of_mem m1)); H.pure_equiv (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_ctr_valid m1.ctr (heap_of_mem m1)); H.star_congruence (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m)); assert (linv e m `equiv` linv e m1); let _ = equiv_extensional_on_star (linv e m) (linv e m1) fp1 in assert ((linv e m `star` fp1) `equiv` (linv e m1 `star` fp1)); assert (interp (linv e m1 `star` fp1) m1); star_commutative (linv e m1) fp1; assert (interp (fp1 `star` linv e m1) m1); m1 let with_inv_except (m:mem) e (fp:slprop) = interp (fp `star` locks_invariant e m) m #push-options "--warn_error -271" let as_hprop (frame:slprop) (mp:mprop frame) : hp:H.hprop frame{forall m. mp (core_mem m) == hp (heap_of_mem m)} = let f = fun h -> mp (mem_of_heap h) in assert (forall m. mp (core_mem m) == f (heap_of_mem m)); let aux (m0:H.hheap frame) (m1:H.heap{H.disjoint m0 m1}) : Lemma (ensures (mem_of_heap (H.join m0 m1) == join (mem_of_heap m0) (mem_of_heap m1))) [SMTPat ()] = () in f let mprop_preservation_of_hprop_preservation (p:slprop) (m0 m1:mem) : Lemma (requires (forall (hp:H.hprop p). hp (heap_of_mem m0) == hp (heap_of_mem m1))) (ensures (forall (mp:mprop p). mp (core_mem m0) == mp (core_mem m1))) = let aux (mp:mprop p) : Lemma (mp (core_mem m0) == mp (core_mem m1)) [SMTPat()] = assert (as_hprop p mp (heap_of_mem m0) == as_hprop p mp (heap_of_mem m1)) in () let lift_heap_action (#fp:slprop) (#a:Type) (#fp':a -> slprop) (e:inames) ($f:H.action fp a fp') : tot_action_nf_except e fp a fp' = let g : tot_pre_action_nf_except e fp a fp' = fun m -> let h0 = hheap_of_hmem m in let (| x, h' |) = f h0 in (| x, hmem_of_hheap m h' |) in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in let h0 = hheap_of_hmem m0 in let (| x', h1 |) = f h0 in H.action_framing f (linv e m0) h0; assert (x == x'); star_associative fp frame (linv e m0); H.action_framing f (frame `star` linv e m0) h0; assert (H.interp ((fp' x) `star` (frame `star` linv e m0)) h1); star_associative (fp' x) frame (linv e m0); assert (H.interp ((fp' x `star` frame) `star` linv e m0) h1); let h1' : H.hheap ((fp' x `star` frame) `star` linv e m0) = h1 in assert (m1 == hmem_of_hheap m0 h1'); assert (with_inv_except m1 e (fp' x `star` frame)); assert (forall (hp:H.hprop frame). hp h0 == hp h1); mprop_preservation_of_hprop_preservation frame m0 m1; () in assert (is_frame_preserving g); g let frame_preserving_respects_preorder #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (m0:hmem_with_inv_except e fp) : Lemma (let (| x, m1 |) = f m0 in mem_evolves m0 m1) = let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1) = () in H.emp_unit fp; assert (interp (fp `star` linv e m0) m0); H.star_congruence (fp `star` emp) (linv e m0) fp (linv e m0); assert (interp ((fp `star` emp) `star` linv e m0) m0); aux emp m0 let lift_tot_action_nf #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') : MstTotNF a e fp fp' = let m0 = NMSTTotal.get () in let m0' : hmem_with_inv_except e fp = m0 in let r = f m0' in let (| x, m1 |) = r in let m1' : hmem_with_inv_except e (fp' x) = m1 in assert (is_frame_preserving f); assert (m1 == dsnd (f m0)); frame_preserving_respects_preorder f m0; NMSTTotal.put #_ #(mem_evolves) m1; x let lift_tot_action #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get #(full_mem) #_ () in ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); lift_tot_action_nf f (** Now defining the lift for heap actions with explicit frame *) let tot_action_with_frame_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = frame:slprop u#a -> m0:hmem_with_inv_except e (fp `star` frame) -> Pure (x:a & hmem_with_inv_except e (fp' x `star` frame)) (requires True) (ensures fun (| x, m1 |) -> mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_with_frame = tot_action_with_frame_except S.empty let lift_heap_action_with_frame (#fp:slprop u#a) (#a:Type u#b) (#fp':a -> slprop u#a) (e:inames) ($f:H.action_with_frame fp a fp') : tot_action_with_frame_except e fp a fp' = fun frame m0 -> let h0 = hheap_of_hmem m0 in calc (equiv) { fp `star` frame `star` locks_invariant e m0; (equiv) { star_associative fp frame (locks_invariant e m0) } fp `star` (frame `star` locks_invariant e m0); }; assert (H.interp (fp `star` frame `star` locks_invariant e m0) h0); assert (H.interp (fp `star` (frame `star` locks_invariant e m0)) h0); //key: apply the heap action with frame * locks_invariant e m0 let (| x, h1 |) = f (frame `star` locks_invariant e m0) h0 in calc (equiv) { fp' x `star` (frame `star` locks_invariant e m0); (equiv) { star_associative (fp' x) frame (locks_invariant e m0) } fp' x `star` frame `star` locks_invariant e m0; }; assert (H.interp (fp' x `star` (frame `star` locks_invariant e m0)) h1); assert (H.interp (fp' x `star` frame `star` locks_invariant e m0) h1); let m1 = hmem_of_hheap m0 h1 in assert (mem_evolves m0 m1); mprop_preservation_of_hprop_preservation (frame `star` locks_invariant e m0) m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)); (| x, m1 |) let lift_tot_action_with_frame #a #e #fp #fp' ($f:tot_action_with_frame_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in assert (inames_ok e m0); ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); let m0' : hmem_with_inv_except e fp = m0 in let r = f frame m0' in let (| x, m1 |) = r in ac_reasoning_for_m_frame_preserving (fp' x) frame (locks_invariant e m1) m1; assert (interp (fp' x `star` frame `star` locks_invariant e m1) m1); assert (interp (fp' x `star` locks_invariant e m1) m1); let m1' : hmem_with_inv_except e (fp' x) = m1 in NMSTTotal.put #_ #(mem_evolves) m1; x let sel_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.sel_action #a #pcm r v0)) let upd_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.upd_action #a #pcm r v0 v1)) let free_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.free_action #a #pcm r v0)) let split_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.split_action #a #pcm r v0 v1)) let gather_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.gather_action #a #pcm r v0 v1))

{ "checked_file": "/", "dependencies": [ "Steel.Preorder.fst.checked", "Steel.Heap.fsti.checked", "prims.fst.checked", "FStar.Witnessed.Core.fsti.checked", "FStar.Set.fsti.checked", "FStar.Preorder.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.PCM.fst.checked", "FStar.NMSTTotal.fst.checked", "FStar.List.Tot.fst.checked", "FStar.IndefiniteDescription.fsti.checked", "FStar.Ghost.fsti.checked", "FStar.FunctionalExtensionality.fsti.checked", "FStar.Classical.Sugar.fsti.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Steel.Memory.fst" }

[ { "abbrev": true, "full_module": "Steel.Preorder", "short_module": "PP" }, { "abbrev": true, "full_module": "FStar.Witnessed.Core", "short_module": "W" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": true, "full_module": "Steel.Heap", "short_module": "H" }, { "abbrev": false, "full_module": "FStar.PCM", "short_module": null }, { "abbrev": false, "full_module": "FStar.FunctionalExtensionality", "short_module": null }, { "abbrev": true, "full_module": "FStar.FunctionalExtensionality", "short_module": "F" }, { "abbrev": false, "full_module": "FStar.PCM", "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

p: Steel.Memory.slprop -> q: Steel.Memory.slprop -> r: Steel.Memory.slprop -> h: Steel.Heap.hheap (Steel.Memory.star p q) {Steel.Heap.stronger q r} -> Steel.Heap.hheap (Steel.Memory.star p r)

Prims.Tot

[ "total" ]

[]

[ "Steel.Memory.slprop", "Steel.Heap.hheap", "Steel.Memory.star", "Steel.Heap.stronger", "Prims.unit", "Steel.Heap.weaken" ]

[]

false

let weaken (p q r: slprop) (h: H.hheap (p `star` q) {H.stronger q r}) : H.hheap (p `star` r) =

H.weaken p q r h; h

false

Steel.Memory.fst

Steel.Memory.lift_heap_action

val lift_heap_action (#fp: slprop) (#a: Type) (#fp': (a -> slprop)) (e: inames) ($f: H.action fp a fp') : tot_action_nf_except e fp a fp'

let lift_heap_action (#fp:slprop) (#a:Type) (#fp':a -> slprop) (e:inames) ($f:H.action fp a fp') : tot_action_nf_except e fp a fp' = let g : tot_pre_action_nf_except e fp a fp' = fun m -> let h0 = hheap_of_hmem m in let (| x, h' |) = f h0 in (| x, hmem_of_hheap m h' |) in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in let h0 = hheap_of_hmem m0 in let (| x', h1 |) = f h0 in H.action_framing f (linv e m0) h0; assert (x == x'); star_associative fp frame (linv e m0); H.action_framing f (frame `star` linv e m0) h0; assert (H.interp ((fp' x) `star` (frame `star` linv e m0)) h1); star_associative (fp' x) frame (linv e m0); assert (H.interp ((fp' x `star` frame) `star` linv e m0) h1); let h1' : H.hheap ((fp' x `star` frame) `star` linv e m0) = h1 in assert (m1 == hmem_of_hheap m0 h1'); assert (with_inv_except m1 e (fp' x `star` frame)); assert (forall (hp:H.hprop frame). hp h0 == hp h1); mprop_preservation_of_hprop_preservation frame m0 m1; () in assert (is_frame_preserving g); g

{ "file_name": "lib/steel/Steel.Memory.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 5, "end_line": 727, "start_col": 0, "start_line": 690 }

(* 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.Memory module F = FStar.FunctionalExtensionality open FStar.FunctionalExtensionality open FStar.PCM module H = Steel.Heap noeq type lock_state : Type u#(a + 1) = | Invariant : inv:H.slprop u#a -> lock_state let lock_store : Type u#(a+1) = list (lock_state u#a) noeq type mem : Type u#(a + 1) = { ctr: nat; heap: H.heap u#a; locks: lock_store u#a; } let heap_of_mem (x:mem) : H.heap = x.heap let mem_of_heap (h:H.heap) : mem = { ctr = 0; heap = h; locks = [] } let mem_set_heap (m:mem) (h:H.heap) : mem = { ctr = m.ctr; heap = h; locks = m.locks; } let core_mem (m:mem) : mem = mem_of_heap (heap_of_mem m) let core_mem_invol m = () let disjoint (m0 m1:mem u#h) : prop = m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks let disjoint_sym m0 m1 = () let join m0 m1 = { ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = m0.locks } let join_commutative m0 m1 = H.join_commutative m0.heap m1.heap let disjoint_join m0 m1 m2 = H.disjoint_join m0.heap m1.heap m2.heap let join_associative m0 m1 m2 = H.join_associative m0.heap m1.heap m2.heap let slprop = H.slprop let interp p m = H.interp p m.heap let equiv p1 p2 = forall m. interp p1 m <==> interp p2 m let slprop_extensionality p q = assert (forall m. interp p m <==> interp q m); let aux (h:H.heap) : Lemma (H.interp p h <==> H.interp q h) [SMTPat (H.interp p h)] = let m : mem = { ctr = 0; heap = h; locks = [] } in assert (interp p m <==> interp q m) in assert (forall h. H.interp p h <==> H.interp q h); Steel.Heap.slprop_extensionality p q let reveal_equiv p1 p2 = () let core_ref = H.core_ref let core_ref_null = H.core_ref_null let core_ref_is_null r = H.core_ref_is_null r let emp : slprop u#a = H.emp let pure = H.pure let pts_to = H.pts_to let h_and = H.h_and let h_or = H.h_or let star = H.star let wand = H.wand let h_exists = H.h_exists let h_forall = H.h_forall //////////////////////////////////////////////////////////////////////////////// //properties of equiv //////////////////////////////////////////////////////////////////////////////// let equiv_symmetric (p1 p2:slprop u#a) = H.equiv_symmetric p1 p2 #push-options "--warn_error -271" let equiv_heap_iff_equiv (p1 p2:slprop u#a) : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat (equiv p1 p2)] = let aux_lr () : Lemma (requires H.equiv p1 p2) (ensures equiv p1 p2) [SMTPat ()] = () in let aux_rl_helper1 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p1 h) (ensures H.interp p2 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl_helper2 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p2 h) (ensures H.interp p1 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl () : Lemma (requires equiv p1 p2) (ensures H.equiv p1 p2) [SMTPat ()] = () in () let equiv_heap_iff_equiv_forall () : Lemma (ensures (forall p1 p2. H.equiv p1 p2 <==> equiv p1 p2)) = let aux p1 p2 : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat ()] = equiv_heap_iff_equiv p1 p2 in () #pop-options let equiv_extensional_on_star (p1 p2 p3:slprop u#a) = equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3 let emp_unit p = H.emp_unit p let intro_emp m = H.intro_emp (heap_of_mem m) let pure_equiv p q = H.pure_equiv p q let pure_interp q m = H.pure_interp q (heap_of_mem m) let pure_star_interp p q m = H.pure_star_interp p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// //pts_to //////////////////////////////////////////////////////////////////////////////// let pts_to_compatible #a #pcm x v0 v1 m = H.pts_to_compatible #a #pcm x v0 v1 (heap_of_mem m) let pts_to_compatible_equiv #a #pcm x v0 v1 = H.pts_to_compatible_equiv #a #pcm x v0 v1 let pts_to_not_null #a #pcm x v m = H.pts_to_not_null #a #pcm x v (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // star //////////////////////////////////////////////////////////////////////////////// let intro_star p q mp mq = H.intro_star p q (heap_of_mem mp) (heap_of_mem mq) let elim_star p q m = let h = heap_of_mem m in H.elim_star p q h; assert (exists hl hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr); let hl = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hl -> exists hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let hr = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hr -> H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let ml = mem_set_heap m hl in let mr = mem_set_heap m hr in assert (disjoint ml mr); assert (m == join ml mr); assert (interp p ml); assert (interp q mr); () let interp_star (p q: slprop) (m: mem) : Lemma (interp (p `star` q) m <==> (exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m)) = let left = interp (p `star` q) m in let right = exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m in let f () : Lemma (requires left) (ensures right) = elim_star p q m in let g () : Lemma (requires right) (ensures left) = Classical.exists_elim left #_ #(fun mp -> exists (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mp -> Classical.exists_elim left #_ #(fun mq -> disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mq -> intro_star p q mp mq ) ) in Classical.move_requires f (); Classical.move_requires g () let star_commutative (p1 p2:slprop) = H.star_commutative p1 p2 let star_associative (p1 p2 p3:slprop) = H.star_associative p1 p2 p3 let star_congruence (p1 p2 p3 p4:slprop) = equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4 let affine_star (p q:slprop) (m:mem) = H.affine_star p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // Invariants on the lock store //////////////////////////////////////////////////////////////////////////////// let iname = nat module S = FStar.Set module L = FStar.List.Tot module W = FStar.Witnessed.Core let rec lock_store_invariant (e:inames) (l:lock_store u#a) : slprop u#a = let current_addr = L.length l - 1 in match l with | [] -> emp | Invariant p :: tl -> if current_addr `S.mem` e then lock_store_invariant e tl else p `star` lock_store_invariant e tl let lock_i (i:iname) (l:lock_store { i < L.length l }) = let ix = L.length l - i - 1 in L.index l ix let iname_for_p (i:iname) (p:slprop) : W.s_predicate lock_store = fun l -> i < L.length l /\ (lock_i i l).inv == p let lock_store_evolves : FStar.Preorder.preorder lock_store = fun (l1 l2 : lock_store) -> L.length l2 >= L.length l1 /\ (forall (i:nat{i < L.length l1}). (lock_i i l1).inv == (lock_i i l2).inv) let inames_in (e:inames) (l:lock_store) : prop = forall i. Set.mem i e ==> i < L.length l let inames_ok e m = inames_in e m.locks let inames_ok_empty m = () let extend_lock_store (e:inames) (l:lock_store{e `inames_in` l}) (p:slprop) : i:iname & l':lock_store { lock_store_invariant e l' == p `star` lock_store_invariant e l /\ iname_for_p i p l' } = (| L.length l, Invariant p :: l |) let set_add (i:iname) (s:inames) = Set.union (Set.singleton i) s let rec move_invariant (e:inames) (l:lock_store) (p:slprop) (i:iname{iname_for_p i p l /\ ~(i `Set.mem` e)}) : Lemma (H.equiv (lock_store_invariant e l) (p `star` lock_store_invariant (set_add i e) l)) = let rec aux (i:iname) (m:lock_store) : Lemma (requires i >= L.length m) (ensures (lock_store_invariant e m `H.equiv` lock_store_invariant (set_add i e) m)) = match m with | [] -> () | Invariant p::tl -> aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl) in let current_addr = L.length l - 1 in match l with | [] -> () | Invariant q::tl -> if i = current_addr then begin assert (lock_store_invariant e l == p `star` lock_store_invariant e tl); aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl); () end else begin move_invariant e tl p i; assert (lock_store_invariant e tl `equiv` (p `star` lock_store_invariant (set_add i e) tl)); H.star_congruence q (lock_store_invariant e tl) q (p `star` lock_store_invariant (set_add i e) tl); if Set.mem current_addr e then () else begin let r = lock_store_invariant (set_add i e) tl in assert (lock_store_invariant e l `equiv` (q `star` (p `star` r))); H.star_associative q p r; H.star_commutative q p; H.star_congruence (q `star` p) r (p `star` q) r; H.star_associative p q r end end let heap_ctr_valid (ctr:nat) (h:H.heap u#a) : prop = h `H.free_above_addr` ctr let ctr_validity (ctr:nat) (h:H.heap) : slprop = H.pure (heap_ctr_valid ctr h) let locks_invariant (e:inames) (m:mem u#a) : slprop u#a = lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m) let full_mem_pred (m:mem) = H.full_heap_pred (heap_of_mem m) (***** Following lemmas are needed in Steel.Effect *****) let core_mem_interp (hp:slprop u#a) (m:mem u#a) = () let interp_depends_only_on (hp:slprop u#a) = H.interp_depends_only_on hp let a_mem_prop_as_a_heap_prop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (H.a_heap_prop u#a) = let g (h: H.heap u#a) : Tot prop = interp sl (mem_of_heap h) /\ f (mem_of_heap h) in let phi0 (h0 h1: H.heap u#a) : Lemma (requires (g h0 /\ H.disjoint h0 h1)) (ensures (g h0 /\ H.disjoint h0 h1 /\ g (H.join h0 h1))) = assert (mem_of_heap (H.join h0 h1) == mem_of_heap h0 `join` mem_of_heap h1); interp_depends_only_on sl in let phi1 (h0 h1: H.heap u#a) : Lemma (ensures ((g h0 /\ H.disjoint h0 h1) ==> g (H.join h0 h1))) = Classical.move_requires (phi0 h0) h1 in Classical.forall_intro_2 phi1; g let refine_slprop sl f = H.as_slprop (a_mem_prop_as_a_heap_prop sl f) let interp_refine_slprop sl f m = assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_mem m)) let dep_hprop (s: slprop) (f: (hmem s -> Tot slprop)) (h: H.heap) : Tot prop = exists (h1: H.heap) . exists (h2: H.heap) . interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 let dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq' : squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h')) = let p2 (h h1 h2: H.heap) : Tot prop = interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 in let p1 (h h1: H.heap) : Tot prop = (exists h2 . p2 h h1 h2) in let h1 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p1 h) in let h2 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p2 h h1) in H.disjoint_join h' h1 h2; assert (H.disjoint h2 h'); let h2' = H.join h2 h' in H.join_commutative h2 h' ; assert (h2' == H.join h' h2); assert (H.disjoint h1 h2'); assert (mem_of_heap h2' == mem_of_heap h2 `join` mem_of_heap h'); interp_depends_only_on (f (mem_of_heap h1)); assert (interp (f (mem_of_heap h1)) (mem_of_heap h2')); H.join_commutative h1 h2; H.join_associative h' h2 h1; H.join_commutative h' h; H.join_commutative h2' h1; assert (H.join h h' == h1 `H.join` h2') let impl_intro_gen (#p: Type0) (#q: Type0) ($prf: (squash p -> Lemma (q ))) : Lemma (p ==> q) = Classical.impl_intro_gen #p #(fun _ -> q) prf let dep_hprop_is_affine1 (s: slprop) (f: (hmem s -> Tot slprop)) (h0 h1: H.heap) : Lemma ((dep_hprop s f h0 /\ H.disjoint h0 h1) ==> (H.disjoint h0 h1 /\ dep_hprop s f (H.join h0 h1))) = impl_intro_gen (dep_hprop_is_affine0 s f h0 h1) let dep_hprop_is_affine (s: slprop) (f: (hmem s -> Tot slprop)) : Lemma (H.heap_prop_is_affine (dep_hprop s f)) = Classical.forall_intro_2 (dep_hprop_is_affine1 s f) let sdep (s: slprop) (f: (hmem s -> Tot slprop)) : Tot slprop = dep_hprop_is_affine s f; H.as_slprop (dep_hprop s f) let interp_sdep (s: slprop) (f: (hmem s -> Tot slprop)) (m: mem) : Lemma (requires (dep_slprop_is_affine s f)) (ensures ( interp (sdep s f) m <==> (exists m1 m2 . interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) )) = dep_hprop_is_affine s f; assert (forall m1 m2 . (interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) ==> ( interp s (mem_of_heap m1.heap) /\ interp (f (mem_of_heap m1.heap)) (mem_of_heap m2.heap) /\ H.disjoint m1.heap m2.heap /\ H.join m1.heap m2.heap == m.heap )); interp_depends_only_on s; Classical.forall_intro (fun m -> interp_depends_only_on (f m)); assert (forall h1 h2 . (interp s (mem_of_heap h1) /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ H.disjoint h1 h2 /\ H.join h1 h2 == m.heap) ==> ( core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ interp s (core_mem (mem_of_heap h1)) /\ interp s (mem_set_heap m h1) /\ core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ f (mem_set_heap m h1) `equiv` f (mem_of_heap h1) /\ interp (f (mem_set_heap m h1)) (mem_of_heap h2) /\ interp (f (mem_set_heap m h1)) (mem_set_heap m h2) /\ disjoint (mem_set_heap m h1) (mem_set_heap m h2) /\ join (mem_set_heap m h1) (mem_set_heap m h2) == m )); () let h_exists_cong (#a:Type) (p q : a -> slprop) : Lemma (requires (forall x. p x `equiv` q x)) (ensures (h_exists p `equiv` h_exists q)) = equiv_heap_iff_equiv_forall (); H.h_exists_cong p q let intro_h_exists #a x p m = H.intro_h_exists x p (heap_of_mem m) let elim_h_exists (#a:_) (p:a -> slprop) (m:mem) = H.elim_h_exists p (heap_of_mem m) let intro_h_forall (#a:_) (p:a -> slprop) (m:mem) = H.intro_h_forall p (heap_of_mem m) let elim_h_forall (#a:_) (p:a -> slprop) (m:mem) (x:a) = H.elim_h_forall p (heap_of_mem m) x let intro_h_and (p q: slprop) (m:mem) = H.intro_h_and p q (heap_of_mem m) let elim_h_and (p q: slprop) (m:mem) = H.elim_h_and p q (heap_of_mem m) let intro_h_or_left (p q: slprop) (m:mem) = H.intro_h_or_left p q (heap_of_mem m) let intro_h_or_right (p q: slprop) (m:mem) = H.intro_h_or_right p q (heap_of_mem m) let elim_h_or (p q: slprop) (m:mem) = H.elim_h_or p q (heap_of_mem m) let intro_wand (p1 p2: slprop u#a) (m:mem) = introduce (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)) ==> interp (wand p1 p2) m with _. ( assert (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)); H.intro_wand p1 p2 (heap_of_mem m); let h = heap_of_mem m in assert ((forall h1. h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) ==> H.interp (wand p1 p2) h); introduce forall h1. (h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) with ( introduce (h `H.disjoint` h1 /\ H.interp p1 h1) ==> H.interp p2 (H.join h h1) with _. ( assert (h `H.disjoint` h1); let m1 = { ctr = m.ctr; heap = h1; locks = m.locks } in assert (m `disjoint` m1) ) ) ) (** Eliminating a wand by proving a heap that satisfies the LHS **) let elim_wand (p1 p2: slprop u#a) (m:mem) (m1:mem) = H.elim_wand p1 p2 (heap_of_mem m) (heap_of_mem m1) //////////////////////////////////////////////////////////////////////////////// // Preorders and effects //////////////////////////////////////////////////////////////////////////////// module PP = Steel.Preorder let mem_evolves = fun (m0 m1:full_mem) -> H.heap_evolves (heap_of_mem m0) (heap_of_mem m1) /\ m0.ctr <= m1.ctr /\ lock_store_evolves m0.locks m1.locks (** See [Steel.Heap.is_frame_preserving]. We add in [lock_invariants] now *) let preserves_frame (e:inames) (pre post:slprop) (m0 m1:mem) = forall (frame:slprop). interp ((pre `star` frame) `star` locks_invariant e m0) m0 ==> (interp ((post `star` frame) `star` locks_invariant e m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) (** This is a version of MstTot with frame quantified, as part of preserves_frame *) effect MstTotNF (a:Type u#a) (except:inames) (expects:slprop u#1) (provides: a -> slprop u#1) = NMSTTotal.NMSTATETOT a (full_mem u#1) mem_evolves (requires fun m0 -> inames_ok except m0 /\ interp (expects `star` locks_invariant except m0) m0) (ensures fun m0 x m1 -> inames_ok except m1 /\ interp (provides x `star` locks_invariant except m1) m1 /\ preserves_frame except expects (provides x) m0 m1) //////////////////////////////////////////////////////////////////////////////// // Lifting heap actions //////////////////////////////////////////////////////////////////////////////// (** Heap actions come in two equivalent flavors: - one that take an explicit frame as argument (action_with_frame) - and one that quantify over all the frame We therefore define two lift routes: - a direct route for those with explicit frame - via MstTotNF for the rest *) let tot_pre_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = hmem_with_inv_except e fp -> (x:a & hmem_with_inv_except e (fp' x)) let tot_pre_action_nf = tot_pre_action_nf_except S.empty let ac_reasoning_for_m_frame_preserving (p q r:slprop u#a) (m:mem u#a) : Lemma (requires interp ((p `star` q) `star` r) m) (ensures interp (p `star` r) m) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_commutative p q; equiv_extensional_on_star (p `star` q) (q `star` p) r } (q `star` p) `star` r; (equiv) { star_associative q p r } q `star` (p `star` r); }; assert (interp (q `star` (p `star` r)) m); affine_star q (p `star` r) m let is_frame_preserving (#e:inames) (#a:Type u#b) (#fp:slprop u#a) (#fp':a -> slprop u#a) (f:tot_pre_action_nf_except e fp a fp') = forall (frame:slprop u#a) (m0:hmem_with_inv_except e (fp `star` frame)). (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = f:tot_pre_action_nf_except e fp a fp'{ is_frame_preserving f } let tot_action_nf = tot_action_nf_except S.empty let linv e (m:mem) = locks_invariant e m let hheap_of_hmem #fp #e (m:hmem_with_inv_except e fp) : h:H.hheap (fp `star` linv e m) { h `H.free_above_addr` m.ctr} = let h = heap_of_mem m in H.pure_interp (heap_ctr_valid m.ctr (heap_of_mem m)) h; h let hmem_of_hheap #e (#fp0 #fp1:slprop) (m:hmem_with_inv_except e fp0) (h:H.full_hheap (fp1 `star` linv e m) { h `Heap.free_above_addr` m.ctr }) : m1:hmem_with_inv_except e fp1{linv e m `equiv` linv e m1} = let m1 : mem = { m with heap = h } in assert (interp (fp1 `star` linv e m) m1); star_commutative fp1 (linv e m); assert (interp (linv e m `star` fp1) m1); assert (linv e m1 == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); assert (linv e m == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m)); H.pure_interp (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_of_mem m); assert (heap_ctr_valid m1.ctr (heap_of_mem m) <==> heap_ctr_valid m1.ctr (heap_of_mem m1)); H.pure_equiv (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_ctr_valid m1.ctr (heap_of_mem m1)); H.star_congruence (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m)); assert (linv e m `equiv` linv e m1); let _ = equiv_extensional_on_star (linv e m) (linv e m1) fp1 in assert ((linv e m `star` fp1) `equiv` (linv e m1 `star` fp1)); assert (interp (linv e m1 `star` fp1) m1); star_commutative (linv e m1) fp1; assert (interp (fp1 `star` linv e m1) m1); m1 let with_inv_except (m:mem) e (fp:slprop) = interp (fp `star` locks_invariant e m) m #push-options "--warn_error -271" let as_hprop (frame:slprop) (mp:mprop frame) : hp:H.hprop frame{forall m. mp (core_mem m) == hp (heap_of_mem m)} = let f = fun h -> mp (mem_of_heap h) in assert (forall m. mp (core_mem m) == f (heap_of_mem m)); let aux (m0:H.hheap frame) (m1:H.heap{H.disjoint m0 m1}) : Lemma (ensures (mem_of_heap (H.join m0 m1) == join (mem_of_heap m0) (mem_of_heap m1))) [SMTPat ()] = () in f let mprop_preservation_of_hprop_preservation (p:slprop) (m0 m1:mem) : Lemma (requires (forall (hp:H.hprop p). hp (heap_of_mem m0) == hp (heap_of_mem m1))) (ensures (forall (mp:mprop p). mp (core_mem m0) == mp (core_mem m1))) = let aux (mp:mprop p) : Lemma (mp (core_mem m0) == mp (core_mem m1)) [SMTPat()] = assert (as_hprop p mp (heap_of_mem m0) == as_hprop p mp (heap_of_mem m1)) in ()

{ "checked_file": "/", "dependencies": [ "Steel.Preorder.fst.checked", "Steel.Heap.fsti.checked", "prims.fst.checked", "FStar.Witnessed.Core.fsti.checked", "FStar.Set.fsti.checked", "FStar.Preorder.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.PCM.fst.checked", "FStar.NMSTTotal.fst.checked", "FStar.List.Tot.fst.checked", "FStar.IndefiniteDescription.fsti.checked", "FStar.Ghost.fsti.checked", "FStar.FunctionalExtensionality.fsti.checked", "FStar.Classical.Sugar.fsti.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Steel.Memory.fst" }

[ { "abbrev": true, "full_module": "Steel.Preorder", "short_module": "PP" }, { "abbrev": true, "full_module": "FStar.Witnessed.Core", "short_module": "W" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": true, "full_module": "Steel.Heap", "short_module": "H" }, { "abbrev": false, "full_module": "FStar.PCM", "short_module": null }, { "abbrev": false, "full_module": "FStar.FunctionalExtensionality", "short_module": null }, { "abbrev": true, "full_module": "FStar.FunctionalExtensionality", "short_module": "F" }, { "abbrev": false, "full_module": "FStar.PCM", "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

e: Steel.Memory.inames -> $f: Steel.Heap.action fp a fp' -> Steel.Memory.tot_action_nf_except e fp a fp'

Prims.Tot

[ "total" ]

[]

[ "Steel.Memory.slprop", "Steel.Memory.inames", "Steel.Heap.action", "Prims.unit", "Prims._assert", "Steel.Memory.is_frame_preserving", "Steel.Memory.hmem_with_inv_except", "Steel.Memory.star", "Prims.l_True", "Prims.squash", "Prims.l_and", "Steel.Memory.interp", "Steel.Memory.locks_invariant", "Steel.Memory.mem_evolves", "Prims.l_Forall", "Steel.Memory.mprop", "Prims.eq2", "Prims.prop", "Steel.Memory.core_mem", "Prims.Cons", "FStar.Pervasives.pattern", "FStar.Pervasives.smt_pat", "Prims.Nil", "Steel.Heap.full_hheap", "Steel.Memory.mprop_preservation_of_hprop_preservation", "Steel.Heap.hprop", "Steel.Memory.with_inv_except", "Steel.Memory.full_mem", "Prims.l_or", "Steel.Memory.inames_ok", "Steel.Memory.equiv", "Steel.Memory.linv", "Steel.Memory.hmem_of_hheap", "Steel.Heap.hheap", "Steel.Heap.interp", "Steel.Memory.star_associative", "Steel.Heap.action_framing", "Prims.dtuple2", "Steel.Heap.free_above_addr", "Steel.Memory.__proj__Mkmem__item__ctr", "Steel.Memory.hheap_of_hmem", "Steel.Memory.ac_reasoning_for_m_frame_preserving", "Steel.Memory.tot_pre_action_nf_except", "Prims.Mkdtuple2", "Steel.Memory.tot_action_nf_except" ]

[]

false

let lift_heap_action (#fp: slprop) (#a: Type) (#fp': (a -> slprop)) (e: inames) ($f: H.action fp a fp') : tot_action_nf_except e fp a fp' =

let g:tot_pre_action_nf_except e fp a fp' = fun m -> let h0 = hheap_of_hmem m in let (| x , h' |) = f h0 in (| x, hmem_of_hheap m h' |) in let aux (frame: slprop) (m0: hmem_with_inv_except e (fp `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x , m1 |) = g m0 in interp (((fp' x) `star` frame) `star` (locks_invariant e m1)) m1 /\ mem_evolves m0 m1 /\ (forall (mp: mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x , m1 |) = g m0 in let h0 = hheap_of_hmem m0 in let (| x' , h1 |) = f h0 in H.action_framing f (linv e m0) h0; assert (x == x'); star_associative fp frame (linv e m0); H.action_framing f (frame `star` (linv e m0)) h0; assert (H.interp ((fp' x) `star` (frame `star` (linv e m0))) h1); star_associative (fp' x) frame (linv e m0); assert (H.interp (((fp' x) `star` frame) `star` (linv e m0)) h1); let h1':H.hheap (((fp' x) `star` frame) `star` (linv e m0)) = h1 in assert (m1 == hmem_of_hheap m0 h1'); assert (with_inv_except m1 e ((fp' x) `star` frame)); assert (forall (hp: H.hprop frame). hp h0 == hp h1); mprop_preservation_of_hprop_preservation frame m0 m1; () in assert (is_frame_preserving g); g

false

Hacl.Spec.Poly1305.Field32xN.Lemmas.fst

Hacl.Spec.Poly1305.Field32xN.Lemmas.load_felem5_le

val load_felem5_le: b:lseq uint8 64 -> Lemma (let lo0 = vec_from_bytes_le U64 4 (sub b 0 32) in let hi0 = vec_from_bytes_le U64 4 (sub b 32 32) in let f = load_felem5_4 lo0 hi0 in felem_fits5 f (1, 1, 1, 1, 1) /\ felem_less5 f (pow2 128) /\ feval5 f == Vec.load_elem4 b)

let load_felem5_le b = let lo0 = vec_from_bytes_le U64 4 (sub b 0 32) in let hi0 = vec_from_bytes_le U64 4 (sub b 32 32) in let lo1 = vec_interleave_low_n 2 lo0 hi0 in let hi1 = vec_interleave_high_n 2 lo0 hi0 in let lo = vec_interleave_low lo1 hi1 in let hi = vec_interleave_high lo1 hi1 in let out = load_felem5_4_compact lo hi in load_felem5_4_interleave lo0 hi0; assert (out == load_felem5_4 lo0 hi0); load_felem5_4_lemma lo hi; Hacl.Impl.Poly1305.Lemmas.uints_from_bytes_le_lemma64_4 b; eq_intro (feval5 out) (Vec.load_elem4 b)

{ "file_name": "code/poly1305/Hacl.Spec.Poly1305.Field32xN.Lemmas.fst", "git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872", "git_url": "https://github.com/project-everest/hacl-star.git", "project_name": "hacl-star" }

{ "end_col": 42, "end_line": 764, "start_col": 0, "start_line": 750 }

module Hacl.Spec.Poly1305.Field32xN.Lemmas open Lib.IntTypes open Lib.IntVector open Lib.Sequence open FStar.Mul open Hacl.Spec.Poly1305.Field32xN open Hacl.Poly1305.Field32xN.Lemmas0 open Hacl.Poly1305.Field32xN.Lemmas1 open Hacl.Poly1305.Field32xN.Lemmas2 module Vec = Hacl.Spec.Poly1305.Vec #set-options "--z3rlimit 100 --max_fuel 0 --initial_ifuel 1 --max_ifuel 1 --using_facts_from '* -FStar.Seq'" val lemma_feval_is_fas_nat_i: #w:lanes -> f:felem5 w{felem_less5 f (pow2 128)} -> i:size_nat{i < w} -> Lemma ((feval5 f).[i] == (fas_nat5 f).[i]) let lemma_feval_is_fas_nat_i #w f i = assert_norm (pow2 128 < Vec.prime); assert ((feval5 f).[i] == (as_nat5 (transpose f).[i]) % Vec.prime); FStar.Math.Lemmas.modulo_lemma (as_nat5 (transpose f).[i]) Vec.prime val lemma_feval_is_fas_nat: #w:lanes -> f:felem5 w{felem_less5 f (pow2 128)} -> Lemma (forall (i:nat). i < w ==> (fas_nat5 f).[i] == (feval5 f).[i]) let lemma_feval_is_fas_nat #w f = FStar.Classical.forall_intro (lemma_feval_is_fas_nat_i #w f) val precomp_r5_fits_lemma: #w:lanes -> r:felem5 w{felem_fits5 r (1, 1, 1, 1, 1)} -> Lemma (felem_fits5 (precomp_r5 #w r) (5, 5, 5, 5, 5)) [SMTPat (precomp_r5 #w r)] let precomp_r5_fits_lemma #w r = FStar.Classical.forall_intro (precomp_r5_as_tup64 #w r) val precomp_r5_fits_lemma2: #w:lanes -> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)} -> Lemma (felem_fits5 (precomp_r5 #w r) (10, 10, 10, 10, 10)) [SMTPat (precomp_r5 #w r)] let precomp_r5_fits_lemma2 #w r = FStar.Classical.forall_intro (precomp_r5_as_tup64 #w r) val precomp_r5_zeros: w:lanes -> Lemma (let r = (zero w, zero w, zero w, zero w, zero w) in precomp_r5 r == (zero w, zero w, zero w, zero w, zero w)) let precomp_r5_zeros w = let r = (zero w, zero w, zero w, zero w, zero w) in let (r0, r1, r2, r3, r4) = precomp_r5 r in let aux (i:nat{i < w}) : Lemma ((vec_v (vec_smul_mod (zero w) (u64 5))).[i] == u64 0) = () in Classical.forall_intro aux; eq_intro (vec_v (vec_smul_mod (zero w) (u64 5))) (vec_v (zero w)); vecv_extensionality (vec_smul_mod (zero w) (u64 5)) (zero w) val fadd5_fits_lemma: #w:lanes -> f1:felem5 w{felem_fits5 f1 (2,2,2,2,2)} -> f2:felem5 w{felem_fits5 f2 (1,1,1,1,1)} -> Lemma (felem_fits5 (fadd5 f1 f2) (3,3,3,3,3)) [SMTPat (fadd5 f1 f2)] let fadd5_fits_lemma #w f1 f2 = let (f10, f11, f12, f13, f14) = f1 in let (f20, f21, f22, f23, f24) = f2 in let o = fadd5 f1 f2 in vec_add_mod_lemma f10 f20; vec_add_mod_lemma f11 f21; vec_add_mod_lemma f12 f22; vec_add_mod_lemma f13 f23; vec_add_mod_lemma f14 f24 val fadd5_eval_lemma: #w:lanes -> f1:felem5 w{felem_fits5 f1 (2,2,2,2,2)} -> f2:felem5 w{felem_fits5 f2 (1,1,1,1,1)} -> Lemma (feval5 (fadd5 f1 f2) == map2 Vec.pfadd (feval5 f1) (feval5 f2)) [SMTPat (fadd5 f1 f2)] let fadd5_eval_lemma #w f1 f2 = let o = fadd5 f1 f2 in FStar.Classical.forall_intro (fadd5_eval_lemma_i f1 f2); eq_intro (feval5 o) (map2 Vec.pfadd (feval5 f1) (feval5 f2)) val mul_felem5_fits_lemma: #w:lanes -> f1:felem5 w{felem_fits5 f1 (3, 3, 3, 3, 3)} -> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)} -> r5:felem5 w{felem_fits5 r5 (10, 10, 10, 10, 10)} -> Lemma (felem_wide_fits5 (mul_felem5 #w f1 r r5) (126, 102, 78, 54, 30)) [SMTPat (mul_felem5 #w f1 r r5)] let mul_felem5_fits_lemma #w f1 r r5 = let (r0, r1, r2, r3, r4) = r in let (f10, f11, f12, f13, f14) = f1 in let (r50, r51, r52, r53, r54) = r5 in let (a0,a1,a2,a3,a4) = smul_felem5 #w f10 (r0,r1,r2,r3,r4) in smul_felem5_fits_lemma #w #3 #(2,2,2,2,2) f10 (r0,r1,r2,r3,r4); let (a10,a11,a12,a13,a14) = smul_add_felem5 #w f11 (r54,r0,r1,r2,r3) (a0,a1,a2,a3,a4) in smul_add_felem5_fits_lemma #w #3 #(10,2,2,2,2) #(6,6,6,6,6) f11 (r54,r0,r1,r2,r3) (a0,a1,a2,a3,a4); let (a20,a21,a22,a23,a24) = smul_add_felem5 #w f12 (r53,r54,r0,r1,r2) (a10,a11,a12,a13,a14) in smul_add_felem5_fits_lemma #w #3 #(10,10,2,2,2) #(36,12,12,12,12) f12 (r53,r54,r0,r1,r2) (a10,a11,a12,a13,a14); let (a30,a31,a32,a33,a34) = smul_add_felem5 #w f13 (r52,r53,r54,r0,r1) (a20,a21,a22,a23,a24) in smul_add_felem5_fits_lemma #w #3 #(10,10,10,2,2) #(66,42,18,18,18) f13 (r52,r53,r54,r0,r1) (a20,a21,a22,a23,a24); let (a40,a41,a42,a43,a44) = smul_add_felem5 #w f14 (r51,r52,r53,r54,r0) (a30,a31,a32,a33,a34) in smul_add_felem5_fits_lemma #w #3 #(10,10,10,10,2) #(96,72,48,24,24) f14 (r51,r52,r53,r54,r0) (a30,a31,a32,a33,a34) val mul_felem5_eval_lemma_i: #w:lanes -> f1:felem5 w{felem_fits5 f1 (3, 3, 3, 3, 3)} -> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)} -> r5:felem5 w{felem_fits5 r5 (10, 10, 10, 10, 10) /\ r5 == precomp_r5 r} -> i:nat{i < w} -> Lemma ((feval5 (mul_felem5 #w f1 r r5)).[i] == (feval5 f1).[i] `Vec.pfmul` (feval5 r).[i]) let mul_felem5_eval_lemma_i #w f1 r r5 i = let (r0, r1, r2, r3, r4) = r in let (f10, f11, f12, f13, f14) = f1 in let (r50, r51, r52, r53, r54) = r5 in let (a0,a1,a2,a3,a4) = smul_felem5 #w f10 (r0,r1,r2,r3,r4) in smul_felem5_eval_lemma #w #3 #(2,2,2,2,2) f10 (r0,r1,r2,r3,r4); smul_felem5_fits_lemma #w #3 #(2,2,2,2,2) f10 (r0,r1,r2,r3,r4); assert ((fas_nat5 (a0,a1,a2,a3,a4)).[i] == (uint64xN_v f10).[i] * (fas_nat5 (r0,r1,r2,r3,r4)).[i]); let (a10,a11,a12,a13,a14) = smul_add_felem5 #w f11 (r54,r0,r1,r2,r3) (a0,a1,a2,a3,a4) in smul_add_felem5_eval_lemma #w #3 #(10,2,2,2,2) #(6,6,6,6,6) f11 (r54,r0,r1,r2,r3) (a0,a1,a2,a3,a4); smul_add_felem5_fits_lemma #w #3 #(10,2,2,2,2) #(6,6,6,6,6) f11 (r54,r0,r1,r2,r3) (a0,a1,a2,a3,a4); assert ((fas_nat5 (a10,a11,a12,a13,a14)).[i] == (fas_nat5 (a0,a1,a2,a3,a4)).[i] + (uint64xN_v f11).[i] * (fas_nat5 (r54,r0,r1,r2,r3)).[i]); let (a20,a21,a22,a23,a24) = smul_add_felem5 #w f12 (r53,r54,r0,r1,r2) (a10,a11,a12,a13,a14) in smul_add_felem5_eval_lemma #w #3 #(10,10,2,2,2) #(36,12,12,12,12) f12 (r53,r54,r0,r1,r2) (a10,a11,a12,a13,a14); smul_add_felem5_fits_lemma #w #3 #(10,10,2,2,2) #(36,12,12,12,12) f12 (r53,r54,r0,r1,r2) (a10,a11,a12,a13,a14); assert ((fas_nat5 (a20,a21,a22,a23,a24)).[i] == (fas_nat5 (a10,a11,a12,a13,a14)).[i] + (uint64xN_v f12).[i] * (fas_nat5 (r53,r54,r0,r1,r2)).[i]); let (a30,a31,a32,a33,a34) = smul_add_felem5 #w f13 (r52,r53,r54,r0,r1) (a20,a21,a22,a23,a24) in smul_add_felem5_eval_lemma #w #3 #(10,10,10,2,2) #(66,42,18,18,18) f13 (r52,r53,r54,r0,r1) (a20,a21,a22,a23,a24); smul_add_felem5_fits_lemma #w #3 #(10,10,10,2,2) #(66,42,18,18,18) f13 (r52,r53,r54,r0,r1) (a20,a21,a22,a23,a24); assert ((fas_nat5 (a30,a31,a32,a33,a34)).[i] == (fas_nat5 (a20,a21,a22,a23,a24)).[i] + (uint64xN_v f13).[i] * (fas_nat5 (r52,r53,r54,r0,r1)).[i]); let (a40,a41,a42,a43,a44) = smul_add_felem5 #w f14 (r51,r52,r53,r54,r0) (a30,a31,a32,a33,a34) in smul_add_felem5_eval_lemma #w #3 #(10,10,10,10,2) #(96,72,48,24,24) f14 (r51,r52,r53,r54,r0) (a30,a31,a32,a33,a34); smul_add_felem5_fits_lemma #w #3 #(10,10,10,10,2) #(96,72,48,24,24) f14 (r51,r52,r53,r54,r0) (a30,a31,a32,a33,a34); assert ((fas_nat5 (a40,a41,a42,a43,a44)).[i] == (fas_nat5 (a30,a31,a32,a33,a34)).[i] + (uint64xN_v f14).[i] * (fas_nat5 (r51,r52,r53,r54,r0)).[i]); assert ((fas_nat5 (a40,a41,a42,a43,a44)).[i] == (uint64xN_v f10).[i] * (fas_nat5 (r0,r1,r2,r3,r4)).[i] + (uint64xN_v f11).[i] * (fas_nat5 (r54,r0,r1,r2,r3)).[i] + (uint64xN_v f12).[i] * (fas_nat5 (r53,r54,r0,r1,r2)).[i] + (uint64xN_v f13).[i] * (fas_nat5 (r52,r53,r54,r0,r1)).[i] + (uint64xN_v f14).[i] * (fas_nat5 (r51,r52,r53,r54,r0)).[i]); mul_felem5_eval_as_tup64 #w f1 r r5 i; mul_felem5_lemma (as_tup64_i f1 i) (as_tup64_i r i) val mul_felem5_eval_lemma: #w:lanes -> f1:felem5 w{felem_fits5 f1 (3, 3, 3, 3, 3)} -> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)} -> r5:felem5 w{felem_fits5 r5 (10, 10, 10, 10, 10) /\ r5 == precomp_r5 r} -> Lemma (feval5 (mul_felem5 #w f1 r r5) == map2 (Vec.pfmul) (feval5 f1) (feval5 r)) [SMTPat (mul_felem5 #w f1 r r5)] let mul_felem5_eval_lemma #w f1 r r5 = let tmp = map2 (Vec.pfmul) (feval5 f1) (feval5 r) in FStar.Classical.forall_intro (mul_felem5_eval_lemma_i #w f1 r r5); eq_intro (feval5 (mul_felem5 #w f1 r r5)) tmp val fmul_r5_fits_lemma: #w:lanes -> f1:felem5 w{felem_fits5 f1 (3, 3, 3, 3, 3)} -> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)} -> r5:felem5 w{felem_fits5 r5 (10, 10, 10, 10, 10)} -> Lemma (felem_fits5 (fmul_r5 #w f1 r r5) (1, 2, 1, 1, 2)) [SMTPat (fmul_r5 #w f1 r r5)] let fmul_r5_fits_lemma #w f1 r r5 = let tmp = mul_felem5 f1 r r5 in mul_felem5_fits_lemma #w f1 r r5; let res = carry_wide_felem5 tmp in carry_wide_felem5_fits_lemma #w tmp val fmul_r5_eval_lemma: #w:lanes -> f1:felem5 w{felem_fits5 f1 (3, 3, 3, 3, 3)} -> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)} -> r5:felem5 w{felem_fits5 r5 (10, 10, 10, 10, 10) /\ r5 == precomp_r5 r} -> Lemma (feval5 (fmul_r5 #w f1 r r5) == map2 (Vec.pfmul) (feval5 f1) (feval5 r)) [SMTPat (fmul_r5 #w f1 r r5)] let fmul_r5_eval_lemma #w f1 r r5 = let tmp = mul_felem5 f1 r r5 in mul_felem5_eval_lemma #w f1 r r5; let res = carry_wide_felem5 tmp in carry_wide_felem5_eval_lemma #w tmp val fadd_mul_r5_fits_lemma: #w:lanes -> acc:felem5 w{felem_fits5 acc (2, 2, 2, 2, 2)} -> f1:felem5 w{felem_fits5 f1 (1, 1, 1, 1, 1)} -> r:felem5 w{felem_fits5 r (1, 1, 1, 1, 1)} -> r5:felem5 w{felem_fits5 r5 (5, 5, 5, 5, 5)} -> Lemma (felem_fits5 (fadd_mul_r5 acc f1 r r5) (1, 2, 1, 1, 2)) [SMTPat (fadd_mul_r5 acc f1 r r5)] let fadd_mul_r5_fits_lemma #w acc f1 r r5 = let acc1 = fadd5 acc f1 in fadd5_fits_lemma #w acc f1; let tmp = mul_felem5 acc1 r r5 in mul_felem5_fits_lemma #w acc1 r r5; let res = carry_wide_felem5 tmp in carry_wide_felem5_fits_lemma #w tmp val fadd_mul_r5_eval_lemma: #w:lanes -> acc:felem5 w{felem_fits5 acc (2, 2, 2, 2, 2)} -> f1:felem5 w{felem_fits5 f1 (1, 1, 1, 1, 1)} -> r:felem5 w{felem_fits5 r (1, 1, 1, 1, 1)} -> r5:felem5 w{felem_fits5 r5 (5, 5, 5, 5, 5) /\ r5 == precomp_r5 r} -> Lemma (feval5 (fadd_mul_r5 acc f1 r r5) == map2 (Vec.pfmul) (map2 (Vec.pfadd) (feval5 acc) (feval5 f1)) (feval5 r)) [SMTPat (fadd_mul_r5 acc f1 r r5)] let fadd_mul_r5_eval_lemma #w acc f1 r r5 = let acc1 = fadd5 acc f1 in fadd5_eval_lemma #w acc f1; let tmp = mul_felem5 acc1 r r5 in mul_felem5_eval_lemma #w acc1 r r5; let res = carry_wide_felem5 tmp in carry_wide_felem5_eval_lemma #w tmp val reduce_felem5_eval_lemma: #w:lanes -> f:felem5 w{felem_fits5 f (2, 2, 2, 2, 2)} -> Lemma (felem_fits5 (reduce_felem5 f) (1, 1, 1, 1, 1) /\ (feval5 f).[0] == (fas_nat5 (reduce_felem5 f)).[0]) [SMTPat (reduce_felem5 f)] let reduce_felem5_eval_lemma #w f = carry_full_felem5_eval_lemma f; carry_full_felem5_fits_lemma f; let f = carry_full_felem5 f in carry_reduce_felem5_lemma #w f; subtract_p5_felem5_lemma #w (carry_full_felem5 f) val fmul_r2_normalize50: acc:felem5 2 -> r:felem5 2 -> r2:felem5 2 -> Pure (felem5 2) (requires felem_fits5 acc (3, 3, 3, 3, 3) /\ felem_fits5 r (1, 1, 1, 1, 1) /\ felem_fits5 r2 (2, 2, 2, 2, 2) /\ feval5 r2 == Vec.compute_r2 (feval5 r).[0]) (ensures fun a -> let fr21 = create2 (feval5 r2).[0] (feval5 r).[0] in feval5 a == Vec.fmul (feval5 acc) fr21 /\ felem_fits5 a (1, 2, 1, 1, 2)) let fmul_r2_normalize50 (a0, a1, a2, a3, a4) (r0, r1, r2, r3, r4) (r20, r21, r22, r23, r24) = let r210 = vec_interleave_low r20 r0 in vec_interleave_low_lemma2 r20 r0; let r211 = vec_interleave_low r21 r1 in vec_interleave_low_lemma2 r21 r1; let r212 = vec_interleave_low r22 r2 in vec_interleave_low_lemma2 r22 r2; let r213 = vec_interleave_low r23 r3 in vec_interleave_low_lemma2 r23 r3; let r214 = vec_interleave_low r24 r4 in vec_interleave_low_lemma2 r24 r4; let acc = (a0, a1, a2, a3, a4) in let fr = (r0, r1, r2, r3, r4) in let fr2 = (r20, r21, r22, r23, r24) in assert ((feval5 fr2).[0] == Vec.pfmul ((feval5 fr).[0]) ((feval5 fr).[0])); let fr21 = (r210, r211, r212, r213, r214) in eq_intro (feval5 fr21) (create2 (feval5 fr2).[0] (feval5 fr).[0]); assert (feval5 fr21 == create2 (feval5 fr2).[0] (feval5 fr).[0]); assert (felem_fits5 fr21 (2, 2, 2, 2, 2)); let fr215 = precomp_r5 #2 fr21 in let a = fmul_r5 #2 acc fr21 fr215 in fmul_r5_eval_lemma acc fr21 fr215; fmul_r5_fits_lemma acc fr21 fr215; assert (feval5 a == Vec.fmul (feval5 acc) (feval5 fr21)); assert (felem_fits5 a (1, 2, 1, 1, 2)); a #push-options "--z3rlimit 150" val fmul_r2_normalize51: a:felem5 2 -> fa1:felem5 2 -> Pure (felem5 2) (requires felem_fits5 a (1, 2, 1, 1, 2) /\ felem_fits5 fa1 (1, 2, 1, 1, 2) /\ feval5 fa1 == create2 (feval5 a).[1] (feval5 a).[1]) (ensures fun out -> (feval5 out).[0] == Vec.pfadd (feval5 a).[0] (feval5 a).[1] /\ felem_fits5 out (2, 4, 2, 2, 4)) let fmul_r2_normalize51 a fa1 = let (a0, a1, a2, a3, a4) = a in let (a10, a11, a12, a13, a14) = fa1 in let o0 = vec_add_mod a0 a10 in let o1 = vec_add_mod a1 a11 in let o2 = vec_add_mod a2 a12 in let o3 = vec_add_mod a3 a13 in let o4 = vec_add_mod a4 a14 in let out = (o0, o1, o2, o3, o4) in let (a0, a1, a2, a3, a4) = as_tup64_i a 0 in let (a10, a11, a12, a13, a14) = as_tup64_i fa1 0 in let (o0, o1, o2, o3, o4) = as_tup64_i out 0 in FStar.Math.Lemmas.modulo_lemma (v a0 + v a10) (pow2 64); FStar.Math.Lemmas.modulo_lemma (v a1 + v a11) (pow2 64); FStar.Math.Lemmas.modulo_lemma (v a2 + v a12) (pow2 64); FStar.Math.Lemmas.modulo_lemma (v a3 + v a13) (pow2 64); FStar.Math.Lemmas.modulo_lemma (v a4 + v a14) (pow2 64); assert (felem_fits5 out (2, 4, 2, 2, 4)); calc (==) { ((feval5 a).[0] + (feval5 a).[1]) % Vec.prime; (==) { } (as_nat5 (a0, a1, a2, a3, a4) % Vec.prime + as_nat5 (a10, a11, a12, a13, a14) % Vec.prime) % Vec.prime; (==) { FStar.Math.Lemmas.lemma_mod_plus_distr_l (as_nat5 (a0, a1, a2, a3, a4)) (as_nat5 (a10, a11, a12, a13, a14)) Vec.prime; FStar.Math.Lemmas.lemma_mod_plus_distr_r (as_nat5 (a0, a1, a2, a3, a4) % Vec.prime) (as_nat5 (a10, a11, a12, a13, a14)) Vec.prime } (as_nat5 (a0, a1, a2, a3, a4) + as_nat5 (a10, a11, a12, a13, a14)) % Vec.prime; (==) { } (feval5 out).[0]; }; out #pop-options val fmul_r2_normalize5_lemma: acc:felem5 2 -> r:felem5 2 -> r2:felem5 2 -> Lemma (requires felem_fits5 acc (3, 3, 3, 3, 3) /\ felem_fits5 r (1, 1, 1, 1, 1) /\ felem_fits5 r2 (2, 2, 2, 2, 2) /\ feval5 r2 == Vec.compute_r2 (feval5 r).[0]) (ensures (let out = fmul_r2_normalize5 acc r r2 in felem_fits5 out (2, 1, 1, 1, 1) /\ (feval5 out).[0] == Vec.normalize_2 (feval5 r).[0] (feval5 acc))) [SMTPat (fmul_r2_normalize5 acc r r2)] let fmul_r2_normalize5_lemma acc r r2 = let a = fmul_r2_normalize50 acc r r2 in let (a0, a1, a2, a3, a4) = a in let a10 = vec_interleave_high a0 a0 in vec_interleave_high_lemma2 a0 a0; let a11 = vec_interleave_high a1 a1 in vec_interleave_high_lemma2 a1 a1; let a12 = vec_interleave_high a2 a2 in vec_interleave_high_lemma2 a2 a2; let a13 = vec_interleave_high a3 a3 in vec_interleave_high_lemma2 a3 a3; let a14 = vec_interleave_high a4 a4 in vec_interleave_high_lemma2 a4 a4; let fa1 = (a10, a11, a12, a13, a14) in eq_intro (feval5 fa1) (create2 (feval5 a).[1] (feval5 a).[1]); assert (feval5 fa1 == create2 (feval5 a).[1] (feval5 a).[1]); assert (felem_fits5 fa1 (1, 2, 1, 1, 2)); let out = fmul_r2_normalize51 a fa1 in assert ((feval5 out).[0] == Vec.pfadd (feval5 a).[0] (feval5 a).[1]); let res = carry_full_felem5 out in carry_full_felem5_lemma out val fmul_r4_normalize50: acc:felem5 4 -> r:felem5 4 -> r2:felem5 4 -> r3:felem5 4 -> r4:felem5 4 -> Pure (felem5 4) (requires felem_fits5 acc (3, 3, 3, 3, 3) /\ felem_fits5 r (1, 1, 1, 1, 1) /\ felem_fits5 r2 (2, 2, 2, 2, 2) /\ felem_fits5 r3 (2, 2, 2, 2, 2) /\ felem_fits5 r4 (2, 2, 2, 2, 2) /\ feval5 r2 == Vec.fmul (feval5 r) (feval5 r) /\ feval5 r3 == Vec.fmul (feval5 r2) (feval5 r) /\ feval5 r4 == Vec.compute_r4 (feval5 r).[0]) (ensures fun out -> let fr4321 = create4 (feval5 r4).[0] (feval5 r3).[0] (feval5 r2).[0] (feval5 r).[0] in feval5 out == Vec.fmul (feval5 acc) fr4321 /\ felem_fits5 out (1, 2, 1, 1, 2)) let fmul_r4_normalize50 acc fr fr2 fr3 fr4 = let (r10, r11, r12, r13, r14) = fr in let (r20, r21, r22, r23, r24) = fr2 in let (r30, r31, r32, r33, r34) = fr3 in let (r40, r41, r42, r43, r44) = fr4 in let (a0, a1, a2, a3, a4) = acc in let v12120 = vec_interleave_low r20 r10 in vec_interleave_low_lemma_uint64_4 r20 r10; let v34340 = vec_interleave_low r40 r30 in vec_interleave_low_lemma_uint64_4 r40 r30; let r12340 = vec_interleave_low_n 2 v34340 v12120 in vec_interleave_low_n_lemma_uint64_4_2 v34340 v12120; let v12121 = vec_interleave_low r21 r11 in vec_interleave_low_lemma_uint64_4 r21 r11; let v34341 = vec_interleave_low r41 r31 in vec_interleave_low_lemma_uint64_4 r41 r31; let r12341 = vec_interleave_low_n 2 v34341 v12121 in vec_interleave_low_n_lemma_uint64_4_2 v34341 v12121; let v12122 = vec_interleave_low r22 r12 in vec_interleave_low_lemma_uint64_4 r22 r12; let v34342 = vec_interleave_low r42 r32 in vec_interleave_low_lemma_uint64_4 r42 r32; let r12342 = vec_interleave_low_n 2 v34342 v12122 in vec_interleave_low_n_lemma_uint64_4_2 v34342 v12122; let v12123 = vec_interleave_low r23 r13 in vec_interleave_low_lemma_uint64_4 r23 r13; let v34343 = vec_interleave_low r43 r33 in vec_interleave_low_lemma_uint64_4 r43 r33; let r12343 = vec_interleave_low_n 2 v34343 v12123 in vec_interleave_low_n_lemma_uint64_4_2 v34343 v12123; let v12124 = vec_interleave_low r24 r14 in vec_interleave_low_lemma_uint64_4 r24 r14; let v34344 = vec_interleave_low r44 r34 in vec_interleave_low_lemma_uint64_4 r44 r34; let r12344 = vec_interleave_low_n 2 v34344 v12124 in vec_interleave_low_n_lemma_uint64_4_2 v34344 v12124; let fr1234 = (r12340, r12341, r12342, r12343, r12344) in eq_intro (feval5 fr1234) (create4 (feval5 fr4).[0] (feval5 fr3).[0] (feval5 fr2).[0] (feval5 fr).[0]); let fr12345 = precomp_r5 #4 fr1234 in let out = fmul_r5 #4 acc fr1234 fr12345 in fmul_r5_eval_lemma acc fr1234 fr12345; fmul_r5_fits_lemma acc fr1234 fr12345; out val lemma_fmul_r4_normalize51: #m:scale32{m <= 2} -> o:uint64xN 4{felem_fits1 o m} -> Lemma (let v00 = vec_interleave_high_n 2 o o in let v10 = vec_add_mod o v00 in let v10h = vec_interleave_high v10 v10 in let v20 = vec_add_mod v10 v10h in felem_fits1 v20 (4 * m) /\ (uint64xN_v v20).[0] == (uint64xN_v o).[0] + (uint64xN_v o).[1] + (uint64xN_v o).[2] + (uint64xN_v o).[3]) let lemma_fmul_r4_normalize51 #m o = let v00 = vec_interleave_high_n 2 o o in vec_interleave_high_n_lemma_uint64_4_2 o o; let (o0, o1, o2, o3) = ((vec_v o).[0], (vec_v o).[1], (vec_v o).[2], (vec_v o).[3]) in assert (vec_v v00 == create4 o2 o3 o2 o3); let v10 = vec_add_mod o v00 in FStar.Math.Lemmas.modulo_lemma (v o0 + v o2) (pow2 64); FStar.Math.Lemmas.modulo_lemma (v o1 + v o3) (pow2 64); assert (v (vec_v v10).[0] == v o0 + v o2); assert (v (vec_v v10).[1] == v o1 + v o3); let v10h = vec_interleave_high v10 v10 in vec_interleave_high_lemma_uint64_4 v10 v10; assert (v (vec_v v10h).[0] == v (vec_v v10).[1]); let v20 = vec_add_mod v10 v10h in FStar.Math.Lemmas.modulo_lemma (v o0 + v o2 + v o1 + v o3) (pow2 64) val lemma_fmul_r4_normalize51_expand: v2:felem5 4 -> out:felem5 4 -> Lemma (requires (let (v20, v21, v22, v23, v24) = v2 in let (o0, o1, o2, o3, o4) = out in (uint64xN_v v20).[0] == (uint64xN_v o0).[0] + (uint64xN_v o0).[1] + (uint64xN_v o0).[2] + (uint64xN_v o0).[3] /\ (uint64xN_v v21).[0] == (uint64xN_v o1).[0] + (uint64xN_v o1).[1] + (uint64xN_v o1).[2] + (uint64xN_v o1).[3] /\ (uint64xN_v v22).[0] == (uint64xN_v o2).[0] + (uint64xN_v o2).[1] + (uint64xN_v o2).[2] + (uint64xN_v o2).[3] /\ (uint64xN_v v23).[0] == (uint64xN_v o3).[0] + (uint64xN_v o3).[1] + (uint64xN_v o3).[2] + (uint64xN_v o3).[3] /\ (uint64xN_v v24).[0] == (uint64xN_v o4).[0] + (uint64xN_v o4).[1] + (uint64xN_v o4).[2] + (uint64xN_v o4).[3])) (ensures (let (v20, v21, v22, v23, v24) = v2 in let (o0, o1, o2, o3, o4) = out in (feval5 v2).[0] == Vec.pfadd (Vec.pfadd (Vec.pfadd (feval5 out).[0] (feval5 out).[1]) (feval5 out).[2]) (feval5 out).[3])) let lemma_fmul_r4_normalize51_expand v2 out = let (v20, v21, v22, v23, v24) = as_tup64_i v2 0 in let (o0, o1, o2, o3, o4) = out in calc (==) { as_nat5 (v20, v21, v22, v23, v24) % Vec.prime; (==) { } (as_nat5 (as_tup64_i out 0) + as_nat5 (as_tup64_i out 1) + as_nat5 (as_tup64_i out 2) + as_nat5 (as_tup64_i out 3)) % Vec.prime; (==) { FStar.Math.Lemmas.lemma_mod_plus_distr_l (as_nat5 (as_tup64_i out 0) + as_nat5 (as_tup64_i out 1)) (as_nat5 (as_tup64_i out 2) + as_nat5 (as_tup64_i out 3)) Vec.prime } ((as_nat5 (as_tup64_i out 0) + as_nat5 (as_tup64_i out 1)) % Vec.prime + as_nat5 (as_tup64_i out 2) + as_nat5 (as_tup64_i out 3)) % Vec.prime; (==) { FStar.Math.Lemmas.modulo_distributivity (as_nat5 (as_tup64_i out 0)) (as_nat5 (as_tup64_i out 1)) Vec.prime } (((feval5 out).[0] + (feval5 out).[1]) % Vec.prime + as_nat5 (as_tup64_i out 2) + as_nat5 (as_tup64_i out 3)) % Vec.prime; (==) { FStar.Math.Lemmas.lemma_mod_plus_distr_l (((feval5 out).[0] + (feval5 out).[1]) % Vec.prime + as_nat5 (as_tup64_i out 2)) (as_nat5 (as_tup64_i out 3)) Vec.prime } ((((feval5 out).[0] + (feval5 out).[1]) % Vec.prime + as_nat5 (as_tup64_i out 2)) % Vec.prime + as_nat5 (as_tup64_i out 3)) % Vec.prime; (==) { FStar.Math.Lemmas.lemma_mod_plus_distr_r (((feval5 out).[0] + (feval5 out).[1]) % Vec.prime) (as_nat5 (as_tup64_i out 2)) Vec.prime } ((((feval5 out).[0] + (feval5 out).[1]) % Vec.prime + (feval5 out).[2]) % Vec.prime + as_nat5 (as_tup64_i out 3)) % Vec.prime; (==) { FStar.Math.Lemmas.lemma_mod_plus_distr_r ((((feval5 out).[0] + (feval5 out).[1]) % Vec.prime + (feval5 out).[2]) % Vec.prime) (as_nat5 (as_tup64_i out 3)) Vec.prime } ((((feval5 out).[0] + (feval5 out).[1]) % Vec.prime + (feval5 out).[2]) % Vec.prime + (feval5 out).[3]) % Vec.prime; }; assert ((feval5 v2).[0] == ((((feval5 out).[0] + (feval5 out).[1]) % Vec.prime + (feval5 out).[2]) % Vec.prime + (feval5 out).[3]) % Vec.prime) val fmul_r4_normalize51: a:felem5 4 -> Pure (felem5 4) (requires felem_fits5 a (1, 2, 1, 1, 2)) (ensures fun res -> felem_fits5 res (4, 8, 4, 4, 8) /\ (feval5 res).[0] == Vec.pfadd (Vec.pfadd (Vec.pfadd (feval5 a).[0] (feval5 a).[1]) (feval5 a).[2]) (feval5 a).[3]) let fmul_r4_normalize51 fa = let (o0, o1, o2, o3, o4) = fa in let v00 = vec_interleave_high_n 2 o0 o0 in let v10 = vec_add_mod o0 v00 in let v10h = vec_interleave_high v10 v10 in let v20 = vec_add_mod v10 v10h in lemma_fmul_r4_normalize51 #1 o0; let v01 = vec_interleave_high_n 2 o1 o1 in let v11 = vec_add_mod o1 v01 in let v11h = vec_interleave_high v11 v11 in let v21 = vec_add_mod v11 v11h in lemma_fmul_r4_normalize51 #2 o1; let v02 = vec_interleave_high_n 2 o2 o2 in let v12 = vec_add_mod o2 v02 in let v12h = vec_interleave_high v12 v12 in let v22 = vec_add_mod v12 v12h in lemma_fmul_r4_normalize51 #1 o2; let v03 = vec_interleave_high_n 2 o3 o3 in let v13 = vec_add_mod o3 v03 in let v13h = vec_interleave_high v13 v13 in let v23 = vec_add_mod v13 v13h in lemma_fmul_r4_normalize51 #1 o3; let v04 = vec_interleave_high_n 2 o4 o4 in let v14 = vec_add_mod o4 v04 in let v14h = vec_interleave_high v14 v14 in let v24 = vec_add_mod v14 v14h in lemma_fmul_r4_normalize51 #2 o4; let res = (v20, v21, v22, v23, v24) in lemma_fmul_r4_normalize51_expand res fa; res val fmul_r4_normalize5_lemma: acc:felem5 4 -> r:felem5 4 -> r_5:felem5 4 -> r4:felem5 4 -> Lemma (requires felem_fits5 acc (3, 3, 3, 3, 3) /\ felem_fits5 r (1, 1, 1, 1, 1) /\ felem_fits5 r4 (2, 2, 2, 2, 2) /\ r_5 == precomp_r5 r /\ feval5 r4 == Vec.compute_r4 (feval5 r).[0]) (ensures (let out = fmul_r4_normalize5 acc r r_5 r4 in felem_fits5 out (2, 1, 1, 1, 1) /\ (feval5 out).[0] == Vec.normalize_4 (feval5 r).[0] (feval5 acc))) [SMTPat (fmul_r4_normalize5 acc r r_5 r4)] #restart-solver #push-options "--z3rlimit 500" let fmul_r4_normalize5_lemma acc fr fr_5 fr4 = let fr2 = fmul_r5 #4 fr fr fr_5 in let fr3 = fmul_r5 #4 fr2 fr fr_5 in let out = fmul_r4_normalize50 acc fr fr2 fr3 fr4 in let v2 = fmul_r4_normalize51 out in let res = carry_full_felem5 v2 in carry_full_felem5_lemma v2 #pop-options val load_felem5_lemma: #w:lanes -> lo:uint64xN w -> hi:uint64xN w -> Lemma (let f = load_felem5 #w lo hi in felem_fits5 f (1, 1, 1, 1, 1) /\ felem_less5 f (pow2 128) /\ feval5 f == createi #Vec.pfelem w (fun i -> (uint64xN_v hi).[i] * pow2 64 + (uint64xN_v lo).[i])) let load_felem5_lemma #w lo hi = let f = load_felem5 #w lo hi in assert_norm (pow2 64 * pow2 64 = pow2 128); assert_norm (pow2 128 < Vec.prime); let res = createi #Vec.pfelem w (fun i -> (uint64xN_v hi).[i] * pow2 64 + (uint64xN_v lo).[i]) in match w with | 1 -> load_felem5_lemma_i #w lo hi 0; eq_intro (feval5 f) res | 2 -> load_felem5_lemma_i #w lo hi 0; load_felem5_lemma_i #w lo hi 1; eq_intro (feval5 f) res | 4 -> load_felem5_lemma_i #w lo hi 0; load_felem5_lemma_i #w lo hi 1; load_felem5_lemma_i #w lo hi 2; load_felem5_lemma_i #w lo hi 3; eq_intro (feval5 f) res val load_felem5_4_interleave: lo:uint64xN 4 -> hi:uint64xN 4 -> Lemma (let m0 = vec_interleave_low_n 2 lo hi in let m1 = vec_interleave_high_n 2 lo hi in let m2 = cast U64 4 (vec_shift_right (cast U128 2 m0) 48ul) in let m3 = cast U64 4 (vec_shift_right (cast U128 2 m1) 48ul) in let m4 = vec_interleave_high m0 m1 in let t0 = vec_interleave_low m0 m1 in let t3 = vec_interleave_low m2 m3 in vec_v m4 == create4 (vec_v lo).[1] (vec_v lo).[3] (vec_v hi).[1] (vec_v hi).[3] /\ vec_v t0 == create4 (vec_v lo).[0] (vec_v lo).[2] (vec_v hi).[0] (vec_v hi).[2] /\ t3 == vec_or (vec_shift_right t0 48ul) (vec_shift_left m4 16ul)) let load_felem5_4_interleave lo hi = let m0 = vec_interleave_low_n 2 lo hi in vec_interleave_low_n_lemma_uint64_4_2 lo hi; //assert (vec_v m0 == create4 (vec_v lo).[0] (vec_v lo).[1] (vec_v hi).[0] (vec_v hi).[1]); let m1 = vec_interleave_high_n 2 lo hi in vec_interleave_high_n_lemma_uint64_4_2 lo hi; //assert (vec_v m1 == create4 (vec_v lo).[2] (vec_v lo).[3] (vec_v hi).[2] (vec_v hi).[3]); let m4 = vec_interleave_high m0 m1 in vec_interleave_high_lemma_uint64_4 m0 m1; //assert (vec_v m4 == create4 (vec_v m0).[1] (vec_v m1).[1] (vec_v m0).[3] (vec_v m1).[3]); assert (vec_v m4 == create4 (vec_v lo).[1] (vec_v lo).[3] (vec_v hi).[1] (vec_v hi).[3]); let t0 = vec_interleave_low m0 m1 in vec_interleave_low_lemma_uint64_4 m0 m1; //assert (vec_v t0 == create4 (vec_v m0).[0] (vec_v m1).[0] (vec_v m0).[2] (vec_v m1).[2]); assert (vec_v t0 == create4 (vec_v lo).[0] (vec_v lo).[2] (vec_v hi).[0] (vec_v hi).[2]); let m2 = cast U64 4 (vec_shift_right (cast U128 2 m0) 48ul) in vec_shift_right_uint128_small2 m0 48ul; assert ((vec_v m2).[0] == (((vec_v lo).[0] >>. 48ul) |. ((vec_v lo).[1] <<. 16ul))); assert ((vec_v m2).[2] == (((vec_v hi).[0] >>. 48ul) |. ((vec_v hi).[1] <<. 16ul))); let m3 = cast U64 4 (vec_shift_right (cast U128 2 m1) 48ul) in vec_shift_right_uint128_small2 m1 48ul; assert ((vec_v m3).[0] == (((vec_v lo).[2] >>. 48ul) |. ((vec_v lo).[3] <<. 16ul))); assert ((vec_v m3).[2] == (((vec_v hi).[2] >>. 48ul) |. ((vec_v hi).[3] <<. 16ul))); let t3 = vec_interleave_low m2 m3 in vec_interleave_low_lemma_uint64_4 m2 m3; eq_intro (vec_v t3) (vec_v (vec_or (vec_shift_right t0 48ul) (vec_shift_left m4 16ul))); vecv_extensionality t3 (vec_or (vec_shift_right t0 48ul) (vec_shift_left m4 16ul)) noextract val load_felem5_4_compact: lo:uint64xN 4 -> hi:uint64xN 4 -> felem5 4 let load_felem5_4_compact lo hi = let mask26 = mask26 4 in let t3 = vec_or (vec_shift_right lo 48ul) (vec_shift_left hi 16ul) in let o0 = vec_and lo mask26 in let o1 = vec_and (vec_shift_right lo 26ul) mask26 in let o2 = vec_and (vec_shift_right t3 4ul) mask26 in let o3 = vec_and (vec_shift_right t3 30ul) mask26 in let o4 = vec_shift_right hi 40ul in (o0, o1, o2, o3, o4) val load_felem5_4_compact_lemma_i: lo:uint64xN 4 -> hi:uint64xN 4 -> i:nat{i < 4} -> Lemma (let f = as_tup64_i (load_felem5_4_compact lo hi) i in tup64_fits5 f (1, 1, 1, 1, 1) /\ as_nat5 f < pow2 128 /\ as_nat5 f % Vec.prime == (uint64xN_v hi).[i] * pow2 64 + (uint64xN_v lo).[i]) let load_felem5_4_compact_lemma_i lo hi i = assert (as_tup64_i (load_felem5_4_compact lo hi) i == load_tup64_4_compact (vec_v lo).[i] (vec_v hi).[i]); load_tup64_4_compact_lemma (vec_v lo).[i] (vec_v hi).[i] val load_felem5_4_lemma: lo:uint64xN 4 -> hi:uint64xN 4 -> Lemma (let f = load_felem5_4_compact lo hi in felem_fits5 f (1, 1, 1, 1, 1) /\ felem_less5 f (pow2 128) /\ feval5 f == createi #Vec.pfelem 4 (fun i -> (uint64xN_v hi).[i] * pow2 64 + (uint64xN_v lo).[i])) let load_felem5_4_lemma lo hi = let f = load_felem5_4_compact lo hi in assert_norm (pow2 64 * pow2 64 = pow2 128); assert_norm (pow2 128 < Vec.prime); let res = createi #Vec.pfelem 4 (fun i -> (uint64xN_v hi).[i] * pow2 64 + (uint64xN_v lo).[i]) in load_felem5_4_compact_lemma_i lo hi 0; load_felem5_4_compact_lemma_i lo hi 1; load_felem5_4_compact_lemma_i lo hi 2; load_felem5_4_compact_lemma_i lo hi 3; eq_intro (feval5 f) res val load_felem5_le: b:lseq uint8 64 -> Lemma (let lo0 = vec_from_bytes_le U64 4 (sub b 0 32) in let hi0 = vec_from_bytes_le U64 4 (sub b 32 32) in let f = load_felem5_4 lo0 hi0 in felem_fits5 f (1, 1, 1, 1, 1) /\ felem_less5 f (pow2 128) /\

{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "Lib.Sequence.fsti.checked", "Lib.IntVector.fsti.checked", "Lib.IntTypes.fsti.checked", "Hacl.Spec.Poly1305.Vec.fst.checked", "Hacl.Spec.Poly1305.Field32xN.fst.checked", "Hacl.Poly1305.Field32xN.Lemmas2.fst.checked", "Hacl.Poly1305.Field32xN.Lemmas1.fst.checked", "Hacl.Poly1305.Field32xN.Lemmas0.fst.checked", "Hacl.Impl.Poly1305.Lemmas.fst.checked", "FStar.UInt32.fsti.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Mul.fst.checked", "FStar.Math.Lemmas.fst.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": false, "source_file": "Hacl.Spec.Poly1305.Field32xN.Lemmas.fst" }

[ { "abbrev": true, "full_module": "Hacl.Spec.Poly1305.Vec", "short_module": "Vec" }, { "abbrev": false, "full_module": "Hacl.Poly1305.Field32xN.Lemmas2", "short_module": null }, { "abbrev": false, "full_module": "Hacl.Poly1305.Field32xN.Lemmas1", "short_module": null }, { "abbrev": false, "full_module": "Hacl.Poly1305.Field32xN.Lemmas0", "short_module": null }, { "abbrev": false, "full_module": "Hacl.Spec.Poly1305.Field32xN", "short_module": null }, { "abbrev": false, "full_module": "FStar.Mul", "short_module": null }, { "abbrev": false, "full_module": "Lib.Sequence", "short_module": null }, { "abbrev": false, "full_module": "Lib.IntVector", "short_module": null }, { "abbrev": false, "full_module": "Lib.IntTypes", "short_module": null }, { "abbrev": false, "full_module": "Hacl.Spec.Poly1305.Field32xN", "short_module": null }, { "abbrev": false, "full_module": "Hacl.Spec.Poly1305.Field32xN", "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": 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": 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": 100, "z3rlimit_factor": 1, "z3seed": 0, "z3smtopt": [], "z3version": "4.8.5" }

false

b: Lib.Sequence.lseq Lib.IntTypes.uint8 64 -> FStar.Pervasives.Lemma (ensures (let lo0 = Lib.IntVector.vec_from_bytes_le Lib.IntTypes.U64 4 (Lib.Sequence.sub b 0 32) in let hi0 = Lib.IntVector.vec_from_bytes_le Lib.IntTypes.U64 4 (Lib.Sequence.sub b 32 32) in let f = Hacl.Spec.Poly1305.Field32xN.load_felem5_4 lo0 hi0 in Hacl.Spec.Poly1305.Field32xN.felem_fits5 f (1, 1, 1, 1, 1) /\ Hacl.Spec.Poly1305.Field32xN.felem_less5 f (Prims.pow2 128) /\ Hacl.Spec.Poly1305.Field32xN.feval5 f == Hacl.Spec.Poly1305.Vec.load_elem4 b))

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Lib.Sequence.lseq", "Lib.IntTypes.uint8", "Lib.Sequence.eq_intro", "Hacl.Spec.Poly1305.Vec.pfelem", "Hacl.Spec.Poly1305.Field32xN.feval5", "Hacl.Spec.Poly1305.Vec.load_elem4", "Prims.unit", "Hacl.Impl.Poly1305.Lemmas.uints_from_bytes_le_lemma64_4", "Hacl.Spec.Poly1305.Field32xN.Lemmas.load_felem5_4_lemma", "Prims._assert", "Prims.eq2", "Hacl.Spec.Poly1305.Field32xN.felem5", "Hacl.Spec.Poly1305.Field32xN.load_felem5_4", "Hacl.Spec.Poly1305.Field32xN.Lemmas.load_felem5_4_interleave", "Hacl.Spec.Poly1305.Field32xN.Lemmas.load_felem5_4_compact", "Lib.IntVector.vec_t", "Lib.IntTypes.U64", "Lib.IntVector.vec_interleave_high", "Lib.IntVector.vec_interleave_low", "Lib.IntVector.vec_interleave_high_n", "Lib.IntVector.vec_interleave_low_n", "Lib.IntVector.vec_from_bytes_le", "Lib.Sequence.sub" ]

[]

true

false

true

false

let load_felem5_le b =

let lo0 = vec_from_bytes_le U64 4 (sub b 0 32) in let hi0 = vec_from_bytes_le U64 4 (sub b 32 32) in let lo1 = vec_interleave_low_n 2 lo0 hi0 in let hi1 = vec_interleave_high_n 2 lo0 hi0 in let lo = vec_interleave_low lo1 hi1 in let hi = vec_interleave_high lo1 hi1 in let out = load_felem5_4_compact lo hi in load_felem5_4_interleave lo0 hi0; assert (out == load_felem5_4 lo0 hi0); load_felem5_4_lemma lo hi; Hacl.Impl.Poly1305.Lemmas.uints_from_bytes_le_lemma64_4 b; eq_intro (feval5 out) (Vec.load_elem4 b)

false

Steel.Memory.fst

Steel.Memory.witnessed_ref_stability

val witnessed_ref_stability (#a #pcm: _) (r: ref a pcm) (fact: property a) : Lemma (requires FStar.Preorder.stable fact (Steel.Preorder.preorder_of_pcm pcm)) (ensures FStar.Preorder.stable (witnessed_ref r fact) mem_evolves)

let witnessed_ref_stability #a #pcm (r:ref a pcm) (fact:property a) : Lemma (requires FStar.Preorder.stable fact (Steel.Preorder.preorder_of_pcm pcm)) (ensures FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) = H.witnessed_ref_stability #a #pcm r fact

{ "file_name": "lib/steel/Steel.Memory.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 44, "end_line": 1002, "start_col": 0, "start_line": 998 }

(* 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.Memory module F = FStar.FunctionalExtensionality open FStar.FunctionalExtensionality open FStar.PCM module H = Steel.Heap noeq type lock_state : Type u#(a + 1) = | Invariant : inv:H.slprop u#a -> lock_state let lock_store : Type u#(a+1) = list (lock_state u#a) noeq type mem : Type u#(a + 1) = { ctr: nat; heap: H.heap u#a; locks: lock_store u#a; } let heap_of_mem (x:mem) : H.heap = x.heap let mem_of_heap (h:H.heap) : mem = { ctr = 0; heap = h; locks = [] } let mem_set_heap (m:mem) (h:H.heap) : mem = { ctr = m.ctr; heap = h; locks = m.locks; } let core_mem (m:mem) : mem = mem_of_heap (heap_of_mem m) let core_mem_invol m = () let disjoint (m0 m1:mem u#h) : prop = m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks let disjoint_sym m0 m1 = () let join m0 m1 = { ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = m0.locks } let join_commutative m0 m1 = H.join_commutative m0.heap m1.heap let disjoint_join m0 m1 m2 = H.disjoint_join m0.heap m1.heap m2.heap let join_associative m0 m1 m2 = H.join_associative m0.heap m1.heap m2.heap let slprop = H.slprop let interp p m = H.interp p m.heap let equiv p1 p2 = forall m. interp p1 m <==> interp p2 m let slprop_extensionality p q = assert (forall m. interp p m <==> interp q m); let aux (h:H.heap) : Lemma (H.interp p h <==> H.interp q h) [SMTPat (H.interp p h)] = let m : mem = { ctr = 0; heap = h; locks = [] } in assert (interp p m <==> interp q m) in assert (forall h. H.interp p h <==> H.interp q h); Steel.Heap.slprop_extensionality p q let reveal_equiv p1 p2 = () let core_ref = H.core_ref let core_ref_null = H.core_ref_null let core_ref_is_null r = H.core_ref_is_null r let emp : slprop u#a = H.emp let pure = H.pure let pts_to = H.pts_to let h_and = H.h_and let h_or = H.h_or let star = H.star let wand = H.wand let h_exists = H.h_exists let h_forall = H.h_forall //////////////////////////////////////////////////////////////////////////////// //properties of equiv //////////////////////////////////////////////////////////////////////////////// let equiv_symmetric (p1 p2:slprop u#a) = H.equiv_symmetric p1 p2 #push-options "--warn_error -271" let equiv_heap_iff_equiv (p1 p2:slprop u#a) : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat (equiv p1 p2)] = let aux_lr () : Lemma (requires H.equiv p1 p2) (ensures equiv p1 p2) [SMTPat ()] = () in let aux_rl_helper1 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p1 h) (ensures H.interp p2 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl_helper2 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p2 h) (ensures H.interp p1 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl () : Lemma (requires equiv p1 p2) (ensures H.equiv p1 p2) [SMTPat ()] = () in () let equiv_heap_iff_equiv_forall () : Lemma (ensures (forall p1 p2. H.equiv p1 p2 <==> equiv p1 p2)) = let aux p1 p2 : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat ()] = equiv_heap_iff_equiv p1 p2 in () #pop-options let equiv_extensional_on_star (p1 p2 p3:slprop u#a) = equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3 let emp_unit p = H.emp_unit p let intro_emp m = H.intro_emp (heap_of_mem m) let pure_equiv p q = H.pure_equiv p q let pure_interp q m = H.pure_interp q (heap_of_mem m) let pure_star_interp p q m = H.pure_star_interp p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// //pts_to //////////////////////////////////////////////////////////////////////////////// let pts_to_compatible #a #pcm x v0 v1 m = H.pts_to_compatible #a #pcm x v0 v1 (heap_of_mem m) let pts_to_compatible_equiv #a #pcm x v0 v1 = H.pts_to_compatible_equiv #a #pcm x v0 v1 let pts_to_not_null #a #pcm x v m = H.pts_to_not_null #a #pcm x v (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // star //////////////////////////////////////////////////////////////////////////////// let intro_star p q mp mq = H.intro_star p q (heap_of_mem mp) (heap_of_mem mq) let elim_star p q m = let h = heap_of_mem m in H.elim_star p q h; assert (exists hl hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr); let hl = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hl -> exists hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let hr = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hr -> H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let ml = mem_set_heap m hl in let mr = mem_set_heap m hr in assert (disjoint ml mr); assert (m == join ml mr); assert (interp p ml); assert (interp q mr); () let interp_star (p q: slprop) (m: mem) : Lemma (interp (p `star` q) m <==> (exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m)) = let left = interp (p `star` q) m in let right = exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m in let f () : Lemma (requires left) (ensures right) = elim_star p q m in let g () : Lemma (requires right) (ensures left) = Classical.exists_elim left #_ #(fun mp -> exists (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mp -> Classical.exists_elim left #_ #(fun mq -> disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mq -> intro_star p q mp mq ) ) in Classical.move_requires f (); Classical.move_requires g () let star_commutative (p1 p2:slprop) = H.star_commutative p1 p2 let star_associative (p1 p2 p3:slprop) = H.star_associative p1 p2 p3 let star_congruence (p1 p2 p3 p4:slprop) = equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4 let affine_star (p q:slprop) (m:mem) = H.affine_star p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // Invariants on the lock store //////////////////////////////////////////////////////////////////////////////// let iname = nat module S = FStar.Set module L = FStar.List.Tot module W = FStar.Witnessed.Core let rec lock_store_invariant (e:inames) (l:lock_store u#a) : slprop u#a = let current_addr = L.length l - 1 in match l with | [] -> emp | Invariant p :: tl -> if current_addr `S.mem` e then lock_store_invariant e tl else p `star` lock_store_invariant e tl let lock_i (i:iname) (l:lock_store { i < L.length l }) = let ix = L.length l - i - 1 in L.index l ix let iname_for_p (i:iname) (p:slprop) : W.s_predicate lock_store = fun l -> i < L.length l /\ (lock_i i l).inv == p let lock_store_evolves : FStar.Preorder.preorder lock_store = fun (l1 l2 : lock_store) -> L.length l2 >= L.length l1 /\ (forall (i:nat{i < L.length l1}). (lock_i i l1).inv == (lock_i i l2).inv) let inames_in (e:inames) (l:lock_store) : prop = forall i. Set.mem i e ==> i < L.length l let inames_ok e m = inames_in e m.locks let inames_ok_empty m = () let extend_lock_store (e:inames) (l:lock_store{e `inames_in` l}) (p:slprop) : i:iname & l':lock_store { lock_store_invariant e l' == p `star` lock_store_invariant e l /\ iname_for_p i p l' } = (| L.length l, Invariant p :: l |) let set_add (i:iname) (s:inames) = Set.union (Set.singleton i) s let rec move_invariant (e:inames) (l:lock_store) (p:slprop) (i:iname{iname_for_p i p l /\ ~(i `Set.mem` e)}) : Lemma (H.equiv (lock_store_invariant e l) (p `star` lock_store_invariant (set_add i e) l)) = let rec aux (i:iname) (m:lock_store) : Lemma (requires i >= L.length m) (ensures (lock_store_invariant e m `H.equiv` lock_store_invariant (set_add i e) m)) = match m with | [] -> () | Invariant p::tl -> aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl) in let current_addr = L.length l - 1 in match l with | [] -> () | Invariant q::tl -> if i = current_addr then begin assert (lock_store_invariant e l == p `star` lock_store_invariant e tl); aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl); () end else begin move_invariant e tl p i; assert (lock_store_invariant e tl `equiv` (p `star` lock_store_invariant (set_add i e) tl)); H.star_congruence q (lock_store_invariant e tl) q (p `star` lock_store_invariant (set_add i e) tl); if Set.mem current_addr e then () else begin let r = lock_store_invariant (set_add i e) tl in assert (lock_store_invariant e l `equiv` (q `star` (p `star` r))); H.star_associative q p r; H.star_commutative q p; H.star_congruence (q `star` p) r (p `star` q) r; H.star_associative p q r end end let heap_ctr_valid (ctr:nat) (h:H.heap u#a) : prop = h `H.free_above_addr` ctr let ctr_validity (ctr:nat) (h:H.heap) : slprop = H.pure (heap_ctr_valid ctr h) let locks_invariant (e:inames) (m:mem u#a) : slprop u#a = lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m) let full_mem_pred (m:mem) = H.full_heap_pred (heap_of_mem m) (***** Following lemmas are needed in Steel.Effect *****) let core_mem_interp (hp:slprop u#a) (m:mem u#a) = () let interp_depends_only_on (hp:slprop u#a) = H.interp_depends_only_on hp let a_mem_prop_as_a_heap_prop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (H.a_heap_prop u#a) = let g (h: H.heap u#a) : Tot prop = interp sl (mem_of_heap h) /\ f (mem_of_heap h) in let phi0 (h0 h1: H.heap u#a) : Lemma (requires (g h0 /\ H.disjoint h0 h1)) (ensures (g h0 /\ H.disjoint h0 h1 /\ g (H.join h0 h1))) = assert (mem_of_heap (H.join h0 h1) == mem_of_heap h0 `join` mem_of_heap h1); interp_depends_only_on sl in let phi1 (h0 h1: H.heap u#a) : Lemma (ensures ((g h0 /\ H.disjoint h0 h1) ==> g (H.join h0 h1))) = Classical.move_requires (phi0 h0) h1 in Classical.forall_intro_2 phi1; g let refine_slprop sl f = H.as_slprop (a_mem_prop_as_a_heap_prop sl f) let interp_refine_slprop sl f m = assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_mem m)) let dep_hprop (s: slprop) (f: (hmem s -> Tot slprop)) (h: H.heap) : Tot prop = exists (h1: H.heap) . exists (h2: H.heap) . interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 let dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq' : squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h')) = let p2 (h h1 h2: H.heap) : Tot prop = interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 in let p1 (h h1: H.heap) : Tot prop = (exists h2 . p2 h h1 h2) in let h1 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p1 h) in let h2 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p2 h h1) in H.disjoint_join h' h1 h2; assert (H.disjoint h2 h'); let h2' = H.join h2 h' in H.join_commutative h2 h' ; assert (h2' == H.join h' h2); assert (H.disjoint h1 h2'); assert (mem_of_heap h2' == mem_of_heap h2 `join` mem_of_heap h'); interp_depends_only_on (f (mem_of_heap h1)); assert (interp (f (mem_of_heap h1)) (mem_of_heap h2')); H.join_commutative h1 h2; H.join_associative h' h2 h1; H.join_commutative h' h; H.join_commutative h2' h1; assert (H.join h h' == h1 `H.join` h2') let impl_intro_gen (#p: Type0) (#q: Type0) ($prf: (squash p -> Lemma (q ))) : Lemma (p ==> q) = Classical.impl_intro_gen #p #(fun _ -> q) prf let dep_hprop_is_affine1 (s: slprop) (f: (hmem s -> Tot slprop)) (h0 h1: H.heap) : Lemma ((dep_hprop s f h0 /\ H.disjoint h0 h1) ==> (H.disjoint h0 h1 /\ dep_hprop s f (H.join h0 h1))) = impl_intro_gen (dep_hprop_is_affine0 s f h0 h1) let dep_hprop_is_affine (s: slprop) (f: (hmem s -> Tot slprop)) : Lemma (H.heap_prop_is_affine (dep_hprop s f)) = Classical.forall_intro_2 (dep_hprop_is_affine1 s f) let sdep (s: slprop) (f: (hmem s -> Tot slprop)) : Tot slprop = dep_hprop_is_affine s f; H.as_slprop (dep_hprop s f) let interp_sdep (s: slprop) (f: (hmem s -> Tot slprop)) (m: mem) : Lemma (requires (dep_slprop_is_affine s f)) (ensures ( interp (sdep s f) m <==> (exists m1 m2 . interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) )) = dep_hprop_is_affine s f; assert (forall m1 m2 . (interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) ==> ( interp s (mem_of_heap m1.heap) /\ interp (f (mem_of_heap m1.heap)) (mem_of_heap m2.heap) /\ H.disjoint m1.heap m2.heap /\ H.join m1.heap m2.heap == m.heap )); interp_depends_only_on s; Classical.forall_intro (fun m -> interp_depends_only_on (f m)); assert (forall h1 h2 . (interp s (mem_of_heap h1) /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ H.disjoint h1 h2 /\ H.join h1 h2 == m.heap) ==> ( core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ interp s (core_mem (mem_of_heap h1)) /\ interp s (mem_set_heap m h1) /\ core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ f (mem_set_heap m h1) `equiv` f (mem_of_heap h1) /\ interp (f (mem_set_heap m h1)) (mem_of_heap h2) /\ interp (f (mem_set_heap m h1)) (mem_set_heap m h2) /\ disjoint (mem_set_heap m h1) (mem_set_heap m h2) /\ join (mem_set_heap m h1) (mem_set_heap m h2) == m )); () let h_exists_cong (#a:Type) (p q : a -> slprop) : Lemma (requires (forall x. p x `equiv` q x)) (ensures (h_exists p `equiv` h_exists q)) = equiv_heap_iff_equiv_forall (); H.h_exists_cong p q let intro_h_exists #a x p m = H.intro_h_exists x p (heap_of_mem m) let elim_h_exists (#a:_) (p:a -> slprop) (m:mem) = H.elim_h_exists p (heap_of_mem m) let intro_h_forall (#a:_) (p:a -> slprop) (m:mem) = H.intro_h_forall p (heap_of_mem m) let elim_h_forall (#a:_) (p:a -> slprop) (m:mem) (x:a) = H.elim_h_forall p (heap_of_mem m) x let intro_h_and (p q: slprop) (m:mem) = H.intro_h_and p q (heap_of_mem m) let elim_h_and (p q: slprop) (m:mem) = H.elim_h_and p q (heap_of_mem m) let intro_h_or_left (p q: slprop) (m:mem) = H.intro_h_or_left p q (heap_of_mem m) let intro_h_or_right (p q: slprop) (m:mem) = H.intro_h_or_right p q (heap_of_mem m) let elim_h_or (p q: slprop) (m:mem) = H.elim_h_or p q (heap_of_mem m) let intro_wand (p1 p2: slprop u#a) (m:mem) = introduce (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)) ==> interp (wand p1 p2) m with _. ( assert (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)); H.intro_wand p1 p2 (heap_of_mem m); let h = heap_of_mem m in assert ((forall h1. h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) ==> H.interp (wand p1 p2) h); introduce forall h1. (h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) with ( introduce (h `H.disjoint` h1 /\ H.interp p1 h1) ==> H.interp p2 (H.join h h1) with _. ( assert (h `H.disjoint` h1); let m1 = { ctr = m.ctr; heap = h1; locks = m.locks } in assert (m `disjoint` m1) ) ) ) (** Eliminating a wand by proving a heap that satisfies the LHS **) let elim_wand (p1 p2: slprop u#a) (m:mem) (m1:mem) = H.elim_wand p1 p2 (heap_of_mem m) (heap_of_mem m1) //////////////////////////////////////////////////////////////////////////////// // Preorders and effects //////////////////////////////////////////////////////////////////////////////// module PP = Steel.Preorder let mem_evolves = fun (m0 m1:full_mem) -> H.heap_evolves (heap_of_mem m0) (heap_of_mem m1) /\ m0.ctr <= m1.ctr /\ lock_store_evolves m0.locks m1.locks (** See [Steel.Heap.is_frame_preserving]. We add in [lock_invariants] now *) let preserves_frame (e:inames) (pre post:slprop) (m0 m1:mem) = forall (frame:slprop). interp ((pre `star` frame) `star` locks_invariant e m0) m0 ==> (interp ((post `star` frame) `star` locks_invariant e m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) (** This is a version of MstTot with frame quantified, as part of preserves_frame *) effect MstTotNF (a:Type u#a) (except:inames) (expects:slprop u#1) (provides: a -> slprop u#1) = NMSTTotal.NMSTATETOT a (full_mem u#1) mem_evolves (requires fun m0 -> inames_ok except m0 /\ interp (expects `star` locks_invariant except m0) m0) (ensures fun m0 x m1 -> inames_ok except m1 /\ interp (provides x `star` locks_invariant except m1) m1 /\ preserves_frame except expects (provides x) m0 m1) //////////////////////////////////////////////////////////////////////////////// // Lifting heap actions //////////////////////////////////////////////////////////////////////////////// (** Heap actions come in two equivalent flavors: - one that take an explicit frame as argument (action_with_frame) - and one that quantify over all the frame We therefore define two lift routes: - a direct route for those with explicit frame - via MstTotNF for the rest *) let tot_pre_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = hmem_with_inv_except e fp -> (x:a & hmem_with_inv_except e (fp' x)) let tot_pre_action_nf = tot_pre_action_nf_except S.empty let ac_reasoning_for_m_frame_preserving (p q r:slprop u#a) (m:mem u#a) : Lemma (requires interp ((p `star` q) `star` r) m) (ensures interp (p `star` r) m) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_commutative p q; equiv_extensional_on_star (p `star` q) (q `star` p) r } (q `star` p) `star` r; (equiv) { star_associative q p r } q `star` (p `star` r); }; assert (interp (q `star` (p `star` r)) m); affine_star q (p `star` r) m let is_frame_preserving (#e:inames) (#a:Type u#b) (#fp:slprop u#a) (#fp':a -> slprop u#a) (f:tot_pre_action_nf_except e fp a fp') = forall (frame:slprop u#a) (m0:hmem_with_inv_except e (fp `star` frame)). (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = f:tot_pre_action_nf_except e fp a fp'{ is_frame_preserving f } let tot_action_nf = tot_action_nf_except S.empty let linv e (m:mem) = locks_invariant e m let hheap_of_hmem #fp #e (m:hmem_with_inv_except e fp) : h:H.hheap (fp `star` linv e m) { h `H.free_above_addr` m.ctr} = let h = heap_of_mem m in H.pure_interp (heap_ctr_valid m.ctr (heap_of_mem m)) h; h let hmem_of_hheap #e (#fp0 #fp1:slprop) (m:hmem_with_inv_except e fp0) (h:H.full_hheap (fp1 `star` linv e m) { h `Heap.free_above_addr` m.ctr }) : m1:hmem_with_inv_except e fp1{linv e m `equiv` linv e m1} = let m1 : mem = { m with heap = h } in assert (interp (fp1 `star` linv e m) m1); star_commutative fp1 (linv e m); assert (interp (linv e m `star` fp1) m1); assert (linv e m1 == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); assert (linv e m == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m)); H.pure_interp (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_of_mem m); assert (heap_ctr_valid m1.ctr (heap_of_mem m) <==> heap_ctr_valid m1.ctr (heap_of_mem m1)); H.pure_equiv (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_ctr_valid m1.ctr (heap_of_mem m1)); H.star_congruence (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m)); assert (linv e m `equiv` linv e m1); let _ = equiv_extensional_on_star (linv e m) (linv e m1) fp1 in assert ((linv e m `star` fp1) `equiv` (linv e m1 `star` fp1)); assert (interp (linv e m1 `star` fp1) m1); star_commutative (linv e m1) fp1; assert (interp (fp1 `star` linv e m1) m1); m1 let with_inv_except (m:mem) e (fp:slprop) = interp (fp `star` locks_invariant e m) m #push-options "--warn_error -271" let as_hprop (frame:slprop) (mp:mprop frame) : hp:H.hprop frame{forall m. mp (core_mem m) == hp (heap_of_mem m)} = let f = fun h -> mp (mem_of_heap h) in assert (forall m. mp (core_mem m) == f (heap_of_mem m)); let aux (m0:H.hheap frame) (m1:H.heap{H.disjoint m0 m1}) : Lemma (ensures (mem_of_heap (H.join m0 m1) == join (mem_of_heap m0) (mem_of_heap m1))) [SMTPat ()] = () in f let mprop_preservation_of_hprop_preservation (p:slprop) (m0 m1:mem) : Lemma (requires (forall (hp:H.hprop p). hp (heap_of_mem m0) == hp (heap_of_mem m1))) (ensures (forall (mp:mprop p). mp (core_mem m0) == mp (core_mem m1))) = let aux (mp:mprop p) : Lemma (mp (core_mem m0) == mp (core_mem m1)) [SMTPat()] = assert (as_hprop p mp (heap_of_mem m0) == as_hprop p mp (heap_of_mem m1)) in () let lift_heap_action (#fp:slprop) (#a:Type) (#fp':a -> slprop) (e:inames) ($f:H.action fp a fp') : tot_action_nf_except e fp a fp' = let g : tot_pre_action_nf_except e fp a fp' = fun m -> let h0 = hheap_of_hmem m in let (| x, h' |) = f h0 in (| x, hmem_of_hheap m h' |) in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in let h0 = hheap_of_hmem m0 in let (| x', h1 |) = f h0 in H.action_framing f (linv e m0) h0; assert (x == x'); star_associative fp frame (linv e m0); H.action_framing f (frame `star` linv e m0) h0; assert (H.interp ((fp' x) `star` (frame `star` linv e m0)) h1); star_associative (fp' x) frame (linv e m0); assert (H.interp ((fp' x `star` frame) `star` linv e m0) h1); let h1' : H.hheap ((fp' x `star` frame) `star` linv e m0) = h1 in assert (m1 == hmem_of_hheap m0 h1'); assert (with_inv_except m1 e (fp' x `star` frame)); assert (forall (hp:H.hprop frame). hp h0 == hp h1); mprop_preservation_of_hprop_preservation frame m0 m1; () in assert (is_frame_preserving g); g let frame_preserving_respects_preorder #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (m0:hmem_with_inv_except e fp) : Lemma (let (| x, m1 |) = f m0 in mem_evolves m0 m1) = let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1) = () in H.emp_unit fp; assert (interp (fp `star` linv e m0) m0); H.star_congruence (fp `star` emp) (linv e m0) fp (linv e m0); assert (interp ((fp `star` emp) `star` linv e m0) m0); aux emp m0 let lift_tot_action_nf #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') : MstTotNF a e fp fp' = let m0 = NMSTTotal.get () in let m0' : hmem_with_inv_except e fp = m0 in let r = f m0' in let (| x, m1 |) = r in let m1' : hmem_with_inv_except e (fp' x) = m1 in assert (is_frame_preserving f); assert (m1 == dsnd (f m0)); frame_preserving_respects_preorder f m0; NMSTTotal.put #_ #(mem_evolves) m1; x let lift_tot_action #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get #(full_mem) #_ () in ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); lift_tot_action_nf f (** Now defining the lift for heap actions with explicit frame *) let tot_action_with_frame_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = frame:slprop u#a -> m0:hmem_with_inv_except e (fp `star` frame) -> Pure (x:a & hmem_with_inv_except e (fp' x `star` frame)) (requires True) (ensures fun (| x, m1 |) -> mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_with_frame = tot_action_with_frame_except S.empty let lift_heap_action_with_frame (#fp:slprop u#a) (#a:Type u#b) (#fp':a -> slprop u#a) (e:inames) ($f:H.action_with_frame fp a fp') : tot_action_with_frame_except e fp a fp' = fun frame m0 -> let h0 = hheap_of_hmem m0 in calc (equiv) { fp `star` frame `star` locks_invariant e m0; (equiv) { star_associative fp frame (locks_invariant e m0) } fp `star` (frame `star` locks_invariant e m0); }; assert (H.interp (fp `star` frame `star` locks_invariant e m0) h0); assert (H.interp (fp `star` (frame `star` locks_invariant e m0)) h0); //key: apply the heap action with frame * locks_invariant e m0 let (| x, h1 |) = f (frame `star` locks_invariant e m0) h0 in calc (equiv) { fp' x `star` (frame `star` locks_invariant e m0); (equiv) { star_associative (fp' x) frame (locks_invariant e m0) } fp' x `star` frame `star` locks_invariant e m0; }; assert (H.interp (fp' x `star` (frame `star` locks_invariant e m0)) h1); assert (H.interp (fp' x `star` frame `star` locks_invariant e m0) h1); let m1 = hmem_of_hheap m0 h1 in assert (mem_evolves m0 m1); mprop_preservation_of_hprop_preservation (frame `star` locks_invariant e m0) m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)); (| x, m1 |) let lift_tot_action_with_frame #a #e #fp #fp' ($f:tot_action_with_frame_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in assert (inames_ok e m0); ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); let m0' : hmem_with_inv_except e fp = m0 in let r = f frame m0' in let (| x, m1 |) = r in ac_reasoning_for_m_frame_preserving (fp' x) frame (locks_invariant e m1) m1; assert (interp (fp' x `star` frame `star` locks_invariant e m1) m1); assert (interp (fp' x `star` locks_invariant e m1) m1); let m1' : hmem_with_inv_except e (fp' x) = m1 in NMSTTotal.put #_ #(mem_evolves) m1; x let sel_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.sel_action #a #pcm r v0)) let upd_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.upd_action #a #pcm r v0 v1)) let free_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.free_action #a #pcm r v0)) let split_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.split_action #a #pcm r v0 v1)) let gather_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.gather_action #a #pcm r v0 v1)) let weaken (p q r:slprop) (h:H.hheap (p `star` q) { H.stronger q r }) : H.hheap (p `star` r) = H.weaken p q r h; h let weaken_pure (q r: prop) : Lemma (requires (q ==> r)) (ensures H.stronger (H.pure q) (H.pure r)) = let aux (h:H.heap) : Lemma (ensures (H.interp (H.pure q) h ==> H.interp (H.pure r) h)) [SMTPat ()] = H.pure_interp q h; H.pure_interp r h in () let inc_ctr (#p:slprop) #e (m:hmem_with_inv_except e p) : m':hmem_with_inv_except e p{m'.ctr = m.ctr + 1 /\ H.stronger (linv e m) (linv e m')} = let m' : mem = { m with ctr = m.ctr + 1} in assert (interp (p `star` linv e m) m'); assert (linv e m == lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m)); assert (linv e m' == lock_store_invariant e m.locks `star` ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken_free_above (heap_of_mem m) m.ctr (m.ctr + 1); weaken_pure (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_ctr_valid (m.ctr + 1) (heap_of_mem m)); assert (H.stronger (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m))); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)); H.stronger_star (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken (p `star` lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)) (heap_of_mem m'); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity (m.ctr + 1) (heap_of_mem m)); let m' : hmem_with_inv_except e p = m' in m' let frame_related_mems (fp0 fp1:slprop u#a) e (m0:hmem_with_inv_except e fp0) (m1:hmem_with_inv_except e fp1) = forall (frame:slprop u#a). interp ((fp0 `star` frame) `star` linv e m0) m0 ==> interp ((fp1 `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) let refined_pre_action e (fp0:slprop) (a:Type) (fp1:a -> slprop) = m0:hmem_with_inv_except e fp0 -> Pure (x:a & hmem_with_inv_except e (fp1 x)) (requires True) (ensures fun (| x, m1 |) -> frame_related_mems fp0 (fp1 x) e m0 m1) let refined_pre_action_as_action (#fp0:slprop) (#a:Type) (#fp1:a -> slprop) #e ($f:refined_pre_action e fp0 a fp1) : tot_action_nf_except e fp0 a fp1 = let g : tot_pre_action_nf_except e fp0 a fp1 = fun m -> f m in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp0 `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp1 x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x', m1' |) = g m0 in let (| x, m1 |) = f m0 in assert (x == x' /\ m1 == m1') in g let alloc_action #a #pcm e x = let f : refined_pre_action e emp (ref a pcm) (fun r -> pts_to r x) = fun m0 -> (* NS: 9/29/22 I needed to annotate h : Heap.full_heap, for use with the Core checker which generates a guard for checking the implicit pattern "dot" term in the dependent pair pattern on the next line. That guard expects `h` to be a full_heap, which is it, because it is a projection of m0. However, this is not reflected in `h`'s type. So, the Core checker, which produces a guard for the pat_dot_term in isolation, cannot recheck the term. If we were to fold in the checking of pat_dot_terms and their guards with the rest of the VC, this would work. *) let h : Heap.full_heap = hheap_of_hmem m0 in let (|r, h'|) = H.extend #a #pcm x m0.ctr h in let m' : hmem_with_inv_except e emp = inc_ctr m0 in let h' : H.hheap (pts_to #a #pcm r x `star` linv e m') = weaken _ (linv e m0) (linv e m') h' in let m1 : hmem_with_inv_except e (pts_to #a #pcm r x) = hmem_of_hheap m' h' in assert (forall frame. H.frame_related_heaps h h' emp (pts_to #a #pcm r x) frame true); let aux (frame:slprop) : Lemma (requires interp ((emp `star` frame) `star` linv e m0) m0) (ensures interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) [SMTPat (emp `star` frame)] = star_associative emp frame (linv e m0); assert (H.interp (emp `star` (frame `star` linv e m0)) h); assert (H.interp (pts_to #a #pcm r x `star` (frame `star` linv e m0)) h'); star_associative (pts_to #a #pcm r x) frame (linv e m0); assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m0) h'); assert (H.stronger (linv e m0) (linv e m')); assert (H.equiv (linv e m') (linv e m1)); assert (H.stronger (linv e m0) (linv e m1)); let h' : H.hheap ((pts_to #a #pcm r x `star` frame) `star` linv e m1) = weaken _ (linv e m0) (linv e m1) h' in assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) h'); assert (forall (mp:H.hprop frame). mp h == mp h'); mprop_preservation_of_hprop_preservation frame m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) in assert (frame_related_mems emp (pts_to r x) e m0 m1); (| r, m1 |) in lift_tot_action (refined_pre_action_as_action f) let select_refine #a #p e r x f = lift_tot_action (lift_heap_action e (H.select_refine #a #p r x f)) let upd_gen #a #p e r x y f = lift_tot_action (lift_heap_action e (H.upd_gen_action r x y f)) //////////////////////////////////////////////////////////////////////////////// // witness / recall //////////////////////////////////////////////////////////////////////////////// let witnessed_ref #a #pcm (r:ref a pcm) (fact:property a) (m:full_mem) = H.witnessed_ref #a #pcm r fact (heap_of_mem m)

{ "checked_file": "/", "dependencies": [ "Steel.Preorder.fst.checked", "Steel.Heap.fsti.checked", "prims.fst.checked", "FStar.Witnessed.Core.fsti.checked", "FStar.Set.fsti.checked", "FStar.Preorder.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.PCM.fst.checked", "FStar.NMSTTotal.fst.checked", "FStar.List.Tot.fst.checked", "FStar.IndefiniteDescription.fsti.checked", "FStar.Ghost.fsti.checked", "FStar.FunctionalExtensionality.fsti.checked", "FStar.Classical.Sugar.fsti.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Steel.Memory.fst" }

[ { "abbrev": true, "full_module": "Steel.Preorder", "short_module": "PP" }, { "abbrev": true, "full_module": "FStar.Witnessed.Core", "short_module": "W" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": true, "full_module": "Steel.Heap", "short_module": "H" }, { "abbrev": false, "full_module": "FStar.PCM", "short_module": null }, { "abbrev": false, "full_module": "FStar.FunctionalExtensionality", "short_module": null }, { "abbrev": true, "full_module": "FStar.FunctionalExtensionality", "short_module": "F" }, { "abbrev": false, "full_module": "FStar.PCM", "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.Memory.ref a pcm -> fact: Steel.Memory.property a -> FStar.Pervasives.Lemma (requires FStar.Preorder.stable fact (Steel.Preorder.preorder_of_pcm pcm)) (ensures FStar.Preorder.stable (Steel.Memory.witnessed_ref r fact) Steel.Memory.mem_evolves)

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "FStar.PCM.pcm", "Steel.Memory.ref", "Steel.Memory.property", "Steel.Heap.witnessed_ref_stability", "Prims.unit", "FStar.Preorder.stable", "Steel.Preorder.preorder_of_pcm", "Prims.squash", "Steel.Memory.full_mem", "Steel.Memory.witnessed_ref", "Steel.Memory.mem_evolves", "Prims.Nil", "FStar.Pervasives.pattern" ]

[]

true

false

true

false

let witnessed_ref_stability #a #pcm (r: ref a pcm) (fact: property a) : Lemma (requires FStar.Preorder.stable fact (Steel.Preorder.preorder_of_pcm pcm)) (ensures FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) =

H.witnessed_ref_stability #a #pcm r fact

false

Steel.Memory.fst

Steel.Memory.witnessed_ref

val witnessed_ref : r: Steel.Memory.ref a pcm -> fact: Steel.Memory.property a -> m: Steel.Memory.full_mem -> Prims.logical

let witnessed_ref #a #pcm (r:ref a pcm) (fact:property a) (m:full_mem) = H.witnessed_ref #a #pcm r fact (heap_of_mem m)

{ "file_name": "lib/steel/Steel.Memory.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 50, "end_line": 996, "start_col": 0, "start_line": 995 }

(* 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.Memory module F = FStar.FunctionalExtensionality open FStar.FunctionalExtensionality open FStar.PCM module H = Steel.Heap noeq type lock_state : Type u#(a + 1) = | Invariant : inv:H.slprop u#a -> lock_state let lock_store : Type u#(a+1) = list (lock_state u#a) noeq type mem : Type u#(a + 1) = { ctr: nat; heap: H.heap u#a; locks: lock_store u#a; } let heap_of_mem (x:mem) : H.heap = x.heap let mem_of_heap (h:H.heap) : mem = { ctr = 0; heap = h; locks = [] } let mem_set_heap (m:mem) (h:H.heap) : mem = { ctr = m.ctr; heap = h; locks = m.locks; } let core_mem (m:mem) : mem = mem_of_heap (heap_of_mem m) let core_mem_invol m = () let disjoint (m0 m1:mem u#h) : prop = m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks let disjoint_sym m0 m1 = () let join m0 m1 = { ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = m0.locks } let join_commutative m0 m1 = H.join_commutative m0.heap m1.heap let disjoint_join m0 m1 m2 = H.disjoint_join m0.heap m1.heap m2.heap let join_associative m0 m1 m2 = H.join_associative m0.heap m1.heap m2.heap let slprop = H.slprop let interp p m = H.interp p m.heap let equiv p1 p2 = forall m. interp p1 m <==> interp p2 m let slprop_extensionality p q = assert (forall m. interp p m <==> interp q m); let aux (h:H.heap) : Lemma (H.interp p h <==> H.interp q h) [SMTPat (H.interp p h)] = let m : mem = { ctr = 0; heap = h; locks = [] } in assert (interp p m <==> interp q m) in assert (forall h. H.interp p h <==> H.interp q h); Steel.Heap.slprop_extensionality p q let reveal_equiv p1 p2 = () let core_ref = H.core_ref let core_ref_null = H.core_ref_null let core_ref_is_null r = H.core_ref_is_null r let emp : slprop u#a = H.emp let pure = H.pure let pts_to = H.pts_to let h_and = H.h_and let h_or = H.h_or let star = H.star let wand = H.wand let h_exists = H.h_exists let h_forall = H.h_forall //////////////////////////////////////////////////////////////////////////////// //properties of equiv //////////////////////////////////////////////////////////////////////////////// let equiv_symmetric (p1 p2:slprop u#a) = H.equiv_symmetric p1 p2 #push-options "--warn_error -271" let equiv_heap_iff_equiv (p1 p2:slprop u#a) : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat (equiv p1 p2)] = let aux_lr () : Lemma (requires H.equiv p1 p2) (ensures equiv p1 p2) [SMTPat ()] = () in let aux_rl_helper1 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p1 h) (ensures H.interp p2 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl_helper2 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p2 h) (ensures H.interp p1 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl () : Lemma (requires equiv p1 p2) (ensures H.equiv p1 p2) [SMTPat ()] = () in () let equiv_heap_iff_equiv_forall () : Lemma (ensures (forall p1 p2. H.equiv p1 p2 <==> equiv p1 p2)) = let aux p1 p2 : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat ()] = equiv_heap_iff_equiv p1 p2 in () #pop-options let equiv_extensional_on_star (p1 p2 p3:slprop u#a) = equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3 let emp_unit p = H.emp_unit p let intro_emp m = H.intro_emp (heap_of_mem m) let pure_equiv p q = H.pure_equiv p q let pure_interp q m = H.pure_interp q (heap_of_mem m) let pure_star_interp p q m = H.pure_star_interp p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// //pts_to //////////////////////////////////////////////////////////////////////////////// let pts_to_compatible #a #pcm x v0 v1 m = H.pts_to_compatible #a #pcm x v0 v1 (heap_of_mem m) let pts_to_compatible_equiv #a #pcm x v0 v1 = H.pts_to_compatible_equiv #a #pcm x v0 v1 let pts_to_not_null #a #pcm x v m = H.pts_to_not_null #a #pcm x v (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // star //////////////////////////////////////////////////////////////////////////////// let intro_star p q mp mq = H.intro_star p q (heap_of_mem mp) (heap_of_mem mq) let elim_star p q m = let h = heap_of_mem m in H.elim_star p q h; assert (exists hl hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr); let hl = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hl -> exists hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let hr = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hr -> H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let ml = mem_set_heap m hl in let mr = mem_set_heap m hr in assert (disjoint ml mr); assert (m == join ml mr); assert (interp p ml); assert (interp q mr); () let interp_star (p q: slprop) (m: mem) : Lemma (interp (p `star` q) m <==> (exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m)) = let left = interp (p `star` q) m in let right = exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m in let f () : Lemma (requires left) (ensures right) = elim_star p q m in let g () : Lemma (requires right) (ensures left) = Classical.exists_elim left #_ #(fun mp -> exists (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mp -> Classical.exists_elim left #_ #(fun mq -> disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mq -> intro_star p q mp mq ) ) in Classical.move_requires f (); Classical.move_requires g () let star_commutative (p1 p2:slprop) = H.star_commutative p1 p2 let star_associative (p1 p2 p3:slprop) = H.star_associative p1 p2 p3 let star_congruence (p1 p2 p3 p4:slprop) = equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4 let affine_star (p q:slprop) (m:mem) = H.affine_star p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // Invariants on the lock store //////////////////////////////////////////////////////////////////////////////// let iname = nat module S = FStar.Set module L = FStar.List.Tot module W = FStar.Witnessed.Core let rec lock_store_invariant (e:inames) (l:lock_store u#a) : slprop u#a = let current_addr = L.length l - 1 in match l with | [] -> emp | Invariant p :: tl -> if current_addr `S.mem` e then lock_store_invariant e tl else p `star` lock_store_invariant e tl let lock_i (i:iname) (l:lock_store { i < L.length l }) = let ix = L.length l - i - 1 in L.index l ix let iname_for_p (i:iname) (p:slprop) : W.s_predicate lock_store = fun l -> i < L.length l /\ (lock_i i l).inv == p let lock_store_evolves : FStar.Preorder.preorder lock_store = fun (l1 l2 : lock_store) -> L.length l2 >= L.length l1 /\ (forall (i:nat{i < L.length l1}). (lock_i i l1).inv == (lock_i i l2).inv) let inames_in (e:inames) (l:lock_store) : prop = forall i. Set.mem i e ==> i < L.length l let inames_ok e m = inames_in e m.locks let inames_ok_empty m = () let extend_lock_store (e:inames) (l:lock_store{e `inames_in` l}) (p:slprop) : i:iname & l':lock_store { lock_store_invariant e l' == p `star` lock_store_invariant e l /\ iname_for_p i p l' } = (| L.length l, Invariant p :: l |) let set_add (i:iname) (s:inames) = Set.union (Set.singleton i) s let rec move_invariant (e:inames) (l:lock_store) (p:slprop) (i:iname{iname_for_p i p l /\ ~(i `Set.mem` e)}) : Lemma (H.equiv (lock_store_invariant e l) (p `star` lock_store_invariant (set_add i e) l)) = let rec aux (i:iname) (m:lock_store) : Lemma (requires i >= L.length m) (ensures (lock_store_invariant e m `H.equiv` lock_store_invariant (set_add i e) m)) = match m with | [] -> () | Invariant p::tl -> aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl) in let current_addr = L.length l - 1 in match l with | [] -> () | Invariant q::tl -> if i = current_addr then begin assert (lock_store_invariant e l == p `star` lock_store_invariant e tl); aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl); () end else begin move_invariant e tl p i; assert (lock_store_invariant e tl `equiv` (p `star` lock_store_invariant (set_add i e) tl)); H.star_congruence q (lock_store_invariant e tl) q (p `star` lock_store_invariant (set_add i e) tl); if Set.mem current_addr e then () else begin let r = lock_store_invariant (set_add i e) tl in assert (lock_store_invariant e l `equiv` (q `star` (p `star` r))); H.star_associative q p r; H.star_commutative q p; H.star_congruence (q `star` p) r (p `star` q) r; H.star_associative p q r end end let heap_ctr_valid (ctr:nat) (h:H.heap u#a) : prop = h `H.free_above_addr` ctr let ctr_validity (ctr:nat) (h:H.heap) : slprop = H.pure (heap_ctr_valid ctr h) let locks_invariant (e:inames) (m:mem u#a) : slprop u#a = lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m) let full_mem_pred (m:mem) = H.full_heap_pred (heap_of_mem m) (***** Following lemmas are needed in Steel.Effect *****) let core_mem_interp (hp:slprop u#a) (m:mem u#a) = () let interp_depends_only_on (hp:slprop u#a) = H.interp_depends_only_on hp let a_mem_prop_as_a_heap_prop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (H.a_heap_prop u#a) = let g (h: H.heap u#a) : Tot prop = interp sl (mem_of_heap h) /\ f (mem_of_heap h) in let phi0 (h0 h1: H.heap u#a) : Lemma (requires (g h0 /\ H.disjoint h0 h1)) (ensures (g h0 /\ H.disjoint h0 h1 /\ g (H.join h0 h1))) = assert (mem_of_heap (H.join h0 h1) == mem_of_heap h0 `join` mem_of_heap h1); interp_depends_only_on sl in let phi1 (h0 h1: H.heap u#a) : Lemma (ensures ((g h0 /\ H.disjoint h0 h1) ==> g (H.join h0 h1))) = Classical.move_requires (phi0 h0) h1 in Classical.forall_intro_2 phi1; g let refine_slprop sl f = H.as_slprop (a_mem_prop_as_a_heap_prop sl f) let interp_refine_slprop sl f m = assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_mem m)) let dep_hprop (s: slprop) (f: (hmem s -> Tot slprop)) (h: H.heap) : Tot prop = exists (h1: H.heap) . exists (h2: H.heap) . interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 let dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq' : squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h')) = let p2 (h h1 h2: H.heap) : Tot prop = interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 in let p1 (h h1: H.heap) : Tot prop = (exists h2 . p2 h h1 h2) in let h1 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p1 h) in let h2 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p2 h h1) in H.disjoint_join h' h1 h2; assert (H.disjoint h2 h'); let h2' = H.join h2 h' in H.join_commutative h2 h' ; assert (h2' == H.join h' h2); assert (H.disjoint h1 h2'); assert (mem_of_heap h2' == mem_of_heap h2 `join` mem_of_heap h'); interp_depends_only_on (f (mem_of_heap h1)); assert (interp (f (mem_of_heap h1)) (mem_of_heap h2')); H.join_commutative h1 h2; H.join_associative h' h2 h1; H.join_commutative h' h; H.join_commutative h2' h1; assert (H.join h h' == h1 `H.join` h2') let impl_intro_gen (#p: Type0) (#q: Type0) ($prf: (squash p -> Lemma (q ))) : Lemma (p ==> q) = Classical.impl_intro_gen #p #(fun _ -> q) prf let dep_hprop_is_affine1 (s: slprop) (f: (hmem s -> Tot slprop)) (h0 h1: H.heap) : Lemma ((dep_hprop s f h0 /\ H.disjoint h0 h1) ==> (H.disjoint h0 h1 /\ dep_hprop s f (H.join h0 h1))) = impl_intro_gen (dep_hprop_is_affine0 s f h0 h1) let dep_hprop_is_affine (s: slprop) (f: (hmem s -> Tot slprop)) : Lemma (H.heap_prop_is_affine (dep_hprop s f)) = Classical.forall_intro_2 (dep_hprop_is_affine1 s f) let sdep (s: slprop) (f: (hmem s -> Tot slprop)) : Tot slprop = dep_hprop_is_affine s f; H.as_slprop (dep_hprop s f) let interp_sdep (s: slprop) (f: (hmem s -> Tot slprop)) (m: mem) : Lemma (requires (dep_slprop_is_affine s f)) (ensures ( interp (sdep s f) m <==> (exists m1 m2 . interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) )) = dep_hprop_is_affine s f; assert (forall m1 m2 . (interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) ==> ( interp s (mem_of_heap m1.heap) /\ interp (f (mem_of_heap m1.heap)) (mem_of_heap m2.heap) /\ H.disjoint m1.heap m2.heap /\ H.join m1.heap m2.heap == m.heap )); interp_depends_only_on s; Classical.forall_intro (fun m -> interp_depends_only_on (f m)); assert (forall h1 h2 . (interp s (mem_of_heap h1) /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ H.disjoint h1 h2 /\ H.join h1 h2 == m.heap) ==> ( core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ interp s (core_mem (mem_of_heap h1)) /\ interp s (mem_set_heap m h1) /\ core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ f (mem_set_heap m h1) `equiv` f (mem_of_heap h1) /\ interp (f (mem_set_heap m h1)) (mem_of_heap h2) /\ interp (f (mem_set_heap m h1)) (mem_set_heap m h2) /\ disjoint (mem_set_heap m h1) (mem_set_heap m h2) /\ join (mem_set_heap m h1) (mem_set_heap m h2) == m )); () let h_exists_cong (#a:Type) (p q : a -> slprop) : Lemma (requires (forall x. p x `equiv` q x)) (ensures (h_exists p `equiv` h_exists q)) = equiv_heap_iff_equiv_forall (); H.h_exists_cong p q let intro_h_exists #a x p m = H.intro_h_exists x p (heap_of_mem m) let elim_h_exists (#a:_) (p:a -> slprop) (m:mem) = H.elim_h_exists p (heap_of_mem m) let intro_h_forall (#a:_) (p:a -> slprop) (m:mem) = H.intro_h_forall p (heap_of_mem m) let elim_h_forall (#a:_) (p:a -> slprop) (m:mem) (x:a) = H.elim_h_forall p (heap_of_mem m) x let intro_h_and (p q: slprop) (m:mem) = H.intro_h_and p q (heap_of_mem m) let elim_h_and (p q: slprop) (m:mem) = H.elim_h_and p q (heap_of_mem m) let intro_h_or_left (p q: slprop) (m:mem) = H.intro_h_or_left p q (heap_of_mem m) let intro_h_or_right (p q: slprop) (m:mem) = H.intro_h_or_right p q (heap_of_mem m) let elim_h_or (p q: slprop) (m:mem) = H.elim_h_or p q (heap_of_mem m) let intro_wand (p1 p2: slprop u#a) (m:mem) = introduce (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)) ==> interp (wand p1 p2) m with _. ( assert (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)); H.intro_wand p1 p2 (heap_of_mem m); let h = heap_of_mem m in assert ((forall h1. h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) ==> H.interp (wand p1 p2) h); introduce forall h1. (h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) with ( introduce (h `H.disjoint` h1 /\ H.interp p1 h1) ==> H.interp p2 (H.join h h1) with _. ( assert (h `H.disjoint` h1); let m1 = { ctr = m.ctr; heap = h1; locks = m.locks } in assert (m `disjoint` m1) ) ) ) (** Eliminating a wand by proving a heap that satisfies the LHS **) let elim_wand (p1 p2: slprop u#a) (m:mem) (m1:mem) = H.elim_wand p1 p2 (heap_of_mem m) (heap_of_mem m1) //////////////////////////////////////////////////////////////////////////////// // Preorders and effects //////////////////////////////////////////////////////////////////////////////// module PP = Steel.Preorder let mem_evolves = fun (m0 m1:full_mem) -> H.heap_evolves (heap_of_mem m0) (heap_of_mem m1) /\ m0.ctr <= m1.ctr /\ lock_store_evolves m0.locks m1.locks (** See [Steel.Heap.is_frame_preserving]. We add in [lock_invariants] now *) let preserves_frame (e:inames) (pre post:slprop) (m0 m1:mem) = forall (frame:slprop). interp ((pre `star` frame) `star` locks_invariant e m0) m0 ==> (interp ((post `star` frame) `star` locks_invariant e m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) (** This is a version of MstTot with frame quantified, as part of preserves_frame *) effect MstTotNF (a:Type u#a) (except:inames) (expects:slprop u#1) (provides: a -> slprop u#1) = NMSTTotal.NMSTATETOT a (full_mem u#1) mem_evolves (requires fun m0 -> inames_ok except m0 /\ interp (expects `star` locks_invariant except m0) m0) (ensures fun m0 x m1 -> inames_ok except m1 /\ interp (provides x `star` locks_invariant except m1) m1 /\ preserves_frame except expects (provides x) m0 m1) //////////////////////////////////////////////////////////////////////////////// // Lifting heap actions //////////////////////////////////////////////////////////////////////////////// (** Heap actions come in two equivalent flavors: - one that take an explicit frame as argument (action_with_frame) - and one that quantify over all the frame We therefore define two lift routes: - a direct route for those with explicit frame - via MstTotNF for the rest *) let tot_pre_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = hmem_with_inv_except e fp -> (x:a & hmem_with_inv_except e (fp' x)) let tot_pre_action_nf = tot_pre_action_nf_except S.empty let ac_reasoning_for_m_frame_preserving (p q r:slprop u#a) (m:mem u#a) : Lemma (requires interp ((p `star` q) `star` r) m) (ensures interp (p `star` r) m) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_commutative p q; equiv_extensional_on_star (p `star` q) (q `star` p) r } (q `star` p) `star` r; (equiv) { star_associative q p r } q `star` (p `star` r); }; assert (interp (q `star` (p `star` r)) m); affine_star q (p `star` r) m let is_frame_preserving (#e:inames) (#a:Type u#b) (#fp:slprop u#a) (#fp':a -> slprop u#a) (f:tot_pre_action_nf_except e fp a fp') = forall (frame:slprop u#a) (m0:hmem_with_inv_except e (fp `star` frame)). (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = f:tot_pre_action_nf_except e fp a fp'{ is_frame_preserving f } let tot_action_nf = tot_action_nf_except S.empty let linv e (m:mem) = locks_invariant e m let hheap_of_hmem #fp #e (m:hmem_with_inv_except e fp) : h:H.hheap (fp `star` linv e m) { h `H.free_above_addr` m.ctr} = let h = heap_of_mem m in H.pure_interp (heap_ctr_valid m.ctr (heap_of_mem m)) h; h let hmem_of_hheap #e (#fp0 #fp1:slprop) (m:hmem_with_inv_except e fp0) (h:H.full_hheap (fp1 `star` linv e m) { h `Heap.free_above_addr` m.ctr }) : m1:hmem_with_inv_except e fp1{linv e m `equiv` linv e m1} = let m1 : mem = { m with heap = h } in assert (interp (fp1 `star` linv e m) m1); star_commutative fp1 (linv e m); assert (interp (linv e m `star` fp1) m1); assert (linv e m1 == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); assert (linv e m == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m)); H.pure_interp (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_of_mem m); assert (heap_ctr_valid m1.ctr (heap_of_mem m) <==> heap_ctr_valid m1.ctr (heap_of_mem m1)); H.pure_equiv (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_ctr_valid m1.ctr (heap_of_mem m1)); H.star_congruence (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m)); assert (linv e m `equiv` linv e m1); let _ = equiv_extensional_on_star (linv e m) (linv e m1) fp1 in assert ((linv e m `star` fp1) `equiv` (linv e m1 `star` fp1)); assert (interp (linv e m1 `star` fp1) m1); star_commutative (linv e m1) fp1; assert (interp (fp1 `star` linv e m1) m1); m1 let with_inv_except (m:mem) e (fp:slprop) = interp (fp `star` locks_invariant e m) m #push-options "--warn_error -271" let as_hprop (frame:slprop) (mp:mprop frame) : hp:H.hprop frame{forall m. mp (core_mem m) == hp (heap_of_mem m)} = let f = fun h -> mp (mem_of_heap h) in assert (forall m. mp (core_mem m) == f (heap_of_mem m)); let aux (m0:H.hheap frame) (m1:H.heap{H.disjoint m0 m1}) : Lemma (ensures (mem_of_heap (H.join m0 m1) == join (mem_of_heap m0) (mem_of_heap m1))) [SMTPat ()] = () in f let mprop_preservation_of_hprop_preservation (p:slprop) (m0 m1:mem) : Lemma (requires (forall (hp:H.hprop p). hp (heap_of_mem m0) == hp (heap_of_mem m1))) (ensures (forall (mp:mprop p). mp (core_mem m0) == mp (core_mem m1))) = let aux (mp:mprop p) : Lemma (mp (core_mem m0) == mp (core_mem m1)) [SMTPat()] = assert (as_hprop p mp (heap_of_mem m0) == as_hprop p mp (heap_of_mem m1)) in () let lift_heap_action (#fp:slprop) (#a:Type) (#fp':a -> slprop) (e:inames) ($f:H.action fp a fp') : tot_action_nf_except e fp a fp' = let g : tot_pre_action_nf_except e fp a fp' = fun m -> let h0 = hheap_of_hmem m in let (| x, h' |) = f h0 in (| x, hmem_of_hheap m h' |) in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in let h0 = hheap_of_hmem m0 in let (| x', h1 |) = f h0 in H.action_framing f (linv e m0) h0; assert (x == x'); star_associative fp frame (linv e m0); H.action_framing f (frame `star` linv e m0) h0; assert (H.interp ((fp' x) `star` (frame `star` linv e m0)) h1); star_associative (fp' x) frame (linv e m0); assert (H.interp ((fp' x `star` frame) `star` linv e m0) h1); let h1' : H.hheap ((fp' x `star` frame) `star` linv e m0) = h1 in assert (m1 == hmem_of_hheap m0 h1'); assert (with_inv_except m1 e (fp' x `star` frame)); assert (forall (hp:H.hprop frame). hp h0 == hp h1); mprop_preservation_of_hprop_preservation frame m0 m1; () in assert (is_frame_preserving g); g let frame_preserving_respects_preorder #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (m0:hmem_with_inv_except e fp) : Lemma (let (| x, m1 |) = f m0 in mem_evolves m0 m1) = let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1) = () in H.emp_unit fp; assert (interp (fp `star` linv e m0) m0); H.star_congruence (fp `star` emp) (linv e m0) fp (linv e m0); assert (interp ((fp `star` emp) `star` linv e m0) m0); aux emp m0 let lift_tot_action_nf #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') : MstTotNF a e fp fp' = let m0 = NMSTTotal.get () in let m0' : hmem_with_inv_except e fp = m0 in let r = f m0' in let (| x, m1 |) = r in let m1' : hmem_with_inv_except e (fp' x) = m1 in assert (is_frame_preserving f); assert (m1 == dsnd (f m0)); frame_preserving_respects_preorder f m0; NMSTTotal.put #_ #(mem_evolves) m1; x let lift_tot_action #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get #(full_mem) #_ () in ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); lift_tot_action_nf f (** Now defining the lift for heap actions with explicit frame *) let tot_action_with_frame_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = frame:slprop u#a -> m0:hmem_with_inv_except e (fp `star` frame) -> Pure (x:a & hmem_with_inv_except e (fp' x `star` frame)) (requires True) (ensures fun (| x, m1 |) -> mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_with_frame = tot_action_with_frame_except S.empty let lift_heap_action_with_frame (#fp:slprop u#a) (#a:Type u#b) (#fp':a -> slprop u#a) (e:inames) ($f:H.action_with_frame fp a fp') : tot_action_with_frame_except e fp a fp' = fun frame m0 -> let h0 = hheap_of_hmem m0 in calc (equiv) { fp `star` frame `star` locks_invariant e m0; (equiv) { star_associative fp frame (locks_invariant e m0) } fp `star` (frame `star` locks_invariant e m0); }; assert (H.interp (fp `star` frame `star` locks_invariant e m0) h0); assert (H.interp (fp `star` (frame `star` locks_invariant e m0)) h0); //key: apply the heap action with frame * locks_invariant e m0 let (| x, h1 |) = f (frame `star` locks_invariant e m0) h0 in calc (equiv) { fp' x `star` (frame `star` locks_invariant e m0); (equiv) { star_associative (fp' x) frame (locks_invariant e m0) } fp' x `star` frame `star` locks_invariant e m0; }; assert (H.interp (fp' x `star` (frame `star` locks_invariant e m0)) h1); assert (H.interp (fp' x `star` frame `star` locks_invariant e m0) h1); let m1 = hmem_of_hheap m0 h1 in assert (mem_evolves m0 m1); mprop_preservation_of_hprop_preservation (frame `star` locks_invariant e m0) m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)); (| x, m1 |) let lift_tot_action_with_frame #a #e #fp #fp' ($f:tot_action_with_frame_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in assert (inames_ok e m0); ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); let m0' : hmem_with_inv_except e fp = m0 in let r = f frame m0' in let (| x, m1 |) = r in ac_reasoning_for_m_frame_preserving (fp' x) frame (locks_invariant e m1) m1; assert (interp (fp' x `star` frame `star` locks_invariant e m1) m1); assert (interp (fp' x `star` locks_invariant e m1) m1); let m1' : hmem_with_inv_except e (fp' x) = m1 in NMSTTotal.put #_ #(mem_evolves) m1; x let sel_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.sel_action #a #pcm r v0)) let upd_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.upd_action #a #pcm r v0 v1)) let free_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.free_action #a #pcm r v0)) let split_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.split_action #a #pcm r v0 v1)) let gather_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.gather_action #a #pcm r v0 v1)) let weaken (p q r:slprop) (h:H.hheap (p `star` q) { H.stronger q r }) : H.hheap (p `star` r) = H.weaken p q r h; h let weaken_pure (q r: prop) : Lemma (requires (q ==> r)) (ensures H.stronger (H.pure q) (H.pure r)) = let aux (h:H.heap) : Lemma (ensures (H.interp (H.pure q) h ==> H.interp (H.pure r) h)) [SMTPat ()] = H.pure_interp q h; H.pure_interp r h in () let inc_ctr (#p:slprop) #e (m:hmem_with_inv_except e p) : m':hmem_with_inv_except e p{m'.ctr = m.ctr + 1 /\ H.stronger (linv e m) (linv e m')} = let m' : mem = { m with ctr = m.ctr + 1} in assert (interp (p `star` linv e m) m'); assert (linv e m == lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m)); assert (linv e m' == lock_store_invariant e m.locks `star` ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken_free_above (heap_of_mem m) m.ctr (m.ctr + 1); weaken_pure (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_ctr_valid (m.ctr + 1) (heap_of_mem m)); assert (H.stronger (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m))); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)); H.stronger_star (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken (p `star` lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)) (heap_of_mem m'); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity (m.ctr + 1) (heap_of_mem m)); let m' : hmem_with_inv_except e p = m' in m' let frame_related_mems (fp0 fp1:slprop u#a) e (m0:hmem_with_inv_except e fp0) (m1:hmem_with_inv_except e fp1) = forall (frame:slprop u#a). interp ((fp0 `star` frame) `star` linv e m0) m0 ==> interp ((fp1 `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) let refined_pre_action e (fp0:slprop) (a:Type) (fp1:a -> slprop) = m0:hmem_with_inv_except e fp0 -> Pure (x:a & hmem_with_inv_except e (fp1 x)) (requires True) (ensures fun (| x, m1 |) -> frame_related_mems fp0 (fp1 x) e m0 m1) let refined_pre_action_as_action (#fp0:slprop) (#a:Type) (#fp1:a -> slprop) #e ($f:refined_pre_action e fp0 a fp1) : tot_action_nf_except e fp0 a fp1 = let g : tot_pre_action_nf_except e fp0 a fp1 = fun m -> f m in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp0 `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp1 x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x', m1' |) = g m0 in let (| x, m1 |) = f m0 in assert (x == x' /\ m1 == m1') in g let alloc_action #a #pcm e x = let f : refined_pre_action e emp (ref a pcm) (fun r -> pts_to r x) = fun m0 -> (* NS: 9/29/22 I needed to annotate h : Heap.full_heap, for use with the Core checker which generates a guard for checking the implicit pattern "dot" term in the dependent pair pattern on the next line. That guard expects `h` to be a full_heap, which is it, because it is a projection of m0. However, this is not reflected in `h`'s type. So, the Core checker, which produces a guard for the pat_dot_term in isolation, cannot recheck the term. If we were to fold in the checking of pat_dot_terms and their guards with the rest of the VC, this would work. *) let h : Heap.full_heap = hheap_of_hmem m0 in let (|r, h'|) = H.extend #a #pcm x m0.ctr h in let m' : hmem_with_inv_except e emp = inc_ctr m0 in let h' : H.hheap (pts_to #a #pcm r x `star` linv e m') = weaken _ (linv e m0) (linv e m') h' in let m1 : hmem_with_inv_except e (pts_to #a #pcm r x) = hmem_of_hheap m' h' in assert (forall frame. H.frame_related_heaps h h' emp (pts_to #a #pcm r x) frame true); let aux (frame:slprop) : Lemma (requires interp ((emp `star` frame) `star` linv e m0) m0) (ensures interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) [SMTPat (emp `star` frame)] = star_associative emp frame (linv e m0); assert (H.interp (emp `star` (frame `star` linv e m0)) h); assert (H.interp (pts_to #a #pcm r x `star` (frame `star` linv e m0)) h'); star_associative (pts_to #a #pcm r x) frame (linv e m0); assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m0) h'); assert (H.stronger (linv e m0) (linv e m')); assert (H.equiv (linv e m') (linv e m1)); assert (H.stronger (linv e m0) (linv e m1)); let h' : H.hheap ((pts_to #a #pcm r x `star` frame) `star` linv e m1) = weaken _ (linv e m0) (linv e m1) h' in assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) h'); assert (forall (mp:H.hprop frame). mp h == mp h'); mprop_preservation_of_hprop_preservation frame m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) in assert (frame_related_mems emp (pts_to r x) e m0 m1); (| r, m1 |) in lift_tot_action (refined_pre_action_as_action f) let select_refine #a #p e r x f = lift_tot_action (lift_heap_action e (H.select_refine #a #p r x f)) let upd_gen #a #p e r x y f = lift_tot_action (lift_heap_action e (H.upd_gen_action r x y f)) //////////////////////////////////////////////////////////////////////////////// // witness / recall ////////////////////////////////////////////////////////////////////////////////

{ "checked_file": "/", "dependencies": [ "Steel.Preorder.fst.checked", "Steel.Heap.fsti.checked", "prims.fst.checked", "FStar.Witnessed.Core.fsti.checked", "FStar.Set.fsti.checked", "FStar.Preorder.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.PCM.fst.checked", "FStar.NMSTTotal.fst.checked", "FStar.List.Tot.fst.checked", "FStar.IndefiniteDescription.fsti.checked", "FStar.Ghost.fsti.checked", "FStar.FunctionalExtensionality.fsti.checked", "FStar.Classical.Sugar.fsti.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Steel.Memory.fst" }

[ { "abbrev": true, "full_module": "Steel.Preorder", "short_module": "PP" }, { "abbrev": true, "full_module": "FStar.Witnessed.Core", "short_module": "W" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": true, "full_module": "Steel.Heap", "short_module": "H" }, { "abbrev": false, "full_module": "FStar.PCM", "short_module": null }, { "abbrev": false, "full_module": "FStar.FunctionalExtensionality", "short_module": null }, { "abbrev": true, "full_module": "FStar.FunctionalExtensionality", "short_module": "F" }, { "abbrev": false, "full_module": "FStar.PCM", "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.Memory.ref a pcm -> fact: Steel.Memory.property a -> m: Steel.Memory.full_mem -> Prims.logical

Prims.Tot

[ "total" ]

[]

[ "FStar.PCM.pcm", "Steel.Memory.ref", "Steel.Memory.property", "Steel.Memory.full_mem", "Steel.Heap.witnessed_ref", "Steel.Memory.heap_of_mem", "Prims.logical" ]

[]

false

true

let witnessed_ref #a #pcm (r: ref a pcm) (fact: property a) (m: full_mem) =

H.witnessed_ref #a #pcm r fact (heap_of_mem m)

false

Steel.Memory.fst

Steel.Memory.gather_action

val gather_action (#a:Type u#1) (#pcm:pcm a) (e:inames) (r:ref a pcm) (v0:FStar.Ghost.erased a) (v1:FStar.Ghost.erased a) : action_except (_:unit{composable pcm v0 v1}) e (pts_to r v0 `star` pts_to r v1) (fun _ -> pts_to r (op pcm v0 v1))

let gather_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.gather_action #a #pcm r v0 v1))

{ "file_name": "lib/steel/Steel.Memory.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 74, "end_line": 856, "start_col": 0, "start_line": 855 }

(* 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.Memory module F = FStar.FunctionalExtensionality open FStar.FunctionalExtensionality open FStar.PCM module H = Steel.Heap noeq type lock_state : Type u#(a + 1) = | Invariant : inv:H.slprop u#a -> lock_state let lock_store : Type u#(a+1) = list (lock_state u#a) noeq type mem : Type u#(a + 1) = { ctr: nat; heap: H.heap u#a; locks: lock_store u#a; } let heap_of_mem (x:mem) : H.heap = x.heap let mem_of_heap (h:H.heap) : mem = { ctr = 0; heap = h; locks = [] } let mem_set_heap (m:mem) (h:H.heap) : mem = { ctr = m.ctr; heap = h; locks = m.locks; } let core_mem (m:mem) : mem = mem_of_heap (heap_of_mem m) let core_mem_invol m = () let disjoint (m0 m1:mem u#h) : prop = m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks let disjoint_sym m0 m1 = () let join m0 m1 = { ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = m0.locks } let join_commutative m0 m1 = H.join_commutative m0.heap m1.heap let disjoint_join m0 m1 m2 = H.disjoint_join m0.heap m1.heap m2.heap let join_associative m0 m1 m2 = H.join_associative m0.heap m1.heap m2.heap let slprop = H.slprop let interp p m = H.interp p m.heap let equiv p1 p2 = forall m. interp p1 m <==> interp p2 m let slprop_extensionality p q = assert (forall m. interp p m <==> interp q m); let aux (h:H.heap) : Lemma (H.interp p h <==> H.interp q h) [SMTPat (H.interp p h)] = let m : mem = { ctr = 0; heap = h; locks = [] } in assert (interp p m <==> interp q m) in assert (forall h. H.interp p h <==> H.interp q h); Steel.Heap.slprop_extensionality p q let reveal_equiv p1 p2 = () let core_ref = H.core_ref let core_ref_null = H.core_ref_null let core_ref_is_null r = H.core_ref_is_null r let emp : slprop u#a = H.emp let pure = H.pure let pts_to = H.pts_to let h_and = H.h_and let h_or = H.h_or let star = H.star let wand = H.wand let h_exists = H.h_exists let h_forall = H.h_forall //////////////////////////////////////////////////////////////////////////////// //properties of equiv //////////////////////////////////////////////////////////////////////////////// let equiv_symmetric (p1 p2:slprop u#a) = H.equiv_symmetric p1 p2 #push-options "--warn_error -271" let equiv_heap_iff_equiv (p1 p2:slprop u#a) : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat (equiv p1 p2)] = let aux_lr () : Lemma (requires H.equiv p1 p2) (ensures equiv p1 p2) [SMTPat ()] = () in let aux_rl_helper1 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p1 h) (ensures H.interp p2 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl_helper2 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p2 h) (ensures H.interp p1 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl () : Lemma (requires equiv p1 p2) (ensures H.equiv p1 p2) [SMTPat ()] = () in () let equiv_heap_iff_equiv_forall () : Lemma (ensures (forall p1 p2. H.equiv p1 p2 <==> equiv p1 p2)) = let aux p1 p2 : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat ()] = equiv_heap_iff_equiv p1 p2 in () #pop-options let equiv_extensional_on_star (p1 p2 p3:slprop u#a) = equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3 let emp_unit p = H.emp_unit p let intro_emp m = H.intro_emp (heap_of_mem m) let pure_equiv p q = H.pure_equiv p q let pure_interp q m = H.pure_interp q (heap_of_mem m) let pure_star_interp p q m = H.pure_star_interp p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// //pts_to //////////////////////////////////////////////////////////////////////////////// let pts_to_compatible #a #pcm x v0 v1 m = H.pts_to_compatible #a #pcm x v0 v1 (heap_of_mem m) let pts_to_compatible_equiv #a #pcm x v0 v1 = H.pts_to_compatible_equiv #a #pcm x v0 v1 let pts_to_not_null #a #pcm x v m = H.pts_to_not_null #a #pcm x v (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // star //////////////////////////////////////////////////////////////////////////////// let intro_star p q mp mq = H.intro_star p q (heap_of_mem mp) (heap_of_mem mq) let elim_star p q m = let h = heap_of_mem m in H.elim_star p q h; assert (exists hl hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr); let hl = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hl -> exists hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let hr = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hr -> H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let ml = mem_set_heap m hl in let mr = mem_set_heap m hr in assert (disjoint ml mr); assert (m == join ml mr); assert (interp p ml); assert (interp q mr); () let interp_star (p q: slprop) (m: mem) : Lemma (interp (p `star` q) m <==> (exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m)) = let left = interp (p `star` q) m in let right = exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m in let f () : Lemma (requires left) (ensures right) = elim_star p q m in let g () : Lemma (requires right) (ensures left) = Classical.exists_elim left #_ #(fun mp -> exists (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mp -> Classical.exists_elim left #_ #(fun mq -> disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mq -> intro_star p q mp mq ) ) in Classical.move_requires f (); Classical.move_requires g () let star_commutative (p1 p2:slprop) = H.star_commutative p1 p2 let star_associative (p1 p2 p3:slprop) = H.star_associative p1 p2 p3 let star_congruence (p1 p2 p3 p4:slprop) = equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4 let affine_star (p q:slprop) (m:mem) = H.affine_star p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // Invariants on the lock store //////////////////////////////////////////////////////////////////////////////// let iname = nat module S = FStar.Set module L = FStar.List.Tot module W = FStar.Witnessed.Core let rec lock_store_invariant (e:inames) (l:lock_store u#a) : slprop u#a = let current_addr = L.length l - 1 in match l with | [] -> emp | Invariant p :: tl -> if current_addr `S.mem` e then lock_store_invariant e tl else p `star` lock_store_invariant e tl let lock_i (i:iname) (l:lock_store { i < L.length l }) = let ix = L.length l - i - 1 in L.index l ix let iname_for_p (i:iname) (p:slprop) : W.s_predicate lock_store = fun l -> i < L.length l /\ (lock_i i l).inv == p let lock_store_evolves : FStar.Preorder.preorder lock_store = fun (l1 l2 : lock_store) -> L.length l2 >= L.length l1 /\ (forall (i:nat{i < L.length l1}). (lock_i i l1).inv == (lock_i i l2).inv) let inames_in (e:inames) (l:lock_store) : prop = forall i. Set.mem i e ==> i < L.length l let inames_ok e m = inames_in e m.locks let inames_ok_empty m = () let extend_lock_store (e:inames) (l:lock_store{e `inames_in` l}) (p:slprop) : i:iname & l':lock_store { lock_store_invariant e l' == p `star` lock_store_invariant e l /\ iname_for_p i p l' } = (| L.length l, Invariant p :: l |) let set_add (i:iname) (s:inames) = Set.union (Set.singleton i) s let rec move_invariant (e:inames) (l:lock_store) (p:slprop) (i:iname{iname_for_p i p l /\ ~(i `Set.mem` e)}) : Lemma (H.equiv (lock_store_invariant e l) (p `star` lock_store_invariant (set_add i e) l)) = let rec aux (i:iname) (m:lock_store) : Lemma (requires i >= L.length m) (ensures (lock_store_invariant e m `H.equiv` lock_store_invariant (set_add i e) m)) = match m with | [] -> () | Invariant p::tl -> aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl) in let current_addr = L.length l - 1 in match l with | [] -> () | Invariant q::tl -> if i = current_addr then begin assert (lock_store_invariant e l == p `star` lock_store_invariant e tl); aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl); () end else begin move_invariant e tl p i; assert (lock_store_invariant e tl `equiv` (p `star` lock_store_invariant (set_add i e) tl)); H.star_congruence q (lock_store_invariant e tl) q (p `star` lock_store_invariant (set_add i e) tl); if Set.mem current_addr e then () else begin let r = lock_store_invariant (set_add i e) tl in assert (lock_store_invariant e l `equiv` (q `star` (p `star` r))); H.star_associative q p r; H.star_commutative q p; H.star_congruence (q `star` p) r (p `star` q) r; H.star_associative p q r end end let heap_ctr_valid (ctr:nat) (h:H.heap u#a) : prop = h `H.free_above_addr` ctr let ctr_validity (ctr:nat) (h:H.heap) : slprop = H.pure (heap_ctr_valid ctr h) let locks_invariant (e:inames) (m:mem u#a) : slprop u#a = lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m) let full_mem_pred (m:mem) = H.full_heap_pred (heap_of_mem m) (***** Following lemmas are needed in Steel.Effect *****) let core_mem_interp (hp:slprop u#a) (m:mem u#a) = () let interp_depends_only_on (hp:slprop u#a) = H.interp_depends_only_on hp let a_mem_prop_as_a_heap_prop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (H.a_heap_prop u#a) = let g (h: H.heap u#a) : Tot prop = interp sl (mem_of_heap h) /\ f (mem_of_heap h) in let phi0 (h0 h1: H.heap u#a) : Lemma (requires (g h0 /\ H.disjoint h0 h1)) (ensures (g h0 /\ H.disjoint h0 h1 /\ g (H.join h0 h1))) = assert (mem_of_heap (H.join h0 h1) == mem_of_heap h0 `join` mem_of_heap h1); interp_depends_only_on sl in let phi1 (h0 h1: H.heap u#a) : Lemma (ensures ((g h0 /\ H.disjoint h0 h1) ==> g (H.join h0 h1))) = Classical.move_requires (phi0 h0) h1 in Classical.forall_intro_2 phi1; g let refine_slprop sl f = H.as_slprop (a_mem_prop_as_a_heap_prop sl f) let interp_refine_slprop sl f m = assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_mem m)) let dep_hprop (s: slprop) (f: (hmem s -> Tot slprop)) (h: H.heap) : Tot prop = exists (h1: H.heap) . exists (h2: H.heap) . interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 let dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq' : squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h')) = let p2 (h h1 h2: H.heap) : Tot prop = interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 in let p1 (h h1: H.heap) : Tot prop = (exists h2 . p2 h h1 h2) in let h1 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p1 h) in let h2 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p2 h h1) in H.disjoint_join h' h1 h2; assert (H.disjoint h2 h'); let h2' = H.join h2 h' in H.join_commutative h2 h' ; assert (h2' == H.join h' h2); assert (H.disjoint h1 h2'); assert (mem_of_heap h2' == mem_of_heap h2 `join` mem_of_heap h'); interp_depends_only_on (f (mem_of_heap h1)); assert (interp (f (mem_of_heap h1)) (mem_of_heap h2')); H.join_commutative h1 h2; H.join_associative h' h2 h1; H.join_commutative h' h; H.join_commutative h2' h1; assert (H.join h h' == h1 `H.join` h2') let impl_intro_gen (#p: Type0) (#q: Type0) ($prf: (squash p -> Lemma (q ))) : Lemma (p ==> q) = Classical.impl_intro_gen #p #(fun _ -> q) prf let dep_hprop_is_affine1 (s: slprop) (f: (hmem s -> Tot slprop)) (h0 h1: H.heap) : Lemma ((dep_hprop s f h0 /\ H.disjoint h0 h1) ==> (H.disjoint h0 h1 /\ dep_hprop s f (H.join h0 h1))) = impl_intro_gen (dep_hprop_is_affine0 s f h0 h1) let dep_hprop_is_affine (s: slprop) (f: (hmem s -> Tot slprop)) : Lemma (H.heap_prop_is_affine (dep_hprop s f)) = Classical.forall_intro_2 (dep_hprop_is_affine1 s f) let sdep (s: slprop) (f: (hmem s -> Tot slprop)) : Tot slprop = dep_hprop_is_affine s f; H.as_slprop (dep_hprop s f) let interp_sdep (s: slprop) (f: (hmem s -> Tot slprop)) (m: mem) : Lemma (requires (dep_slprop_is_affine s f)) (ensures ( interp (sdep s f) m <==> (exists m1 m2 . interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) )) = dep_hprop_is_affine s f; assert (forall m1 m2 . (interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) ==> ( interp s (mem_of_heap m1.heap) /\ interp (f (mem_of_heap m1.heap)) (mem_of_heap m2.heap) /\ H.disjoint m1.heap m2.heap /\ H.join m1.heap m2.heap == m.heap )); interp_depends_only_on s; Classical.forall_intro (fun m -> interp_depends_only_on (f m)); assert (forall h1 h2 . (interp s (mem_of_heap h1) /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ H.disjoint h1 h2 /\ H.join h1 h2 == m.heap) ==> ( core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ interp s (core_mem (mem_of_heap h1)) /\ interp s (mem_set_heap m h1) /\ core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ f (mem_set_heap m h1) `equiv` f (mem_of_heap h1) /\ interp (f (mem_set_heap m h1)) (mem_of_heap h2) /\ interp (f (mem_set_heap m h1)) (mem_set_heap m h2) /\ disjoint (mem_set_heap m h1) (mem_set_heap m h2) /\ join (mem_set_heap m h1) (mem_set_heap m h2) == m )); () let h_exists_cong (#a:Type) (p q : a -> slprop) : Lemma (requires (forall x. p x `equiv` q x)) (ensures (h_exists p `equiv` h_exists q)) = equiv_heap_iff_equiv_forall (); H.h_exists_cong p q let intro_h_exists #a x p m = H.intro_h_exists x p (heap_of_mem m) let elim_h_exists (#a:_) (p:a -> slprop) (m:mem) = H.elim_h_exists p (heap_of_mem m) let intro_h_forall (#a:_) (p:a -> slprop) (m:mem) = H.intro_h_forall p (heap_of_mem m) let elim_h_forall (#a:_) (p:a -> slprop) (m:mem) (x:a) = H.elim_h_forall p (heap_of_mem m) x let intro_h_and (p q: slprop) (m:mem) = H.intro_h_and p q (heap_of_mem m) let elim_h_and (p q: slprop) (m:mem) = H.elim_h_and p q (heap_of_mem m) let intro_h_or_left (p q: slprop) (m:mem) = H.intro_h_or_left p q (heap_of_mem m) let intro_h_or_right (p q: slprop) (m:mem) = H.intro_h_or_right p q (heap_of_mem m) let elim_h_or (p q: slprop) (m:mem) = H.elim_h_or p q (heap_of_mem m) let intro_wand (p1 p2: slprop u#a) (m:mem) = introduce (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)) ==> interp (wand p1 p2) m with _. ( assert (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)); H.intro_wand p1 p2 (heap_of_mem m); let h = heap_of_mem m in assert ((forall h1. h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) ==> H.interp (wand p1 p2) h); introduce forall h1. (h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) with ( introduce (h `H.disjoint` h1 /\ H.interp p1 h1) ==> H.interp p2 (H.join h h1) with _. ( assert (h `H.disjoint` h1); let m1 = { ctr = m.ctr; heap = h1; locks = m.locks } in assert (m `disjoint` m1) ) ) ) (** Eliminating a wand by proving a heap that satisfies the LHS **) let elim_wand (p1 p2: slprop u#a) (m:mem) (m1:mem) = H.elim_wand p1 p2 (heap_of_mem m) (heap_of_mem m1) //////////////////////////////////////////////////////////////////////////////// // Preorders and effects //////////////////////////////////////////////////////////////////////////////// module PP = Steel.Preorder let mem_evolves = fun (m0 m1:full_mem) -> H.heap_evolves (heap_of_mem m0) (heap_of_mem m1) /\ m0.ctr <= m1.ctr /\ lock_store_evolves m0.locks m1.locks (** See [Steel.Heap.is_frame_preserving]. We add in [lock_invariants] now *) let preserves_frame (e:inames) (pre post:slprop) (m0 m1:mem) = forall (frame:slprop). interp ((pre `star` frame) `star` locks_invariant e m0) m0 ==> (interp ((post `star` frame) `star` locks_invariant e m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) (** This is a version of MstTot with frame quantified, as part of preserves_frame *) effect MstTotNF (a:Type u#a) (except:inames) (expects:slprop u#1) (provides: a -> slprop u#1) = NMSTTotal.NMSTATETOT a (full_mem u#1) mem_evolves (requires fun m0 -> inames_ok except m0 /\ interp (expects `star` locks_invariant except m0) m0) (ensures fun m0 x m1 -> inames_ok except m1 /\ interp (provides x `star` locks_invariant except m1) m1 /\ preserves_frame except expects (provides x) m0 m1) //////////////////////////////////////////////////////////////////////////////// // Lifting heap actions //////////////////////////////////////////////////////////////////////////////// (** Heap actions come in two equivalent flavors: - one that take an explicit frame as argument (action_with_frame) - and one that quantify over all the frame We therefore define two lift routes: - a direct route for those with explicit frame - via MstTotNF for the rest *) let tot_pre_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = hmem_with_inv_except e fp -> (x:a & hmem_with_inv_except e (fp' x)) let tot_pre_action_nf = tot_pre_action_nf_except S.empty let ac_reasoning_for_m_frame_preserving (p q r:slprop u#a) (m:mem u#a) : Lemma (requires interp ((p `star` q) `star` r) m) (ensures interp (p `star` r) m) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_commutative p q; equiv_extensional_on_star (p `star` q) (q `star` p) r } (q `star` p) `star` r; (equiv) { star_associative q p r } q `star` (p `star` r); }; assert (interp (q `star` (p `star` r)) m); affine_star q (p `star` r) m let is_frame_preserving (#e:inames) (#a:Type u#b) (#fp:slprop u#a) (#fp':a -> slprop u#a) (f:tot_pre_action_nf_except e fp a fp') = forall (frame:slprop u#a) (m0:hmem_with_inv_except e (fp `star` frame)). (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = f:tot_pre_action_nf_except e fp a fp'{ is_frame_preserving f } let tot_action_nf = tot_action_nf_except S.empty let linv e (m:mem) = locks_invariant e m let hheap_of_hmem #fp #e (m:hmem_with_inv_except e fp) : h:H.hheap (fp `star` linv e m) { h `H.free_above_addr` m.ctr} = let h = heap_of_mem m in H.pure_interp (heap_ctr_valid m.ctr (heap_of_mem m)) h; h let hmem_of_hheap #e (#fp0 #fp1:slprop) (m:hmem_with_inv_except e fp0) (h:H.full_hheap (fp1 `star` linv e m) { h `Heap.free_above_addr` m.ctr }) : m1:hmem_with_inv_except e fp1{linv e m `equiv` linv e m1} = let m1 : mem = { m with heap = h } in assert (interp (fp1 `star` linv e m) m1); star_commutative fp1 (linv e m); assert (interp (linv e m `star` fp1) m1); assert (linv e m1 == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); assert (linv e m == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m)); H.pure_interp (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_of_mem m); assert (heap_ctr_valid m1.ctr (heap_of_mem m) <==> heap_ctr_valid m1.ctr (heap_of_mem m1)); H.pure_equiv (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_ctr_valid m1.ctr (heap_of_mem m1)); H.star_congruence (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m)); assert (linv e m `equiv` linv e m1); let _ = equiv_extensional_on_star (linv e m) (linv e m1) fp1 in assert ((linv e m `star` fp1) `equiv` (linv e m1 `star` fp1)); assert (interp (linv e m1 `star` fp1) m1); star_commutative (linv e m1) fp1; assert (interp (fp1 `star` linv e m1) m1); m1 let with_inv_except (m:mem) e (fp:slprop) = interp (fp `star` locks_invariant e m) m #push-options "--warn_error -271" let as_hprop (frame:slprop) (mp:mprop frame) : hp:H.hprop frame{forall m. mp (core_mem m) == hp (heap_of_mem m)} = let f = fun h -> mp (mem_of_heap h) in assert (forall m. mp (core_mem m) == f (heap_of_mem m)); let aux (m0:H.hheap frame) (m1:H.heap{H.disjoint m0 m1}) : Lemma (ensures (mem_of_heap (H.join m0 m1) == join (mem_of_heap m0) (mem_of_heap m1))) [SMTPat ()] = () in f let mprop_preservation_of_hprop_preservation (p:slprop) (m0 m1:mem) : Lemma (requires (forall (hp:H.hprop p). hp (heap_of_mem m0) == hp (heap_of_mem m1))) (ensures (forall (mp:mprop p). mp (core_mem m0) == mp (core_mem m1))) = let aux (mp:mprop p) : Lemma (mp (core_mem m0) == mp (core_mem m1)) [SMTPat()] = assert (as_hprop p mp (heap_of_mem m0) == as_hprop p mp (heap_of_mem m1)) in () let lift_heap_action (#fp:slprop) (#a:Type) (#fp':a -> slprop) (e:inames) ($f:H.action fp a fp') : tot_action_nf_except e fp a fp' = let g : tot_pre_action_nf_except e fp a fp' = fun m -> let h0 = hheap_of_hmem m in let (| x, h' |) = f h0 in (| x, hmem_of_hheap m h' |) in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in let h0 = hheap_of_hmem m0 in let (| x', h1 |) = f h0 in H.action_framing f (linv e m0) h0; assert (x == x'); star_associative fp frame (linv e m0); H.action_framing f (frame `star` linv e m0) h0; assert (H.interp ((fp' x) `star` (frame `star` linv e m0)) h1); star_associative (fp' x) frame (linv e m0); assert (H.interp ((fp' x `star` frame) `star` linv e m0) h1); let h1' : H.hheap ((fp' x `star` frame) `star` linv e m0) = h1 in assert (m1 == hmem_of_hheap m0 h1'); assert (with_inv_except m1 e (fp' x `star` frame)); assert (forall (hp:H.hprop frame). hp h0 == hp h1); mprop_preservation_of_hprop_preservation frame m0 m1; () in assert (is_frame_preserving g); g let frame_preserving_respects_preorder #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (m0:hmem_with_inv_except e fp) : Lemma (let (| x, m1 |) = f m0 in mem_evolves m0 m1) = let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1) = () in H.emp_unit fp; assert (interp (fp `star` linv e m0) m0); H.star_congruence (fp `star` emp) (linv e m0) fp (linv e m0); assert (interp ((fp `star` emp) `star` linv e m0) m0); aux emp m0 let lift_tot_action_nf #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') : MstTotNF a e fp fp' = let m0 = NMSTTotal.get () in let m0' : hmem_with_inv_except e fp = m0 in let r = f m0' in let (| x, m1 |) = r in let m1' : hmem_with_inv_except e (fp' x) = m1 in assert (is_frame_preserving f); assert (m1 == dsnd (f m0)); frame_preserving_respects_preorder f m0; NMSTTotal.put #_ #(mem_evolves) m1; x let lift_tot_action #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get #(full_mem) #_ () in ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); lift_tot_action_nf f (** Now defining the lift for heap actions with explicit frame *) let tot_action_with_frame_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = frame:slprop u#a -> m0:hmem_with_inv_except e (fp `star` frame) -> Pure (x:a & hmem_with_inv_except e (fp' x `star` frame)) (requires True) (ensures fun (| x, m1 |) -> mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_with_frame = tot_action_with_frame_except S.empty let lift_heap_action_with_frame (#fp:slprop u#a) (#a:Type u#b) (#fp':a -> slprop u#a) (e:inames) ($f:H.action_with_frame fp a fp') : tot_action_with_frame_except e fp a fp' = fun frame m0 -> let h0 = hheap_of_hmem m0 in calc (equiv) { fp `star` frame `star` locks_invariant e m0; (equiv) { star_associative fp frame (locks_invariant e m0) } fp `star` (frame `star` locks_invariant e m0); }; assert (H.interp (fp `star` frame `star` locks_invariant e m0) h0); assert (H.interp (fp `star` (frame `star` locks_invariant e m0)) h0); //key: apply the heap action with frame * locks_invariant e m0 let (| x, h1 |) = f (frame `star` locks_invariant e m0) h0 in calc (equiv) { fp' x `star` (frame `star` locks_invariant e m0); (equiv) { star_associative (fp' x) frame (locks_invariant e m0) } fp' x `star` frame `star` locks_invariant e m0; }; assert (H.interp (fp' x `star` (frame `star` locks_invariant e m0)) h1); assert (H.interp (fp' x `star` frame `star` locks_invariant e m0) h1); let m1 = hmem_of_hheap m0 h1 in assert (mem_evolves m0 m1); mprop_preservation_of_hprop_preservation (frame `star` locks_invariant e m0) m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)); (| x, m1 |) let lift_tot_action_with_frame #a #e #fp #fp' ($f:tot_action_with_frame_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in assert (inames_ok e m0); ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); let m0' : hmem_with_inv_except e fp = m0 in let r = f frame m0' in let (| x, m1 |) = r in ac_reasoning_for_m_frame_preserving (fp' x) frame (locks_invariant e m1) m1; assert (interp (fp' x `star` frame `star` locks_invariant e m1) m1); assert (interp (fp' x `star` locks_invariant e m1) m1); let m1' : hmem_with_inv_except e (fp' x) = m1 in NMSTTotal.put #_ #(mem_evolves) m1; x let sel_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.sel_action #a #pcm r v0)) let upd_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.upd_action #a #pcm r v0 v1)) let free_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.free_action #a #pcm r v0)) let split_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.split_action #a #pcm r v0 v1))

{ "checked_file": "/", "dependencies": [ "Steel.Preorder.fst.checked", "Steel.Heap.fsti.checked", "prims.fst.checked", "FStar.Witnessed.Core.fsti.checked", "FStar.Set.fsti.checked", "FStar.Preorder.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.PCM.fst.checked", "FStar.NMSTTotal.fst.checked", "FStar.List.Tot.fst.checked", "FStar.IndefiniteDescription.fsti.checked", "FStar.Ghost.fsti.checked", "FStar.FunctionalExtensionality.fsti.checked", "FStar.Classical.Sugar.fsti.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Steel.Memory.fst" }

[ { "abbrev": true, "full_module": "Steel.Preorder", "short_module": "PP" }, { "abbrev": true, "full_module": "FStar.Witnessed.Core", "short_module": "W" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": true, "full_module": "Steel.Heap", "short_module": "H" }, { "abbrev": false, "full_module": "FStar.FunctionalExtensionality", "short_module": null }, { "abbrev": true, "full_module": "FStar.FunctionalExtensionality", "short_module": "F" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": false, "full_module": "FStar.PCM", "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

e: Steel.Memory.inames -> r: Steel.Memory.ref a pcm -> v0: FStar.Ghost.erased a -> v1: FStar.Ghost.erased a -> Steel.Memory.action_except (_: Prims.unit{FStar.PCM.composable pcm (FStar.Ghost.reveal v0) (FStar.Ghost.reveal v1)}) e (Steel.Memory.star (Steel.Memory.pts_to r (FStar.Ghost.reveal v0)) (Steel.Memory.pts_to r (FStar.Ghost.reveal v1))) (fun _ -> Steel.Memory.pts_to r (FStar.PCM.op pcm (FStar.Ghost.reveal v0) (FStar.Ghost.reveal v1)))

Prims.Tot

[ "total" ]

[]

[ "FStar.PCM.pcm", "Steel.Memory.inames", "Steel.Memory.ref", "FStar.Ghost.erased", "Steel.Memory.lift_tot_action", "Prims.unit", "FStar.PCM.composable", "FStar.Ghost.reveal", "Steel.Heap.star", "Steel.Heap.pts_to", "FStar.PCM.op", "Steel.Memory.slprop", "Steel.Memory.lift_heap_action", "Steel.Heap.gather_action", "Steel.Memory.action_except", "Steel.Memory.star", "Steel.Memory.pts_to" ]

[]

false

let gather_action #a #pcm e r v0 v1 =

lift_tot_action (lift_heap_action e (H.gather_action #a #pcm r v0 v1))

false

Steel.Memory.fst

Steel.Memory.pure_true_equiv

val pure_true_equiv (p: slprop) : Lemma ((p `star` (pure True)) `equiv` p)

let pure_true_equiv (p:slprop) : Lemma ((p `star` pure True) `equiv` p) = FStar.Classical.forall_intro (pure_star_interp p True); emp_unit p; assert ((p `star` pure True) `equiv` p)

{ "file_name": "lib/steel/Steel.Memory.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 43, "end_line": 1062, "start_col": 0, "start_line": 1058 }

(* 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.Memory module F = FStar.FunctionalExtensionality open FStar.FunctionalExtensionality open FStar.PCM module H = Steel.Heap noeq type lock_state : Type u#(a + 1) = | Invariant : inv:H.slprop u#a -> lock_state let lock_store : Type u#(a+1) = list (lock_state u#a) noeq type mem : Type u#(a + 1) = { ctr: nat; heap: H.heap u#a; locks: lock_store u#a; } let heap_of_mem (x:mem) : H.heap = x.heap let mem_of_heap (h:H.heap) : mem = { ctr = 0; heap = h; locks = [] } let mem_set_heap (m:mem) (h:H.heap) : mem = { ctr = m.ctr; heap = h; locks = m.locks; } let core_mem (m:mem) : mem = mem_of_heap (heap_of_mem m) let core_mem_invol m = () let disjoint (m0 m1:mem u#h) : prop = m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks let disjoint_sym m0 m1 = () let join m0 m1 = { ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = m0.locks } let join_commutative m0 m1 = H.join_commutative m0.heap m1.heap let disjoint_join m0 m1 m2 = H.disjoint_join m0.heap m1.heap m2.heap let join_associative m0 m1 m2 = H.join_associative m0.heap m1.heap m2.heap let slprop = H.slprop let interp p m = H.interp p m.heap let equiv p1 p2 = forall m. interp p1 m <==> interp p2 m let slprop_extensionality p q = assert (forall m. interp p m <==> interp q m); let aux (h:H.heap) : Lemma (H.interp p h <==> H.interp q h) [SMTPat (H.interp p h)] = let m : mem = { ctr = 0; heap = h; locks = [] } in assert (interp p m <==> interp q m) in assert (forall h. H.interp p h <==> H.interp q h); Steel.Heap.slprop_extensionality p q let reveal_equiv p1 p2 = () let core_ref = H.core_ref let core_ref_null = H.core_ref_null let core_ref_is_null r = H.core_ref_is_null r let emp : slprop u#a = H.emp let pure = H.pure let pts_to = H.pts_to let h_and = H.h_and let h_or = H.h_or let star = H.star let wand = H.wand let h_exists = H.h_exists let h_forall = H.h_forall //////////////////////////////////////////////////////////////////////////////// //properties of equiv //////////////////////////////////////////////////////////////////////////////// let equiv_symmetric (p1 p2:slprop u#a) = H.equiv_symmetric p1 p2 #push-options "--warn_error -271" let equiv_heap_iff_equiv (p1 p2:slprop u#a) : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat (equiv p1 p2)] = let aux_lr () : Lemma (requires H.equiv p1 p2) (ensures equiv p1 p2) [SMTPat ()] = () in let aux_rl_helper1 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p1 h) (ensures H.interp p2 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl_helper2 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p2 h) (ensures H.interp p1 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl () : Lemma (requires equiv p1 p2) (ensures H.equiv p1 p2) [SMTPat ()] = () in () let equiv_heap_iff_equiv_forall () : Lemma (ensures (forall p1 p2. H.equiv p1 p2 <==> equiv p1 p2)) = let aux p1 p2 : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat ()] = equiv_heap_iff_equiv p1 p2 in () #pop-options let equiv_extensional_on_star (p1 p2 p3:slprop u#a) = equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3 let emp_unit p = H.emp_unit p let intro_emp m = H.intro_emp (heap_of_mem m) let pure_equiv p q = H.pure_equiv p q let pure_interp q m = H.pure_interp q (heap_of_mem m) let pure_star_interp p q m = H.pure_star_interp p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// //pts_to //////////////////////////////////////////////////////////////////////////////// let pts_to_compatible #a #pcm x v0 v1 m = H.pts_to_compatible #a #pcm x v0 v1 (heap_of_mem m) let pts_to_compatible_equiv #a #pcm x v0 v1 = H.pts_to_compatible_equiv #a #pcm x v0 v1 let pts_to_not_null #a #pcm x v m = H.pts_to_not_null #a #pcm x v (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // star //////////////////////////////////////////////////////////////////////////////// let intro_star p q mp mq = H.intro_star p q (heap_of_mem mp) (heap_of_mem mq) let elim_star p q m = let h = heap_of_mem m in H.elim_star p q h; assert (exists hl hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr); let hl = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hl -> exists hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let hr = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hr -> H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let ml = mem_set_heap m hl in let mr = mem_set_heap m hr in assert (disjoint ml mr); assert (m == join ml mr); assert (interp p ml); assert (interp q mr); () let interp_star (p q: slprop) (m: mem) : Lemma (interp (p `star` q) m <==> (exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m)) = let left = interp (p `star` q) m in let right = exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m in let f () : Lemma (requires left) (ensures right) = elim_star p q m in let g () : Lemma (requires right) (ensures left) = Classical.exists_elim left #_ #(fun mp -> exists (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mp -> Classical.exists_elim left #_ #(fun mq -> disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mq -> intro_star p q mp mq ) ) in Classical.move_requires f (); Classical.move_requires g () let star_commutative (p1 p2:slprop) = H.star_commutative p1 p2 let star_associative (p1 p2 p3:slprop) = H.star_associative p1 p2 p3 let star_congruence (p1 p2 p3 p4:slprop) = equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4 let affine_star (p q:slprop) (m:mem) = H.affine_star p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // Invariants on the lock store //////////////////////////////////////////////////////////////////////////////// let iname = nat module S = FStar.Set module L = FStar.List.Tot module W = FStar.Witnessed.Core let rec lock_store_invariant (e:inames) (l:lock_store u#a) : slprop u#a = let current_addr = L.length l - 1 in match l with | [] -> emp | Invariant p :: tl -> if current_addr `S.mem` e then lock_store_invariant e tl else p `star` lock_store_invariant e tl let lock_i (i:iname) (l:lock_store { i < L.length l }) = let ix = L.length l - i - 1 in L.index l ix let iname_for_p (i:iname) (p:slprop) : W.s_predicate lock_store = fun l -> i < L.length l /\ (lock_i i l).inv == p let lock_store_evolves : FStar.Preorder.preorder lock_store = fun (l1 l2 : lock_store) -> L.length l2 >= L.length l1 /\ (forall (i:nat{i < L.length l1}). (lock_i i l1).inv == (lock_i i l2).inv) let inames_in (e:inames) (l:lock_store) : prop = forall i. Set.mem i e ==> i < L.length l let inames_ok e m = inames_in e m.locks let inames_ok_empty m = () let extend_lock_store (e:inames) (l:lock_store{e `inames_in` l}) (p:slprop) : i:iname & l':lock_store { lock_store_invariant e l' == p `star` lock_store_invariant e l /\ iname_for_p i p l' } = (| L.length l, Invariant p :: l |) let set_add (i:iname) (s:inames) = Set.union (Set.singleton i) s let rec move_invariant (e:inames) (l:lock_store) (p:slprop) (i:iname{iname_for_p i p l /\ ~(i `Set.mem` e)}) : Lemma (H.equiv (lock_store_invariant e l) (p `star` lock_store_invariant (set_add i e) l)) = let rec aux (i:iname) (m:lock_store) : Lemma (requires i >= L.length m) (ensures (lock_store_invariant e m `H.equiv` lock_store_invariant (set_add i e) m)) = match m with | [] -> () | Invariant p::tl -> aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl) in let current_addr = L.length l - 1 in match l with | [] -> () | Invariant q::tl -> if i = current_addr then begin assert (lock_store_invariant e l == p `star` lock_store_invariant e tl); aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl); () end else begin move_invariant e tl p i; assert (lock_store_invariant e tl `equiv` (p `star` lock_store_invariant (set_add i e) tl)); H.star_congruence q (lock_store_invariant e tl) q (p `star` lock_store_invariant (set_add i e) tl); if Set.mem current_addr e then () else begin let r = lock_store_invariant (set_add i e) tl in assert (lock_store_invariant e l `equiv` (q `star` (p `star` r))); H.star_associative q p r; H.star_commutative q p; H.star_congruence (q `star` p) r (p `star` q) r; H.star_associative p q r end end let heap_ctr_valid (ctr:nat) (h:H.heap u#a) : prop = h `H.free_above_addr` ctr let ctr_validity (ctr:nat) (h:H.heap) : slprop = H.pure (heap_ctr_valid ctr h) let locks_invariant (e:inames) (m:mem u#a) : slprop u#a = lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m) let full_mem_pred (m:mem) = H.full_heap_pred (heap_of_mem m) (***** Following lemmas are needed in Steel.Effect *****) let core_mem_interp (hp:slprop u#a) (m:mem u#a) = () let interp_depends_only_on (hp:slprop u#a) = H.interp_depends_only_on hp let a_mem_prop_as_a_heap_prop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (H.a_heap_prop u#a) = let g (h: H.heap u#a) : Tot prop = interp sl (mem_of_heap h) /\ f (mem_of_heap h) in let phi0 (h0 h1: H.heap u#a) : Lemma (requires (g h0 /\ H.disjoint h0 h1)) (ensures (g h0 /\ H.disjoint h0 h1 /\ g (H.join h0 h1))) = assert (mem_of_heap (H.join h0 h1) == mem_of_heap h0 `join` mem_of_heap h1); interp_depends_only_on sl in let phi1 (h0 h1: H.heap u#a) : Lemma (ensures ((g h0 /\ H.disjoint h0 h1) ==> g (H.join h0 h1))) = Classical.move_requires (phi0 h0) h1 in Classical.forall_intro_2 phi1; g let refine_slprop sl f = H.as_slprop (a_mem_prop_as_a_heap_prop sl f) let interp_refine_slprop sl f m = assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_mem m)) let dep_hprop (s: slprop) (f: (hmem s -> Tot slprop)) (h: H.heap) : Tot prop = exists (h1: H.heap) . exists (h2: H.heap) . interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 let dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq' : squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h')) = let p2 (h h1 h2: H.heap) : Tot prop = interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 in let p1 (h h1: H.heap) : Tot prop = (exists h2 . p2 h h1 h2) in let h1 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p1 h) in let h2 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p2 h h1) in H.disjoint_join h' h1 h2; assert (H.disjoint h2 h'); let h2' = H.join h2 h' in H.join_commutative h2 h' ; assert (h2' == H.join h' h2); assert (H.disjoint h1 h2'); assert (mem_of_heap h2' == mem_of_heap h2 `join` mem_of_heap h'); interp_depends_only_on (f (mem_of_heap h1)); assert (interp (f (mem_of_heap h1)) (mem_of_heap h2')); H.join_commutative h1 h2; H.join_associative h' h2 h1; H.join_commutative h' h; H.join_commutative h2' h1; assert (H.join h h' == h1 `H.join` h2') let impl_intro_gen (#p: Type0) (#q: Type0) ($prf: (squash p -> Lemma (q ))) : Lemma (p ==> q) = Classical.impl_intro_gen #p #(fun _ -> q) prf let dep_hprop_is_affine1 (s: slprop) (f: (hmem s -> Tot slprop)) (h0 h1: H.heap) : Lemma ((dep_hprop s f h0 /\ H.disjoint h0 h1) ==> (H.disjoint h0 h1 /\ dep_hprop s f (H.join h0 h1))) = impl_intro_gen (dep_hprop_is_affine0 s f h0 h1) let dep_hprop_is_affine (s: slprop) (f: (hmem s -> Tot slprop)) : Lemma (H.heap_prop_is_affine (dep_hprop s f)) = Classical.forall_intro_2 (dep_hprop_is_affine1 s f) let sdep (s: slprop) (f: (hmem s -> Tot slprop)) : Tot slprop = dep_hprop_is_affine s f; H.as_slprop (dep_hprop s f) let interp_sdep (s: slprop) (f: (hmem s -> Tot slprop)) (m: mem) : Lemma (requires (dep_slprop_is_affine s f)) (ensures ( interp (sdep s f) m <==> (exists m1 m2 . interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) )) = dep_hprop_is_affine s f; assert (forall m1 m2 . (interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) ==> ( interp s (mem_of_heap m1.heap) /\ interp (f (mem_of_heap m1.heap)) (mem_of_heap m2.heap) /\ H.disjoint m1.heap m2.heap /\ H.join m1.heap m2.heap == m.heap )); interp_depends_only_on s; Classical.forall_intro (fun m -> interp_depends_only_on (f m)); assert (forall h1 h2 . (interp s (mem_of_heap h1) /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ H.disjoint h1 h2 /\ H.join h1 h2 == m.heap) ==> ( core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ interp s (core_mem (mem_of_heap h1)) /\ interp s (mem_set_heap m h1) /\ core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ f (mem_set_heap m h1) `equiv` f (mem_of_heap h1) /\ interp (f (mem_set_heap m h1)) (mem_of_heap h2) /\ interp (f (mem_set_heap m h1)) (mem_set_heap m h2) /\ disjoint (mem_set_heap m h1) (mem_set_heap m h2) /\ join (mem_set_heap m h1) (mem_set_heap m h2) == m )); () let h_exists_cong (#a:Type) (p q : a -> slprop) : Lemma (requires (forall x. p x `equiv` q x)) (ensures (h_exists p `equiv` h_exists q)) = equiv_heap_iff_equiv_forall (); H.h_exists_cong p q let intro_h_exists #a x p m = H.intro_h_exists x p (heap_of_mem m) let elim_h_exists (#a:_) (p:a -> slprop) (m:mem) = H.elim_h_exists p (heap_of_mem m) let intro_h_forall (#a:_) (p:a -> slprop) (m:mem) = H.intro_h_forall p (heap_of_mem m) let elim_h_forall (#a:_) (p:a -> slprop) (m:mem) (x:a) = H.elim_h_forall p (heap_of_mem m) x let intro_h_and (p q: slprop) (m:mem) = H.intro_h_and p q (heap_of_mem m) let elim_h_and (p q: slprop) (m:mem) = H.elim_h_and p q (heap_of_mem m) let intro_h_or_left (p q: slprop) (m:mem) = H.intro_h_or_left p q (heap_of_mem m) let intro_h_or_right (p q: slprop) (m:mem) = H.intro_h_or_right p q (heap_of_mem m) let elim_h_or (p q: slprop) (m:mem) = H.elim_h_or p q (heap_of_mem m) let intro_wand (p1 p2: slprop u#a) (m:mem) = introduce (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)) ==> interp (wand p1 p2) m with _. ( assert (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)); H.intro_wand p1 p2 (heap_of_mem m); let h = heap_of_mem m in assert ((forall h1. h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) ==> H.interp (wand p1 p2) h); introduce forall h1. (h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) with ( introduce (h `H.disjoint` h1 /\ H.interp p1 h1) ==> H.interp p2 (H.join h h1) with _. ( assert (h `H.disjoint` h1); let m1 = { ctr = m.ctr; heap = h1; locks = m.locks } in assert (m `disjoint` m1) ) ) ) (** Eliminating a wand by proving a heap that satisfies the LHS **) let elim_wand (p1 p2: slprop u#a) (m:mem) (m1:mem) = H.elim_wand p1 p2 (heap_of_mem m) (heap_of_mem m1) //////////////////////////////////////////////////////////////////////////////// // Preorders and effects //////////////////////////////////////////////////////////////////////////////// module PP = Steel.Preorder let mem_evolves = fun (m0 m1:full_mem) -> H.heap_evolves (heap_of_mem m0) (heap_of_mem m1) /\ m0.ctr <= m1.ctr /\ lock_store_evolves m0.locks m1.locks (** See [Steel.Heap.is_frame_preserving]. We add in [lock_invariants] now *) let preserves_frame (e:inames) (pre post:slprop) (m0 m1:mem) = forall (frame:slprop). interp ((pre `star` frame) `star` locks_invariant e m0) m0 ==> (interp ((post `star` frame) `star` locks_invariant e m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) (** This is a version of MstTot with frame quantified, as part of preserves_frame *) effect MstTotNF (a:Type u#a) (except:inames) (expects:slprop u#1) (provides: a -> slprop u#1) = NMSTTotal.NMSTATETOT a (full_mem u#1) mem_evolves (requires fun m0 -> inames_ok except m0 /\ interp (expects `star` locks_invariant except m0) m0) (ensures fun m0 x m1 -> inames_ok except m1 /\ interp (provides x `star` locks_invariant except m1) m1 /\ preserves_frame except expects (provides x) m0 m1) //////////////////////////////////////////////////////////////////////////////// // Lifting heap actions //////////////////////////////////////////////////////////////////////////////// (** Heap actions come in two equivalent flavors: - one that take an explicit frame as argument (action_with_frame) - and one that quantify over all the frame We therefore define two lift routes: - a direct route for those with explicit frame - via MstTotNF for the rest *) let tot_pre_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = hmem_with_inv_except e fp -> (x:a & hmem_with_inv_except e (fp' x)) let tot_pre_action_nf = tot_pre_action_nf_except S.empty let ac_reasoning_for_m_frame_preserving (p q r:slprop u#a) (m:mem u#a) : Lemma (requires interp ((p `star` q) `star` r) m) (ensures interp (p `star` r) m) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_commutative p q; equiv_extensional_on_star (p `star` q) (q `star` p) r } (q `star` p) `star` r; (equiv) { star_associative q p r } q `star` (p `star` r); }; assert (interp (q `star` (p `star` r)) m); affine_star q (p `star` r) m let is_frame_preserving (#e:inames) (#a:Type u#b) (#fp:slprop u#a) (#fp':a -> slprop u#a) (f:tot_pre_action_nf_except e fp a fp') = forall (frame:slprop u#a) (m0:hmem_with_inv_except e (fp `star` frame)). (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = f:tot_pre_action_nf_except e fp a fp'{ is_frame_preserving f } let tot_action_nf = tot_action_nf_except S.empty let linv e (m:mem) = locks_invariant e m let hheap_of_hmem #fp #e (m:hmem_with_inv_except e fp) : h:H.hheap (fp `star` linv e m) { h `H.free_above_addr` m.ctr} = let h = heap_of_mem m in H.pure_interp (heap_ctr_valid m.ctr (heap_of_mem m)) h; h let hmem_of_hheap #e (#fp0 #fp1:slprop) (m:hmem_with_inv_except e fp0) (h:H.full_hheap (fp1 `star` linv e m) { h `Heap.free_above_addr` m.ctr }) : m1:hmem_with_inv_except e fp1{linv e m `equiv` linv e m1} = let m1 : mem = { m with heap = h } in assert (interp (fp1 `star` linv e m) m1); star_commutative fp1 (linv e m); assert (interp (linv e m `star` fp1) m1); assert (linv e m1 == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); assert (linv e m == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m)); H.pure_interp (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_of_mem m); assert (heap_ctr_valid m1.ctr (heap_of_mem m) <==> heap_ctr_valid m1.ctr (heap_of_mem m1)); H.pure_equiv (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_ctr_valid m1.ctr (heap_of_mem m1)); H.star_congruence (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m)); assert (linv e m `equiv` linv e m1); let _ = equiv_extensional_on_star (linv e m) (linv e m1) fp1 in assert ((linv e m `star` fp1) `equiv` (linv e m1 `star` fp1)); assert (interp (linv e m1 `star` fp1) m1); star_commutative (linv e m1) fp1; assert (interp (fp1 `star` linv e m1) m1); m1 let with_inv_except (m:mem) e (fp:slprop) = interp (fp `star` locks_invariant e m) m #push-options "--warn_error -271" let as_hprop (frame:slprop) (mp:mprop frame) : hp:H.hprop frame{forall m. mp (core_mem m) == hp (heap_of_mem m)} = let f = fun h -> mp (mem_of_heap h) in assert (forall m. mp (core_mem m) == f (heap_of_mem m)); let aux (m0:H.hheap frame) (m1:H.heap{H.disjoint m0 m1}) : Lemma (ensures (mem_of_heap (H.join m0 m1) == join (mem_of_heap m0) (mem_of_heap m1))) [SMTPat ()] = () in f let mprop_preservation_of_hprop_preservation (p:slprop) (m0 m1:mem) : Lemma (requires (forall (hp:H.hprop p). hp (heap_of_mem m0) == hp (heap_of_mem m1))) (ensures (forall (mp:mprop p). mp (core_mem m0) == mp (core_mem m1))) = let aux (mp:mprop p) : Lemma (mp (core_mem m0) == mp (core_mem m1)) [SMTPat()] = assert (as_hprop p mp (heap_of_mem m0) == as_hprop p mp (heap_of_mem m1)) in () let lift_heap_action (#fp:slprop) (#a:Type) (#fp':a -> slprop) (e:inames) ($f:H.action fp a fp') : tot_action_nf_except e fp a fp' = let g : tot_pre_action_nf_except e fp a fp' = fun m -> let h0 = hheap_of_hmem m in let (| x, h' |) = f h0 in (| x, hmem_of_hheap m h' |) in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in let h0 = hheap_of_hmem m0 in let (| x', h1 |) = f h0 in H.action_framing f (linv e m0) h0; assert (x == x'); star_associative fp frame (linv e m0); H.action_framing f (frame `star` linv e m0) h0; assert (H.interp ((fp' x) `star` (frame `star` linv e m0)) h1); star_associative (fp' x) frame (linv e m0); assert (H.interp ((fp' x `star` frame) `star` linv e m0) h1); let h1' : H.hheap ((fp' x `star` frame) `star` linv e m0) = h1 in assert (m1 == hmem_of_hheap m0 h1'); assert (with_inv_except m1 e (fp' x `star` frame)); assert (forall (hp:H.hprop frame). hp h0 == hp h1); mprop_preservation_of_hprop_preservation frame m0 m1; () in assert (is_frame_preserving g); g let frame_preserving_respects_preorder #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (m0:hmem_with_inv_except e fp) : Lemma (let (| x, m1 |) = f m0 in mem_evolves m0 m1) = let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1) = () in H.emp_unit fp; assert (interp (fp `star` linv e m0) m0); H.star_congruence (fp `star` emp) (linv e m0) fp (linv e m0); assert (interp ((fp `star` emp) `star` linv e m0) m0); aux emp m0 let lift_tot_action_nf #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') : MstTotNF a e fp fp' = let m0 = NMSTTotal.get () in let m0' : hmem_with_inv_except e fp = m0 in let r = f m0' in let (| x, m1 |) = r in let m1' : hmem_with_inv_except e (fp' x) = m1 in assert (is_frame_preserving f); assert (m1 == dsnd (f m0)); frame_preserving_respects_preorder f m0; NMSTTotal.put #_ #(mem_evolves) m1; x let lift_tot_action #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get #(full_mem) #_ () in ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); lift_tot_action_nf f (** Now defining the lift for heap actions with explicit frame *) let tot_action_with_frame_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = frame:slprop u#a -> m0:hmem_with_inv_except e (fp `star` frame) -> Pure (x:a & hmem_with_inv_except e (fp' x `star` frame)) (requires True) (ensures fun (| x, m1 |) -> mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_with_frame = tot_action_with_frame_except S.empty let lift_heap_action_with_frame (#fp:slprop u#a) (#a:Type u#b) (#fp':a -> slprop u#a) (e:inames) ($f:H.action_with_frame fp a fp') : tot_action_with_frame_except e fp a fp' = fun frame m0 -> let h0 = hheap_of_hmem m0 in calc (equiv) { fp `star` frame `star` locks_invariant e m0; (equiv) { star_associative fp frame (locks_invariant e m0) } fp `star` (frame `star` locks_invariant e m0); }; assert (H.interp (fp `star` frame `star` locks_invariant e m0) h0); assert (H.interp (fp `star` (frame `star` locks_invariant e m0)) h0); //key: apply the heap action with frame * locks_invariant e m0 let (| x, h1 |) = f (frame `star` locks_invariant e m0) h0 in calc (equiv) { fp' x `star` (frame `star` locks_invariant e m0); (equiv) { star_associative (fp' x) frame (locks_invariant e m0) } fp' x `star` frame `star` locks_invariant e m0; }; assert (H.interp (fp' x `star` (frame `star` locks_invariant e m0)) h1); assert (H.interp (fp' x `star` frame `star` locks_invariant e m0) h1); let m1 = hmem_of_hheap m0 h1 in assert (mem_evolves m0 m1); mprop_preservation_of_hprop_preservation (frame `star` locks_invariant e m0) m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)); (| x, m1 |) let lift_tot_action_with_frame #a #e #fp #fp' ($f:tot_action_with_frame_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in assert (inames_ok e m0); ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); let m0' : hmem_with_inv_except e fp = m0 in let r = f frame m0' in let (| x, m1 |) = r in ac_reasoning_for_m_frame_preserving (fp' x) frame (locks_invariant e m1) m1; assert (interp (fp' x `star` frame `star` locks_invariant e m1) m1); assert (interp (fp' x `star` locks_invariant e m1) m1); let m1' : hmem_with_inv_except e (fp' x) = m1 in NMSTTotal.put #_ #(mem_evolves) m1; x let sel_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.sel_action #a #pcm r v0)) let upd_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.upd_action #a #pcm r v0 v1)) let free_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.free_action #a #pcm r v0)) let split_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.split_action #a #pcm r v0 v1)) let gather_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.gather_action #a #pcm r v0 v1)) let weaken (p q r:slprop) (h:H.hheap (p `star` q) { H.stronger q r }) : H.hheap (p `star` r) = H.weaken p q r h; h let weaken_pure (q r: prop) : Lemma (requires (q ==> r)) (ensures H.stronger (H.pure q) (H.pure r)) = let aux (h:H.heap) : Lemma (ensures (H.interp (H.pure q) h ==> H.interp (H.pure r) h)) [SMTPat ()] = H.pure_interp q h; H.pure_interp r h in () let inc_ctr (#p:slprop) #e (m:hmem_with_inv_except e p) : m':hmem_with_inv_except e p{m'.ctr = m.ctr + 1 /\ H.stronger (linv e m) (linv e m')} = let m' : mem = { m with ctr = m.ctr + 1} in assert (interp (p `star` linv e m) m'); assert (linv e m == lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m)); assert (linv e m' == lock_store_invariant e m.locks `star` ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken_free_above (heap_of_mem m) m.ctr (m.ctr + 1); weaken_pure (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_ctr_valid (m.ctr + 1) (heap_of_mem m)); assert (H.stronger (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m))); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)); H.stronger_star (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken (p `star` lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)) (heap_of_mem m'); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity (m.ctr + 1) (heap_of_mem m)); let m' : hmem_with_inv_except e p = m' in m' let frame_related_mems (fp0 fp1:slprop u#a) e (m0:hmem_with_inv_except e fp0) (m1:hmem_with_inv_except e fp1) = forall (frame:slprop u#a). interp ((fp0 `star` frame) `star` linv e m0) m0 ==> interp ((fp1 `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) let refined_pre_action e (fp0:slprop) (a:Type) (fp1:a -> slprop) = m0:hmem_with_inv_except e fp0 -> Pure (x:a & hmem_with_inv_except e (fp1 x)) (requires True) (ensures fun (| x, m1 |) -> frame_related_mems fp0 (fp1 x) e m0 m1) let refined_pre_action_as_action (#fp0:slprop) (#a:Type) (#fp1:a -> slprop) #e ($f:refined_pre_action e fp0 a fp1) : tot_action_nf_except e fp0 a fp1 = let g : tot_pre_action_nf_except e fp0 a fp1 = fun m -> f m in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp0 `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp1 x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x', m1' |) = g m0 in let (| x, m1 |) = f m0 in assert (x == x' /\ m1 == m1') in g let alloc_action #a #pcm e x = let f : refined_pre_action e emp (ref a pcm) (fun r -> pts_to r x) = fun m0 -> (* NS: 9/29/22 I needed to annotate h : Heap.full_heap, for use with the Core checker which generates a guard for checking the implicit pattern "dot" term in the dependent pair pattern on the next line. That guard expects `h` to be a full_heap, which is it, because it is a projection of m0. However, this is not reflected in `h`'s type. So, the Core checker, which produces a guard for the pat_dot_term in isolation, cannot recheck the term. If we were to fold in the checking of pat_dot_terms and their guards with the rest of the VC, this would work. *) let h : Heap.full_heap = hheap_of_hmem m0 in let (|r, h'|) = H.extend #a #pcm x m0.ctr h in let m' : hmem_with_inv_except e emp = inc_ctr m0 in let h' : H.hheap (pts_to #a #pcm r x `star` linv e m') = weaken _ (linv e m0) (linv e m') h' in let m1 : hmem_with_inv_except e (pts_to #a #pcm r x) = hmem_of_hheap m' h' in assert (forall frame. H.frame_related_heaps h h' emp (pts_to #a #pcm r x) frame true); let aux (frame:slprop) : Lemma (requires interp ((emp `star` frame) `star` linv e m0) m0) (ensures interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) [SMTPat (emp `star` frame)] = star_associative emp frame (linv e m0); assert (H.interp (emp `star` (frame `star` linv e m0)) h); assert (H.interp (pts_to #a #pcm r x `star` (frame `star` linv e m0)) h'); star_associative (pts_to #a #pcm r x) frame (linv e m0); assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m0) h'); assert (H.stronger (linv e m0) (linv e m')); assert (H.equiv (linv e m') (linv e m1)); assert (H.stronger (linv e m0) (linv e m1)); let h' : H.hheap ((pts_to #a #pcm r x `star` frame) `star` linv e m1) = weaken _ (linv e m0) (linv e m1) h' in assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) h'); assert (forall (mp:H.hprop frame). mp h == mp h'); mprop_preservation_of_hprop_preservation frame m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) in assert (frame_related_mems emp (pts_to r x) e m0 m1); (| r, m1 |) in lift_tot_action (refined_pre_action_as_action f) let select_refine #a #p e r x f = lift_tot_action (lift_heap_action e (H.select_refine #a #p r x f)) let upd_gen #a #p e r x y f = lift_tot_action (lift_heap_action e (H.upd_gen_action r x y f)) //////////////////////////////////////////////////////////////////////////////// // witness / recall //////////////////////////////////////////////////////////////////////////////// let witnessed_ref #a #pcm (r:ref a pcm) (fact:property a) (m:full_mem) = H.witnessed_ref #a #pcm r fact (heap_of_mem m) let witnessed_ref_stability #a #pcm (r:ref a pcm) (fact:property a) : Lemma (requires FStar.Preorder.stable fact (Steel.Preorder.preorder_of_pcm pcm)) (ensures FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) = H.witnessed_ref_stability #a #pcm r fact let witnessed (#a:Type u#1) (#pcm:pcm a) (r:ref a pcm) (fact:property a) = W.witnessed _ mem_evolves (witnessed_ref r fact) let rearrange_pqr_prq (p q r:slprop) : Lemma (((p `star` q) `star` r) `equiv` ((p `star` r) `star` q)) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_associative p q r } p `star` (q `star` r); (equiv) { star_commutative q r; star_congruence p (q `star` r) p (r `star` q) } p `star` (r `star` q); (equiv) { star_associative p r q } (p `star` r) `star` q; } let preserves_frame_cong (e:inames) (p q:slprop) (r s:slprop) (m0 m1:mem) : Lemma (requires p `equiv` r /\ q `equiv` s /\ preserves_frame e p q m0 m1) (ensures preserves_frame e r s m0 m1) = let aux0 (p q r s:slprop) : Lemma (requires p `equiv` s) (ensures (((p `star` q) `star` r) `equiv` ((s `star` q) `star` r))) = star_congruence p q s q; star_congruence (p `star` q) r (s `star` q) r in let aux (frame:slprop) : Lemma (requires interp ((r `star` frame) `star` locks_invariant e m0) m0) (ensures interp ((s `star` frame) `star` locks_invariant e m1) m1 /\ interp ((p `star` frame) `star` locks_invariant e m0) m0) [SMTPat (r `star` frame)] = aux0 p frame (locks_invariant e m0) r; aux0 q frame (locks_invariant e m1) s; assert (((p `star` frame) `star` locks_invariant e m0) `equiv` ((r `star` frame) `star` locks_invariant e m0)); assert (interp ((p `star` frame) `star` locks_invariant e m0) m0); assert (interp ((q `star` frame) `star` locks_invariant e m1) m1); assert (((q `star` frame) `star` locks_invariant e m1) `equiv` ((s `star` frame) `star` locks_invariant e m1)); () in ()

{ "checked_file": "/", "dependencies": [ "Steel.Preorder.fst.checked", "Steel.Heap.fsti.checked", "prims.fst.checked", "FStar.Witnessed.Core.fsti.checked", "FStar.Set.fsti.checked", "FStar.Preorder.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.PCM.fst.checked", "FStar.NMSTTotal.fst.checked", "FStar.List.Tot.fst.checked", "FStar.IndefiniteDescription.fsti.checked", "FStar.Ghost.fsti.checked", "FStar.FunctionalExtensionality.fsti.checked", "FStar.Classical.Sugar.fsti.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Steel.Memory.fst" }

[ { "abbrev": true, "full_module": "Steel.Preorder", "short_module": "PP" }, { "abbrev": true, "full_module": "FStar.Witnessed.Core", "short_module": "W" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": true, "full_module": "Steel.Heap", "short_module": "H" }, { "abbrev": false, "full_module": "FStar.PCM", "short_module": null }, { "abbrev": false, "full_module": "FStar.FunctionalExtensionality", "short_module": null }, { "abbrev": true, "full_module": "FStar.FunctionalExtensionality", "short_module": "F" }, { "abbrev": false, "full_module": "FStar.PCM", "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

p: Steel.Memory.slprop -> FStar.Pervasives.Lemma (ensures Steel.Memory.equiv (Steel.Memory.star p (Steel.Memory.pure Prims.l_True)) p)

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Steel.Memory.slprop", "Prims._assert", "Steel.Memory.equiv", "Steel.Memory.star", "Steel.Memory.pure", "Prims.l_True", "Prims.unit", "Steel.Memory.emp_unit", "FStar.Classical.forall_intro", "Steel.Memory.mem", "Prims.l_iff", "Steel.Memory.interp", "Prims.l_and", "Steel.Memory.emp", "Steel.Memory.pure_star_interp", "Prims.squash", "Prims.Nil", "FStar.Pervasives.pattern" ]

[]

false

true

false

let pure_true_equiv (p: slprop) : Lemma ((p `star` (pure True)) `equiv` p) =

FStar.Classical.forall_intro (pure_star_interp p True); emp_unit p; assert ((p `star` (pure True)) `equiv` p)

false

Steel.Memory.fst

Steel.Memory.rearrange_pqr_prq

val rearrange_pqr_prq (p q r: slprop) : Lemma (((p `star` q) `star` r) `equiv` ((p `star` r) `star` q))

let rearrange_pqr_prq (p q r:slprop) : Lemma (((p `star` q) `star` r) `equiv` ((p `star` r) `star` q)) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_associative p q r } p `star` (q `star` r); (equiv) { star_commutative q r; star_congruence p (q `star` r) p (r `star` q) } p `star` (r `star` q); (equiv) { star_associative p r q } (p `star` r) `star` q; }

{ "file_name": "lib/steel/Steel.Memory.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 9, "end_line": 1025, "start_col": 0, "start_line": 1010 }

(* 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.Memory module F = FStar.FunctionalExtensionality open FStar.FunctionalExtensionality open FStar.PCM module H = Steel.Heap noeq type lock_state : Type u#(a + 1) = | Invariant : inv:H.slprop u#a -> lock_state let lock_store : Type u#(a+1) = list (lock_state u#a) noeq type mem : Type u#(a + 1) = { ctr: nat; heap: H.heap u#a; locks: lock_store u#a; } let heap_of_mem (x:mem) : H.heap = x.heap let mem_of_heap (h:H.heap) : mem = { ctr = 0; heap = h; locks = [] } let mem_set_heap (m:mem) (h:H.heap) : mem = { ctr = m.ctr; heap = h; locks = m.locks; } let core_mem (m:mem) : mem = mem_of_heap (heap_of_mem m) let core_mem_invol m = () let disjoint (m0 m1:mem u#h) : prop = m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks let disjoint_sym m0 m1 = () let join m0 m1 = { ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = m0.locks } let join_commutative m0 m1 = H.join_commutative m0.heap m1.heap let disjoint_join m0 m1 m2 = H.disjoint_join m0.heap m1.heap m2.heap let join_associative m0 m1 m2 = H.join_associative m0.heap m1.heap m2.heap let slprop = H.slprop let interp p m = H.interp p m.heap let equiv p1 p2 = forall m. interp p1 m <==> interp p2 m let slprop_extensionality p q = assert (forall m. interp p m <==> interp q m); let aux (h:H.heap) : Lemma (H.interp p h <==> H.interp q h) [SMTPat (H.interp p h)] = let m : mem = { ctr = 0; heap = h; locks = [] } in assert (interp p m <==> interp q m) in assert (forall h. H.interp p h <==> H.interp q h); Steel.Heap.slprop_extensionality p q let reveal_equiv p1 p2 = () let core_ref = H.core_ref let core_ref_null = H.core_ref_null let core_ref_is_null r = H.core_ref_is_null r let emp : slprop u#a = H.emp let pure = H.pure let pts_to = H.pts_to let h_and = H.h_and let h_or = H.h_or let star = H.star let wand = H.wand let h_exists = H.h_exists let h_forall = H.h_forall //////////////////////////////////////////////////////////////////////////////// //properties of equiv //////////////////////////////////////////////////////////////////////////////// let equiv_symmetric (p1 p2:slprop u#a) = H.equiv_symmetric p1 p2 #push-options "--warn_error -271" let equiv_heap_iff_equiv (p1 p2:slprop u#a) : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat (equiv p1 p2)] = let aux_lr () : Lemma (requires H.equiv p1 p2) (ensures equiv p1 p2) [SMTPat ()] = () in let aux_rl_helper1 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p1 h) (ensures H.interp p2 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl_helper2 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p2 h) (ensures H.interp p1 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl () : Lemma (requires equiv p1 p2) (ensures H.equiv p1 p2) [SMTPat ()] = () in () let equiv_heap_iff_equiv_forall () : Lemma (ensures (forall p1 p2. H.equiv p1 p2 <==> equiv p1 p2)) = let aux p1 p2 : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat ()] = equiv_heap_iff_equiv p1 p2 in () #pop-options let equiv_extensional_on_star (p1 p2 p3:slprop u#a) = equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3 let emp_unit p = H.emp_unit p let intro_emp m = H.intro_emp (heap_of_mem m) let pure_equiv p q = H.pure_equiv p q let pure_interp q m = H.pure_interp q (heap_of_mem m) let pure_star_interp p q m = H.pure_star_interp p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// //pts_to //////////////////////////////////////////////////////////////////////////////// let pts_to_compatible #a #pcm x v0 v1 m = H.pts_to_compatible #a #pcm x v0 v1 (heap_of_mem m) let pts_to_compatible_equiv #a #pcm x v0 v1 = H.pts_to_compatible_equiv #a #pcm x v0 v1 let pts_to_not_null #a #pcm x v m = H.pts_to_not_null #a #pcm x v (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // star //////////////////////////////////////////////////////////////////////////////// let intro_star p q mp mq = H.intro_star p q (heap_of_mem mp) (heap_of_mem mq) let elim_star p q m = let h = heap_of_mem m in H.elim_star p q h; assert (exists hl hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr); let hl = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hl -> exists hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let hr = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hr -> H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let ml = mem_set_heap m hl in let mr = mem_set_heap m hr in assert (disjoint ml mr); assert (m == join ml mr); assert (interp p ml); assert (interp q mr); () let interp_star (p q: slprop) (m: mem) : Lemma (interp (p `star` q) m <==> (exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m)) = let left = interp (p `star` q) m in let right = exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m in let f () : Lemma (requires left) (ensures right) = elim_star p q m in let g () : Lemma (requires right) (ensures left) = Classical.exists_elim left #_ #(fun mp -> exists (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mp -> Classical.exists_elim left #_ #(fun mq -> disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mq -> intro_star p q mp mq ) ) in Classical.move_requires f (); Classical.move_requires g () let star_commutative (p1 p2:slprop) = H.star_commutative p1 p2 let star_associative (p1 p2 p3:slprop) = H.star_associative p1 p2 p3 let star_congruence (p1 p2 p3 p4:slprop) = equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4 let affine_star (p q:slprop) (m:mem) = H.affine_star p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // Invariants on the lock store //////////////////////////////////////////////////////////////////////////////// let iname = nat module S = FStar.Set module L = FStar.List.Tot module W = FStar.Witnessed.Core let rec lock_store_invariant (e:inames) (l:lock_store u#a) : slprop u#a = let current_addr = L.length l - 1 in match l with | [] -> emp | Invariant p :: tl -> if current_addr `S.mem` e then lock_store_invariant e tl else p `star` lock_store_invariant e tl let lock_i (i:iname) (l:lock_store { i < L.length l }) = let ix = L.length l - i - 1 in L.index l ix let iname_for_p (i:iname) (p:slprop) : W.s_predicate lock_store = fun l -> i < L.length l /\ (lock_i i l).inv == p let lock_store_evolves : FStar.Preorder.preorder lock_store = fun (l1 l2 : lock_store) -> L.length l2 >= L.length l1 /\ (forall (i:nat{i < L.length l1}). (lock_i i l1).inv == (lock_i i l2).inv) let inames_in (e:inames) (l:lock_store) : prop = forall i. Set.mem i e ==> i < L.length l let inames_ok e m = inames_in e m.locks let inames_ok_empty m = () let extend_lock_store (e:inames) (l:lock_store{e `inames_in` l}) (p:slprop) : i:iname & l':lock_store { lock_store_invariant e l' == p `star` lock_store_invariant e l /\ iname_for_p i p l' } = (| L.length l, Invariant p :: l |) let set_add (i:iname) (s:inames) = Set.union (Set.singleton i) s let rec move_invariant (e:inames) (l:lock_store) (p:slprop) (i:iname{iname_for_p i p l /\ ~(i `Set.mem` e)}) : Lemma (H.equiv (lock_store_invariant e l) (p `star` lock_store_invariant (set_add i e) l)) = let rec aux (i:iname) (m:lock_store) : Lemma (requires i >= L.length m) (ensures (lock_store_invariant e m `H.equiv` lock_store_invariant (set_add i e) m)) = match m with | [] -> () | Invariant p::tl -> aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl) in let current_addr = L.length l - 1 in match l with | [] -> () | Invariant q::tl -> if i = current_addr then begin assert (lock_store_invariant e l == p `star` lock_store_invariant e tl); aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl); () end else begin move_invariant e tl p i; assert (lock_store_invariant e tl `equiv` (p `star` lock_store_invariant (set_add i e) tl)); H.star_congruence q (lock_store_invariant e tl) q (p `star` lock_store_invariant (set_add i e) tl); if Set.mem current_addr e then () else begin let r = lock_store_invariant (set_add i e) tl in assert (lock_store_invariant e l `equiv` (q `star` (p `star` r))); H.star_associative q p r; H.star_commutative q p; H.star_congruence (q `star` p) r (p `star` q) r; H.star_associative p q r end end let heap_ctr_valid (ctr:nat) (h:H.heap u#a) : prop = h `H.free_above_addr` ctr let ctr_validity (ctr:nat) (h:H.heap) : slprop = H.pure (heap_ctr_valid ctr h) let locks_invariant (e:inames) (m:mem u#a) : slprop u#a = lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m) let full_mem_pred (m:mem) = H.full_heap_pred (heap_of_mem m) (***** Following lemmas are needed in Steel.Effect *****) let core_mem_interp (hp:slprop u#a) (m:mem u#a) = () let interp_depends_only_on (hp:slprop u#a) = H.interp_depends_only_on hp let a_mem_prop_as_a_heap_prop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (H.a_heap_prop u#a) = let g (h: H.heap u#a) : Tot prop = interp sl (mem_of_heap h) /\ f (mem_of_heap h) in let phi0 (h0 h1: H.heap u#a) : Lemma (requires (g h0 /\ H.disjoint h0 h1)) (ensures (g h0 /\ H.disjoint h0 h1 /\ g (H.join h0 h1))) = assert (mem_of_heap (H.join h0 h1) == mem_of_heap h0 `join` mem_of_heap h1); interp_depends_only_on sl in let phi1 (h0 h1: H.heap u#a) : Lemma (ensures ((g h0 /\ H.disjoint h0 h1) ==> g (H.join h0 h1))) = Classical.move_requires (phi0 h0) h1 in Classical.forall_intro_2 phi1; g let refine_slprop sl f = H.as_slprop (a_mem_prop_as_a_heap_prop sl f) let interp_refine_slprop sl f m = assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_mem m)) let dep_hprop (s: slprop) (f: (hmem s -> Tot slprop)) (h: H.heap) : Tot prop = exists (h1: H.heap) . exists (h2: H.heap) . interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 let dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq' : squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h')) = let p2 (h h1 h2: H.heap) : Tot prop = interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 in let p1 (h h1: H.heap) : Tot prop = (exists h2 . p2 h h1 h2) in let h1 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p1 h) in let h2 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p2 h h1) in H.disjoint_join h' h1 h2; assert (H.disjoint h2 h'); let h2' = H.join h2 h' in H.join_commutative h2 h' ; assert (h2' == H.join h' h2); assert (H.disjoint h1 h2'); assert (mem_of_heap h2' == mem_of_heap h2 `join` mem_of_heap h'); interp_depends_only_on (f (mem_of_heap h1)); assert (interp (f (mem_of_heap h1)) (mem_of_heap h2')); H.join_commutative h1 h2; H.join_associative h' h2 h1; H.join_commutative h' h; H.join_commutative h2' h1; assert (H.join h h' == h1 `H.join` h2') let impl_intro_gen (#p: Type0) (#q: Type0) ($prf: (squash p -> Lemma (q ))) : Lemma (p ==> q) = Classical.impl_intro_gen #p #(fun _ -> q) prf let dep_hprop_is_affine1 (s: slprop) (f: (hmem s -> Tot slprop)) (h0 h1: H.heap) : Lemma ((dep_hprop s f h0 /\ H.disjoint h0 h1) ==> (H.disjoint h0 h1 /\ dep_hprop s f (H.join h0 h1))) = impl_intro_gen (dep_hprop_is_affine0 s f h0 h1) let dep_hprop_is_affine (s: slprop) (f: (hmem s -> Tot slprop)) : Lemma (H.heap_prop_is_affine (dep_hprop s f)) = Classical.forall_intro_2 (dep_hprop_is_affine1 s f) let sdep (s: slprop) (f: (hmem s -> Tot slprop)) : Tot slprop = dep_hprop_is_affine s f; H.as_slprop (dep_hprop s f) let interp_sdep (s: slprop) (f: (hmem s -> Tot slprop)) (m: mem) : Lemma (requires (dep_slprop_is_affine s f)) (ensures ( interp (sdep s f) m <==> (exists m1 m2 . interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) )) = dep_hprop_is_affine s f; assert (forall m1 m2 . (interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) ==> ( interp s (mem_of_heap m1.heap) /\ interp (f (mem_of_heap m1.heap)) (mem_of_heap m2.heap) /\ H.disjoint m1.heap m2.heap /\ H.join m1.heap m2.heap == m.heap )); interp_depends_only_on s; Classical.forall_intro (fun m -> interp_depends_only_on (f m)); assert (forall h1 h2 . (interp s (mem_of_heap h1) /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ H.disjoint h1 h2 /\ H.join h1 h2 == m.heap) ==> ( core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ interp s (core_mem (mem_of_heap h1)) /\ interp s (mem_set_heap m h1) /\ core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ f (mem_set_heap m h1) `equiv` f (mem_of_heap h1) /\ interp (f (mem_set_heap m h1)) (mem_of_heap h2) /\ interp (f (mem_set_heap m h1)) (mem_set_heap m h2) /\ disjoint (mem_set_heap m h1) (mem_set_heap m h2) /\ join (mem_set_heap m h1) (mem_set_heap m h2) == m )); () let h_exists_cong (#a:Type) (p q : a -> slprop) : Lemma (requires (forall x. p x `equiv` q x)) (ensures (h_exists p `equiv` h_exists q)) = equiv_heap_iff_equiv_forall (); H.h_exists_cong p q let intro_h_exists #a x p m = H.intro_h_exists x p (heap_of_mem m) let elim_h_exists (#a:_) (p:a -> slprop) (m:mem) = H.elim_h_exists p (heap_of_mem m) let intro_h_forall (#a:_) (p:a -> slprop) (m:mem) = H.intro_h_forall p (heap_of_mem m) let elim_h_forall (#a:_) (p:a -> slprop) (m:mem) (x:a) = H.elim_h_forall p (heap_of_mem m) x let intro_h_and (p q: slprop) (m:mem) = H.intro_h_and p q (heap_of_mem m) let elim_h_and (p q: slprop) (m:mem) = H.elim_h_and p q (heap_of_mem m) let intro_h_or_left (p q: slprop) (m:mem) = H.intro_h_or_left p q (heap_of_mem m) let intro_h_or_right (p q: slprop) (m:mem) = H.intro_h_or_right p q (heap_of_mem m) let elim_h_or (p q: slprop) (m:mem) = H.elim_h_or p q (heap_of_mem m) let intro_wand (p1 p2: slprop u#a) (m:mem) = introduce (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)) ==> interp (wand p1 p2) m with _. ( assert (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)); H.intro_wand p1 p2 (heap_of_mem m); let h = heap_of_mem m in assert ((forall h1. h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) ==> H.interp (wand p1 p2) h); introduce forall h1. (h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) with ( introduce (h `H.disjoint` h1 /\ H.interp p1 h1) ==> H.interp p2 (H.join h h1) with _. ( assert (h `H.disjoint` h1); let m1 = { ctr = m.ctr; heap = h1; locks = m.locks } in assert (m `disjoint` m1) ) ) ) (** Eliminating a wand by proving a heap that satisfies the LHS **) let elim_wand (p1 p2: slprop u#a) (m:mem) (m1:mem) = H.elim_wand p1 p2 (heap_of_mem m) (heap_of_mem m1) //////////////////////////////////////////////////////////////////////////////// // Preorders and effects //////////////////////////////////////////////////////////////////////////////// module PP = Steel.Preorder let mem_evolves = fun (m0 m1:full_mem) -> H.heap_evolves (heap_of_mem m0) (heap_of_mem m1) /\ m0.ctr <= m1.ctr /\ lock_store_evolves m0.locks m1.locks (** See [Steel.Heap.is_frame_preserving]. We add in [lock_invariants] now *) let preserves_frame (e:inames) (pre post:slprop) (m0 m1:mem) = forall (frame:slprop). interp ((pre `star` frame) `star` locks_invariant e m0) m0 ==> (interp ((post `star` frame) `star` locks_invariant e m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) (** This is a version of MstTot with frame quantified, as part of preserves_frame *) effect MstTotNF (a:Type u#a) (except:inames) (expects:slprop u#1) (provides: a -> slprop u#1) = NMSTTotal.NMSTATETOT a (full_mem u#1) mem_evolves (requires fun m0 -> inames_ok except m0 /\ interp (expects `star` locks_invariant except m0) m0) (ensures fun m0 x m1 -> inames_ok except m1 /\ interp (provides x `star` locks_invariant except m1) m1 /\ preserves_frame except expects (provides x) m0 m1) //////////////////////////////////////////////////////////////////////////////// // Lifting heap actions //////////////////////////////////////////////////////////////////////////////// (** Heap actions come in two equivalent flavors: - one that take an explicit frame as argument (action_with_frame) - and one that quantify over all the frame We therefore define two lift routes: - a direct route for those with explicit frame - via MstTotNF for the rest *) let tot_pre_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = hmem_with_inv_except e fp -> (x:a & hmem_with_inv_except e (fp' x)) let tot_pre_action_nf = tot_pre_action_nf_except S.empty let ac_reasoning_for_m_frame_preserving (p q r:slprop u#a) (m:mem u#a) : Lemma (requires interp ((p `star` q) `star` r) m) (ensures interp (p `star` r) m) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_commutative p q; equiv_extensional_on_star (p `star` q) (q `star` p) r } (q `star` p) `star` r; (equiv) { star_associative q p r } q `star` (p `star` r); }; assert (interp (q `star` (p `star` r)) m); affine_star q (p `star` r) m let is_frame_preserving (#e:inames) (#a:Type u#b) (#fp:slprop u#a) (#fp':a -> slprop u#a) (f:tot_pre_action_nf_except e fp a fp') = forall (frame:slprop u#a) (m0:hmem_with_inv_except e (fp `star` frame)). (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = f:tot_pre_action_nf_except e fp a fp'{ is_frame_preserving f } let tot_action_nf = tot_action_nf_except S.empty let linv e (m:mem) = locks_invariant e m let hheap_of_hmem #fp #e (m:hmem_with_inv_except e fp) : h:H.hheap (fp `star` linv e m) { h `H.free_above_addr` m.ctr} = let h = heap_of_mem m in H.pure_interp (heap_ctr_valid m.ctr (heap_of_mem m)) h; h let hmem_of_hheap #e (#fp0 #fp1:slprop) (m:hmem_with_inv_except e fp0) (h:H.full_hheap (fp1 `star` linv e m) { h `Heap.free_above_addr` m.ctr }) : m1:hmem_with_inv_except e fp1{linv e m `equiv` linv e m1} = let m1 : mem = { m with heap = h } in assert (interp (fp1 `star` linv e m) m1); star_commutative fp1 (linv e m); assert (interp (linv e m `star` fp1) m1); assert (linv e m1 == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); assert (linv e m == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m)); H.pure_interp (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_of_mem m); assert (heap_ctr_valid m1.ctr (heap_of_mem m) <==> heap_ctr_valid m1.ctr (heap_of_mem m1)); H.pure_equiv (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_ctr_valid m1.ctr (heap_of_mem m1)); H.star_congruence (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m)); assert (linv e m `equiv` linv e m1); let _ = equiv_extensional_on_star (linv e m) (linv e m1) fp1 in assert ((linv e m `star` fp1) `equiv` (linv e m1 `star` fp1)); assert (interp (linv e m1 `star` fp1) m1); star_commutative (linv e m1) fp1; assert (interp (fp1 `star` linv e m1) m1); m1 let with_inv_except (m:mem) e (fp:slprop) = interp (fp `star` locks_invariant e m) m #push-options "--warn_error -271" let as_hprop (frame:slprop) (mp:mprop frame) : hp:H.hprop frame{forall m. mp (core_mem m) == hp (heap_of_mem m)} = let f = fun h -> mp (mem_of_heap h) in assert (forall m. mp (core_mem m) == f (heap_of_mem m)); let aux (m0:H.hheap frame) (m1:H.heap{H.disjoint m0 m1}) : Lemma (ensures (mem_of_heap (H.join m0 m1) == join (mem_of_heap m0) (mem_of_heap m1))) [SMTPat ()] = () in f let mprop_preservation_of_hprop_preservation (p:slprop) (m0 m1:mem) : Lemma (requires (forall (hp:H.hprop p). hp (heap_of_mem m0) == hp (heap_of_mem m1))) (ensures (forall (mp:mprop p). mp (core_mem m0) == mp (core_mem m1))) = let aux (mp:mprop p) : Lemma (mp (core_mem m0) == mp (core_mem m1)) [SMTPat()] = assert (as_hprop p mp (heap_of_mem m0) == as_hprop p mp (heap_of_mem m1)) in () let lift_heap_action (#fp:slprop) (#a:Type) (#fp':a -> slprop) (e:inames) ($f:H.action fp a fp') : tot_action_nf_except e fp a fp' = let g : tot_pre_action_nf_except e fp a fp' = fun m -> let h0 = hheap_of_hmem m in let (| x, h' |) = f h0 in (| x, hmem_of_hheap m h' |) in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in let h0 = hheap_of_hmem m0 in let (| x', h1 |) = f h0 in H.action_framing f (linv e m0) h0; assert (x == x'); star_associative fp frame (linv e m0); H.action_framing f (frame `star` linv e m0) h0; assert (H.interp ((fp' x) `star` (frame `star` linv e m0)) h1); star_associative (fp' x) frame (linv e m0); assert (H.interp ((fp' x `star` frame) `star` linv e m0) h1); let h1' : H.hheap ((fp' x `star` frame) `star` linv e m0) = h1 in assert (m1 == hmem_of_hheap m0 h1'); assert (with_inv_except m1 e (fp' x `star` frame)); assert (forall (hp:H.hprop frame). hp h0 == hp h1); mprop_preservation_of_hprop_preservation frame m0 m1; () in assert (is_frame_preserving g); g let frame_preserving_respects_preorder #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (m0:hmem_with_inv_except e fp) : Lemma (let (| x, m1 |) = f m0 in mem_evolves m0 m1) = let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1) = () in H.emp_unit fp; assert (interp (fp `star` linv e m0) m0); H.star_congruence (fp `star` emp) (linv e m0) fp (linv e m0); assert (interp ((fp `star` emp) `star` linv e m0) m0); aux emp m0 let lift_tot_action_nf #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') : MstTotNF a e fp fp' = let m0 = NMSTTotal.get () in let m0' : hmem_with_inv_except e fp = m0 in let r = f m0' in let (| x, m1 |) = r in let m1' : hmem_with_inv_except e (fp' x) = m1 in assert (is_frame_preserving f); assert (m1 == dsnd (f m0)); frame_preserving_respects_preorder f m0; NMSTTotal.put #_ #(mem_evolves) m1; x let lift_tot_action #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get #(full_mem) #_ () in ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); lift_tot_action_nf f (** Now defining the lift for heap actions with explicit frame *) let tot_action_with_frame_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = frame:slprop u#a -> m0:hmem_with_inv_except e (fp `star` frame) -> Pure (x:a & hmem_with_inv_except e (fp' x `star` frame)) (requires True) (ensures fun (| x, m1 |) -> mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_with_frame = tot_action_with_frame_except S.empty let lift_heap_action_with_frame (#fp:slprop u#a) (#a:Type u#b) (#fp':a -> slprop u#a) (e:inames) ($f:H.action_with_frame fp a fp') : tot_action_with_frame_except e fp a fp' = fun frame m0 -> let h0 = hheap_of_hmem m0 in calc (equiv) { fp `star` frame `star` locks_invariant e m0; (equiv) { star_associative fp frame (locks_invariant e m0) } fp `star` (frame `star` locks_invariant e m0); }; assert (H.interp (fp `star` frame `star` locks_invariant e m0) h0); assert (H.interp (fp `star` (frame `star` locks_invariant e m0)) h0); //key: apply the heap action with frame * locks_invariant e m0 let (| x, h1 |) = f (frame `star` locks_invariant e m0) h0 in calc (equiv) { fp' x `star` (frame `star` locks_invariant e m0); (equiv) { star_associative (fp' x) frame (locks_invariant e m0) } fp' x `star` frame `star` locks_invariant e m0; }; assert (H.interp (fp' x `star` (frame `star` locks_invariant e m0)) h1); assert (H.interp (fp' x `star` frame `star` locks_invariant e m0) h1); let m1 = hmem_of_hheap m0 h1 in assert (mem_evolves m0 m1); mprop_preservation_of_hprop_preservation (frame `star` locks_invariant e m0) m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)); (| x, m1 |) let lift_tot_action_with_frame #a #e #fp #fp' ($f:tot_action_with_frame_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in assert (inames_ok e m0); ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); let m0' : hmem_with_inv_except e fp = m0 in let r = f frame m0' in let (| x, m1 |) = r in ac_reasoning_for_m_frame_preserving (fp' x) frame (locks_invariant e m1) m1; assert (interp (fp' x `star` frame `star` locks_invariant e m1) m1); assert (interp (fp' x `star` locks_invariant e m1) m1); let m1' : hmem_with_inv_except e (fp' x) = m1 in NMSTTotal.put #_ #(mem_evolves) m1; x let sel_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.sel_action #a #pcm r v0)) let upd_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.upd_action #a #pcm r v0 v1)) let free_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.free_action #a #pcm r v0)) let split_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.split_action #a #pcm r v0 v1)) let gather_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.gather_action #a #pcm r v0 v1)) let weaken (p q r:slprop) (h:H.hheap (p `star` q) { H.stronger q r }) : H.hheap (p `star` r) = H.weaken p q r h; h let weaken_pure (q r: prop) : Lemma (requires (q ==> r)) (ensures H.stronger (H.pure q) (H.pure r)) = let aux (h:H.heap) : Lemma (ensures (H.interp (H.pure q) h ==> H.interp (H.pure r) h)) [SMTPat ()] = H.pure_interp q h; H.pure_interp r h in () let inc_ctr (#p:slprop) #e (m:hmem_with_inv_except e p) : m':hmem_with_inv_except e p{m'.ctr = m.ctr + 1 /\ H.stronger (linv e m) (linv e m')} = let m' : mem = { m with ctr = m.ctr + 1} in assert (interp (p `star` linv e m) m'); assert (linv e m == lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m)); assert (linv e m' == lock_store_invariant e m.locks `star` ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken_free_above (heap_of_mem m) m.ctr (m.ctr + 1); weaken_pure (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_ctr_valid (m.ctr + 1) (heap_of_mem m)); assert (H.stronger (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m))); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)); H.stronger_star (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken (p `star` lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)) (heap_of_mem m'); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity (m.ctr + 1) (heap_of_mem m)); let m' : hmem_with_inv_except e p = m' in m' let frame_related_mems (fp0 fp1:slprop u#a) e (m0:hmem_with_inv_except e fp0) (m1:hmem_with_inv_except e fp1) = forall (frame:slprop u#a). interp ((fp0 `star` frame) `star` linv e m0) m0 ==> interp ((fp1 `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) let refined_pre_action e (fp0:slprop) (a:Type) (fp1:a -> slprop) = m0:hmem_with_inv_except e fp0 -> Pure (x:a & hmem_with_inv_except e (fp1 x)) (requires True) (ensures fun (| x, m1 |) -> frame_related_mems fp0 (fp1 x) e m0 m1) let refined_pre_action_as_action (#fp0:slprop) (#a:Type) (#fp1:a -> slprop) #e ($f:refined_pre_action e fp0 a fp1) : tot_action_nf_except e fp0 a fp1 = let g : tot_pre_action_nf_except e fp0 a fp1 = fun m -> f m in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp0 `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp1 x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x', m1' |) = g m0 in let (| x, m1 |) = f m0 in assert (x == x' /\ m1 == m1') in g let alloc_action #a #pcm e x = let f : refined_pre_action e emp (ref a pcm) (fun r -> pts_to r x) = fun m0 -> (* NS: 9/29/22 I needed to annotate h : Heap.full_heap, for use with the Core checker which generates a guard for checking the implicit pattern "dot" term in the dependent pair pattern on the next line. That guard expects `h` to be a full_heap, which is it, because it is a projection of m0. However, this is not reflected in `h`'s type. So, the Core checker, which produces a guard for the pat_dot_term in isolation, cannot recheck the term. If we were to fold in the checking of pat_dot_terms and their guards with the rest of the VC, this would work. *) let h : Heap.full_heap = hheap_of_hmem m0 in let (|r, h'|) = H.extend #a #pcm x m0.ctr h in let m' : hmem_with_inv_except e emp = inc_ctr m0 in let h' : H.hheap (pts_to #a #pcm r x `star` linv e m') = weaken _ (linv e m0) (linv e m') h' in let m1 : hmem_with_inv_except e (pts_to #a #pcm r x) = hmem_of_hheap m' h' in assert (forall frame. H.frame_related_heaps h h' emp (pts_to #a #pcm r x) frame true); let aux (frame:slprop) : Lemma (requires interp ((emp `star` frame) `star` linv e m0) m0) (ensures interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) [SMTPat (emp `star` frame)] = star_associative emp frame (linv e m0); assert (H.interp (emp `star` (frame `star` linv e m0)) h); assert (H.interp (pts_to #a #pcm r x `star` (frame `star` linv e m0)) h'); star_associative (pts_to #a #pcm r x) frame (linv e m0); assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m0) h'); assert (H.stronger (linv e m0) (linv e m')); assert (H.equiv (linv e m') (linv e m1)); assert (H.stronger (linv e m0) (linv e m1)); let h' : H.hheap ((pts_to #a #pcm r x `star` frame) `star` linv e m1) = weaken _ (linv e m0) (linv e m1) h' in assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) h'); assert (forall (mp:H.hprop frame). mp h == mp h'); mprop_preservation_of_hprop_preservation frame m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) in assert (frame_related_mems emp (pts_to r x) e m0 m1); (| r, m1 |) in lift_tot_action (refined_pre_action_as_action f) let select_refine #a #p e r x f = lift_tot_action (lift_heap_action e (H.select_refine #a #p r x f)) let upd_gen #a #p e r x y f = lift_tot_action (lift_heap_action e (H.upd_gen_action r x y f)) //////////////////////////////////////////////////////////////////////////////// // witness / recall //////////////////////////////////////////////////////////////////////////////// let witnessed_ref #a #pcm (r:ref a pcm) (fact:property a) (m:full_mem) = H.witnessed_ref #a #pcm r fact (heap_of_mem m) let witnessed_ref_stability #a #pcm (r:ref a pcm) (fact:property a) : Lemma (requires FStar.Preorder.stable fact (Steel.Preorder.preorder_of_pcm pcm)) (ensures FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) = H.witnessed_ref_stability #a #pcm r fact let witnessed (#a:Type u#1) (#pcm:pcm a) (r:ref a pcm) (fact:property a) = W.witnessed _ mem_evolves (witnessed_ref r fact)

{ "checked_file": "/", "dependencies": [ "Steel.Preorder.fst.checked", "Steel.Heap.fsti.checked", "prims.fst.checked", "FStar.Witnessed.Core.fsti.checked", "FStar.Set.fsti.checked", "FStar.Preorder.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.PCM.fst.checked", "FStar.NMSTTotal.fst.checked", "FStar.List.Tot.fst.checked", "FStar.IndefiniteDescription.fsti.checked", "FStar.Ghost.fsti.checked", "FStar.FunctionalExtensionality.fsti.checked", "FStar.Classical.Sugar.fsti.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Steel.Memory.fst" }

[ { "abbrev": true, "full_module": "Steel.Preorder", "short_module": "PP" }, { "abbrev": true, "full_module": "FStar.Witnessed.Core", "short_module": "W" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": true, "full_module": "Steel.Heap", "short_module": "H" }, { "abbrev": false, "full_module": "FStar.PCM", "short_module": null }, { "abbrev": false, "full_module": "FStar.FunctionalExtensionality", "short_module": null }, { "abbrev": true, "full_module": "FStar.FunctionalExtensionality", "short_module": "F" }, { "abbrev": false, "full_module": "FStar.PCM", "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

p: Steel.Memory.slprop -> q: Steel.Memory.slprop -> r: Steel.Memory.slprop -> FStar.Pervasives.Lemma (ensures Steel.Memory.equiv (Steel.Memory.star (Steel.Memory.star p q) r) (Steel.Memory.star (Steel.Memory.star p r) q))

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Steel.Memory.slprop", "FStar.Calc.calc_finish", "Steel.Memory.equiv", "Steel.Memory.star", "Prims.Cons", "FStar.Preorder.relation", "Prims.Nil", "Prims.unit", "FStar.Calc.calc_step", "FStar.Calc.calc_init", "FStar.Calc.calc_pack", "Steel.Memory.star_associative", "Prims.squash", "Steel.Memory.star_congruence", "Steel.Memory.star_commutative", "Prims.l_True", "FStar.Pervasives.pattern" ]

[]

false

true

false

let rearrange_pqr_prq (p q r: slprop) : Lemma (((p `star` q) `star` r) `equiv` ((p `star` r) `star` q)) =

calc (equiv) { (p `star` q) `star` r; (equiv) { star_associative p q r } p `star` (q `star` r); (equiv) { (star_commutative q r; star_congruence p (q `star` r) p (r `star` q)) } p `star` (r `star` q); (equiv) { star_associative p r q } (p `star` r) `star` q; }

false

Steel.Memory.fst

Steel.Memory.preserves_frame_star_pure

val preserves_frame_star_pure (e: inames) (p q: slprop) (r s: prop) (m: mem) : Lemma (requires r /\ s) (ensures preserves_frame e p q m m <==> preserves_frame e (p `star` (pure r)) (q `star` (pure s)) m m )

let preserves_frame_star_pure (e:inames) (p q:slprop) (r s:prop) (m:mem) : Lemma (requires r /\ s) (ensures preserves_frame e p q m m <==> preserves_frame e (p `star` pure r) (q `star` pure s) m m) = pure_equiv r True; star_congruence p (pure r) p (pure True); pure_equiv s True; star_congruence q (pure s) q (pure True); pure_true_equiv p; pure_true_equiv q; let fwd () : Lemma (requires preserves_frame e p q m m) (ensures preserves_frame e (p `star` pure r) (q `star` pure s) m m) [SMTPat ()] = preserves_frame_cong e p q (p `star` pure r) (q `star` pure s) m m in let bk () : Lemma (requires preserves_frame e (p `star` pure r) (q `star` pure s) m m) (ensures preserves_frame e p q m m) [SMTPat ()] = preserves_frame_cong e (p `star` pure r) (q `star` pure s) p q m m in ()

{ "file_name": "lib/steel/Steel.Memory.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 6, "end_line": 1090, "start_col": 0, "start_line": 1064 }

(* 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.Memory module F = FStar.FunctionalExtensionality open FStar.FunctionalExtensionality open FStar.PCM module H = Steel.Heap noeq type lock_state : Type u#(a + 1) = | Invariant : inv:H.slprop u#a -> lock_state let lock_store : Type u#(a+1) = list (lock_state u#a) noeq type mem : Type u#(a + 1) = { ctr: nat; heap: H.heap u#a; locks: lock_store u#a; } let heap_of_mem (x:mem) : H.heap = x.heap let mem_of_heap (h:H.heap) : mem = { ctr = 0; heap = h; locks = [] } let mem_set_heap (m:mem) (h:H.heap) : mem = { ctr = m.ctr; heap = h; locks = m.locks; } let core_mem (m:mem) : mem = mem_of_heap (heap_of_mem m) let core_mem_invol m = () let disjoint (m0 m1:mem u#h) : prop = m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks let disjoint_sym m0 m1 = () let join m0 m1 = { ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = m0.locks } let join_commutative m0 m1 = H.join_commutative m0.heap m1.heap let disjoint_join m0 m1 m2 = H.disjoint_join m0.heap m1.heap m2.heap let join_associative m0 m1 m2 = H.join_associative m0.heap m1.heap m2.heap let slprop = H.slprop let interp p m = H.interp p m.heap let equiv p1 p2 = forall m. interp p1 m <==> interp p2 m let slprop_extensionality p q = assert (forall m. interp p m <==> interp q m); let aux (h:H.heap) : Lemma (H.interp p h <==> H.interp q h) [SMTPat (H.interp p h)] = let m : mem = { ctr = 0; heap = h; locks = [] } in assert (interp p m <==> interp q m) in assert (forall h. H.interp p h <==> H.interp q h); Steel.Heap.slprop_extensionality p q let reveal_equiv p1 p2 = () let core_ref = H.core_ref let core_ref_null = H.core_ref_null let core_ref_is_null r = H.core_ref_is_null r let emp : slprop u#a = H.emp let pure = H.pure let pts_to = H.pts_to let h_and = H.h_and let h_or = H.h_or let star = H.star let wand = H.wand let h_exists = H.h_exists let h_forall = H.h_forall //////////////////////////////////////////////////////////////////////////////// //properties of equiv //////////////////////////////////////////////////////////////////////////////// let equiv_symmetric (p1 p2:slprop u#a) = H.equiv_symmetric p1 p2 #push-options "--warn_error -271" let equiv_heap_iff_equiv (p1 p2:slprop u#a) : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat (equiv p1 p2)] = let aux_lr () : Lemma (requires H.equiv p1 p2) (ensures equiv p1 p2) [SMTPat ()] = () in let aux_rl_helper1 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p1 h) (ensures H.interp p2 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl_helper2 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p2 h) (ensures H.interp p1 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl () : Lemma (requires equiv p1 p2) (ensures H.equiv p1 p2) [SMTPat ()] = () in () let equiv_heap_iff_equiv_forall () : Lemma (ensures (forall p1 p2. H.equiv p1 p2 <==> equiv p1 p2)) = let aux p1 p2 : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat ()] = equiv_heap_iff_equiv p1 p2 in () #pop-options let equiv_extensional_on_star (p1 p2 p3:slprop u#a) = equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3 let emp_unit p = H.emp_unit p let intro_emp m = H.intro_emp (heap_of_mem m) let pure_equiv p q = H.pure_equiv p q let pure_interp q m = H.pure_interp q (heap_of_mem m) let pure_star_interp p q m = H.pure_star_interp p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// //pts_to //////////////////////////////////////////////////////////////////////////////// let pts_to_compatible #a #pcm x v0 v1 m = H.pts_to_compatible #a #pcm x v0 v1 (heap_of_mem m) let pts_to_compatible_equiv #a #pcm x v0 v1 = H.pts_to_compatible_equiv #a #pcm x v0 v1 let pts_to_not_null #a #pcm x v m = H.pts_to_not_null #a #pcm x v (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // star //////////////////////////////////////////////////////////////////////////////// let intro_star p q mp mq = H.intro_star p q (heap_of_mem mp) (heap_of_mem mq) let elim_star p q m = let h = heap_of_mem m in H.elim_star p q h; assert (exists hl hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr); let hl = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hl -> exists hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let hr = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hr -> H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let ml = mem_set_heap m hl in let mr = mem_set_heap m hr in assert (disjoint ml mr); assert (m == join ml mr); assert (interp p ml); assert (interp q mr); () let interp_star (p q: slprop) (m: mem) : Lemma (interp (p `star` q) m <==> (exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m)) = let left = interp (p `star` q) m in let right = exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m in let f () : Lemma (requires left) (ensures right) = elim_star p q m in let g () : Lemma (requires right) (ensures left) = Classical.exists_elim left #_ #(fun mp -> exists (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mp -> Classical.exists_elim left #_ #(fun mq -> disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mq -> intro_star p q mp mq ) ) in Classical.move_requires f (); Classical.move_requires g () let star_commutative (p1 p2:slprop) = H.star_commutative p1 p2 let star_associative (p1 p2 p3:slprop) = H.star_associative p1 p2 p3 let star_congruence (p1 p2 p3 p4:slprop) = equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4 let affine_star (p q:slprop) (m:mem) = H.affine_star p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // Invariants on the lock store //////////////////////////////////////////////////////////////////////////////// let iname = nat module S = FStar.Set module L = FStar.List.Tot module W = FStar.Witnessed.Core let rec lock_store_invariant (e:inames) (l:lock_store u#a) : slprop u#a = let current_addr = L.length l - 1 in match l with | [] -> emp | Invariant p :: tl -> if current_addr `S.mem` e then lock_store_invariant e tl else p `star` lock_store_invariant e tl let lock_i (i:iname) (l:lock_store { i < L.length l }) = let ix = L.length l - i - 1 in L.index l ix let iname_for_p (i:iname) (p:slprop) : W.s_predicate lock_store = fun l -> i < L.length l /\ (lock_i i l).inv == p let lock_store_evolves : FStar.Preorder.preorder lock_store = fun (l1 l2 : lock_store) -> L.length l2 >= L.length l1 /\ (forall (i:nat{i < L.length l1}). (lock_i i l1).inv == (lock_i i l2).inv) let inames_in (e:inames) (l:lock_store) : prop = forall i. Set.mem i e ==> i < L.length l let inames_ok e m = inames_in e m.locks let inames_ok_empty m = () let extend_lock_store (e:inames) (l:lock_store{e `inames_in` l}) (p:slprop) : i:iname & l':lock_store { lock_store_invariant e l' == p `star` lock_store_invariant e l /\ iname_for_p i p l' } = (| L.length l, Invariant p :: l |) let set_add (i:iname) (s:inames) = Set.union (Set.singleton i) s let rec move_invariant (e:inames) (l:lock_store) (p:slprop) (i:iname{iname_for_p i p l /\ ~(i `Set.mem` e)}) : Lemma (H.equiv (lock_store_invariant e l) (p `star` lock_store_invariant (set_add i e) l)) = let rec aux (i:iname) (m:lock_store) : Lemma (requires i >= L.length m) (ensures (lock_store_invariant e m `H.equiv` lock_store_invariant (set_add i e) m)) = match m with | [] -> () | Invariant p::tl -> aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl) in let current_addr = L.length l - 1 in match l with | [] -> () | Invariant q::tl -> if i = current_addr then begin assert (lock_store_invariant e l == p `star` lock_store_invariant e tl); aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl); () end else begin move_invariant e tl p i; assert (lock_store_invariant e tl `equiv` (p `star` lock_store_invariant (set_add i e) tl)); H.star_congruence q (lock_store_invariant e tl) q (p `star` lock_store_invariant (set_add i e) tl); if Set.mem current_addr e then () else begin let r = lock_store_invariant (set_add i e) tl in assert (lock_store_invariant e l `equiv` (q `star` (p `star` r))); H.star_associative q p r; H.star_commutative q p; H.star_congruence (q `star` p) r (p `star` q) r; H.star_associative p q r end end let heap_ctr_valid (ctr:nat) (h:H.heap u#a) : prop = h `H.free_above_addr` ctr let ctr_validity (ctr:nat) (h:H.heap) : slprop = H.pure (heap_ctr_valid ctr h) let locks_invariant (e:inames) (m:mem u#a) : slprop u#a = lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m) let full_mem_pred (m:mem) = H.full_heap_pred (heap_of_mem m) (***** Following lemmas are needed in Steel.Effect *****) let core_mem_interp (hp:slprop u#a) (m:mem u#a) = () let interp_depends_only_on (hp:slprop u#a) = H.interp_depends_only_on hp let a_mem_prop_as_a_heap_prop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (H.a_heap_prop u#a) = let g (h: H.heap u#a) : Tot prop = interp sl (mem_of_heap h) /\ f (mem_of_heap h) in let phi0 (h0 h1: H.heap u#a) : Lemma (requires (g h0 /\ H.disjoint h0 h1)) (ensures (g h0 /\ H.disjoint h0 h1 /\ g (H.join h0 h1))) = assert (mem_of_heap (H.join h0 h1) == mem_of_heap h0 `join` mem_of_heap h1); interp_depends_only_on sl in let phi1 (h0 h1: H.heap u#a) : Lemma (ensures ((g h0 /\ H.disjoint h0 h1) ==> g (H.join h0 h1))) = Classical.move_requires (phi0 h0) h1 in Classical.forall_intro_2 phi1; g let refine_slprop sl f = H.as_slprop (a_mem_prop_as_a_heap_prop sl f) let interp_refine_slprop sl f m = assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_mem m)) let dep_hprop (s: slprop) (f: (hmem s -> Tot slprop)) (h: H.heap) : Tot prop = exists (h1: H.heap) . exists (h2: H.heap) . interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 let dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq' : squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h')) = let p2 (h h1 h2: H.heap) : Tot prop = interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 in let p1 (h h1: H.heap) : Tot prop = (exists h2 . p2 h h1 h2) in let h1 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p1 h) in let h2 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p2 h h1) in H.disjoint_join h' h1 h2; assert (H.disjoint h2 h'); let h2' = H.join h2 h' in H.join_commutative h2 h' ; assert (h2' == H.join h' h2); assert (H.disjoint h1 h2'); assert (mem_of_heap h2' == mem_of_heap h2 `join` mem_of_heap h'); interp_depends_only_on (f (mem_of_heap h1)); assert (interp (f (mem_of_heap h1)) (mem_of_heap h2')); H.join_commutative h1 h2; H.join_associative h' h2 h1; H.join_commutative h' h; H.join_commutative h2' h1; assert (H.join h h' == h1 `H.join` h2') let impl_intro_gen (#p: Type0) (#q: Type0) ($prf: (squash p -> Lemma (q ))) : Lemma (p ==> q) = Classical.impl_intro_gen #p #(fun _ -> q) prf let dep_hprop_is_affine1 (s: slprop) (f: (hmem s -> Tot slprop)) (h0 h1: H.heap) : Lemma ((dep_hprop s f h0 /\ H.disjoint h0 h1) ==> (H.disjoint h0 h1 /\ dep_hprop s f (H.join h0 h1))) = impl_intro_gen (dep_hprop_is_affine0 s f h0 h1) let dep_hprop_is_affine (s: slprop) (f: (hmem s -> Tot slprop)) : Lemma (H.heap_prop_is_affine (dep_hprop s f)) = Classical.forall_intro_2 (dep_hprop_is_affine1 s f) let sdep (s: slprop) (f: (hmem s -> Tot slprop)) : Tot slprop = dep_hprop_is_affine s f; H.as_slprop (dep_hprop s f) let interp_sdep (s: slprop) (f: (hmem s -> Tot slprop)) (m: mem) : Lemma (requires (dep_slprop_is_affine s f)) (ensures ( interp (sdep s f) m <==> (exists m1 m2 . interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) )) = dep_hprop_is_affine s f; assert (forall m1 m2 . (interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) ==> ( interp s (mem_of_heap m1.heap) /\ interp (f (mem_of_heap m1.heap)) (mem_of_heap m2.heap) /\ H.disjoint m1.heap m2.heap /\ H.join m1.heap m2.heap == m.heap )); interp_depends_only_on s; Classical.forall_intro (fun m -> interp_depends_only_on (f m)); assert (forall h1 h2 . (interp s (mem_of_heap h1) /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ H.disjoint h1 h2 /\ H.join h1 h2 == m.heap) ==> ( core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ interp s (core_mem (mem_of_heap h1)) /\ interp s (mem_set_heap m h1) /\ core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ f (mem_set_heap m h1) `equiv` f (mem_of_heap h1) /\ interp (f (mem_set_heap m h1)) (mem_of_heap h2) /\ interp (f (mem_set_heap m h1)) (mem_set_heap m h2) /\ disjoint (mem_set_heap m h1) (mem_set_heap m h2) /\ join (mem_set_heap m h1) (mem_set_heap m h2) == m )); () let h_exists_cong (#a:Type) (p q : a -> slprop) : Lemma (requires (forall x. p x `equiv` q x)) (ensures (h_exists p `equiv` h_exists q)) = equiv_heap_iff_equiv_forall (); H.h_exists_cong p q let intro_h_exists #a x p m = H.intro_h_exists x p (heap_of_mem m) let elim_h_exists (#a:_) (p:a -> slprop) (m:mem) = H.elim_h_exists p (heap_of_mem m) let intro_h_forall (#a:_) (p:a -> slprop) (m:mem) = H.intro_h_forall p (heap_of_mem m) let elim_h_forall (#a:_) (p:a -> slprop) (m:mem) (x:a) = H.elim_h_forall p (heap_of_mem m) x let intro_h_and (p q: slprop) (m:mem) = H.intro_h_and p q (heap_of_mem m) let elim_h_and (p q: slprop) (m:mem) = H.elim_h_and p q (heap_of_mem m) let intro_h_or_left (p q: slprop) (m:mem) = H.intro_h_or_left p q (heap_of_mem m) let intro_h_or_right (p q: slprop) (m:mem) = H.intro_h_or_right p q (heap_of_mem m) let elim_h_or (p q: slprop) (m:mem) = H.elim_h_or p q (heap_of_mem m) let intro_wand (p1 p2: slprop u#a) (m:mem) = introduce (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)) ==> interp (wand p1 p2) m with _. ( assert (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)); H.intro_wand p1 p2 (heap_of_mem m); let h = heap_of_mem m in assert ((forall h1. h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) ==> H.interp (wand p1 p2) h); introduce forall h1. (h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) with ( introduce (h `H.disjoint` h1 /\ H.interp p1 h1) ==> H.interp p2 (H.join h h1) with _. ( assert (h `H.disjoint` h1); let m1 = { ctr = m.ctr; heap = h1; locks = m.locks } in assert (m `disjoint` m1) ) ) ) (** Eliminating a wand by proving a heap that satisfies the LHS **) let elim_wand (p1 p2: slprop u#a) (m:mem) (m1:mem) = H.elim_wand p1 p2 (heap_of_mem m) (heap_of_mem m1) //////////////////////////////////////////////////////////////////////////////// // Preorders and effects //////////////////////////////////////////////////////////////////////////////// module PP = Steel.Preorder let mem_evolves = fun (m0 m1:full_mem) -> H.heap_evolves (heap_of_mem m0) (heap_of_mem m1) /\ m0.ctr <= m1.ctr /\ lock_store_evolves m0.locks m1.locks (** See [Steel.Heap.is_frame_preserving]. We add in [lock_invariants] now *) let preserves_frame (e:inames) (pre post:slprop) (m0 m1:mem) = forall (frame:slprop). interp ((pre `star` frame) `star` locks_invariant e m0) m0 ==> (interp ((post `star` frame) `star` locks_invariant e m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) (** This is a version of MstTot with frame quantified, as part of preserves_frame *) effect MstTotNF (a:Type u#a) (except:inames) (expects:slprop u#1) (provides: a -> slprop u#1) = NMSTTotal.NMSTATETOT a (full_mem u#1) mem_evolves (requires fun m0 -> inames_ok except m0 /\ interp (expects `star` locks_invariant except m0) m0) (ensures fun m0 x m1 -> inames_ok except m1 /\ interp (provides x `star` locks_invariant except m1) m1 /\ preserves_frame except expects (provides x) m0 m1) //////////////////////////////////////////////////////////////////////////////// // Lifting heap actions //////////////////////////////////////////////////////////////////////////////// (** Heap actions come in two equivalent flavors: - one that take an explicit frame as argument (action_with_frame) - and one that quantify over all the frame We therefore define two lift routes: - a direct route for those with explicit frame - via MstTotNF for the rest *) let tot_pre_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = hmem_with_inv_except e fp -> (x:a & hmem_with_inv_except e (fp' x)) let tot_pre_action_nf = tot_pre_action_nf_except S.empty let ac_reasoning_for_m_frame_preserving (p q r:slprop u#a) (m:mem u#a) : Lemma (requires interp ((p `star` q) `star` r) m) (ensures interp (p `star` r) m) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_commutative p q; equiv_extensional_on_star (p `star` q) (q `star` p) r } (q `star` p) `star` r; (equiv) { star_associative q p r } q `star` (p `star` r); }; assert (interp (q `star` (p `star` r)) m); affine_star q (p `star` r) m let is_frame_preserving (#e:inames) (#a:Type u#b) (#fp:slprop u#a) (#fp':a -> slprop u#a) (f:tot_pre_action_nf_except e fp a fp') = forall (frame:slprop u#a) (m0:hmem_with_inv_except e (fp `star` frame)). (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = f:tot_pre_action_nf_except e fp a fp'{ is_frame_preserving f } let tot_action_nf = tot_action_nf_except S.empty let linv e (m:mem) = locks_invariant e m let hheap_of_hmem #fp #e (m:hmem_with_inv_except e fp) : h:H.hheap (fp `star` linv e m) { h `H.free_above_addr` m.ctr} = let h = heap_of_mem m in H.pure_interp (heap_ctr_valid m.ctr (heap_of_mem m)) h; h let hmem_of_hheap #e (#fp0 #fp1:slprop) (m:hmem_with_inv_except e fp0) (h:H.full_hheap (fp1 `star` linv e m) { h `Heap.free_above_addr` m.ctr }) : m1:hmem_with_inv_except e fp1{linv e m `equiv` linv e m1} = let m1 : mem = { m with heap = h } in assert (interp (fp1 `star` linv e m) m1); star_commutative fp1 (linv e m); assert (interp (linv e m `star` fp1) m1); assert (linv e m1 == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); assert (linv e m == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m)); H.pure_interp (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_of_mem m); assert (heap_ctr_valid m1.ctr (heap_of_mem m) <==> heap_ctr_valid m1.ctr (heap_of_mem m1)); H.pure_equiv (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_ctr_valid m1.ctr (heap_of_mem m1)); H.star_congruence (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m)); assert (linv e m `equiv` linv e m1); let _ = equiv_extensional_on_star (linv e m) (linv e m1) fp1 in assert ((linv e m `star` fp1) `equiv` (linv e m1 `star` fp1)); assert (interp (linv e m1 `star` fp1) m1); star_commutative (linv e m1) fp1; assert (interp (fp1 `star` linv e m1) m1); m1 let with_inv_except (m:mem) e (fp:slprop) = interp (fp `star` locks_invariant e m) m #push-options "--warn_error -271" let as_hprop (frame:slprop) (mp:mprop frame) : hp:H.hprop frame{forall m. mp (core_mem m) == hp (heap_of_mem m)} = let f = fun h -> mp (mem_of_heap h) in assert (forall m. mp (core_mem m) == f (heap_of_mem m)); let aux (m0:H.hheap frame) (m1:H.heap{H.disjoint m0 m1}) : Lemma (ensures (mem_of_heap (H.join m0 m1) == join (mem_of_heap m0) (mem_of_heap m1))) [SMTPat ()] = () in f let mprop_preservation_of_hprop_preservation (p:slprop) (m0 m1:mem) : Lemma (requires (forall (hp:H.hprop p). hp (heap_of_mem m0) == hp (heap_of_mem m1))) (ensures (forall (mp:mprop p). mp (core_mem m0) == mp (core_mem m1))) = let aux (mp:mprop p) : Lemma (mp (core_mem m0) == mp (core_mem m1)) [SMTPat()] = assert (as_hprop p mp (heap_of_mem m0) == as_hprop p mp (heap_of_mem m1)) in () let lift_heap_action (#fp:slprop) (#a:Type) (#fp':a -> slprop) (e:inames) ($f:H.action fp a fp') : tot_action_nf_except e fp a fp' = let g : tot_pre_action_nf_except e fp a fp' = fun m -> let h0 = hheap_of_hmem m in let (| x, h' |) = f h0 in (| x, hmem_of_hheap m h' |) in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in let h0 = hheap_of_hmem m0 in let (| x', h1 |) = f h0 in H.action_framing f (linv e m0) h0; assert (x == x'); star_associative fp frame (linv e m0); H.action_framing f (frame `star` linv e m0) h0; assert (H.interp ((fp' x) `star` (frame `star` linv e m0)) h1); star_associative (fp' x) frame (linv e m0); assert (H.interp ((fp' x `star` frame) `star` linv e m0) h1); let h1' : H.hheap ((fp' x `star` frame) `star` linv e m0) = h1 in assert (m1 == hmem_of_hheap m0 h1'); assert (with_inv_except m1 e (fp' x `star` frame)); assert (forall (hp:H.hprop frame). hp h0 == hp h1); mprop_preservation_of_hprop_preservation frame m0 m1; () in assert (is_frame_preserving g); g let frame_preserving_respects_preorder #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (m0:hmem_with_inv_except e fp) : Lemma (let (| x, m1 |) = f m0 in mem_evolves m0 m1) = let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1) = () in H.emp_unit fp; assert (interp (fp `star` linv e m0) m0); H.star_congruence (fp `star` emp) (linv e m0) fp (linv e m0); assert (interp ((fp `star` emp) `star` linv e m0) m0); aux emp m0 let lift_tot_action_nf #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') : MstTotNF a e fp fp' = let m0 = NMSTTotal.get () in let m0' : hmem_with_inv_except e fp = m0 in let r = f m0' in let (| x, m1 |) = r in let m1' : hmem_with_inv_except e (fp' x) = m1 in assert (is_frame_preserving f); assert (m1 == dsnd (f m0)); frame_preserving_respects_preorder f m0; NMSTTotal.put #_ #(mem_evolves) m1; x let lift_tot_action #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get #(full_mem) #_ () in ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); lift_tot_action_nf f (** Now defining the lift for heap actions with explicit frame *) let tot_action_with_frame_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = frame:slprop u#a -> m0:hmem_with_inv_except e (fp `star` frame) -> Pure (x:a & hmem_with_inv_except e (fp' x `star` frame)) (requires True) (ensures fun (| x, m1 |) -> mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_with_frame = tot_action_with_frame_except S.empty let lift_heap_action_with_frame (#fp:slprop u#a) (#a:Type u#b) (#fp':a -> slprop u#a) (e:inames) ($f:H.action_with_frame fp a fp') : tot_action_with_frame_except e fp a fp' = fun frame m0 -> let h0 = hheap_of_hmem m0 in calc (equiv) { fp `star` frame `star` locks_invariant e m0; (equiv) { star_associative fp frame (locks_invariant e m0) } fp `star` (frame `star` locks_invariant e m0); }; assert (H.interp (fp `star` frame `star` locks_invariant e m0) h0); assert (H.interp (fp `star` (frame `star` locks_invariant e m0)) h0); //key: apply the heap action with frame * locks_invariant e m0 let (| x, h1 |) = f (frame `star` locks_invariant e m0) h0 in calc (equiv) { fp' x `star` (frame `star` locks_invariant e m0); (equiv) { star_associative (fp' x) frame (locks_invariant e m0) } fp' x `star` frame `star` locks_invariant e m0; }; assert (H.interp (fp' x `star` (frame `star` locks_invariant e m0)) h1); assert (H.interp (fp' x `star` frame `star` locks_invariant e m0) h1); let m1 = hmem_of_hheap m0 h1 in assert (mem_evolves m0 m1); mprop_preservation_of_hprop_preservation (frame `star` locks_invariant e m0) m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)); (| x, m1 |) let lift_tot_action_with_frame #a #e #fp #fp' ($f:tot_action_with_frame_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in assert (inames_ok e m0); ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); let m0' : hmem_with_inv_except e fp = m0 in let r = f frame m0' in let (| x, m1 |) = r in ac_reasoning_for_m_frame_preserving (fp' x) frame (locks_invariant e m1) m1; assert (interp (fp' x `star` frame `star` locks_invariant e m1) m1); assert (interp (fp' x `star` locks_invariant e m1) m1); let m1' : hmem_with_inv_except e (fp' x) = m1 in NMSTTotal.put #_ #(mem_evolves) m1; x let sel_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.sel_action #a #pcm r v0)) let upd_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.upd_action #a #pcm r v0 v1)) let free_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.free_action #a #pcm r v0)) let split_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.split_action #a #pcm r v0 v1)) let gather_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.gather_action #a #pcm r v0 v1)) let weaken (p q r:slprop) (h:H.hheap (p `star` q) { H.stronger q r }) : H.hheap (p `star` r) = H.weaken p q r h; h let weaken_pure (q r: prop) : Lemma (requires (q ==> r)) (ensures H.stronger (H.pure q) (H.pure r)) = let aux (h:H.heap) : Lemma (ensures (H.interp (H.pure q) h ==> H.interp (H.pure r) h)) [SMTPat ()] = H.pure_interp q h; H.pure_interp r h in () let inc_ctr (#p:slprop) #e (m:hmem_with_inv_except e p) : m':hmem_with_inv_except e p{m'.ctr = m.ctr + 1 /\ H.stronger (linv e m) (linv e m')} = let m' : mem = { m with ctr = m.ctr + 1} in assert (interp (p `star` linv e m) m'); assert (linv e m == lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m)); assert (linv e m' == lock_store_invariant e m.locks `star` ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken_free_above (heap_of_mem m) m.ctr (m.ctr + 1); weaken_pure (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_ctr_valid (m.ctr + 1) (heap_of_mem m)); assert (H.stronger (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m))); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)); H.stronger_star (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken (p `star` lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)) (heap_of_mem m'); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity (m.ctr + 1) (heap_of_mem m)); let m' : hmem_with_inv_except e p = m' in m' let frame_related_mems (fp0 fp1:slprop u#a) e (m0:hmem_with_inv_except e fp0) (m1:hmem_with_inv_except e fp1) = forall (frame:slprop u#a). interp ((fp0 `star` frame) `star` linv e m0) m0 ==> interp ((fp1 `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) let refined_pre_action e (fp0:slprop) (a:Type) (fp1:a -> slprop) = m0:hmem_with_inv_except e fp0 -> Pure (x:a & hmem_with_inv_except e (fp1 x)) (requires True) (ensures fun (| x, m1 |) -> frame_related_mems fp0 (fp1 x) e m0 m1) let refined_pre_action_as_action (#fp0:slprop) (#a:Type) (#fp1:a -> slprop) #e ($f:refined_pre_action e fp0 a fp1) : tot_action_nf_except e fp0 a fp1 = let g : tot_pre_action_nf_except e fp0 a fp1 = fun m -> f m in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp0 `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp1 x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x', m1' |) = g m0 in let (| x, m1 |) = f m0 in assert (x == x' /\ m1 == m1') in g let alloc_action #a #pcm e x = let f : refined_pre_action e emp (ref a pcm) (fun r -> pts_to r x) = fun m0 -> (* NS: 9/29/22 I needed to annotate h : Heap.full_heap, for use with the Core checker which generates a guard for checking the implicit pattern "dot" term in the dependent pair pattern on the next line. That guard expects `h` to be a full_heap, which is it, because it is a projection of m0. However, this is not reflected in `h`'s type. So, the Core checker, which produces a guard for the pat_dot_term in isolation, cannot recheck the term. If we were to fold in the checking of pat_dot_terms and their guards with the rest of the VC, this would work. *) let h : Heap.full_heap = hheap_of_hmem m0 in let (|r, h'|) = H.extend #a #pcm x m0.ctr h in let m' : hmem_with_inv_except e emp = inc_ctr m0 in let h' : H.hheap (pts_to #a #pcm r x `star` linv e m') = weaken _ (linv e m0) (linv e m') h' in let m1 : hmem_with_inv_except e (pts_to #a #pcm r x) = hmem_of_hheap m' h' in assert (forall frame. H.frame_related_heaps h h' emp (pts_to #a #pcm r x) frame true); let aux (frame:slprop) : Lemma (requires interp ((emp `star` frame) `star` linv e m0) m0) (ensures interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) [SMTPat (emp `star` frame)] = star_associative emp frame (linv e m0); assert (H.interp (emp `star` (frame `star` linv e m0)) h); assert (H.interp (pts_to #a #pcm r x `star` (frame `star` linv e m0)) h'); star_associative (pts_to #a #pcm r x) frame (linv e m0); assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m0) h'); assert (H.stronger (linv e m0) (linv e m')); assert (H.equiv (linv e m') (linv e m1)); assert (H.stronger (linv e m0) (linv e m1)); let h' : H.hheap ((pts_to #a #pcm r x `star` frame) `star` linv e m1) = weaken _ (linv e m0) (linv e m1) h' in assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) h'); assert (forall (mp:H.hprop frame). mp h == mp h'); mprop_preservation_of_hprop_preservation frame m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) in assert (frame_related_mems emp (pts_to r x) e m0 m1); (| r, m1 |) in lift_tot_action (refined_pre_action_as_action f) let select_refine #a #p e r x f = lift_tot_action (lift_heap_action e (H.select_refine #a #p r x f)) let upd_gen #a #p e r x y f = lift_tot_action (lift_heap_action e (H.upd_gen_action r x y f)) //////////////////////////////////////////////////////////////////////////////// // witness / recall //////////////////////////////////////////////////////////////////////////////// let witnessed_ref #a #pcm (r:ref a pcm) (fact:property a) (m:full_mem) = H.witnessed_ref #a #pcm r fact (heap_of_mem m) let witnessed_ref_stability #a #pcm (r:ref a pcm) (fact:property a) : Lemma (requires FStar.Preorder.stable fact (Steel.Preorder.preorder_of_pcm pcm)) (ensures FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) = H.witnessed_ref_stability #a #pcm r fact let witnessed (#a:Type u#1) (#pcm:pcm a) (r:ref a pcm) (fact:property a) = W.witnessed _ mem_evolves (witnessed_ref r fact) let rearrange_pqr_prq (p q r:slprop) : Lemma (((p `star` q) `star` r) `equiv` ((p `star` r) `star` q)) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_associative p q r } p `star` (q `star` r); (equiv) { star_commutative q r; star_congruence p (q `star` r) p (r `star` q) } p `star` (r `star` q); (equiv) { star_associative p r q } (p `star` r) `star` q; } let preserves_frame_cong (e:inames) (p q:slprop) (r s:slprop) (m0 m1:mem) : Lemma (requires p `equiv` r /\ q `equiv` s /\ preserves_frame e p q m0 m1) (ensures preserves_frame e r s m0 m1) = let aux0 (p q r s:slprop) : Lemma (requires p `equiv` s) (ensures (((p `star` q) `star` r) `equiv` ((s `star` q) `star` r))) = star_congruence p q s q; star_congruence (p `star` q) r (s `star` q) r in let aux (frame:slprop) : Lemma (requires interp ((r `star` frame) `star` locks_invariant e m0) m0) (ensures interp ((s `star` frame) `star` locks_invariant e m1) m1 /\ interp ((p `star` frame) `star` locks_invariant e m0) m0) [SMTPat (r `star` frame)] = aux0 p frame (locks_invariant e m0) r; aux0 q frame (locks_invariant e m1) s; assert (((p `star` frame) `star` locks_invariant e m0) `equiv` ((r `star` frame) `star` locks_invariant e m0)); assert (interp ((p `star` frame) `star` locks_invariant e m0) m0); assert (interp ((q `star` frame) `star` locks_invariant e m1) m1); assert (((q `star` frame) `star` locks_invariant e m1) `equiv` ((s `star` frame) `star` locks_invariant e m1)); () in () let pure_true_equiv (p:slprop) : Lemma ((p `star` pure True) `equiv` p) = FStar.Classical.forall_intro (pure_star_interp p True); emp_unit p; assert ((p `star` pure True) `equiv` p)

{ "checked_file": "/", "dependencies": [ "Steel.Preorder.fst.checked", "Steel.Heap.fsti.checked", "prims.fst.checked", "FStar.Witnessed.Core.fsti.checked", "FStar.Set.fsti.checked", "FStar.Preorder.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.PCM.fst.checked", "FStar.NMSTTotal.fst.checked", "FStar.List.Tot.fst.checked", "FStar.IndefiniteDescription.fsti.checked", "FStar.Ghost.fsti.checked", "FStar.FunctionalExtensionality.fsti.checked", "FStar.Classical.Sugar.fsti.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Steel.Memory.fst" }

[ { "abbrev": true, "full_module": "Steel.Preorder", "short_module": "PP" }, { "abbrev": true, "full_module": "FStar.Witnessed.Core", "short_module": "W" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": true, "full_module": "Steel.Heap", "short_module": "H" }, { "abbrev": false, "full_module": "FStar.PCM", "short_module": null }, { "abbrev": false, "full_module": "FStar.FunctionalExtensionality", "short_module": null }, { "abbrev": true, "full_module": "FStar.FunctionalExtensionality", "short_module": "F" }, { "abbrev": false, "full_module": "FStar.PCM", "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

e: Steel.Memory.inames -> p: Steel.Memory.slprop -> q: Steel.Memory.slprop -> r: Prims.prop -> s: Prims.prop -> m: Steel.Memory.mem -> FStar.Pervasives.Lemma (requires r /\ s) (ensures Steel.Memory.preserves_frame e p q m m <==> Steel.Memory.preserves_frame e (Steel.Memory.star p (Steel.Memory.pure r)) (Steel.Memory.star q (Steel.Memory.pure s)) m m)

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Steel.Memory.inames", "Steel.Memory.slprop", "Prims.prop", "Steel.Memory.mem", "Prims.unit", "Steel.Memory.preserves_frame", "Steel.Memory.star", "Steel.Memory.pure", "Prims.squash", "Prims.Cons", "FStar.Pervasives.pattern", "FStar.Pervasives.smt_pat", "Prims.Nil", "Steel.Memory.preserves_frame_cong", "Steel.Memory.pure_true_equiv", "Steel.Memory.star_congruence", "Prims.l_True", "Steel.Memory.pure_equiv", "Prims.l_and", "Prims.l_iff" ]

[]

false

true

false

let preserves_frame_star_pure (e: inames) (p q: slprop) (r s: prop) (m: mem) : Lemma (requires r /\ s) (ensures preserves_frame e p q m m <==> preserves_frame e (p `star` (pure r)) (q `star` (pure s)) m m ) =

pure_equiv r True; star_congruence p (pure r) p (pure True); pure_equiv s True; star_congruence q (pure s) q (pure True); pure_true_equiv p; pure_true_equiv q; let fwd () : Lemma (requires preserves_frame e p q m m) (ensures preserves_frame e (p `star` (pure r)) (q `star` (pure s)) m m) [SMTPat ()] = preserves_frame_cong e p q (p `star` (pure r)) (q `star` (pure s)) m m in let bk () : Lemma (requires preserves_frame e (p `star` (pure r)) (q `star` (pure s)) m m) (ensures preserves_frame e p q m m) [SMTPat ()] = preserves_frame_cong e (p `star` (pure r)) (q `star` (pure s)) p q m m in ()

false

Steel.Memory.fst

Steel.Memory.preserves_frame_cong

val preserves_frame_cong (e: inames) (p q r s: slprop) (m0 m1: mem) : Lemma (requires p `equiv` r /\ q `equiv` s /\ preserves_frame e p q m0 m1) (ensures preserves_frame e r s m0 m1)

let preserves_frame_cong (e:inames) (p q:slprop) (r s:slprop) (m0 m1:mem) : Lemma (requires p `equiv` r /\ q `equiv` s /\ preserves_frame e p q m0 m1) (ensures preserves_frame e r s m0 m1) = let aux0 (p q r s:slprop) : Lemma (requires p `equiv` s) (ensures (((p `star` q) `star` r) `equiv` ((s `star` q) `star` r))) = star_congruence p q s q; star_congruence (p `star` q) r (s `star` q) r in let aux (frame:slprop) : Lemma (requires interp ((r `star` frame) `star` locks_invariant e m0) m0) (ensures interp ((s `star` frame) `star` locks_invariant e m1) m1 /\ interp ((p `star` frame) `star` locks_invariant e m0) m0) [SMTPat (r `star` frame)] = aux0 p frame (locks_invariant e m0) r; aux0 q frame (locks_invariant e m1) s; assert (((p `star` frame) `star` locks_invariant e m0) `equiv` ((r `star` frame) `star` locks_invariant e m0)); assert (interp ((p `star` frame) `star` locks_invariant e m0) m0); assert (interp ((q `star` frame) `star` locks_invariant e m1) m1); assert (((q `star` frame) `star` locks_invariant e m1) `equiv` ((s `star` frame) `star` locks_invariant e m1)); () in ()

{ "file_name": "lib/steel/Steel.Memory.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 6, "end_line": 1056, "start_col": 0, "start_line": 1028 }

(* 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.Memory module F = FStar.FunctionalExtensionality open FStar.FunctionalExtensionality open FStar.PCM module H = Steel.Heap noeq type lock_state : Type u#(a + 1) = | Invariant : inv:H.slprop u#a -> lock_state let lock_store : Type u#(a+1) = list (lock_state u#a) noeq type mem : Type u#(a + 1) = { ctr: nat; heap: H.heap u#a; locks: lock_store u#a; } let heap_of_mem (x:mem) : H.heap = x.heap let mem_of_heap (h:H.heap) : mem = { ctr = 0; heap = h; locks = [] } let mem_set_heap (m:mem) (h:H.heap) : mem = { ctr = m.ctr; heap = h; locks = m.locks; } let core_mem (m:mem) : mem = mem_of_heap (heap_of_mem m) let core_mem_invol m = () let disjoint (m0 m1:mem u#h) : prop = m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks let disjoint_sym m0 m1 = () let join m0 m1 = { ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = m0.locks } let join_commutative m0 m1 = H.join_commutative m0.heap m1.heap let disjoint_join m0 m1 m2 = H.disjoint_join m0.heap m1.heap m2.heap let join_associative m0 m1 m2 = H.join_associative m0.heap m1.heap m2.heap let slprop = H.slprop let interp p m = H.interp p m.heap let equiv p1 p2 = forall m. interp p1 m <==> interp p2 m let slprop_extensionality p q = assert (forall m. interp p m <==> interp q m); let aux (h:H.heap) : Lemma (H.interp p h <==> H.interp q h) [SMTPat (H.interp p h)] = let m : mem = { ctr = 0; heap = h; locks = [] } in assert (interp p m <==> interp q m) in assert (forall h. H.interp p h <==> H.interp q h); Steel.Heap.slprop_extensionality p q let reveal_equiv p1 p2 = () let core_ref = H.core_ref let core_ref_null = H.core_ref_null let core_ref_is_null r = H.core_ref_is_null r let emp : slprop u#a = H.emp let pure = H.pure let pts_to = H.pts_to let h_and = H.h_and let h_or = H.h_or let star = H.star let wand = H.wand let h_exists = H.h_exists let h_forall = H.h_forall //////////////////////////////////////////////////////////////////////////////// //properties of equiv //////////////////////////////////////////////////////////////////////////////// let equiv_symmetric (p1 p2:slprop u#a) = H.equiv_symmetric p1 p2 #push-options "--warn_error -271" let equiv_heap_iff_equiv (p1 p2:slprop u#a) : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat (equiv p1 p2)] = let aux_lr () : Lemma (requires H.equiv p1 p2) (ensures equiv p1 p2) [SMTPat ()] = () in let aux_rl_helper1 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p1 h) (ensures H.interp p2 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl_helper2 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p2 h) (ensures H.interp p1 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl () : Lemma (requires equiv p1 p2) (ensures H.equiv p1 p2) [SMTPat ()] = () in () let equiv_heap_iff_equiv_forall () : Lemma (ensures (forall p1 p2. H.equiv p1 p2 <==> equiv p1 p2)) = let aux p1 p2 : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat ()] = equiv_heap_iff_equiv p1 p2 in () #pop-options let equiv_extensional_on_star (p1 p2 p3:slprop u#a) = equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3 let emp_unit p = H.emp_unit p let intro_emp m = H.intro_emp (heap_of_mem m) let pure_equiv p q = H.pure_equiv p q let pure_interp q m = H.pure_interp q (heap_of_mem m) let pure_star_interp p q m = H.pure_star_interp p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// //pts_to //////////////////////////////////////////////////////////////////////////////// let pts_to_compatible #a #pcm x v0 v1 m = H.pts_to_compatible #a #pcm x v0 v1 (heap_of_mem m) let pts_to_compatible_equiv #a #pcm x v0 v1 = H.pts_to_compatible_equiv #a #pcm x v0 v1 let pts_to_not_null #a #pcm x v m = H.pts_to_not_null #a #pcm x v (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // star //////////////////////////////////////////////////////////////////////////////// let intro_star p q mp mq = H.intro_star p q (heap_of_mem mp) (heap_of_mem mq) let elim_star p q m = let h = heap_of_mem m in H.elim_star p q h; assert (exists hl hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr); let hl = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hl -> exists hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let hr = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hr -> H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let ml = mem_set_heap m hl in let mr = mem_set_heap m hr in assert (disjoint ml mr); assert (m == join ml mr); assert (interp p ml); assert (interp q mr); () let interp_star (p q: slprop) (m: mem) : Lemma (interp (p `star` q) m <==> (exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m)) = let left = interp (p `star` q) m in let right = exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m in let f () : Lemma (requires left) (ensures right) = elim_star p q m in let g () : Lemma (requires right) (ensures left) = Classical.exists_elim left #_ #(fun mp -> exists (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mp -> Classical.exists_elim left #_ #(fun mq -> disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mq -> intro_star p q mp mq ) ) in Classical.move_requires f (); Classical.move_requires g () let star_commutative (p1 p2:slprop) = H.star_commutative p1 p2 let star_associative (p1 p2 p3:slprop) = H.star_associative p1 p2 p3 let star_congruence (p1 p2 p3 p4:slprop) = equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4 let affine_star (p q:slprop) (m:mem) = H.affine_star p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // Invariants on the lock store //////////////////////////////////////////////////////////////////////////////// let iname = nat module S = FStar.Set module L = FStar.List.Tot module W = FStar.Witnessed.Core let rec lock_store_invariant (e:inames) (l:lock_store u#a) : slprop u#a = let current_addr = L.length l - 1 in match l with | [] -> emp | Invariant p :: tl -> if current_addr `S.mem` e then lock_store_invariant e tl else p `star` lock_store_invariant e tl let lock_i (i:iname) (l:lock_store { i < L.length l }) = let ix = L.length l - i - 1 in L.index l ix let iname_for_p (i:iname) (p:slprop) : W.s_predicate lock_store = fun l -> i < L.length l /\ (lock_i i l).inv == p let lock_store_evolves : FStar.Preorder.preorder lock_store = fun (l1 l2 : lock_store) -> L.length l2 >= L.length l1 /\ (forall (i:nat{i < L.length l1}). (lock_i i l1).inv == (lock_i i l2).inv) let inames_in (e:inames) (l:lock_store) : prop = forall i. Set.mem i e ==> i < L.length l let inames_ok e m = inames_in e m.locks let inames_ok_empty m = () let extend_lock_store (e:inames) (l:lock_store{e `inames_in` l}) (p:slprop) : i:iname & l':lock_store { lock_store_invariant e l' == p `star` lock_store_invariant e l /\ iname_for_p i p l' } = (| L.length l, Invariant p :: l |) let set_add (i:iname) (s:inames) = Set.union (Set.singleton i) s let rec move_invariant (e:inames) (l:lock_store) (p:slprop) (i:iname{iname_for_p i p l /\ ~(i `Set.mem` e)}) : Lemma (H.equiv (lock_store_invariant e l) (p `star` lock_store_invariant (set_add i e) l)) = let rec aux (i:iname) (m:lock_store) : Lemma (requires i >= L.length m) (ensures (lock_store_invariant e m `H.equiv` lock_store_invariant (set_add i e) m)) = match m with | [] -> () | Invariant p::tl -> aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl) in let current_addr = L.length l - 1 in match l with | [] -> () | Invariant q::tl -> if i = current_addr then begin assert (lock_store_invariant e l == p `star` lock_store_invariant e tl); aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl); () end else begin move_invariant e tl p i; assert (lock_store_invariant e tl `equiv` (p `star` lock_store_invariant (set_add i e) tl)); H.star_congruence q (lock_store_invariant e tl) q (p `star` lock_store_invariant (set_add i e) tl); if Set.mem current_addr e then () else begin let r = lock_store_invariant (set_add i e) tl in assert (lock_store_invariant e l `equiv` (q `star` (p `star` r))); H.star_associative q p r; H.star_commutative q p; H.star_congruence (q `star` p) r (p `star` q) r; H.star_associative p q r end end let heap_ctr_valid (ctr:nat) (h:H.heap u#a) : prop = h `H.free_above_addr` ctr let ctr_validity (ctr:nat) (h:H.heap) : slprop = H.pure (heap_ctr_valid ctr h) let locks_invariant (e:inames) (m:mem u#a) : slprop u#a = lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m) let full_mem_pred (m:mem) = H.full_heap_pred (heap_of_mem m) (***** Following lemmas are needed in Steel.Effect *****) let core_mem_interp (hp:slprop u#a) (m:mem u#a) = () let interp_depends_only_on (hp:slprop u#a) = H.interp_depends_only_on hp let a_mem_prop_as_a_heap_prop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (H.a_heap_prop u#a) = let g (h: H.heap u#a) : Tot prop = interp sl (mem_of_heap h) /\ f (mem_of_heap h) in let phi0 (h0 h1: H.heap u#a) : Lemma (requires (g h0 /\ H.disjoint h0 h1)) (ensures (g h0 /\ H.disjoint h0 h1 /\ g (H.join h0 h1))) = assert (mem_of_heap (H.join h0 h1) == mem_of_heap h0 `join` mem_of_heap h1); interp_depends_only_on sl in let phi1 (h0 h1: H.heap u#a) : Lemma (ensures ((g h0 /\ H.disjoint h0 h1) ==> g (H.join h0 h1))) = Classical.move_requires (phi0 h0) h1 in Classical.forall_intro_2 phi1; g let refine_slprop sl f = H.as_slprop (a_mem_prop_as_a_heap_prop sl f) let interp_refine_slprop sl f m = assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_mem m)) let dep_hprop (s: slprop) (f: (hmem s -> Tot slprop)) (h: H.heap) : Tot prop = exists (h1: H.heap) . exists (h2: H.heap) . interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 let dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq' : squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h')) = let p2 (h h1 h2: H.heap) : Tot prop = interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 in let p1 (h h1: H.heap) : Tot prop = (exists h2 . p2 h h1 h2) in let h1 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p1 h) in let h2 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p2 h h1) in H.disjoint_join h' h1 h2; assert (H.disjoint h2 h'); let h2' = H.join h2 h' in H.join_commutative h2 h' ; assert (h2' == H.join h' h2); assert (H.disjoint h1 h2'); assert (mem_of_heap h2' == mem_of_heap h2 `join` mem_of_heap h'); interp_depends_only_on (f (mem_of_heap h1)); assert (interp (f (mem_of_heap h1)) (mem_of_heap h2')); H.join_commutative h1 h2; H.join_associative h' h2 h1; H.join_commutative h' h; H.join_commutative h2' h1; assert (H.join h h' == h1 `H.join` h2') let impl_intro_gen (#p: Type0) (#q: Type0) ($prf: (squash p -> Lemma (q ))) : Lemma (p ==> q) = Classical.impl_intro_gen #p #(fun _ -> q) prf let dep_hprop_is_affine1 (s: slprop) (f: (hmem s -> Tot slprop)) (h0 h1: H.heap) : Lemma ((dep_hprop s f h0 /\ H.disjoint h0 h1) ==> (H.disjoint h0 h1 /\ dep_hprop s f (H.join h0 h1))) = impl_intro_gen (dep_hprop_is_affine0 s f h0 h1) let dep_hprop_is_affine (s: slprop) (f: (hmem s -> Tot slprop)) : Lemma (H.heap_prop_is_affine (dep_hprop s f)) = Classical.forall_intro_2 (dep_hprop_is_affine1 s f) let sdep (s: slprop) (f: (hmem s -> Tot slprop)) : Tot slprop = dep_hprop_is_affine s f; H.as_slprop (dep_hprop s f) let interp_sdep (s: slprop) (f: (hmem s -> Tot slprop)) (m: mem) : Lemma (requires (dep_slprop_is_affine s f)) (ensures ( interp (sdep s f) m <==> (exists m1 m2 . interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) )) = dep_hprop_is_affine s f; assert (forall m1 m2 . (interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) ==> ( interp s (mem_of_heap m1.heap) /\ interp (f (mem_of_heap m1.heap)) (mem_of_heap m2.heap) /\ H.disjoint m1.heap m2.heap /\ H.join m1.heap m2.heap == m.heap )); interp_depends_only_on s; Classical.forall_intro (fun m -> interp_depends_only_on (f m)); assert (forall h1 h2 . (interp s (mem_of_heap h1) /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ H.disjoint h1 h2 /\ H.join h1 h2 == m.heap) ==> ( core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ interp s (core_mem (mem_of_heap h1)) /\ interp s (mem_set_heap m h1) /\ core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ f (mem_set_heap m h1) `equiv` f (mem_of_heap h1) /\ interp (f (mem_set_heap m h1)) (mem_of_heap h2) /\ interp (f (mem_set_heap m h1)) (mem_set_heap m h2) /\ disjoint (mem_set_heap m h1) (mem_set_heap m h2) /\ join (mem_set_heap m h1) (mem_set_heap m h2) == m )); () let h_exists_cong (#a:Type) (p q : a -> slprop) : Lemma (requires (forall x. p x `equiv` q x)) (ensures (h_exists p `equiv` h_exists q)) = equiv_heap_iff_equiv_forall (); H.h_exists_cong p q let intro_h_exists #a x p m = H.intro_h_exists x p (heap_of_mem m) let elim_h_exists (#a:_) (p:a -> slprop) (m:mem) = H.elim_h_exists p (heap_of_mem m) let intro_h_forall (#a:_) (p:a -> slprop) (m:mem) = H.intro_h_forall p (heap_of_mem m) let elim_h_forall (#a:_) (p:a -> slprop) (m:mem) (x:a) = H.elim_h_forall p (heap_of_mem m) x let intro_h_and (p q: slprop) (m:mem) = H.intro_h_and p q (heap_of_mem m) let elim_h_and (p q: slprop) (m:mem) = H.elim_h_and p q (heap_of_mem m) let intro_h_or_left (p q: slprop) (m:mem) = H.intro_h_or_left p q (heap_of_mem m) let intro_h_or_right (p q: slprop) (m:mem) = H.intro_h_or_right p q (heap_of_mem m) let elim_h_or (p q: slprop) (m:mem) = H.elim_h_or p q (heap_of_mem m) let intro_wand (p1 p2: slprop u#a) (m:mem) = introduce (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)) ==> interp (wand p1 p2) m with _. ( assert (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)); H.intro_wand p1 p2 (heap_of_mem m); let h = heap_of_mem m in assert ((forall h1. h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) ==> H.interp (wand p1 p2) h); introduce forall h1. (h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) with ( introduce (h `H.disjoint` h1 /\ H.interp p1 h1) ==> H.interp p2 (H.join h h1) with _. ( assert (h `H.disjoint` h1); let m1 = { ctr = m.ctr; heap = h1; locks = m.locks } in assert (m `disjoint` m1) ) ) ) (** Eliminating a wand by proving a heap that satisfies the LHS **) let elim_wand (p1 p2: slprop u#a) (m:mem) (m1:mem) = H.elim_wand p1 p2 (heap_of_mem m) (heap_of_mem m1) //////////////////////////////////////////////////////////////////////////////// // Preorders and effects //////////////////////////////////////////////////////////////////////////////// module PP = Steel.Preorder let mem_evolves = fun (m0 m1:full_mem) -> H.heap_evolves (heap_of_mem m0) (heap_of_mem m1) /\ m0.ctr <= m1.ctr /\ lock_store_evolves m0.locks m1.locks (** See [Steel.Heap.is_frame_preserving]. We add in [lock_invariants] now *) let preserves_frame (e:inames) (pre post:slprop) (m0 m1:mem) = forall (frame:slprop). interp ((pre `star` frame) `star` locks_invariant e m0) m0 ==> (interp ((post `star` frame) `star` locks_invariant e m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) (** This is a version of MstTot with frame quantified, as part of preserves_frame *) effect MstTotNF (a:Type u#a) (except:inames) (expects:slprop u#1) (provides: a -> slprop u#1) = NMSTTotal.NMSTATETOT a (full_mem u#1) mem_evolves (requires fun m0 -> inames_ok except m0 /\ interp (expects `star` locks_invariant except m0) m0) (ensures fun m0 x m1 -> inames_ok except m1 /\ interp (provides x `star` locks_invariant except m1) m1 /\ preserves_frame except expects (provides x) m0 m1) //////////////////////////////////////////////////////////////////////////////// // Lifting heap actions //////////////////////////////////////////////////////////////////////////////// (** Heap actions come in two equivalent flavors: - one that take an explicit frame as argument (action_with_frame) - and one that quantify over all the frame We therefore define two lift routes: - a direct route for those with explicit frame - via MstTotNF for the rest *) let tot_pre_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = hmem_with_inv_except e fp -> (x:a & hmem_with_inv_except e (fp' x)) let tot_pre_action_nf = tot_pre_action_nf_except S.empty let ac_reasoning_for_m_frame_preserving (p q r:slprop u#a) (m:mem u#a) : Lemma (requires interp ((p `star` q) `star` r) m) (ensures interp (p `star` r) m) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_commutative p q; equiv_extensional_on_star (p `star` q) (q `star` p) r } (q `star` p) `star` r; (equiv) { star_associative q p r } q `star` (p `star` r); }; assert (interp (q `star` (p `star` r)) m); affine_star q (p `star` r) m let is_frame_preserving (#e:inames) (#a:Type u#b) (#fp:slprop u#a) (#fp':a -> slprop u#a) (f:tot_pre_action_nf_except e fp a fp') = forall (frame:slprop u#a) (m0:hmem_with_inv_except e (fp `star` frame)). (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = f:tot_pre_action_nf_except e fp a fp'{ is_frame_preserving f } let tot_action_nf = tot_action_nf_except S.empty let linv e (m:mem) = locks_invariant e m let hheap_of_hmem #fp #e (m:hmem_with_inv_except e fp) : h:H.hheap (fp `star` linv e m) { h `H.free_above_addr` m.ctr} = let h = heap_of_mem m in H.pure_interp (heap_ctr_valid m.ctr (heap_of_mem m)) h; h let hmem_of_hheap #e (#fp0 #fp1:slprop) (m:hmem_with_inv_except e fp0) (h:H.full_hheap (fp1 `star` linv e m) { h `Heap.free_above_addr` m.ctr }) : m1:hmem_with_inv_except e fp1{linv e m `equiv` linv e m1} = let m1 : mem = { m with heap = h } in assert (interp (fp1 `star` linv e m) m1); star_commutative fp1 (linv e m); assert (interp (linv e m `star` fp1) m1); assert (linv e m1 == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); assert (linv e m == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m)); H.pure_interp (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_of_mem m); assert (heap_ctr_valid m1.ctr (heap_of_mem m) <==> heap_ctr_valid m1.ctr (heap_of_mem m1)); H.pure_equiv (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_ctr_valid m1.ctr (heap_of_mem m1)); H.star_congruence (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m)); assert (linv e m `equiv` linv e m1); let _ = equiv_extensional_on_star (linv e m) (linv e m1) fp1 in assert ((linv e m `star` fp1) `equiv` (linv e m1 `star` fp1)); assert (interp (linv e m1 `star` fp1) m1); star_commutative (linv e m1) fp1; assert (interp (fp1 `star` linv e m1) m1); m1 let with_inv_except (m:mem) e (fp:slprop) = interp (fp `star` locks_invariant e m) m #push-options "--warn_error -271" let as_hprop (frame:slprop) (mp:mprop frame) : hp:H.hprop frame{forall m. mp (core_mem m) == hp (heap_of_mem m)} = let f = fun h -> mp (mem_of_heap h) in assert (forall m. mp (core_mem m) == f (heap_of_mem m)); let aux (m0:H.hheap frame) (m1:H.heap{H.disjoint m0 m1}) : Lemma (ensures (mem_of_heap (H.join m0 m1) == join (mem_of_heap m0) (mem_of_heap m1))) [SMTPat ()] = () in f let mprop_preservation_of_hprop_preservation (p:slprop) (m0 m1:mem) : Lemma (requires (forall (hp:H.hprop p). hp (heap_of_mem m0) == hp (heap_of_mem m1))) (ensures (forall (mp:mprop p). mp (core_mem m0) == mp (core_mem m1))) = let aux (mp:mprop p) : Lemma (mp (core_mem m0) == mp (core_mem m1)) [SMTPat()] = assert (as_hprop p mp (heap_of_mem m0) == as_hprop p mp (heap_of_mem m1)) in () let lift_heap_action (#fp:slprop) (#a:Type) (#fp':a -> slprop) (e:inames) ($f:H.action fp a fp') : tot_action_nf_except e fp a fp' = let g : tot_pre_action_nf_except e fp a fp' = fun m -> let h0 = hheap_of_hmem m in let (| x, h' |) = f h0 in (| x, hmem_of_hheap m h' |) in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in let h0 = hheap_of_hmem m0 in let (| x', h1 |) = f h0 in H.action_framing f (linv e m0) h0; assert (x == x'); star_associative fp frame (linv e m0); H.action_framing f (frame `star` linv e m0) h0; assert (H.interp ((fp' x) `star` (frame `star` linv e m0)) h1); star_associative (fp' x) frame (linv e m0); assert (H.interp ((fp' x `star` frame) `star` linv e m0) h1); let h1' : H.hheap ((fp' x `star` frame) `star` linv e m0) = h1 in assert (m1 == hmem_of_hheap m0 h1'); assert (with_inv_except m1 e (fp' x `star` frame)); assert (forall (hp:H.hprop frame). hp h0 == hp h1); mprop_preservation_of_hprop_preservation frame m0 m1; () in assert (is_frame_preserving g); g let frame_preserving_respects_preorder #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (m0:hmem_with_inv_except e fp) : Lemma (let (| x, m1 |) = f m0 in mem_evolves m0 m1) = let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1) = () in H.emp_unit fp; assert (interp (fp `star` linv e m0) m0); H.star_congruence (fp `star` emp) (linv e m0) fp (linv e m0); assert (interp ((fp `star` emp) `star` linv e m0) m0); aux emp m0 let lift_tot_action_nf #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') : MstTotNF a e fp fp' = let m0 = NMSTTotal.get () in let m0' : hmem_with_inv_except e fp = m0 in let r = f m0' in let (| x, m1 |) = r in let m1' : hmem_with_inv_except e (fp' x) = m1 in assert (is_frame_preserving f); assert (m1 == dsnd (f m0)); frame_preserving_respects_preorder f m0; NMSTTotal.put #_ #(mem_evolves) m1; x let lift_tot_action #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get #(full_mem) #_ () in ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); lift_tot_action_nf f (** Now defining the lift for heap actions with explicit frame *) let tot_action_with_frame_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = frame:slprop u#a -> m0:hmem_with_inv_except e (fp `star` frame) -> Pure (x:a & hmem_with_inv_except e (fp' x `star` frame)) (requires True) (ensures fun (| x, m1 |) -> mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_with_frame = tot_action_with_frame_except S.empty let lift_heap_action_with_frame (#fp:slprop u#a) (#a:Type u#b) (#fp':a -> slprop u#a) (e:inames) ($f:H.action_with_frame fp a fp') : tot_action_with_frame_except e fp a fp' = fun frame m0 -> let h0 = hheap_of_hmem m0 in calc (equiv) { fp `star` frame `star` locks_invariant e m0; (equiv) { star_associative fp frame (locks_invariant e m0) } fp `star` (frame `star` locks_invariant e m0); }; assert (H.interp (fp `star` frame `star` locks_invariant e m0) h0); assert (H.interp (fp `star` (frame `star` locks_invariant e m0)) h0); //key: apply the heap action with frame * locks_invariant e m0 let (| x, h1 |) = f (frame `star` locks_invariant e m0) h0 in calc (equiv) { fp' x `star` (frame `star` locks_invariant e m0); (equiv) { star_associative (fp' x) frame (locks_invariant e m0) } fp' x `star` frame `star` locks_invariant e m0; }; assert (H.interp (fp' x `star` (frame `star` locks_invariant e m0)) h1); assert (H.interp (fp' x `star` frame `star` locks_invariant e m0) h1); let m1 = hmem_of_hheap m0 h1 in assert (mem_evolves m0 m1); mprop_preservation_of_hprop_preservation (frame `star` locks_invariant e m0) m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)); (| x, m1 |) let lift_tot_action_with_frame #a #e #fp #fp' ($f:tot_action_with_frame_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in assert (inames_ok e m0); ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); let m0' : hmem_with_inv_except e fp = m0 in let r = f frame m0' in let (| x, m1 |) = r in ac_reasoning_for_m_frame_preserving (fp' x) frame (locks_invariant e m1) m1; assert (interp (fp' x `star` frame `star` locks_invariant e m1) m1); assert (interp (fp' x `star` locks_invariant e m1) m1); let m1' : hmem_with_inv_except e (fp' x) = m1 in NMSTTotal.put #_ #(mem_evolves) m1; x let sel_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.sel_action #a #pcm r v0)) let upd_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.upd_action #a #pcm r v0 v1)) let free_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.free_action #a #pcm r v0)) let split_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.split_action #a #pcm r v0 v1)) let gather_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.gather_action #a #pcm r v0 v1)) let weaken (p q r:slprop) (h:H.hheap (p `star` q) { H.stronger q r }) : H.hheap (p `star` r) = H.weaken p q r h; h let weaken_pure (q r: prop) : Lemma (requires (q ==> r)) (ensures H.stronger (H.pure q) (H.pure r)) = let aux (h:H.heap) : Lemma (ensures (H.interp (H.pure q) h ==> H.interp (H.pure r) h)) [SMTPat ()] = H.pure_interp q h; H.pure_interp r h in () let inc_ctr (#p:slprop) #e (m:hmem_with_inv_except e p) : m':hmem_with_inv_except e p{m'.ctr = m.ctr + 1 /\ H.stronger (linv e m) (linv e m')} = let m' : mem = { m with ctr = m.ctr + 1} in assert (interp (p `star` linv e m) m'); assert (linv e m == lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m)); assert (linv e m' == lock_store_invariant e m.locks `star` ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken_free_above (heap_of_mem m) m.ctr (m.ctr + 1); weaken_pure (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_ctr_valid (m.ctr + 1) (heap_of_mem m)); assert (H.stronger (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m))); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)); H.stronger_star (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken (p `star` lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)) (heap_of_mem m'); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity (m.ctr + 1) (heap_of_mem m)); let m' : hmem_with_inv_except e p = m' in m' let frame_related_mems (fp0 fp1:slprop u#a) e (m0:hmem_with_inv_except e fp0) (m1:hmem_with_inv_except e fp1) = forall (frame:slprop u#a). interp ((fp0 `star` frame) `star` linv e m0) m0 ==> interp ((fp1 `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) let refined_pre_action e (fp0:slprop) (a:Type) (fp1:a -> slprop) = m0:hmem_with_inv_except e fp0 -> Pure (x:a & hmem_with_inv_except e (fp1 x)) (requires True) (ensures fun (| x, m1 |) -> frame_related_mems fp0 (fp1 x) e m0 m1) let refined_pre_action_as_action (#fp0:slprop) (#a:Type) (#fp1:a -> slprop) #e ($f:refined_pre_action e fp0 a fp1) : tot_action_nf_except e fp0 a fp1 = let g : tot_pre_action_nf_except e fp0 a fp1 = fun m -> f m in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp0 `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp1 x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x', m1' |) = g m0 in let (| x, m1 |) = f m0 in assert (x == x' /\ m1 == m1') in g let alloc_action #a #pcm e x = let f : refined_pre_action e emp (ref a pcm) (fun r -> pts_to r x) = fun m0 -> (* NS: 9/29/22 I needed to annotate h : Heap.full_heap, for use with the Core checker which generates a guard for checking the implicit pattern "dot" term in the dependent pair pattern on the next line. That guard expects `h` to be a full_heap, which is it, because it is a projection of m0. However, this is not reflected in `h`'s type. So, the Core checker, which produces a guard for the pat_dot_term in isolation, cannot recheck the term. If we were to fold in the checking of pat_dot_terms and their guards with the rest of the VC, this would work. *) let h : Heap.full_heap = hheap_of_hmem m0 in let (|r, h'|) = H.extend #a #pcm x m0.ctr h in let m' : hmem_with_inv_except e emp = inc_ctr m0 in let h' : H.hheap (pts_to #a #pcm r x `star` linv e m') = weaken _ (linv e m0) (linv e m') h' in let m1 : hmem_with_inv_except e (pts_to #a #pcm r x) = hmem_of_hheap m' h' in assert (forall frame. H.frame_related_heaps h h' emp (pts_to #a #pcm r x) frame true); let aux (frame:slprop) : Lemma (requires interp ((emp `star` frame) `star` linv e m0) m0) (ensures interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) [SMTPat (emp `star` frame)] = star_associative emp frame (linv e m0); assert (H.interp (emp `star` (frame `star` linv e m0)) h); assert (H.interp (pts_to #a #pcm r x `star` (frame `star` linv e m0)) h'); star_associative (pts_to #a #pcm r x) frame (linv e m0); assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m0) h'); assert (H.stronger (linv e m0) (linv e m')); assert (H.equiv (linv e m') (linv e m1)); assert (H.stronger (linv e m0) (linv e m1)); let h' : H.hheap ((pts_to #a #pcm r x `star` frame) `star` linv e m1) = weaken _ (linv e m0) (linv e m1) h' in assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) h'); assert (forall (mp:H.hprop frame). mp h == mp h'); mprop_preservation_of_hprop_preservation frame m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) in assert (frame_related_mems emp (pts_to r x) e m0 m1); (| r, m1 |) in lift_tot_action (refined_pre_action_as_action f) let select_refine #a #p e r x f = lift_tot_action (lift_heap_action e (H.select_refine #a #p r x f)) let upd_gen #a #p e r x y f = lift_tot_action (lift_heap_action e (H.upd_gen_action r x y f)) //////////////////////////////////////////////////////////////////////////////// // witness / recall //////////////////////////////////////////////////////////////////////////////// let witnessed_ref #a #pcm (r:ref a pcm) (fact:property a) (m:full_mem) = H.witnessed_ref #a #pcm r fact (heap_of_mem m) let witnessed_ref_stability #a #pcm (r:ref a pcm) (fact:property a) : Lemma (requires FStar.Preorder.stable fact (Steel.Preorder.preorder_of_pcm pcm)) (ensures FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) = H.witnessed_ref_stability #a #pcm r fact let witnessed (#a:Type u#1) (#pcm:pcm a) (r:ref a pcm) (fact:property a) = W.witnessed _ mem_evolves (witnessed_ref r fact) let rearrange_pqr_prq (p q r:slprop) : Lemma (((p `star` q) `star` r) `equiv` ((p `star` r) `star` q)) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_associative p q r } p `star` (q `star` r); (equiv) { star_commutative q r; star_congruence p (q `star` r) p (r `star` q) } p `star` (r `star` q); (equiv) { star_associative p r q } (p `star` r) `star` q; }

{ "checked_file": "/", "dependencies": [ "Steel.Preorder.fst.checked", "Steel.Heap.fsti.checked", "prims.fst.checked", "FStar.Witnessed.Core.fsti.checked", "FStar.Set.fsti.checked", "FStar.Preorder.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.PCM.fst.checked", "FStar.NMSTTotal.fst.checked", "FStar.List.Tot.fst.checked", "FStar.IndefiniteDescription.fsti.checked", "FStar.Ghost.fsti.checked", "FStar.FunctionalExtensionality.fsti.checked", "FStar.Classical.Sugar.fsti.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Steel.Memory.fst" }

[ { "abbrev": true, "full_module": "Steel.Preorder", "short_module": "PP" }, { "abbrev": true, "full_module": "FStar.Witnessed.Core", "short_module": "W" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": true, "full_module": "Steel.Heap", "short_module": "H" }, { "abbrev": false, "full_module": "FStar.PCM", "short_module": null }, { "abbrev": false, "full_module": "FStar.FunctionalExtensionality", "short_module": null }, { "abbrev": true, "full_module": "FStar.FunctionalExtensionality", "short_module": "F" }, { "abbrev": false, "full_module": "FStar.PCM", "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

e: Steel.Memory.inames -> p: Steel.Memory.slprop -> q: Steel.Memory.slprop -> r: Steel.Memory.slprop -> s: Steel.Memory.slprop -> m0: Steel.Memory.mem -> m1: Steel.Memory.mem -> FStar.Pervasives.Lemma (requires Steel.Memory.equiv p r /\ Steel.Memory.equiv q s /\ Steel.Memory.preserves_frame e p q m0 m1 ) (ensures Steel.Memory.preserves_frame e r s m0 m1)

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Steel.Memory.inames", "Steel.Memory.slprop", "Steel.Memory.mem", "Prims.unit", "Steel.Memory.interp", "Steel.Memory.star", "Steel.Memory.locks_invariant", "Prims.squash", "Prims.l_and", "Prims.Cons", "FStar.Pervasives.pattern", "FStar.Pervasives.smt_pat", "Prims.Nil", "Prims._assert", "Steel.Memory.equiv", "Steel.Memory.star_congruence", "Steel.Memory.preserves_frame" ]

[]

false

true

false

let preserves_frame_cong (e: inames) (p q r s: slprop) (m0 m1: mem) : Lemma (requires p `equiv` r /\ q `equiv` s /\ preserves_frame e p q m0 m1) (ensures preserves_frame e r s m0 m1) =

let aux0 (p q r s: slprop) : Lemma (requires p `equiv` s) (ensures (((p `star` q) `star` r) `equiv` ((s `star` q) `star` r))) = star_congruence p q s q; star_congruence (p `star` q) r (s `star` q) r in let aux (frame: slprop) : Lemma (requires interp ((r `star` frame) `star` (locks_invariant e m0)) m0) (ensures interp ((s `star` frame) `star` (locks_invariant e m1)) m1 /\ interp ((p `star` frame) `star` (locks_invariant e m0)) m0) [SMTPat (r `star` frame)] = aux0 p frame (locks_invariant e m0) r; aux0 q frame (locks_invariant e m1) s; assert (((p `star` frame) `star` (locks_invariant e m0)) `equiv` ((r `star` frame) `star` (locks_invariant e m0))); assert (interp ((p `star` frame) `star` (locks_invariant e m0)) m0); assert (interp ((q `star` frame) `star` (locks_invariant e m1)) m1); assert (((q `star` frame) `star` (locks_invariant e m1)) `equiv` ((s `star` frame) `star` (locks_invariant e m1))); () in ()

false

Steel.Memory.fst

Steel.Memory.alloc_action

val alloc_action (#a:Type u#1) (#pcm:pcm a) (e:inames) (x:a{compatible pcm x x /\ pcm.refine x}) : action_except (ref a pcm) e emp (fun r -> pts_to r x)

let alloc_action #a #pcm e x = let f : refined_pre_action e emp (ref a pcm) (fun r -> pts_to r x) = fun m0 -> (* NS: 9/29/22 I needed to annotate h : Heap.full_heap, for use with the Core checker which generates a guard for checking the implicit pattern "dot" term in the dependent pair pattern on the next line. That guard expects `h` to be a full_heap, which is it, because it is a projection of m0. However, this is not reflected in `h`'s type. So, the Core checker, which produces a guard for the pat_dot_term in isolation, cannot recheck the term. If we were to fold in the checking of pat_dot_terms and their guards with the rest of the VC, this would work. *) let h : Heap.full_heap = hheap_of_hmem m0 in let (|r, h'|) = H.extend #a #pcm x m0.ctr h in let m' : hmem_with_inv_except e emp = inc_ctr m0 in let h' : H.hheap (pts_to #a #pcm r x `star` linv e m') = weaken _ (linv e m0) (linv e m') h' in let m1 : hmem_with_inv_except e (pts_to #a #pcm r x) = hmem_of_hheap m' h' in assert (forall frame. H.frame_related_heaps h h' emp (pts_to #a #pcm r x) frame true); let aux (frame:slprop) : Lemma (requires interp ((emp `star` frame) `star` linv e m0) m0) (ensures interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) [SMTPat (emp `star` frame)] = star_associative emp frame (linv e m0); assert (H.interp (emp `star` (frame `star` linv e m0)) h); assert (H.interp (pts_to #a #pcm r x `star` (frame `star` linv e m0)) h'); star_associative (pts_to #a #pcm r x) frame (linv e m0); assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m0) h'); assert (H.stronger (linv e m0) (linv e m')); assert (H.equiv (linv e m') (linv e m1)); assert (H.stronger (linv e m0) (linv e m1)); let h' : H.hheap ((pts_to #a #pcm r x `star` frame) `star` linv e m1) = weaken _ (linv e m0) (linv e m1) h' in assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) h'); assert (forall (mp:H.hprop frame). mp h == mp h'); mprop_preservation_of_hprop_preservation frame m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) in assert (frame_related_mems emp (pts_to r x) e m0 m1); (| r, m1 |) in lift_tot_action (refined_pre_action_as_action f)

{ "file_name": "lib/steel/Steel.Memory.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 52, "end_line": 982, "start_col": 0, "start_line": 940 }

(* 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.Memory module F = FStar.FunctionalExtensionality open FStar.FunctionalExtensionality open FStar.PCM module H = Steel.Heap noeq type lock_state : Type u#(a + 1) = | Invariant : inv:H.slprop u#a -> lock_state let lock_store : Type u#(a+1) = list (lock_state u#a) noeq type mem : Type u#(a + 1) = { ctr: nat; heap: H.heap u#a; locks: lock_store u#a; } let heap_of_mem (x:mem) : H.heap = x.heap let mem_of_heap (h:H.heap) : mem = { ctr = 0; heap = h; locks = [] } let mem_set_heap (m:mem) (h:H.heap) : mem = { ctr = m.ctr; heap = h; locks = m.locks; } let core_mem (m:mem) : mem = mem_of_heap (heap_of_mem m) let core_mem_invol m = () let disjoint (m0 m1:mem u#h) : prop = m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks let disjoint_sym m0 m1 = () let join m0 m1 = { ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = m0.locks } let join_commutative m0 m1 = H.join_commutative m0.heap m1.heap let disjoint_join m0 m1 m2 = H.disjoint_join m0.heap m1.heap m2.heap let join_associative m0 m1 m2 = H.join_associative m0.heap m1.heap m2.heap let slprop = H.slprop let interp p m = H.interp p m.heap let equiv p1 p2 = forall m. interp p1 m <==> interp p2 m let slprop_extensionality p q = assert (forall m. interp p m <==> interp q m); let aux (h:H.heap) : Lemma (H.interp p h <==> H.interp q h) [SMTPat (H.interp p h)] = let m : mem = { ctr = 0; heap = h; locks = [] } in assert (interp p m <==> interp q m) in assert (forall h. H.interp p h <==> H.interp q h); Steel.Heap.slprop_extensionality p q let reveal_equiv p1 p2 = () let core_ref = H.core_ref let core_ref_null = H.core_ref_null let core_ref_is_null r = H.core_ref_is_null r let emp : slprop u#a = H.emp let pure = H.pure let pts_to = H.pts_to let h_and = H.h_and let h_or = H.h_or let star = H.star let wand = H.wand let h_exists = H.h_exists let h_forall = H.h_forall //////////////////////////////////////////////////////////////////////////////// //properties of equiv //////////////////////////////////////////////////////////////////////////////// let equiv_symmetric (p1 p2:slprop u#a) = H.equiv_symmetric p1 p2 #push-options "--warn_error -271" let equiv_heap_iff_equiv (p1 p2:slprop u#a) : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat (equiv p1 p2)] = let aux_lr () : Lemma (requires H.equiv p1 p2) (ensures equiv p1 p2) [SMTPat ()] = () in let aux_rl_helper1 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p1 h) (ensures H.interp p2 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl_helper2 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p2 h) (ensures H.interp p1 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl () : Lemma (requires equiv p1 p2) (ensures H.equiv p1 p2) [SMTPat ()] = () in () let equiv_heap_iff_equiv_forall () : Lemma (ensures (forall p1 p2. H.equiv p1 p2 <==> equiv p1 p2)) = let aux p1 p2 : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat ()] = equiv_heap_iff_equiv p1 p2 in () #pop-options let equiv_extensional_on_star (p1 p2 p3:slprop u#a) = equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3 let emp_unit p = H.emp_unit p let intro_emp m = H.intro_emp (heap_of_mem m) let pure_equiv p q = H.pure_equiv p q let pure_interp q m = H.pure_interp q (heap_of_mem m) let pure_star_interp p q m = H.pure_star_interp p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// //pts_to //////////////////////////////////////////////////////////////////////////////// let pts_to_compatible #a #pcm x v0 v1 m = H.pts_to_compatible #a #pcm x v0 v1 (heap_of_mem m) let pts_to_compatible_equiv #a #pcm x v0 v1 = H.pts_to_compatible_equiv #a #pcm x v0 v1 let pts_to_not_null #a #pcm x v m = H.pts_to_not_null #a #pcm x v (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // star //////////////////////////////////////////////////////////////////////////////// let intro_star p q mp mq = H.intro_star p q (heap_of_mem mp) (heap_of_mem mq) let elim_star p q m = let h = heap_of_mem m in H.elim_star p q h; assert (exists hl hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr); let hl = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hl -> exists hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let hr = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hr -> H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let ml = mem_set_heap m hl in let mr = mem_set_heap m hr in assert (disjoint ml mr); assert (m == join ml mr); assert (interp p ml); assert (interp q mr); () let interp_star (p q: slprop) (m: mem) : Lemma (interp (p `star` q) m <==> (exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m)) = let left = interp (p `star` q) m in let right = exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m in let f () : Lemma (requires left) (ensures right) = elim_star p q m in let g () : Lemma (requires right) (ensures left) = Classical.exists_elim left #_ #(fun mp -> exists (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mp -> Classical.exists_elim left #_ #(fun mq -> disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mq -> intro_star p q mp mq ) ) in Classical.move_requires f (); Classical.move_requires g () let star_commutative (p1 p2:slprop) = H.star_commutative p1 p2 let star_associative (p1 p2 p3:slprop) = H.star_associative p1 p2 p3 let star_congruence (p1 p2 p3 p4:slprop) = equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4 let affine_star (p q:slprop) (m:mem) = H.affine_star p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // Invariants on the lock store //////////////////////////////////////////////////////////////////////////////// let iname = nat module S = FStar.Set module L = FStar.List.Tot module W = FStar.Witnessed.Core let rec lock_store_invariant (e:inames) (l:lock_store u#a) : slprop u#a = let current_addr = L.length l - 1 in match l with | [] -> emp | Invariant p :: tl -> if current_addr `S.mem` e then lock_store_invariant e tl else p `star` lock_store_invariant e tl let lock_i (i:iname) (l:lock_store { i < L.length l }) = let ix = L.length l - i - 1 in L.index l ix let iname_for_p (i:iname) (p:slprop) : W.s_predicate lock_store = fun l -> i < L.length l /\ (lock_i i l).inv == p let lock_store_evolves : FStar.Preorder.preorder lock_store = fun (l1 l2 : lock_store) -> L.length l2 >= L.length l1 /\ (forall (i:nat{i < L.length l1}). (lock_i i l1).inv == (lock_i i l2).inv) let inames_in (e:inames) (l:lock_store) : prop = forall i. Set.mem i e ==> i < L.length l let inames_ok e m = inames_in e m.locks let inames_ok_empty m = () let extend_lock_store (e:inames) (l:lock_store{e `inames_in` l}) (p:slprop) : i:iname & l':lock_store { lock_store_invariant e l' == p `star` lock_store_invariant e l /\ iname_for_p i p l' } = (| L.length l, Invariant p :: l |) let set_add (i:iname) (s:inames) = Set.union (Set.singleton i) s let rec move_invariant (e:inames) (l:lock_store) (p:slprop) (i:iname{iname_for_p i p l /\ ~(i `Set.mem` e)}) : Lemma (H.equiv (lock_store_invariant e l) (p `star` lock_store_invariant (set_add i e) l)) = let rec aux (i:iname) (m:lock_store) : Lemma (requires i >= L.length m) (ensures (lock_store_invariant e m `H.equiv` lock_store_invariant (set_add i e) m)) = match m with | [] -> () | Invariant p::tl -> aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl) in let current_addr = L.length l - 1 in match l with | [] -> () | Invariant q::tl -> if i = current_addr then begin assert (lock_store_invariant e l == p `star` lock_store_invariant e tl); aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl); () end else begin move_invariant e tl p i; assert (lock_store_invariant e tl `equiv` (p `star` lock_store_invariant (set_add i e) tl)); H.star_congruence q (lock_store_invariant e tl) q (p `star` lock_store_invariant (set_add i e) tl); if Set.mem current_addr e then () else begin let r = lock_store_invariant (set_add i e) tl in assert (lock_store_invariant e l `equiv` (q `star` (p `star` r))); H.star_associative q p r; H.star_commutative q p; H.star_congruence (q `star` p) r (p `star` q) r; H.star_associative p q r end end let heap_ctr_valid (ctr:nat) (h:H.heap u#a) : prop = h `H.free_above_addr` ctr let ctr_validity (ctr:nat) (h:H.heap) : slprop = H.pure (heap_ctr_valid ctr h) let locks_invariant (e:inames) (m:mem u#a) : slprop u#a = lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m) let full_mem_pred (m:mem) = H.full_heap_pred (heap_of_mem m) (***** Following lemmas are needed in Steel.Effect *****) let core_mem_interp (hp:slprop u#a) (m:mem u#a) = () let interp_depends_only_on (hp:slprop u#a) = H.interp_depends_only_on hp let a_mem_prop_as_a_heap_prop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (H.a_heap_prop u#a) = let g (h: H.heap u#a) : Tot prop = interp sl (mem_of_heap h) /\ f (mem_of_heap h) in let phi0 (h0 h1: H.heap u#a) : Lemma (requires (g h0 /\ H.disjoint h0 h1)) (ensures (g h0 /\ H.disjoint h0 h1 /\ g (H.join h0 h1))) = assert (mem_of_heap (H.join h0 h1) == mem_of_heap h0 `join` mem_of_heap h1); interp_depends_only_on sl in let phi1 (h0 h1: H.heap u#a) : Lemma (ensures ((g h0 /\ H.disjoint h0 h1) ==> g (H.join h0 h1))) = Classical.move_requires (phi0 h0) h1 in Classical.forall_intro_2 phi1; g let refine_slprop sl f = H.as_slprop (a_mem_prop_as_a_heap_prop sl f) let interp_refine_slprop sl f m = assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_mem m)) let dep_hprop (s: slprop) (f: (hmem s -> Tot slprop)) (h: H.heap) : Tot prop = exists (h1: H.heap) . exists (h2: H.heap) . interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 let dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq' : squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h')) = let p2 (h h1 h2: H.heap) : Tot prop = interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 in let p1 (h h1: H.heap) : Tot prop = (exists h2 . p2 h h1 h2) in let h1 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p1 h) in let h2 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p2 h h1) in H.disjoint_join h' h1 h2; assert (H.disjoint h2 h'); let h2' = H.join h2 h' in H.join_commutative h2 h' ; assert (h2' == H.join h' h2); assert (H.disjoint h1 h2'); assert (mem_of_heap h2' == mem_of_heap h2 `join` mem_of_heap h'); interp_depends_only_on (f (mem_of_heap h1)); assert (interp (f (mem_of_heap h1)) (mem_of_heap h2')); H.join_commutative h1 h2; H.join_associative h' h2 h1; H.join_commutative h' h; H.join_commutative h2' h1; assert (H.join h h' == h1 `H.join` h2') let impl_intro_gen (#p: Type0) (#q: Type0) ($prf: (squash p -> Lemma (q ))) : Lemma (p ==> q) = Classical.impl_intro_gen #p #(fun _ -> q) prf let dep_hprop_is_affine1 (s: slprop) (f: (hmem s -> Tot slprop)) (h0 h1: H.heap) : Lemma ((dep_hprop s f h0 /\ H.disjoint h0 h1) ==> (H.disjoint h0 h1 /\ dep_hprop s f (H.join h0 h1))) = impl_intro_gen (dep_hprop_is_affine0 s f h0 h1) let dep_hprop_is_affine (s: slprop) (f: (hmem s -> Tot slprop)) : Lemma (H.heap_prop_is_affine (dep_hprop s f)) = Classical.forall_intro_2 (dep_hprop_is_affine1 s f) let sdep (s: slprop) (f: (hmem s -> Tot slprop)) : Tot slprop = dep_hprop_is_affine s f; H.as_slprop (dep_hprop s f) let interp_sdep (s: slprop) (f: (hmem s -> Tot slprop)) (m: mem) : Lemma (requires (dep_slprop_is_affine s f)) (ensures ( interp (sdep s f) m <==> (exists m1 m2 . interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) )) = dep_hprop_is_affine s f; assert (forall m1 m2 . (interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) ==> ( interp s (mem_of_heap m1.heap) /\ interp (f (mem_of_heap m1.heap)) (mem_of_heap m2.heap) /\ H.disjoint m1.heap m2.heap /\ H.join m1.heap m2.heap == m.heap )); interp_depends_only_on s; Classical.forall_intro (fun m -> interp_depends_only_on (f m)); assert (forall h1 h2 . (interp s (mem_of_heap h1) /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ H.disjoint h1 h2 /\ H.join h1 h2 == m.heap) ==> ( core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ interp s (core_mem (mem_of_heap h1)) /\ interp s (mem_set_heap m h1) /\ core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ f (mem_set_heap m h1) `equiv` f (mem_of_heap h1) /\ interp (f (mem_set_heap m h1)) (mem_of_heap h2) /\ interp (f (mem_set_heap m h1)) (mem_set_heap m h2) /\ disjoint (mem_set_heap m h1) (mem_set_heap m h2) /\ join (mem_set_heap m h1) (mem_set_heap m h2) == m )); () let h_exists_cong (#a:Type) (p q : a -> slprop) : Lemma (requires (forall x. p x `equiv` q x)) (ensures (h_exists p `equiv` h_exists q)) = equiv_heap_iff_equiv_forall (); H.h_exists_cong p q let intro_h_exists #a x p m = H.intro_h_exists x p (heap_of_mem m) let elim_h_exists (#a:_) (p:a -> slprop) (m:mem) = H.elim_h_exists p (heap_of_mem m) let intro_h_forall (#a:_) (p:a -> slprop) (m:mem) = H.intro_h_forall p (heap_of_mem m) let elim_h_forall (#a:_) (p:a -> slprop) (m:mem) (x:a) = H.elim_h_forall p (heap_of_mem m) x let intro_h_and (p q: slprop) (m:mem) = H.intro_h_and p q (heap_of_mem m) let elim_h_and (p q: slprop) (m:mem) = H.elim_h_and p q (heap_of_mem m) let intro_h_or_left (p q: slprop) (m:mem) = H.intro_h_or_left p q (heap_of_mem m) let intro_h_or_right (p q: slprop) (m:mem) = H.intro_h_or_right p q (heap_of_mem m) let elim_h_or (p q: slprop) (m:mem) = H.elim_h_or p q (heap_of_mem m) let intro_wand (p1 p2: slprop u#a) (m:mem) = introduce (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)) ==> interp (wand p1 p2) m with _. ( assert (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)); H.intro_wand p1 p2 (heap_of_mem m); let h = heap_of_mem m in assert ((forall h1. h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) ==> H.interp (wand p1 p2) h); introduce forall h1. (h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) with ( introduce (h `H.disjoint` h1 /\ H.interp p1 h1) ==> H.interp p2 (H.join h h1) with _. ( assert (h `H.disjoint` h1); let m1 = { ctr = m.ctr; heap = h1; locks = m.locks } in assert (m `disjoint` m1) ) ) ) (** Eliminating a wand by proving a heap that satisfies the LHS **) let elim_wand (p1 p2: slprop u#a) (m:mem) (m1:mem) = H.elim_wand p1 p2 (heap_of_mem m) (heap_of_mem m1) //////////////////////////////////////////////////////////////////////////////// // Preorders and effects //////////////////////////////////////////////////////////////////////////////// module PP = Steel.Preorder let mem_evolves = fun (m0 m1:full_mem) -> H.heap_evolves (heap_of_mem m0) (heap_of_mem m1) /\ m0.ctr <= m1.ctr /\ lock_store_evolves m0.locks m1.locks (** See [Steel.Heap.is_frame_preserving]. We add in [lock_invariants] now *) let preserves_frame (e:inames) (pre post:slprop) (m0 m1:mem) = forall (frame:slprop). interp ((pre `star` frame) `star` locks_invariant e m0) m0 ==> (interp ((post `star` frame) `star` locks_invariant e m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) (** This is a version of MstTot with frame quantified, as part of preserves_frame *) effect MstTotNF (a:Type u#a) (except:inames) (expects:slprop u#1) (provides: a -> slprop u#1) = NMSTTotal.NMSTATETOT a (full_mem u#1) mem_evolves (requires fun m0 -> inames_ok except m0 /\ interp (expects `star` locks_invariant except m0) m0) (ensures fun m0 x m1 -> inames_ok except m1 /\ interp (provides x `star` locks_invariant except m1) m1 /\ preserves_frame except expects (provides x) m0 m1) //////////////////////////////////////////////////////////////////////////////// // Lifting heap actions //////////////////////////////////////////////////////////////////////////////// (** Heap actions come in two equivalent flavors: - one that take an explicit frame as argument (action_with_frame) - and one that quantify over all the frame We therefore define two lift routes: - a direct route for those with explicit frame - via MstTotNF for the rest *) let tot_pre_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = hmem_with_inv_except e fp -> (x:a & hmem_with_inv_except e (fp' x)) let tot_pre_action_nf = tot_pre_action_nf_except S.empty let ac_reasoning_for_m_frame_preserving (p q r:slprop u#a) (m:mem u#a) : Lemma (requires interp ((p `star` q) `star` r) m) (ensures interp (p `star` r) m) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_commutative p q; equiv_extensional_on_star (p `star` q) (q `star` p) r } (q `star` p) `star` r; (equiv) { star_associative q p r } q `star` (p `star` r); }; assert (interp (q `star` (p `star` r)) m); affine_star q (p `star` r) m let is_frame_preserving (#e:inames) (#a:Type u#b) (#fp:slprop u#a) (#fp':a -> slprop u#a) (f:tot_pre_action_nf_except e fp a fp') = forall (frame:slprop u#a) (m0:hmem_with_inv_except e (fp `star` frame)). (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = f:tot_pre_action_nf_except e fp a fp'{ is_frame_preserving f } let tot_action_nf = tot_action_nf_except S.empty let linv e (m:mem) = locks_invariant e m let hheap_of_hmem #fp #e (m:hmem_with_inv_except e fp) : h:H.hheap (fp `star` linv e m) { h `H.free_above_addr` m.ctr} = let h = heap_of_mem m in H.pure_interp (heap_ctr_valid m.ctr (heap_of_mem m)) h; h let hmem_of_hheap #e (#fp0 #fp1:slprop) (m:hmem_with_inv_except e fp0) (h:H.full_hheap (fp1 `star` linv e m) { h `Heap.free_above_addr` m.ctr }) : m1:hmem_with_inv_except e fp1{linv e m `equiv` linv e m1} = let m1 : mem = { m with heap = h } in assert (interp (fp1 `star` linv e m) m1); star_commutative fp1 (linv e m); assert (interp (linv e m `star` fp1) m1); assert (linv e m1 == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); assert (linv e m == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m)); H.pure_interp (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_of_mem m); assert (heap_ctr_valid m1.ctr (heap_of_mem m) <==> heap_ctr_valid m1.ctr (heap_of_mem m1)); H.pure_equiv (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_ctr_valid m1.ctr (heap_of_mem m1)); H.star_congruence (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m)); assert (linv e m `equiv` linv e m1); let _ = equiv_extensional_on_star (linv e m) (linv e m1) fp1 in assert ((linv e m `star` fp1) `equiv` (linv e m1 `star` fp1)); assert (interp (linv e m1 `star` fp1) m1); star_commutative (linv e m1) fp1; assert (interp (fp1 `star` linv e m1) m1); m1 let with_inv_except (m:mem) e (fp:slprop) = interp (fp `star` locks_invariant e m) m #push-options "--warn_error -271" let as_hprop (frame:slprop) (mp:mprop frame) : hp:H.hprop frame{forall m. mp (core_mem m) == hp (heap_of_mem m)} = let f = fun h -> mp (mem_of_heap h) in assert (forall m. mp (core_mem m) == f (heap_of_mem m)); let aux (m0:H.hheap frame) (m1:H.heap{H.disjoint m0 m1}) : Lemma (ensures (mem_of_heap (H.join m0 m1) == join (mem_of_heap m0) (mem_of_heap m1))) [SMTPat ()] = () in f let mprop_preservation_of_hprop_preservation (p:slprop) (m0 m1:mem) : Lemma (requires (forall (hp:H.hprop p). hp (heap_of_mem m0) == hp (heap_of_mem m1))) (ensures (forall (mp:mprop p). mp (core_mem m0) == mp (core_mem m1))) = let aux (mp:mprop p) : Lemma (mp (core_mem m0) == mp (core_mem m1)) [SMTPat()] = assert (as_hprop p mp (heap_of_mem m0) == as_hprop p mp (heap_of_mem m1)) in () let lift_heap_action (#fp:slprop) (#a:Type) (#fp':a -> slprop) (e:inames) ($f:H.action fp a fp') : tot_action_nf_except e fp a fp' = let g : tot_pre_action_nf_except e fp a fp' = fun m -> let h0 = hheap_of_hmem m in let (| x, h' |) = f h0 in (| x, hmem_of_hheap m h' |) in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in let h0 = hheap_of_hmem m0 in let (| x', h1 |) = f h0 in H.action_framing f (linv e m0) h0; assert (x == x'); star_associative fp frame (linv e m0); H.action_framing f (frame `star` linv e m0) h0; assert (H.interp ((fp' x) `star` (frame `star` linv e m0)) h1); star_associative (fp' x) frame (linv e m0); assert (H.interp ((fp' x `star` frame) `star` linv e m0) h1); let h1' : H.hheap ((fp' x `star` frame) `star` linv e m0) = h1 in assert (m1 == hmem_of_hheap m0 h1'); assert (with_inv_except m1 e (fp' x `star` frame)); assert (forall (hp:H.hprop frame). hp h0 == hp h1); mprop_preservation_of_hprop_preservation frame m0 m1; () in assert (is_frame_preserving g); g let frame_preserving_respects_preorder #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (m0:hmem_with_inv_except e fp) : Lemma (let (| x, m1 |) = f m0 in mem_evolves m0 m1) = let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1) = () in H.emp_unit fp; assert (interp (fp `star` linv e m0) m0); H.star_congruence (fp `star` emp) (linv e m0) fp (linv e m0); assert (interp ((fp `star` emp) `star` linv e m0) m0); aux emp m0 let lift_tot_action_nf #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') : MstTotNF a e fp fp' = let m0 = NMSTTotal.get () in let m0' : hmem_with_inv_except e fp = m0 in let r = f m0' in let (| x, m1 |) = r in let m1' : hmem_with_inv_except e (fp' x) = m1 in assert (is_frame_preserving f); assert (m1 == dsnd (f m0)); frame_preserving_respects_preorder f m0; NMSTTotal.put #_ #(mem_evolves) m1; x let lift_tot_action #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get #(full_mem) #_ () in ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); lift_tot_action_nf f (** Now defining the lift for heap actions with explicit frame *) let tot_action_with_frame_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = frame:slprop u#a -> m0:hmem_with_inv_except e (fp `star` frame) -> Pure (x:a & hmem_with_inv_except e (fp' x `star` frame)) (requires True) (ensures fun (| x, m1 |) -> mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_with_frame = tot_action_with_frame_except S.empty let lift_heap_action_with_frame (#fp:slprop u#a) (#a:Type u#b) (#fp':a -> slprop u#a) (e:inames) ($f:H.action_with_frame fp a fp') : tot_action_with_frame_except e fp a fp' = fun frame m0 -> let h0 = hheap_of_hmem m0 in calc (equiv) { fp `star` frame `star` locks_invariant e m0; (equiv) { star_associative fp frame (locks_invariant e m0) } fp `star` (frame `star` locks_invariant e m0); }; assert (H.interp (fp `star` frame `star` locks_invariant e m0) h0); assert (H.interp (fp `star` (frame `star` locks_invariant e m0)) h0); //key: apply the heap action with frame * locks_invariant e m0 let (| x, h1 |) = f (frame `star` locks_invariant e m0) h0 in calc (equiv) { fp' x `star` (frame `star` locks_invariant e m0); (equiv) { star_associative (fp' x) frame (locks_invariant e m0) } fp' x `star` frame `star` locks_invariant e m0; }; assert (H.interp (fp' x `star` (frame `star` locks_invariant e m0)) h1); assert (H.interp (fp' x `star` frame `star` locks_invariant e m0) h1); let m1 = hmem_of_hheap m0 h1 in assert (mem_evolves m0 m1); mprop_preservation_of_hprop_preservation (frame `star` locks_invariant e m0) m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)); (| x, m1 |) let lift_tot_action_with_frame #a #e #fp #fp' ($f:tot_action_with_frame_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in assert (inames_ok e m0); ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); let m0' : hmem_with_inv_except e fp = m0 in let r = f frame m0' in let (| x, m1 |) = r in ac_reasoning_for_m_frame_preserving (fp' x) frame (locks_invariant e m1) m1; assert (interp (fp' x `star` frame `star` locks_invariant e m1) m1); assert (interp (fp' x `star` locks_invariant e m1) m1); let m1' : hmem_with_inv_except e (fp' x) = m1 in NMSTTotal.put #_ #(mem_evolves) m1; x let sel_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.sel_action #a #pcm r v0)) let upd_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.upd_action #a #pcm r v0 v1)) let free_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.free_action #a #pcm r v0)) let split_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.split_action #a #pcm r v0 v1)) let gather_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.gather_action #a #pcm r v0 v1)) let weaken (p q r:slprop) (h:H.hheap (p `star` q) { H.stronger q r }) : H.hheap (p `star` r) = H.weaken p q r h; h let weaken_pure (q r: prop) : Lemma (requires (q ==> r)) (ensures H.stronger (H.pure q) (H.pure r)) = let aux (h:H.heap) : Lemma (ensures (H.interp (H.pure q) h ==> H.interp (H.pure r) h)) [SMTPat ()] = H.pure_interp q h; H.pure_interp r h in () let inc_ctr (#p:slprop) #e (m:hmem_with_inv_except e p) : m':hmem_with_inv_except e p{m'.ctr = m.ctr + 1 /\ H.stronger (linv e m) (linv e m')} = let m' : mem = { m with ctr = m.ctr + 1} in assert (interp (p `star` linv e m) m'); assert (linv e m == lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m)); assert (linv e m' == lock_store_invariant e m.locks `star` ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken_free_above (heap_of_mem m) m.ctr (m.ctr + 1); weaken_pure (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_ctr_valid (m.ctr + 1) (heap_of_mem m)); assert (H.stronger (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m))); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)); H.stronger_star (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken (p `star` lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)) (heap_of_mem m'); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity (m.ctr + 1) (heap_of_mem m)); let m' : hmem_with_inv_except e p = m' in m' let frame_related_mems (fp0 fp1:slprop u#a) e (m0:hmem_with_inv_except e fp0) (m1:hmem_with_inv_except e fp1) = forall (frame:slprop u#a). interp ((fp0 `star` frame) `star` linv e m0) m0 ==> interp ((fp1 `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) let refined_pre_action e (fp0:slprop) (a:Type) (fp1:a -> slprop) = m0:hmem_with_inv_except e fp0 -> Pure (x:a & hmem_with_inv_except e (fp1 x)) (requires True) (ensures fun (| x, m1 |) -> frame_related_mems fp0 (fp1 x) e m0 m1) let refined_pre_action_as_action (#fp0:slprop) (#a:Type) (#fp1:a -> slprop) #e ($f:refined_pre_action e fp0 a fp1) : tot_action_nf_except e fp0 a fp1 = let g : tot_pre_action_nf_except e fp0 a fp1 = fun m -> f m in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp0 `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp1 x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x', m1' |) = g m0 in let (| x, m1 |) = f m0 in assert (x == x' /\ m1 == m1') in g

{ "checked_file": "/", "dependencies": [ "Steel.Preorder.fst.checked", "Steel.Heap.fsti.checked", "prims.fst.checked", "FStar.Witnessed.Core.fsti.checked", "FStar.Set.fsti.checked", "FStar.Preorder.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.PCM.fst.checked", "FStar.NMSTTotal.fst.checked", "FStar.List.Tot.fst.checked", "FStar.IndefiniteDescription.fsti.checked", "FStar.Ghost.fsti.checked", "FStar.FunctionalExtensionality.fsti.checked", "FStar.Classical.Sugar.fsti.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Steel.Memory.fst" }

[ { "abbrev": true, "full_module": "Steel.Preorder", "short_module": "PP" }, { "abbrev": true, "full_module": "FStar.Witnessed.Core", "short_module": "W" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": true, "full_module": "Steel.Heap", "short_module": "H" }, { "abbrev": false, "full_module": "FStar.FunctionalExtensionality", "short_module": null }, { "abbrev": true, "full_module": "FStar.FunctionalExtensionality", "short_module": "F" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": false, "full_module": "FStar.PCM", "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

e: Steel.Memory.inames -> x: a{FStar.PCM.compatible pcm x x /\ Mkpcm?.refine pcm x} -> Steel.Memory.action_except (Steel.Memory.ref a pcm) e Steel.Memory.emp (fun r -> Steel.Memory.pts_to r x)

Prims.Tot

[ "total" ]

[]

[ "FStar.PCM.pcm", "Steel.Memory.inames", "Prims.l_and", "FStar.PCM.compatible", "FStar.PCM.__proj__Mkpcm__item__refine", "Steel.Memory.lift_tot_action", "Steel.Memory.ref", "Steel.Memory.emp", "Steel.Memory.pts_to", "Steel.Memory.slprop", "Steel.Memory.refined_pre_action_as_action", "Steel.Memory.refined_pre_action", "Steel.Memory.hmem_with_inv_except", "Steel.Heap.ref", "Steel.Heap.full_heap", "Prims.l_Forall", "Steel.Heap.slprop", "Steel.Heap.frame_related_heaps", "Steel.Heap.emp", "Steel.Heap.pts_to", "Steel.Heap.free_above_addr", "Prims.op_Addition", "Steel.Memory.__proj__Mkmem__item__ctr", "Steel.Heap.heap_evolves", "Prims.Mkdtuple2", "Prims.unit", "Prims._assert", "Steel.Memory.frame_related_mems", "Steel.Memory.interp", "Steel.Memory.star", "Steel.Memory.linv", "Prims.squash", "Steel.Memory.mem_evolves", "Steel.Memory.mprop", "Prims.eq2", "Prims.prop", "Steel.Memory.core_mem", "Prims.Cons", "FStar.Pervasives.pattern", "FStar.Pervasives.smt_pat", "Prims.Nil", "Steel.Memory.mprop_preservation_of_hprop_preservation", "Steel.Heap.hprop", "Steel.Heap.interp", "Steel.Heap.hheap", "Steel.Memory.weaken", "Steel.Heap.stronger", "Steel.Heap.equiv", "Steel.Memory.star_associative", "Steel.Memory.hmem_of_hheap", "Steel.Memory.inc_ctr", "Prims.dtuple2", "Steel.Heap.extend", "Steel.Memory.hheap_of_hmem", "Steel.Memory.action_except" ]

[]

false

let alloc_action #a #pcm e x =

let f:refined_pre_action e emp (ref a pcm) (fun r -> pts_to r x) = fun m0 -> let h:Heap.full_heap = hheap_of_hmem m0 in let (| r , h' |) = H.extend #a #pcm x m0.ctr h in let m':hmem_with_inv_except e emp = inc_ctr m0 in let h':H.hheap ((pts_to #a #pcm r x) `star` (linv e m')) = weaken _ (linv e m0) (linv e m') h' in let m1:hmem_with_inv_except e (pts_to #a #pcm r x) = hmem_of_hheap m' h' in assert (forall frame. H.frame_related_heaps h h' emp (pts_to #a #pcm r x) frame true); let aux (frame: slprop) : Lemma (requires interp ((emp `star` frame) `star` (linv e m0)) m0) (ensures interp (((pts_to #a #pcm r x) `star` frame) `star` (linv e m1)) m1 /\ mem_evolves m0 m1 /\ (forall (mp: mprop frame). mp (core_mem m0) == mp (core_mem m1))) [SMTPat (emp `star` frame)] = star_associative emp frame (linv e m0); assert (H.interp (emp `star` (frame `star` (linv e m0))) h); assert (H.interp ((pts_to #a #pcm r x) `star` (frame `star` (linv e m0))) h'); star_associative (pts_to #a #pcm r x) frame (linv e m0); assert (H.interp (((pts_to #a #pcm r x) `star` frame) `star` (linv e m0)) h'); assert (H.stronger (linv e m0) (linv e m')); assert (H.equiv (linv e m') (linv e m1)); assert (H.stronger (linv e m0) (linv e m1)); let h':H.hheap (((pts_to #a #pcm r x) `star` frame) `star` (linv e m1)) = weaken _ (linv e m0) (linv e m1) h' in assert (H.interp (((pts_to #a #pcm r x) `star` frame) `star` (linv e m1)) h'); assert (forall (mp: H.hprop frame). mp h == mp h'); mprop_preservation_of_hprop_preservation frame m0 m1; assert (forall (mp: mprop frame). mp (core_mem m0) == mp (core_mem m1)) in assert (frame_related_mems emp (pts_to r x) e m0 m1); (| r, m1 |) in lift_tot_action (refined_pre_action_as_action f)

false

Steel.Memory.fst

Steel.Memory.upd_gen

val upd_gen (#a:Type) (#p:pcm a) (e:inames) (r:ref a p) (x y:Ghost.erased a) (f:FStar.PCM.frame_preserving_upd p x y) : action_except unit e (pts_to r x) (fun _ -> pts_to r y)

let upd_gen #a #p e r x y f = lift_tot_action (lift_heap_action e (H.upd_gen_action r x y f))

{ "file_name": "lib/steel/Steel.Memory.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 67, "end_line": 989, "start_col": 0, "start_line": 988 }

(* 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.Memory module F = FStar.FunctionalExtensionality open FStar.FunctionalExtensionality open FStar.PCM module H = Steel.Heap noeq type lock_state : Type u#(a + 1) = | Invariant : inv:H.slprop u#a -> lock_state let lock_store : Type u#(a+1) = list (lock_state u#a) noeq type mem : Type u#(a + 1) = { ctr: nat; heap: H.heap u#a; locks: lock_store u#a; } let heap_of_mem (x:mem) : H.heap = x.heap let mem_of_heap (h:H.heap) : mem = { ctr = 0; heap = h; locks = [] } let mem_set_heap (m:mem) (h:H.heap) : mem = { ctr = m.ctr; heap = h; locks = m.locks; } let core_mem (m:mem) : mem = mem_of_heap (heap_of_mem m) let core_mem_invol m = () let disjoint (m0 m1:mem u#h) : prop = m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks let disjoint_sym m0 m1 = () let join m0 m1 = { ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = m0.locks } let join_commutative m0 m1 = H.join_commutative m0.heap m1.heap let disjoint_join m0 m1 m2 = H.disjoint_join m0.heap m1.heap m2.heap let join_associative m0 m1 m2 = H.join_associative m0.heap m1.heap m2.heap let slprop = H.slprop let interp p m = H.interp p m.heap let equiv p1 p2 = forall m. interp p1 m <==> interp p2 m let slprop_extensionality p q = assert (forall m. interp p m <==> interp q m); let aux (h:H.heap) : Lemma (H.interp p h <==> H.interp q h) [SMTPat (H.interp p h)] = let m : mem = { ctr = 0; heap = h; locks = [] } in assert (interp p m <==> interp q m) in assert (forall h. H.interp p h <==> H.interp q h); Steel.Heap.slprop_extensionality p q let reveal_equiv p1 p2 = () let core_ref = H.core_ref let core_ref_null = H.core_ref_null let core_ref_is_null r = H.core_ref_is_null r let emp : slprop u#a = H.emp let pure = H.pure let pts_to = H.pts_to let h_and = H.h_and let h_or = H.h_or let star = H.star let wand = H.wand let h_exists = H.h_exists let h_forall = H.h_forall //////////////////////////////////////////////////////////////////////////////// //properties of equiv //////////////////////////////////////////////////////////////////////////////// let equiv_symmetric (p1 p2:slprop u#a) = H.equiv_symmetric p1 p2 #push-options "--warn_error -271" let equiv_heap_iff_equiv (p1 p2:slprop u#a) : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat (equiv p1 p2)] = let aux_lr () : Lemma (requires H.equiv p1 p2) (ensures equiv p1 p2) [SMTPat ()] = () in let aux_rl_helper1 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p1 h) (ensures H.interp p2 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl_helper2 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p2 h) (ensures H.interp p1 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl () : Lemma (requires equiv p1 p2) (ensures H.equiv p1 p2) [SMTPat ()] = () in () let equiv_heap_iff_equiv_forall () : Lemma (ensures (forall p1 p2. H.equiv p1 p2 <==> equiv p1 p2)) = let aux p1 p2 : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat ()] = equiv_heap_iff_equiv p1 p2 in () #pop-options let equiv_extensional_on_star (p1 p2 p3:slprop u#a) = equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3 let emp_unit p = H.emp_unit p let intro_emp m = H.intro_emp (heap_of_mem m) let pure_equiv p q = H.pure_equiv p q let pure_interp q m = H.pure_interp q (heap_of_mem m) let pure_star_interp p q m = H.pure_star_interp p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// //pts_to //////////////////////////////////////////////////////////////////////////////// let pts_to_compatible #a #pcm x v0 v1 m = H.pts_to_compatible #a #pcm x v0 v1 (heap_of_mem m) let pts_to_compatible_equiv #a #pcm x v0 v1 = H.pts_to_compatible_equiv #a #pcm x v0 v1 let pts_to_not_null #a #pcm x v m = H.pts_to_not_null #a #pcm x v (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // star //////////////////////////////////////////////////////////////////////////////// let intro_star p q mp mq = H.intro_star p q (heap_of_mem mp) (heap_of_mem mq) let elim_star p q m = let h = heap_of_mem m in H.elim_star p q h; assert (exists hl hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr); let hl = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hl -> exists hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let hr = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hr -> H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let ml = mem_set_heap m hl in let mr = mem_set_heap m hr in assert (disjoint ml mr); assert (m == join ml mr); assert (interp p ml); assert (interp q mr); () let interp_star (p q: slprop) (m: mem) : Lemma (interp (p `star` q) m <==> (exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m)) = let left = interp (p `star` q) m in let right = exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m in let f () : Lemma (requires left) (ensures right) = elim_star p q m in let g () : Lemma (requires right) (ensures left) = Classical.exists_elim left #_ #(fun mp -> exists (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mp -> Classical.exists_elim left #_ #(fun mq -> disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mq -> intro_star p q mp mq ) ) in Classical.move_requires f (); Classical.move_requires g () let star_commutative (p1 p2:slprop) = H.star_commutative p1 p2 let star_associative (p1 p2 p3:slprop) = H.star_associative p1 p2 p3 let star_congruence (p1 p2 p3 p4:slprop) = equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4 let affine_star (p q:slprop) (m:mem) = H.affine_star p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // Invariants on the lock store //////////////////////////////////////////////////////////////////////////////// let iname = nat module S = FStar.Set module L = FStar.List.Tot module W = FStar.Witnessed.Core let rec lock_store_invariant (e:inames) (l:lock_store u#a) : slprop u#a = let current_addr = L.length l - 1 in match l with | [] -> emp | Invariant p :: tl -> if current_addr `S.mem` e then lock_store_invariant e tl else p `star` lock_store_invariant e tl let lock_i (i:iname) (l:lock_store { i < L.length l }) = let ix = L.length l - i - 1 in L.index l ix let iname_for_p (i:iname) (p:slprop) : W.s_predicate lock_store = fun l -> i < L.length l /\ (lock_i i l).inv == p let lock_store_evolves : FStar.Preorder.preorder lock_store = fun (l1 l2 : lock_store) -> L.length l2 >= L.length l1 /\ (forall (i:nat{i < L.length l1}). (lock_i i l1).inv == (lock_i i l2).inv) let inames_in (e:inames) (l:lock_store) : prop = forall i. Set.mem i e ==> i < L.length l let inames_ok e m = inames_in e m.locks let inames_ok_empty m = () let extend_lock_store (e:inames) (l:lock_store{e `inames_in` l}) (p:slprop) : i:iname & l':lock_store { lock_store_invariant e l' == p `star` lock_store_invariant e l /\ iname_for_p i p l' } = (| L.length l, Invariant p :: l |) let set_add (i:iname) (s:inames) = Set.union (Set.singleton i) s let rec move_invariant (e:inames) (l:lock_store) (p:slprop) (i:iname{iname_for_p i p l /\ ~(i `Set.mem` e)}) : Lemma (H.equiv (lock_store_invariant e l) (p `star` lock_store_invariant (set_add i e) l)) = let rec aux (i:iname) (m:lock_store) : Lemma (requires i >= L.length m) (ensures (lock_store_invariant e m `H.equiv` lock_store_invariant (set_add i e) m)) = match m with | [] -> () | Invariant p::tl -> aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl) in let current_addr = L.length l - 1 in match l with | [] -> () | Invariant q::tl -> if i = current_addr then begin assert (lock_store_invariant e l == p `star` lock_store_invariant e tl); aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl); () end else begin move_invariant e tl p i; assert (lock_store_invariant e tl `equiv` (p `star` lock_store_invariant (set_add i e) tl)); H.star_congruence q (lock_store_invariant e tl) q (p `star` lock_store_invariant (set_add i e) tl); if Set.mem current_addr e then () else begin let r = lock_store_invariant (set_add i e) tl in assert (lock_store_invariant e l `equiv` (q `star` (p `star` r))); H.star_associative q p r; H.star_commutative q p; H.star_congruence (q `star` p) r (p `star` q) r; H.star_associative p q r end end let heap_ctr_valid (ctr:nat) (h:H.heap u#a) : prop = h `H.free_above_addr` ctr let ctr_validity (ctr:nat) (h:H.heap) : slprop = H.pure (heap_ctr_valid ctr h) let locks_invariant (e:inames) (m:mem u#a) : slprop u#a = lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m) let full_mem_pred (m:mem) = H.full_heap_pred (heap_of_mem m) (***** Following lemmas are needed in Steel.Effect *****) let core_mem_interp (hp:slprop u#a) (m:mem u#a) = () let interp_depends_only_on (hp:slprop u#a) = H.interp_depends_only_on hp let a_mem_prop_as_a_heap_prop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (H.a_heap_prop u#a) = let g (h: H.heap u#a) : Tot prop = interp sl (mem_of_heap h) /\ f (mem_of_heap h) in let phi0 (h0 h1: H.heap u#a) : Lemma (requires (g h0 /\ H.disjoint h0 h1)) (ensures (g h0 /\ H.disjoint h0 h1 /\ g (H.join h0 h1))) = assert (mem_of_heap (H.join h0 h1) == mem_of_heap h0 `join` mem_of_heap h1); interp_depends_only_on sl in let phi1 (h0 h1: H.heap u#a) : Lemma (ensures ((g h0 /\ H.disjoint h0 h1) ==> g (H.join h0 h1))) = Classical.move_requires (phi0 h0) h1 in Classical.forall_intro_2 phi1; g let refine_slprop sl f = H.as_slprop (a_mem_prop_as_a_heap_prop sl f) let interp_refine_slprop sl f m = assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_mem m)) let dep_hprop (s: slprop) (f: (hmem s -> Tot slprop)) (h: H.heap) : Tot prop = exists (h1: H.heap) . exists (h2: H.heap) . interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 let dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq' : squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h')) = let p2 (h h1 h2: H.heap) : Tot prop = interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 in let p1 (h h1: H.heap) : Tot prop = (exists h2 . p2 h h1 h2) in let h1 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p1 h) in let h2 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p2 h h1) in H.disjoint_join h' h1 h2; assert (H.disjoint h2 h'); let h2' = H.join h2 h' in H.join_commutative h2 h' ; assert (h2' == H.join h' h2); assert (H.disjoint h1 h2'); assert (mem_of_heap h2' == mem_of_heap h2 `join` mem_of_heap h'); interp_depends_only_on (f (mem_of_heap h1)); assert (interp (f (mem_of_heap h1)) (mem_of_heap h2')); H.join_commutative h1 h2; H.join_associative h' h2 h1; H.join_commutative h' h; H.join_commutative h2' h1; assert (H.join h h' == h1 `H.join` h2') let impl_intro_gen (#p: Type0) (#q: Type0) ($prf: (squash p -> Lemma (q ))) : Lemma (p ==> q) = Classical.impl_intro_gen #p #(fun _ -> q) prf let dep_hprop_is_affine1 (s: slprop) (f: (hmem s -> Tot slprop)) (h0 h1: H.heap) : Lemma ((dep_hprop s f h0 /\ H.disjoint h0 h1) ==> (H.disjoint h0 h1 /\ dep_hprop s f (H.join h0 h1))) = impl_intro_gen (dep_hprop_is_affine0 s f h0 h1) let dep_hprop_is_affine (s: slprop) (f: (hmem s -> Tot slprop)) : Lemma (H.heap_prop_is_affine (dep_hprop s f)) = Classical.forall_intro_2 (dep_hprop_is_affine1 s f) let sdep (s: slprop) (f: (hmem s -> Tot slprop)) : Tot slprop = dep_hprop_is_affine s f; H.as_slprop (dep_hprop s f) let interp_sdep (s: slprop) (f: (hmem s -> Tot slprop)) (m: mem) : Lemma (requires (dep_slprop_is_affine s f)) (ensures ( interp (sdep s f) m <==> (exists m1 m2 . interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) )) = dep_hprop_is_affine s f; assert (forall m1 m2 . (interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) ==> ( interp s (mem_of_heap m1.heap) /\ interp (f (mem_of_heap m1.heap)) (mem_of_heap m2.heap) /\ H.disjoint m1.heap m2.heap /\ H.join m1.heap m2.heap == m.heap )); interp_depends_only_on s; Classical.forall_intro (fun m -> interp_depends_only_on (f m)); assert (forall h1 h2 . (interp s (mem_of_heap h1) /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ H.disjoint h1 h2 /\ H.join h1 h2 == m.heap) ==> ( core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ interp s (core_mem (mem_of_heap h1)) /\ interp s (mem_set_heap m h1) /\ core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ f (mem_set_heap m h1) `equiv` f (mem_of_heap h1) /\ interp (f (mem_set_heap m h1)) (mem_of_heap h2) /\ interp (f (mem_set_heap m h1)) (mem_set_heap m h2) /\ disjoint (mem_set_heap m h1) (mem_set_heap m h2) /\ join (mem_set_heap m h1) (mem_set_heap m h2) == m )); () let h_exists_cong (#a:Type) (p q : a -> slprop) : Lemma (requires (forall x. p x `equiv` q x)) (ensures (h_exists p `equiv` h_exists q)) = equiv_heap_iff_equiv_forall (); H.h_exists_cong p q let intro_h_exists #a x p m = H.intro_h_exists x p (heap_of_mem m) let elim_h_exists (#a:_) (p:a -> slprop) (m:mem) = H.elim_h_exists p (heap_of_mem m) let intro_h_forall (#a:_) (p:a -> slprop) (m:mem) = H.intro_h_forall p (heap_of_mem m) let elim_h_forall (#a:_) (p:a -> slprop) (m:mem) (x:a) = H.elim_h_forall p (heap_of_mem m) x let intro_h_and (p q: slprop) (m:mem) = H.intro_h_and p q (heap_of_mem m) let elim_h_and (p q: slprop) (m:mem) = H.elim_h_and p q (heap_of_mem m) let intro_h_or_left (p q: slprop) (m:mem) = H.intro_h_or_left p q (heap_of_mem m) let intro_h_or_right (p q: slprop) (m:mem) = H.intro_h_or_right p q (heap_of_mem m) let elim_h_or (p q: slprop) (m:mem) = H.elim_h_or p q (heap_of_mem m) let intro_wand (p1 p2: slprop u#a) (m:mem) = introduce (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)) ==> interp (wand p1 p2) m with _. ( assert (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)); H.intro_wand p1 p2 (heap_of_mem m); let h = heap_of_mem m in assert ((forall h1. h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) ==> H.interp (wand p1 p2) h); introduce forall h1. (h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) with ( introduce (h `H.disjoint` h1 /\ H.interp p1 h1) ==> H.interp p2 (H.join h h1) with _. ( assert (h `H.disjoint` h1); let m1 = { ctr = m.ctr; heap = h1; locks = m.locks } in assert (m `disjoint` m1) ) ) ) (** Eliminating a wand by proving a heap that satisfies the LHS **) let elim_wand (p1 p2: slprop u#a) (m:mem) (m1:mem) = H.elim_wand p1 p2 (heap_of_mem m) (heap_of_mem m1) //////////////////////////////////////////////////////////////////////////////// // Preorders and effects //////////////////////////////////////////////////////////////////////////////// module PP = Steel.Preorder let mem_evolves = fun (m0 m1:full_mem) -> H.heap_evolves (heap_of_mem m0) (heap_of_mem m1) /\ m0.ctr <= m1.ctr /\ lock_store_evolves m0.locks m1.locks (** See [Steel.Heap.is_frame_preserving]. We add in [lock_invariants] now *) let preserves_frame (e:inames) (pre post:slprop) (m0 m1:mem) = forall (frame:slprop). interp ((pre `star` frame) `star` locks_invariant e m0) m0 ==> (interp ((post `star` frame) `star` locks_invariant e m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) (** This is a version of MstTot with frame quantified, as part of preserves_frame *) effect MstTotNF (a:Type u#a) (except:inames) (expects:slprop u#1) (provides: a -> slprop u#1) = NMSTTotal.NMSTATETOT a (full_mem u#1) mem_evolves (requires fun m0 -> inames_ok except m0 /\ interp (expects `star` locks_invariant except m0) m0) (ensures fun m0 x m1 -> inames_ok except m1 /\ interp (provides x `star` locks_invariant except m1) m1 /\ preserves_frame except expects (provides x) m0 m1) //////////////////////////////////////////////////////////////////////////////// // Lifting heap actions //////////////////////////////////////////////////////////////////////////////// (** Heap actions come in two equivalent flavors: - one that take an explicit frame as argument (action_with_frame) - and one that quantify over all the frame We therefore define two lift routes: - a direct route for those with explicit frame - via MstTotNF for the rest *) let tot_pre_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = hmem_with_inv_except e fp -> (x:a & hmem_with_inv_except e (fp' x)) let tot_pre_action_nf = tot_pre_action_nf_except S.empty let ac_reasoning_for_m_frame_preserving (p q r:slprop u#a) (m:mem u#a) : Lemma (requires interp ((p `star` q) `star` r) m) (ensures interp (p `star` r) m) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_commutative p q; equiv_extensional_on_star (p `star` q) (q `star` p) r } (q `star` p) `star` r; (equiv) { star_associative q p r } q `star` (p `star` r); }; assert (interp (q `star` (p `star` r)) m); affine_star q (p `star` r) m let is_frame_preserving (#e:inames) (#a:Type u#b) (#fp:slprop u#a) (#fp':a -> slprop u#a) (f:tot_pre_action_nf_except e fp a fp') = forall (frame:slprop u#a) (m0:hmem_with_inv_except e (fp `star` frame)). (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = f:tot_pre_action_nf_except e fp a fp'{ is_frame_preserving f } let tot_action_nf = tot_action_nf_except S.empty let linv e (m:mem) = locks_invariant e m let hheap_of_hmem #fp #e (m:hmem_with_inv_except e fp) : h:H.hheap (fp `star` linv e m) { h `H.free_above_addr` m.ctr} = let h = heap_of_mem m in H.pure_interp (heap_ctr_valid m.ctr (heap_of_mem m)) h; h let hmem_of_hheap #e (#fp0 #fp1:slprop) (m:hmem_with_inv_except e fp0) (h:H.full_hheap (fp1 `star` linv e m) { h `Heap.free_above_addr` m.ctr }) : m1:hmem_with_inv_except e fp1{linv e m `equiv` linv e m1} = let m1 : mem = { m with heap = h } in assert (interp (fp1 `star` linv e m) m1); star_commutative fp1 (linv e m); assert (interp (linv e m `star` fp1) m1); assert (linv e m1 == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); assert (linv e m == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m)); H.pure_interp (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_of_mem m); assert (heap_ctr_valid m1.ctr (heap_of_mem m) <==> heap_ctr_valid m1.ctr (heap_of_mem m1)); H.pure_equiv (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_ctr_valid m1.ctr (heap_of_mem m1)); H.star_congruence (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m)); assert (linv e m `equiv` linv e m1); let _ = equiv_extensional_on_star (linv e m) (linv e m1) fp1 in assert ((linv e m `star` fp1) `equiv` (linv e m1 `star` fp1)); assert (interp (linv e m1 `star` fp1) m1); star_commutative (linv e m1) fp1; assert (interp (fp1 `star` linv e m1) m1); m1 let with_inv_except (m:mem) e (fp:slprop) = interp (fp `star` locks_invariant e m) m #push-options "--warn_error -271" let as_hprop (frame:slprop) (mp:mprop frame) : hp:H.hprop frame{forall m. mp (core_mem m) == hp (heap_of_mem m)} = let f = fun h -> mp (mem_of_heap h) in assert (forall m. mp (core_mem m) == f (heap_of_mem m)); let aux (m0:H.hheap frame) (m1:H.heap{H.disjoint m0 m1}) : Lemma (ensures (mem_of_heap (H.join m0 m1) == join (mem_of_heap m0) (mem_of_heap m1))) [SMTPat ()] = () in f let mprop_preservation_of_hprop_preservation (p:slprop) (m0 m1:mem) : Lemma (requires (forall (hp:H.hprop p). hp (heap_of_mem m0) == hp (heap_of_mem m1))) (ensures (forall (mp:mprop p). mp (core_mem m0) == mp (core_mem m1))) = let aux (mp:mprop p) : Lemma (mp (core_mem m0) == mp (core_mem m1)) [SMTPat()] = assert (as_hprop p mp (heap_of_mem m0) == as_hprop p mp (heap_of_mem m1)) in () let lift_heap_action (#fp:slprop) (#a:Type) (#fp':a -> slprop) (e:inames) ($f:H.action fp a fp') : tot_action_nf_except e fp a fp' = let g : tot_pre_action_nf_except e fp a fp' = fun m -> let h0 = hheap_of_hmem m in let (| x, h' |) = f h0 in (| x, hmem_of_hheap m h' |) in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in let h0 = hheap_of_hmem m0 in let (| x', h1 |) = f h0 in H.action_framing f (linv e m0) h0; assert (x == x'); star_associative fp frame (linv e m0); H.action_framing f (frame `star` linv e m0) h0; assert (H.interp ((fp' x) `star` (frame `star` linv e m0)) h1); star_associative (fp' x) frame (linv e m0); assert (H.interp ((fp' x `star` frame) `star` linv e m0) h1); let h1' : H.hheap ((fp' x `star` frame) `star` linv e m0) = h1 in assert (m1 == hmem_of_hheap m0 h1'); assert (with_inv_except m1 e (fp' x `star` frame)); assert (forall (hp:H.hprop frame). hp h0 == hp h1); mprop_preservation_of_hprop_preservation frame m0 m1; () in assert (is_frame_preserving g); g let frame_preserving_respects_preorder #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (m0:hmem_with_inv_except e fp) : Lemma (let (| x, m1 |) = f m0 in mem_evolves m0 m1) = let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1) = () in H.emp_unit fp; assert (interp (fp `star` linv e m0) m0); H.star_congruence (fp `star` emp) (linv e m0) fp (linv e m0); assert (interp ((fp `star` emp) `star` linv e m0) m0); aux emp m0 let lift_tot_action_nf #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') : MstTotNF a e fp fp' = let m0 = NMSTTotal.get () in let m0' : hmem_with_inv_except e fp = m0 in let r = f m0' in let (| x, m1 |) = r in let m1' : hmem_with_inv_except e (fp' x) = m1 in assert (is_frame_preserving f); assert (m1 == dsnd (f m0)); frame_preserving_respects_preorder f m0; NMSTTotal.put #_ #(mem_evolves) m1; x let lift_tot_action #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get #(full_mem) #_ () in ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); lift_tot_action_nf f (** Now defining the lift for heap actions with explicit frame *) let tot_action_with_frame_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = frame:slprop u#a -> m0:hmem_with_inv_except e (fp `star` frame) -> Pure (x:a & hmem_with_inv_except e (fp' x `star` frame)) (requires True) (ensures fun (| x, m1 |) -> mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_with_frame = tot_action_with_frame_except S.empty let lift_heap_action_with_frame (#fp:slprop u#a) (#a:Type u#b) (#fp':a -> slprop u#a) (e:inames) ($f:H.action_with_frame fp a fp') : tot_action_with_frame_except e fp a fp' = fun frame m0 -> let h0 = hheap_of_hmem m0 in calc (equiv) { fp `star` frame `star` locks_invariant e m0; (equiv) { star_associative fp frame (locks_invariant e m0) } fp `star` (frame `star` locks_invariant e m0); }; assert (H.interp (fp `star` frame `star` locks_invariant e m0) h0); assert (H.interp (fp `star` (frame `star` locks_invariant e m0)) h0); //key: apply the heap action with frame * locks_invariant e m0 let (| x, h1 |) = f (frame `star` locks_invariant e m0) h0 in calc (equiv) { fp' x `star` (frame `star` locks_invariant e m0); (equiv) { star_associative (fp' x) frame (locks_invariant e m0) } fp' x `star` frame `star` locks_invariant e m0; }; assert (H.interp (fp' x `star` (frame `star` locks_invariant e m0)) h1); assert (H.interp (fp' x `star` frame `star` locks_invariant e m0) h1); let m1 = hmem_of_hheap m0 h1 in assert (mem_evolves m0 m1); mprop_preservation_of_hprop_preservation (frame `star` locks_invariant e m0) m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)); (| x, m1 |) let lift_tot_action_with_frame #a #e #fp #fp' ($f:tot_action_with_frame_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in assert (inames_ok e m0); ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); let m0' : hmem_with_inv_except e fp = m0 in let r = f frame m0' in let (| x, m1 |) = r in ac_reasoning_for_m_frame_preserving (fp' x) frame (locks_invariant e m1) m1; assert (interp (fp' x `star` frame `star` locks_invariant e m1) m1); assert (interp (fp' x `star` locks_invariant e m1) m1); let m1' : hmem_with_inv_except e (fp' x) = m1 in NMSTTotal.put #_ #(mem_evolves) m1; x let sel_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.sel_action #a #pcm r v0)) let upd_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.upd_action #a #pcm r v0 v1)) let free_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.free_action #a #pcm r v0)) let split_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.split_action #a #pcm r v0 v1)) let gather_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.gather_action #a #pcm r v0 v1)) let weaken (p q r:slprop) (h:H.hheap (p `star` q) { H.stronger q r }) : H.hheap (p `star` r) = H.weaken p q r h; h let weaken_pure (q r: prop) : Lemma (requires (q ==> r)) (ensures H.stronger (H.pure q) (H.pure r)) = let aux (h:H.heap) : Lemma (ensures (H.interp (H.pure q) h ==> H.interp (H.pure r) h)) [SMTPat ()] = H.pure_interp q h; H.pure_interp r h in () let inc_ctr (#p:slprop) #e (m:hmem_with_inv_except e p) : m':hmem_with_inv_except e p{m'.ctr = m.ctr + 1 /\ H.stronger (linv e m) (linv e m')} = let m' : mem = { m with ctr = m.ctr + 1} in assert (interp (p `star` linv e m) m'); assert (linv e m == lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m)); assert (linv e m' == lock_store_invariant e m.locks `star` ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken_free_above (heap_of_mem m) m.ctr (m.ctr + 1); weaken_pure (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_ctr_valid (m.ctr + 1) (heap_of_mem m)); assert (H.stronger (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m))); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)); H.stronger_star (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken (p `star` lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)) (heap_of_mem m'); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity (m.ctr + 1) (heap_of_mem m)); let m' : hmem_with_inv_except e p = m' in m' let frame_related_mems (fp0 fp1:slprop u#a) e (m0:hmem_with_inv_except e fp0) (m1:hmem_with_inv_except e fp1) = forall (frame:slprop u#a). interp ((fp0 `star` frame) `star` linv e m0) m0 ==> interp ((fp1 `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) let refined_pre_action e (fp0:slprop) (a:Type) (fp1:a -> slprop) = m0:hmem_with_inv_except e fp0 -> Pure (x:a & hmem_with_inv_except e (fp1 x)) (requires True) (ensures fun (| x, m1 |) -> frame_related_mems fp0 (fp1 x) e m0 m1) let refined_pre_action_as_action (#fp0:slprop) (#a:Type) (#fp1:a -> slprop) #e ($f:refined_pre_action e fp0 a fp1) : tot_action_nf_except e fp0 a fp1 = let g : tot_pre_action_nf_except e fp0 a fp1 = fun m -> f m in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp0 `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp1 x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x', m1' |) = g m0 in let (| x, m1 |) = f m0 in assert (x == x' /\ m1 == m1') in g let alloc_action #a #pcm e x = let f : refined_pre_action e emp (ref a pcm) (fun r -> pts_to r x) = fun m0 -> (* NS: 9/29/22 I needed to annotate h : Heap.full_heap, for use with the Core checker which generates a guard for checking the implicit pattern "dot" term in the dependent pair pattern on the next line. That guard expects `h` to be a full_heap, which is it, because it is a projection of m0. However, this is not reflected in `h`'s type. So, the Core checker, which produces a guard for the pat_dot_term in isolation, cannot recheck the term. If we were to fold in the checking of pat_dot_terms and their guards with the rest of the VC, this would work. *) let h : Heap.full_heap = hheap_of_hmem m0 in let (|r, h'|) = H.extend #a #pcm x m0.ctr h in let m' : hmem_with_inv_except e emp = inc_ctr m0 in let h' : H.hheap (pts_to #a #pcm r x `star` linv e m') = weaken _ (linv e m0) (linv e m') h' in let m1 : hmem_with_inv_except e (pts_to #a #pcm r x) = hmem_of_hheap m' h' in assert (forall frame. H.frame_related_heaps h h' emp (pts_to #a #pcm r x) frame true); let aux (frame:slprop) : Lemma (requires interp ((emp `star` frame) `star` linv e m0) m0) (ensures interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) [SMTPat (emp `star` frame)] = star_associative emp frame (linv e m0); assert (H.interp (emp `star` (frame `star` linv e m0)) h); assert (H.interp (pts_to #a #pcm r x `star` (frame `star` linv e m0)) h'); star_associative (pts_to #a #pcm r x) frame (linv e m0); assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m0) h'); assert (H.stronger (linv e m0) (linv e m')); assert (H.equiv (linv e m') (linv e m1)); assert (H.stronger (linv e m0) (linv e m1)); let h' : H.hheap ((pts_to #a #pcm r x `star` frame) `star` linv e m1) = weaken _ (linv e m0) (linv e m1) h' in assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) h'); assert (forall (mp:H.hprop frame). mp h == mp h'); mprop_preservation_of_hprop_preservation frame m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) in assert (frame_related_mems emp (pts_to r x) e m0 m1); (| r, m1 |) in lift_tot_action (refined_pre_action_as_action f) let select_refine #a #p e r x f = lift_tot_action (lift_heap_action e (H.select_refine #a #p r x f))

{ "checked_file": "/", "dependencies": [ "Steel.Preorder.fst.checked", "Steel.Heap.fsti.checked", "prims.fst.checked", "FStar.Witnessed.Core.fsti.checked", "FStar.Set.fsti.checked", "FStar.Preorder.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.PCM.fst.checked", "FStar.NMSTTotal.fst.checked", "FStar.List.Tot.fst.checked", "FStar.IndefiniteDescription.fsti.checked", "FStar.Ghost.fsti.checked", "FStar.FunctionalExtensionality.fsti.checked", "FStar.Classical.Sugar.fsti.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Steel.Memory.fst" }

[ { "abbrev": true, "full_module": "Steel.Preorder", "short_module": "PP" }, { "abbrev": true, "full_module": "FStar.Witnessed.Core", "short_module": "W" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": true, "full_module": "Steel.Heap", "short_module": "H" }, { "abbrev": false, "full_module": "FStar.FunctionalExtensionality", "short_module": null }, { "abbrev": true, "full_module": "FStar.FunctionalExtensionality", "short_module": "F" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": false, "full_module": "FStar.PCM", "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

e: Steel.Memory.inames -> r: Steel.Memory.ref a p -> x: FStar.Ghost.erased a -> y: FStar.Ghost.erased a -> f: FStar.PCM.frame_preserving_upd p (FStar.Ghost.reveal x) (FStar.Ghost.reveal y) -> Steel.Memory.action_except Prims.unit e (Steel.Memory.pts_to r (FStar.Ghost.reveal x)) (fun _ -> Steel.Memory.pts_to r (FStar.Ghost.reveal y))

Prims.Tot

[ "total" ]

[]

[ "FStar.PCM.pcm", "Steel.Memory.inames", "Steel.Memory.ref", "FStar.Ghost.erased", "FStar.PCM.frame_preserving_upd", "FStar.Ghost.reveal", "Steel.Memory.lift_tot_action", "Prims.unit", "Steel.Heap.pts_to", "Steel.Memory.slprop", "Steel.Memory.lift_heap_action", "Steel.Heap.upd_gen_action", "Steel.Memory.action_except", "Steel.Memory.pts_to" ]

[]

false

let upd_gen #a #p e r x y f =

lift_tot_action (lift_heap_action e (H.upd_gen_action r x y f))

false

Steel.Memory.fst

Steel.Memory.new_invariant

val new_invariant (e:inames) (p:slprop) : action_except (inv p) e p (fun _ -> emp)

let new_invariant (e:inames) (p:slprop) (frame:slprop) : MstTot (inv p) e p (fun _ -> emp) frame (fun _ -> True) (fun _ _ _ -> True) = fresh_invariant e p [] frame

{ "file_name": "lib/steel/Steel.Memory.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 32, "end_line": 1292, "start_col": 0, "start_line": 1290 }

(* 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.Memory module F = FStar.FunctionalExtensionality open FStar.FunctionalExtensionality open FStar.PCM module H = Steel.Heap noeq type lock_state : Type u#(a + 1) = | Invariant : inv:H.slprop u#a -> lock_state let lock_store : Type u#(a+1) = list (lock_state u#a) noeq type mem : Type u#(a + 1) = { ctr: nat; heap: H.heap u#a; locks: lock_store u#a; } let heap_of_mem (x:mem) : H.heap = x.heap let mem_of_heap (h:H.heap) : mem = { ctr = 0; heap = h; locks = [] } let mem_set_heap (m:mem) (h:H.heap) : mem = { ctr = m.ctr; heap = h; locks = m.locks; } let core_mem (m:mem) : mem = mem_of_heap (heap_of_mem m) let core_mem_invol m = () let disjoint (m0 m1:mem u#h) : prop = m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks let disjoint_sym m0 m1 = () let join m0 m1 = { ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = m0.locks } let join_commutative m0 m1 = H.join_commutative m0.heap m1.heap let disjoint_join m0 m1 m2 = H.disjoint_join m0.heap m1.heap m2.heap let join_associative m0 m1 m2 = H.join_associative m0.heap m1.heap m2.heap let slprop = H.slprop let interp p m = H.interp p m.heap let equiv p1 p2 = forall m. interp p1 m <==> interp p2 m let slprop_extensionality p q = assert (forall m. interp p m <==> interp q m); let aux (h:H.heap) : Lemma (H.interp p h <==> H.interp q h) [SMTPat (H.interp p h)] = let m : mem = { ctr = 0; heap = h; locks = [] } in assert (interp p m <==> interp q m) in assert (forall h. H.interp p h <==> H.interp q h); Steel.Heap.slprop_extensionality p q let reveal_equiv p1 p2 = () let core_ref = H.core_ref let core_ref_null = H.core_ref_null let core_ref_is_null r = H.core_ref_is_null r let emp : slprop u#a = H.emp let pure = H.pure let pts_to = H.pts_to let h_and = H.h_and let h_or = H.h_or let star = H.star let wand = H.wand let h_exists = H.h_exists let h_forall = H.h_forall //////////////////////////////////////////////////////////////////////////////// //properties of equiv //////////////////////////////////////////////////////////////////////////////// let equiv_symmetric (p1 p2:slprop u#a) = H.equiv_symmetric p1 p2 #push-options "--warn_error -271" let equiv_heap_iff_equiv (p1 p2:slprop u#a) : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat (equiv p1 p2)] = let aux_lr () : Lemma (requires H.equiv p1 p2) (ensures equiv p1 p2) [SMTPat ()] = () in let aux_rl_helper1 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p1 h) (ensures H.interp p2 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl_helper2 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p2 h) (ensures H.interp p1 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl () : Lemma (requires equiv p1 p2) (ensures H.equiv p1 p2) [SMTPat ()] = () in () let equiv_heap_iff_equiv_forall () : Lemma (ensures (forall p1 p2. H.equiv p1 p2 <==> equiv p1 p2)) = let aux p1 p2 : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat ()] = equiv_heap_iff_equiv p1 p2 in () #pop-options let equiv_extensional_on_star (p1 p2 p3:slprop u#a) = equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3 let emp_unit p = H.emp_unit p let intro_emp m = H.intro_emp (heap_of_mem m) let pure_equiv p q = H.pure_equiv p q let pure_interp q m = H.pure_interp q (heap_of_mem m) let pure_star_interp p q m = H.pure_star_interp p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// //pts_to //////////////////////////////////////////////////////////////////////////////// let pts_to_compatible #a #pcm x v0 v1 m = H.pts_to_compatible #a #pcm x v0 v1 (heap_of_mem m) let pts_to_compatible_equiv #a #pcm x v0 v1 = H.pts_to_compatible_equiv #a #pcm x v0 v1 let pts_to_not_null #a #pcm x v m = H.pts_to_not_null #a #pcm x v (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // star //////////////////////////////////////////////////////////////////////////////// let intro_star p q mp mq = H.intro_star p q (heap_of_mem mp) (heap_of_mem mq) let elim_star p q m = let h = heap_of_mem m in H.elim_star p q h; assert (exists hl hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr); let hl = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hl -> exists hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let hr = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hr -> H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let ml = mem_set_heap m hl in let mr = mem_set_heap m hr in assert (disjoint ml mr); assert (m == join ml mr); assert (interp p ml); assert (interp q mr); () let interp_star (p q: slprop) (m: mem) : Lemma (interp (p `star` q) m <==> (exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m)) = let left = interp (p `star` q) m in let right = exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m in let f () : Lemma (requires left) (ensures right) = elim_star p q m in let g () : Lemma (requires right) (ensures left) = Classical.exists_elim left #_ #(fun mp -> exists (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mp -> Classical.exists_elim left #_ #(fun mq -> disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mq -> intro_star p q mp mq ) ) in Classical.move_requires f (); Classical.move_requires g () let star_commutative (p1 p2:slprop) = H.star_commutative p1 p2 let star_associative (p1 p2 p3:slprop) = H.star_associative p1 p2 p3 let star_congruence (p1 p2 p3 p4:slprop) = equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4 let affine_star (p q:slprop) (m:mem) = H.affine_star p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // Invariants on the lock store //////////////////////////////////////////////////////////////////////////////// let iname = nat module S = FStar.Set module L = FStar.List.Tot module W = FStar.Witnessed.Core let rec lock_store_invariant (e:inames) (l:lock_store u#a) : slprop u#a = let current_addr = L.length l - 1 in match l with | [] -> emp | Invariant p :: tl -> if current_addr `S.mem` e then lock_store_invariant e tl else p `star` lock_store_invariant e tl let lock_i (i:iname) (l:lock_store { i < L.length l }) = let ix = L.length l - i - 1 in L.index l ix let iname_for_p (i:iname) (p:slprop) : W.s_predicate lock_store = fun l -> i < L.length l /\ (lock_i i l).inv == p let lock_store_evolves : FStar.Preorder.preorder lock_store = fun (l1 l2 : lock_store) -> L.length l2 >= L.length l1 /\ (forall (i:nat{i < L.length l1}). (lock_i i l1).inv == (lock_i i l2).inv) let inames_in (e:inames) (l:lock_store) : prop = forall i. Set.mem i e ==> i < L.length l let inames_ok e m = inames_in e m.locks let inames_ok_empty m = () let extend_lock_store (e:inames) (l:lock_store{e `inames_in` l}) (p:slprop) : i:iname & l':lock_store { lock_store_invariant e l' == p `star` lock_store_invariant e l /\ iname_for_p i p l' } = (| L.length l, Invariant p :: l |) let set_add (i:iname) (s:inames) = Set.union (Set.singleton i) s let rec move_invariant (e:inames) (l:lock_store) (p:slprop) (i:iname{iname_for_p i p l /\ ~(i `Set.mem` e)}) : Lemma (H.equiv (lock_store_invariant e l) (p `star` lock_store_invariant (set_add i e) l)) = let rec aux (i:iname) (m:lock_store) : Lemma (requires i >= L.length m) (ensures (lock_store_invariant e m `H.equiv` lock_store_invariant (set_add i e) m)) = match m with | [] -> () | Invariant p::tl -> aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl) in let current_addr = L.length l - 1 in match l with | [] -> () | Invariant q::tl -> if i = current_addr then begin assert (lock_store_invariant e l == p `star` lock_store_invariant e tl); aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl); () end else begin move_invariant e tl p i; assert (lock_store_invariant e tl `equiv` (p `star` lock_store_invariant (set_add i e) tl)); H.star_congruence q (lock_store_invariant e tl) q (p `star` lock_store_invariant (set_add i e) tl); if Set.mem current_addr e then () else begin let r = lock_store_invariant (set_add i e) tl in assert (lock_store_invariant e l `equiv` (q `star` (p `star` r))); H.star_associative q p r; H.star_commutative q p; H.star_congruence (q `star` p) r (p `star` q) r; H.star_associative p q r end end let heap_ctr_valid (ctr:nat) (h:H.heap u#a) : prop = h `H.free_above_addr` ctr let ctr_validity (ctr:nat) (h:H.heap) : slprop = H.pure (heap_ctr_valid ctr h) let locks_invariant (e:inames) (m:mem u#a) : slprop u#a = lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m) let full_mem_pred (m:mem) = H.full_heap_pred (heap_of_mem m) (***** Following lemmas are needed in Steel.Effect *****) let core_mem_interp (hp:slprop u#a) (m:mem u#a) = () let interp_depends_only_on (hp:slprop u#a) = H.interp_depends_only_on hp let a_mem_prop_as_a_heap_prop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (H.a_heap_prop u#a) = let g (h: H.heap u#a) : Tot prop = interp sl (mem_of_heap h) /\ f (mem_of_heap h) in let phi0 (h0 h1: H.heap u#a) : Lemma (requires (g h0 /\ H.disjoint h0 h1)) (ensures (g h0 /\ H.disjoint h0 h1 /\ g (H.join h0 h1))) = assert (mem_of_heap (H.join h0 h1) == mem_of_heap h0 `join` mem_of_heap h1); interp_depends_only_on sl in let phi1 (h0 h1: H.heap u#a) : Lemma (ensures ((g h0 /\ H.disjoint h0 h1) ==> g (H.join h0 h1))) = Classical.move_requires (phi0 h0) h1 in Classical.forall_intro_2 phi1; g let refine_slprop sl f = H.as_slprop (a_mem_prop_as_a_heap_prop sl f) let interp_refine_slprop sl f m = assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_mem m)) let dep_hprop (s: slprop) (f: (hmem s -> Tot slprop)) (h: H.heap) : Tot prop = exists (h1: H.heap) . exists (h2: H.heap) . interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 let dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq' : squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h')) = let p2 (h h1 h2: H.heap) : Tot prop = interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 in let p1 (h h1: H.heap) : Tot prop = (exists h2 . p2 h h1 h2) in let h1 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p1 h) in let h2 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p2 h h1) in H.disjoint_join h' h1 h2; assert (H.disjoint h2 h'); let h2' = H.join h2 h' in H.join_commutative h2 h' ; assert (h2' == H.join h' h2); assert (H.disjoint h1 h2'); assert (mem_of_heap h2' == mem_of_heap h2 `join` mem_of_heap h'); interp_depends_only_on (f (mem_of_heap h1)); assert (interp (f (mem_of_heap h1)) (mem_of_heap h2')); H.join_commutative h1 h2; H.join_associative h' h2 h1; H.join_commutative h' h; H.join_commutative h2' h1; assert (H.join h h' == h1 `H.join` h2') let impl_intro_gen (#p: Type0) (#q: Type0) ($prf: (squash p -> Lemma (q ))) : Lemma (p ==> q) = Classical.impl_intro_gen #p #(fun _ -> q) prf let dep_hprop_is_affine1 (s: slprop) (f: (hmem s -> Tot slprop)) (h0 h1: H.heap) : Lemma ((dep_hprop s f h0 /\ H.disjoint h0 h1) ==> (H.disjoint h0 h1 /\ dep_hprop s f (H.join h0 h1))) = impl_intro_gen (dep_hprop_is_affine0 s f h0 h1) let dep_hprop_is_affine (s: slprop) (f: (hmem s -> Tot slprop)) : Lemma (H.heap_prop_is_affine (dep_hprop s f)) = Classical.forall_intro_2 (dep_hprop_is_affine1 s f) let sdep (s: slprop) (f: (hmem s -> Tot slprop)) : Tot slprop = dep_hprop_is_affine s f; H.as_slprop (dep_hprop s f) let interp_sdep (s: slprop) (f: (hmem s -> Tot slprop)) (m: mem) : Lemma (requires (dep_slprop_is_affine s f)) (ensures ( interp (sdep s f) m <==> (exists m1 m2 . interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) )) = dep_hprop_is_affine s f; assert (forall m1 m2 . (interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) ==> ( interp s (mem_of_heap m1.heap) /\ interp (f (mem_of_heap m1.heap)) (mem_of_heap m2.heap) /\ H.disjoint m1.heap m2.heap /\ H.join m1.heap m2.heap == m.heap )); interp_depends_only_on s; Classical.forall_intro (fun m -> interp_depends_only_on (f m)); assert (forall h1 h2 . (interp s (mem_of_heap h1) /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ H.disjoint h1 h2 /\ H.join h1 h2 == m.heap) ==> ( core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ interp s (core_mem (mem_of_heap h1)) /\ interp s (mem_set_heap m h1) /\ core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ f (mem_set_heap m h1) `equiv` f (mem_of_heap h1) /\ interp (f (mem_set_heap m h1)) (mem_of_heap h2) /\ interp (f (mem_set_heap m h1)) (mem_set_heap m h2) /\ disjoint (mem_set_heap m h1) (mem_set_heap m h2) /\ join (mem_set_heap m h1) (mem_set_heap m h2) == m )); () let h_exists_cong (#a:Type) (p q : a -> slprop) : Lemma (requires (forall x. p x `equiv` q x)) (ensures (h_exists p `equiv` h_exists q)) = equiv_heap_iff_equiv_forall (); H.h_exists_cong p q let intro_h_exists #a x p m = H.intro_h_exists x p (heap_of_mem m) let elim_h_exists (#a:_) (p:a -> slprop) (m:mem) = H.elim_h_exists p (heap_of_mem m) let intro_h_forall (#a:_) (p:a -> slprop) (m:mem) = H.intro_h_forall p (heap_of_mem m) let elim_h_forall (#a:_) (p:a -> slprop) (m:mem) (x:a) = H.elim_h_forall p (heap_of_mem m) x let intro_h_and (p q: slprop) (m:mem) = H.intro_h_and p q (heap_of_mem m) let elim_h_and (p q: slprop) (m:mem) = H.elim_h_and p q (heap_of_mem m) let intro_h_or_left (p q: slprop) (m:mem) = H.intro_h_or_left p q (heap_of_mem m) let intro_h_or_right (p q: slprop) (m:mem) = H.intro_h_or_right p q (heap_of_mem m) let elim_h_or (p q: slprop) (m:mem) = H.elim_h_or p q (heap_of_mem m) let intro_wand (p1 p2: slprop u#a) (m:mem) = introduce (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)) ==> interp (wand p1 p2) m with _. ( assert (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)); H.intro_wand p1 p2 (heap_of_mem m); let h = heap_of_mem m in assert ((forall h1. h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) ==> H.interp (wand p1 p2) h); introduce forall h1. (h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) with ( introduce (h `H.disjoint` h1 /\ H.interp p1 h1) ==> H.interp p2 (H.join h h1) with _. ( assert (h `H.disjoint` h1); let m1 = { ctr = m.ctr; heap = h1; locks = m.locks } in assert (m `disjoint` m1) ) ) ) (** Eliminating a wand by proving a heap that satisfies the LHS **) let elim_wand (p1 p2: slprop u#a) (m:mem) (m1:mem) = H.elim_wand p1 p2 (heap_of_mem m) (heap_of_mem m1) //////////////////////////////////////////////////////////////////////////////// // Preorders and effects //////////////////////////////////////////////////////////////////////////////// module PP = Steel.Preorder let mem_evolves = fun (m0 m1:full_mem) -> H.heap_evolves (heap_of_mem m0) (heap_of_mem m1) /\ m0.ctr <= m1.ctr /\ lock_store_evolves m0.locks m1.locks (** See [Steel.Heap.is_frame_preserving]. We add in [lock_invariants] now *) let preserves_frame (e:inames) (pre post:slprop) (m0 m1:mem) = forall (frame:slprop). interp ((pre `star` frame) `star` locks_invariant e m0) m0 ==> (interp ((post `star` frame) `star` locks_invariant e m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) (** This is a version of MstTot with frame quantified, as part of preserves_frame *) effect MstTotNF (a:Type u#a) (except:inames) (expects:slprop u#1) (provides: a -> slprop u#1) = NMSTTotal.NMSTATETOT a (full_mem u#1) mem_evolves (requires fun m0 -> inames_ok except m0 /\ interp (expects `star` locks_invariant except m0) m0) (ensures fun m0 x m1 -> inames_ok except m1 /\ interp (provides x `star` locks_invariant except m1) m1 /\ preserves_frame except expects (provides x) m0 m1) //////////////////////////////////////////////////////////////////////////////// // Lifting heap actions //////////////////////////////////////////////////////////////////////////////// (** Heap actions come in two equivalent flavors: - one that take an explicit frame as argument (action_with_frame) - and one that quantify over all the frame We therefore define two lift routes: - a direct route for those with explicit frame - via MstTotNF for the rest *) let tot_pre_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = hmem_with_inv_except e fp -> (x:a & hmem_with_inv_except e (fp' x)) let tot_pre_action_nf = tot_pre_action_nf_except S.empty let ac_reasoning_for_m_frame_preserving (p q r:slprop u#a) (m:mem u#a) : Lemma (requires interp ((p `star` q) `star` r) m) (ensures interp (p `star` r) m) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_commutative p q; equiv_extensional_on_star (p `star` q) (q `star` p) r } (q `star` p) `star` r; (equiv) { star_associative q p r } q `star` (p `star` r); }; assert (interp (q `star` (p `star` r)) m); affine_star q (p `star` r) m let is_frame_preserving (#e:inames) (#a:Type u#b) (#fp:slprop u#a) (#fp':a -> slprop u#a) (f:tot_pre_action_nf_except e fp a fp') = forall (frame:slprop u#a) (m0:hmem_with_inv_except e (fp `star` frame)). (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = f:tot_pre_action_nf_except e fp a fp'{ is_frame_preserving f } let tot_action_nf = tot_action_nf_except S.empty let linv e (m:mem) = locks_invariant e m let hheap_of_hmem #fp #e (m:hmem_with_inv_except e fp) : h:H.hheap (fp `star` linv e m) { h `H.free_above_addr` m.ctr} = let h = heap_of_mem m in H.pure_interp (heap_ctr_valid m.ctr (heap_of_mem m)) h; h let hmem_of_hheap #e (#fp0 #fp1:slprop) (m:hmem_with_inv_except e fp0) (h:H.full_hheap (fp1 `star` linv e m) { h `Heap.free_above_addr` m.ctr }) : m1:hmem_with_inv_except e fp1{linv e m `equiv` linv e m1} = let m1 : mem = { m with heap = h } in assert (interp (fp1 `star` linv e m) m1); star_commutative fp1 (linv e m); assert (interp (linv e m `star` fp1) m1); assert (linv e m1 == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); assert (linv e m == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m)); H.pure_interp (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_of_mem m); assert (heap_ctr_valid m1.ctr (heap_of_mem m) <==> heap_ctr_valid m1.ctr (heap_of_mem m1)); H.pure_equiv (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_ctr_valid m1.ctr (heap_of_mem m1)); H.star_congruence (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m)); assert (linv e m `equiv` linv e m1); let _ = equiv_extensional_on_star (linv e m) (linv e m1) fp1 in assert ((linv e m `star` fp1) `equiv` (linv e m1 `star` fp1)); assert (interp (linv e m1 `star` fp1) m1); star_commutative (linv e m1) fp1; assert (interp (fp1 `star` linv e m1) m1); m1 let with_inv_except (m:mem) e (fp:slprop) = interp (fp `star` locks_invariant e m) m #push-options "--warn_error -271" let as_hprop (frame:slprop) (mp:mprop frame) : hp:H.hprop frame{forall m. mp (core_mem m) == hp (heap_of_mem m)} = let f = fun h -> mp (mem_of_heap h) in assert (forall m. mp (core_mem m) == f (heap_of_mem m)); let aux (m0:H.hheap frame) (m1:H.heap{H.disjoint m0 m1}) : Lemma (ensures (mem_of_heap (H.join m0 m1) == join (mem_of_heap m0) (mem_of_heap m1))) [SMTPat ()] = () in f let mprop_preservation_of_hprop_preservation (p:slprop) (m0 m1:mem) : Lemma (requires (forall (hp:H.hprop p). hp (heap_of_mem m0) == hp (heap_of_mem m1))) (ensures (forall (mp:mprop p). mp (core_mem m0) == mp (core_mem m1))) = let aux (mp:mprop p) : Lemma (mp (core_mem m0) == mp (core_mem m1)) [SMTPat()] = assert (as_hprop p mp (heap_of_mem m0) == as_hprop p mp (heap_of_mem m1)) in () let lift_heap_action (#fp:slprop) (#a:Type) (#fp':a -> slprop) (e:inames) ($f:H.action fp a fp') : tot_action_nf_except e fp a fp' = let g : tot_pre_action_nf_except e fp a fp' = fun m -> let h0 = hheap_of_hmem m in let (| x, h' |) = f h0 in (| x, hmem_of_hheap m h' |) in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in let h0 = hheap_of_hmem m0 in let (| x', h1 |) = f h0 in H.action_framing f (linv e m0) h0; assert (x == x'); star_associative fp frame (linv e m0); H.action_framing f (frame `star` linv e m0) h0; assert (H.interp ((fp' x) `star` (frame `star` linv e m0)) h1); star_associative (fp' x) frame (linv e m0); assert (H.interp ((fp' x `star` frame) `star` linv e m0) h1); let h1' : H.hheap ((fp' x `star` frame) `star` linv e m0) = h1 in assert (m1 == hmem_of_hheap m0 h1'); assert (with_inv_except m1 e (fp' x `star` frame)); assert (forall (hp:H.hprop frame). hp h0 == hp h1); mprop_preservation_of_hprop_preservation frame m0 m1; () in assert (is_frame_preserving g); g let frame_preserving_respects_preorder #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (m0:hmem_with_inv_except e fp) : Lemma (let (| x, m1 |) = f m0 in mem_evolves m0 m1) = let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1) = () in H.emp_unit fp; assert (interp (fp `star` linv e m0) m0); H.star_congruence (fp `star` emp) (linv e m0) fp (linv e m0); assert (interp ((fp `star` emp) `star` linv e m0) m0); aux emp m0 let lift_tot_action_nf #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') : MstTotNF a e fp fp' = let m0 = NMSTTotal.get () in let m0' : hmem_with_inv_except e fp = m0 in let r = f m0' in let (| x, m1 |) = r in let m1' : hmem_with_inv_except e (fp' x) = m1 in assert (is_frame_preserving f); assert (m1 == dsnd (f m0)); frame_preserving_respects_preorder f m0; NMSTTotal.put #_ #(mem_evolves) m1; x let lift_tot_action #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get #(full_mem) #_ () in ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); lift_tot_action_nf f (** Now defining the lift for heap actions with explicit frame *) let tot_action_with_frame_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = frame:slprop u#a -> m0:hmem_with_inv_except e (fp `star` frame) -> Pure (x:a & hmem_with_inv_except e (fp' x `star` frame)) (requires True) (ensures fun (| x, m1 |) -> mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_with_frame = tot_action_with_frame_except S.empty let lift_heap_action_with_frame (#fp:slprop u#a) (#a:Type u#b) (#fp':a -> slprop u#a) (e:inames) ($f:H.action_with_frame fp a fp') : tot_action_with_frame_except e fp a fp' = fun frame m0 -> let h0 = hheap_of_hmem m0 in calc (equiv) { fp `star` frame `star` locks_invariant e m0; (equiv) { star_associative fp frame (locks_invariant e m0) } fp `star` (frame `star` locks_invariant e m0); }; assert (H.interp (fp `star` frame `star` locks_invariant e m0) h0); assert (H.interp (fp `star` (frame `star` locks_invariant e m0)) h0); //key: apply the heap action with frame * locks_invariant e m0 let (| x, h1 |) = f (frame `star` locks_invariant e m0) h0 in calc (equiv) { fp' x `star` (frame `star` locks_invariant e m0); (equiv) { star_associative (fp' x) frame (locks_invariant e m0) } fp' x `star` frame `star` locks_invariant e m0; }; assert (H.interp (fp' x `star` (frame `star` locks_invariant e m0)) h1); assert (H.interp (fp' x `star` frame `star` locks_invariant e m0) h1); let m1 = hmem_of_hheap m0 h1 in assert (mem_evolves m0 m1); mprop_preservation_of_hprop_preservation (frame `star` locks_invariant e m0) m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)); (| x, m1 |) let lift_tot_action_with_frame #a #e #fp #fp' ($f:tot_action_with_frame_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in assert (inames_ok e m0); ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); let m0' : hmem_with_inv_except e fp = m0 in let r = f frame m0' in let (| x, m1 |) = r in ac_reasoning_for_m_frame_preserving (fp' x) frame (locks_invariant e m1) m1; assert (interp (fp' x `star` frame `star` locks_invariant e m1) m1); assert (interp (fp' x `star` locks_invariant e m1) m1); let m1' : hmem_with_inv_except e (fp' x) = m1 in NMSTTotal.put #_ #(mem_evolves) m1; x let sel_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.sel_action #a #pcm r v0)) let upd_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.upd_action #a #pcm r v0 v1)) let free_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.free_action #a #pcm r v0)) let split_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.split_action #a #pcm r v0 v1)) let gather_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.gather_action #a #pcm r v0 v1)) let weaken (p q r:slprop) (h:H.hheap (p `star` q) { H.stronger q r }) : H.hheap (p `star` r) = H.weaken p q r h; h let weaken_pure (q r: prop) : Lemma (requires (q ==> r)) (ensures H.stronger (H.pure q) (H.pure r)) = let aux (h:H.heap) : Lemma (ensures (H.interp (H.pure q) h ==> H.interp (H.pure r) h)) [SMTPat ()] = H.pure_interp q h; H.pure_interp r h in () let inc_ctr (#p:slprop) #e (m:hmem_with_inv_except e p) : m':hmem_with_inv_except e p{m'.ctr = m.ctr + 1 /\ H.stronger (linv e m) (linv e m')} = let m' : mem = { m with ctr = m.ctr + 1} in assert (interp (p `star` linv e m) m'); assert (linv e m == lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m)); assert (linv e m' == lock_store_invariant e m.locks `star` ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken_free_above (heap_of_mem m) m.ctr (m.ctr + 1); weaken_pure (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_ctr_valid (m.ctr + 1) (heap_of_mem m)); assert (H.stronger (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m))); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)); H.stronger_star (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken (p `star` lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)) (heap_of_mem m'); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity (m.ctr + 1) (heap_of_mem m)); let m' : hmem_with_inv_except e p = m' in m' let frame_related_mems (fp0 fp1:slprop u#a) e (m0:hmem_with_inv_except e fp0) (m1:hmem_with_inv_except e fp1) = forall (frame:slprop u#a). interp ((fp0 `star` frame) `star` linv e m0) m0 ==> interp ((fp1 `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) let refined_pre_action e (fp0:slprop) (a:Type) (fp1:a -> slprop) = m0:hmem_with_inv_except e fp0 -> Pure (x:a & hmem_with_inv_except e (fp1 x)) (requires True) (ensures fun (| x, m1 |) -> frame_related_mems fp0 (fp1 x) e m0 m1) let refined_pre_action_as_action (#fp0:slprop) (#a:Type) (#fp1:a -> slprop) #e ($f:refined_pre_action e fp0 a fp1) : tot_action_nf_except e fp0 a fp1 = let g : tot_pre_action_nf_except e fp0 a fp1 = fun m -> f m in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp0 `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp1 x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x', m1' |) = g m0 in let (| x, m1 |) = f m0 in assert (x == x' /\ m1 == m1') in g let alloc_action #a #pcm e x = let f : refined_pre_action e emp (ref a pcm) (fun r -> pts_to r x) = fun m0 -> (* NS: 9/29/22 I needed to annotate h : Heap.full_heap, for use with the Core checker which generates a guard for checking the implicit pattern "dot" term in the dependent pair pattern on the next line. That guard expects `h` to be a full_heap, which is it, because it is a projection of m0. However, this is not reflected in `h`'s type. So, the Core checker, which produces a guard for the pat_dot_term in isolation, cannot recheck the term. If we were to fold in the checking of pat_dot_terms and their guards with the rest of the VC, this would work. *) let h : Heap.full_heap = hheap_of_hmem m0 in let (|r, h'|) = H.extend #a #pcm x m0.ctr h in let m' : hmem_with_inv_except e emp = inc_ctr m0 in let h' : H.hheap (pts_to #a #pcm r x `star` linv e m') = weaken _ (linv e m0) (linv e m') h' in let m1 : hmem_with_inv_except e (pts_to #a #pcm r x) = hmem_of_hheap m' h' in assert (forall frame. H.frame_related_heaps h h' emp (pts_to #a #pcm r x) frame true); let aux (frame:slprop) : Lemma (requires interp ((emp `star` frame) `star` linv e m0) m0) (ensures interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) [SMTPat (emp `star` frame)] = star_associative emp frame (linv e m0); assert (H.interp (emp `star` (frame `star` linv e m0)) h); assert (H.interp (pts_to #a #pcm r x `star` (frame `star` linv e m0)) h'); star_associative (pts_to #a #pcm r x) frame (linv e m0); assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m0) h'); assert (H.stronger (linv e m0) (linv e m')); assert (H.equiv (linv e m') (linv e m1)); assert (H.stronger (linv e m0) (linv e m1)); let h' : H.hheap ((pts_to #a #pcm r x `star` frame) `star` linv e m1) = weaken _ (linv e m0) (linv e m1) h' in assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) h'); assert (forall (mp:H.hprop frame). mp h == mp h'); mprop_preservation_of_hprop_preservation frame m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) in assert (frame_related_mems emp (pts_to r x) e m0 m1); (| r, m1 |) in lift_tot_action (refined_pre_action_as_action f) let select_refine #a #p e r x f = lift_tot_action (lift_heap_action e (H.select_refine #a #p r x f)) let upd_gen #a #p e r x y f = lift_tot_action (lift_heap_action e (H.upd_gen_action r x y f)) //////////////////////////////////////////////////////////////////////////////// // witness / recall //////////////////////////////////////////////////////////////////////////////// let witnessed_ref #a #pcm (r:ref a pcm) (fact:property a) (m:full_mem) = H.witnessed_ref #a #pcm r fact (heap_of_mem m) let witnessed_ref_stability #a #pcm (r:ref a pcm) (fact:property a) : Lemma (requires FStar.Preorder.stable fact (Steel.Preorder.preorder_of_pcm pcm)) (ensures FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) = H.witnessed_ref_stability #a #pcm r fact let witnessed (#a:Type u#1) (#pcm:pcm a) (r:ref a pcm) (fact:property a) = W.witnessed _ mem_evolves (witnessed_ref r fact) let rearrange_pqr_prq (p q r:slprop) : Lemma (((p `star` q) `star` r) `equiv` ((p `star` r) `star` q)) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_associative p q r } p `star` (q `star` r); (equiv) { star_commutative q r; star_congruence p (q `star` r) p (r `star` q) } p `star` (r `star` q); (equiv) { star_associative p r q } (p `star` r) `star` q; } let preserves_frame_cong (e:inames) (p q:slprop) (r s:slprop) (m0 m1:mem) : Lemma (requires p `equiv` r /\ q `equiv` s /\ preserves_frame e p q m0 m1) (ensures preserves_frame e r s m0 m1) = let aux0 (p q r s:slprop) : Lemma (requires p `equiv` s) (ensures (((p `star` q) `star` r) `equiv` ((s `star` q) `star` r))) = star_congruence p q s q; star_congruence (p `star` q) r (s `star` q) r in let aux (frame:slprop) : Lemma (requires interp ((r `star` frame) `star` locks_invariant e m0) m0) (ensures interp ((s `star` frame) `star` locks_invariant e m1) m1 /\ interp ((p `star` frame) `star` locks_invariant e m0) m0) [SMTPat (r `star` frame)] = aux0 p frame (locks_invariant e m0) r; aux0 q frame (locks_invariant e m1) s; assert (((p `star` frame) `star` locks_invariant e m0) `equiv` ((r `star` frame) `star` locks_invariant e m0)); assert (interp ((p `star` frame) `star` locks_invariant e m0) m0); assert (interp ((q `star` frame) `star` locks_invariant e m1) m1); assert (((q `star` frame) `star` locks_invariant e m1) `equiv` ((s `star` frame) `star` locks_invariant e m1)); () in () let pure_true_equiv (p:slprop) : Lemma ((p `star` pure True) `equiv` p) = FStar.Classical.forall_intro (pure_star_interp p True); emp_unit p; assert ((p `star` pure True) `equiv` p) let preserves_frame_star_pure (e:inames) (p q:slprop) (r s:prop) (m:mem) : Lemma (requires r /\ s) (ensures preserves_frame e p q m m <==> preserves_frame e (p `star` pure r) (q `star` pure s) m m) = pure_equiv r True; star_congruence p (pure r) p (pure True); pure_equiv s True; star_congruence q (pure s) q (pure True); pure_true_equiv p; pure_true_equiv q; let fwd () : Lemma (requires preserves_frame e p q m m) (ensures preserves_frame e (p `star` pure r) (q `star` pure s) m m) [SMTPat ()] = preserves_frame_cong e p q (p `star` pure r) (q `star` pure s) m m in let bk () : Lemma (requires preserves_frame e (p `star` pure r) (q `star` pure s) m m) (ensures preserves_frame e p q m m) [SMTPat ()] = preserves_frame_cong e (p `star` pure r) (q `star` pure s) p q m m in () let witness (#a:Type) (#pcm:pcm a) (e:inames) (r:erased (ref a pcm)) (fact:stable_property pcm) (v:Ghost.erased a) (_:squash (forall z. compatible pcm v z ==> fact z)) (frame:slprop) : MstTot (witnessed r fact) e (pts_to r v) (fun _ -> pts_to r v) frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in let _ : unit = let hr : H.ref a pcm = r in let v' = H.sel_v hr v (heap_of_mem m0) in assert (interp (H.ptr hr) m0 /\ H.sel #a #pcm hr (heap_of_mem m0) == v'); assert (compatible pcm v v'); assert (fact v'); assert (witnessed_ref r fact m0); witnessed_ref_stability r fact; assert (FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) in let w = NMSTTotal.witness _ mem_evolves (witnessed_ref r fact) in w let recall (#a:Type u#1) (#pcm:pcm a) (#fact:property a) (e:inames) (r:erased (ref a pcm)) (v:Ghost.erased a) (w:witnessed r fact) (frame:slprop) = let m0 = NMSTTotal.get () in NMSTTotal.recall _ mem_evolves (witnessed_ref r fact) w; let hr : H.ref a pcm = r in assert (witnessed_ref r fact m0); let v1 = H.sel_v hr v (heap_of_mem m0) in assert (compatible pcm v v1); assert (H.sel hr (heap_of_mem m0) == v1); assert (fact v1); assert (interp ((pts_to r v `star` frame) `star` locks_invariant e m0) m0); emp_unit ((pts_to r v `star` frame) `star` locks_invariant e m0); pure_star_interp ((pts_to r v `star` frame) `star` locks_invariant e m0) (fact v1) m0; assert (interp (((pts_to r v `star` frame) `star` locks_invariant e m0) `star` pure (fact v1)) m0); rearrange_pqr_prq (pts_to r v `star` frame) (locks_invariant e m0) (pure (fact v1)); assert (interp (((pts_to r v `star` frame) `star` pure (fact v1)) `star` locks_invariant e m0) m0); rearrange_pqr_prq (pts_to r v) frame (pure (fact v1)); star_congruence ((pts_to r v `star` frame) `star` pure (fact v1)) (locks_invariant e m0) ((pts_to r v `star` pure (fact v1)) `star` frame) (locks_invariant e m0); Ghost.hide v1 let iname_for_p_mem (i:iname) (p:slprop) : W.s_predicate mem = fun m -> iname_for_p i p m.locks let iname_for_p_stable (i:iname) (p:slprop) : Lemma (W.stable full_mem mem_evolves (iname_for_p_mem i p)) = () let ( >--> ) (i:iname) (p:slprop) : Type0 = W.witnessed full_mem mem_evolves (iname_for_p_mem i p) let hmem_with_inv_equiv e (m:mem) (p:slprop) : Lemma (interp (p `star` linv e m) m <==> interp (p `star` lock_store_invariant e m.locks) m /\ heap_ctr_valid m.ctr (heap_of_mem m)) = calc (<==>) { interp (p `star` linv e m) m; (<==>) { H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) } interp ((p `star` lock_store_invariant e m.locks) `star` ctr_validity m.ctr (heap_of_mem m)) m; (<==>) { H.pure_star_interp (p `star` lock_store_invariant e m.locks) (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_of_mem m) } interp ((p `star` lock_store_invariant e m.locks) `star` emp) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); (<==>) { H.emp_unit (p `star` lock_store_invariant e m.locks) } interp (p `star` lock_store_invariant e m.locks) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); } let new_invariant_tot_action (e:inames) (p:slprop) (m0:hmem_with_inv_except e p{ e `inames_in` m0.locks }) : Pure (iname & hmem_with_inv_except e emp) (requires True) (ensures fun (i, m1) -> iname_for_p_mem i p m1 /\ frame_related_mems p emp e m0 m1 /\ mem_evolves m0 m1) = let (| i, l1 |) = extend_lock_store e m0.locks p in let m1 = { m0 with locks = l1 } in assert (lock_store_invariant e m1.locks == p `star` lock_store_invariant e m0.locks); calc (equiv) { linv e m1; (equiv) {} (lock_store_invariant e m1.locks `star` ctr_validity m1.ctr (heap_of_mem m1)); (equiv) {} ((p `star` lock_store_invariant e m0.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); (equiv) { H.star_associative p (lock_store_invariant e m0.locks) (ctr_validity m1.ctr (heap_of_mem m1)) } (p `star` (lock_store_invariant e m0.locks `star` ctr_validity m1.ctr (heap_of_mem m1))); (equiv) { } (p `star` linv e m0); }; assert (iname_for_p_mem i p m1); assert (lock_store_evolves m0.locks l1); assert (mem_evolves m0 m1); hmem_with_inv_equiv e m0 p; assert (interp (p `star` lock_store_invariant e m0.locks) m1); assert (interp (lock_store_invariant e m1.locks) m1); H.emp_unit (lock_store_invariant e m1.locks); H.star_commutative (lock_store_invariant e m1.locks) emp; assert (interp (emp `star` lock_store_invariant e m1.locks) m1); hmem_with_inv_equiv e m1 emp; let m1 : hmem_with_inv_except e emp = m1 in let aux (frame:slprop) : Lemma (requires interp ((p `star` frame) `star` linv e m0) m0) (ensures interp ((emp `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) <==> mp (core_mem m1))) [SMTPat (p `star` frame)] = assert (interp ((p `star` frame) `star` linv e m0) m1); calc (equiv) { ((p `star` frame) `star` linv e m0); (equiv) { H.star_commutative p frame; H.star_congruence (p `star` frame) (linv e m0) (frame `star` p) (linv e m0); H.star_associative frame p (linv e m0) } (frame `star` (p `star` linv e m0)); (equiv) { H.star_congruence frame (p `star` linv e m0) frame (linv e m1) } (frame `star` linv e m1); (equiv) { H.emp_unit (frame `star` linv e m1); H.star_commutative (frame `star` linv e m1) emp; H.star_associative emp frame (linv e m1) } ((emp `star` frame) `star` linv e m1); }; assert (interp ((emp `star` frame) `star` linv e m1) m1) in assert (frame_related_mems p emp e m0 m1); ( i, m1 ) let name_is_ok (i:iname) (m0:full_mem u#1) : prop = i < List.Tot.length m0.locks let witnessed_name_is_ok (i:iname) = W.witnessed full_mem mem_evolves (name_is_ok i) let pre_inv = i:erased iname & witnessed_name_is_ok i let inv (p:slprop u#1) = i:erased iname & witnessed_name_is_ok i & (i >--> p) let pre_inv_of_inv #p (i:inv p) = let (|i, w, _|) = i in (|i,w|) let name_of_pre_inv (i:pre_inv) = dfst i let rec recall_all (ctx:list pre_inv) : NMSTTotal.NMSTATETOT unit (full_mem u#1) mem_evolves (requires fun _ -> True) (ensures fun m0 _ m1 -> m0==m1 /\ (forall i. i `List.Tot.memP` ctx ==> name_is_ok (name_of_pre_inv i) m0)) = match ctx with | [] -> () | hd::tl -> let (| q, i |) = hd in let i : W.witnessed full_mem mem_evolves (name_is_ok q) = i in NMSTTotal.recall _ mem_evolves (name_is_ok q) i; recall_all tl let fresh_invariant (e:inames) (p:slprop) (ctx:list pre_inv) (frame:slprop) : MstTot (i:inv p { not (mem_inv e i) /\ fresh_wrt ctx (name_of_inv i)}) e p (fun _ -> emp) frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in recall_all ctx; ac_reasoning_for_m_frame_preserving p frame (locks_invariant e m0) m0; assert (interp (p `star` locks_invariant e m0) m0); let r = new_invariant_tot_action e p m0 in let ( i, m1 ) = r in assert (i == List.Tot.length m0.locks); assert (not (Set.mem i e)); assert (mem_evolves m0 m1); NMSTTotal.put #full_mem #mem_evolves m1; iname_for_p_stable i p; let w = NMSTTotal.witness full_mem mem_evolves (iname_for_p_mem i p) in let w0 = NMSTTotal.witness full_mem mem_evolves (name_is_ok i) in (| hide i, w0, w |)

{ "checked_file": "/", "dependencies": [ "Steel.Preorder.fst.checked", "Steel.Heap.fsti.checked", "prims.fst.checked", "FStar.Witnessed.Core.fsti.checked", "FStar.Set.fsti.checked", "FStar.Preorder.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.PCM.fst.checked", "FStar.NMSTTotal.fst.checked", "FStar.List.Tot.fst.checked", "FStar.IndefiniteDescription.fsti.checked", "FStar.Ghost.fsti.checked", "FStar.FunctionalExtensionality.fsti.checked", "FStar.Classical.Sugar.fsti.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Steel.Memory.fst" }

[ { "abbrev": true, "full_module": "Steel.Preorder", "short_module": "PP" }, { "abbrev": true, "full_module": "FStar.Witnessed.Core", "short_module": "W" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": true, "full_module": "Steel.Heap", "short_module": "H" }, { "abbrev": false, "full_module": "FStar.FunctionalExtensionality", "short_module": null }, { "abbrev": true, "full_module": "FStar.FunctionalExtensionality", "short_module": "F" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": false, "full_module": "FStar.PCM", "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

e: Steel.Memory.inames -> p: Steel.Memory.slprop -> Steel.Memory.action_except (Steel.Memory.inv p) e p (fun _ -> Steel.Memory.emp)

Prims.Tot

[ "total" ]

[]

[ "Steel.Memory.inames", "Steel.Memory.slprop", "Steel.Memory.fresh_invariant", "Prims.Nil", "Steel.Memory.pre_inv", "Steel.Memory.inv", "Prims.l_and", "Prims.b2t", "Prims.op_Negation", "FStar.Ghost.reveal", "Prims.bool", "Steel.Memory.mem_inv", "Steel.Memory.fresh_wrt", "Steel.Memory.name_of_inv", "Steel.Memory.emp", "Steel.Memory.mem", "Prims.l_True", "Prims.prop" ]

[]

false

let new_invariant (e: inames) (p frame: slprop) : MstTot (inv p) e p (fun _ -> emp) frame (fun _ -> True) (fun _ _ _ -> True) =

fresh_invariant e p [] frame

false

Hacl.Spec.Poly1305.Field32xN.Lemmas.fst

Hacl.Spec.Poly1305.Field32xN.Lemmas.fmul_r2_normalize5_lemma

val fmul_r2_normalize5_lemma: acc:felem5 2 -> r:felem5 2 -> r2:felem5 2 -> Lemma (requires felem_fits5 acc (3, 3, 3, 3, 3) /\ felem_fits5 r (1, 1, 1, 1, 1) /\ felem_fits5 r2 (2, 2, 2, 2, 2) /\ feval5 r2 == Vec.compute_r2 (feval5 r).[0]) (ensures (let out = fmul_r2_normalize5 acc r r2 in felem_fits5 out (2, 1, 1, 1, 1) /\ (feval5 out).[0] == Vec.normalize_2 (feval5 r).[0] (feval5 acc))) [SMTPat (fmul_r2_normalize5 acc r r2)]

let fmul_r2_normalize5_lemma acc r r2 = let a = fmul_r2_normalize50 acc r r2 in let (a0, a1, a2, a3, a4) = a in let a10 = vec_interleave_high a0 a0 in vec_interleave_high_lemma2 a0 a0; let a11 = vec_interleave_high a1 a1 in vec_interleave_high_lemma2 a1 a1; let a12 = vec_interleave_high a2 a2 in vec_interleave_high_lemma2 a2 a2; let a13 = vec_interleave_high a3 a3 in vec_interleave_high_lemma2 a3 a3; let a14 = vec_interleave_high a4 a4 in vec_interleave_high_lemma2 a4 a4; let fa1 = (a10, a11, a12, a13, a14) in eq_intro (feval5 fa1) (create2 (feval5 a).[1] (feval5 a).[1]); assert (feval5 fa1 == create2 (feval5 a).[1] (feval5 a).[1]); assert (felem_fits5 fa1 (1, 2, 1, 1, 2)); let out = fmul_r2_normalize51 a fa1 in assert ((feval5 out).[0] == Vec.pfadd (feval5 a).[0] (feval5 a).[1]); let res = carry_full_felem5 out in carry_full_felem5_lemma out

{ "file_name": "code/poly1305/Hacl.Spec.Poly1305.Field32xN.Lemmas.fst", "git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872", "git_url": "https://github.com/project-everest/hacl-star.git", "project_name": "hacl-star" }

{ "end_col": 29, "end_line": 404, "start_col": 0, "start_line": 381 }

module Hacl.Spec.Poly1305.Field32xN.Lemmas open Lib.IntTypes open Lib.IntVector open Lib.Sequence open FStar.Mul open Hacl.Spec.Poly1305.Field32xN open Hacl.Poly1305.Field32xN.Lemmas0 open Hacl.Poly1305.Field32xN.Lemmas1 open Hacl.Poly1305.Field32xN.Lemmas2 module Vec = Hacl.Spec.Poly1305.Vec #set-options "--z3rlimit 100 --max_fuel 0 --initial_ifuel 1 --max_ifuel 1 --using_facts_from '* -FStar.Seq'" val lemma_feval_is_fas_nat_i: #w:lanes -> f:felem5 w{felem_less5 f (pow2 128)} -> i:size_nat{i < w} -> Lemma ((feval5 f).[i] == (fas_nat5 f).[i]) let lemma_feval_is_fas_nat_i #w f i = assert_norm (pow2 128 < Vec.prime); assert ((feval5 f).[i] == (as_nat5 (transpose f).[i]) % Vec.prime); FStar.Math.Lemmas.modulo_lemma (as_nat5 (transpose f).[i]) Vec.prime val lemma_feval_is_fas_nat: #w:lanes -> f:felem5 w{felem_less5 f (pow2 128)} -> Lemma (forall (i:nat). i < w ==> (fas_nat5 f).[i] == (feval5 f).[i]) let lemma_feval_is_fas_nat #w f = FStar.Classical.forall_intro (lemma_feval_is_fas_nat_i #w f) val precomp_r5_fits_lemma: #w:lanes -> r:felem5 w{felem_fits5 r (1, 1, 1, 1, 1)} -> Lemma (felem_fits5 (precomp_r5 #w r) (5, 5, 5, 5, 5)) [SMTPat (precomp_r5 #w r)] let precomp_r5_fits_lemma #w r = FStar.Classical.forall_intro (precomp_r5_as_tup64 #w r) val precomp_r5_fits_lemma2: #w:lanes -> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)} -> Lemma (felem_fits5 (precomp_r5 #w r) (10, 10, 10, 10, 10)) [SMTPat (precomp_r5 #w r)] let precomp_r5_fits_lemma2 #w r = FStar.Classical.forall_intro (precomp_r5_as_tup64 #w r) val precomp_r5_zeros: w:lanes -> Lemma (let r = (zero w, zero w, zero w, zero w, zero w) in precomp_r5 r == (zero w, zero w, zero w, zero w, zero w)) let precomp_r5_zeros w = let r = (zero w, zero w, zero w, zero w, zero w) in let (r0, r1, r2, r3, r4) = precomp_r5 r in let aux (i:nat{i < w}) : Lemma ((vec_v (vec_smul_mod (zero w) (u64 5))).[i] == u64 0) = () in Classical.forall_intro aux; eq_intro (vec_v (vec_smul_mod (zero w) (u64 5))) (vec_v (zero w)); vecv_extensionality (vec_smul_mod (zero w) (u64 5)) (zero w) val fadd5_fits_lemma: #w:lanes -> f1:felem5 w{felem_fits5 f1 (2,2,2,2,2)} -> f2:felem5 w{felem_fits5 f2 (1,1,1,1,1)} -> Lemma (felem_fits5 (fadd5 f1 f2) (3,3,3,3,3)) [SMTPat (fadd5 f1 f2)] let fadd5_fits_lemma #w f1 f2 = let (f10, f11, f12, f13, f14) = f1 in let (f20, f21, f22, f23, f24) = f2 in let o = fadd5 f1 f2 in vec_add_mod_lemma f10 f20; vec_add_mod_lemma f11 f21; vec_add_mod_lemma f12 f22; vec_add_mod_lemma f13 f23; vec_add_mod_lemma f14 f24 val fadd5_eval_lemma: #w:lanes -> f1:felem5 w{felem_fits5 f1 (2,2,2,2,2)} -> f2:felem5 w{felem_fits5 f2 (1,1,1,1,1)} -> Lemma (feval5 (fadd5 f1 f2) == map2 Vec.pfadd (feval5 f1) (feval5 f2)) [SMTPat (fadd5 f1 f2)] let fadd5_eval_lemma #w f1 f2 = let o = fadd5 f1 f2 in FStar.Classical.forall_intro (fadd5_eval_lemma_i f1 f2); eq_intro (feval5 o) (map2 Vec.pfadd (feval5 f1) (feval5 f2)) val mul_felem5_fits_lemma: #w:lanes -> f1:felem5 w{felem_fits5 f1 (3, 3, 3, 3, 3)} -> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)} -> r5:felem5 w{felem_fits5 r5 (10, 10, 10, 10, 10)} -> Lemma (felem_wide_fits5 (mul_felem5 #w f1 r r5) (126, 102, 78, 54, 30)) [SMTPat (mul_felem5 #w f1 r r5)] let mul_felem5_fits_lemma #w f1 r r5 = let (r0, r1, r2, r3, r4) = r in let (f10, f11, f12, f13, f14) = f1 in let (r50, r51, r52, r53, r54) = r5 in let (a0,a1,a2,a3,a4) = smul_felem5 #w f10 (r0,r1,r2,r3,r4) in smul_felem5_fits_lemma #w #3 #(2,2,2,2,2) f10 (r0,r1,r2,r3,r4); let (a10,a11,a12,a13,a14) = smul_add_felem5 #w f11 (r54,r0,r1,r2,r3) (a0,a1,a2,a3,a4) in smul_add_felem5_fits_lemma #w #3 #(10,2,2,2,2) #(6,6,6,6,6) f11 (r54,r0,r1,r2,r3) (a0,a1,a2,a3,a4); let (a20,a21,a22,a23,a24) = smul_add_felem5 #w f12 (r53,r54,r0,r1,r2) (a10,a11,a12,a13,a14) in smul_add_felem5_fits_lemma #w #3 #(10,10,2,2,2) #(36,12,12,12,12) f12 (r53,r54,r0,r1,r2) (a10,a11,a12,a13,a14); let (a30,a31,a32,a33,a34) = smul_add_felem5 #w f13 (r52,r53,r54,r0,r1) (a20,a21,a22,a23,a24) in smul_add_felem5_fits_lemma #w #3 #(10,10,10,2,2) #(66,42,18,18,18) f13 (r52,r53,r54,r0,r1) (a20,a21,a22,a23,a24); let (a40,a41,a42,a43,a44) = smul_add_felem5 #w f14 (r51,r52,r53,r54,r0) (a30,a31,a32,a33,a34) in smul_add_felem5_fits_lemma #w #3 #(10,10,10,10,2) #(96,72,48,24,24) f14 (r51,r52,r53,r54,r0) (a30,a31,a32,a33,a34) val mul_felem5_eval_lemma_i: #w:lanes -> f1:felem5 w{felem_fits5 f1 (3, 3, 3, 3, 3)} -> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)} -> r5:felem5 w{felem_fits5 r5 (10, 10, 10, 10, 10) /\ r5 == precomp_r5 r} -> i:nat{i < w} -> Lemma ((feval5 (mul_felem5 #w f1 r r5)).[i] == (feval5 f1).[i] `Vec.pfmul` (feval5 r).[i]) let mul_felem5_eval_lemma_i #w f1 r r5 i = let (r0, r1, r2, r3, r4) = r in let (f10, f11, f12, f13, f14) = f1 in let (r50, r51, r52, r53, r54) = r5 in let (a0,a1,a2,a3,a4) = smul_felem5 #w f10 (r0,r1,r2,r3,r4) in smul_felem5_eval_lemma #w #3 #(2,2,2,2,2) f10 (r0,r1,r2,r3,r4); smul_felem5_fits_lemma #w #3 #(2,2,2,2,2) f10 (r0,r1,r2,r3,r4); assert ((fas_nat5 (a0,a1,a2,a3,a4)).[i] == (uint64xN_v f10).[i] * (fas_nat5 (r0,r1,r2,r3,r4)).[i]); let (a10,a11,a12,a13,a14) = smul_add_felem5 #w f11 (r54,r0,r1,r2,r3) (a0,a1,a2,a3,a4) in smul_add_felem5_eval_lemma #w #3 #(10,2,2,2,2) #(6,6,6,6,6) f11 (r54,r0,r1,r2,r3) (a0,a1,a2,a3,a4); smul_add_felem5_fits_lemma #w #3 #(10,2,2,2,2) #(6,6,6,6,6) f11 (r54,r0,r1,r2,r3) (a0,a1,a2,a3,a4); assert ((fas_nat5 (a10,a11,a12,a13,a14)).[i] == (fas_nat5 (a0,a1,a2,a3,a4)).[i] + (uint64xN_v f11).[i] * (fas_nat5 (r54,r0,r1,r2,r3)).[i]); let (a20,a21,a22,a23,a24) = smul_add_felem5 #w f12 (r53,r54,r0,r1,r2) (a10,a11,a12,a13,a14) in smul_add_felem5_eval_lemma #w #3 #(10,10,2,2,2) #(36,12,12,12,12) f12 (r53,r54,r0,r1,r2) (a10,a11,a12,a13,a14); smul_add_felem5_fits_lemma #w #3 #(10,10,2,2,2) #(36,12,12,12,12) f12 (r53,r54,r0,r1,r2) (a10,a11,a12,a13,a14); assert ((fas_nat5 (a20,a21,a22,a23,a24)).[i] == (fas_nat5 (a10,a11,a12,a13,a14)).[i] + (uint64xN_v f12).[i] * (fas_nat5 (r53,r54,r0,r1,r2)).[i]); let (a30,a31,a32,a33,a34) = smul_add_felem5 #w f13 (r52,r53,r54,r0,r1) (a20,a21,a22,a23,a24) in smul_add_felem5_eval_lemma #w #3 #(10,10,10,2,2) #(66,42,18,18,18) f13 (r52,r53,r54,r0,r1) (a20,a21,a22,a23,a24); smul_add_felem5_fits_lemma #w #3 #(10,10,10,2,2) #(66,42,18,18,18) f13 (r52,r53,r54,r0,r1) (a20,a21,a22,a23,a24); assert ((fas_nat5 (a30,a31,a32,a33,a34)).[i] == (fas_nat5 (a20,a21,a22,a23,a24)).[i] + (uint64xN_v f13).[i] * (fas_nat5 (r52,r53,r54,r0,r1)).[i]); let (a40,a41,a42,a43,a44) = smul_add_felem5 #w f14 (r51,r52,r53,r54,r0) (a30,a31,a32,a33,a34) in smul_add_felem5_eval_lemma #w #3 #(10,10,10,10,2) #(96,72,48,24,24) f14 (r51,r52,r53,r54,r0) (a30,a31,a32,a33,a34); smul_add_felem5_fits_lemma #w #3 #(10,10,10,10,2) #(96,72,48,24,24) f14 (r51,r52,r53,r54,r0) (a30,a31,a32,a33,a34); assert ((fas_nat5 (a40,a41,a42,a43,a44)).[i] == (fas_nat5 (a30,a31,a32,a33,a34)).[i] + (uint64xN_v f14).[i] * (fas_nat5 (r51,r52,r53,r54,r0)).[i]); assert ((fas_nat5 (a40,a41,a42,a43,a44)).[i] == (uint64xN_v f10).[i] * (fas_nat5 (r0,r1,r2,r3,r4)).[i] + (uint64xN_v f11).[i] * (fas_nat5 (r54,r0,r1,r2,r3)).[i] + (uint64xN_v f12).[i] * (fas_nat5 (r53,r54,r0,r1,r2)).[i] + (uint64xN_v f13).[i] * (fas_nat5 (r52,r53,r54,r0,r1)).[i] + (uint64xN_v f14).[i] * (fas_nat5 (r51,r52,r53,r54,r0)).[i]); mul_felem5_eval_as_tup64 #w f1 r r5 i; mul_felem5_lemma (as_tup64_i f1 i) (as_tup64_i r i) val mul_felem5_eval_lemma: #w:lanes -> f1:felem5 w{felem_fits5 f1 (3, 3, 3, 3, 3)} -> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)} -> r5:felem5 w{felem_fits5 r5 (10, 10, 10, 10, 10) /\ r5 == precomp_r5 r} -> Lemma (feval5 (mul_felem5 #w f1 r r5) == map2 (Vec.pfmul) (feval5 f1) (feval5 r)) [SMTPat (mul_felem5 #w f1 r r5)] let mul_felem5_eval_lemma #w f1 r r5 = let tmp = map2 (Vec.pfmul) (feval5 f1) (feval5 r) in FStar.Classical.forall_intro (mul_felem5_eval_lemma_i #w f1 r r5); eq_intro (feval5 (mul_felem5 #w f1 r r5)) tmp val fmul_r5_fits_lemma: #w:lanes -> f1:felem5 w{felem_fits5 f1 (3, 3, 3, 3, 3)} -> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)} -> r5:felem5 w{felem_fits5 r5 (10, 10, 10, 10, 10)} -> Lemma (felem_fits5 (fmul_r5 #w f1 r r5) (1, 2, 1, 1, 2)) [SMTPat (fmul_r5 #w f1 r r5)] let fmul_r5_fits_lemma #w f1 r r5 = let tmp = mul_felem5 f1 r r5 in mul_felem5_fits_lemma #w f1 r r5; let res = carry_wide_felem5 tmp in carry_wide_felem5_fits_lemma #w tmp val fmul_r5_eval_lemma: #w:lanes -> f1:felem5 w{felem_fits5 f1 (3, 3, 3, 3, 3)} -> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)} -> r5:felem5 w{felem_fits5 r5 (10, 10, 10, 10, 10) /\ r5 == precomp_r5 r} -> Lemma (feval5 (fmul_r5 #w f1 r r5) == map2 (Vec.pfmul) (feval5 f1) (feval5 r)) [SMTPat (fmul_r5 #w f1 r r5)] let fmul_r5_eval_lemma #w f1 r r5 = let tmp = mul_felem5 f1 r r5 in mul_felem5_eval_lemma #w f1 r r5; let res = carry_wide_felem5 tmp in carry_wide_felem5_eval_lemma #w tmp val fadd_mul_r5_fits_lemma: #w:lanes -> acc:felem5 w{felem_fits5 acc (2, 2, 2, 2, 2)} -> f1:felem5 w{felem_fits5 f1 (1, 1, 1, 1, 1)} -> r:felem5 w{felem_fits5 r (1, 1, 1, 1, 1)} -> r5:felem5 w{felem_fits5 r5 (5, 5, 5, 5, 5)} -> Lemma (felem_fits5 (fadd_mul_r5 acc f1 r r5) (1, 2, 1, 1, 2)) [SMTPat (fadd_mul_r5 acc f1 r r5)] let fadd_mul_r5_fits_lemma #w acc f1 r r5 = let acc1 = fadd5 acc f1 in fadd5_fits_lemma #w acc f1; let tmp = mul_felem5 acc1 r r5 in mul_felem5_fits_lemma #w acc1 r r5; let res = carry_wide_felem5 tmp in carry_wide_felem5_fits_lemma #w tmp val fadd_mul_r5_eval_lemma: #w:lanes -> acc:felem5 w{felem_fits5 acc (2, 2, 2, 2, 2)} -> f1:felem5 w{felem_fits5 f1 (1, 1, 1, 1, 1)} -> r:felem5 w{felem_fits5 r (1, 1, 1, 1, 1)} -> r5:felem5 w{felem_fits5 r5 (5, 5, 5, 5, 5) /\ r5 == precomp_r5 r} -> Lemma (feval5 (fadd_mul_r5 acc f1 r r5) == map2 (Vec.pfmul) (map2 (Vec.pfadd) (feval5 acc) (feval5 f1)) (feval5 r)) [SMTPat (fadd_mul_r5 acc f1 r r5)] let fadd_mul_r5_eval_lemma #w acc f1 r r5 = let acc1 = fadd5 acc f1 in fadd5_eval_lemma #w acc f1; let tmp = mul_felem5 acc1 r r5 in mul_felem5_eval_lemma #w acc1 r r5; let res = carry_wide_felem5 tmp in carry_wide_felem5_eval_lemma #w tmp val reduce_felem5_eval_lemma: #w:lanes -> f:felem5 w{felem_fits5 f (2, 2, 2, 2, 2)} -> Lemma (felem_fits5 (reduce_felem5 f) (1, 1, 1, 1, 1) /\ (feval5 f).[0] == (fas_nat5 (reduce_felem5 f)).[0]) [SMTPat (reduce_felem5 f)] let reduce_felem5_eval_lemma #w f = carry_full_felem5_eval_lemma f; carry_full_felem5_fits_lemma f; let f = carry_full_felem5 f in carry_reduce_felem5_lemma #w f; subtract_p5_felem5_lemma #w (carry_full_felem5 f) val fmul_r2_normalize50: acc:felem5 2 -> r:felem5 2 -> r2:felem5 2 -> Pure (felem5 2) (requires felem_fits5 acc (3, 3, 3, 3, 3) /\ felem_fits5 r (1, 1, 1, 1, 1) /\ felem_fits5 r2 (2, 2, 2, 2, 2) /\ feval5 r2 == Vec.compute_r2 (feval5 r).[0]) (ensures fun a -> let fr21 = create2 (feval5 r2).[0] (feval5 r).[0] in feval5 a == Vec.fmul (feval5 acc) fr21 /\ felem_fits5 a (1, 2, 1, 1, 2)) let fmul_r2_normalize50 (a0, a1, a2, a3, a4) (r0, r1, r2, r3, r4) (r20, r21, r22, r23, r24) = let r210 = vec_interleave_low r20 r0 in vec_interleave_low_lemma2 r20 r0; let r211 = vec_interleave_low r21 r1 in vec_interleave_low_lemma2 r21 r1; let r212 = vec_interleave_low r22 r2 in vec_interleave_low_lemma2 r22 r2; let r213 = vec_interleave_low r23 r3 in vec_interleave_low_lemma2 r23 r3; let r214 = vec_interleave_low r24 r4 in vec_interleave_low_lemma2 r24 r4; let acc = (a0, a1, a2, a3, a4) in let fr = (r0, r1, r2, r3, r4) in let fr2 = (r20, r21, r22, r23, r24) in assert ((feval5 fr2).[0] == Vec.pfmul ((feval5 fr).[0]) ((feval5 fr).[0])); let fr21 = (r210, r211, r212, r213, r214) in eq_intro (feval5 fr21) (create2 (feval5 fr2).[0] (feval5 fr).[0]); assert (feval5 fr21 == create2 (feval5 fr2).[0] (feval5 fr).[0]); assert (felem_fits5 fr21 (2, 2, 2, 2, 2)); let fr215 = precomp_r5 #2 fr21 in let a = fmul_r5 #2 acc fr21 fr215 in fmul_r5_eval_lemma acc fr21 fr215; fmul_r5_fits_lemma acc fr21 fr215; assert (feval5 a == Vec.fmul (feval5 acc) (feval5 fr21)); assert (felem_fits5 a (1, 2, 1, 1, 2)); a #push-options "--z3rlimit 150" val fmul_r2_normalize51: a:felem5 2 -> fa1:felem5 2 -> Pure (felem5 2) (requires felem_fits5 a (1, 2, 1, 1, 2) /\ felem_fits5 fa1 (1, 2, 1, 1, 2) /\ feval5 fa1 == create2 (feval5 a).[1] (feval5 a).[1]) (ensures fun out -> (feval5 out).[0] == Vec.pfadd (feval5 a).[0] (feval5 a).[1] /\ felem_fits5 out (2, 4, 2, 2, 4)) let fmul_r2_normalize51 a fa1 = let (a0, a1, a2, a3, a4) = a in let (a10, a11, a12, a13, a14) = fa1 in let o0 = vec_add_mod a0 a10 in let o1 = vec_add_mod a1 a11 in let o2 = vec_add_mod a2 a12 in let o3 = vec_add_mod a3 a13 in let o4 = vec_add_mod a4 a14 in let out = (o0, o1, o2, o3, o4) in let (a0, a1, a2, a3, a4) = as_tup64_i a 0 in let (a10, a11, a12, a13, a14) = as_tup64_i fa1 0 in let (o0, o1, o2, o3, o4) = as_tup64_i out 0 in FStar.Math.Lemmas.modulo_lemma (v a0 + v a10) (pow2 64); FStar.Math.Lemmas.modulo_lemma (v a1 + v a11) (pow2 64); FStar.Math.Lemmas.modulo_lemma (v a2 + v a12) (pow2 64); FStar.Math.Lemmas.modulo_lemma (v a3 + v a13) (pow2 64); FStar.Math.Lemmas.modulo_lemma (v a4 + v a14) (pow2 64); assert (felem_fits5 out (2, 4, 2, 2, 4)); calc (==) { ((feval5 a).[0] + (feval5 a).[1]) % Vec.prime; (==) { } (as_nat5 (a0, a1, a2, a3, a4) % Vec.prime + as_nat5 (a10, a11, a12, a13, a14) % Vec.prime) % Vec.prime; (==) { FStar.Math.Lemmas.lemma_mod_plus_distr_l (as_nat5 (a0, a1, a2, a3, a4)) (as_nat5 (a10, a11, a12, a13, a14)) Vec.prime; FStar.Math.Lemmas.lemma_mod_plus_distr_r (as_nat5 (a0, a1, a2, a3, a4) % Vec.prime) (as_nat5 (a10, a11, a12, a13, a14)) Vec.prime } (as_nat5 (a0, a1, a2, a3, a4) + as_nat5 (a10, a11, a12, a13, a14)) % Vec.prime; (==) { } (feval5 out).[0]; }; out #pop-options val fmul_r2_normalize5_lemma: acc:felem5 2 -> r:felem5 2 -> r2:felem5 2 -> Lemma (requires felem_fits5 acc (3, 3, 3, 3, 3) /\ felem_fits5 r (1, 1, 1, 1, 1) /\ felem_fits5 r2 (2, 2, 2, 2, 2) /\ feval5 r2 == Vec.compute_r2 (feval5 r).[0]) (ensures (let out = fmul_r2_normalize5 acc r r2 in felem_fits5 out (2, 1, 1, 1, 1) /\ (feval5 out).[0] == Vec.normalize_2 (feval5 r).[0] (feval5 acc))) [SMTPat (fmul_r2_normalize5 acc r r2)]

{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "Lib.Sequence.fsti.checked", "Lib.IntVector.fsti.checked", "Lib.IntTypes.fsti.checked", "Hacl.Spec.Poly1305.Vec.fst.checked", "Hacl.Spec.Poly1305.Field32xN.fst.checked", "Hacl.Poly1305.Field32xN.Lemmas2.fst.checked", "Hacl.Poly1305.Field32xN.Lemmas1.fst.checked", "Hacl.Poly1305.Field32xN.Lemmas0.fst.checked", "Hacl.Impl.Poly1305.Lemmas.fst.checked", "FStar.UInt32.fsti.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Mul.fst.checked", "FStar.Math.Lemmas.fst.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": false, "source_file": "Hacl.Spec.Poly1305.Field32xN.Lemmas.fst" }

[ { "abbrev": true, "full_module": "Hacl.Spec.Poly1305.Vec", "short_module": "Vec" }, { "abbrev": false, "full_module": "Hacl.Poly1305.Field32xN.Lemmas2", "short_module": null }, { "abbrev": false, "full_module": "Hacl.Poly1305.Field32xN.Lemmas1", "short_module": null }, { "abbrev": false, "full_module": "Hacl.Poly1305.Field32xN.Lemmas0", "short_module": null }, { "abbrev": false, "full_module": "Hacl.Spec.Poly1305.Field32xN", "short_module": null }, { "abbrev": false, "full_module": "FStar.Mul", "short_module": null }, { "abbrev": false, "full_module": "Lib.Sequence", "short_module": null }, { "abbrev": false, "full_module": "Lib.IntVector", "short_module": null }, { "abbrev": false, "full_module": "Lib.IntTypes", "short_module": null }, { "abbrev": false, "full_module": "Hacl.Spec.Poly1305.Field32xN", "short_module": null }, { "abbrev": false, "full_module": "Hacl.Spec.Poly1305.Field32xN", "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": 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": 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": 100, "z3rlimit_factor": 1, "z3seed": 0, "z3smtopt": [], "z3version": "4.8.5" }

false

acc: Hacl.Spec.Poly1305.Field32xN.felem5 2 -> r: Hacl.Spec.Poly1305.Field32xN.felem5 2 -> r2: Hacl.Spec.Poly1305.Field32xN.felem5 2 -> FStar.Pervasives.Lemma (requires Hacl.Spec.Poly1305.Field32xN.felem_fits5 acc (3, 3, 3, 3, 3) /\ Hacl.Spec.Poly1305.Field32xN.felem_fits5 r (1, 1, 1, 1, 1) /\ Hacl.Spec.Poly1305.Field32xN.felem_fits5 r2 (2, 2, 2, 2, 2) /\ Hacl.Spec.Poly1305.Field32xN.feval5 r2 == Hacl.Spec.Poly1305.Vec.compute_r2 (Hacl.Spec.Poly1305.Field32xN.feval5 r).[ 0 ]) (ensures (let out = Hacl.Spec.Poly1305.Field32xN.fmul_r2_normalize5 acc r r2 in Hacl.Spec.Poly1305.Field32xN.felem_fits5 out (2, 1, 1, 1, 1) /\ (Hacl.Spec.Poly1305.Field32xN.feval5 out).[ 0 ] == Hacl.Spec.Poly1305.Vec.normalize_2 (Hacl.Spec.Poly1305.Field32xN.feval5 r).[ 0 ] (Hacl.Spec.Poly1305.Field32xN.feval5 acc))) [SMTPat (Hacl.Spec.Poly1305.Field32xN.fmul_r2_normalize5 acc r r2)]

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Hacl.Spec.Poly1305.Field32xN.felem5", "Hacl.Spec.Poly1305.Field32xN.uint64xN", "Hacl.Poly1305.Field32xN.Lemmas1.carry_full_felem5_lemma", "Hacl.Spec.Poly1305.Field32xN.carry_full_felem5", "Prims.unit", "Prims._assert", "Prims.eq2", "Hacl.Spec.Poly1305.Vec.pfelem", "Lib.Sequence.op_String_Access", "Hacl.Spec.Poly1305.Field32xN.feval5", "Hacl.Spec.Poly1305.Vec.pfadd", "Hacl.Spec.Poly1305.Field32xN.Lemmas.fmul_r2_normalize51", "Hacl.Spec.Poly1305.Field32xN.felem_fits5", "FStar.Pervasives.Native.Mktuple5", "Prims.nat", "Lib.Sequence.lseq", "Lib.Sequence.create2", "Lib.Sequence.eq_intro", "FStar.Pervasives.Native.tuple5", "Lib.IntVector.vec_interleave_high_lemma2", "Lib.IntTypes.U64", "Lib.IntVector.vec_t", "Lib.IntVector.vec_interleave_high", "Hacl.Spec.Poly1305.Field32xN.Lemmas.fmul_r2_normalize50" ]

[]

false

true

false

let fmul_r2_normalize5_lemma acc r r2 =

let a = fmul_r2_normalize50 acc r r2 in let a0, a1, a2, a3, a4 = a in let a10 = vec_interleave_high a0 a0 in vec_interleave_high_lemma2 a0 a0; let a11 = vec_interleave_high a1 a1 in vec_interleave_high_lemma2 a1 a1; let a12 = vec_interleave_high a2 a2 in vec_interleave_high_lemma2 a2 a2; let a13 = vec_interleave_high a3 a3 in vec_interleave_high_lemma2 a3 a3; let a14 = vec_interleave_high a4 a4 in vec_interleave_high_lemma2 a4 a4; let fa1 = (a10, a11, a12, a13, a14) in eq_intro (feval5 fa1) (create2 (feval5 a).[ 1 ] (feval5 a).[ 1 ]); assert (feval5 fa1 == create2 (feval5 a).[ 1 ] (feval5 a).[ 1 ]); assert (felem_fits5 fa1 (1, 2, 1, 1, 2)); let out = fmul_r2_normalize51 a fa1 in assert ((feval5 out).[ 0 ] == Vec.pfadd (feval5 a).[ 0 ] (feval5 a).[ 1 ]); let res = carry_full_felem5 out in carry_full_felem5_lemma out

false

Steel.Memory.fst

Steel.Memory.rearrange_invariant

val rearrange_invariant (p q r q0 q1: slprop) : Lemma (requires q `equiv` (q0 `star` q1)) (ensures (p `star` (q `star` r)) `equiv` ((q0 `star` p) `star` (q1 `star` r)))

let rearrange_invariant (p q r : slprop) (q0 q1:slprop) : Lemma (requires q `equiv` (q0 `star` q1)) (ensures (p `star` (q `star` r)) `equiv` ((q0 `star` p) `star` (q1 `star` r))) = calc (equiv) { p `star` (q `star` r); (equiv) { calc (equiv) { (q `star` r); (equiv) { star_congruence q r (q0 `star` q1) r } (q0 `star` q1) `star` r; }; star_congruence p (q `star` r) p ((q0 `star` q1) `star` r) } (p `star` ((q0 `star` q1) `star` r)); (equiv) { star_associative q0 q1 r; star_congruence p ((q0 `star` q1) `star` r) p (q0 `star` (q1 `star` r)); star_associative p q0 (q1 `star` r) } (p `star` q0) `star` (q1 `star` r); (equiv) { star_commutative p q0; star_congruence (p `star` q0) (q1 `star` r) (q0 `star` p) (q1 `star` r) } (q0 `star` p) `star` (q1 `star` r); }

{ "file_name": "lib/steel/Steel.Memory.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 5, "end_line": 1328, "start_col": 0, "start_line": 1294 }

(* 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.Memory module F = FStar.FunctionalExtensionality open FStar.FunctionalExtensionality open FStar.PCM module H = Steel.Heap noeq type lock_state : Type u#(a + 1) = | Invariant : inv:H.slprop u#a -> lock_state let lock_store : Type u#(a+1) = list (lock_state u#a) noeq type mem : Type u#(a + 1) = { ctr: nat; heap: H.heap u#a; locks: lock_store u#a; } let heap_of_mem (x:mem) : H.heap = x.heap let mem_of_heap (h:H.heap) : mem = { ctr = 0; heap = h; locks = [] } let mem_set_heap (m:mem) (h:H.heap) : mem = { ctr = m.ctr; heap = h; locks = m.locks; } let core_mem (m:mem) : mem = mem_of_heap (heap_of_mem m) let core_mem_invol m = () let disjoint (m0 m1:mem u#h) : prop = m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks let disjoint_sym m0 m1 = () let join m0 m1 = { ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = m0.locks } let join_commutative m0 m1 = H.join_commutative m0.heap m1.heap let disjoint_join m0 m1 m2 = H.disjoint_join m0.heap m1.heap m2.heap let join_associative m0 m1 m2 = H.join_associative m0.heap m1.heap m2.heap let slprop = H.slprop let interp p m = H.interp p m.heap let equiv p1 p2 = forall m. interp p1 m <==> interp p2 m let slprop_extensionality p q = assert (forall m. interp p m <==> interp q m); let aux (h:H.heap) : Lemma (H.interp p h <==> H.interp q h) [SMTPat (H.interp p h)] = let m : mem = { ctr = 0; heap = h; locks = [] } in assert (interp p m <==> interp q m) in assert (forall h. H.interp p h <==> H.interp q h); Steel.Heap.slprop_extensionality p q let reveal_equiv p1 p2 = () let core_ref = H.core_ref let core_ref_null = H.core_ref_null let core_ref_is_null r = H.core_ref_is_null r let emp : slprop u#a = H.emp let pure = H.pure let pts_to = H.pts_to let h_and = H.h_and let h_or = H.h_or let star = H.star let wand = H.wand let h_exists = H.h_exists let h_forall = H.h_forall //////////////////////////////////////////////////////////////////////////////// //properties of equiv //////////////////////////////////////////////////////////////////////////////// let equiv_symmetric (p1 p2:slprop u#a) = H.equiv_symmetric p1 p2 #push-options "--warn_error -271" let equiv_heap_iff_equiv (p1 p2:slprop u#a) : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat (equiv p1 p2)] = let aux_lr () : Lemma (requires H.equiv p1 p2) (ensures equiv p1 p2) [SMTPat ()] = () in let aux_rl_helper1 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p1 h) (ensures H.interp p2 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl_helper2 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p2 h) (ensures H.interp p1 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl () : Lemma (requires equiv p1 p2) (ensures H.equiv p1 p2) [SMTPat ()] = () in () let equiv_heap_iff_equiv_forall () : Lemma (ensures (forall p1 p2. H.equiv p1 p2 <==> equiv p1 p2)) = let aux p1 p2 : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat ()] = equiv_heap_iff_equiv p1 p2 in () #pop-options let equiv_extensional_on_star (p1 p2 p3:slprop u#a) = equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3 let emp_unit p = H.emp_unit p let intro_emp m = H.intro_emp (heap_of_mem m) let pure_equiv p q = H.pure_equiv p q let pure_interp q m = H.pure_interp q (heap_of_mem m) let pure_star_interp p q m = H.pure_star_interp p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// //pts_to //////////////////////////////////////////////////////////////////////////////// let pts_to_compatible #a #pcm x v0 v1 m = H.pts_to_compatible #a #pcm x v0 v1 (heap_of_mem m) let pts_to_compatible_equiv #a #pcm x v0 v1 = H.pts_to_compatible_equiv #a #pcm x v0 v1 let pts_to_not_null #a #pcm x v m = H.pts_to_not_null #a #pcm x v (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // star //////////////////////////////////////////////////////////////////////////////// let intro_star p q mp mq = H.intro_star p q (heap_of_mem mp) (heap_of_mem mq) let elim_star p q m = let h = heap_of_mem m in H.elim_star p q h; assert (exists hl hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr); let hl = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hl -> exists hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let hr = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hr -> H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let ml = mem_set_heap m hl in let mr = mem_set_heap m hr in assert (disjoint ml mr); assert (m == join ml mr); assert (interp p ml); assert (interp q mr); () let interp_star (p q: slprop) (m: mem) : Lemma (interp (p `star` q) m <==> (exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m)) = let left = interp (p `star` q) m in let right = exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m in let f () : Lemma (requires left) (ensures right) = elim_star p q m in let g () : Lemma (requires right) (ensures left) = Classical.exists_elim left #_ #(fun mp -> exists (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mp -> Classical.exists_elim left #_ #(fun mq -> disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mq -> intro_star p q mp mq ) ) in Classical.move_requires f (); Classical.move_requires g () let star_commutative (p1 p2:slprop) = H.star_commutative p1 p2 let star_associative (p1 p2 p3:slprop) = H.star_associative p1 p2 p3 let star_congruence (p1 p2 p3 p4:slprop) = equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4 let affine_star (p q:slprop) (m:mem) = H.affine_star p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // Invariants on the lock store //////////////////////////////////////////////////////////////////////////////// let iname = nat module S = FStar.Set module L = FStar.List.Tot module W = FStar.Witnessed.Core let rec lock_store_invariant (e:inames) (l:lock_store u#a) : slprop u#a = let current_addr = L.length l - 1 in match l with | [] -> emp | Invariant p :: tl -> if current_addr `S.mem` e then lock_store_invariant e tl else p `star` lock_store_invariant e tl let lock_i (i:iname) (l:lock_store { i < L.length l }) = let ix = L.length l - i - 1 in L.index l ix let iname_for_p (i:iname) (p:slprop) : W.s_predicate lock_store = fun l -> i < L.length l /\ (lock_i i l).inv == p let lock_store_evolves : FStar.Preorder.preorder lock_store = fun (l1 l2 : lock_store) -> L.length l2 >= L.length l1 /\ (forall (i:nat{i < L.length l1}). (lock_i i l1).inv == (lock_i i l2).inv) let inames_in (e:inames) (l:lock_store) : prop = forall i. Set.mem i e ==> i < L.length l let inames_ok e m = inames_in e m.locks let inames_ok_empty m = () let extend_lock_store (e:inames) (l:lock_store{e `inames_in` l}) (p:slprop) : i:iname & l':lock_store { lock_store_invariant e l' == p `star` lock_store_invariant e l /\ iname_for_p i p l' } = (| L.length l, Invariant p :: l |) let set_add (i:iname) (s:inames) = Set.union (Set.singleton i) s let rec move_invariant (e:inames) (l:lock_store) (p:slprop) (i:iname{iname_for_p i p l /\ ~(i `Set.mem` e)}) : Lemma (H.equiv (lock_store_invariant e l) (p `star` lock_store_invariant (set_add i e) l)) = let rec aux (i:iname) (m:lock_store) : Lemma (requires i >= L.length m) (ensures (lock_store_invariant e m `H.equiv` lock_store_invariant (set_add i e) m)) = match m with | [] -> () | Invariant p::tl -> aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl) in let current_addr = L.length l - 1 in match l with | [] -> () | Invariant q::tl -> if i = current_addr then begin assert (lock_store_invariant e l == p `star` lock_store_invariant e tl); aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl); () end else begin move_invariant e tl p i; assert (lock_store_invariant e tl `equiv` (p `star` lock_store_invariant (set_add i e) tl)); H.star_congruence q (lock_store_invariant e tl) q (p `star` lock_store_invariant (set_add i e) tl); if Set.mem current_addr e then () else begin let r = lock_store_invariant (set_add i e) tl in assert (lock_store_invariant e l `equiv` (q `star` (p `star` r))); H.star_associative q p r; H.star_commutative q p; H.star_congruence (q `star` p) r (p `star` q) r; H.star_associative p q r end end let heap_ctr_valid (ctr:nat) (h:H.heap u#a) : prop = h `H.free_above_addr` ctr let ctr_validity (ctr:nat) (h:H.heap) : slprop = H.pure (heap_ctr_valid ctr h) let locks_invariant (e:inames) (m:mem u#a) : slprop u#a = lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m) let full_mem_pred (m:mem) = H.full_heap_pred (heap_of_mem m) (***** Following lemmas are needed in Steel.Effect *****) let core_mem_interp (hp:slprop u#a) (m:mem u#a) = () let interp_depends_only_on (hp:slprop u#a) = H.interp_depends_only_on hp let a_mem_prop_as_a_heap_prop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (H.a_heap_prop u#a) = let g (h: H.heap u#a) : Tot prop = interp sl (mem_of_heap h) /\ f (mem_of_heap h) in let phi0 (h0 h1: H.heap u#a) : Lemma (requires (g h0 /\ H.disjoint h0 h1)) (ensures (g h0 /\ H.disjoint h0 h1 /\ g (H.join h0 h1))) = assert (mem_of_heap (H.join h0 h1) == mem_of_heap h0 `join` mem_of_heap h1); interp_depends_only_on sl in let phi1 (h0 h1: H.heap u#a) : Lemma (ensures ((g h0 /\ H.disjoint h0 h1) ==> g (H.join h0 h1))) = Classical.move_requires (phi0 h0) h1 in Classical.forall_intro_2 phi1; g let refine_slprop sl f = H.as_slprop (a_mem_prop_as_a_heap_prop sl f) let interp_refine_slprop sl f m = assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_mem m)) let dep_hprop (s: slprop) (f: (hmem s -> Tot slprop)) (h: H.heap) : Tot prop = exists (h1: H.heap) . exists (h2: H.heap) . interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 let dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq' : squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h')) = let p2 (h h1 h2: H.heap) : Tot prop = interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 in let p1 (h h1: H.heap) : Tot prop = (exists h2 . p2 h h1 h2) in let h1 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p1 h) in let h2 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p2 h h1) in H.disjoint_join h' h1 h2; assert (H.disjoint h2 h'); let h2' = H.join h2 h' in H.join_commutative h2 h' ; assert (h2' == H.join h' h2); assert (H.disjoint h1 h2'); assert (mem_of_heap h2' == mem_of_heap h2 `join` mem_of_heap h'); interp_depends_only_on (f (mem_of_heap h1)); assert (interp (f (mem_of_heap h1)) (mem_of_heap h2')); H.join_commutative h1 h2; H.join_associative h' h2 h1; H.join_commutative h' h; H.join_commutative h2' h1; assert (H.join h h' == h1 `H.join` h2') let impl_intro_gen (#p: Type0) (#q: Type0) ($prf: (squash p -> Lemma (q ))) : Lemma (p ==> q) = Classical.impl_intro_gen #p #(fun _ -> q) prf let dep_hprop_is_affine1 (s: slprop) (f: (hmem s -> Tot slprop)) (h0 h1: H.heap) : Lemma ((dep_hprop s f h0 /\ H.disjoint h0 h1) ==> (H.disjoint h0 h1 /\ dep_hprop s f (H.join h0 h1))) = impl_intro_gen (dep_hprop_is_affine0 s f h0 h1) let dep_hprop_is_affine (s: slprop) (f: (hmem s -> Tot slprop)) : Lemma (H.heap_prop_is_affine (dep_hprop s f)) = Classical.forall_intro_2 (dep_hprop_is_affine1 s f) let sdep (s: slprop) (f: (hmem s -> Tot slprop)) : Tot slprop = dep_hprop_is_affine s f; H.as_slprop (dep_hprop s f) let interp_sdep (s: slprop) (f: (hmem s -> Tot slprop)) (m: mem) : Lemma (requires (dep_slprop_is_affine s f)) (ensures ( interp (sdep s f) m <==> (exists m1 m2 . interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) )) = dep_hprop_is_affine s f; assert (forall m1 m2 . (interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) ==> ( interp s (mem_of_heap m1.heap) /\ interp (f (mem_of_heap m1.heap)) (mem_of_heap m2.heap) /\ H.disjoint m1.heap m2.heap /\ H.join m1.heap m2.heap == m.heap )); interp_depends_only_on s; Classical.forall_intro (fun m -> interp_depends_only_on (f m)); assert (forall h1 h2 . (interp s (mem_of_heap h1) /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ H.disjoint h1 h2 /\ H.join h1 h2 == m.heap) ==> ( core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ interp s (core_mem (mem_of_heap h1)) /\ interp s (mem_set_heap m h1) /\ core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ f (mem_set_heap m h1) `equiv` f (mem_of_heap h1) /\ interp (f (mem_set_heap m h1)) (mem_of_heap h2) /\ interp (f (mem_set_heap m h1)) (mem_set_heap m h2) /\ disjoint (mem_set_heap m h1) (mem_set_heap m h2) /\ join (mem_set_heap m h1) (mem_set_heap m h2) == m )); () let h_exists_cong (#a:Type) (p q : a -> slprop) : Lemma (requires (forall x. p x `equiv` q x)) (ensures (h_exists p `equiv` h_exists q)) = equiv_heap_iff_equiv_forall (); H.h_exists_cong p q let intro_h_exists #a x p m = H.intro_h_exists x p (heap_of_mem m) let elim_h_exists (#a:_) (p:a -> slprop) (m:mem) = H.elim_h_exists p (heap_of_mem m) let intro_h_forall (#a:_) (p:a -> slprop) (m:mem) = H.intro_h_forall p (heap_of_mem m) let elim_h_forall (#a:_) (p:a -> slprop) (m:mem) (x:a) = H.elim_h_forall p (heap_of_mem m) x let intro_h_and (p q: slprop) (m:mem) = H.intro_h_and p q (heap_of_mem m) let elim_h_and (p q: slprop) (m:mem) = H.elim_h_and p q (heap_of_mem m) let intro_h_or_left (p q: slprop) (m:mem) = H.intro_h_or_left p q (heap_of_mem m) let intro_h_or_right (p q: slprop) (m:mem) = H.intro_h_or_right p q (heap_of_mem m) let elim_h_or (p q: slprop) (m:mem) = H.elim_h_or p q (heap_of_mem m) let intro_wand (p1 p2: slprop u#a) (m:mem) = introduce (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)) ==> interp (wand p1 p2) m with _. ( assert (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)); H.intro_wand p1 p2 (heap_of_mem m); let h = heap_of_mem m in assert ((forall h1. h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) ==> H.interp (wand p1 p2) h); introduce forall h1. (h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) with ( introduce (h `H.disjoint` h1 /\ H.interp p1 h1) ==> H.interp p2 (H.join h h1) with _. ( assert (h `H.disjoint` h1); let m1 = { ctr = m.ctr; heap = h1; locks = m.locks } in assert (m `disjoint` m1) ) ) ) (** Eliminating a wand by proving a heap that satisfies the LHS **) let elim_wand (p1 p2: slprop u#a) (m:mem) (m1:mem) = H.elim_wand p1 p2 (heap_of_mem m) (heap_of_mem m1) //////////////////////////////////////////////////////////////////////////////// // Preorders and effects //////////////////////////////////////////////////////////////////////////////// module PP = Steel.Preorder let mem_evolves = fun (m0 m1:full_mem) -> H.heap_evolves (heap_of_mem m0) (heap_of_mem m1) /\ m0.ctr <= m1.ctr /\ lock_store_evolves m0.locks m1.locks (** See [Steel.Heap.is_frame_preserving]. We add in [lock_invariants] now *) let preserves_frame (e:inames) (pre post:slprop) (m0 m1:mem) = forall (frame:slprop). interp ((pre `star` frame) `star` locks_invariant e m0) m0 ==> (interp ((post `star` frame) `star` locks_invariant e m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) (** This is a version of MstTot with frame quantified, as part of preserves_frame *) effect MstTotNF (a:Type u#a) (except:inames) (expects:slprop u#1) (provides: a -> slprop u#1) = NMSTTotal.NMSTATETOT a (full_mem u#1) mem_evolves (requires fun m0 -> inames_ok except m0 /\ interp (expects `star` locks_invariant except m0) m0) (ensures fun m0 x m1 -> inames_ok except m1 /\ interp (provides x `star` locks_invariant except m1) m1 /\ preserves_frame except expects (provides x) m0 m1) //////////////////////////////////////////////////////////////////////////////// // Lifting heap actions //////////////////////////////////////////////////////////////////////////////// (** Heap actions come in two equivalent flavors: - one that take an explicit frame as argument (action_with_frame) - and one that quantify over all the frame We therefore define two lift routes: - a direct route for those with explicit frame - via MstTotNF for the rest *) let tot_pre_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = hmem_with_inv_except e fp -> (x:a & hmem_with_inv_except e (fp' x)) let tot_pre_action_nf = tot_pre_action_nf_except S.empty let ac_reasoning_for_m_frame_preserving (p q r:slprop u#a) (m:mem u#a) : Lemma (requires interp ((p `star` q) `star` r) m) (ensures interp (p `star` r) m) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_commutative p q; equiv_extensional_on_star (p `star` q) (q `star` p) r } (q `star` p) `star` r; (equiv) { star_associative q p r } q `star` (p `star` r); }; assert (interp (q `star` (p `star` r)) m); affine_star q (p `star` r) m let is_frame_preserving (#e:inames) (#a:Type u#b) (#fp:slprop u#a) (#fp':a -> slprop u#a) (f:tot_pre_action_nf_except e fp a fp') = forall (frame:slprop u#a) (m0:hmem_with_inv_except e (fp `star` frame)). (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = f:tot_pre_action_nf_except e fp a fp'{ is_frame_preserving f } let tot_action_nf = tot_action_nf_except S.empty let linv e (m:mem) = locks_invariant e m let hheap_of_hmem #fp #e (m:hmem_with_inv_except e fp) : h:H.hheap (fp `star` linv e m) { h `H.free_above_addr` m.ctr} = let h = heap_of_mem m in H.pure_interp (heap_ctr_valid m.ctr (heap_of_mem m)) h; h let hmem_of_hheap #e (#fp0 #fp1:slprop) (m:hmem_with_inv_except e fp0) (h:H.full_hheap (fp1 `star` linv e m) { h `Heap.free_above_addr` m.ctr }) : m1:hmem_with_inv_except e fp1{linv e m `equiv` linv e m1} = let m1 : mem = { m with heap = h } in assert (interp (fp1 `star` linv e m) m1); star_commutative fp1 (linv e m); assert (interp (linv e m `star` fp1) m1); assert (linv e m1 == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); assert (linv e m == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m)); H.pure_interp (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_of_mem m); assert (heap_ctr_valid m1.ctr (heap_of_mem m) <==> heap_ctr_valid m1.ctr (heap_of_mem m1)); H.pure_equiv (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_ctr_valid m1.ctr (heap_of_mem m1)); H.star_congruence (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m)); assert (linv e m `equiv` linv e m1); let _ = equiv_extensional_on_star (linv e m) (linv e m1) fp1 in assert ((linv e m `star` fp1) `equiv` (linv e m1 `star` fp1)); assert (interp (linv e m1 `star` fp1) m1); star_commutative (linv e m1) fp1; assert (interp (fp1 `star` linv e m1) m1); m1 let with_inv_except (m:mem) e (fp:slprop) = interp (fp `star` locks_invariant e m) m #push-options "--warn_error -271" let as_hprop (frame:slprop) (mp:mprop frame) : hp:H.hprop frame{forall m. mp (core_mem m) == hp (heap_of_mem m)} = let f = fun h -> mp (mem_of_heap h) in assert (forall m. mp (core_mem m) == f (heap_of_mem m)); let aux (m0:H.hheap frame) (m1:H.heap{H.disjoint m0 m1}) : Lemma (ensures (mem_of_heap (H.join m0 m1) == join (mem_of_heap m0) (mem_of_heap m1))) [SMTPat ()] = () in f let mprop_preservation_of_hprop_preservation (p:slprop) (m0 m1:mem) : Lemma (requires (forall (hp:H.hprop p). hp (heap_of_mem m0) == hp (heap_of_mem m1))) (ensures (forall (mp:mprop p). mp (core_mem m0) == mp (core_mem m1))) = let aux (mp:mprop p) : Lemma (mp (core_mem m0) == mp (core_mem m1)) [SMTPat()] = assert (as_hprop p mp (heap_of_mem m0) == as_hprop p mp (heap_of_mem m1)) in () let lift_heap_action (#fp:slprop) (#a:Type) (#fp':a -> slprop) (e:inames) ($f:H.action fp a fp') : tot_action_nf_except e fp a fp' = let g : tot_pre_action_nf_except e fp a fp' = fun m -> let h0 = hheap_of_hmem m in let (| x, h' |) = f h0 in (| x, hmem_of_hheap m h' |) in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in let h0 = hheap_of_hmem m0 in let (| x', h1 |) = f h0 in H.action_framing f (linv e m0) h0; assert (x == x'); star_associative fp frame (linv e m0); H.action_framing f (frame `star` linv e m0) h0; assert (H.interp ((fp' x) `star` (frame `star` linv e m0)) h1); star_associative (fp' x) frame (linv e m0); assert (H.interp ((fp' x `star` frame) `star` linv e m0) h1); let h1' : H.hheap ((fp' x `star` frame) `star` linv e m0) = h1 in assert (m1 == hmem_of_hheap m0 h1'); assert (with_inv_except m1 e (fp' x `star` frame)); assert (forall (hp:H.hprop frame). hp h0 == hp h1); mprop_preservation_of_hprop_preservation frame m0 m1; () in assert (is_frame_preserving g); g let frame_preserving_respects_preorder #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (m0:hmem_with_inv_except e fp) : Lemma (let (| x, m1 |) = f m0 in mem_evolves m0 m1) = let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1) = () in H.emp_unit fp; assert (interp (fp `star` linv e m0) m0); H.star_congruence (fp `star` emp) (linv e m0) fp (linv e m0); assert (interp ((fp `star` emp) `star` linv e m0) m0); aux emp m0 let lift_tot_action_nf #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') : MstTotNF a e fp fp' = let m0 = NMSTTotal.get () in let m0' : hmem_with_inv_except e fp = m0 in let r = f m0' in let (| x, m1 |) = r in let m1' : hmem_with_inv_except e (fp' x) = m1 in assert (is_frame_preserving f); assert (m1 == dsnd (f m0)); frame_preserving_respects_preorder f m0; NMSTTotal.put #_ #(mem_evolves) m1; x let lift_tot_action #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get #(full_mem) #_ () in ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); lift_tot_action_nf f (** Now defining the lift for heap actions with explicit frame *) let tot_action_with_frame_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = frame:slprop u#a -> m0:hmem_with_inv_except e (fp `star` frame) -> Pure (x:a & hmem_with_inv_except e (fp' x `star` frame)) (requires True) (ensures fun (| x, m1 |) -> mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_with_frame = tot_action_with_frame_except S.empty let lift_heap_action_with_frame (#fp:slprop u#a) (#a:Type u#b) (#fp':a -> slprop u#a) (e:inames) ($f:H.action_with_frame fp a fp') : tot_action_with_frame_except e fp a fp' = fun frame m0 -> let h0 = hheap_of_hmem m0 in calc (equiv) { fp `star` frame `star` locks_invariant e m0; (equiv) { star_associative fp frame (locks_invariant e m0) } fp `star` (frame `star` locks_invariant e m0); }; assert (H.interp (fp `star` frame `star` locks_invariant e m0) h0); assert (H.interp (fp `star` (frame `star` locks_invariant e m0)) h0); //key: apply the heap action with frame * locks_invariant e m0 let (| x, h1 |) = f (frame `star` locks_invariant e m0) h0 in calc (equiv) { fp' x `star` (frame `star` locks_invariant e m0); (equiv) { star_associative (fp' x) frame (locks_invariant e m0) } fp' x `star` frame `star` locks_invariant e m0; }; assert (H.interp (fp' x `star` (frame `star` locks_invariant e m0)) h1); assert (H.interp (fp' x `star` frame `star` locks_invariant e m0) h1); let m1 = hmem_of_hheap m0 h1 in assert (mem_evolves m0 m1); mprop_preservation_of_hprop_preservation (frame `star` locks_invariant e m0) m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)); (| x, m1 |) let lift_tot_action_with_frame #a #e #fp #fp' ($f:tot_action_with_frame_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in assert (inames_ok e m0); ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); let m0' : hmem_with_inv_except e fp = m0 in let r = f frame m0' in let (| x, m1 |) = r in ac_reasoning_for_m_frame_preserving (fp' x) frame (locks_invariant e m1) m1; assert (interp (fp' x `star` frame `star` locks_invariant e m1) m1); assert (interp (fp' x `star` locks_invariant e m1) m1); let m1' : hmem_with_inv_except e (fp' x) = m1 in NMSTTotal.put #_ #(mem_evolves) m1; x let sel_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.sel_action #a #pcm r v0)) let upd_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.upd_action #a #pcm r v0 v1)) let free_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.free_action #a #pcm r v0)) let split_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.split_action #a #pcm r v0 v1)) let gather_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.gather_action #a #pcm r v0 v1)) let weaken (p q r:slprop) (h:H.hheap (p `star` q) { H.stronger q r }) : H.hheap (p `star` r) = H.weaken p q r h; h let weaken_pure (q r: prop) : Lemma (requires (q ==> r)) (ensures H.stronger (H.pure q) (H.pure r)) = let aux (h:H.heap) : Lemma (ensures (H.interp (H.pure q) h ==> H.interp (H.pure r) h)) [SMTPat ()] = H.pure_interp q h; H.pure_interp r h in () let inc_ctr (#p:slprop) #e (m:hmem_with_inv_except e p) : m':hmem_with_inv_except e p{m'.ctr = m.ctr + 1 /\ H.stronger (linv e m) (linv e m')} = let m' : mem = { m with ctr = m.ctr + 1} in assert (interp (p `star` linv e m) m'); assert (linv e m == lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m)); assert (linv e m' == lock_store_invariant e m.locks `star` ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken_free_above (heap_of_mem m) m.ctr (m.ctr + 1); weaken_pure (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_ctr_valid (m.ctr + 1) (heap_of_mem m)); assert (H.stronger (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m))); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)); H.stronger_star (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken (p `star` lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)) (heap_of_mem m'); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity (m.ctr + 1) (heap_of_mem m)); let m' : hmem_with_inv_except e p = m' in m' let frame_related_mems (fp0 fp1:slprop u#a) e (m0:hmem_with_inv_except e fp0) (m1:hmem_with_inv_except e fp1) = forall (frame:slprop u#a). interp ((fp0 `star` frame) `star` linv e m0) m0 ==> interp ((fp1 `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) let refined_pre_action e (fp0:slprop) (a:Type) (fp1:a -> slprop) = m0:hmem_with_inv_except e fp0 -> Pure (x:a & hmem_with_inv_except e (fp1 x)) (requires True) (ensures fun (| x, m1 |) -> frame_related_mems fp0 (fp1 x) e m0 m1) let refined_pre_action_as_action (#fp0:slprop) (#a:Type) (#fp1:a -> slprop) #e ($f:refined_pre_action e fp0 a fp1) : tot_action_nf_except e fp0 a fp1 = let g : tot_pre_action_nf_except e fp0 a fp1 = fun m -> f m in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp0 `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp1 x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x', m1' |) = g m0 in let (| x, m1 |) = f m0 in assert (x == x' /\ m1 == m1') in g let alloc_action #a #pcm e x = let f : refined_pre_action e emp (ref a pcm) (fun r -> pts_to r x) = fun m0 -> (* NS: 9/29/22 I needed to annotate h : Heap.full_heap, for use with the Core checker which generates a guard for checking the implicit pattern "dot" term in the dependent pair pattern on the next line. That guard expects `h` to be a full_heap, which is it, because it is a projection of m0. However, this is not reflected in `h`'s type. So, the Core checker, which produces a guard for the pat_dot_term in isolation, cannot recheck the term. If we were to fold in the checking of pat_dot_terms and their guards with the rest of the VC, this would work. *) let h : Heap.full_heap = hheap_of_hmem m0 in let (|r, h'|) = H.extend #a #pcm x m0.ctr h in let m' : hmem_with_inv_except e emp = inc_ctr m0 in let h' : H.hheap (pts_to #a #pcm r x `star` linv e m') = weaken _ (linv e m0) (linv e m') h' in let m1 : hmem_with_inv_except e (pts_to #a #pcm r x) = hmem_of_hheap m' h' in assert (forall frame. H.frame_related_heaps h h' emp (pts_to #a #pcm r x) frame true); let aux (frame:slprop) : Lemma (requires interp ((emp `star` frame) `star` linv e m0) m0) (ensures interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) [SMTPat (emp `star` frame)] = star_associative emp frame (linv e m0); assert (H.interp (emp `star` (frame `star` linv e m0)) h); assert (H.interp (pts_to #a #pcm r x `star` (frame `star` linv e m0)) h'); star_associative (pts_to #a #pcm r x) frame (linv e m0); assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m0) h'); assert (H.stronger (linv e m0) (linv e m')); assert (H.equiv (linv e m') (linv e m1)); assert (H.stronger (linv e m0) (linv e m1)); let h' : H.hheap ((pts_to #a #pcm r x `star` frame) `star` linv e m1) = weaken _ (linv e m0) (linv e m1) h' in assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) h'); assert (forall (mp:H.hprop frame). mp h == mp h'); mprop_preservation_of_hprop_preservation frame m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) in assert (frame_related_mems emp (pts_to r x) e m0 m1); (| r, m1 |) in lift_tot_action (refined_pre_action_as_action f) let select_refine #a #p e r x f = lift_tot_action (lift_heap_action e (H.select_refine #a #p r x f)) let upd_gen #a #p e r x y f = lift_tot_action (lift_heap_action e (H.upd_gen_action r x y f)) //////////////////////////////////////////////////////////////////////////////// // witness / recall //////////////////////////////////////////////////////////////////////////////// let witnessed_ref #a #pcm (r:ref a pcm) (fact:property a) (m:full_mem) = H.witnessed_ref #a #pcm r fact (heap_of_mem m) let witnessed_ref_stability #a #pcm (r:ref a pcm) (fact:property a) : Lemma (requires FStar.Preorder.stable fact (Steel.Preorder.preorder_of_pcm pcm)) (ensures FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) = H.witnessed_ref_stability #a #pcm r fact let witnessed (#a:Type u#1) (#pcm:pcm a) (r:ref a pcm) (fact:property a) = W.witnessed _ mem_evolves (witnessed_ref r fact) let rearrange_pqr_prq (p q r:slprop) : Lemma (((p `star` q) `star` r) `equiv` ((p `star` r) `star` q)) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_associative p q r } p `star` (q `star` r); (equiv) { star_commutative q r; star_congruence p (q `star` r) p (r `star` q) } p `star` (r `star` q); (equiv) { star_associative p r q } (p `star` r) `star` q; } let preserves_frame_cong (e:inames) (p q:slprop) (r s:slprop) (m0 m1:mem) : Lemma (requires p `equiv` r /\ q `equiv` s /\ preserves_frame e p q m0 m1) (ensures preserves_frame e r s m0 m1) = let aux0 (p q r s:slprop) : Lemma (requires p `equiv` s) (ensures (((p `star` q) `star` r) `equiv` ((s `star` q) `star` r))) = star_congruence p q s q; star_congruence (p `star` q) r (s `star` q) r in let aux (frame:slprop) : Lemma (requires interp ((r `star` frame) `star` locks_invariant e m0) m0) (ensures interp ((s `star` frame) `star` locks_invariant e m1) m1 /\ interp ((p `star` frame) `star` locks_invariant e m0) m0) [SMTPat (r `star` frame)] = aux0 p frame (locks_invariant e m0) r; aux0 q frame (locks_invariant e m1) s; assert (((p `star` frame) `star` locks_invariant e m0) `equiv` ((r `star` frame) `star` locks_invariant e m0)); assert (interp ((p `star` frame) `star` locks_invariant e m0) m0); assert (interp ((q `star` frame) `star` locks_invariant e m1) m1); assert (((q `star` frame) `star` locks_invariant e m1) `equiv` ((s `star` frame) `star` locks_invariant e m1)); () in () let pure_true_equiv (p:slprop) : Lemma ((p `star` pure True) `equiv` p) = FStar.Classical.forall_intro (pure_star_interp p True); emp_unit p; assert ((p `star` pure True) `equiv` p) let preserves_frame_star_pure (e:inames) (p q:slprop) (r s:prop) (m:mem) : Lemma (requires r /\ s) (ensures preserves_frame e p q m m <==> preserves_frame e (p `star` pure r) (q `star` pure s) m m) = pure_equiv r True; star_congruence p (pure r) p (pure True); pure_equiv s True; star_congruence q (pure s) q (pure True); pure_true_equiv p; pure_true_equiv q; let fwd () : Lemma (requires preserves_frame e p q m m) (ensures preserves_frame e (p `star` pure r) (q `star` pure s) m m) [SMTPat ()] = preserves_frame_cong e p q (p `star` pure r) (q `star` pure s) m m in let bk () : Lemma (requires preserves_frame e (p `star` pure r) (q `star` pure s) m m) (ensures preserves_frame e p q m m) [SMTPat ()] = preserves_frame_cong e (p `star` pure r) (q `star` pure s) p q m m in () let witness (#a:Type) (#pcm:pcm a) (e:inames) (r:erased (ref a pcm)) (fact:stable_property pcm) (v:Ghost.erased a) (_:squash (forall z. compatible pcm v z ==> fact z)) (frame:slprop) : MstTot (witnessed r fact) e (pts_to r v) (fun _ -> pts_to r v) frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in let _ : unit = let hr : H.ref a pcm = r in let v' = H.sel_v hr v (heap_of_mem m0) in assert (interp (H.ptr hr) m0 /\ H.sel #a #pcm hr (heap_of_mem m0) == v'); assert (compatible pcm v v'); assert (fact v'); assert (witnessed_ref r fact m0); witnessed_ref_stability r fact; assert (FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) in let w = NMSTTotal.witness _ mem_evolves (witnessed_ref r fact) in w let recall (#a:Type u#1) (#pcm:pcm a) (#fact:property a) (e:inames) (r:erased (ref a pcm)) (v:Ghost.erased a) (w:witnessed r fact) (frame:slprop) = let m0 = NMSTTotal.get () in NMSTTotal.recall _ mem_evolves (witnessed_ref r fact) w; let hr : H.ref a pcm = r in assert (witnessed_ref r fact m0); let v1 = H.sel_v hr v (heap_of_mem m0) in assert (compatible pcm v v1); assert (H.sel hr (heap_of_mem m0) == v1); assert (fact v1); assert (interp ((pts_to r v `star` frame) `star` locks_invariant e m0) m0); emp_unit ((pts_to r v `star` frame) `star` locks_invariant e m0); pure_star_interp ((pts_to r v `star` frame) `star` locks_invariant e m0) (fact v1) m0; assert (interp (((pts_to r v `star` frame) `star` locks_invariant e m0) `star` pure (fact v1)) m0); rearrange_pqr_prq (pts_to r v `star` frame) (locks_invariant e m0) (pure (fact v1)); assert (interp (((pts_to r v `star` frame) `star` pure (fact v1)) `star` locks_invariant e m0) m0); rearrange_pqr_prq (pts_to r v) frame (pure (fact v1)); star_congruence ((pts_to r v `star` frame) `star` pure (fact v1)) (locks_invariant e m0) ((pts_to r v `star` pure (fact v1)) `star` frame) (locks_invariant e m0); Ghost.hide v1 let iname_for_p_mem (i:iname) (p:slprop) : W.s_predicate mem = fun m -> iname_for_p i p m.locks let iname_for_p_stable (i:iname) (p:slprop) : Lemma (W.stable full_mem mem_evolves (iname_for_p_mem i p)) = () let ( >--> ) (i:iname) (p:slprop) : Type0 = W.witnessed full_mem mem_evolves (iname_for_p_mem i p) let hmem_with_inv_equiv e (m:mem) (p:slprop) : Lemma (interp (p `star` linv e m) m <==> interp (p `star` lock_store_invariant e m.locks) m /\ heap_ctr_valid m.ctr (heap_of_mem m)) = calc (<==>) { interp (p `star` linv e m) m; (<==>) { H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) } interp ((p `star` lock_store_invariant e m.locks) `star` ctr_validity m.ctr (heap_of_mem m)) m; (<==>) { H.pure_star_interp (p `star` lock_store_invariant e m.locks) (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_of_mem m) } interp ((p `star` lock_store_invariant e m.locks) `star` emp) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); (<==>) { H.emp_unit (p `star` lock_store_invariant e m.locks) } interp (p `star` lock_store_invariant e m.locks) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); } let new_invariant_tot_action (e:inames) (p:slprop) (m0:hmem_with_inv_except e p{ e `inames_in` m0.locks }) : Pure (iname & hmem_with_inv_except e emp) (requires True) (ensures fun (i, m1) -> iname_for_p_mem i p m1 /\ frame_related_mems p emp e m0 m1 /\ mem_evolves m0 m1) = let (| i, l1 |) = extend_lock_store e m0.locks p in let m1 = { m0 with locks = l1 } in assert (lock_store_invariant e m1.locks == p `star` lock_store_invariant e m0.locks); calc (equiv) { linv e m1; (equiv) {} (lock_store_invariant e m1.locks `star` ctr_validity m1.ctr (heap_of_mem m1)); (equiv) {} ((p `star` lock_store_invariant e m0.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); (equiv) { H.star_associative p (lock_store_invariant e m0.locks) (ctr_validity m1.ctr (heap_of_mem m1)) } (p `star` (lock_store_invariant e m0.locks `star` ctr_validity m1.ctr (heap_of_mem m1))); (equiv) { } (p `star` linv e m0); }; assert (iname_for_p_mem i p m1); assert (lock_store_evolves m0.locks l1); assert (mem_evolves m0 m1); hmem_with_inv_equiv e m0 p; assert (interp (p `star` lock_store_invariant e m0.locks) m1); assert (interp (lock_store_invariant e m1.locks) m1); H.emp_unit (lock_store_invariant e m1.locks); H.star_commutative (lock_store_invariant e m1.locks) emp; assert (interp (emp `star` lock_store_invariant e m1.locks) m1); hmem_with_inv_equiv e m1 emp; let m1 : hmem_with_inv_except e emp = m1 in let aux (frame:slprop) : Lemma (requires interp ((p `star` frame) `star` linv e m0) m0) (ensures interp ((emp `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) <==> mp (core_mem m1))) [SMTPat (p `star` frame)] = assert (interp ((p `star` frame) `star` linv e m0) m1); calc (equiv) { ((p `star` frame) `star` linv e m0); (equiv) { H.star_commutative p frame; H.star_congruence (p `star` frame) (linv e m0) (frame `star` p) (linv e m0); H.star_associative frame p (linv e m0) } (frame `star` (p `star` linv e m0)); (equiv) { H.star_congruence frame (p `star` linv e m0) frame (linv e m1) } (frame `star` linv e m1); (equiv) { H.emp_unit (frame `star` linv e m1); H.star_commutative (frame `star` linv e m1) emp; H.star_associative emp frame (linv e m1) } ((emp `star` frame) `star` linv e m1); }; assert (interp ((emp `star` frame) `star` linv e m1) m1) in assert (frame_related_mems p emp e m0 m1); ( i, m1 ) let name_is_ok (i:iname) (m0:full_mem u#1) : prop = i < List.Tot.length m0.locks let witnessed_name_is_ok (i:iname) = W.witnessed full_mem mem_evolves (name_is_ok i) let pre_inv = i:erased iname & witnessed_name_is_ok i let inv (p:slprop u#1) = i:erased iname & witnessed_name_is_ok i & (i >--> p) let pre_inv_of_inv #p (i:inv p) = let (|i, w, _|) = i in (|i,w|) let name_of_pre_inv (i:pre_inv) = dfst i let rec recall_all (ctx:list pre_inv) : NMSTTotal.NMSTATETOT unit (full_mem u#1) mem_evolves (requires fun _ -> True) (ensures fun m0 _ m1 -> m0==m1 /\ (forall i. i `List.Tot.memP` ctx ==> name_is_ok (name_of_pre_inv i) m0)) = match ctx with | [] -> () | hd::tl -> let (| q, i |) = hd in let i : W.witnessed full_mem mem_evolves (name_is_ok q) = i in NMSTTotal.recall _ mem_evolves (name_is_ok q) i; recall_all tl let fresh_invariant (e:inames) (p:slprop) (ctx:list pre_inv) (frame:slprop) : MstTot (i:inv p { not (mem_inv e i) /\ fresh_wrt ctx (name_of_inv i)}) e p (fun _ -> emp) frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in recall_all ctx; ac_reasoning_for_m_frame_preserving p frame (locks_invariant e m0) m0; assert (interp (p `star` locks_invariant e m0) m0); let r = new_invariant_tot_action e p m0 in let ( i, m1 ) = r in assert (i == List.Tot.length m0.locks); assert (not (Set.mem i e)); assert (mem_evolves m0 m1); NMSTTotal.put #full_mem #mem_evolves m1; iname_for_p_stable i p; let w = NMSTTotal.witness full_mem mem_evolves (iname_for_p_mem i p) in let w0 = NMSTTotal.witness full_mem mem_evolves (name_is_ok i) in (| hide i, w0, w |) let new_invariant (e:inames) (p:slprop) (frame:slprop) : MstTot (inv p) e p (fun _ -> emp) frame (fun _ -> True) (fun _ _ _ -> True) = fresh_invariant e p [] frame

{ "checked_file": "/", "dependencies": [ "Steel.Preorder.fst.checked", "Steel.Heap.fsti.checked", "prims.fst.checked", "FStar.Witnessed.Core.fsti.checked", "FStar.Set.fsti.checked", "FStar.Preorder.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.PCM.fst.checked", "FStar.NMSTTotal.fst.checked", "FStar.List.Tot.fst.checked", "FStar.IndefiniteDescription.fsti.checked", "FStar.Ghost.fsti.checked", "FStar.FunctionalExtensionality.fsti.checked", "FStar.Classical.Sugar.fsti.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Steel.Memory.fst" }

[ { "abbrev": true, "full_module": "Steel.Preorder", "short_module": "PP" }, { "abbrev": true, "full_module": "FStar.Witnessed.Core", "short_module": "W" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": true, "full_module": "Steel.Heap", "short_module": "H" }, { "abbrev": false, "full_module": "FStar.PCM", "short_module": null }, { "abbrev": false, "full_module": "FStar.FunctionalExtensionality", "short_module": null }, { "abbrev": true, "full_module": "FStar.FunctionalExtensionality", "short_module": "F" }, { "abbrev": false, "full_module": "FStar.PCM", "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

p: Steel.Memory.slprop -> q: Steel.Memory.slprop -> r: Steel.Memory.slprop -> q0: Steel.Memory.slprop -> q1: Steel.Memory.slprop -> FStar.Pervasives.Lemma (requires Steel.Memory.equiv q (Steel.Memory.star q0 q1)) (ensures Steel.Memory.equiv (Steel.Memory.star p (Steel.Memory.star q r)) (Steel.Memory.star (Steel.Memory.star q0 p) (Steel.Memory.star q1 r)))

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Steel.Memory.slprop", "FStar.Calc.calc_finish", "Steel.Memory.equiv", "Steel.Memory.star", "Prims.Cons", "FStar.Preorder.relation", "Prims.Nil", "Prims.unit", "FStar.Calc.calc_step", "FStar.Calc.calc_init", "FStar.Calc.calc_pack", "Steel.Memory.star_congruence", "Prims.squash", "Steel.Memory.star_associative", "Steel.Memory.star_commutative", "FStar.Pervasives.pattern" ]

[]

false

true

false

let rearrange_invariant (p q r q0 q1: slprop) : Lemma (requires q `equiv` (q0 `star` q1)) (ensures (p `star` (q `star` r)) `equiv` ((q0 `star` p) `star` (q1 `star` r))) =

calc (equiv) { p `star` (q `star` r); (equiv) { (calc (equiv) { (q `star` r); (equiv) { star_congruence q r (q0 `star` q1) r } (q0 `star` q1) `star` r; }; star_congruence p (q `star` r) p ((q0 `star` q1) `star` r)) } (p `star` ((q0 `star` q1) `star` r)); (equiv) { (star_associative q0 q1 r; star_congruence p ((q0 `star` q1) `star` r) p (q0 `star` (q1 `star` r)); star_associative p q0 (q1 `star` r)) } (p `star` q0) `star` (q1 `star` r); (equiv) { (star_commutative p q0; star_congruence (p `star` q0) (q1 `star` r) (q0 `star` p) (q1 `star` r)) } (q0 `star` p) `star` (q1 `star` r); }

false

Steel.Memory.fst

Steel.Memory.hmem_with_inv_equiv

val hmem_with_inv_equiv (e: _) (m: mem) (p: slprop) : Lemma (interp (p `star` (linv e m)) m <==> interp (p `star` (lock_store_invariant e m.locks)) m /\ heap_ctr_valid m.ctr (heap_of_mem m))

let hmem_with_inv_equiv e (m:mem) (p:slprop) : Lemma (interp (p `star` linv e m) m <==> interp (p `star` lock_store_invariant e m.locks) m /\ heap_ctr_valid m.ctr (heap_of_mem m)) = calc (<==>) { interp (p `star` linv e m) m; (<==>) { H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) } interp ((p `star` lock_store_invariant e m.locks) `star` ctr_validity m.ctr (heap_of_mem m)) m; (<==>) { H.pure_star_interp (p `star` lock_store_invariant e m.locks) (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_of_mem m) } interp ((p `star` lock_store_invariant e m.locks) `star` emp) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); (<==>) { H.emp_unit (p `star` lock_store_invariant e m.locks) } interp (p `star` lock_store_invariant e m.locks) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); }

{ "file_name": "lib/steel/Steel.Memory.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 5, "end_line": 1174, "start_col": 0, "start_line": 1160 }

(* 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.Memory module F = FStar.FunctionalExtensionality open FStar.FunctionalExtensionality open FStar.PCM module H = Steel.Heap noeq type lock_state : Type u#(a + 1) = | Invariant : inv:H.slprop u#a -> lock_state let lock_store : Type u#(a+1) = list (lock_state u#a) noeq type mem : Type u#(a + 1) = { ctr: nat; heap: H.heap u#a; locks: lock_store u#a; } let heap_of_mem (x:mem) : H.heap = x.heap let mem_of_heap (h:H.heap) : mem = { ctr = 0; heap = h; locks = [] } let mem_set_heap (m:mem) (h:H.heap) : mem = { ctr = m.ctr; heap = h; locks = m.locks; } let core_mem (m:mem) : mem = mem_of_heap (heap_of_mem m) let core_mem_invol m = () let disjoint (m0 m1:mem u#h) : prop = m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks let disjoint_sym m0 m1 = () let join m0 m1 = { ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = m0.locks } let join_commutative m0 m1 = H.join_commutative m0.heap m1.heap let disjoint_join m0 m1 m2 = H.disjoint_join m0.heap m1.heap m2.heap let join_associative m0 m1 m2 = H.join_associative m0.heap m1.heap m2.heap let slprop = H.slprop let interp p m = H.interp p m.heap let equiv p1 p2 = forall m. interp p1 m <==> interp p2 m let slprop_extensionality p q = assert (forall m. interp p m <==> interp q m); let aux (h:H.heap) : Lemma (H.interp p h <==> H.interp q h) [SMTPat (H.interp p h)] = let m : mem = { ctr = 0; heap = h; locks = [] } in assert (interp p m <==> interp q m) in assert (forall h. H.interp p h <==> H.interp q h); Steel.Heap.slprop_extensionality p q let reveal_equiv p1 p2 = () let core_ref = H.core_ref let core_ref_null = H.core_ref_null let core_ref_is_null r = H.core_ref_is_null r let emp : slprop u#a = H.emp let pure = H.pure let pts_to = H.pts_to let h_and = H.h_and let h_or = H.h_or let star = H.star let wand = H.wand let h_exists = H.h_exists let h_forall = H.h_forall //////////////////////////////////////////////////////////////////////////////// //properties of equiv //////////////////////////////////////////////////////////////////////////////// let equiv_symmetric (p1 p2:slprop u#a) = H.equiv_symmetric p1 p2 #push-options "--warn_error -271" let equiv_heap_iff_equiv (p1 p2:slprop u#a) : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat (equiv p1 p2)] = let aux_lr () : Lemma (requires H.equiv p1 p2) (ensures equiv p1 p2) [SMTPat ()] = () in let aux_rl_helper1 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p1 h) (ensures H.interp p2 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl_helper2 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p2 h) (ensures H.interp p1 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl () : Lemma (requires equiv p1 p2) (ensures H.equiv p1 p2) [SMTPat ()] = () in () let equiv_heap_iff_equiv_forall () : Lemma (ensures (forall p1 p2. H.equiv p1 p2 <==> equiv p1 p2)) = let aux p1 p2 : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat ()] = equiv_heap_iff_equiv p1 p2 in () #pop-options let equiv_extensional_on_star (p1 p2 p3:slprop u#a) = equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3 let emp_unit p = H.emp_unit p let intro_emp m = H.intro_emp (heap_of_mem m) let pure_equiv p q = H.pure_equiv p q let pure_interp q m = H.pure_interp q (heap_of_mem m) let pure_star_interp p q m = H.pure_star_interp p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// //pts_to //////////////////////////////////////////////////////////////////////////////// let pts_to_compatible #a #pcm x v0 v1 m = H.pts_to_compatible #a #pcm x v0 v1 (heap_of_mem m) let pts_to_compatible_equiv #a #pcm x v0 v1 = H.pts_to_compatible_equiv #a #pcm x v0 v1 let pts_to_not_null #a #pcm x v m = H.pts_to_not_null #a #pcm x v (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // star //////////////////////////////////////////////////////////////////////////////// let intro_star p q mp mq = H.intro_star p q (heap_of_mem mp) (heap_of_mem mq) let elim_star p q m = let h = heap_of_mem m in H.elim_star p q h; assert (exists hl hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr); let hl = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hl -> exists hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let hr = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hr -> H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let ml = mem_set_heap m hl in let mr = mem_set_heap m hr in assert (disjoint ml mr); assert (m == join ml mr); assert (interp p ml); assert (interp q mr); () let interp_star (p q: slprop) (m: mem) : Lemma (interp (p `star` q) m <==> (exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m)) = let left = interp (p `star` q) m in let right = exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m in let f () : Lemma (requires left) (ensures right) = elim_star p q m in let g () : Lemma (requires right) (ensures left) = Classical.exists_elim left #_ #(fun mp -> exists (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mp -> Classical.exists_elim left #_ #(fun mq -> disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mq -> intro_star p q mp mq ) ) in Classical.move_requires f (); Classical.move_requires g () let star_commutative (p1 p2:slprop) = H.star_commutative p1 p2 let star_associative (p1 p2 p3:slprop) = H.star_associative p1 p2 p3 let star_congruence (p1 p2 p3 p4:slprop) = equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4 let affine_star (p q:slprop) (m:mem) = H.affine_star p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // Invariants on the lock store //////////////////////////////////////////////////////////////////////////////// let iname = nat module S = FStar.Set module L = FStar.List.Tot module W = FStar.Witnessed.Core let rec lock_store_invariant (e:inames) (l:lock_store u#a) : slprop u#a = let current_addr = L.length l - 1 in match l with | [] -> emp | Invariant p :: tl -> if current_addr `S.mem` e then lock_store_invariant e tl else p `star` lock_store_invariant e tl let lock_i (i:iname) (l:lock_store { i < L.length l }) = let ix = L.length l - i - 1 in L.index l ix let iname_for_p (i:iname) (p:slprop) : W.s_predicate lock_store = fun l -> i < L.length l /\ (lock_i i l).inv == p let lock_store_evolves : FStar.Preorder.preorder lock_store = fun (l1 l2 : lock_store) -> L.length l2 >= L.length l1 /\ (forall (i:nat{i < L.length l1}). (lock_i i l1).inv == (lock_i i l2).inv) let inames_in (e:inames) (l:lock_store) : prop = forall i. Set.mem i e ==> i < L.length l let inames_ok e m = inames_in e m.locks let inames_ok_empty m = () let extend_lock_store (e:inames) (l:lock_store{e `inames_in` l}) (p:slprop) : i:iname & l':lock_store { lock_store_invariant e l' == p `star` lock_store_invariant e l /\ iname_for_p i p l' } = (| L.length l, Invariant p :: l |) let set_add (i:iname) (s:inames) = Set.union (Set.singleton i) s let rec move_invariant (e:inames) (l:lock_store) (p:slprop) (i:iname{iname_for_p i p l /\ ~(i `Set.mem` e)}) : Lemma (H.equiv (lock_store_invariant e l) (p `star` lock_store_invariant (set_add i e) l)) = let rec aux (i:iname) (m:lock_store) : Lemma (requires i >= L.length m) (ensures (lock_store_invariant e m `H.equiv` lock_store_invariant (set_add i e) m)) = match m with | [] -> () | Invariant p::tl -> aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl) in let current_addr = L.length l - 1 in match l with | [] -> () | Invariant q::tl -> if i = current_addr then begin assert (lock_store_invariant e l == p `star` lock_store_invariant e tl); aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl); () end else begin move_invariant e tl p i; assert (lock_store_invariant e tl `equiv` (p `star` lock_store_invariant (set_add i e) tl)); H.star_congruence q (lock_store_invariant e tl) q (p `star` lock_store_invariant (set_add i e) tl); if Set.mem current_addr e then () else begin let r = lock_store_invariant (set_add i e) tl in assert (lock_store_invariant e l `equiv` (q `star` (p `star` r))); H.star_associative q p r; H.star_commutative q p; H.star_congruence (q `star` p) r (p `star` q) r; H.star_associative p q r end end let heap_ctr_valid (ctr:nat) (h:H.heap u#a) : prop = h `H.free_above_addr` ctr let ctr_validity (ctr:nat) (h:H.heap) : slprop = H.pure (heap_ctr_valid ctr h) let locks_invariant (e:inames) (m:mem u#a) : slprop u#a = lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m) let full_mem_pred (m:mem) = H.full_heap_pred (heap_of_mem m) (***** Following lemmas are needed in Steel.Effect *****) let core_mem_interp (hp:slprop u#a) (m:mem u#a) = () let interp_depends_only_on (hp:slprop u#a) = H.interp_depends_only_on hp let a_mem_prop_as_a_heap_prop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (H.a_heap_prop u#a) = let g (h: H.heap u#a) : Tot prop = interp sl (mem_of_heap h) /\ f (mem_of_heap h) in let phi0 (h0 h1: H.heap u#a) : Lemma (requires (g h0 /\ H.disjoint h0 h1)) (ensures (g h0 /\ H.disjoint h0 h1 /\ g (H.join h0 h1))) = assert (mem_of_heap (H.join h0 h1) == mem_of_heap h0 `join` mem_of_heap h1); interp_depends_only_on sl in let phi1 (h0 h1: H.heap u#a) : Lemma (ensures ((g h0 /\ H.disjoint h0 h1) ==> g (H.join h0 h1))) = Classical.move_requires (phi0 h0) h1 in Classical.forall_intro_2 phi1; g let refine_slprop sl f = H.as_slprop (a_mem_prop_as_a_heap_prop sl f) let interp_refine_slprop sl f m = assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_mem m)) let dep_hprop (s: slprop) (f: (hmem s -> Tot slprop)) (h: H.heap) : Tot prop = exists (h1: H.heap) . exists (h2: H.heap) . interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 let dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq' : squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h')) = let p2 (h h1 h2: H.heap) : Tot prop = interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 in let p1 (h h1: H.heap) : Tot prop = (exists h2 . p2 h h1 h2) in let h1 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p1 h) in let h2 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p2 h h1) in H.disjoint_join h' h1 h2; assert (H.disjoint h2 h'); let h2' = H.join h2 h' in H.join_commutative h2 h' ; assert (h2' == H.join h' h2); assert (H.disjoint h1 h2'); assert (mem_of_heap h2' == mem_of_heap h2 `join` mem_of_heap h'); interp_depends_only_on (f (mem_of_heap h1)); assert (interp (f (mem_of_heap h1)) (mem_of_heap h2')); H.join_commutative h1 h2; H.join_associative h' h2 h1; H.join_commutative h' h; H.join_commutative h2' h1; assert (H.join h h' == h1 `H.join` h2') let impl_intro_gen (#p: Type0) (#q: Type0) ($prf: (squash p -> Lemma (q ))) : Lemma (p ==> q) = Classical.impl_intro_gen #p #(fun _ -> q) prf let dep_hprop_is_affine1 (s: slprop) (f: (hmem s -> Tot slprop)) (h0 h1: H.heap) : Lemma ((dep_hprop s f h0 /\ H.disjoint h0 h1) ==> (H.disjoint h0 h1 /\ dep_hprop s f (H.join h0 h1))) = impl_intro_gen (dep_hprop_is_affine0 s f h0 h1) let dep_hprop_is_affine (s: slprop) (f: (hmem s -> Tot slprop)) : Lemma (H.heap_prop_is_affine (dep_hprop s f)) = Classical.forall_intro_2 (dep_hprop_is_affine1 s f) let sdep (s: slprop) (f: (hmem s -> Tot slprop)) : Tot slprop = dep_hprop_is_affine s f; H.as_slprop (dep_hprop s f) let interp_sdep (s: slprop) (f: (hmem s -> Tot slprop)) (m: mem) : Lemma (requires (dep_slprop_is_affine s f)) (ensures ( interp (sdep s f) m <==> (exists m1 m2 . interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) )) = dep_hprop_is_affine s f; assert (forall m1 m2 . (interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) ==> ( interp s (mem_of_heap m1.heap) /\ interp (f (mem_of_heap m1.heap)) (mem_of_heap m2.heap) /\ H.disjoint m1.heap m2.heap /\ H.join m1.heap m2.heap == m.heap )); interp_depends_only_on s; Classical.forall_intro (fun m -> interp_depends_only_on (f m)); assert (forall h1 h2 . (interp s (mem_of_heap h1) /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ H.disjoint h1 h2 /\ H.join h1 h2 == m.heap) ==> ( core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ interp s (core_mem (mem_of_heap h1)) /\ interp s (mem_set_heap m h1) /\ core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ f (mem_set_heap m h1) `equiv` f (mem_of_heap h1) /\ interp (f (mem_set_heap m h1)) (mem_of_heap h2) /\ interp (f (mem_set_heap m h1)) (mem_set_heap m h2) /\ disjoint (mem_set_heap m h1) (mem_set_heap m h2) /\ join (mem_set_heap m h1) (mem_set_heap m h2) == m )); () let h_exists_cong (#a:Type) (p q : a -> slprop) : Lemma (requires (forall x. p x `equiv` q x)) (ensures (h_exists p `equiv` h_exists q)) = equiv_heap_iff_equiv_forall (); H.h_exists_cong p q let intro_h_exists #a x p m = H.intro_h_exists x p (heap_of_mem m) let elim_h_exists (#a:_) (p:a -> slprop) (m:mem) = H.elim_h_exists p (heap_of_mem m) let intro_h_forall (#a:_) (p:a -> slprop) (m:mem) = H.intro_h_forall p (heap_of_mem m) let elim_h_forall (#a:_) (p:a -> slprop) (m:mem) (x:a) = H.elim_h_forall p (heap_of_mem m) x let intro_h_and (p q: slprop) (m:mem) = H.intro_h_and p q (heap_of_mem m) let elim_h_and (p q: slprop) (m:mem) = H.elim_h_and p q (heap_of_mem m) let intro_h_or_left (p q: slprop) (m:mem) = H.intro_h_or_left p q (heap_of_mem m) let intro_h_or_right (p q: slprop) (m:mem) = H.intro_h_or_right p q (heap_of_mem m) let elim_h_or (p q: slprop) (m:mem) = H.elim_h_or p q (heap_of_mem m) let intro_wand (p1 p2: slprop u#a) (m:mem) = introduce (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)) ==> interp (wand p1 p2) m with _. ( assert (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)); H.intro_wand p1 p2 (heap_of_mem m); let h = heap_of_mem m in assert ((forall h1. h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) ==> H.interp (wand p1 p2) h); introduce forall h1. (h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) with ( introduce (h `H.disjoint` h1 /\ H.interp p1 h1) ==> H.interp p2 (H.join h h1) with _. ( assert (h `H.disjoint` h1); let m1 = { ctr = m.ctr; heap = h1; locks = m.locks } in assert (m `disjoint` m1) ) ) ) (** Eliminating a wand by proving a heap that satisfies the LHS **) let elim_wand (p1 p2: slprop u#a) (m:mem) (m1:mem) = H.elim_wand p1 p2 (heap_of_mem m) (heap_of_mem m1) //////////////////////////////////////////////////////////////////////////////// // Preorders and effects //////////////////////////////////////////////////////////////////////////////// module PP = Steel.Preorder let mem_evolves = fun (m0 m1:full_mem) -> H.heap_evolves (heap_of_mem m0) (heap_of_mem m1) /\ m0.ctr <= m1.ctr /\ lock_store_evolves m0.locks m1.locks (** See [Steel.Heap.is_frame_preserving]. We add in [lock_invariants] now *) let preserves_frame (e:inames) (pre post:slprop) (m0 m1:mem) = forall (frame:slprop). interp ((pre `star` frame) `star` locks_invariant e m0) m0 ==> (interp ((post `star` frame) `star` locks_invariant e m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) (** This is a version of MstTot with frame quantified, as part of preserves_frame *) effect MstTotNF (a:Type u#a) (except:inames) (expects:slprop u#1) (provides: a -> slprop u#1) = NMSTTotal.NMSTATETOT a (full_mem u#1) mem_evolves (requires fun m0 -> inames_ok except m0 /\ interp (expects `star` locks_invariant except m0) m0) (ensures fun m0 x m1 -> inames_ok except m1 /\ interp (provides x `star` locks_invariant except m1) m1 /\ preserves_frame except expects (provides x) m0 m1) //////////////////////////////////////////////////////////////////////////////// // Lifting heap actions //////////////////////////////////////////////////////////////////////////////// (** Heap actions come in two equivalent flavors: - one that take an explicit frame as argument (action_with_frame) - and one that quantify over all the frame We therefore define two lift routes: - a direct route for those with explicit frame - via MstTotNF for the rest *) let tot_pre_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = hmem_with_inv_except e fp -> (x:a & hmem_with_inv_except e (fp' x)) let tot_pre_action_nf = tot_pre_action_nf_except S.empty let ac_reasoning_for_m_frame_preserving (p q r:slprop u#a) (m:mem u#a) : Lemma (requires interp ((p `star` q) `star` r) m) (ensures interp (p `star` r) m) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_commutative p q; equiv_extensional_on_star (p `star` q) (q `star` p) r } (q `star` p) `star` r; (equiv) { star_associative q p r } q `star` (p `star` r); }; assert (interp (q `star` (p `star` r)) m); affine_star q (p `star` r) m let is_frame_preserving (#e:inames) (#a:Type u#b) (#fp:slprop u#a) (#fp':a -> slprop u#a) (f:tot_pre_action_nf_except e fp a fp') = forall (frame:slprop u#a) (m0:hmem_with_inv_except e (fp `star` frame)). (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = f:tot_pre_action_nf_except e fp a fp'{ is_frame_preserving f } let tot_action_nf = tot_action_nf_except S.empty let linv e (m:mem) = locks_invariant e m let hheap_of_hmem #fp #e (m:hmem_with_inv_except e fp) : h:H.hheap (fp `star` linv e m) { h `H.free_above_addr` m.ctr} = let h = heap_of_mem m in H.pure_interp (heap_ctr_valid m.ctr (heap_of_mem m)) h; h let hmem_of_hheap #e (#fp0 #fp1:slprop) (m:hmem_with_inv_except e fp0) (h:H.full_hheap (fp1 `star` linv e m) { h `Heap.free_above_addr` m.ctr }) : m1:hmem_with_inv_except e fp1{linv e m `equiv` linv e m1} = let m1 : mem = { m with heap = h } in assert (interp (fp1 `star` linv e m) m1); star_commutative fp1 (linv e m); assert (interp (linv e m `star` fp1) m1); assert (linv e m1 == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); assert (linv e m == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m)); H.pure_interp (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_of_mem m); assert (heap_ctr_valid m1.ctr (heap_of_mem m) <==> heap_ctr_valid m1.ctr (heap_of_mem m1)); H.pure_equiv (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_ctr_valid m1.ctr (heap_of_mem m1)); H.star_congruence (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m)); assert (linv e m `equiv` linv e m1); let _ = equiv_extensional_on_star (linv e m) (linv e m1) fp1 in assert ((linv e m `star` fp1) `equiv` (linv e m1 `star` fp1)); assert (interp (linv e m1 `star` fp1) m1); star_commutative (linv e m1) fp1; assert (interp (fp1 `star` linv e m1) m1); m1 let with_inv_except (m:mem) e (fp:slprop) = interp (fp `star` locks_invariant e m) m #push-options "--warn_error -271" let as_hprop (frame:slprop) (mp:mprop frame) : hp:H.hprop frame{forall m. mp (core_mem m) == hp (heap_of_mem m)} = let f = fun h -> mp (mem_of_heap h) in assert (forall m. mp (core_mem m) == f (heap_of_mem m)); let aux (m0:H.hheap frame) (m1:H.heap{H.disjoint m0 m1}) : Lemma (ensures (mem_of_heap (H.join m0 m1) == join (mem_of_heap m0) (mem_of_heap m1))) [SMTPat ()] = () in f let mprop_preservation_of_hprop_preservation (p:slprop) (m0 m1:mem) : Lemma (requires (forall (hp:H.hprop p). hp (heap_of_mem m0) == hp (heap_of_mem m1))) (ensures (forall (mp:mprop p). mp (core_mem m0) == mp (core_mem m1))) = let aux (mp:mprop p) : Lemma (mp (core_mem m0) == mp (core_mem m1)) [SMTPat()] = assert (as_hprop p mp (heap_of_mem m0) == as_hprop p mp (heap_of_mem m1)) in () let lift_heap_action (#fp:slprop) (#a:Type) (#fp':a -> slprop) (e:inames) ($f:H.action fp a fp') : tot_action_nf_except e fp a fp' = let g : tot_pre_action_nf_except e fp a fp' = fun m -> let h0 = hheap_of_hmem m in let (| x, h' |) = f h0 in (| x, hmem_of_hheap m h' |) in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in let h0 = hheap_of_hmem m0 in let (| x', h1 |) = f h0 in H.action_framing f (linv e m0) h0; assert (x == x'); star_associative fp frame (linv e m0); H.action_framing f (frame `star` linv e m0) h0; assert (H.interp ((fp' x) `star` (frame `star` linv e m0)) h1); star_associative (fp' x) frame (linv e m0); assert (H.interp ((fp' x `star` frame) `star` linv e m0) h1); let h1' : H.hheap ((fp' x `star` frame) `star` linv e m0) = h1 in assert (m1 == hmem_of_hheap m0 h1'); assert (with_inv_except m1 e (fp' x `star` frame)); assert (forall (hp:H.hprop frame). hp h0 == hp h1); mprop_preservation_of_hprop_preservation frame m0 m1; () in assert (is_frame_preserving g); g let frame_preserving_respects_preorder #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (m0:hmem_with_inv_except e fp) : Lemma (let (| x, m1 |) = f m0 in mem_evolves m0 m1) = let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1) = () in H.emp_unit fp; assert (interp (fp `star` linv e m0) m0); H.star_congruence (fp `star` emp) (linv e m0) fp (linv e m0); assert (interp ((fp `star` emp) `star` linv e m0) m0); aux emp m0 let lift_tot_action_nf #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') : MstTotNF a e fp fp' = let m0 = NMSTTotal.get () in let m0' : hmem_with_inv_except e fp = m0 in let r = f m0' in let (| x, m1 |) = r in let m1' : hmem_with_inv_except e (fp' x) = m1 in assert (is_frame_preserving f); assert (m1 == dsnd (f m0)); frame_preserving_respects_preorder f m0; NMSTTotal.put #_ #(mem_evolves) m1; x let lift_tot_action #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get #(full_mem) #_ () in ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); lift_tot_action_nf f (** Now defining the lift for heap actions with explicit frame *) let tot_action_with_frame_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = frame:slprop u#a -> m0:hmem_with_inv_except e (fp `star` frame) -> Pure (x:a & hmem_with_inv_except e (fp' x `star` frame)) (requires True) (ensures fun (| x, m1 |) -> mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_with_frame = tot_action_with_frame_except S.empty let lift_heap_action_with_frame (#fp:slprop u#a) (#a:Type u#b) (#fp':a -> slprop u#a) (e:inames) ($f:H.action_with_frame fp a fp') : tot_action_with_frame_except e fp a fp' = fun frame m0 -> let h0 = hheap_of_hmem m0 in calc (equiv) { fp `star` frame `star` locks_invariant e m0; (equiv) { star_associative fp frame (locks_invariant e m0) } fp `star` (frame `star` locks_invariant e m0); }; assert (H.interp (fp `star` frame `star` locks_invariant e m0) h0); assert (H.interp (fp `star` (frame `star` locks_invariant e m0)) h0); //key: apply the heap action with frame * locks_invariant e m0 let (| x, h1 |) = f (frame `star` locks_invariant e m0) h0 in calc (equiv) { fp' x `star` (frame `star` locks_invariant e m0); (equiv) { star_associative (fp' x) frame (locks_invariant e m0) } fp' x `star` frame `star` locks_invariant e m0; }; assert (H.interp (fp' x `star` (frame `star` locks_invariant e m0)) h1); assert (H.interp (fp' x `star` frame `star` locks_invariant e m0) h1); let m1 = hmem_of_hheap m0 h1 in assert (mem_evolves m0 m1); mprop_preservation_of_hprop_preservation (frame `star` locks_invariant e m0) m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)); (| x, m1 |) let lift_tot_action_with_frame #a #e #fp #fp' ($f:tot_action_with_frame_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in assert (inames_ok e m0); ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); let m0' : hmem_with_inv_except e fp = m0 in let r = f frame m0' in let (| x, m1 |) = r in ac_reasoning_for_m_frame_preserving (fp' x) frame (locks_invariant e m1) m1; assert (interp (fp' x `star` frame `star` locks_invariant e m1) m1); assert (interp (fp' x `star` locks_invariant e m1) m1); let m1' : hmem_with_inv_except e (fp' x) = m1 in NMSTTotal.put #_ #(mem_evolves) m1; x let sel_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.sel_action #a #pcm r v0)) let upd_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.upd_action #a #pcm r v0 v1)) let free_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.free_action #a #pcm r v0)) let split_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.split_action #a #pcm r v0 v1)) let gather_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.gather_action #a #pcm r v0 v1)) let weaken (p q r:slprop) (h:H.hheap (p `star` q) { H.stronger q r }) : H.hheap (p `star` r) = H.weaken p q r h; h let weaken_pure (q r: prop) : Lemma (requires (q ==> r)) (ensures H.stronger (H.pure q) (H.pure r)) = let aux (h:H.heap) : Lemma (ensures (H.interp (H.pure q) h ==> H.interp (H.pure r) h)) [SMTPat ()] = H.pure_interp q h; H.pure_interp r h in () let inc_ctr (#p:slprop) #e (m:hmem_with_inv_except e p) : m':hmem_with_inv_except e p{m'.ctr = m.ctr + 1 /\ H.stronger (linv e m) (linv e m')} = let m' : mem = { m with ctr = m.ctr + 1} in assert (interp (p `star` linv e m) m'); assert (linv e m == lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m)); assert (linv e m' == lock_store_invariant e m.locks `star` ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken_free_above (heap_of_mem m) m.ctr (m.ctr + 1); weaken_pure (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_ctr_valid (m.ctr + 1) (heap_of_mem m)); assert (H.stronger (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m))); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)); H.stronger_star (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken (p `star` lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)) (heap_of_mem m'); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity (m.ctr + 1) (heap_of_mem m)); let m' : hmem_with_inv_except e p = m' in m' let frame_related_mems (fp0 fp1:slprop u#a) e (m0:hmem_with_inv_except e fp0) (m1:hmem_with_inv_except e fp1) = forall (frame:slprop u#a). interp ((fp0 `star` frame) `star` linv e m0) m0 ==> interp ((fp1 `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) let refined_pre_action e (fp0:slprop) (a:Type) (fp1:a -> slprop) = m0:hmem_with_inv_except e fp0 -> Pure (x:a & hmem_with_inv_except e (fp1 x)) (requires True) (ensures fun (| x, m1 |) -> frame_related_mems fp0 (fp1 x) e m0 m1) let refined_pre_action_as_action (#fp0:slprop) (#a:Type) (#fp1:a -> slprop) #e ($f:refined_pre_action e fp0 a fp1) : tot_action_nf_except e fp0 a fp1 = let g : tot_pre_action_nf_except e fp0 a fp1 = fun m -> f m in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp0 `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp1 x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x', m1' |) = g m0 in let (| x, m1 |) = f m0 in assert (x == x' /\ m1 == m1') in g let alloc_action #a #pcm e x = let f : refined_pre_action e emp (ref a pcm) (fun r -> pts_to r x) = fun m0 -> (* NS: 9/29/22 I needed to annotate h : Heap.full_heap, for use with the Core checker which generates a guard for checking the implicit pattern "dot" term in the dependent pair pattern on the next line. That guard expects `h` to be a full_heap, which is it, because it is a projection of m0. However, this is not reflected in `h`'s type. So, the Core checker, which produces a guard for the pat_dot_term in isolation, cannot recheck the term. If we were to fold in the checking of pat_dot_terms and their guards with the rest of the VC, this would work. *) let h : Heap.full_heap = hheap_of_hmem m0 in let (|r, h'|) = H.extend #a #pcm x m0.ctr h in let m' : hmem_with_inv_except e emp = inc_ctr m0 in let h' : H.hheap (pts_to #a #pcm r x `star` linv e m') = weaken _ (linv e m0) (linv e m') h' in let m1 : hmem_with_inv_except e (pts_to #a #pcm r x) = hmem_of_hheap m' h' in assert (forall frame. H.frame_related_heaps h h' emp (pts_to #a #pcm r x) frame true); let aux (frame:slprop) : Lemma (requires interp ((emp `star` frame) `star` linv e m0) m0) (ensures interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) [SMTPat (emp `star` frame)] = star_associative emp frame (linv e m0); assert (H.interp (emp `star` (frame `star` linv e m0)) h); assert (H.interp (pts_to #a #pcm r x `star` (frame `star` linv e m0)) h'); star_associative (pts_to #a #pcm r x) frame (linv e m0); assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m0) h'); assert (H.stronger (linv e m0) (linv e m')); assert (H.equiv (linv e m') (linv e m1)); assert (H.stronger (linv e m0) (linv e m1)); let h' : H.hheap ((pts_to #a #pcm r x `star` frame) `star` linv e m1) = weaken _ (linv e m0) (linv e m1) h' in assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) h'); assert (forall (mp:H.hprop frame). mp h == mp h'); mprop_preservation_of_hprop_preservation frame m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) in assert (frame_related_mems emp (pts_to r x) e m0 m1); (| r, m1 |) in lift_tot_action (refined_pre_action_as_action f) let select_refine #a #p e r x f = lift_tot_action (lift_heap_action e (H.select_refine #a #p r x f)) let upd_gen #a #p e r x y f = lift_tot_action (lift_heap_action e (H.upd_gen_action r x y f)) //////////////////////////////////////////////////////////////////////////////// // witness / recall //////////////////////////////////////////////////////////////////////////////// let witnessed_ref #a #pcm (r:ref a pcm) (fact:property a) (m:full_mem) = H.witnessed_ref #a #pcm r fact (heap_of_mem m) let witnessed_ref_stability #a #pcm (r:ref a pcm) (fact:property a) : Lemma (requires FStar.Preorder.stable fact (Steel.Preorder.preorder_of_pcm pcm)) (ensures FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) = H.witnessed_ref_stability #a #pcm r fact let witnessed (#a:Type u#1) (#pcm:pcm a) (r:ref a pcm) (fact:property a) = W.witnessed _ mem_evolves (witnessed_ref r fact) let rearrange_pqr_prq (p q r:slprop) : Lemma (((p `star` q) `star` r) `equiv` ((p `star` r) `star` q)) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_associative p q r } p `star` (q `star` r); (equiv) { star_commutative q r; star_congruence p (q `star` r) p (r `star` q) } p `star` (r `star` q); (equiv) { star_associative p r q } (p `star` r) `star` q; } let preserves_frame_cong (e:inames) (p q:slprop) (r s:slprop) (m0 m1:mem) : Lemma (requires p `equiv` r /\ q `equiv` s /\ preserves_frame e p q m0 m1) (ensures preserves_frame e r s m0 m1) = let aux0 (p q r s:slprop) : Lemma (requires p `equiv` s) (ensures (((p `star` q) `star` r) `equiv` ((s `star` q) `star` r))) = star_congruence p q s q; star_congruence (p `star` q) r (s `star` q) r in let aux (frame:slprop) : Lemma (requires interp ((r `star` frame) `star` locks_invariant e m0) m0) (ensures interp ((s `star` frame) `star` locks_invariant e m1) m1 /\ interp ((p `star` frame) `star` locks_invariant e m0) m0) [SMTPat (r `star` frame)] = aux0 p frame (locks_invariant e m0) r; aux0 q frame (locks_invariant e m1) s; assert (((p `star` frame) `star` locks_invariant e m0) `equiv` ((r `star` frame) `star` locks_invariant e m0)); assert (interp ((p `star` frame) `star` locks_invariant e m0) m0); assert (interp ((q `star` frame) `star` locks_invariant e m1) m1); assert (((q `star` frame) `star` locks_invariant e m1) `equiv` ((s `star` frame) `star` locks_invariant e m1)); () in () let pure_true_equiv (p:slprop) : Lemma ((p `star` pure True) `equiv` p) = FStar.Classical.forall_intro (pure_star_interp p True); emp_unit p; assert ((p `star` pure True) `equiv` p) let preserves_frame_star_pure (e:inames) (p q:slprop) (r s:prop) (m:mem) : Lemma (requires r /\ s) (ensures preserves_frame e p q m m <==> preserves_frame e (p `star` pure r) (q `star` pure s) m m) = pure_equiv r True; star_congruence p (pure r) p (pure True); pure_equiv s True; star_congruence q (pure s) q (pure True); pure_true_equiv p; pure_true_equiv q; let fwd () : Lemma (requires preserves_frame e p q m m) (ensures preserves_frame e (p `star` pure r) (q `star` pure s) m m) [SMTPat ()] = preserves_frame_cong e p q (p `star` pure r) (q `star` pure s) m m in let bk () : Lemma (requires preserves_frame e (p `star` pure r) (q `star` pure s) m m) (ensures preserves_frame e p q m m) [SMTPat ()] = preserves_frame_cong e (p `star` pure r) (q `star` pure s) p q m m in () let witness (#a:Type) (#pcm:pcm a) (e:inames) (r:erased (ref a pcm)) (fact:stable_property pcm) (v:Ghost.erased a) (_:squash (forall z. compatible pcm v z ==> fact z)) (frame:slprop) : MstTot (witnessed r fact) e (pts_to r v) (fun _ -> pts_to r v) frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in let _ : unit = let hr : H.ref a pcm = r in let v' = H.sel_v hr v (heap_of_mem m0) in assert (interp (H.ptr hr) m0 /\ H.sel #a #pcm hr (heap_of_mem m0) == v'); assert (compatible pcm v v'); assert (fact v'); assert (witnessed_ref r fact m0); witnessed_ref_stability r fact; assert (FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) in let w = NMSTTotal.witness _ mem_evolves (witnessed_ref r fact) in w let recall (#a:Type u#1) (#pcm:pcm a) (#fact:property a) (e:inames) (r:erased (ref a pcm)) (v:Ghost.erased a) (w:witnessed r fact) (frame:slprop) = let m0 = NMSTTotal.get () in NMSTTotal.recall _ mem_evolves (witnessed_ref r fact) w; let hr : H.ref a pcm = r in assert (witnessed_ref r fact m0); let v1 = H.sel_v hr v (heap_of_mem m0) in assert (compatible pcm v v1); assert (H.sel hr (heap_of_mem m0) == v1); assert (fact v1); assert (interp ((pts_to r v `star` frame) `star` locks_invariant e m0) m0); emp_unit ((pts_to r v `star` frame) `star` locks_invariant e m0); pure_star_interp ((pts_to r v `star` frame) `star` locks_invariant e m0) (fact v1) m0; assert (interp (((pts_to r v `star` frame) `star` locks_invariant e m0) `star` pure (fact v1)) m0); rearrange_pqr_prq (pts_to r v `star` frame) (locks_invariant e m0) (pure (fact v1)); assert (interp (((pts_to r v `star` frame) `star` pure (fact v1)) `star` locks_invariant e m0) m0); rearrange_pqr_prq (pts_to r v) frame (pure (fact v1)); star_congruence ((pts_to r v `star` frame) `star` pure (fact v1)) (locks_invariant e m0) ((pts_to r v `star` pure (fact v1)) `star` frame) (locks_invariant e m0); Ghost.hide v1 let iname_for_p_mem (i:iname) (p:slprop) : W.s_predicate mem = fun m -> iname_for_p i p m.locks let iname_for_p_stable (i:iname) (p:slprop) : Lemma (W.stable full_mem mem_evolves (iname_for_p_mem i p)) = () let ( >--> ) (i:iname) (p:slprop) : Type0 = W.witnessed full_mem mem_evolves (iname_for_p_mem i p)

{ "checked_file": "/", "dependencies": [ "Steel.Preorder.fst.checked", "Steel.Heap.fsti.checked", "prims.fst.checked", "FStar.Witnessed.Core.fsti.checked", "FStar.Set.fsti.checked", "FStar.Preorder.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.PCM.fst.checked", "FStar.NMSTTotal.fst.checked", "FStar.List.Tot.fst.checked", "FStar.IndefiniteDescription.fsti.checked", "FStar.Ghost.fsti.checked", "FStar.FunctionalExtensionality.fsti.checked", "FStar.Classical.Sugar.fsti.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Steel.Memory.fst" }

[ { "abbrev": true, "full_module": "Steel.Preorder", "short_module": "PP" }, { "abbrev": true, "full_module": "FStar.Witnessed.Core", "short_module": "W" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": true, "full_module": "Steel.Heap", "short_module": "H" }, { "abbrev": false, "full_module": "FStar.PCM", "short_module": null }, { "abbrev": false, "full_module": "FStar.FunctionalExtensionality", "short_module": null }, { "abbrev": true, "full_module": "FStar.FunctionalExtensionality", "short_module": "F" }, { "abbrev": false, "full_module": "FStar.PCM", "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

e: Steel.Memory.inames -> m: Steel.Memory.mem -> p: Steel.Memory.slprop -> FStar.Pervasives.Lemma (ensures Steel.Memory.interp (Steel.Memory.star p (Steel.Memory.linv e m)) m <==> Steel.Memory.interp (Steel.Memory.star p (Steel.Memory.lock_store_invariant e (Mkmem?.locks m))) m /\ Steel.Memory.heap_ctr_valid (Mkmem?.ctr m) (Steel.Memory.heap_of_mem m))

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Steel.Memory.inames", "Steel.Memory.mem", "Steel.Memory.slprop", "FStar.Calc.calc_finish", "Prims.logical", "Prims.l_iff", "Steel.Memory.interp", "Steel.Memory.star", "Steel.Memory.linv", "Prims.l_and", "Steel.Memory.lock_store_invariant", "Steel.Memory.__proj__Mkmem__item__locks", "Steel.Memory.heap_ctr_valid", "Steel.Memory.__proj__Mkmem__item__ctr", "Steel.Memory.heap_of_mem", "Prims.Cons", "FStar.Preorder.relation", "Prims.Nil", "Prims.unit", "FStar.Calc.calc_step", "Steel.Memory.emp", "Steel.Memory.ctr_validity", "FStar.Calc.calc_init", "FStar.Calc.calc_pack", "Steel.Heap.star_associative", "Prims.squash", "Steel.Heap.pure_star_interp", "Steel.Heap.emp_unit", "Prims.l_True", "FStar.Pervasives.pattern" ]

[]

false

true

false

let hmem_with_inv_equiv e (m: mem) (p: slprop) : Lemma (interp (p `star` (linv e m)) m <==> interp (p `star` (lock_store_invariant e m.locks)) m /\ heap_ctr_valid m.ctr (heap_of_mem m)) =

calc ( <==> ) { interp (p `star` (linv e m)) m; ( <==> ) { H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) } interp ((p `star` (lock_store_invariant e m.locks)) `star` (ctr_validity m.ctr (heap_of_mem m))) m; ( <==> ) { H.pure_star_interp (p `star` (lock_store_invariant e m.locks)) (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_of_mem m) } interp ((p `star` (lock_store_invariant e m.locks)) `star` emp) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); ( <==> ) { H.emp_unit (p `star` (lock_store_invariant e m.locks)) } interp (p `star` (lock_store_invariant e m.locks)) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); }

false

Steel.Memory.fst

Steel.Memory.recall_all

val recall_all (ctx: list pre_inv) : NMSTTotal.NMSTATETOT unit (full_mem u#1) mem_evolves (requires fun _ -> True) (ensures fun m0 _ m1 -> m0 == m1 /\ (forall i. i `List.Tot.memP` ctx ==> name_is_ok (name_of_pre_inv i) m0))

let rec recall_all (ctx:list pre_inv) : NMSTTotal.NMSTATETOT unit (full_mem u#1) mem_evolves (requires fun _ -> True) (ensures fun m0 _ m1 -> m0==m1 /\ (forall i. i `List.Tot.memP` ctx ==> name_is_ok (name_of_pre_inv i) m0)) = match ctx with | [] -> () | hd::tl -> let (| q, i |) = hd in let i : W.witnessed full_mem mem_evolves (name_is_ok q) = i in NMSTTotal.recall _ mem_evolves (name_is_ok q) i; recall_all tl

{ "file_name": "lib/steel/Steel.Memory.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 19, "end_line": 1271, "start_col": 0, "start_line": 1261 }

(* 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.Memory module F = FStar.FunctionalExtensionality open FStar.FunctionalExtensionality open FStar.PCM module H = Steel.Heap noeq type lock_state : Type u#(a + 1) = | Invariant : inv:H.slprop u#a -> lock_state let lock_store : Type u#(a+1) = list (lock_state u#a) noeq type mem : Type u#(a + 1) = { ctr: nat; heap: H.heap u#a; locks: lock_store u#a; } let heap_of_mem (x:mem) : H.heap = x.heap let mem_of_heap (h:H.heap) : mem = { ctr = 0; heap = h; locks = [] } let mem_set_heap (m:mem) (h:H.heap) : mem = { ctr = m.ctr; heap = h; locks = m.locks; } let core_mem (m:mem) : mem = mem_of_heap (heap_of_mem m) let core_mem_invol m = () let disjoint (m0 m1:mem u#h) : prop = m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks let disjoint_sym m0 m1 = () let join m0 m1 = { ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = m0.locks } let join_commutative m0 m1 = H.join_commutative m0.heap m1.heap let disjoint_join m0 m1 m2 = H.disjoint_join m0.heap m1.heap m2.heap let join_associative m0 m1 m2 = H.join_associative m0.heap m1.heap m2.heap let slprop = H.slprop let interp p m = H.interp p m.heap let equiv p1 p2 = forall m. interp p1 m <==> interp p2 m let slprop_extensionality p q = assert (forall m. interp p m <==> interp q m); let aux (h:H.heap) : Lemma (H.interp p h <==> H.interp q h) [SMTPat (H.interp p h)] = let m : mem = { ctr = 0; heap = h; locks = [] } in assert (interp p m <==> interp q m) in assert (forall h. H.interp p h <==> H.interp q h); Steel.Heap.slprop_extensionality p q let reveal_equiv p1 p2 = () let core_ref = H.core_ref let core_ref_null = H.core_ref_null let core_ref_is_null r = H.core_ref_is_null r let emp : slprop u#a = H.emp let pure = H.pure let pts_to = H.pts_to let h_and = H.h_and let h_or = H.h_or let star = H.star let wand = H.wand let h_exists = H.h_exists let h_forall = H.h_forall //////////////////////////////////////////////////////////////////////////////// //properties of equiv //////////////////////////////////////////////////////////////////////////////// let equiv_symmetric (p1 p2:slprop u#a) = H.equiv_symmetric p1 p2 #push-options "--warn_error -271" let equiv_heap_iff_equiv (p1 p2:slprop u#a) : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat (equiv p1 p2)] = let aux_lr () : Lemma (requires H.equiv p1 p2) (ensures equiv p1 p2) [SMTPat ()] = () in let aux_rl_helper1 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p1 h) (ensures H.interp p2 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl_helper2 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p2 h) (ensures H.interp p1 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl () : Lemma (requires equiv p1 p2) (ensures H.equiv p1 p2) [SMTPat ()] = () in () let equiv_heap_iff_equiv_forall () : Lemma (ensures (forall p1 p2. H.equiv p1 p2 <==> equiv p1 p2)) = let aux p1 p2 : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat ()] = equiv_heap_iff_equiv p1 p2 in () #pop-options let equiv_extensional_on_star (p1 p2 p3:slprop u#a) = equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3 let emp_unit p = H.emp_unit p let intro_emp m = H.intro_emp (heap_of_mem m) let pure_equiv p q = H.pure_equiv p q let pure_interp q m = H.pure_interp q (heap_of_mem m) let pure_star_interp p q m = H.pure_star_interp p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// //pts_to //////////////////////////////////////////////////////////////////////////////// let pts_to_compatible #a #pcm x v0 v1 m = H.pts_to_compatible #a #pcm x v0 v1 (heap_of_mem m) let pts_to_compatible_equiv #a #pcm x v0 v1 = H.pts_to_compatible_equiv #a #pcm x v0 v1 let pts_to_not_null #a #pcm x v m = H.pts_to_not_null #a #pcm x v (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // star //////////////////////////////////////////////////////////////////////////////// let intro_star p q mp mq = H.intro_star p q (heap_of_mem mp) (heap_of_mem mq) let elim_star p q m = let h = heap_of_mem m in H.elim_star p q h; assert (exists hl hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr); let hl = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hl -> exists hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let hr = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hr -> H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let ml = mem_set_heap m hl in let mr = mem_set_heap m hr in assert (disjoint ml mr); assert (m == join ml mr); assert (interp p ml); assert (interp q mr); () let interp_star (p q: slprop) (m: mem) : Lemma (interp (p `star` q) m <==> (exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m)) = let left = interp (p `star` q) m in let right = exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m in let f () : Lemma (requires left) (ensures right) = elim_star p q m in let g () : Lemma (requires right) (ensures left) = Classical.exists_elim left #_ #(fun mp -> exists (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mp -> Classical.exists_elim left #_ #(fun mq -> disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mq -> intro_star p q mp mq ) ) in Classical.move_requires f (); Classical.move_requires g () let star_commutative (p1 p2:slprop) = H.star_commutative p1 p2 let star_associative (p1 p2 p3:slprop) = H.star_associative p1 p2 p3 let star_congruence (p1 p2 p3 p4:slprop) = equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4 let affine_star (p q:slprop) (m:mem) = H.affine_star p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // Invariants on the lock store //////////////////////////////////////////////////////////////////////////////// let iname = nat module S = FStar.Set module L = FStar.List.Tot module W = FStar.Witnessed.Core let rec lock_store_invariant (e:inames) (l:lock_store u#a) : slprop u#a = let current_addr = L.length l - 1 in match l with | [] -> emp | Invariant p :: tl -> if current_addr `S.mem` e then lock_store_invariant e tl else p `star` lock_store_invariant e tl let lock_i (i:iname) (l:lock_store { i < L.length l }) = let ix = L.length l - i - 1 in L.index l ix let iname_for_p (i:iname) (p:slprop) : W.s_predicate lock_store = fun l -> i < L.length l /\ (lock_i i l).inv == p let lock_store_evolves : FStar.Preorder.preorder lock_store = fun (l1 l2 : lock_store) -> L.length l2 >= L.length l1 /\ (forall (i:nat{i < L.length l1}). (lock_i i l1).inv == (lock_i i l2).inv) let inames_in (e:inames) (l:lock_store) : prop = forall i. Set.mem i e ==> i < L.length l let inames_ok e m = inames_in e m.locks let inames_ok_empty m = () let extend_lock_store (e:inames) (l:lock_store{e `inames_in` l}) (p:slprop) : i:iname & l':lock_store { lock_store_invariant e l' == p `star` lock_store_invariant e l /\ iname_for_p i p l' } = (| L.length l, Invariant p :: l |) let set_add (i:iname) (s:inames) = Set.union (Set.singleton i) s let rec move_invariant (e:inames) (l:lock_store) (p:slprop) (i:iname{iname_for_p i p l /\ ~(i `Set.mem` e)}) : Lemma (H.equiv (lock_store_invariant e l) (p `star` lock_store_invariant (set_add i e) l)) = let rec aux (i:iname) (m:lock_store) : Lemma (requires i >= L.length m) (ensures (lock_store_invariant e m `H.equiv` lock_store_invariant (set_add i e) m)) = match m with | [] -> () | Invariant p::tl -> aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl) in let current_addr = L.length l - 1 in match l with | [] -> () | Invariant q::tl -> if i = current_addr then begin assert (lock_store_invariant e l == p `star` lock_store_invariant e tl); aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl); () end else begin move_invariant e tl p i; assert (lock_store_invariant e tl `equiv` (p `star` lock_store_invariant (set_add i e) tl)); H.star_congruence q (lock_store_invariant e tl) q (p `star` lock_store_invariant (set_add i e) tl); if Set.mem current_addr e then () else begin let r = lock_store_invariant (set_add i e) tl in assert (lock_store_invariant e l `equiv` (q `star` (p `star` r))); H.star_associative q p r; H.star_commutative q p; H.star_congruence (q `star` p) r (p `star` q) r; H.star_associative p q r end end let heap_ctr_valid (ctr:nat) (h:H.heap u#a) : prop = h `H.free_above_addr` ctr let ctr_validity (ctr:nat) (h:H.heap) : slprop = H.pure (heap_ctr_valid ctr h) let locks_invariant (e:inames) (m:mem u#a) : slprop u#a = lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m) let full_mem_pred (m:mem) = H.full_heap_pred (heap_of_mem m) (***** Following lemmas are needed in Steel.Effect *****) let core_mem_interp (hp:slprop u#a) (m:mem u#a) = () let interp_depends_only_on (hp:slprop u#a) = H.interp_depends_only_on hp let a_mem_prop_as_a_heap_prop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (H.a_heap_prop u#a) = let g (h: H.heap u#a) : Tot prop = interp sl (mem_of_heap h) /\ f (mem_of_heap h) in let phi0 (h0 h1: H.heap u#a) : Lemma (requires (g h0 /\ H.disjoint h0 h1)) (ensures (g h0 /\ H.disjoint h0 h1 /\ g (H.join h0 h1))) = assert (mem_of_heap (H.join h0 h1) == mem_of_heap h0 `join` mem_of_heap h1); interp_depends_only_on sl in let phi1 (h0 h1: H.heap u#a) : Lemma (ensures ((g h0 /\ H.disjoint h0 h1) ==> g (H.join h0 h1))) = Classical.move_requires (phi0 h0) h1 in Classical.forall_intro_2 phi1; g let refine_slprop sl f = H.as_slprop (a_mem_prop_as_a_heap_prop sl f) let interp_refine_slprop sl f m = assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_mem m)) let dep_hprop (s: slprop) (f: (hmem s -> Tot slprop)) (h: H.heap) : Tot prop = exists (h1: H.heap) . exists (h2: H.heap) . interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 let dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq' : squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h')) = let p2 (h h1 h2: H.heap) : Tot prop = interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 in let p1 (h h1: H.heap) : Tot prop = (exists h2 . p2 h h1 h2) in let h1 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p1 h) in let h2 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p2 h h1) in H.disjoint_join h' h1 h2; assert (H.disjoint h2 h'); let h2' = H.join h2 h' in H.join_commutative h2 h' ; assert (h2' == H.join h' h2); assert (H.disjoint h1 h2'); assert (mem_of_heap h2' == mem_of_heap h2 `join` mem_of_heap h'); interp_depends_only_on (f (mem_of_heap h1)); assert (interp (f (mem_of_heap h1)) (mem_of_heap h2')); H.join_commutative h1 h2; H.join_associative h' h2 h1; H.join_commutative h' h; H.join_commutative h2' h1; assert (H.join h h' == h1 `H.join` h2') let impl_intro_gen (#p: Type0) (#q: Type0) ($prf: (squash p -> Lemma (q ))) : Lemma (p ==> q) = Classical.impl_intro_gen #p #(fun _ -> q) prf let dep_hprop_is_affine1 (s: slprop) (f: (hmem s -> Tot slprop)) (h0 h1: H.heap) : Lemma ((dep_hprop s f h0 /\ H.disjoint h0 h1) ==> (H.disjoint h0 h1 /\ dep_hprop s f (H.join h0 h1))) = impl_intro_gen (dep_hprop_is_affine0 s f h0 h1) let dep_hprop_is_affine (s: slprop) (f: (hmem s -> Tot slprop)) : Lemma (H.heap_prop_is_affine (dep_hprop s f)) = Classical.forall_intro_2 (dep_hprop_is_affine1 s f) let sdep (s: slprop) (f: (hmem s -> Tot slprop)) : Tot slprop = dep_hprop_is_affine s f; H.as_slprop (dep_hprop s f) let interp_sdep (s: slprop) (f: (hmem s -> Tot slprop)) (m: mem) : Lemma (requires (dep_slprop_is_affine s f)) (ensures ( interp (sdep s f) m <==> (exists m1 m2 . interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) )) = dep_hprop_is_affine s f; assert (forall m1 m2 . (interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) ==> ( interp s (mem_of_heap m1.heap) /\ interp (f (mem_of_heap m1.heap)) (mem_of_heap m2.heap) /\ H.disjoint m1.heap m2.heap /\ H.join m1.heap m2.heap == m.heap )); interp_depends_only_on s; Classical.forall_intro (fun m -> interp_depends_only_on (f m)); assert (forall h1 h2 . (interp s (mem_of_heap h1) /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ H.disjoint h1 h2 /\ H.join h1 h2 == m.heap) ==> ( core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ interp s (core_mem (mem_of_heap h1)) /\ interp s (mem_set_heap m h1) /\ core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ f (mem_set_heap m h1) `equiv` f (mem_of_heap h1) /\ interp (f (mem_set_heap m h1)) (mem_of_heap h2) /\ interp (f (mem_set_heap m h1)) (mem_set_heap m h2) /\ disjoint (mem_set_heap m h1) (mem_set_heap m h2) /\ join (mem_set_heap m h1) (mem_set_heap m h2) == m )); () let h_exists_cong (#a:Type) (p q : a -> slprop) : Lemma (requires (forall x. p x `equiv` q x)) (ensures (h_exists p `equiv` h_exists q)) = equiv_heap_iff_equiv_forall (); H.h_exists_cong p q let intro_h_exists #a x p m = H.intro_h_exists x p (heap_of_mem m) let elim_h_exists (#a:_) (p:a -> slprop) (m:mem) = H.elim_h_exists p (heap_of_mem m) let intro_h_forall (#a:_) (p:a -> slprop) (m:mem) = H.intro_h_forall p (heap_of_mem m) let elim_h_forall (#a:_) (p:a -> slprop) (m:mem) (x:a) = H.elim_h_forall p (heap_of_mem m) x let intro_h_and (p q: slprop) (m:mem) = H.intro_h_and p q (heap_of_mem m) let elim_h_and (p q: slprop) (m:mem) = H.elim_h_and p q (heap_of_mem m) let intro_h_or_left (p q: slprop) (m:mem) = H.intro_h_or_left p q (heap_of_mem m) let intro_h_or_right (p q: slprop) (m:mem) = H.intro_h_or_right p q (heap_of_mem m) let elim_h_or (p q: slprop) (m:mem) = H.elim_h_or p q (heap_of_mem m) let intro_wand (p1 p2: slprop u#a) (m:mem) = introduce (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)) ==> interp (wand p1 p2) m with _. ( assert (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)); H.intro_wand p1 p2 (heap_of_mem m); let h = heap_of_mem m in assert ((forall h1. h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) ==> H.interp (wand p1 p2) h); introduce forall h1. (h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) with ( introduce (h `H.disjoint` h1 /\ H.interp p1 h1) ==> H.interp p2 (H.join h h1) with _. ( assert (h `H.disjoint` h1); let m1 = { ctr = m.ctr; heap = h1; locks = m.locks } in assert (m `disjoint` m1) ) ) ) (** Eliminating a wand by proving a heap that satisfies the LHS **) let elim_wand (p1 p2: slprop u#a) (m:mem) (m1:mem) = H.elim_wand p1 p2 (heap_of_mem m) (heap_of_mem m1) //////////////////////////////////////////////////////////////////////////////// // Preorders and effects //////////////////////////////////////////////////////////////////////////////// module PP = Steel.Preorder let mem_evolves = fun (m0 m1:full_mem) -> H.heap_evolves (heap_of_mem m0) (heap_of_mem m1) /\ m0.ctr <= m1.ctr /\ lock_store_evolves m0.locks m1.locks (** See [Steel.Heap.is_frame_preserving]. We add in [lock_invariants] now *) let preserves_frame (e:inames) (pre post:slprop) (m0 m1:mem) = forall (frame:slprop). interp ((pre `star` frame) `star` locks_invariant e m0) m0 ==> (interp ((post `star` frame) `star` locks_invariant e m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) (** This is a version of MstTot with frame quantified, as part of preserves_frame *) effect MstTotNF (a:Type u#a) (except:inames) (expects:slprop u#1) (provides: a -> slprop u#1) = NMSTTotal.NMSTATETOT a (full_mem u#1) mem_evolves (requires fun m0 -> inames_ok except m0 /\ interp (expects `star` locks_invariant except m0) m0) (ensures fun m0 x m1 -> inames_ok except m1 /\ interp (provides x `star` locks_invariant except m1) m1 /\ preserves_frame except expects (provides x) m0 m1) //////////////////////////////////////////////////////////////////////////////// // Lifting heap actions //////////////////////////////////////////////////////////////////////////////// (** Heap actions come in two equivalent flavors: - one that take an explicit frame as argument (action_with_frame) - and one that quantify over all the frame We therefore define two lift routes: - a direct route for those with explicit frame - via MstTotNF for the rest *) let tot_pre_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = hmem_with_inv_except e fp -> (x:a & hmem_with_inv_except e (fp' x)) let tot_pre_action_nf = tot_pre_action_nf_except S.empty let ac_reasoning_for_m_frame_preserving (p q r:slprop u#a) (m:mem u#a) : Lemma (requires interp ((p `star` q) `star` r) m) (ensures interp (p `star` r) m) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_commutative p q; equiv_extensional_on_star (p `star` q) (q `star` p) r } (q `star` p) `star` r; (equiv) { star_associative q p r } q `star` (p `star` r); }; assert (interp (q `star` (p `star` r)) m); affine_star q (p `star` r) m let is_frame_preserving (#e:inames) (#a:Type u#b) (#fp:slprop u#a) (#fp':a -> slprop u#a) (f:tot_pre_action_nf_except e fp a fp') = forall (frame:slprop u#a) (m0:hmem_with_inv_except e (fp `star` frame)). (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = f:tot_pre_action_nf_except e fp a fp'{ is_frame_preserving f } let tot_action_nf = tot_action_nf_except S.empty let linv e (m:mem) = locks_invariant e m let hheap_of_hmem #fp #e (m:hmem_with_inv_except e fp) : h:H.hheap (fp `star` linv e m) { h `H.free_above_addr` m.ctr} = let h = heap_of_mem m in H.pure_interp (heap_ctr_valid m.ctr (heap_of_mem m)) h; h let hmem_of_hheap #e (#fp0 #fp1:slprop) (m:hmem_with_inv_except e fp0) (h:H.full_hheap (fp1 `star` linv e m) { h `Heap.free_above_addr` m.ctr }) : m1:hmem_with_inv_except e fp1{linv e m `equiv` linv e m1} = let m1 : mem = { m with heap = h } in assert (interp (fp1 `star` linv e m) m1); star_commutative fp1 (linv e m); assert (interp (linv e m `star` fp1) m1); assert (linv e m1 == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); assert (linv e m == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m)); H.pure_interp (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_of_mem m); assert (heap_ctr_valid m1.ctr (heap_of_mem m) <==> heap_ctr_valid m1.ctr (heap_of_mem m1)); H.pure_equiv (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_ctr_valid m1.ctr (heap_of_mem m1)); H.star_congruence (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m)); assert (linv e m `equiv` linv e m1); let _ = equiv_extensional_on_star (linv e m) (linv e m1) fp1 in assert ((linv e m `star` fp1) `equiv` (linv e m1 `star` fp1)); assert (interp (linv e m1 `star` fp1) m1); star_commutative (linv e m1) fp1; assert (interp (fp1 `star` linv e m1) m1); m1 let with_inv_except (m:mem) e (fp:slprop) = interp (fp `star` locks_invariant e m) m #push-options "--warn_error -271" let as_hprop (frame:slprop) (mp:mprop frame) : hp:H.hprop frame{forall m. mp (core_mem m) == hp (heap_of_mem m)} = let f = fun h -> mp (mem_of_heap h) in assert (forall m. mp (core_mem m) == f (heap_of_mem m)); let aux (m0:H.hheap frame) (m1:H.heap{H.disjoint m0 m1}) : Lemma (ensures (mem_of_heap (H.join m0 m1) == join (mem_of_heap m0) (mem_of_heap m1))) [SMTPat ()] = () in f let mprop_preservation_of_hprop_preservation (p:slprop) (m0 m1:mem) : Lemma (requires (forall (hp:H.hprop p). hp (heap_of_mem m0) == hp (heap_of_mem m1))) (ensures (forall (mp:mprop p). mp (core_mem m0) == mp (core_mem m1))) = let aux (mp:mprop p) : Lemma (mp (core_mem m0) == mp (core_mem m1)) [SMTPat()] = assert (as_hprop p mp (heap_of_mem m0) == as_hprop p mp (heap_of_mem m1)) in () let lift_heap_action (#fp:slprop) (#a:Type) (#fp':a -> slprop) (e:inames) ($f:H.action fp a fp') : tot_action_nf_except e fp a fp' = let g : tot_pre_action_nf_except e fp a fp' = fun m -> let h0 = hheap_of_hmem m in let (| x, h' |) = f h0 in (| x, hmem_of_hheap m h' |) in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in let h0 = hheap_of_hmem m0 in let (| x', h1 |) = f h0 in H.action_framing f (linv e m0) h0; assert (x == x'); star_associative fp frame (linv e m0); H.action_framing f (frame `star` linv e m0) h0; assert (H.interp ((fp' x) `star` (frame `star` linv e m0)) h1); star_associative (fp' x) frame (linv e m0); assert (H.interp ((fp' x `star` frame) `star` linv e m0) h1); let h1' : H.hheap ((fp' x `star` frame) `star` linv e m0) = h1 in assert (m1 == hmem_of_hheap m0 h1'); assert (with_inv_except m1 e (fp' x `star` frame)); assert (forall (hp:H.hprop frame). hp h0 == hp h1); mprop_preservation_of_hprop_preservation frame m0 m1; () in assert (is_frame_preserving g); g let frame_preserving_respects_preorder #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (m0:hmem_with_inv_except e fp) : Lemma (let (| x, m1 |) = f m0 in mem_evolves m0 m1) = let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1) = () in H.emp_unit fp; assert (interp (fp `star` linv e m0) m0); H.star_congruence (fp `star` emp) (linv e m0) fp (linv e m0); assert (interp ((fp `star` emp) `star` linv e m0) m0); aux emp m0 let lift_tot_action_nf #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') : MstTotNF a e fp fp' = let m0 = NMSTTotal.get () in let m0' : hmem_with_inv_except e fp = m0 in let r = f m0' in let (| x, m1 |) = r in let m1' : hmem_with_inv_except e (fp' x) = m1 in assert (is_frame_preserving f); assert (m1 == dsnd (f m0)); frame_preserving_respects_preorder f m0; NMSTTotal.put #_ #(mem_evolves) m1; x let lift_tot_action #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get #(full_mem) #_ () in ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); lift_tot_action_nf f (** Now defining the lift for heap actions with explicit frame *) let tot_action_with_frame_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = frame:slprop u#a -> m0:hmem_with_inv_except e (fp `star` frame) -> Pure (x:a & hmem_with_inv_except e (fp' x `star` frame)) (requires True) (ensures fun (| x, m1 |) -> mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_with_frame = tot_action_with_frame_except S.empty let lift_heap_action_with_frame (#fp:slprop u#a) (#a:Type u#b) (#fp':a -> slprop u#a) (e:inames) ($f:H.action_with_frame fp a fp') : tot_action_with_frame_except e fp a fp' = fun frame m0 -> let h0 = hheap_of_hmem m0 in calc (equiv) { fp `star` frame `star` locks_invariant e m0; (equiv) { star_associative fp frame (locks_invariant e m0) } fp `star` (frame `star` locks_invariant e m0); }; assert (H.interp (fp `star` frame `star` locks_invariant e m0) h0); assert (H.interp (fp `star` (frame `star` locks_invariant e m0)) h0); //key: apply the heap action with frame * locks_invariant e m0 let (| x, h1 |) = f (frame `star` locks_invariant e m0) h0 in calc (equiv) { fp' x `star` (frame `star` locks_invariant e m0); (equiv) { star_associative (fp' x) frame (locks_invariant e m0) } fp' x `star` frame `star` locks_invariant e m0; }; assert (H.interp (fp' x `star` (frame `star` locks_invariant e m0)) h1); assert (H.interp (fp' x `star` frame `star` locks_invariant e m0) h1); let m1 = hmem_of_hheap m0 h1 in assert (mem_evolves m0 m1); mprop_preservation_of_hprop_preservation (frame `star` locks_invariant e m0) m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)); (| x, m1 |) let lift_tot_action_with_frame #a #e #fp #fp' ($f:tot_action_with_frame_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in assert (inames_ok e m0); ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); let m0' : hmem_with_inv_except e fp = m0 in let r = f frame m0' in let (| x, m1 |) = r in ac_reasoning_for_m_frame_preserving (fp' x) frame (locks_invariant e m1) m1; assert (interp (fp' x `star` frame `star` locks_invariant e m1) m1); assert (interp (fp' x `star` locks_invariant e m1) m1); let m1' : hmem_with_inv_except e (fp' x) = m1 in NMSTTotal.put #_ #(mem_evolves) m1; x let sel_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.sel_action #a #pcm r v0)) let upd_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.upd_action #a #pcm r v0 v1)) let free_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.free_action #a #pcm r v0)) let split_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.split_action #a #pcm r v0 v1)) let gather_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.gather_action #a #pcm r v0 v1)) let weaken (p q r:slprop) (h:H.hheap (p `star` q) { H.stronger q r }) : H.hheap (p `star` r) = H.weaken p q r h; h let weaken_pure (q r: prop) : Lemma (requires (q ==> r)) (ensures H.stronger (H.pure q) (H.pure r)) = let aux (h:H.heap) : Lemma (ensures (H.interp (H.pure q) h ==> H.interp (H.pure r) h)) [SMTPat ()] = H.pure_interp q h; H.pure_interp r h in () let inc_ctr (#p:slprop) #e (m:hmem_with_inv_except e p) : m':hmem_with_inv_except e p{m'.ctr = m.ctr + 1 /\ H.stronger (linv e m) (linv e m')} = let m' : mem = { m with ctr = m.ctr + 1} in assert (interp (p `star` linv e m) m'); assert (linv e m == lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m)); assert (linv e m' == lock_store_invariant e m.locks `star` ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken_free_above (heap_of_mem m) m.ctr (m.ctr + 1); weaken_pure (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_ctr_valid (m.ctr + 1) (heap_of_mem m)); assert (H.stronger (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m))); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)); H.stronger_star (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken (p `star` lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)) (heap_of_mem m'); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity (m.ctr + 1) (heap_of_mem m)); let m' : hmem_with_inv_except e p = m' in m' let frame_related_mems (fp0 fp1:slprop u#a) e (m0:hmem_with_inv_except e fp0) (m1:hmem_with_inv_except e fp1) = forall (frame:slprop u#a). interp ((fp0 `star` frame) `star` linv e m0) m0 ==> interp ((fp1 `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) let refined_pre_action e (fp0:slprop) (a:Type) (fp1:a -> slprop) = m0:hmem_with_inv_except e fp0 -> Pure (x:a & hmem_with_inv_except e (fp1 x)) (requires True) (ensures fun (| x, m1 |) -> frame_related_mems fp0 (fp1 x) e m0 m1) let refined_pre_action_as_action (#fp0:slprop) (#a:Type) (#fp1:a -> slprop) #e ($f:refined_pre_action e fp0 a fp1) : tot_action_nf_except e fp0 a fp1 = let g : tot_pre_action_nf_except e fp0 a fp1 = fun m -> f m in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp0 `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp1 x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x', m1' |) = g m0 in let (| x, m1 |) = f m0 in assert (x == x' /\ m1 == m1') in g let alloc_action #a #pcm e x = let f : refined_pre_action e emp (ref a pcm) (fun r -> pts_to r x) = fun m0 -> (* NS: 9/29/22 I needed to annotate h : Heap.full_heap, for use with the Core checker which generates a guard for checking the implicit pattern "dot" term in the dependent pair pattern on the next line. That guard expects `h` to be a full_heap, which is it, because it is a projection of m0. However, this is not reflected in `h`'s type. So, the Core checker, which produces a guard for the pat_dot_term in isolation, cannot recheck the term. If we were to fold in the checking of pat_dot_terms and their guards with the rest of the VC, this would work. *) let h : Heap.full_heap = hheap_of_hmem m0 in let (|r, h'|) = H.extend #a #pcm x m0.ctr h in let m' : hmem_with_inv_except e emp = inc_ctr m0 in let h' : H.hheap (pts_to #a #pcm r x `star` linv e m') = weaken _ (linv e m0) (linv e m') h' in let m1 : hmem_with_inv_except e (pts_to #a #pcm r x) = hmem_of_hheap m' h' in assert (forall frame. H.frame_related_heaps h h' emp (pts_to #a #pcm r x) frame true); let aux (frame:slprop) : Lemma (requires interp ((emp `star` frame) `star` linv e m0) m0) (ensures interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) [SMTPat (emp `star` frame)] = star_associative emp frame (linv e m0); assert (H.interp (emp `star` (frame `star` linv e m0)) h); assert (H.interp (pts_to #a #pcm r x `star` (frame `star` linv e m0)) h'); star_associative (pts_to #a #pcm r x) frame (linv e m0); assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m0) h'); assert (H.stronger (linv e m0) (linv e m')); assert (H.equiv (linv e m') (linv e m1)); assert (H.stronger (linv e m0) (linv e m1)); let h' : H.hheap ((pts_to #a #pcm r x `star` frame) `star` linv e m1) = weaken _ (linv e m0) (linv e m1) h' in assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) h'); assert (forall (mp:H.hprop frame). mp h == mp h'); mprop_preservation_of_hprop_preservation frame m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) in assert (frame_related_mems emp (pts_to r x) e m0 m1); (| r, m1 |) in lift_tot_action (refined_pre_action_as_action f) let select_refine #a #p e r x f = lift_tot_action (lift_heap_action e (H.select_refine #a #p r x f)) let upd_gen #a #p e r x y f = lift_tot_action (lift_heap_action e (H.upd_gen_action r x y f)) //////////////////////////////////////////////////////////////////////////////// // witness / recall //////////////////////////////////////////////////////////////////////////////// let witnessed_ref #a #pcm (r:ref a pcm) (fact:property a) (m:full_mem) = H.witnessed_ref #a #pcm r fact (heap_of_mem m) let witnessed_ref_stability #a #pcm (r:ref a pcm) (fact:property a) : Lemma (requires FStar.Preorder.stable fact (Steel.Preorder.preorder_of_pcm pcm)) (ensures FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) = H.witnessed_ref_stability #a #pcm r fact let witnessed (#a:Type u#1) (#pcm:pcm a) (r:ref a pcm) (fact:property a) = W.witnessed _ mem_evolves (witnessed_ref r fact) let rearrange_pqr_prq (p q r:slprop) : Lemma (((p `star` q) `star` r) `equiv` ((p `star` r) `star` q)) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_associative p q r } p `star` (q `star` r); (equiv) { star_commutative q r; star_congruence p (q `star` r) p (r `star` q) } p `star` (r `star` q); (equiv) { star_associative p r q } (p `star` r) `star` q; } let preserves_frame_cong (e:inames) (p q:slprop) (r s:slprop) (m0 m1:mem) : Lemma (requires p `equiv` r /\ q `equiv` s /\ preserves_frame e p q m0 m1) (ensures preserves_frame e r s m0 m1) = let aux0 (p q r s:slprop) : Lemma (requires p `equiv` s) (ensures (((p `star` q) `star` r) `equiv` ((s `star` q) `star` r))) = star_congruence p q s q; star_congruence (p `star` q) r (s `star` q) r in let aux (frame:slprop) : Lemma (requires interp ((r `star` frame) `star` locks_invariant e m0) m0) (ensures interp ((s `star` frame) `star` locks_invariant e m1) m1 /\ interp ((p `star` frame) `star` locks_invariant e m0) m0) [SMTPat (r `star` frame)] = aux0 p frame (locks_invariant e m0) r; aux0 q frame (locks_invariant e m1) s; assert (((p `star` frame) `star` locks_invariant e m0) `equiv` ((r `star` frame) `star` locks_invariant e m0)); assert (interp ((p `star` frame) `star` locks_invariant e m0) m0); assert (interp ((q `star` frame) `star` locks_invariant e m1) m1); assert (((q `star` frame) `star` locks_invariant e m1) `equiv` ((s `star` frame) `star` locks_invariant e m1)); () in () let pure_true_equiv (p:slprop) : Lemma ((p `star` pure True) `equiv` p) = FStar.Classical.forall_intro (pure_star_interp p True); emp_unit p; assert ((p `star` pure True) `equiv` p) let preserves_frame_star_pure (e:inames) (p q:slprop) (r s:prop) (m:mem) : Lemma (requires r /\ s) (ensures preserves_frame e p q m m <==> preserves_frame e (p `star` pure r) (q `star` pure s) m m) = pure_equiv r True; star_congruence p (pure r) p (pure True); pure_equiv s True; star_congruence q (pure s) q (pure True); pure_true_equiv p; pure_true_equiv q; let fwd () : Lemma (requires preserves_frame e p q m m) (ensures preserves_frame e (p `star` pure r) (q `star` pure s) m m) [SMTPat ()] = preserves_frame_cong e p q (p `star` pure r) (q `star` pure s) m m in let bk () : Lemma (requires preserves_frame e (p `star` pure r) (q `star` pure s) m m) (ensures preserves_frame e p q m m) [SMTPat ()] = preserves_frame_cong e (p `star` pure r) (q `star` pure s) p q m m in () let witness (#a:Type) (#pcm:pcm a) (e:inames) (r:erased (ref a pcm)) (fact:stable_property pcm) (v:Ghost.erased a) (_:squash (forall z. compatible pcm v z ==> fact z)) (frame:slprop) : MstTot (witnessed r fact) e (pts_to r v) (fun _ -> pts_to r v) frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in let _ : unit = let hr : H.ref a pcm = r in let v' = H.sel_v hr v (heap_of_mem m0) in assert (interp (H.ptr hr) m0 /\ H.sel #a #pcm hr (heap_of_mem m0) == v'); assert (compatible pcm v v'); assert (fact v'); assert (witnessed_ref r fact m0); witnessed_ref_stability r fact; assert (FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) in let w = NMSTTotal.witness _ mem_evolves (witnessed_ref r fact) in w let recall (#a:Type u#1) (#pcm:pcm a) (#fact:property a) (e:inames) (r:erased (ref a pcm)) (v:Ghost.erased a) (w:witnessed r fact) (frame:slprop) = let m0 = NMSTTotal.get () in NMSTTotal.recall _ mem_evolves (witnessed_ref r fact) w; let hr : H.ref a pcm = r in assert (witnessed_ref r fact m0); let v1 = H.sel_v hr v (heap_of_mem m0) in assert (compatible pcm v v1); assert (H.sel hr (heap_of_mem m0) == v1); assert (fact v1); assert (interp ((pts_to r v `star` frame) `star` locks_invariant e m0) m0); emp_unit ((pts_to r v `star` frame) `star` locks_invariant e m0); pure_star_interp ((pts_to r v `star` frame) `star` locks_invariant e m0) (fact v1) m0; assert (interp (((pts_to r v `star` frame) `star` locks_invariant e m0) `star` pure (fact v1)) m0); rearrange_pqr_prq (pts_to r v `star` frame) (locks_invariant e m0) (pure (fact v1)); assert (interp (((pts_to r v `star` frame) `star` pure (fact v1)) `star` locks_invariant e m0) m0); rearrange_pqr_prq (pts_to r v) frame (pure (fact v1)); star_congruence ((pts_to r v `star` frame) `star` pure (fact v1)) (locks_invariant e m0) ((pts_to r v `star` pure (fact v1)) `star` frame) (locks_invariant e m0); Ghost.hide v1 let iname_for_p_mem (i:iname) (p:slprop) : W.s_predicate mem = fun m -> iname_for_p i p m.locks let iname_for_p_stable (i:iname) (p:slprop) : Lemma (W.stable full_mem mem_evolves (iname_for_p_mem i p)) = () let ( >--> ) (i:iname) (p:slprop) : Type0 = W.witnessed full_mem mem_evolves (iname_for_p_mem i p) let hmem_with_inv_equiv e (m:mem) (p:slprop) : Lemma (interp (p `star` linv e m) m <==> interp (p `star` lock_store_invariant e m.locks) m /\ heap_ctr_valid m.ctr (heap_of_mem m)) = calc (<==>) { interp (p `star` linv e m) m; (<==>) { H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) } interp ((p `star` lock_store_invariant e m.locks) `star` ctr_validity m.ctr (heap_of_mem m)) m; (<==>) { H.pure_star_interp (p `star` lock_store_invariant e m.locks) (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_of_mem m) } interp ((p `star` lock_store_invariant e m.locks) `star` emp) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); (<==>) { H.emp_unit (p `star` lock_store_invariant e m.locks) } interp (p `star` lock_store_invariant e m.locks) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); } let new_invariant_tot_action (e:inames) (p:slprop) (m0:hmem_with_inv_except e p{ e `inames_in` m0.locks }) : Pure (iname & hmem_with_inv_except e emp) (requires True) (ensures fun (i, m1) -> iname_for_p_mem i p m1 /\ frame_related_mems p emp e m0 m1 /\ mem_evolves m0 m1) = let (| i, l1 |) = extend_lock_store e m0.locks p in let m1 = { m0 with locks = l1 } in assert (lock_store_invariant e m1.locks == p `star` lock_store_invariant e m0.locks); calc (equiv) { linv e m1; (equiv) {} (lock_store_invariant e m1.locks `star` ctr_validity m1.ctr (heap_of_mem m1)); (equiv) {} ((p `star` lock_store_invariant e m0.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); (equiv) { H.star_associative p (lock_store_invariant e m0.locks) (ctr_validity m1.ctr (heap_of_mem m1)) } (p `star` (lock_store_invariant e m0.locks `star` ctr_validity m1.ctr (heap_of_mem m1))); (equiv) { } (p `star` linv e m0); }; assert (iname_for_p_mem i p m1); assert (lock_store_evolves m0.locks l1); assert (mem_evolves m0 m1); hmem_with_inv_equiv e m0 p; assert (interp (p `star` lock_store_invariant e m0.locks) m1); assert (interp (lock_store_invariant e m1.locks) m1); H.emp_unit (lock_store_invariant e m1.locks); H.star_commutative (lock_store_invariant e m1.locks) emp; assert (interp (emp `star` lock_store_invariant e m1.locks) m1); hmem_with_inv_equiv e m1 emp; let m1 : hmem_with_inv_except e emp = m1 in let aux (frame:slprop) : Lemma (requires interp ((p `star` frame) `star` linv e m0) m0) (ensures interp ((emp `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) <==> mp (core_mem m1))) [SMTPat (p `star` frame)] = assert (interp ((p `star` frame) `star` linv e m0) m1); calc (equiv) { ((p `star` frame) `star` linv e m0); (equiv) { H.star_commutative p frame; H.star_congruence (p `star` frame) (linv e m0) (frame `star` p) (linv e m0); H.star_associative frame p (linv e m0) } (frame `star` (p `star` linv e m0)); (equiv) { H.star_congruence frame (p `star` linv e m0) frame (linv e m1) } (frame `star` linv e m1); (equiv) { H.emp_unit (frame `star` linv e m1); H.star_commutative (frame `star` linv e m1) emp; H.star_associative emp frame (linv e m1) } ((emp `star` frame) `star` linv e m1); }; assert (interp ((emp `star` frame) `star` linv e m1) m1) in assert (frame_related_mems p emp e m0 m1); ( i, m1 ) let name_is_ok (i:iname) (m0:full_mem u#1) : prop = i < List.Tot.length m0.locks let witnessed_name_is_ok (i:iname) = W.witnessed full_mem mem_evolves (name_is_ok i) let pre_inv = i:erased iname & witnessed_name_is_ok i let inv (p:slprop u#1) = i:erased iname & witnessed_name_is_ok i & (i >--> p) let pre_inv_of_inv #p (i:inv p) = let (|i, w, _|) = i in (|i,w|) let name_of_pre_inv (i:pre_inv) = dfst i

{ "checked_file": "/", "dependencies": [ "Steel.Preorder.fst.checked", "Steel.Heap.fsti.checked", "prims.fst.checked", "FStar.Witnessed.Core.fsti.checked", "FStar.Set.fsti.checked", "FStar.Preorder.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.PCM.fst.checked", "FStar.NMSTTotal.fst.checked", "FStar.List.Tot.fst.checked", "FStar.IndefiniteDescription.fsti.checked", "FStar.Ghost.fsti.checked", "FStar.FunctionalExtensionality.fsti.checked", "FStar.Classical.Sugar.fsti.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Steel.Memory.fst" }

[ { "abbrev": true, "full_module": "Steel.Preorder", "short_module": "PP" }, { "abbrev": true, "full_module": "FStar.Witnessed.Core", "short_module": "W" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": true, "full_module": "Steel.Heap", "short_module": "H" }, { "abbrev": false, "full_module": "FStar.PCM", "short_module": null }, { "abbrev": false, "full_module": "FStar.FunctionalExtensionality", "short_module": null }, { "abbrev": true, "full_module": "FStar.FunctionalExtensionality", "short_module": "F" }, { "abbrev": false, "full_module": "FStar.PCM", "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

ctx: Prims.list Steel.Memory.pre_inv -> FStar.NMSTTotal.NMSTATETOT Prims.unit

FStar.NMSTTotal.NMSTATETOT

[]

[ "Prims.list", "Steel.Memory.pre_inv", "Prims.unit", "FStar.Ghost.erased", "Steel.Memory.iname", "Steel.Memory.witnessed_name_is_ok", "FStar.Ghost.reveal", "Steel.Memory.recall_all", "FStar.NMSTTotal.recall", "Steel.Memory.full_mem", "Steel.Memory.mem_evolves", "Steel.Memory.name_is_ok", "FStar.Witnessed.Core.witnessed", "Prims.l_True", "Prims.l_and", "Prims.eq2", "Prims.l_Forall", "Prims.l_imp", "FStar.List.Tot.Base.memP", "Steel.Memory.name_of_pre_inv" ]

[ "recursion" ]

false

true

false

let rec recall_all (ctx: list pre_inv) : NMSTTotal.NMSTATETOT unit (full_mem u#1) mem_evolves (requires fun _ -> True) (ensures fun m0 _ m1 -> m0 == m1 /\ (forall i. i `List.Tot.memP` ctx ==> name_is_ok (name_of_pre_inv i) m0)) =

match ctx with | [] -> () | hd :: tl -> let (| q , i |) = hd in let i:W.witnessed full_mem mem_evolves (name_is_ok q) = i in NMSTTotal.recall _ mem_evolves (name_is_ok q) i; recall_all tl

false

Hacl.Spec.Poly1305.Field32xN.Lemmas.fst

Hacl.Spec.Poly1305.Field32xN.Lemmas.fmul_r2_normalize51

val fmul_r2_normalize51: a:felem5 2 -> fa1:felem5 2 -> Pure (felem5 2) (requires felem_fits5 a (1, 2, 1, 1, 2) /\ felem_fits5 fa1 (1, 2, 1, 1, 2) /\ feval5 fa1 == create2 (feval5 a).[1] (feval5 a).[1]) (ensures fun out -> (feval5 out).[0] == Vec.pfadd (feval5 a).[0] (feval5 a).[1] /\ felem_fits5 out (2, 4, 2, 2, 4))

let fmul_r2_normalize51 a fa1 = let (a0, a1, a2, a3, a4) = a in let (a10, a11, a12, a13, a14) = fa1 in let o0 = vec_add_mod a0 a10 in let o1 = vec_add_mod a1 a11 in let o2 = vec_add_mod a2 a12 in let o3 = vec_add_mod a3 a13 in let o4 = vec_add_mod a4 a14 in let out = (o0, o1, o2, o3, o4) in let (a0, a1, a2, a3, a4) = as_tup64_i a 0 in let (a10, a11, a12, a13, a14) = as_tup64_i fa1 0 in let (o0, o1, o2, o3, o4) = as_tup64_i out 0 in FStar.Math.Lemmas.modulo_lemma (v a0 + v a10) (pow2 64); FStar.Math.Lemmas.modulo_lemma (v a1 + v a11) (pow2 64); FStar.Math.Lemmas.modulo_lemma (v a2 + v a12) (pow2 64); FStar.Math.Lemmas.modulo_lemma (v a3 + v a13) (pow2 64); FStar.Math.Lemmas.modulo_lemma (v a4 + v a14) (pow2 64); assert (felem_fits5 out (2, 4, 2, 2, 4)); calc (==) { ((feval5 a).[0] + (feval5 a).[1]) % Vec.prime; (==) { } (as_nat5 (a0, a1, a2, a3, a4) % Vec.prime + as_nat5 (a10, a11, a12, a13, a14) % Vec.prime) % Vec.prime; (==) { FStar.Math.Lemmas.lemma_mod_plus_distr_l (as_nat5 (a0, a1, a2, a3, a4)) (as_nat5 (a10, a11, a12, a13, a14)) Vec.prime; FStar.Math.Lemmas.lemma_mod_plus_distr_r (as_nat5 (a0, a1, a2, a3, a4) % Vec.prime) (as_nat5 (a10, a11, a12, a13, a14)) Vec.prime } (as_nat5 (a0, a1, a2, a3, a4) + as_nat5 (a10, a11, a12, a13, a14)) % Vec.prime; (==) { } (feval5 out).[0]; }; out

{ "file_name": "code/poly1305/Hacl.Spec.Poly1305.Field32xN.Lemmas.fst", "git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872", "git_url": "https://github.com/project-everest/hacl-star.git", "project_name": "hacl-star" }

{ "end_col": 5, "end_line": 361, "start_col": 0, "start_line": 328 }

module Hacl.Spec.Poly1305.Field32xN.Lemmas open Lib.IntTypes open Lib.IntVector open Lib.Sequence open FStar.Mul open Hacl.Spec.Poly1305.Field32xN open Hacl.Poly1305.Field32xN.Lemmas0 open Hacl.Poly1305.Field32xN.Lemmas1 open Hacl.Poly1305.Field32xN.Lemmas2 module Vec = Hacl.Spec.Poly1305.Vec #set-options "--z3rlimit 100 --max_fuel 0 --initial_ifuel 1 --max_ifuel 1 --using_facts_from '* -FStar.Seq'" val lemma_feval_is_fas_nat_i: #w:lanes -> f:felem5 w{felem_less5 f (pow2 128)} -> i:size_nat{i < w} -> Lemma ((feval5 f).[i] == (fas_nat5 f).[i]) let lemma_feval_is_fas_nat_i #w f i = assert_norm (pow2 128 < Vec.prime); assert ((feval5 f).[i] == (as_nat5 (transpose f).[i]) % Vec.prime); FStar.Math.Lemmas.modulo_lemma (as_nat5 (transpose f).[i]) Vec.prime val lemma_feval_is_fas_nat: #w:lanes -> f:felem5 w{felem_less5 f (pow2 128)} -> Lemma (forall (i:nat). i < w ==> (fas_nat5 f).[i] == (feval5 f).[i]) let lemma_feval_is_fas_nat #w f = FStar.Classical.forall_intro (lemma_feval_is_fas_nat_i #w f) val precomp_r5_fits_lemma: #w:lanes -> r:felem5 w{felem_fits5 r (1, 1, 1, 1, 1)} -> Lemma (felem_fits5 (precomp_r5 #w r) (5, 5, 5, 5, 5)) [SMTPat (precomp_r5 #w r)] let precomp_r5_fits_lemma #w r = FStar.Classical.forall_intro (precomp_r5_as_tup64 #w r) val precomp_r5_fits_lemma2: #w:lanes -> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)} -> Lemma (felem_fits5 (precomp_r5 #w r) (10, 10, 10, 10, 10)) [SMTPat (precomp_r5 #w r)] let precomp_r5_fits_lemma2 #w r = FStar.Classical.forall_intro (precomp_r5_as_tup64 #w r) val precomp_r5_zeros: w:lanes -> Lemma (let r = (zero w, zero w, zero w, zero w, zero w) in precomp_r5 r == (zero w, zero w, zero w, zero w, zero w)) let precomp_r5_zeros w = let r = (zero w, zero w, zero w, zero w, zero w) in let (r0, r1, r2, r3, r4) = precomp_r5 r in let aux (i:nat{i < w}) : Lemma ((vec_v (vec_smul_mod (zero w) (u64 5))).[i] == u64 0) = () in Classical.forall_intro aux; eq_intro (vec_v (vec_smul_mod (zero w) (u64 5))) (vec_v (zero w)); vecv_extensionality (vec_smul_mod (zero w) (u64 5)) (zero w) val fadd5_fits_lemma: #w:lanes -> f1:felem5 w{felem_fits5 f1 (2,2,2,2,2)} -> f2:felem5 w{felem_fits5 f2 (1,1,1,1,1)} -> Lemma (felem_fits5 (fadd5 f1 f2) (3,3,3,3,3)) [SMTPat (fadd5 f1 f2)] let fadd5_fits_lemma #w f1 f2 = let (f10, f11, f12, f13, f14) = f1 in let (f20, f21, f22, f23, f24) = f2 in let o = fadd5 f1 f2 in vec_add_mod_lemma f10 f20; vec_add_mod_lemma f11 f21; vec_add_mod_lemma f12 f22; vec_add_mod_lemma f13 f23; vec_add_mod_lemma f14 f24 val fadd5_eval_lemma: #w:lanes -> f1:felem5 w{felem_fits5 f1 (2,2,2,2,2)} -> f2:felem5 w{felem_fits5 f2 (1,1,1,1,1)} -> Lemma (feval5 (fadd5 f1 f2) == map2 Vec.pfadd (feval5 f1) (feval5 f2)) [SMTPat (fadd5 f1 f2)] let fadd5_eval_lemma #w f1 f2 = let o = fadd5 f1 f2 in FStar.Classical.forall_intro (fadd5_eval_lemma_i f1 f2); eq_intro (feval5 o) (map2 Vec.pfadd (feval5 f1) (feval5 f2)) val mul_felem5_fits_lemma: #w:lanes -> f1:felem5 w{felem_fits5 f1 (3, 3, 3, 3, 3)} -> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)} -> r5:felem5 w{felem_fits5 r5 (10, 10, 10, 10, 10)} -> Lemma (felem_wide_fits5 (mul_felem5 #w f1 r r5) (126, 102, 78, 54, 30)) [SMTPat (mul_felem5 #w f1 r r5)] let mul_felem5_fits_lemma #w f1 r r5 = let (r0, r1, r2, r3, r4) = r in let (f10, f11, f12, f13, f14) = f1 in let (r50, r51, r52, r53, r54) = r5 in let (a0,a1,a2,a3,a4) = smul_felem5 #w f10 (r0,r1,r2,r3,r4) in smul_felem5_fits_lemma #w #3 #(2,2,2,2,2) f10 (r0,r1,r2,r3,r4); let (a10,a11,a12,a13,a14) = smul_add_felem5 #w f11 (r54,r0,r1,r2,r3) (a0,a1,a2,a3,a4) in smul_add_felem5_fits_lemma #w #3 #(10,2,2,2,2) #(6,6,6,6,6) f11 (r54,r0,r1,r2,r3) (a0,a1,a2,a3,a4); let (a20,a21,a22,a23,a24) = smul_add_felem5 #w f12 (r53,r54,r0,r1,r2) (a10,a11,a12,a13,a14) in smul_add_felem5_fits_lemma #w #3 #(10,10,2,2,2) #(36,12,12,12,12) f12 (r53,r54,r0,r1,r2) (a10,a11,a12,a13,a14); let (a30,a31,a32,a33,a34) = smul_add_felem5 #w f13 (r52,r53,r54,r0,r1) (a20,a21,a22,a23,a24) in smul_add_felem5_fits_lemma #w #3 #(10,10,10,2,2) #(66,42,18,18,18) f13 (r52,r53,r54,r0,r1) (a20,a21,a22,a23,a24); let (a40,a41,a42,a43,a44) = smul_add_felem5 #w f14 (r51,r52,r53,r54,r0) (a30,a31,a32,a33,a34) in smul_add_felem5_fits_lemma #w #3 #(10,10,10,10,2) #(96,72,48,24,24) f14 (r51,r52,r53,r54,r0) (a30,a31,a32,a33,a34) val mul_felem5_eval_lemma_i: #w:lanes -> f1:felem5 w{felem_fits5 f1 (3, 3, 3, 3, 3)} -> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)} -> r5:felem5 w{felem_fits5 r5 (10, 10, 10, 10, 10) /\ r5 == precomp_r5 r} -> i:nat{i < w} -> Lemma ((feval5 (mul_felem5 #w f1 r r5)).[i] == (feval5 f1).[i] `Vec.pfmul` (feval5 r).[i]) let mul_felem5_eval_lemma_i #w f1 r r5 i = let (r0, r1, r2, r3, r4) = r in let (f10, f11, f12, f13, f14) = f1 in let (r50, r51, r52, r53, r54) = r5 in let (a0,a1,a2,a3,a4) = smul_felem5 #w f10 (r0,r1,r2,r3,r4) in smul_felem5_eval_lemma #w #3 #(2,2,2,2,2) f10 (r0,r1,r2,r3,r4); smul_felem5_fits_lemma #w #3 #(2,2,2,2,2) f10 (r0,r1,r2,r3,r4); assert ((fas_nat5 (a0,a1,a2,a3,a4)).[i] == (uint64xN_v f10).[i] * (fas_nat5 (r0,r1,r2,r3,r4)).[i]); let (a10,a11,a12,a13,a14) = smul_add_felem5 #w f11 (r54,r0,r1,r2,r3) (a0,a1,a2,a3,a4) in smul_add_felem5_eval_lemma #w #3 #(10,2,2,2,2) #(6,6,6,6,6) f11 (r54,r0,r1,r2,r3) (a0,a1,a2,a3,a4); smul_add_felem5_fits_lemma #w #3 #(10,2,2,2,2) #(6,6,6,6,6) f11 (r54,r0,r1,r2,r3) (a0,a1,a2,a3,a4); assert ((fas_nat5 (a10,a11,a12,a13,a14)).[i] == (fas_nat5 (a0,a1,a2,a3,a4)).[i] + (uint64xN_v f11).[i] * (fas_nat5 (r54,r0,r1,r2,r3)).[i]); let (a20,a21,a22,a23,a24) = smul_add_felem5 #w f12 (r53,r54,r0,r1,r2) (a10,a11,a12,a13,a14) in smul_add_felem5_eval_lemma #w #3 #(10,10,2,2,2) #(36,12,12,12,12) f12 (r53,r54,r0,r1,r2) (a10,a11,a12,a13,a14); smul_add_felem5_fits_lemma #w #3 #(10,10,2,2,2) #(36,12,12,12,12) f12 (r53,r54,r0,r1,r2) (a10,a11,a12,a13,a14); assert ((fas_nat5 (a20,a21,a22,a23,a24)).[i] == (fas_nat5 (a10,a11,a12,a13,a14)).[i] + (uint64xN_v f12).[i] * (fas_nat5 (r53,r54,r0,r1,r2)).[i]); let (a30,a31,a32,a33,a34) = smul_add_felem5 #w f13 (r52,r53,r54,r0,r1) (a20,a21,a22,a23,a24) in smul_add_felem5_eval_lemma #w #3 #(10,10,10,2,2) #(66,42,18,18,18) f13 (r52,r53,r54,r0,r1) (a20,a21,a22,a23,a24); smul_add_felem5_fits_lemma #w #3 #(10,10,10,2,2) #(66,42,18,18,18) f13 (r52,r53,r54,r0,r1) (a20,a21,a22,a23,a24); assert ((fas_nat5 (a30,a31,a32,a33,a34)).[i] == (fas_nat5 (a20,a21,a22,a23,a24)).[i] + (uint64xN_v f13).[i] * (fas_nat5 (r52,r53,r54,r0,r1)).[i]); let (a40,a41,a42,a43,a44) = smul_add_felem5 #w f14 (r51,r52,r53,r54,r0) (a30,a31,a32,a33,a34) in smul_add_felem5_eval_lemma #w #3 #(10,10,10,10,2) #(96,72,48,24,24) f14 (r51,r52,r53,r54,r0) (a30,a31,a32,a33,a34); smul_add_felem5_fits_lemma #w #3 #(10,10,10,10,2) #(96,72,48,24,24) f14 (r51,r52,r53,r54,r0) (a30,a31,a32,a33,a34); assert ((fas_nat5 (a40,a41,a42,a43,a44)).[i] == (fas_nat5 (a30,a31,a32,a33,a34)).[i] + (uint64xN_v f14).[i] * (fas_nat5 (r51,r52,r53,r54,r0)).[i]); assert ((fas_nat5 (a40,a41,a42,a43,a44)).[i] == (uint64xN_v f10).[i] * (fas_nat5 (r0,r1,r2,r3,r4)).[i] + (uint64xN_v f11).[i] * (fas_nat5 (r54,r0,r1,r2,r3)).[i] + (uint64xN_v f12).[i] * (fas_nat5 (r53,r54,r0,r1,r2)).[i] + (uint64xN_v f13).[i] * (fas_nat5 (r52,r53,r54,r0,r1)).[i] + (uint64xN_v f14).[i] * (fas_nat5 (r51,r52,r53,r54,r0)).[i]); mul_felem5_eval_as_tup64 #w f1 r r5 i; mul_felem5_lemma (as_tup64_i f1 i) (as_tup64_i r i) val mul_felem5_eval_lemma: #w:lanes -> f1:felem5 w{felem_fits5 f1 (3, 3, 3, 3, 3)} -> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)} -> r5:felem5 w{felem_fits5 r5 (10, 10, 10, 10, 10) /\ r5 == precomp_r5 r} -> Lemma (feval5 (mul_felem5 #w f1 r r5) == map2 (Vec.pfmul) (feval5 f1) (feval5 r)) [SMTPat (mul_felem5 #w f1 r r5)] let mul_felem5_eval_lemma #w f1 r r5 = let tmp = map2 (Vec.pfmul) (feval5 f1) (feval5 r) in FStar.Classical.forall_intro (mul_felem5_eval_lemma_i #w f1 r r5); eq_intro (feval5 (mul_felem5 #w f1 r r5)) tmp val fmul_r5_fits_lemma: #w:lanes -> f1:felem5 w{felem_fits5 f1 (3, 3, 3, 3, 3)} -> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)} -> r5:felem5 w{felem_fits5 r5 (10, 10, 10, 10, 10)} -> Lemma (felem_fits5 (fmul_r5 #w f1 r r5) (1, 2, 1, 1, 2)) [SMTPat (fmul_r5 #w f1 r r5)] let fmul_r5_fits_lemma #w f1 r r5 = let tmp = mul_felem5 f1 r r5 in mul_felem5_fits_lemma #w f1 r r5; let res = carry_wide_felem5 tmp in carry_wide_felem5_fits_lemma #w tmp val fmul_r5_eval_lemma: #w:lanes -> f1:felem5 w{felem_fits5 f1 (3, 3, 3, 3, 3)} -> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)} -> r5:felem5 w{felem_fits5 r5 (10, 10, 10, 10, 10) /\ r5 == precomp_r5 r} -> Lemma (feval5 (fmul_r5 #w f1 r r5) == map2 (Vec.pfmul) (feval5 f1) (feval5 r)) [SMTPat (fmul_r5 #w f1 r r5)] let fmul_r5_eval_lemma #w f1 r r5 = let tmp = mul_felem5 f1 r r5 in mul_felem5_eval_lemma #w f1 r r5; let res = carry_wide_felem5 tmp in carry_wide_felem5_eval_lemma #w tmp val fadd_mul_r5_fits_lemma: #w:lanes -> acc:felem5 w{felem_fits5 acc (2, 2, 2, 2, 2)} -> f1:felem5 w{felem_fits5 f1 (1, 1, 1, 1, 1)} -> r:felem5 w{felem_fits5 r (1, 1, 1, 1, 1)} -> r5:felem5 w{felem_fits5 r5 (5, 5, 5, 5, 5)} -> Lemma (felem_fits5 (fadd_mul_r5 acc f1 r r5) (1, 2, 1, 1, 2)) [SMTPat (fadd_mul_r5 acc f1 r r5)] let fadd_mul_r5_fits_lemma #w acc f1 r r5 = let acc1 = fadd5 acc f1 in fadd5_fits_lemma #w acc f1; let tmp = mul_felem5 acc1 r r5 in mul_felem5_fits_lemma #w acc1 r r5; let res = carry_wide_felem5 tmp in carry_wide_felem5_fits_lemma #w tmp val fadd_mul_r5_eval_lemma: #w:lanes -> acc:felem5 w{felem_fits5 acc (2, 2, 2, 2, 2)} -> f1:felem5 w{felem_fits5 f1 (1, 1, 1, 1, 1)} -> r:felem5 w{felem_fits5 r (1, 1, 1, 1, 1)} -> r5:felem5 w{felem_fits5 r5 (5, 5, 5, 5, 5) /\ r5 == precomp_r5 r} -> Lemma (feval5 (fadd_mul_r5 acc f1 r r5) == map2 (Vec.pfmul) (map2 (Vec.pfadd) (feval5 acc) (feval5 f1)) (feval5 r)) [SMTPat (fadd_mul_r5 acc f1 r r5)] let fadd_mul_r5_eval_lemma #w acc f1 r r5 = let acc1 = fadd5 acc f1 in fadd5_eval_lemma #w acc f1; let tmp = mul_felem5 acc1 r r5 in mul_felem5_eval_lemma #w acc1 r r5; let res = carry_wide_felem5 tmp in carry_wide_felem5_eval_lemma #w tmp val reduce_felem5_eval_lemma: #w:lanes -> f:felem5 w{felem_fits5 f (2, 2, 2, 2, 2)} -> Lemma (felem_fits5 (reduce_felem5 f) (1, 1, 1, 1, 1) /\ (feval5 f).[0] == (fas_nat5 (reduce_felem5 f)).[0]) [SMTPat (reduce_felem5 f)] let reduce_felem5_eval_lemma #w f = carry_full_felem5_eval_lemma f; carry_full_felem5_fits_lemma f; let f = carry_full_felem5 f in carry_reduce_felem5_lemma #w f; subtract_p5_felem5_lemma #w (carry_full_felem5 f) val fmul_r2_normalize50: acc:felem5 2 -> r:felem5 2 -> r2:felem5 2 -> Pure (felem5 2) (requires felem_fits5 acc (3, 3, 3, 3, 3) /\ felem_fits5 r (1, 1, 1, 1, 1) /\ felem_fits5 r2 (2, 2, 2, 2, 2) /\ feval5 r2 == Vec.compute_r2 (feval5 r).[0]) (ensures fun a -> let fr21 = create2 (feval5 r2).[0] (feval5 r).[0] in feval5 a == Vec.fmul (feval5 acc) fr21 /\ felem_fits5 a (1, 2, 1, 1, 2)) let fmul_r2_normalize50 (a0, a1, a2, a3, a4) (r0, r1, r2, r3, r4) (r20, r21, r22, r23, r24) = let r210 = vec_interleave_low r20 r0 in vec_interleave_low_lemma2 r20 r0; let r211 = vec_interleave_low r21 r1 in vec_interleave_low_lemma2 r21 r1; let r212 = vec_interleave_low r22 r2 in vec_interleave_low_lemma2 r22 r2; let r213 = vec_interleave_low r23 r3 in vec_interleave_low_lemma2 r23 r3; let r214 = vec_interleave_low r24 r4 in vec_interleave_low_lemma2 r24 r4; let acc = (a0, a1, a2, a3, a4) in let fr = (r0, r1, r2, r3, r4) in let fr2 = (r20, r21, r22, r23, r24) in assert ((feval5 fr2).[0] == Vec.pfmul ((feval5 fr).[0]) ((feval5 fr).[0])); let fr21 = (r210, r211, r212, r213, r214) in eq_intro (feval5 fr21) (create2 (feval5 fr2).[0] (feval5 fr).[0]); assert (feval5 fr21 == create2 (feval5 fr2).[0] (feval5 fr).[0]); assert (felem_fits5 fr21 (2, 2, 2, 2, 2)); let fr215 = precomp_r5 #2 fr21 in let a = fmul_r5 #2 acc fr21 fr215 in fmul_r5_eval_lemma acc fr21 fr215; fmul_r5_fits_lemma acc fr21 fr215; assert (feval5 a == Vec.fmul (feval5 acc) (feval5 fr21)); assert (felem_fits5 a (1, 2, 1, 1, 2)); a #push-options "--z3rlimit 150" val fmul_r2_normalize51: a:felem5 2 -> fa1:felem5 2 -> Pure (felem5 2) (requires felem_fits5 a (1, 2, 1, 1, 2) /\ felem_fits5 fa1 (1, 2, 1, 1, 2) /\ feval5 fa1 == create2 (feval5 a).[1] (feval5 a).[1]) (ensures fun out -> (feval5 out).[0] == Vec.pfadd (feval5 a).[0] (feval5 a).[1] /\ felem_fits5 out (2, 4, 2, 2, 4))

{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "Lib.Sequence.fsti.checked", "Lib.IntVector.fsti.checked", "Lib.IntTypes.fsti.checked", "Hacl.Spec.Poly1305.Vec.fst.checked", "Hacl.Spec.Poly1305.Field32xN.fst.checked", "Hacl.Poly1305.Field32xN.Lemmas2.fst.checked", "Hacl.Poly1305.Field32xN.Lemmas1.fst.checked", "Hacl.Poly1305.Field32xN.Lemmas0.fst.checked", "Hacl.Impl.Poly1305.Lemmas.fst.checked", "FStar.UInt32.fsti.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Mul.fst.checked", "FStar.Math.Lemmas.fst.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": false, "source_file": "Hacl.Spec.Poly1305.Field32xN.Lemmas.fst" }

[ { "abbrev": true, "full_module": "Hacl.Spec.Poly1305.Vec", "short_module": "Vec" }, { "abbrev": false, "full_module": "Hacl.Poly1305.Field32xN.Lemmas2", "short_module": null }, { "abbrev": false, "full_module": "Hacl.Poly1305.Field32xN.Lemmas1", "short_module": null }, { "abbrev": false, "full_module": "Hacl.Poly1305.Field32xN.Lemmas0", "short_module": null }, { "abbrev": false, "full_module": "Hacl.Spec.Poly1305.Field32xN", "short_module": null }, { "abbrev": false, "full_module": "FStar.Mul", "short_module": null }, { "abbrev": false, "full_module": "Lib.Sequence", "short_module": null }, { "abbrev": false, "full_module": "Lib.IntVector", "short_module": null }, { "abbrev": false, "full_module": "Lib.IntTypes", "short_module": null }, { "abbrev": false, "full_module": "Hacl.Spec.Poly1305.Field32xN", "short_module": null }, { "abbrev": false, "full_module": "Hacl.Spec.Poly1305.Field32xN", "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": 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": 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": 150, "z3rlimit_factor": 1, "z3seed": 0, "z3smtopt": [], "z3version": "4.8.5" }

false

a: Hacl.Spec.Poly1305.Field32xN.felem5 2 -> fa1: Hacl.Spec.Poly1305.Field32xN.felem5 2 -> Prims.Pure (Hacl.Spec.Poly1305.Field32xN.felem5 2)

Prims.Pure

[]

[ "Hacl.Spec.Poly1305.Field32xN.felem5", "Hacl.Spec.Poly1305.Field32xN.uint64xN", "Lib.IntTypes.uint64", "Prims.unit", "FStar.Calc.calc_finish", "Prims.int", "Prims.eq2", "Prims.op_Modulus", "Prims.op_Addition", "Lib.Sequence.op_String_Access", "Hacl.Spec.Poly1305.Vec.pfelem", "Hacl.Spec.Poly1305.Field32xN.feval5", "Hacl.Spec.Poly1305.Vec.prime", "Prims.Cons", "FStar.Preorder.relation", "Prims.Nil", "FStar.Calc.calc_step", "Hacl.Spec.Poly1305.Field32xN.as_nat5", "FStar.Pervasives.Native.Mktuple5", "FStar.Calc.calc_init", "FStar.Calc.calc_pack", "Prims.squash", "FStar.Math.Lemmas.lemma_mod_plus_distr_r", "FStar.Math.Lemmas.lemma_mod_plus_distr_l", "Prims._assert", "Hacl.Spec.Poly1305.Field32xN.felem_fits5", "Prims.nat", "FStar.Math.Lemmas.modulo_lemma", "Lib.IntTypes.v", "Lib.IntTypes.U64", "Lib.IntTypes.SEC", "Prims.pow2", "Hacl.Spec.Poly1305.Field32xN.tup64_5", "Hacl.Spec.Poly1305.Field32xN.as_tup64_i", "FStar.Pervasives.Native.tuple5", "Lib.IntVector.vec_t", "Lib.IntVector.vec_add_mod" ]

[]

false

let fmul_r2_normalize51 a fa1 =

let a0, a1, a2, a3, a4 = a in let a10, a11, a12, a13, a14 = fa1 in let o0 = vec_add_mod a0 a10 in let o1 = vec_add_mod a1 a11 in let o2 = vec_add_mod a2 a12 in let o3 = vec_add_mod a3 a13 in let o4 = vec_add_mod a4 a14 in let out = (o0, o1, o2, o3, o4) in let a0, a1, a2, a3, a4 = as_tup64_i a 0 in let a10, a11, a12, a13, a14 = as_tup64_i fa1 0 in let o0, o1, o2, o3, o4 = as_tup64_i out 0 in FStar.Math.Lemmas.modulo_lemma (v a0 + v a10) (pow2 64); FStar.Math.Lemmas.modulo_lemma (v a1 + v a11) (pow2 64); FStar.Math.Lemmas.modulo_lemma (v a2 + v a12) (pow2 64); FStar.Math.Lemmas.modulo_lemma (v a3 + v a13) (pow2 64); FStar.Math.Lemmas.modulo_lemma (v a4 + v a14) (pow2 64); assert (felem_fits5 out (2, 4, 2, 2, 4)); calc ( == ) { ((feval5 a).[ 0 ] + (feval5 a).[ 1 ]) % Vec.prime; ( == ) { () } (as_nat5 (a0, a1, a2, a3, a4) % Vec.prime + as_nat5 (a10, a11, a12, a13, a14) % Vec.prime) % Vec.prime; ( == ) { (FStar.Math.Lemmas.lemma_mod_plus_distr_l (as_nat5 (a0, a1, a2, a3, a4)) (as_nat5 (a10, a11, a12, a13, a14)) Vec.prime; FStar.Math.Lemmas.lemma_mod_plus_distr_r (as_nat5 (a0, a1, a2, a3, a4) % Vec.prime) (as_nat5 (a10, a11, a12, a13, a14)) Vec.prime) } (as_nat5 (a0, a1, a2, a3, a4) + as_nat5 (a10, a11, a12, a13, a14)) % Vec.prime; ( == ) { () } (feval5 out).[ 0 ]; }; out

false

Steel.Memory.fst

Steel.Memory.witness

val witness (#a:Type) (#pcm:pcm a) (e:inames) (r:erased (ref a pcm)) (fact:stable_property pcm) (v:Ghost.erased a) (_:squash (forall z. compatible pcm v z ==> fact z)) : action_except (witnessed r fact) e (pts_to r v) (fun _ -> pts_to r v)

let witness (#a:Type) (#pcm:pcm a) (e:inames) (r:erased (ref a pcm)) (fact:stable_property pcm) (v:Ghost.erased a) (_:squash (forall z. compatible pcm v z ==> fact z)) (frame:slprop) : MstTot (witnessed r fact) e (pts_to r v) (fun _ -> pts_to r v) frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in let _ : unit = let hr : H.ref a pcm = r in let v' = H.sel_v hr v (heap_of_mem m0) in assert (interp (H.ptr hr) m0 /\ H.sel #a #pcm hr (heap_of_mem m0) == v'); assert (compatible pcm v v'); assert (fact v'); assert (witnessed_ref r fact m0); witnessed_ref_stability r fact; assert (FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) in let w = NMSTTotal.witness _ mem_evolves (witnessed_ref r fact) in w

{ "file_name": "lib/steel/Steel.Memory.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 5, "end_line": 1117, "start_col": 0, "start_line": 1093 }

(* 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.Memory module F = FStar.FunctionalExtensionality open FStar.FunctionalExtensionality open FStar.PCM module H = Steel.Heap noeq type lock_state : Type u#(a + 1) = | Invariant : inv:H.slprop u#a -> lock_state let lock_store : Type u#(a+1) = list (lock_state u#a) noeq type mem : Type u#(a + 1) = { ctr: nat; heap: H.heap u#a; locks: lock_store u#a; } let heap_of_mem (x:mem) : H.heap = x.heap let mem_of_heap (h:H.heap) : mem = { ctr = 0; heap = h; locks = [] } let mem_set_heap (m:mem) (h:H.heap) : mem = { ctr = m.ctr; heap = h; locks = m.locks; } let core_mem (m:mem) : mem = mem_of_heap (heap_of_mem m) let core_mem_invol m = () let disjoint (m0 m1:mem u#h) : prop = m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks let disjoint_sym m0 m1 = () let join m0 m1 = { ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = m0.locks } let join_commutative m0 m1 = H.join_commutative m0.heap m1.heap let disjoint_join m0 m1 m2 = H.disjoint_join m0.heap m1.heap m2.heap let join_associative m0 m1 m2 = H.join_associative m0.heap m1.heap m2.heap let slprop = H.slprop let interp p m = H.interp p m.heap let equiv p1 p2 = forall m. interp p1 m <==> interp p2 m let slprop_extensionality p q = assert (forall m. interp p m <==> interp q m); let aux (h:H.heap) : Lemma (H.interp p h <==> H.interp q h) [SMTPat (H.interp p h)] = let m : mem = { ctr = 0; heap = h; locks = [] } in assert (interp p m <==> interp q m) in assert (forall h. H.interp p h <==> H.interp q h); Steel.Heap.slprop_extensionality p q let reveal_equiv p1 p2 = () let core_ref = H.core_ref let core_ref_null = H.core_ref_null let core_ref_is_null r = H.core_ref_is_null r let emp : slprop u#a = H.emp let pure = H.pure let pts_to = H.pts_to let h_and = H.h_and let h_or = H.h_or let star = H.star let wand = H.wand let h_exists = H.h_exists let h_forall = H.h_forall //////////////////////////////////////////////////////////////////////////////// //properties of equiv //////////////////////////////////////////////////////////////////////////////// let equiv_symmetric (p1 p2:slprop u#a) = H.equiv_symmetric p1 p2 #push-options "--warn_error -271" let equiv_heap_iff_equiv (p1 p2:slprop u#a) : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat (equiv p1 p2)] = let aux_lr () : Lemma (requires H.equiv p1 p2) (ensures equiv p1 p2) [SMTPat ()] = () in let aux_rl_helper1 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p1 h) (ensures H.interp p2 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl_helper2 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p2 h) (ensures H.interp p1 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl () : Lemma (requires equiv p1 p2) (ensures H.equiv p1 p2) [SMTPat ()] = () in () let equiv_heap_iff_equiv_forall () : Lemma (ensures (forall p1 p2. H.equiv p1 p2 <==> equiv p1 p2)) = let aux p1 p2 : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat ()] = equiv_heap_iff_equiv p1 p2 in () #pop-options let equiv_extensional_on_star (p1 p2 p3:slprop u#a) = equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3 let emp_unit p = H.emp_unit p let intro_emp m = H.intro_emp (heap_of_mem m) let pure_equiv p q = H.pure_equiv p q let pure_interp q m = H.pure_interp q (heap_of_mem m) let pure_star_interp p q m = H.pure_star_interp p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// //pts_to //////////////////////////////////////////////////////////////////////////////// let pts_to_compatible #a #pcm x v0 v1 m = H.pts_to_compatible #a #pcm x v0 v1 (heap_of_mem m) let pts_to_compatible_equiv #a #pcm x v0 v1 = H.pts_to_compatible_equiv #a #pcm x v0 v1 let pts_to_not_null #a #pcm x v m = H.pts_to_not_null #a #pcm x v (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // star //////////////////////////////////////////////////////////////////////////////// let intro_star p q mp mq = H.intro_star p q (heap_of_mem mp) (heap_of_mem mq) let elim_star p q m = let h = heap_of_mem m in H.elim_star p q h; assert (exists hl hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr); let hl = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hl -> exists hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let hr = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hr -> H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let ml = mem_set_heap m hl in let mr = mem_set_heap m hr in assert (disjoint ml mr); assert (m == join ml mr); assert (interp p ml); assert (interp q mr); () let interp_star (p q: slprop) (m: mem) : Lemma (interp (p `star` q) m <==> (exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m)) = let left = interp (p `star` q) m in let right = exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m in let f () : Lemma (requires left) (ensures right) = elim_star p q m in let g () : Lemma (requires right) (ensures left) = Classical.exists_elim left #_ #(fun mp -> exists (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mp -> Classical.exists_elim left #_ #(fun mq -> disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mq -> intro_star p q mp mq ) ) in Classical.move_requires f (); Classical.move_requires g () let star_commutative (p1 p2:slprop) = H.star_commutative p1 p2 let star_associative (p1 p2 p3:slprop) = H.star_associative p1 p2 p3 let star_congruence (p1 p2 p3 p4:slprop) = equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4 let affine_star (p q:slprop) (m:mem) = H.affine_star p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // Invariants on the lock store //////////////////////////////////////////////////////////////////////////////// let iname = nat module S = FStar.Set module L = FStar.List.Tot module W = FStar.Witnessed.Core let rec lock_store_invariant (e:inames) (l:lock_store u#a) : slprop u#a = let current_addr = L.length l - 1 in match l with | [] -> emp | Invariant p :: tl -> if current_addr `S.mem` e then lock_store_invariant e tl else p `star` lock_store_invariant e tl let lock_i (i:iname) (l:lock_store { i < L.length l }) = let ix = L.length l - i - 1 in L.index l ix let iname_for_p (i:iname) (p:slprop) : W.s_predicate lock_store = fun l -> i < L.length l /\ (lock_i i l).inv == p let lock_store_evolves : FStar.Preorder.preorder lock_store = fun (l1 l2 : lock_store) -> L.length l2 >= L.length l1 /\ (forall (i:nat{i < L.length l1}). (lock_i i l1).inv == (lock_i i l2).inv) let inames_in (e:inames) (l:lock_store) : prop = forall i. Set.mem i e ==> i < L.length l let inames_ok e m = inames_in e m.locks let inames_ok_empty m = () let extend_lock_store (e:inames) (l:lock_store{e `inames_in` l}) (p:slprop) : i:iname & l':lock_store { lock_store_invariant e l' == p `star` lock_store_invariant e l /\ iname_for_p i p l' } = (| L.length l, Invariant p :: l |) let set_add (i:iname) (s:inames) = Set.union (Set.singleton i) s let rec move_invariant (e:inames) (l:lock_store) (p:slprop) (i:iname{iname_for_p i p l /\ ~(i `Set.mem` e)}) : Lemma (H.equiv (lock_store_invariant e l) (p `star` lock_store_invariant (set_add i e) l)) = let rec aux (i:iname) (m:lock_store) : Lemma (requires i >= L.length m) (ensures (lock_store_invariant e m `H.equiv` lock_store_invariant (set_add i e) m)) = match m with | [] -> () | Invariant p::tl -> aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl) in let current_addr = L.length l - 1 in match l with | [] -> () | Invariant q::tl -> if i = current_addr then begin assert (lock_store_invariant e l == p `star` lock_store_invariant e tl); aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl); () end else begin move_invariant e tl p i; assert (lock_store_invariant e tl `equiv` (p `star` lock_store_invariant (set_add i e) tl)); H.star_congruence q (lock_store_invariant e tl) q (p `star` lock_store_invariant (set_add i e) tl); if Set.mem current_addr e then () else begin let r = lock_store_invariant (set_add i e) tl in assert (lock_store_invariant e l `equiv` (q `star` (p `star` r))); H.star_associative q p r; H.star_commutative q p; H.star_congruence (q `star` p) r (p `star` q) r; H.star_associative p q r end end let heap_ctr_valid (ctr:nat) (h:H.heap u#a) : prop = h `H.free_above_addr` ctr let ctr_validity (ctr:nat) (h:H.heap) : slprop = H.pure (heap_ctr_valid ctr h) let locks_invariant (e:inames) (m:mem u#a) : slprop u#a = lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m) let full_mem_pred (m:mem) = H.full_heap_pred (heap_of_mem m) (***** Following lemmas are needed in Steel.Effect *****) let core_mem_interp (hp:slprop u#a) (m:mem u#a) = () let interp_depends_only_on (hp:slprop u#a) = H.interp_depends_only_on hp let a_mem_prop_as_a_heap_prop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (H.a_heap_prop u#a) = let g (h: H.heap u#a) : Tot prop = interp sl (mem_of_heap h) /\ f (mem_of_heap h) in let phi0 (h0 h1: H.heap u#a) : Lemma (requires (g h0 /\ H.disjoint h0 h1)) (ensures (g h0 /\ H.disjoint h0 h1 /\ g (H.join h0 h1))) = assert (mem_of_heap (H.join h0 h1) == mem_of_heap h0 `join` mem_of_heap h1); interp_depends_only_on sl in let phi1 (h0 h1: H.heap u#a) : Lemma (ensures ((g h0 /\ H.disjoint h0 h1) ==> g (H.join h0 h1))) = Classical.move_requires (phi0 h0) h1 in Classical.forall_intro_2 phi1; g let refine_slprop sl f = H.as_slprop (a_mem_prop_as_a_heap_prop sl f) let interp_refine_slprop sl f m = assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_mem m)) let dep_hprop (s: slprop) (f: (hmem s -> Tot slprop)) (h: H.heap) : Tot prop = exists (h1: H.heap) . exists (h2: H.heap) . interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 let dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq' : squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h')) = let p2 (h h1 h2: H.heap) : Tot prop = interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 in let p1 (h h1: H.heap) : Tot prop = (exists h2 . p2 h h1 h2) in let h1 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p1 h) in let h2 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p2 h h1) in H.disjoint_join h' h1 h2; assert (H.disjoint h2 h'); let h2' = H.join h2 h' in H.join_commutative h2 h' ; assert (h2' == H.join h' h2); assert (H.disjoint h1 h2'); assert (mem_of_heap h2' == mem_of_heap h2 `join` mem_of_heap h'); interp_depends_only_on (f (mem_of_heap h1)); assert (interp (f (mem_of_heap h1)) (mem_of_heap h2')); H.join_commutative h1 h2; H.join_associative h' h2 h1; H.join_commutative h' h; H.join_commutative h2' h1; assert (H.join h h' == h1 `H.join` h2') let impl_intro_gen (#p: Type0) (#q: Type0) ($prf: (squash p -> Lemma (q ))) : Lemma (p ==> q) = Classical.impl_intro_gen #p #(fun _ -> q) prf let dep_hprop_is_affine1 (s: slprop) (f: (hmem s -> Tot slprop)) (h0 h1: H.heap) : Lemma ((dep_hprop s f h0 /\ H.disjoint h0 h1) ==> (H.disjoint h0 h1 /\ dep_hprop s f (H.join h0 h1))) = impl_intro_gen (dep_hprop_is_affine0 s f h0 h1) let dep_hprop_is_affine (s: slprop) (f: (hmem s -> Tot slprop)) : Lemma (H.heap_prop_is_affine (dep_hprop s f)) = Classical.forall_intro_2 (dep_hprop_is_affine1 s f) let sdep (s: slprop) (f: (hmem s -> Tot slprop)) : Tot slprop = dep_hprop_is_affine s f; H.as_slprop (dep_hprop s f) let interp_sdep (s: slprop) (f: (hmem s -> Tot slprop)) (m: mem) : Lemma (requires (dep_slprop_is_affine s f)) (ensures ( interp (sdep s f) m <==> (exists m1 m2 . interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) )) = dep_hprop_is_affine s f; assert (forall m1 m2 . (interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) ==> ( interp s (mem_of_heap m1.heap) /\ interp (f (mem_of_heap m1.heap)) (mem_of_heap m2.heap) /\ H.disjoint m1.heap m2.heap /\ H.join m1.heap m2.heap == m.heap )); interp_depends_only_on s; Classical.forall_intro (fun m -> interp_depends_only_on (f m)); assert (forall h1 h2 . (interp s (mem_of_heap h1) /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ H.disjoint h1 h2 /\ H.join h1 h2 == m.heap) ==> ( core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ interp s (core_mem (mem_of_heap h1)) /\ interp s (mem_set_heap m h1) /\ core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ f (mem_set_heap m h1) `equiv` f (mem_of_heap h1) /\ interp (f (mem_set_heap m h1)) (mem_of_heap h2) /\ interp (f (mem_set_heap m h1)) (mem_set_heap m h2) /\ disjoint (mem_set_heap m h1) (mem_set_heap m h2) /\ join (mem_set_heap m h1) (mem_set_heap m h2) == m )); () let h_exists_cong (#a:Type) (p q : a -> slprop) : Lemma (requires (forall x. p x `equiv` q x)) (ensures (h_exists p `equiv` h_exists q)) = equiv_heap_iff_equiv_forall (); H.h_exists_cong p q let intro_h_exists #a x p m = H.intro_h_exists x p (heap_of_mem m) let elim_h_exists (#a:_) (p:a -> slprop) (m:mem) = H.elim_h_exists p (heap_of_mem m) let intro_h_forall (#a:_) (p:a -> slprop) (m:mem) = H.intro_h_forall p (heap_of_mem m) let elim_h_forall (#a:_) (p:a -> slprop) (m:mem) (x:a) = H.elim_h_forall p (heap_of_mem m) x let intro_h_and (p q: slprop) (m:mem) = H.intro_h_and p q (heap_of_mem m) let elim_h_and (p q: slprop) (m:mem) = H.elim_h_and p q (heap_of_mem m) let intro_h_or_left (p q: slprop) (m:mem) = H.intro_h_or_left p q (heap_of_mem m) let intro_h_or_right (p q: slprop) (m:mem) = H.intro_h_or_right p q (heap_of_mem m) let elim_h_or (p q: slprop) (m:mem) = H.elim_h_or p q (heap_of_mem m) let intro_wand (p1 p2: slprop u#a) (m:mem) = introduce (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)) ==> interp (wand p1 p2) m with _. ( assert (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)); H.intro_wand p1 p2 (heap_of_mem m); let h = heap_of_mem m in assert ((forall h1. h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) ==> H.interp (wand p1 p2) h); introduce forall h1. (h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) with ( introduce (h `H.disjoint` h1 /\ H.interp p1 h1) ==> H.interp p2 (H.join h h1) with _. ( assert (h `H.disjoint` h1); let m1 = { ctr = m.ctr; heap = h1; locks = m.locks } in assert (m `disjoint` m1) ) ) ) (** Eliminating a wand by proving a heap that satisfies the LHS **) let elim_wand (p1 p2: slprop u#a) (m:mem) (m1:mem) = H.elim_wand p1 p2 (heap_of_mem m) (heap_of_mem m1) //////////////////////////////////////////////////////////////////////////////// // Preorders and effects //////////////////////////////////////////////////////////////////////////////// module PP = Steel.Preorder let mem_evolves = fun (m0 m1:full_mem) -> H.heap_evolves (heap_of_mem m0) (heap_of_mem m1) /\ m0.ctr <= m1.ctr /\ lock_store_evolves m0.locks m1.locks (** See [Steel.Heap.is_frame_preserving]. We add in [lock_invariants] now *) let preserves_frame (e:inames) (pre post:slprop) (m0 m1:mem) = forall (frame:slprop). interp ((pre `star` frame) `star` locks_invariant e m0) m0 ==> (interp ((post `star` frame) `star` locks_invariant e m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) (** This is a version of MstTot with frame quantified, as part of preserves_frame *) effect MstTotNF (a:Type u#a) (except:inames) (expects:slprop u#1) (provides: a -> slprop u#1) = NMSTTotal.NMSTATETOT a (full_mem u#1) mem_evolves (requires fun m0 -> inames_ok except m0 /\ interp (expects `star` locks_invariant except m0) m0) (ensures fun m0 x m1 -> inames_ok except m1 /\ interp (provides x `star` locks_invariant except m1) m1 /\ preserves_frame except expects (provides x) m0 m1) //////////////////////////////////////////////////////////////////////////////// // Lifting heap actions //////////////////////////////////////////////////////////////////////////////// (** Heap actions come in two equivalent flavors: - one that take an explicit frame as argument (action_with_frame) - and one that quantify over all the frame We therefore define two lift routes: - a direct route for those with explicit frame - via MstTotNF for the rest *) let tot_pre_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = hmem_with_inv_except e fp -> (x:a & hmem_with_inv_except e (fp' x)) let tot_pre_action_nf = tot_pre_action_nf_except S.empty let ac_reasoning_for_m_frame_preserving (p q r:slprop u#a) (m:mem u#a) : Lemma (requires interp ((p `star` q) `star` r) m) (ensures interp (p `star` r) m) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_commutative p q; equiv_extensional_on_star (p `star` q) (q `star` p) r } (q `star` p) `star` r; (equiv) { star_associative q p r } q `star` (p `star` r); }; assert (interp (q `star` (p `star` r)) m); affine_star q (p `star` r) m let is_frame_preserving (#e:inames) (#a:Type u#b) (#fp:slprop u#a) (#fp':a -> slprop u#a) (f:tot_pre_action_nf_except e fp a fp') = forall (frame:slprop u#a) (m0:hmem_with_inv_except e (fp `star` frame)). (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = f:tot_pre_action_nf_except e fp a fp'{ is_frame_preserving f } let tot_action_nf = tot_action_nf_except S.empty let linv e (m:mem) = locks_invariant e m let hheap_of_hmem #fp #e (m:hmem_with_inv_except e fp) : h:H.hheap (fp `star` linv e m) { h `H.free_above_addr` m.ctr} = let h = heap_of_mem m in H.pure_interp (heap_ctr_valid m.ctr (heap_of_mem m)) h; h let hmem_of_hheap #e (#fp0 #fp1:slprop) (m:hmem_with_inv_except e fp0) (h:H.full_hheap (fp1 `star` linv e m) { h `Heap.free_above_addr` m.ctr }) : m1:hmem_with_inv_except e fp1{linv e m `equiv` linv e m1} = let m1 : mem = { m with heap = h } in assert (interp (fp1 `star` linv e m) m1); star_commutative fp1 (linv e m); assert (interp (linv e m `star` fp1) m1); assert (linv e m1 == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); assert (linv e m == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m)); H.pure_interp (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_of_mem m); assert (heap_ctr_valid m1.ctr (heap_of_mem m) <==> heap_ctr_valid m1.ctr (heap_of_mem m1)); H.pure_equiv (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_ctr_valid m1.ctr (heap_of_mem m1)); H.star_congruence (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m)); assert (linv e m `equiv` linv e m1); let _ = equiv_extensional_on_star (linv e m) (linv e m1) fp1 in assert ((linv e m `star` fp1) `equiv` (linv e m1 `star` fp1)); assert (interp (linv e m1 `star` fp1) m1); star_commutative (linv e m1) fp1; assert (interp (fp1 `star` linv e m1) m1); m1 let with_inv_except (m:mem) e (fp:slprop) = interp (fp `star` locks_invariant e m) m #push-options "--warn_error -271" let as_hprop (frame:slprop) (mp:mprop frame) : hp:H.hprop frame{forall m. mp (core_mem m) == hp (heap_of_mem m)} = let f = fun h -> mp (mem_of_heap h) in assert (forall m. mp (core_mem m) == f (heap_of_mem m)); let aux (m0:H.hheap frame) (m1:H.heap{H.disjoint m0 m1}) : Lemma (ensures (mem_of_heap (H.join m0 m1) == join (mem_of_heap m0) (mem_of_heap m1))) [SMTPat ()] = () in f let mprop_preservation_of_hprop_preservation (p:slprop) (m0 m1:mem) : Lemma (requires (forall (hp:H.hprop p). hp (heap_of_mem m0) == hp (heap_of_mem m1))) (ensures (forall (mp:mprop p). mp (core_mem m0) == mp (core_mem m1))) = let aux (mp:mprop p) : Lemma (mp (core_mem m0) == mp (core_mem m1)) [SMTPat()] = assert (as_hprop p mp (heap_of_mem m0) == as_hprop p mp (heap_of_mem m1)) in () let lift_heap_action (#fp:slprop) (#a:Type) (#fp':a -> slprop) (e:inames) ($f:H.action fp a fp') : tot_action_nf_except e fp a fp' = let g : tot_pre_action_nf_except e fp a fp' = fun m -> let h0 = hheap_of_hmem m in let (| x, h' |) = f h0 in (| x, hmem_of_hheap m h' |) in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in let h0 = hheap_of_hmem m0 in let (| x', h1 |) = f h0 in H.action_framing f (linv e m0) h0; assert (x == x'); star_associative fp frame (linv e m0); H.action_framing f (frame `star` linv e m0) h0; assert (H.interp ((fp' x) `star` (frame `star` linv e m0)) h1); star_associative (fp' x) frame (linv e m0); assert (H.interp ((fp' x `star` frame) `star` linv e m0) h1); let h1' : H.hheap ((fp' x `star` frame) `star` linv e m0) = h1 in assert (m1 == hmem_of_hheap m0 h1'); assert (with_inv_except m1 e (fp' x `star` frame)); assert (forall (hp:H.hprop frame). hp h0 == hp h1); mprop_preservation_of_hprop_preservation frame m0 m1; () in assert (is_frame_preserving g); g let frame_preserving_respects_preorder #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (m0:hmem_with_inv_except e fp) : Lemma (let (| x, m1 |) = f m0 in mem_evolves m0 m1) = let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1) = () in H.emp_unit fp; assert (interp (fp `star` linv e m0) m0); H.star_congruence (fp `star` emp) (linv e m0) fp (linv e m0); assert (interp ((fp `star` emp) `star` linv e m0) m0); aux emp m0 let lift_tot_action_nf #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') : MstTotNF a e fp fp' = let m0 = NMSTTotal.get () in let m0' : hmem_with_inv_except e fp = m0 in let r = f m0' in let (| x, m1 |) = r in let m1' : hmem_with_inv_except e (fp' x) = m1 in assert (is_frame_preserving f); assert (m1 == dsnd (f m0)); frame_preserving_respects_preorder f m0; NMSTTotal.put #_ #(mem_evolves) m1; x let lift_tot_action #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get #(full_mem) #_ () in ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); lift_tot_action_nf f (** Now defining the lift for heap actions with explicit frame *) let tot_action_with_frame_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = frame:slprop u#a -> m0:hmem_with_inv_except e (fp `star` frame) -> Pure (x:a & hmem_with_inv_except e (fp' x `star` frame)) (requires True) (ensures fun (| x, m1 |) -> mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_with_frame = tot_action_with_frame_except S.empty let lift_heap_action_with_frame (#fp:slprop u#a) (#a:Type u#b) (#fp':a -> slprop u#a) (e:inames) ($f:H.action_with_frame fp a fp') : tot_action_with_frame_except e fp a fp' = fun frame m0 -> let h0 = hheap_of_hmem m0 in calc (equiv) { fp `star` frame `star` locks_invariant e m0; (equiv) { star_associative fp frame (locks_invariant e m0) } fp `star` (frame `star` locks_invariant e m0); }; assert (H.interp (fp `star` frame `star` locks_invariant e m0) h0); assert (H.interp (fp `star` (frame `star` locks_invariant e m0)) h0); //key: apply the heap action with frame * locks_invariant e m0 let (| x, h1 |) = f (frame `star` locks_invariant e m0) h0 in calc (equiv) { fp' x `star` (frame `star` locks_invariant e m0); (equiv) { star_associative (fp' x) frame (locks_invariant e m0) } fp' x `star` frame `star` locks_invariant e m0; }; assert (H.interp (fp' x `star` (frame `star` locks_invariant e m0)) h1); assert (H.interp (fp' x `star` frame `star` locks_invariant e m0) h1); let m1 = hmem_of_hheap m0 h1 in assert (mem_evolves m0 m1); mprop_preservation_of_hprop_preservation (frame `star` locks_invariant e m0) m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)); (| x, m1 |) let lift_tot_action_with_frame #a #e #fp #fp' ($f:tot_action_with_frame_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in assert (inames_ok e m0); ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); let m0' : hmem_with_inv_except e fp = m0 in let r = f frame m0' in let (| x, m1 |) = r in ac_reasoning_for_m_frame_preserving (fp' x) frame (locks_invariant e m1) m1; assert (interp (fp' x `star` frame `star` locks_invariant e m1) m1); assert (interp (fp' x `star` locks_invariant e m1) m1); let m1' : hmem_with_inv_except e (fp' x) = m1 in NMSTTotal.put #_ #(mem_evolves) m1; x let sel_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.sel_action #a #pcm r v0)) let upd_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.upd_action #a #pcm r v0 v1)) let free_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.free_action #a #pcm r v0)) let split_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.split_action #a #pcm r v0 v1)) let gather_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.gather_action #a #pcm r v0 v1)) let weaken (p q r:slprop) (h:H.hheap (p `star` q) { H.stronger q r }) : H.hheap (p `star` r) = H.weaken p q r h; h let weaken_pure (q r: prop) : Lemma (requires (q ==> r)) (ensures H.stronger (H.pure q) (H.pure r)) = let aux (h:H.heap) : Lemma (ensures (H.interp (H.pure q) h ==> H.interp (H.pure r) h)) [SMTPat ()] = H.pure_interp q h; H.pure_interp r h in () let inc_ctr (#p:slprop) #e (m:hmem_with_inv_except e p) : m':hmem_with_inv_except e p{m'.ctr = m.ctr + 1 /\ H.stronger (linv e m) (linv e m')} = let m' : mem = { m with ctr = m.ctr + 1} in assert (interp (p `star` linv e m) m'); assert (linv e m == lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m)); assert (linv e m' == lock_store_invariant e m.locks `star` ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken_free_above (heap_of_mem m) m.ctr (m.ctr + 1); weaken_pure (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_ctr_valid (m.ctr + 1) (heap_of_mem m)); assert (H.stronger (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m))); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)); H.stronger_star (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken (p `star` lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)) (heap_of_mem m'); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity (m.ctr + 1) (heap_of_mem m)); let m' : hmem_with_inv_except e p = m' in m' let frame_related_mems (fp0 fp1:slprop u#a) e (m0:hmem_with_inv_except e fp0) (m1:hmem_with_inv_except e fp1) = forall (frame:slprop u#a). interp ((fp0 `star` frame) `star` linv e m0) m0 ==> interp ((fp1 `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) let refined_pre_action e (fp0:slprop) (a:Type) (fp1:a -> slprop) = m0:hmem_with_inv_except e fp0 -> Pure (x:a & hmem_with_inv_except e (fp1 x)) (requires True) (ensures fun (| x, m1 |) -> frame_related_mems fp0 (fp1 x) e m0 m1) let refined_pre_action_as_action (#fp0:slprop) (#a:Type) (#fp1:a -> slprop) #e ($f:refined_pre_action e fp0 a fp1) : tot_action_nf_except e fp0 a fp1 = let g : tot_pre_action_nf_except e fp0 a fp1 = fun m -> f m in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp0 `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp1 x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x', m1' |) = g m0 in let (| x, m1 |) = f m0 in assert (x == x' /\ m1 == m1') in g let alloc_action #a #pcm e x = let f : refined_pre_action e emp (ref a pcm) (fun r -> pts_to r x) = fun m0 -> (* NS: 9/29/22 I needed to annotate h : Heap.full_heap, for use with the Core checker which generates a guard for checking the implicit pattern "dot" term in the dependent pair pattern on the next line. That guard expects `h` to be a full_heap, which is it, because it is a projection of m0. However, this is not reflected in `h`'s type. So, the Core checker, which produces a guard for the pat_dot_term in isolation, cannot recheck the term. If we were to fold in the checking of pat_dot_terms and their guards with the rest of the VC, this would work. *) let h : Heap.full_heap = hheap_of_hmem m0 in let (|r, h'|) = H.extend #a #pcm x m0.ctr h in let m' : hmem_with_inv_except e emp = inc_ctr m0 in let h' : H.hheap (pts_to #a #pcm r x `star` linv e m') = weaken _ (linv e m0) (linv e m') h' in let m1 : hmem_with_inv_except e (pts_to #a #pcm r x) = hmem_of_hheap m' h' in assert (forall frame. H.frame_related_heaps h h' emp (pts_to #a #pcm r x) frame true); let aux (frame:slprop) : Lemma (requires interp ((emp `star` frame) `star` linv e m0) m0) (ensures interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) [SMTPat (emp `star` frame)] = star_associative emp frame (linv e m0); assert (H.interp (emp `star` (frame `star` linv e m0)) h); assert (H.interp (pts_to #a #pcm r x `star` (frame `star` linv e m0)) h'); star_associative (pts_to #a #pcm r x) frame (linv e m0); assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m0) h'); assert (H.stronger (linv e m0) (linv e m')); assert (H.equiv (linv e m') (linv e m1)); assert (H.stronger (linv e m0) (linv e m1)); let h' : H.hheap ((pts_to #a #pcm r x `star` frame) `star` linv e m1) = weaken _ (linv e m0) (linv e m1) h' in assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) h'); assert (forall (mp:H.hprop frame). mp h == mp h'); mprop_preservation_of_hprop_preservation frame m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) in assert (frame_related_mems emp (pts_to r x) e m0 m1); (| r, m1 |) in lift_tot_action (refined_pre_action_as_action f) let select_refine #a #p e r x f = lift_tot_action (lift_heap_action e (H.select_refine #a #p r x f)) let upd_gen #a #p e r x y f = lift_tot_action (lift_heap_action e (H.upd_gen_action r x y f)) //////////////////////////////////////////////////////////////////////////////// // witness / recall //////////////////////////////////////////////////////////////////////////////// let witnessed_ref #a #pcm (r:ref a pcm) (fact:property a) (m:full_mem) = H.witnessed_ref #a #pcm r fact (heap_of_mem m) let witnessed_ref_stability #a #pcm (r:ref a pcm) (fact:property a) : Lemma (requires FStar.Preorder.stable fact (Steel.Preorder.preorder_of_pcm pcm)) (ensures FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) = H.witnessed_ref_stability #a #pcm r fact let witnessed (#a:Type u#1) (#pcm:pcm a) (r:ref a pcm) (fact:property a) = W.witnessed _ mem_evolves (witnessed_ref r fact) let rearrange_pqr_prq (p q r:slprop) : Lemma (((p `star` q) `star` r) `equiv` ((p `star` r) `star` q)) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_associative p q r } p `star` (q `star` r); (equiv) { star_commutative q r; star_congruence p (q `star` r) p (r `star` q) } p `star` (r `star` q); (equiv) { star_associative p r q } (p `star` r) `star` q; } let preserves_frame_cong (e:inames) (p q:slprop) (r s:slprop) (m0 m1:mem) : Lemma (requires p `equiv` r /\ q `equiv` s /\ preserves_frame e p q m0 m1) (ensures preserves_frame e r s m0 m1) = let aux0 (p q r s:slprop) : Lemma (requires p `equiv` s) (ensures (((p `star` q) `star` r) `equiv` ((s `star` q) `star` r))) = star_congruence p q s q; star_congruence (p `star` q) r (s `star` q) r in let aux (frame:slprop) : Lemma (requires interp ((r `star` frame) `star` locks_invariant e m0) m0) (ensures interp ((s `star` frame) `star` locks_invariant e m1) m1 /\ interp ((p `star` frame) `star` locks_invariant e m0) m0) [SMTPat (r `star` frame)] = aux0 p frame (locks_invariant e m0) r; aux0 q frame (locks_invariant e m1) s; assert (((p `star` frame) `star` locks_invariant e m0) `equiv` ((r `star` frame) `star` locks_invariant e m0)); assert (interp ((p `star` frame) `star` locks_invariant e m0) m0); assert (interp ((q `star` frame) `star` locks_invariant e m1) m1); assert (((q `star` frame) `star` locks_invariant e m1) `equiv` ((s `star` frame) `star` locks_invariant e m1)); () in () let pure_true_equiv (p:slprop) : Lemma ((p `star` pure True) `equiv` p) = FStar.Classical.forall_intro (pure_star_interp p True); emp_unit p; assert ((p `star` pure True) `equiv` p) let preserves_frame_star_pure (e:inames) (p q:slprop) (r s:prop) (m:mem) : Lemma (requires r /\ s) (ensures preserves_frame e p q m m <==> preserves_frame e (p `star` pure r) (q `star` pure s) m m) = pure_equiv r True; star_congruence p (pure r) p (pure True); pure_equiv s True; star_congruence q (pure s) q (pure True); pure_true_equiv p; pure_true_equiv q; let fwd () : Lemma (requires preserves_frame e p q m m) (ensures preserves_frame e (p `star` pure r) (q `star` pure s) m m) [SMTPat ()] = preserves_frame_cong e p q (p `star` pure r) (q `star` pure s) m m in let bk () : Lemma (requires preserves_frame e (p `star` pure r) (q `star` pure s) m m) (ensures preserves_frame e p q m m) [SMTPat ()] = preserves_frame_cong e (p `star` pure r) (q `star` pure s) p q m m in ()

{ "checked_file": "/", "dependencies": [ "Steel.Preorder.fst.checked", "Steel.Heap.fsti.checked", "prims.fst.checked", "FStar.Witnessed.Core.fsti.checked", "FStar.Set.fsti.checked", "FStar.Preorder.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.PCM.fst.checked", "FStar.NMSTTotal.fst.checked", "FStar.List.Tot.fst.checked", "FStar.IndefiniteDescription.fsti.checked", "FStar.Ghost.fsti.checked", "FStar.FunctionalExtensionality.fsti.checked", "FStar.Classical.Sugar.fsti.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Steel.Memory.fst" }

[ { "abbrev": true, "full_module": "Steel.Preorder", "short_module": "PP" }, { "abbrev": true, "full_module": "FStar.Witnessed.Core", "short_module": "W" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": true, "full_module": "Steel.Heap", "short_module": "H" }, { "abbrev": false, "full_module": "FStar.FunctionalExtensionality", "short_module": null }, { "abbrev": true, "full_module": "FStar.FunctionalExtensionality", "short_module": "F" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": false, "full_module": "FStar.PCM", "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

e: Steel.Memory.inames -> r: FStar.Ghost.erased (Steel.Memory.ref a pcm) -> fact: Steel.Memory.stable_property pcm -> v: FStar.Ghost.erased a -> _: Prims.squash (forall (z: a). FStar.PCM.compatible pcm (FStar.Ghost.reveal v) z ==> fact z) -> Steel.Memory.action_except (Steel.Memory.witnessed (FStar.Ghost.reveal r) fact) e (Steel.Memory.pts_to (FStar.Ghost.reveal r) (FStar.Ghost.reveal v)) (fun _ -> Steel.Memory.pts_to (FStar.Ghost.reveal r) (FStar.Ghost.reveal v))

Prims.Tot

[ "total" ]

[]

[ "FStar.PCM.pcm", "Steel.Memory.inames", "FStar.Ghost.erased", "Steel.Memory.ref", "Steel.Memory.stable_property", "Prims.squash", "Prims.l_Forall", "Prims.l_imp", "FStar.PCM.compatible", "FStar.Ghost.reveal", "Steel.Memory.slprop", "Steel.Memory.witnessed", "FStar.Witnessed.Core.witnessed", "Steel.Memory.full_mem", "Steel.Memory.mem_evolves", "Steel.Memory.witnessed_ref", "FStar.NMSTTotal.witness", "Prims.unit", "Prims._assert", "FStar.Preorder.stable", "Steel.Memory.witnessed_ref_stability", "Prims.l_and", "Steel.Memory.interp", "Steel.Heap.ptr", "Prims.eq2", "Steel.Heap.sel", "Steel.Memory.heap_of_mem", "FStar.PCM.__proj__Mkpcm__item__refine", "Steel.Heap.interp", "Steel.Heap.sel_v", "Steel.Heap.ref", "FStar.NMSTTotal.get", "Steel.Memory.pts_to", "Steel.Memory.mem", "Prims.l_True", "Prims.prop" ]

[]

false

let witness (#a: Type) (#pcm: pcm a) (e: inames) (r: erased (ref a pcm)) (fact: stable_property pcm) (v: Ghost.erased a) (_: squash (forall z. compatible pcm v z ==> fact z)) (frame: slprop) : MstTot (witnessed r fact) e (pts_to r v) (fun _ -> pts_to r v) frame (fun _ -> True) (fun _ _ _ -> True) =

let m0 = NMSTTotal.get () in let _:unit = let hr:H.ref a pcm = r in let v' = H.sel_v hr v (heap_of_mem m0) in assert (interp (H.ptr hr) m0 /\ H.sel #a #pcm hr (heap_of_mem m0) == v'); assert (compatible pcm v v'); assert (fact v'); assert (witnessed_ref r fact m0); witnessed_ref_stability r fact; assert (FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) in let w = NMSTTotal.witness _ mem_evolves (witnessed_ref r fact) in w

false

Steel.Memory.fst

Steel.Memory.equiv_ext_right

val equiv_ext_right (p q r: slprop) : Lemma (requires q `equiv` r) (ensures (p `star` q) `equiv` (p `star` r))

let equiv_ext_right (p q r:slprop) : Lemma (requires q `equiv` r) (ensures (p `star` q) `equiv` (p `star` r)) = calc (equiv) { p `star` q; (equiv) { star_commutative p q } q `star` p; (equiv) { equiv_extensional_on_star q r p } r `star` p; (equiv) { star_commutative p r } p `star` r; }

{ "file_name": "lib/steel/Steel.Memory.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 5, "end_line": 1386, "start_col": 0, "start_line": 1374 }

(* 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.Memory module F = FStar.FunctionalExtensionality open FStar.FunctionalExtensionality open FStar.PCM module H = Steel.Heap noeq type lock_state : Type u#(a + 1) = | Invariant : inv:H.slprop u#a -> lock_state let lock_store : Type u#(a+1) = list (lock_state u#a) noeq type mem : Type u#(a + 1) = { ctr: nat; heap: H.heap u#a; locks: lock_store u#a; } let heap_of_mem (x:mem) : H.heap = x.heap let mem_of_heap (h:H.heap) : mem = { ctr = 0; heap = h; locks = [] } let mem_set_heap (m:mem) (h:H.heap) : mem = { ctr = m.ctr; heap = h; locks = m.locks; } let core_mem (m:mem) : mem = mem_of_heap (heap_of_mem m) let core_mem_invol m = () let disjoint (m0 m1:mem u#h) : prop = m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks let disjoint_sym m0 m1 = () let join m0 m1 = { ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = m0.locks } let join_commutative m0 m1 = H.join_commutative m0.heap m1.heap let disjoint_join m0 m1 m2 = H.disjoint_join m0.heap m1.heap m2.heap let join_associative m0 m1 m2 = H.join_associative m0.heap m1.heap m2.heap let slprop = H.slprop let interp p m = H.interp p m.heap let equiv p1 p2 = forall m. interp p1 m <==> interp p2 m let slprop_extensionality p q = assert (forall m. interp p m <==> interp q m); let aux (h:H.heap) : Lemma (H.interp p h <==> H.interp q h) [SMTPat (H.interp p h)] = let m : mem = { ctr = 0; heap = h; locks = [] } in assert (interp p m <==> interp q m) in assert (forall h. H.interp p h <==> H.interp q h); Steel.Heap.slprop_extensionality p q let reveal_equiv p1 p2 = () let core_ref = H.core_ref let core_ref_null = H.core_ref_null let core_ref_is_null r = H.core_ref_is_null r let emp : slprop u#a = H.emp let pure = H.pure let pts_to = H.pts_to let h_and = H.h_and let h_or = H.h_or let star = H.star let wand = H.wand let h_exists = H.h_exists let h_forall = H.h_forall //////////////////////////////////////////////////////////////////////////////// //properties of equiv //////////////////////////////////////////////////////////////////////////////// let equiv_symmetric (p1 p2:slprop u#a) = H.equiv_symmetric p1 p2 #push-options "--warn_error -271" let equiv_heap_iff_equiv (p1 p2:slprop u#a) : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat (equiv p1 p2)] = let aux_lr () : Lemma (requires H.equiv p1 p2) (ensures equiv p1 p2) [SMTPat ()] = () in let aux_rl_helper1 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p1 h) (ensures H.interp p2 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl_helper2 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p2 h) (ensures H.interp p1 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl () : Lemma (requires equiv p1 p2) (ensures H.equiv p1 p2) [SMTPat ()] = () in () let equiv_heap_iff_equiv_forall () : Lemma (ensures (forall p1 p2. H.equiv p1 p2 <==> equiv p1 p2)) = let aux p1 p2 : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat ()] = equiv_heap_iff_equiv p1 p2 in () #pop-options let equiv_extensional_on_star (p1 p2 p3:slprop u#a) = equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3 let emp_unit p = H.emp_unit p let intro_emp m = H.intro_emp (heap_of_mem m) let pure_equiv p q = H.pure_equiv p q let pure_interp q m = H.pure_interp q (heap_of_mem m) let pure_star_interp p q m = H.pure_star_interp p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// //pts_to //////////////////////////////////////////////////////////////////////////////// let pts_to_compatible #a #pcm x v0 v1 m = H.pts_to_compatible #a #pcm x v0 v1 (heap_of_mem m) let pts_to_compatible_equiv #a #pcm x v0 v1 = H.pts_to_compatible_equiv #a #pcm x v0 v1 let pts_to_not_null #a #pcm x v m = H.pts_to_not_null #a #pcm x v (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // star //////////////////////////////////////////////////////////////////////////////// let intro_star p q mp mq = H.intro_star p q (heap_of_mem mp) (heap_of_mem mq) let elim_star p q m = let h = heap_of_mem m in H.elim_star p q h; assert (exists hl hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr); let hl = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hl -> exists hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let hr = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hr -> H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let ml = mem_set_heap m hl in let mr = mem_set_heap m hr in assert (disjoint ml mr); assert (m == join ml mr); assert (interp p ml); assert (interp q mr); () let interp_star (p q: slprop) (m: mem) : Lemma (interp (p `star` q) m <==> (exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m)) = let left = interp (p `star` q) m in let right = exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m in let f () : Lemma (requires left) (ensures right) = elim_star p q m in let g () : Lemma (requires right) (ensures left) = Classical.exists_elim left #_ #(fun mp -> exists (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mp -> Classical.exists_elim left #_ #(fun mq -> disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mq -> intro_star p q mp mq ) ) in Classical.move_requires f (); Classical.move_requires g () let star_commutative (p1 p2:slprop) = H.star_commutative p1 p2 let star_associative (p1 p2 p3:slprop) = H.star_associative p1 p2 p3 let star_congruence (p1 p2 p3 p4:slprop) = equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4 let affine_star (p q:slprop) (m:mem) = H.affine_star p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // Invariants on the lock store //////////////////////////////////////////////////////////////////////////////// let iname = nat module S = FStar.Set module L = FStar.List.Tot module W = FStar.Witnessed.Core let rec lock_store_invariant (e:inames) (l:lock_store u#a) : slprop u#a = let current_addr = L.length l - 1 in match l with | [] -> emp | Invariant p :: tl -> if current_addr `S.mem` e then lock_store_invariant e tl else p `star` lock_store_invariant e tl let lock_i (i:iname) (l:lock_store { i < L.length l }) = let ix = L.length l - i - 1 in L.index l ix let iname_for_p (i:iname) (p:slprop) : W.s_predicate lock_store = fun l -> i < L.length l /\ (lock_i i l).inv == p let lock_store_evolves : FStar.Preorder.preorder lock_store = fun (l1 l2 : lock_store) -> L.length l2 >= L.length l1 /\ (forall (i:nat{i < L.length l1}). (lock_i i l1).inv == (lock_i i l2).inv) let inames_in (e:inames) (l:lock_store) : prop = forall i. Set.mem i e ==> i < L.length l let inames_ok e m = inames_in e m.locks let inames_ok_empty m = () let extend_lock_store (e:inames) (l:lock_store{e `inames_in` l}) (p:slprop) : i:iname & l':lock_store { lock_store_invariant e l' == p `star` lock_store_invariant e l /\ iname_for_p i p l' } = (| L.length l, Invariant p :: l |) let set_add (i:iname) (s:inames) = Set.union (Set.singleton i) s let rec move_invariant (e:inames) (l:lock_store) (p:slprop) (i:iname{iname_for_p i p l /\ ~(i `Set.mem` e)}) : Lemma (H.equiv (lock_store_invariant e l) (p `star` lock_store_invariant (set_add i e) l)) = let rec aux (i:iname) (m:lock_store) : Lemma (requires i >= L.length m) (ensures (lock_store_invariant e m `H.equiv` lock_store_invariant (set_add i e) m)) = match m with | [] -> () | Invariant p::tl -> aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl) in let current_addr = L.length l - 1 in match l with | [] -> () | Invariant q::tl -> if i = current_addr then begin assert (lock_store_invariant e l == p `star` lock_store_invariant e tl); aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl); () end else begin move_invariant e tl p i; assert (lock_store_invariant e tl `equiv` (p `star` lock_store_invariant (set_add i e) tl)); H.star_congruence q (lock_store_invariant e tl) q (p `star` lock_store_invariant (set_add i e) tl); if Set.mem current_addr e then () else begin let r = lock_store_invariant (set_add i e) tl in assert (lock_store_invariant e l `equiv` (q `star` (p `star` r))); H.star_associative q p r; H.star_commutative q p; H.star_congruence (q `star` p) r (p `star` q) r; H.star_associative p q r end end let heap_ctr_valid (ctr:nat) (h:H.heap u#a) : prop = h `H.free_above_addr` ctr let ctr_validity (ctr:nat) (h:H.heap) : slprop = H.pure (heap_ctr_valid ctr h) let locks_invariant (e:inames) (m:mem u#a) : slprop u#a = lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m) let full_mem_pred (m:mem) = H.full_heap_pred (heap_of_mem m) (***** Following lemmas are needed in Steel.Effect *****) let core_mem_interp (hp:slprop u#a) (m:mem u#a) = () let interp_depends_only_on (hp:slprop u#a) = H.interp_depends_only_on hp let a_mem_prop_as_a_heap_prop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (H.a_heap_prop u#a) = let g (h: H.heap u#a) : Tot prop = interp sl (mem_of_heap h) /\ f (mem_of_heap h) in let phi0 (h0 h1: H.heap u#a) : Lemma (requires (g h0 /\ H.disjoint h0 h1)) (ensures (g h0 /\ H.disjoint h0 h1 /\ g (H.join h0 h1))) = assert (mem_of_heap (H.join h0 h1) == mem_of_heap h0 `join` mem_of_heap h1); interp_depends_only_on sl in let phi1 (h0 h1: H.heap u#a) : Lemma (ensures ((g h0 /\ H.disjoint h0 h1) ==> g (H.join h0 h1))) = Classical.move_requires (phi0 h0) h1 in Classical.forall_intro_2 phi1; g let refine_slprop sl f = H.as_slprop (a_mem_prop_as_a_heap_prop sl f) let interp_refine_slprop sl f m = assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_mem m)) let dep_hprop (s: slprop) (f: (hmem s -> Tot slprop)) (h: H.heap) : Tot prop = exists (h1: H.heap) . exists (h2: H.heap) . interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 let dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq' : squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h')) = let p2 (h h1 h2: H.heap) : Tot prop = interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 in let p1 (h h1: H.heap) : Tot prop = (exists h2 . p2 h h1 h2) in let h1 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p1 h) in let h2 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p2 h h1) in H.disjoint_join h' h1 h2; assert (H.disjoint h2 h'); let h2' = H.join h2 h' in H.join_commutative h2 h' ; assert (h2' == H.join h' h2); assert (H.disjoint h1 h2'); assert (mem_of_heap h2' == mem_of_heap h2 `join` mem_of_heap h'); interp_depends_only_on (f (mem_of_heap h1)); assert (interp (f (mem_of_heap h1)) (mem_of_heap h2')); H.join_commutative h1 h2; H.join_associative h' h2 h1; H.join_commutative h' h; H.join_commutative h2' h1; assert (H.join h h' == h1 `H.join` h2') let impl_intro_gen (#p: Type0) (#q: Type0) ($prf: (squash p -> Lemma (q ))) : Lemma (p ==> q) = Classical.impl_intro_gen #p #(fun _ -> q) prf let dep_hprop_is_affine1 (s: slprop) (f: (hmem s -> Tot slprop)) (h0 h1: H.heap) : Lemma ((dep_hprop s f h0 /\ H.disjoint h0 h1) ==> (H.disjoint h0 h1 /\ dep_hprop s f (H.join h0 h1))) = impl_intro_gen (dep_hprop_is_affine0 s f h0 h1) let dep_hprop_is_affine (s: slprop) (f: (hmem s -> Tot slprop)) : Lemma (H.heap_prop_is_affine (dep_hprop s f)) = Classical.forall_intro_2 (dep_hprop_is_affine1 s f) let sdep (s: slprop) (f: (hmem s -> Tot slprop)) : Tot slprop = dep_hprop_is_affine s f; H.as_slprop (dep_hprop s f) let interp_sdep (s: slprop) (f: (hmem s -> Tot slprop)) (m: mem) : Lemma (requires (dep_slprop_is_affine s f)) (ensures ( interp (sdep s f) m <==> (exists m1 m2 . interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) )) = dep_hprop_is_affine s f; assert (forall m1 m2 . (interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) ==> ( interp s (mem_of_heap m1.heap) /\ interp (f (mem_of_heap m1.heap)) (mem_of_heap m2.heap) /\ H.disjoint m1.heap m2.heap /\ H.join m1.heap m2.heap == m.heap )); interp_depends_only_on s; Classical.forall_intro (fun m -> interp_depends_only_on (f m)); assert (forall h1 h2 . (interp s (mem_of_heap h1) /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ H.disjoint h1 h2 /\ H.join h1 h2 == m.heap) ==> ( core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ interp s (core_mem (mem_of_heap h1)) /\ interp s (mem_set_heap m h1) /\ core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ f (mem_set_heap m h1) `equiv` f (mem_of_heap h1) /\ interp (f (mem_set_heap m h1)) (mem_of_heap h2) /\ interp (f (mem_set_heap m h1)) (mem_set_heap m h2) /\ disjoint (mem_set_heap m h1) (mem_set_heap m h2) /\ join (mem_set_heap m h1) (mem_set_heap m h2) == m )); () let h_exists_cong (#a:Type) (p q : a -> slprop) : Lemma (requires (forall x. p x `equiv` q x)) (ensures (h_exists p `equiv` h_exists q)) = equiv_heap_iff_equiv_forall (); H.h_exists_cong p q let intro_h_exists #a x p m = H.intro_h_exists x p (heap_of_mem m) let elim_h_exists (#a:_) (p:a -> slprop) (m:mem) = H.elim_h_exists p (heap_of_mem m) let intro_h_forall (#a:_) (p:a -> slprop) (m:mem) = H.intro_h_forall p (heap_of_mem m) let elim_h_forall (#a:_) (p:a -> slprop) (m:mem) (x:a) = H.elim_h_forall p (heap_of_mem m) x let intro_h_and (p q: slprop) (m:mem) = H.intro_h_and p q (heap_of_mem m) let elim_h_and (p q: slprop) (m:mem) = H.elim_h_and p q (heap_of_mem m) let intro_h_or_left (p q: slprop) (m:mem) = H.intro_h_or_left p q (heap_of_mem m) let intro_h_or_right (p q: slprop) (m:mem) = H.intro_h_or_right p q (heap_of_mem m) let elim_h_or (p q: slprop) (m:mem) = H.elim_h_or p q (heap_of_mem m) let intro_wand (p1 p2: slprop u#a) (m:mem) = introduce (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)) ==> interp (wand p1 p2) m with _. ( assert (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)); H.intro_wand p1 p2 (heap_of_mem m); let h = heap_of_mem m in assert ((forall h1. h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) ==> H.interp (wand p1 p2) h); introduce forall h1. (h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) with ( introduce (h `H.disjoint` h1 /\ H.interp p1 h1) ==> H.interp p2 (H.join h h1) with _. ( assert (h `H.disjoint` h1); let m1 = { ctr = m.ctr; heap = h1; locks = m.locks } in assert (m `disjoint` m1) ) ) ) (** Eliminating a wand by proving a heap that satisfies the LHS **) let elim_wand (p1 p2: slprop u#a) (m:mem) (m1:mem) = H.elim_wand p1 p2 (heap_of_mem m) (heap_of_mem m1) //////////////////////////////////////////////////////////////////////////////// // Preorders and effects //////////////////////////////////////////////////////////////////////////////// module PP = Steel.Preorder let mem_evolves = fun (m0 m1:full_mem) -> H.heap_evolves (heap_of_mem m0) (heap_of_mem m1) /\ m0.ctr <= m1.ctr /\ lock_store_evolves m0.locks m1.locks (** See [Steel.Heap.is_frame_preserving]. We add in [lock_invariants] now *) let preserves_frame (e:inames) (pre post:slprop) (m0 m1:mem) = forall (frame:slprop). interp ((pre `star` frame) `star` locks_invariant e m0) m0 ==> (interp ((post `star` frame) `star` locks_invariant e m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) (** This is a version of MstTot with frame quantified, as part of preserves_frame *) effect MstTotNF (a:Type u#a) (except:inames) (expects:slprop u#1) (provides: a -> slprop u#1) = NMSTTotal.NMSTATETOT a (full_mem u#1) mem_evolves (requires fun m0 -> inames_ok except m0 /\ interp (expects `star` locks_invariant except m0) m0) (ensures fun m0 x m1 -> inames_ok except m1 /\ interp (provides x `star` locks_invariant except m1) m1 /\ preserves_frame except expects (provides x) m0 m1) //////////////////////////////////////////////////////////////////////////////// // Lifting heap actions //////////////////////////////////////////////////////////////////////////////// (** Heap actions come in two equivalent flavors: - one that take an explicit frame as argument (action_with_frame) - and one that quantify over all the frame We therefore define two lift routes: - a direct route for those with explicit frame - via MstTotNF for the rest *) let tot_pre_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = hmem_with_inv_except e fp -> (x:a & hmem_with_inv_except e (fp' x)) let tot_pre_action_nf = tot_pre_action_nf_except S.empty let ac_reasoning_for_m_frame_preserving (p q r:slprop u#a) (m:mem u#a) : Lemma (requires interp ((p `star` q) `star` r) m) (ensures interp (p `star` r) m) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_commutative p q; equiv_extensional_on_star (p `star` q) (q `star` p) r } (q `star` p) `star` r; (equiv) { star_associative q p r } q `star` (p `star` r); }; assert (interp (q `star` (p `star` r)) m); affine_star q (p `star` r) m let is_frame_preserving (#e:inames) (#a:Type u#b) (#fp:slprop u#a) (#fp':a -> slprop u#a) (f:tot_pre_action_nf_except e fp a fp') = forall (frame:slprop u#a) (m0:hmem_with_inv_except e (fp `star` frame)). (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = f:tot_pre_action_nf_except e fp a fp'{ is_frame_preserving f } let tot_action_nf = tot_action_nf_except S.empty let linv e (m:mem) = locks_invariant e m let hheap_of_hmem #fp #e (m:hmem_with_inv_except e fp) : h:H.hheap (fp `star` linv e m) { h `H.free_above_addr` m.ctr} = let h = heap_of_mem m in H.pure_interp (heap_ctr_valid m.ctr (heap_of_mem m)) h; h let hmem_of_hheap #e (#fp0 #fp1:slprop) (m:hmem_with_inv_except e fp0) (h:H.full_hheap (fp1 `star` linv e m) { h `Heap.free_above_addr` m.ctr }) : m1:hmem_with_inv_except e fp1{linv e m `equiv` linv e m1} = let m1 : mem = { m with heap = h } in assert (interp (fp1 `star` linv e m) m1); star_commutative fp1 (linv e m); assert (interp (linv e m `star` fp1) m1); assert (linv e m1 == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); assert (linv e m == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m)); H.pure_interp (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_of_mem m); assert (heap_ctr_valid m1.ctr (heap_of_mem m) <==> heap_ctr_valid m1.ctr (heap_of_mem m1)); H.pure_equiv (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_ctr_valid m1.ctr (heap_of_mem m1)); H.star_congruence (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m)); assert (linv e m `equiv` linv e m1); let _ = equiv_extensional_on_star (linv e m) (linv e m1) fp1 in assert ((linv e m `star` fp1) `equiv` (linv e m1 `star` fp1)); assert (interp (linv e m1 `star` fp1) m1); star_commutative (linv e m1) fp1; assert (interp (fp1 `star` linv e m1) m1); m1 let with_inv_except (m:mem) e (fp:slprop) = interp (fp `star` locks_invariant e m) m #push-options "--warn_error -271" let as_hprop (frame:slprop) (mp:mprop frame) : hp:H.hprop frame{forall m. mp (core_mem m) == hp (heap_of_mem m)} = let f = fun h -> mp (mem_of_heap h) in assert (forall m. mp (core_mem m) == f (heap_of_mem m)); let aux (m0:H.hheap frame) (m1:H.heap{H.disjoint m0 m1}) : Lemma (ensures (mem_of_heap (H.join m0 m1) == join (mem_of_heap m0) (mem_of_heap m1))) [SMTPat ()] = () in f let mprop_preservation_of_hprop_preservation (p:slprop) (m0 m1:mem) : Lemma (requires (forall (hp:H.hprop p). hp (heap_of_mem m0) == hp (heap_of_mem m1))) (ensures (forall (mp:mprop p). mp (core_mem m0) == mp (core_mem m1))) = let aux (mp:mprop p) : Lemma (mp (core_mem m0) == mp (core_mem m1)) [SMTPat()] = assert (as_hprop p mp (heap_of_mem m0) == as_hprop p mp (heap_of_mem m1)) in () let lift_heap_action (#fp:slprop) (#a:Type) (#fp':a -> slprop) (e:inames) ($f:H.action fp a fp') : tot_action_nf_except e fp a fp' = let g : tot_pre_action_nf_except e fp a fp' = fun m -> let h0 = hheap_of_hmem m in let (| x, h' |) = f h0 in (| x, hmem_of_hheap m h' |) in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in let h0 = hheap_of_hmem m0 in let (| x', h1 |) = f h0 in H.action_framing f (linv e m0) h0; assert (x == x'); star_associative fp frame (linv e m0); H.action_framing f (frame `star` linv e m0) h0; assert (H.interp ((fp' x) `star` (frame `star` linv e m0)) h1); star_associative (fp' x) frame (linv e m0); assert (H.interp ((fp' x `star` frame) `star` linv e m0) h1); let h1' : H.hheap ((fp' x `star` frame) `star` linv e m0) = h1 in assert (m1 == hmem_of_hheap m0 h1'); assert (with_inv_except m1 e (fp' x `star` frame)); assert (forall (hp:H.hprop frame). hp h0 == hp h1); mprop_preservation_of_hprop_preservation frame m0 m1; () in assert (is_frame_preserving g); g let frame_preserving_respects_preorder #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (m0:hmem_with_inv_except e fp) : Lemma (let (| x, m1 |) = f m0 in mem_evolves m0 m1) = let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1) = () in H.emp_unit fp; assert (interp (fp `star` linv e m0) m0); H.star_congruence (fp `star` emp) (linv e m0) fp (linv e m0); assert (interp ((fp `star` emp) `star` linv e m0) m0); aux emp m0 let lift_tot_action_nf #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') : MstTotNF a e fp fp' = let m0 = NMSTTotal.get () in let m0' : hmem_with_inv_except e fp = m0 in let r = f m0' in let (| x, m1 |) = r in let m1' : hmem_with_inv_except e (fp' x) = m1 in assert (is_frame_preserving f); assert (m1 == dsnd (f m0)); frame_preserving_respects_preorder f m0; NMSTTotal.put #_ #(mem_evolves) m1; x let lift_tot_action #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get #(full_mem) #_ () in ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); lift_tot_action_nf f (** Now defining the lift for heap actions with explicit frame *) let tot_action_with_frame_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = frame:slprop u#a -> m0:hmem_with_inv_except e (fp `star` frame) -> Pure (x:a & hmem_with_inv_except e (fp' x `star` frame)) (requires True) (ensures fun (| x, m1 |) -> mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_with_frame = tot_action_with_frame_except S.empty let lift_heap_action_with_frame (#fp:slprop u#a) (#a:Type u#b) (#fp':a -> slprop u#a) (e:inames) ($f:H.action_with_frame fp a fp') : tot_action_with_frame_except e fp a fp' = fun frame m0 -> let h0 = hheap_of_hmem m0 in calc (equiv) { fp `star` frame `star` locks_invariant e m0; (equiv) { star_associative fp frame (locks_invariant e m0) } fp `star` (frame `star` locks_invariant e m0); }; assert (H.interp (fp `star` frame `star` locks_invariant e m0) h0); assert (H.interp (fp `star` (frame `star` locks_invariant e m0)) h0); //key: apply the heap action with frame * locks_invariant e m0 let (| x, h1 |) = f (frame `star` locks_invariant e m0) h0 in calc (equiv) { fp' x `star` (frame `star` locks_invariant e m0); (equiv) { star_associative (fp' x) frame (locks_invariant e m0) } fp' x `star` frame `star` locks_invariant e m0; }; assert (H.interp (fp' x `star` (frame `star` locks_invariant e m0)) h1); assert (H.interp (fp' x `star` frame `star` locks_invariant e m0) h1); let m1 = hmem_of_hheap m0 h1 in assert (mem_evolves m0 m1); mprop_preservation_of_hprop_preservation (frame `star` locks_invariant e m0) m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)); (| x, m1 |) let lift_tot_action_with_frame #a #e #fp #fp' ($f:tot_action_with_frame_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in assert (inames_ok e m0); ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); let m0' : hmem_with_inv_except e fp = m0 in let r = f frame m0' in let (| x, m1 |) = r in ac_reasoning_for_m_frame_preserving (fp' x) frame (locks_invariant e m1) m1; assert (interp (fp' x `star` frame `star` locks_invariant e m1) m1); assert (interp (fp' x `star` locks_invariant e m1) m1); let m1' : hmem_with_inv_except e (fp' x) = m1 in NMSTTotal.put #_ #(mem_evolves) m1; x let sel_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.sel_action #a #pcm r v0)) let upd_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.upd_action #a #pcm r v0 v1)) let free_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.free_action #a #pcm r v0)) let split_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.split_action #a #pcm r v0 v1)) let gather_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.gather_action #a #pcm r v0 v1)) let weaken (p q r:slprop) (h:H.hheap (p `star` q) { H.stronger q r }) : H.hheap (p `star` r) = H.weaken p q r h; h let weaken_pure (q r: prop) : Lemma (requires (q ==> r)) (ensures H.stronger (H.pure q) (H.pure r)) = let aux (h:H.heap) : Lemma (ensures (H.interp (H.pure q) h ==> H.interp (H.pure r) h)) [SMTPat ()] = H.pure_interp q h; H.pure_interp r h in () let inc_ctr (#p:slprop) #e (m:hmem_with_inv_except e p) : m':hmem_with_inv_except e p{m'.ctr = m.ctr + 1 /\ H.stronger (linv e m) (linv e m')} = let m' : mem = { m with ctr = m.ctr + 1} in assert (interp (p `star` linv e m) m'); assert (linv e m == lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m)); assert (linv e m' == lock_store_invariant e m.locks `star` ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken_free_above (heap_of_mem m) m.ctr (m.ctr + 1); weaken_pure (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_ctr_valid (m.ctr + 1) (heap_of_mem m)); assert (H.stronger (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m))); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)); H.stronger_star (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken (p `star` lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)) (heap_of_mem m'); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity (m.ctr + 1) (heap_of_mem m)); let m' : hmem_with_inv_except e p = m' in m' let frame_related_mems (fp0 fp1:slprop u#a) e (m0:hmem_with_inv_except e fp0) (m1:hmem_with_inv_except e fp1) = forall (frame:slprop u#a). interp ((fp0 `star` frame) `star` linv e m0) m0 ==> interp ((fp1 `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) let refined_pre_action e (fp0:slprop) (a:Type) (fp1:a -> slprop) = m0:hmem_with_inv_except e fp0 -> Pure (x:a & hmem_with_inv_except e (fp1 x)) (requires True) (ensures fun (| x, m1 |) -> frame_related_mems fp0 (fp1 x) e m0 m1) let refined_pre_action_as_action (#fp0:slprop) (#a:Type) (#fp1:a -> slprop) #e ($f:refined_pre_action e fp0 a fp1) : tot_action_nf_except e fp0 a fp1 = let g : tot_pre_action_nf_except e fp0 a fp1 = fun m -> f m in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp0 `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp1 x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x', m1' |) = g m0 in let (| x, m1 |) = f m0 in assert (x == x' /\ m1 == m1') in g let alloc_action #a #pcm e x = let f : refined_pre_action e emp (ref a pcm) (fun r -> pts_to r x) = fun m0 -> (* NS: 9/29/22 I needed to annotate h : Heap.full_heap, for use with the Core checker which generates a guard for checking the implicit pattern "dot" term in the dependent pair pattern on the next line. That guard expects `h` to be a full_heap, which is it, because it is a projection of m0. However, this is not reflected in `h`'s type. So, the Core checker, which produces a guard for the pat_dot_term in isolation, cannot recheck the term. If we were to fold in the checking of pat_dot_terms and their guards with the rest of the VC, this would work. *) let h : Heap.full_heap = hheap_of_hmem m0 in let (|r, h'|) = H.extend #a #pcm x m0.ctr h in let m' : hmem_with_inv_except e emp = inc_ctr m0 in let h' : H.hheap (pts_to #a #pcm r x `star` linv e m') = weaken _ (linv e m0) (linv e m') h' in let m1 : hmem_with_inv_except e (pts_to #a #pcm r x) = hmem_of_hheap m' h' in assert (forall frame. H.frame_related_heaps h h' emp (pts_to #a #pcm r x) frame true); let aux (frame:slprop) : Lemma (requires interp ((emp `star` frame) `star` linv e m0) m0) (ensures interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) [SMTPat (emp `star` frame)] = star_associative emp frame (linv e m0); assert (H.interp (emp `star` (frame `star` linv e m0)) h); assert (H.interp (pts_to #a #pcm r x `star` (frame `star` linv e m0)) h'); star_associative (pts_to #a #pcm r x) frame (linv e m0); assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m0) h'); assert (H.stronger (linv e m0) (linv e m')); assert (H.equiv (linv e m') (linv e m1)); assert (H.stronger (linv e m0) (linv e m1)); let h' : H.hheap ((pts_to #a #pcm r x `star` frame) `star` linv e m1) = weaken _ (linv e m0) (linv e m1) h' in assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) h'); assert (forall (mp:H.hprop frame). mp h == mp h'); mprop_preservation_of_hprop_preservation frame m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) in assert (frame_related_mems emp (pts_to r x) e m0 m1); (| r, m1 |) in lift_tot_action (refined_pre_action_as_action f) let select_refine #a #p e r x f = lift_tot_action (lift_heap_action e (H.select_refine #a #p r x f)) let upd_gen #a #p e r x y f = lift_tot_action (lift_heap_action e (H.upd_gen_action r x y f)) //////////////////////////////////////////////////////////////////////////////// // witness / recall //////////////////////////////////////////////////////////////////////////////// let witnessed_ref #a #pcm (r:ref a pcm) (fact:property a) (m:full_mem) = H.witnessed_ref #a #pcm r fact (heap_of_mem m) let witnessed_ref_stability #a #pcm (r:ref a pcm) (fact:property a) : Lemma (requires FStar.Preorder.stable fact (Steel.Preorder.preorder_of_pcm pcm)) (ensures FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) = H.witnessed_ref_stability #a #pcm r fact let witnessed (#a:Type u#1) (#pcm:pcm a) (r:ref a pcm) (fact:property a) = W.witnessed _ mem_evolves (witnessed_ref r fact) let rearrange_pqr_prq (p q r:slprop) : Lemma (((p `star` q) `star` r) `equiv` ((p `star` r) `star` q)) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_associative p q r } p `star` (q `star` r); (equiv) { star_commutative q r; star_congruence p (q `star` r) p (r `star` q) } p `star` (r `star` q); (equiv) { star_associative p r q } (p `star` r) `star` q; } let preserves_frame_cong (e:inames) (p q:slprop) (r s:slprop) (m0 m1:mem) : Lemma (requires p `equiv` r /\ q `equiv` s /\ preserves_frame e p q m0 m1) (ensures preserves_frame e r s m0 m1) = let aux0 (p q r s:slprop) : Lemma (requires p `equiv` s) (ensures (((p `star` q) `star` r) `equiv` ((s `star` q) `star` r))) = star_congruence p q s q; star_congruence (p `star` q) r (s `star` q) r in let aux (frame:slprop) : Lemma (requires interp ((r `star` frame) `star` locks_invariant e m0) m0) (ensures interp ((s `star` frame) `star` locks_invariant e m1) m1 /\ interp ((p `star` frame) `star` locks_invariant e m0) m0) [SMTPat (r `star` frame)] = aux0 p frame (locks_invariant e m0) r; aux0 q frame (locks_invariant e m1) s; assert (((p `star` frame) `star` locks_invariant e m0) `equiv` ((r `star` frame) `star` locks_invariant e m0)); assert (interp ((p `star` frame) `star` locks_invariant e m0) m0); assert (interp ((q `star` frame) `star` locks_invariant e m1) m1); assert (((q `star` frame) `star` locks_invariant e m1) `equiv` ((s `star` frame) `star` locks_invariant e m1)); () in () let pure_true_equiv (p:slprop) : Lemma ((p `star` pure True) `equiv` p) = FStar.Classical.forall_intro (pure_star_interp p True); emp_unit p; assert ((p `star` pure True) `equiv` p) let preserves_frame_star_pure (e:inames) (p q:slprop) (r s:prop) (m:mem) : Lemma (requires r /\ s) (ensures preserves_frame e p q m m <==> preserves_frame e (p `star` pure r) (q `star` pure s) m m) = pure_equiv r True; star_congruence p (pure r) p (pure True); pure_equiv s True; star_congruence q (pure s) q (pure True); pure_true_equiv p; pure_true_equiv q; let fwd () : Lemma (requires preserves_frame e p q m m) (ensures preserves_frame e (p `star` pure r) (q `star` pure s) m m) [SMTPat ()] = preserves_frame_cong e p q (p `star` pure r) (q `star` pure s) m m in let bk () : Lemma (requires preserves_frame e (p `star` pure r) (q `star` pure s) m m) (ensures preserves_frame e p q m m) [SMTPat ()] = preserves_frame_cong e (p `star` pure r) (q `star` pure s) p q m m in () let witness (#a:Type) (#pcm:pcm a) (e:inames) (r:erased (ref a pcm)) (fact:stable_property pcm) (v:Ghost.erased a) (_:squash (forall z. compatible pcm v z ==> fact z)) (frame:slprop) : MstTot (witnessed r fact) e (pts_to r v) (fun _ -> pts_to r v) frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in let _ : unit = let hr : H.ref a pcm = r in let v' = H.sel_v hr v (heap_of_mem m0) in assert (interp (H.ptr hr) m0 /\ H.sel #a #pcm hr (heap_of_mem m0) == v'); assert (compatible pcm v v'); assert (fact v'); assert (witnessed_ref r fact m0); witnessed_ref_stability r fact; assert (FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) in let w = NMSTTotal.witness _ mem_evolves (witnessed_ref r fact) in w let recall (#a:Type u#1) (#pcm:pcm a) (#fact:property a) (e:inames) (r:erased (ref a pcm)) (v:Ghost.erased a) (w:witnessed r fact) (frame:slprop) = let m0 = NMSTTotal.get () in NMSTTotal.recall _ mem_evolves (witnessed_ref r fact) w; let hr : H.ref a pcm = r in assert (witnessed_ref r fact m0); let v1 = H.sel_v hr v (heap_of_mem m0) in assert (compatible pcm v v1); assert (H.sel hr (heap_of_mem m0) == v1); assert (fact v1); assert (interp ((pts_to r v `star` frame) `star` locks_invariant e m0) m0); emp_unit ((pts_to r v `star` frame) `star` locks_invariant e m0); pure_star_interp ((pts_to r v `star` frame) `star` locks_invariant e m0) (fact v1) m0; assert (interp (((pts_to r v `star` frame) `star` locks_invariant e m0) `star` pure (fact v1)) m0); rearrange_pqr_prq (pts_to r v `star` frame) (locks_invariant e m0) (pure (fact v1)); assert (interp (((pts_to r v `star` frame) `star` pure (fact v1)) `star` locks_invariant e m0) m0); rearrange_pqr_prq (pts_to r v) frame (pure (fact v1)); star_congruence ((pts_to r v `star` frame) `star` pure (fact v1)) (locks_invariant e m0) ((pts_to r v `star` pure (fact v1)) `star` frame) (locks_invariant e m0); Ghost.hide v1 let iname_for_p_mem (i:iname) (p:slprop) : W.s_predicate mem = fun m -> iname_for_p i p m.locks let iname_for_p_stable (i:iname) (p:slprop) : Lemma (W.stable full_mem mem_evolves (iname_for_p_mem i p)) = () let ( >--> ) (i:iname) (p:slprop) : Type0 = W.witnessed full_mem mem_evolves (iname_for_p_mem i p) let hmem_with_inv_equiv e (m:mem) (p:slprop) : Lemma (interp (p `star` linv e m) m <==> interp (p `star` lock_store_invariant e m.locks) m /\ heap_ctr_valid m.ctr (heap_of_mem m)) = calc (<==>) { interp (p `star` linv e m) m; (<==>) { H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) } interp ((p `star` lock_store_invariant e m.locks) `star` ctr_validity m.ctr (heap_of_mem m)) m; (<==>) { H.pure_star_interp (p `star` lock_store_invariant e m.locks) (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_of_mem m) } interp ((p `star` lock_store_invariant e m.locks) `star` emp) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); (<==>) { H.emp_unit (p `star` lock_store_invariant e m.locks) } interp (p `star` lock_store_invariant e m.locks) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); } let new_invariant_tot_action (e:inames) (p:slprop) (m0:hmem_with_inv_except e p{ e `inames_in` m0.locks }) : Pure (iname & hmem_with_inv_except e emp) (requires True) (ensures fun (i, m1) -> iname_for_p_mem i p m1 /\ frame_related_mems p emp e m0 m1 /\ mem_evolves m0 m1) = let (| i, l1 |) = extend_lock_store e m0.locks p in let m1 = { m0 with locks = l1 } in assert (lock_store_invariant e m1.locks == p `star` lock_store_invariant e m0.locks); calc (equiv) { linv e m1; (equiv) {} (lock_store_invariant e m1.locks `star` ctr_validity m1.ctr (heap_of_mem m1)); (equiv) {} ((p `star` lock_store_invariant e m0.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); (equiv) { H.star_associative p (lock_store_invariant e m0.locks) (ctr_validity m1.ctr (heap_of_mem m1)) } (p `star` (lock_store_invariant e m0.locks `star` ctr_validity m1.ctr (heap_of_mem m1))); (equiv) { } (p `star` linv e m0); }; assert (iname_for_p_mem i p m1); assert (lock_store_evolves m0.locks l1); assert (mem_evolves m0 m1); hmem_with_inv_equiv e m0 p; assert (interp (p `star` lock_store_invariant e m0.locks) m1); assert (interp (lock_store_invariant e m1.locks) m1); H.emp_unit (lock_store_invariant e m1.locks); H.star_commutative (lock_store_invariant e m1.locks) emp; assert (interp (emp `star` lock_store_invariant e m1.locks) m1); hmem_with_inv_equiv e m1 emp; let m1 : hmem_with_inv_except e emp = m1 in let aux (frame:slprop) : Lemma (requires interp ((p `star` frame) `star` linv e m0) m0) (ensures interp ((emp `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) <==> mp (core_mem m1))) [SMTPat (p `star` frame)] = assert (interp ((p `star` frame) `star` linv e m0) m1); calc (equiv) { ((p `star` frame) `star` linv e m0); (equiv) { H.star_commutative p frame; H.star_congruence (p `star` frame) (linv e m0) (frame `star` p) (linv e m0); H.star_associative frame p (linv e m0) } (frame `star` (p `star` linv e m0)); (equiv) { H.star_congruence frame (p `star` linv e m0) frame (linv e m1) } (frame `star` linv e m1); (equiv) { H.emp_unit (frame `star` linv e m1); H.star_commutative (frame `star` linv e m1) emp; H.star_associative emp frame (linv e m1) } ((emp `star` frame) `star` linv e m1); }; assert (interp ((emp `star` frame) `star` linv e m1) m1) in assert (frame_related_mems p emp e m0 m1); ( i, m1 ) let name_is_ok (i:iname) (m0:full_mem u#1) : prop = i < List.Tot.length m0.locks let witnessed_name_is_ok (i:iname) = W.witnessed full_mem mem_evolves (name_is_ok i) let pre_inv = i:erased iname & witnessed_name_is_ok i let inv (p:slprop u#1) = i:erased iname & witnessed_name_is_ok i & (i >--> p) let pre_inv_of_inv #p (i:inv p) = let (|i, w, _|) = i in (|i,w|) let name_of_pre_inv (i:pre_inv) = dfst i let rec recall_all (ctx:list pre_inv) : NMSTTotal.NMSTATETOT unit (full_mem u#1) mem_evolves (requires fun _ -> True) (ensures fun m0 _ m1 -> m0==m1 /\ (forall i. i `List.Tot.memP` ctx ==> name_is_ok (name_of_pre_inv i) m0)) = match ctx with | [] -> () | hd::tl -> let (| q, i |) = hd in let i : W.witnessed full_mem mem_evolves (name_is_ok q) = i in NMSTTotal.recall _ mem_evolves (name_is_ok q) i; recall_all tl let fresh_invariant (e:inames) (p:slprop) (ctx:list pre_inv) (frame:slprop) : MstTot (i:inv p { not (mem_inv e i) /\ fresh_wrt ctx (name_of_inv i)}) e p (fun _ -> emp) frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in recall_all ctx; ac_reasoning_for_m_frame_preserving p frame (locks_invariant e m0) m0; assert (interp (p `star` locks_invariant e m0) m0); let r = new_invariant_tot_action e p m0 in let ( i, m1 ) = r in assert (i == List.Tot.length m0.locks); assert (not (Set.mem i e)); assert (mem_evolves m0 m1); NMSTTotal.put #full_mem #mem_evolves m1; iname_for_p_stable i p; let w = NMSTTotal.witness full_mem mem_evolves (iname_for_p_mem i p) in let w0 = NMSTTotal.witness full_mem mem_evolves (name_is_ok i) in (| hide i, w0, w |) let new_invariant (e:inames) (p:slprop) (frame:slprop) : MstTot (inv p) e p (fun _ -> emp) frame (fun _ -> True) (fun _ _ _ -> True) = fresh_invariant e p [] frame let rearrange_invariant (p q r : slprop) (q0 q1:slprop) : Lemma (requires q `equiv` (q0 `star` q1)) (ensures (p `star` (q `star` r)) `equiv` ((q0 `star` p) `star` (q1 `star` r))) = calc (equiv) { p `star` (q `star` r); (equiv) { calc (equiv) { (q `star` r); (equiv) { star_congruence q r (q0 `star` q1) r } (q0 `star` q1) `star` r; }; star_congruence p (q `star` r) p ((q0 `star` q1) `star` r) } (p `star` ((q0 `star` q1) `star` r)); (equiv) { star_associative q0 q1 r; star_congruence p ((q0 `star` q1) `star` r) p (q0 `star` (q1 `star` r)); star_associative p q0 (q1 `star` r) } (p `star` q0) `star` (q1 `star` r); (equiv) { star_commutative p q0; star_congruence (p `star` q0) (q1 `star` r) (q0 `star` p) (q1 `star` r) } (q0 `star` p) `star` (q1 `star` r); } let preserves_frame_invariant (fp fp':slprop) (opened_invariants:inames) (p:slprop) (i:inv p{not (mem_inv opened_invariants i)}) (m0:hmem_with_inv_except (add_inv opened_invariants i) (p `star` fp)) (m1:mem) : Lemma (requires preserves_frame (set_add (name_of_inv i) opened_invariants) (p `star` fp) (p `star` fp') m0 m1 /\ interp (fp' `star` linv opened_invariants m1) m1 /\ inames_ok opened_invariants m1 /\ (lock_store_invariant opened_invariants m0.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks)) /\ (lock_store_invariant opened_invariants m1.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks))) (ensures preserves_frame opened_invariants fp fp' m0 m1) = let aux (frame:slprop) : Lemma (requires interp ((fp `star` frame) `star` linv opened_invariants m0) m0) (ensures interp ((fp' `star` frame) `star` linv opened_invariants m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) [SMTPat()] = rearrange_invariant (fp `star` frame) (lock_store_invariant opened_invariants m0.locks) (ctr_validity m0.ctr (heap_of_mem m0)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks); assert (interp ((p `star` (fp `star` frame)) `star` linv (set_add (name_of_inv i) opened_invariants) m0) m0); star_associative p fp frame; star_congruence (p `star` (fp `star` frame)) (linv (set_add (name_of_inv i) opened_invariants) m0) ((p `star` fp) `star` frame) (linv (set_add (name_of_inv i) opened_invariants) m0); assert (interp (((p `star` fp) `star` frame) `star` linv (set_add (name_of_inv i) opened_invariants) m0) m0); assert (interp (((p `star` fp') `star` frame) `star` linv (set_add (name_of_inv i) opened_invariants) m1) m1); star_associative p fp' frame; star_congruence ((p `star` fp') `star` frame) (linv (set_add (name_of_inv i) opened_invariants) m1) (p `star` (fp' `star` frame)) (linv (set_add (name_of_inv i) opened_invariants) m1); assert (interp ((p `star` (fp' `star` frame)) `star` linv (set_add (name_of_inv i) opened_invariants) m1) m1); rearrange_invariant (fp' `star` frame) (lock_store_invariant opened_invariants m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks); assert (interp ((fp' `star` frame) `star` linv opened_invariants m1) m1); () in ()

{ "checked_file": "/", "dependencies": [ "Steel.Preorder.fst.checked", "Steel.Heap.fsti.checked", "prims.fst.checked", "FStar.Witnessed.Core.fsti.checked", "FStar.Set.fsti.checked", "FStar.Preorder.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.PCM.fst.checked", "FStar.NMSTTotal.fst.checked", "FStar.List.Tot.fst.checked", "FStar.IndefiniteDescription.fsti.checked", "FStar.Ghost.fsti.checked", "FStar.FunctionalExtensionality.fsti.checked", "FStar.Classical.Sugar.fsti.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Steel.Memory.fst" }

[ { "abbrev": true, "full_module": "Steel.Preorder", "short_module": "PP" }, { "abbrev": true, "full_module": "FStar.Witnessed.Core", "short_module": "W" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": true, "full_module": "Steel.Heap", "short_module": "H" }, { "abbrev": false, "full_module": "FStar.PCM", "short_module": null }, { "abbrev": false, "full_module": "FStar.FunctionalExtensionality", "short_module": null }, { "abbrev": true, "full_module": "FStar.FunctionalExtensionality", "short_module": "F" }, { "abbrev": false, "full_module": "FStar.PCM", "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

p: Steel.Memory.slprop -> q: Steel.Memory.slprop -> r: Steel.Memory.slprop -> FStar.Pervasives.Lemma (requires Steel.Memory.equiv q r) (ensures Steel.Memory.equiv (Steel.Memory.star p q) (Steel.Memory.star p r))

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Steel.Memory.slprop", "FStar.Calc.calc_finish", "Steel.Memory.equiv", "Steel.Memory.star", "Prims.Cons", "FStar.Preorder.relation", "Prims.Nil", "Prims.unit", "FStar.Calc.calc_step", "FStar.Calc.calc_init", "FStar.Calc.calc_pack", "Steel.Memory.star_commutative", "Prims.squash", "Steel.Memory.equiv_extensional_on_star", "FStar.Pervasives.pattern" ]

[]

false

true

false

let equiv_ext_right (p q r: slprop) : Lemma (requires q `equiv` r) (ensures (p `star` q) `equiv` (p `star` r)) =

calc (equiv) { p `star` q; (equiv) { star_commutative p q } q `star` p; (equiv) { equiv_extensional_on_star q r p } r `star` p; (equiv) { star_commutative p r } p `star` r; }

false

Steel.Memory.fst

Steel.Memory.with_inv_helper

val with_inv_helper (fp frame ls1 ctr p ls2: slprop) : Lemma (requires ls1 `equiv` (p `star` ls2)) (ensures ((fp `star` frame) `star` (ls1 `star` ctr)) `equiv` (((p `star` fp) `star` frame) `star` (ls2 `star` ctr)))

let with_inv_helper (fp frame ls1 ctr p ls2:slprop) : Lemma (requires ls1 `equiv` (p `star` ls2)) (ensures (fp `star` frame `star` (ls1 `star` ctr)) `equiv` (p `star` fp `star` frame `star` (ls2 `star` ctr))) = calc (equiv) { ls1 `star` ctr; (equiv) { equiv_extensional_on_star ls1 (p `star` ls2) ctr } p `star` ls2 `star` ctr; }; calc (equiv) { p `star` ls2 `star` ctr; (equiv) { star_associative p ls2 ctr } p `star` (ls2 `star` ctr); }; calc (equiv) { fp `star` frame `star` p; (equiv) { star_commutative (fp `star` frame) p } p `star` (fp `star` frame); (equiv) { star_associative p fp frame } p `star` fp `star` frame; }; calc (equiv) { fp `star` frame `star` (ls1 `star` ctr); (equiv) { equiv_ext_right (fp `star` frame) (ls1 `star` ctr) (p `star` ls2 `star` ctr) } (fp `star` frame) `star` (p `star` ls2 `star` ctr); (equiv) { equiv_ext_right (fp `star` frame) (p `star` ls2 `star` ctr) (p `star` (ls2 `star` ctr)) } (fp `star` frame) `star` (p `star` (ls2 `star` ctr)); (equiv) { star_associative (fp `star` frame) p (ls2 `star` ctr) } (fp `star` frame `star` p) `star` (ls2 `star` ctr); (equiv) { equiv_extensional_on_star (fp `star` frame `star` p) (p `star` fp `star` frame) (ls2 `star` ctr) } (p `star` fp `star` frame) `star` (ls2 `star` ctr); }

{ "file_name": "lib/steel/Steel.Memory.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 5, "end_line": 1428, "start_col": 0, "start_line": 1388 }

(* 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.Memory module F = FStar.FunctionalExtensionality open FStar.FunctionalExtensionality open FStar.PCM module H = Steel.Heap noeq type lock_state : Type u#(a + 1) = | Invariant : inv:H.slprop u#a -> lock_state let lock_store : Type u#(a+1) = list (lock_state u#a) noeq type mem : Type u#(a + 1) = { ctr: nat; heap: H.heap u#a; locks: lock_store u#a; } let heap_of_mem (x:mem) : H.heap = x.heap let mem_of_heap (h:H.heap) : mem = { ctr = 0; heap = h; locks = [] } let mem_set_heap (m:mem) (h:H.heap) : mem = { ctr = m.ctr; heap = h; locks = m.locks; } let core_mem (m:mem) : mem = mem_of_heap (heap_of_mem m) let core_mem_invol m = () let disjoint (m0 m1:mem u#h) : prop = m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks let disjoint_sym m0 m1 = () let join m0 m1 = { ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = m0.locks } let join_commutative m0 m1 = H.join_commutative m0.heap m1.heap let disjoint_join m0 m1 m2 = H.disjoint_join m0.heap m1.heap m2.heap let join_associative m0 m1 m2 = H.join_associative m0.heap m1.heap m2.heap let slprop = H.slprop let interp p m = H.interp p m.heap let equiv p1 p2 = forall m. interp p1 m <==> interp p2 m let slprop_extensionality p q = assert (forall m. interp p m <==> interp q m); let aux (h:H.heap) : Lemma (H.interp p h <==> H.interp q h) [SMTPat (H.interp p h)] = let m : mem = { ctr = 0; heap = h; locks = [] } in assert (interp p m <==> interp q m) in assert (forall h. H.interp p h <==> H.interp q h); Steel.Heap.slprop_extensionality p q let reveal_equiv p1 p2 = () let core_ref = H.core_ref let core_ref_null = H.core_ref_null let core_ref_is_null r = H.core_ref_is_null r let emp : slprop u#a = H.emp let pure = H.pure let pts_to = H.pts_to let h_and = H.h_and let h_or = H.h_or let star = H.star let wand = H.wand let h_exists = H.h_exists let h_forall = H.h_forall //////////////////////////////////////////////////////////////////////////////// //properties of equiv //////////////////////////////////////////////////////////////////////////////// let equiv_symmetric (p1 p2:slprop u#a) = H.equiv_symmetric p1 p2 #push-options "--warn_error -271" let equiv_heap_iff_equiv (p1 p2:slprop u#a) : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat (equiv p1 p2)] = let aux_lr () : Lemma (requires H.equiv p1 p2) (ensures equiv p1 p2) [SMTPat ()] = () in let aux_rl_helper1 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p1 h) (ensures H.interp p2 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl_helper2 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p2 h) (ensures H.interp p1 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl () : Lemma (requires equiv p1 p2) (ensures H.equiv p1 p2) [SMTPat ()] = () in () let equiv_heap_iff_equiv_forall () : Lemma (ensures (forall p1 p2. H.equiv p1 p2 <==> equiv p1 p2)) = let aux p1 p2 : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat ()] = equiv_heap_iff_equiv p1 p2 in () #pop-options let equiv_extensional_on_star (p1 p2 p3:slprop u#a) = equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3 let emp_unit p = H.emp_unit p let intro_emp m = H.intro_emp (heap_of_mem m) let pure_equiv p q = H.pure_equiv p q let pure_interp q m = H.pure_interp q (heap_of_mem m) let pure_star_interp p q m = H.pure_star_interp p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// //pts_to //////////////////////////////////////////////////////////////////////////////// let pts_to_compatible #a #pcm x v0 v1 m = H.pts_to_compatible #a #pcm x v0 v1 (heap_of_mem m) let pts_to_compatible_equiv #a #pcm x v0 v1 = H.pts_to_compatible_equiv #a #pcm x v0 v1 let pts_to_not_null #a #pcm x v m = H.pts_to_not_null #a #pcm x v (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // star //////////////////////////////////////////////////////////////////////////////// let intro_star p q mp mq = H.intro_star p q (heap_of_mem mp) (heap_of_mem mq) let elim_star p q m = let h = heap_of_mem m in H.elim_star p q h; assert (exists hl hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr); let hl = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hl -> exists hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let hr = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hr -> H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let ml = mem_set_heap m hl in let mr = mem_set_heap m hr in assert (disjoint ml mr); assert (m == join ml mr); assert (interp p ml); assert (interp q mr); () let interp_star (p q: slprop) (m: mem) : Lemma (interp (p `star` q) m <==> (exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m)) = let left = interp (p `star` q) m in let right = exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m in let f () : Lemma (requires left) (ensures right) = elim_star p q m in let g () : Lemma (requires right) (ensures left) = Classical.exists_elim left #_ #(fun mp -> exists (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mp -> Classical.exists_elim left #_ #(fun mq -> disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mq -> intro_star p q mp mq ) ) in Classical.move_requires f (); Classical.move_requires g () let star_commutative (p1 p2:slprop) = H.star_commutative p1 p2 let star_associative (p1 p2 p3:slprop) = H.star_associative p1 p2 p3 let star_congruence (p1 p2 p3 p4:slprop) = equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4 let affine_star (p q:slprop) (m:mem) = H.affine_star p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // Invariants on the lock store //////////////////////////////////////////////////////////////////////////////// let iname = nat module S = FStar.Set module L = FStar.List.Tot module W = FStar.Witnessed.Core let rec lock_store_invariant (e:inames) (l:lock_store u#a) : slprop u#a = let current_addr = L.length l - 1 in match l with | [] -> emp | Invariant p :: tl -> if current_addr `S.mem` e then lock_store_invariant e tl else p `star` lock_store_invariant e tl let lock_i (i:iname) (l:lock_store { i < L.length l }) = let ix = L.length l - i - 1 in L.index l ix let iname_for_p (i:iname) (p:slprop) : W.s_predicate lock_store = fun l -> i < L.length l /\ (lock_i i l).inv == p let lock_store_evolves : FStar.Preorder.preorder lock_store = fun (l1 l2 : lock_store) -> L.length l2 >= L.length l1 /\ (forall (i:nat{i < L.length l1}). (lock_i i l1).inv == (lock_i i l2).inv) let inames_in (e:inames) (l:lock_store) : prop = forall i. Set.mem i e ==> i < L.length l let inames_ok e m = inames_in e m.locks let inames_ok_empty m = () let extend_lock_store (e:inames) (l:lock_store{e `inames_in` l}) (p:slprop) : i:iname & l':lock_store { lock_store_invariant e l' == p `star` lock_store_invariant e l /\ iname_for_p i p l' } = (| L.length l, Invariant p :: l |) let set_add (i:iname) (s:inames) = Set.union (Set.singleton i) s let rec move_invariant (e:inames) (l:lock_store) (p:slprop) (i:iname{iname_for_p i p l /\ ~(i `Set.mem` e)}) : Lemma (H.equiv (lock_store_invariant e l) (p `star` lock_store_invariant (set_add i e) l)) = let rec aux (i:iname) (m:lock_store) : Lemma (requires i >= L.length m) (ensures (lock_store_invariant e m `H.equiv` lock_store_invariant (set_add i e) m)) = match m with | [] -> () | Invariant p::tl -> aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl) in let current_addr = L.length l - 1 in match l with | [] -> () | Invariant q::tl -> if i = current_addr then begin assert (lock_store_invariant e l == p `star` lock_store_invariant e tl); aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl); () end else begin move_invariant e tl p i; assert (lock_store_invariant e tl `equiv` (p `star` lock_store_invariant (set_add i e) tl)); H.star_congruence q (lock_store_invariant e tl) q (p `star` lock_store_invariant (set_add i e) tl); if Set.mem current_addr e then () else begin let r = lock_store_invariant (set_add i e) tl in assert (lock_store_invariant e l `equiv` (q `star` (p `star` r))); H.star_associative q p r; H.star_commutative q p; H.star_congruence (q `star` p) r (p `star` q) r; H.star_associative p q r end end let heap_ctr_valid (ctr:nat) (h:H.heap u#a) : prop = h `H.free_above_addr` ctr let ctr_validity (ctr:nat) (h:H.heap) : slprop = H.pure (heap_ctr_valid ctr h) let locks_invariant (e:inames) (m:mem u#a) : slprop u#a = lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m) let full_mem_pred (m:mem) = H.full_heap_pred (heap_of_mem m) (***** Following lemmas are needed in Steel.Effect *****) let core_mem_interp (hp:slprop u#a) (m:mem u#a) = () let interp_depends_only_on (hp:slprop u#a) = H.interp_depends_only_on hp let a_mem_prop_as_a_heap_prop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (H.a_heap_prop u#a) = let g (h: H.heap u#a) : Tot prop = interp sl (mem_of_heap h) /\ f (mem_of_heap h) in let phi0 (h0 h1: H.heap u#a) : Lemma (requires (g h0 /\ H.disjoint h0 h1)) (ensures (g h0 /\ H.disjoint h0 h1 /\ g (H.join h0 h1))) = assert (mem_of_heap (H.join h0 h1) == mem_of_heap h0 `join` mem_of_heap h1); interp_depends_only_on sl in let phi1 (h0 h1: H.heap u#a) : Lemma (ensures ((g h0 /\ H.disjoint h0 h1) ==> g (H.join h0 h1))) = Classical.move_requires (phi0 h0) h1 in Classical.forall_intro_2 phi1; g let refine_slprop sl f = H.as_slprop (a_mem_prop_as_a_heap_prop sl f) let interp_refine_slprop sl f m = assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_mem m)) let dep_hprop (s: slprop) (f: (hmem s -> Tot slprop)) (h: H.heap) : Tot prop = exists (h1: H.heap) . exists (h2: H.heap) . interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 let dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq' : squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h')) = let p2 (h h1 h2: H.heap) : Tot prop = interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 in let p1 (h h1: H.heap) : Tot prop = (exists h2 . p2 h h1 h2) in let h1 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p1 h) in let h2 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p2 h h1) in H.disjoint_join h' h1 h2; assert (H.disjoint h2 h'); let h2' = H.join h2 h' in H.join_commutative h2 h' ; assert (h2' == H.join h' h2); assert (H.disjoint h1 h2'); assert (mem_of_heap h2' == mem_of_heap h2 `join` mem_of_heap h'); interp_depends_only_on (f (mem_of_heap h1)); assert (interp (f (mem_of_heap h1)) (mem_of_heap h2')); H.join_commutative h1 h2; H.join_associative h' h2 h1; H.join_commutative h' h; H.join_commutative h2' h1; assert (H.join h h' == h1 `H.join` h2') let impl_intro_gen (#p: Type0) (#q: Type0) ($prf: (squash p -> Lemma (q ))) : Lemma (p ==> q) = Classical.impl_intro_gen #p #(fun _ -> q) prf let dep_hprop_is_affine1 (s: slprop) (f: (hmem s -> Tot slprop)) (h0 h1: H.heap) : Lemma ((dep_hprop s f h0 /\ H.disjoint h0 h1) ==> (H.disjoint h0 h1 /\ dep_hprop s f (H.join h0 h1))) = impl_intro_gen (dep_hprop_is_affine0 s f h0 h1) let dep_hprop_is_affine (s: slprop) (f: (hmem s -> Tot slprop)) : Lemma (H.heap_prop_is_affine (dep_hprop s f)) = Classical.forall_intro_2 (dep_hprop_is_affine1 s f) let sdep (s: slprop) (f: (hmem s -> Tot slprop)) : Tot slprop = dep_hprop_is_affine s f; H.as_slprop (dep_hprop s f) let interp_sdep (s: slprop) (f: (hmem s -> Tot slprop)) (m: mem) : Lemma (requires (dep_slprop_is_affine s f)) (ensures ( interp (sdep s f) m <==> (exists m1 m2 . interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) )) = dep_hprop_is_affine s f; assert (forall m1 m2 . (interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) ==> ( interp s (mem_of_heap m1.heap) /\ interp (f (mem_of_heap m1.heap)) (mem_of_heap m2.heap) /\ H.disjoint m1.heap m2.heap /\ H.join m1.heap m2.heap == m.heap )); interp_depends_only_on s; Classical.forall_intro (fun m -> interp_depends_only_on (f m)); assert (forall h1 h2 . (interp s (mem_of_heap h1) /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ H.disjoint h1 h2 /\ H.join h1 h2 == m.heap) ==> ( core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ interp s (core_mem (mem_of_heap h1)) /\ interp s (mem_set_heap m h1) /\ core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ f (mem_set_heap m h1) `equiv` f (mem_of_heap h1) /\ interp (f (mem_set_heap m h1)) (mem_of_heap h2) /\ interp (f (mem_set_heap m h1)) (mem_set_heap m h2) /\ disjoint (mem_set_heap m h1) (mem_set_heap m h2) /\ join (mem_set_heap m h1) (mem_set_heap m h2) == m )); () let h_exists_cong (#a:Type) (p q : a -> slprop) : Lemma (requires (forall x. p x `equiv` q x)) (ensures (h_exists p `equiv` h_exists q)) = equiv_heap_iff_equiv_forall (); H.h_exists_cong p q let intro_h_exists #a x p m = H.intro_h_exists x p (heap_of_mem m) let elim_h_exists (#a:_) (p:a -> slprop) (m:mem) = H.elim_h_exists p (heap_of_mem m) let intro_h_forall (#a:_) (p:a -> slprop) (m:mem) = H.intro_h_forall p (heap_of_mem m) let elim_h_forall (#a:_) (p:a -> slprop) (m:mem) (x:a) = H.elim_h_forall p (heap_of_mem m) x let intro_h_and (p q: slprop) (m:mem) = H.intro_h_and p q (heap_of_mem m) let elim_h_and (p q: slprop) (m:mem) = H.elim_h_and p q (heap_of_mem m) let intro_h_or_left (p q: slprop) (m:mem) = H.intro_h_or_left p q (heap_of_mem m) let intro_h_or_right (p q: slprop) (m:mem) = H.intro_h_or_right p q (heap_of_mem m) let elim_h_or (p q: slprop) (m:mem) = H.elim_h_or p q (heap_of_mem m) let intro_wand (p1 p2: slprop u#a) (m:mem) = introduce (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)) ==> interp (wand p1 p2) m with _. ( assert (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)); H.intro_wand p1 p2 (heap_of_mem m); let h = heap_of_mem m in assert ((forall h1. h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) ==> H.interp (wand p1 p2) h); introduce forall h1. (h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) with ( introduce (h `H.disjoint` h1 /\ H.interp p1 h1) ==> H.interp p2 (H.join h h1) with _. ( assert (h `H.disjoint` h1); let m1 = { ctr = m.ctr; heap = h1; locks = m.locks } in assert (m `disjoint` m1) ) ) ) (** Eliminating a wand by proving a heap that satisfies the LHS **) let elim_wand (p1 p2: slprop u#a) (m:mem) (m1:mem) = H.elim_wand p1 p2 (heap_of_mem m) (heap_of_mem m1) //////////////////////////////////////////////////////////////////////////////// // Preorders and effects //////////////////////////////////////////////////////////////////////////////// module PP = Steel.Preorder let mem_evolves = fun (m0 m1:full_mem) -> H.heap_evolves (heap_of_mem m0) (heap_of_mem m1) /\ m0.ctr <= m1.ctr /\ lock_store_evolves m0.locks m1.locks (** See [Steel.Heap.is_frame_preserving]. We add in [lock_invariants] now *) let preserves_frame (e:inames) (pre post:slprop) (m0 m1:mem) = forall (frame:slprop). interp ((pre `star` frame) `star` locks_invariant e m0) m0 ==> (interp ((post `star` frame) `star` locks_invariant e m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) (** This is a version of MstTot with frame quantified, as part of preserves_frame *) effect MstTotNF (a:Type u#a) (except:inames) (expects:slprop u#1) (provides: a -> slprop u#1) = NMSTTotal.NMSTATETOT a (full_mem u#1) mem_evolves (requires fun m0 -> inames_ok except m0 /\ interp (expects `star` locks_invariant except m0) m0) (ensures fun m0 x m1 -> inames_ok except m1 /\ interp (provides x `star` locks_invariant except m1) m1 /\ preserves_frame except expects (provides x) m0 m1) //////////////////////////////////////////////////////////////////////////////// // Lifting heap actions //////////////////////////////////////////////////////////////////////////////// (** Heap actions come in two equivalent flavors: - one that take an explicit frame as argument (action_with_frame) - and one that quantify over all the frame We therefore define two lift routes: - a direct route for those with explicit frame - via MstTotNF for the rest *) let tot_pre_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = hmem_with_inv_except e fp -> (x:a & hmem_with_inv_except e (fp' x)) let tot_pre_action_nf = tot_pre_action_nf_except S.empty let ac_reasoning_for_m_frame_preserving (p q r:slprop u#a) (m:mem u#a) : Lemma (requires interp ((p `star` q) `star` r) m) (ensures interp (p `star` r) m) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_commutative p q; equiv_extensional_on_star (p `star` q) (q `star` p) r } (q `star` p) `star` r; (equiv) { star_associative q p r } q `star` (p `star` r); }; assert (interp (q `star` (p `star` r)) m); affine_star q (p `star` r) m let is_frame_preserving (#e:inames) (#a:Type u#b) (#fp:slprop u#a) (#fp':a -> slprop u#a) (f:tot_pre_action_nf_except e fp a fp') = forall (frame:slprop u#a) (m0:hmem_with_inv_except e (fp `star` frame)). (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = f:tot_pre_action_nf_except e fp a fp'{ is_frame_preserving f } let tot_action_nf = tot_action_nf_except S.empty let linv e (m:mem) = locks_invariant e m let hheap_of_hmem #fp #e (m:hmem_with_inv_except e fp) : h:H.hheap (fp `star` linv e m) { h `H.free_above_addr` m.ctr} = let h = heap_of_mem m in H.pure_interp (heap_ctr_valid m.ctr (heap_of_mem m)) h; h let hmem_of_hheap #e (#fp0 #fp1:slprop) (m:hmem_with_inv_except e fp0) (h:H.full_hheap (fp1 `star` linv e m) { h `Heap.free_above_addr` m.ctr }) : m1:hmem_with_inv_except e fp1{linv e m `equiv` linv e m1} = let m1 : mem = { m with heap = h } in assert (interp (fp1 `star` linv e m) m1); star_commutative fp1 (linv e m); assert (interp (linv e m `star` fp1) m1); assert (linv e m1 == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); assert (linv e m == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m)); H.pure_interp (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_of_mem m); assert (heap_ctr_valid m1.ctr (heap_of_mem m) <==> heap_ctr_valid m1.ctr (heap_of_mem m1)); H.pure_equiv (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_ctr_valid m1.ctr (heap_of_mem m1)); H.star_congruence (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m)); assert (linv e m `equiv` linv e m1); let _ = equiv_extensional_on_star (linv e m) (linv e m1) fp1 in assert ((linv e m `star` fp1) `equiv` (linv e m1 `star` fp1)); assert (interp (linv e m1 `star` fp1) m1); star_commutative (linv e m1) fp1; assert (interp (fp1 `star` linv e m1) m1); m1 let with_inv_except (m:mem) e (fp:slprop) = interp (fp `star` locks_invariant e m) m #push-options "--warn_error -271" let as_hprop (frame:slprop) (mp:mprop frame) : hp:H.hprop frame{forall m. mp (core_mem m) == hp (heap_of_mem m)} = let f = fun h -> mp (mem_of_heap h) in assert (forall m. mp (core_mem m) == f (heap_of_mem m)); let aux (m0:H.hheap frame) (m1:H.heap{H.disjoint m0 m1}) : Lemma (ensures (mem_of_heap (H.join m0 m1) == join (mem_of_heap m0) (mem_of_heap m1))) [SMTPat ()] = () in f let mprop_preservation_of_hprop_preservation (p:slprop) (m0 m1:mem) : Lemma (requires (forall (hp:H.hprop p). hp (heap_of_mem m0) == hp (heap_of_mem m1))) (ensures (forall (mp:mprop p). mp (core_mem m0) == mp (core_mem m1))) = let aux (mp:mprop p) : Lemma (mp (core_mem m0) == mp (core_mem m1)) [SMTPat()] = assert (as_hprop p mp (heap_of_mem m0) == as_hprop p mp (heap_of_mem m1)) in () let lift_heap_action (#fp:slprop) (#a:Type) (#fp':a -> slprop) (e:inames) ($f:H.action fp a fp') : tot_action_nf_except e fp a fp' = let g : tot_pre_action_nf_except e fp a fp' = fun m -> let h0 = hheap_of_hmem m in let (| x, h' |) = f h0 in (| x, hmem_of_hheap m h' |) in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in let h0 = hheap_of_hmem m0 in let (| x', h1 |) = f h0 in H.action_framing f (linv e m0) h0; assert (x == x'); star_associative fp frame (linv e m0); H.action_framing f (frame `star` linv e m0) h0; assert (H.interp ((fp' x) `star` (frame `star` linv e m0)) h1); star_associative (fp' x) frame (linv e m0); assert (H.interp ((fp' x `star` frame) `star` linv e m0) h1); let h1' : H.hheap ((fp' x `star` frame) `star` linv e m0) = h1 in assert (m1 == hmem_of_hheap m0 h1'); assert (with_inv_except m1 e (fp' x `star` frame)); assert (forall (hp:H.hprop frame). hp h0 == hp h1); mprop_preservation_of_hprop_preservation frame m0 m1; () in assert (is_frame_preserving g); g let frame_preserving_respects_preorder #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (m0:hmem_with_inv_except e fp) : Lemma (let (| x, m1 |) = f m0 in mem_evolves m0 m1) = let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1) = () in H.emp_unit fp; assert (interp (fp `star` linv e m0) m0); H.star_congruence (fp `star` emp) (linv e m0) fp (linv e m0); assert (interp ((fp `star` emp) `star` linv e m0) m0); aux emp m0 let lift_tot_action_nf #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') : MstTotNF a e fp fp' = let m0 = NMSTTotal.get () in let m0' : hmem_with_inv_except e fp = m0 in let r = f m0' in let (| x, m1 |) = r in let m1' : hmem_with_inv_except e (fp' x) = m1 in assert (is_frame_preserving f); assert (m1 == dsnd (f m0)); frame_preserving_respects_preorder f m0; NMSTTotal.put #_ #(mem_evolves) m1; x let lift_tot_action #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get #(full_mem) #_ () in ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); lift_tot_action_nf f (** Now defining the lift for heap actions with explicit frame *) let tot_action_with_frame_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = frame:slprop u#a -> m0:hmem_with_inv_except e (fp `star` frame) -> Pure (x:a & hmem_with_inv_except e (fp' x `star` frame)) (requires True) (ensures fun (| x, m1 |) -> mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_with_frame = tot_action_with_frame_except S.empty let lift_heap_action_with_frame (#fp:slprop u#a) (#a:Type u#b) (#fp':a -> slprop u#a) (e:inames) ($f:H.action_with_frame fp a fp') : tot_action_with_frame_except e fp a fp' = fun frame m0 -> let h0 = hheap_of_hmem m0 in calc (equiv) { fp `star` frame `star` locks_invariant e m0; (equiv) { star_associative fp frame (locks_invariant e m0) } fp `star` (frame `star` locks_invariant e m0); }; assert (H.interp (fp `star` frame `star` locks_invariant e m0) h0); assert (H.interp (fp `star` (frame `star` locks_invariant e m0)) h0); //key: apply the heap action with frame * locks_invariant e m0 let (| x, h1 |) = f (frame `star` locks_invariant e m0) h0 in calc (equiv) { fp' x `star` (frame `star` locks_invariant e m0); (equiv) { star_associative (fp' x) frame (locks_invariant e m0) } fp' x `star` frame `star` locks_invariant e m0; }; assert (H.interp (fp' x `star` (frame `star` locks_invariant e m0)) h1); assert (H.interp (fp' x `star` frame `star` locks_invariant e m0) h1); let m1 = hmem_of_hheap m0 h1 in assert (mem_evolves m0 m1); mprop_preservation_of_hprop_preservation (frame `star` locks_invariant e m0) m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)); (| x, m1 |) let lift_tot_action_with_frame #a #e #fp #fp' ($f:tot_action_with_frame_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in assert (inames_ok e m0); ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); let m0' : hmem_with_inv_except e fp = m0 in let r = f frame m0' in let (| x, m1 |) = r in ac_reasoning_for_m_frame_preserving (fp' x) frame (locks_invariant e m1) m1; assert (interp (fp' x `star` frame `star` locks_invariant e m1) m1); assert (interp (fp' x `star` locks_invariant e m1) m1); let m1' : hmem_with_inv_except e (fp' x) = m1 in NMSTTotal.put #_ #(mem_evolves) m1; x let sel_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.sel_action #a #pcm r v0)) let upd_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.upd_action #a #pcm r v0 v1)) let free_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.free_action #a #pcm r v0)) let split_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.split_action #a #pcm r v0 v1)) let gather_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.gather_action #a #pcm r v0 v1)) let weaken (p q r:slprop) (h:H.hheap (p `star` q) { H.stronger q r }) : H.hheap (p `star` r) = H.weaken p q r h; h let weaken_pure (q r: prop) : Lemma (requires (q ==> r)) (ensures H.stronger (H.pure q) (H.pure r)) = let aux (h:H.heap) : Lemma (ensures (H.interp (H.pure q) h ==> H.interp (H.pure r) h)) [SMTPat ()] = H.pure_interp q h; H.pure_interp r h in () let inc_ctr (#p:slprop) #e (m:hmem_with_inv_except e p) : m':hmem_with_inv_except e p{m'.ctr = m.ctr + 1 /\ H.stronger (linv e m) (linv e m')} = let m' : mem = { m with ctr = m.ctr + 1} in assert (interp (p `star` linv e m) m'); assert (linv e m == lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m)); assert (linv e m' == lock_store_invariant e m.locks `star` ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken_free_above (heap_of_mem m) m.ctr (m.ctr + 1); weaken_pure (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_ctr_valid (m.ctr + 1) (heap_of_mem m)); assert (H.stronger (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m))); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)); H.stronger_star (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken (p `star` lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)) (heap_of_mem m'); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity (m.ctr + 1) (heap_of_mem m)); let m' : hmem_with_inv_except e p = m' in m' let frame_related_mems (fp0 fp1:slprop u#a) e (m0:hmem_with_inv_except e fp0) (m1:hmem_with_inv_except e fp1) = forall (frame:slprop u#a). interp ((fp0 `star` frame) `star` linv e m0) m0 ==> interp ((fp1 `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) let refined_pre_action e (fp0:slprop) (a:Type) (fp1:a -> slprop) = m0:hmem_with_inv_except e fp0 -> Pure (x:a & hmem_with_inv_except e (fp1 x)) (requires True) (ensures fun (| x, m1 |) -> frame_related_mems fp0 (fp1 x) e m0 m1) let refined_pre_action_as_action (#fp0:slprop) (#a:Type) (#fp1:a -> slprop) #e ($f:refined_pre_action e fp0 a fp1) : tot_action_nf_except e fp0 a fp1 = let g : tot_pre_action_nf_except e fp0 a fp1 = fun m -> f m in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp0 `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp1 x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x', m1' |) = g m0 in let (| x, m1 |) = f m0 in assert (x == x' /\ m1 == m1') in g let alloc_action #a #pcm e x = let f : refined_pre_action e emp (ref a pcm) (fun r -> pts_to r x) = fun m0 -> (* NS: 9/29/22 I needed to annotate h : Heap.full_heap, for use with the Core checker which generates a guard for checking the implicit pattern "dot" term in the dependent pair pattern on the next line. That guard expects `h` to be a full_heap, which is it, because it is a projection of m0. However, this is not reflected in `h`'s type. So, the Core checker, which produces a guard for the pat_dot_term in isolation, cannot recheck the term. If we were to fold in the checking of pat_dot_terms and their guards with the rest of the VC, this would work. *) let h : Heap.full_heap = hheap_of_hmem m0 in let (|r, h'|) = H.extend #a #pcm x m0.ctr h in let m' : hmem_with_inv_except e emp = inc_ctr m0 in let h' : H.hheap (pts_to #a #pcm r x `star` linv e m') = weaken _ (linv e m0) (linv e m') h' in let m1 : hmem_with_inv_except e (pts_to #a #pcm r x) = hmem_of_hheap m' h' in assert (forall frame. H.frame_related_heaps h h' emp (pts_to #a #pcm r x) frame true); let aux (frame:slprop) : Lemma (requires interp ((emp `star` frame) `star` linv e m0) m0) (ensures interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) [SMTPat (emp `star` frame)] = star_associative emp frame (linv e m0); assert (H.interp (emp `star` (frame `star` linv e m0)) h); assert (H.interp (pts_to #a #pcm r x `star` (frame `star` linv e m0)) h'); star_associative (pts_to #a #pcm r x) frame (linv e m0); assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m0) h'); assert (H.stronger (linv e m0) (linv e m')); assert (H.equiv (linv e m') (linv e m1)); assert (H.stronger (linv e m0) (linv e m1)); let h' : H.hheap ((pts_to #a #pcm r x `star` frame) `star` linv e m1) = weaken _ (linv e m0) (linv e m1) h' in assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) h'); assert (forall (mp:H.hprop frame). mp h == mp h'); mprop_preservation_of_hprop_preservation frame m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) in assert (frame_related_mems emp (pts_to r x) e m0 m1); (| r, m1 |) in lift_tot_action (refined_pre_action_as_action f) let select_refine #a #p e r x f = lift_tot_action (lift_heap_action e (H.select_refine #a #p r x f)) let upd_gen #a #p e r x y f = lift_tot_action (lift_heap_action e (H.upd_gen_action r x y f)) //////////////////////////////////////////////////////////////////////////////// // witness / recall //////////////////////////////////////////////////////////////////////////////// let witnessed_ref #a #pcm (r:ref a pcm) (fact:property a) (m:full_mem) = H.witnessed_ref #a #pcm r fact (heap_of_mem m) let witnessed_ref_stability #a #pcm (r:ref a pcm) (fact:property a) : Lemma (requires FStar.Preorder.stable fact (Steel.Preorder.preorder_of_pcm pcm)) (ensures FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) = H.witnessed_ref_stability #a #pcm r fact let witnessed (#a:Type u#1) (#pcm:pcm a) (r:ref a pcm) (fact:property a) = W.witnessed _ mem_evolves (witnessed_ref r fact) let rearrange_pqr_prq (p q r:slprop) : Lemma (((p `star` q) `star` r) `equiv` ((p `star` r) `star` q)) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_associative p q r } p `star` (q `star` r); (equiv) { star_commutative q r; star_congruence p (q `star` r) p (r `star` q) } p `star` (r `star` q); (equiv) { star_associative p r q } (p `star` r) `star` q; } let preserves_frame_cong (e:inames) (p q:slprop) (r s:slprop) (m0 m1:mem) : Lemma (requires p `equiv` r /\ q `equiv` s /\ preserves_frame e p q m0 m1) (ensures preserves_frame e r s m0 m1) = let aux0 (p q r s:slprop) : Lemma (requires p `equiv` s) (ensures (((p `star` q) `star` r) `equiv` ((s `star` q) `star` r))) = star_congruence p q s q; star_congruence (p `star` q) r (s `star` q) r in let aux (frame:slprop) : Lemma (requires interp ((r `star` frame) `star` locks_invariant e m0) m0) (ensures interp ((s `star` frame) `star` locks_invariant e m1) m1 /\ interp ((p `star` frame) `star` locks_invariant e m0) m0) [SMTPat (r `star` frame)] = aux0 p frame (locks_invariant e m0) r; aux0 q frame (locks_invariant e m1) s; assert (((p `star` frame) `star` locks_invariant e m0) `equiv` ((r `star` frame) `star` locks_invariant e m0)); assert (interp ((p `star` frame) `star` locks_invariant e m0) m0); assert (interp ((q `star` frame) `star` locks_invariant e m1) m1); assert (((q `star` frame) `star` locks_invariant e m1) `equiv` ((s `star` frame) `star` locks_invariant e m1)); () in () let pure_true_equiv (p:slprop) : Lemma ((p `star` pure True) `equiv` p) = FStar.Classical.forall_intro (pure_star_interp p True); emp_unit p; assert ((p `star` pure True) `equiv` p) let preserves_frame_star_pure (e:inames) (p q:slprop) (r s:prop) (m:mem) : Lemma (requires r /\ s) (ensures preserves_frame e p q m m <==> preserves_frame e (p `star` pure r) (q `star` pure s) m m) = pure_equiv r True; star_congruence p (pure r) p (pure True); pure_equiv s True; star_congruence q (pure s) q (pure True); pure_true_equiv p; pure_true_equiv q; let fwd () : Lemma (requires preserves_frame e p q m m) (ensures preserves_frame e (p `star` pure r) (q `star` pure s) m m) [SMTPat ()] = preserves_frame_cong e p q (p `star` pure r) (q `star` pure s) m m in let bk () : Lemma (requires preserves_frame e (p `star` pure r) (q `star` pure s) m m) (ensures preserves_frame e p q m m) [SMTPat ()] = preserves_frame_cong e (p `star` pure r) (q `star` pure s) p q m m in () let witness (#a:Type) (#pcm:pcm a) (e:inames) (r:erased (ref a pcm)) (fact:stable_property pcm) (v:Ghost.erased a) (_:squash (forall z. compatible pcm v z ==> fact z)) (frame:slprop) : MstTot (witnessed r fact) e (pts_to r v) (fun _ -> pts_to r v) frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in let _ : unit = let hr : H.ref a pcm = r in let v' = H.sel_v hr v (heap_of_mem m0) in assert (interp (H.ptr hr) m0 /\ H.sel #a #pcm hr (heap_of_mem m0) == v'); assert (compatible pcm v v'); assert (fact v'); assert (witnessed_ref r fact m0); witnessed_ref_stability r fact; assert (FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) in let w = NMSTTotal.witness _ mem_evolves (witnessed_ref r fact) in w let recall (#a:Type u#1) (#pcm:pcm a) (#fact:property a) (e:inames) (r:erased (ref a pcm)) (v:Ghost.erased a) (w:witnessed r fact) (frame:slprop) = let m0 = NMSTTotal.get () in NMSTTotal.recall _ mem_evolves (witnessed_ref r fact) w; let hr : H.ref a pcm = r in assert (witnessed_ref r fact m0); let v1 = H.sel_v hr v (heap_of_mem m0) in assert (compatible pcm v v1); assert (H.sel hr (heap_of_mem m0) == v1); assert (fact v1); assert (interp ((pts_to r v `star` frame) `star` locks_invariant e m0) m0); emp_unit ((pts_to r v `star` frame) `star` locks_invariant e m0); pure_star_interp ((pts_to r v `star` frame) `star` locks_invariant e m0) (fact v1) m0; assert (interp (((pts_to r v `star` frame) `star` locks_invariant e m0) `star` pure (fact v1)) m0); rearrange_pqr_prq (pts_to r v `star` frame) (locks_invariant e m0) (pure (fact v1)); assert (interp (((pts_to r v `star` frame) `star` pure (fact v1)) `star` locks_invariant e m0) m0); rearrange_pqr_prq (pts_to r v) frame (pure (fact v1)); star_congruence ((pts_to r v `star` frame) `star` pure (fact v1)) (locks_invariant e m0) ((pts_to r v `star` pure (fact v1)) `star` frame) (locks_invariant e m0); Ghost.hide v1 let iname_for_p_mem (i:iname) (p:slprop) : W.s_predicate mem = fun m -> iname_for_p i p m.locks let iname_for_p_stable (i:iname) (p:slprop) : Lemma (W.stable full_mem mem_evolves (iname_for_p_mem i p)) = () let ( >--> ) (i:iname) (p:slprop) : Type0 = W.witnessed full_mem mem_evolves (iname_for_p_mem i p) let hmem_with_inv_equiv e (m:mem) (p:slprop) : Lemma (interp (p `star` linv e m) m <==> interp (p `star` lock_store_invariant e m.locks) m /\ heap_ctr_valid m.ctr (heap_of_mem m)) = calc (<==>) { interp (p `star` linv e m) m; (<==>) { H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) } interp ((p `star` lock_store_invariant e m.locks) `star` ctr_validity m.ctr (heap_of_mem m)) m; (<==>) { H.pure_star_interp (p `star` lock_store_invariant e m.locks) (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_of_mem m) } interp ((p `star` lock_store_invariant e m.locks) `star` emp) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); (<==>) { H.emp_unit (p `star` lock_store_invariant e m.locks) } interp (p `star` lock_store_invariant e m.locks) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); } let new_invariant_tot_action (e:inames) (p:slprop) (m0:hmem_with_inv_except e p{ e `inames_in` m0.locks }) : Pure (iname & hmem_with_inv_except e emp) (requires True) (ensures fun (i, m1) -> iname_for_p_mem i p m1 /\ frame_related_mems p emp e m0 m1 /\ mem_evolves m0 m1) = let (| i, l1 |) = extend_lock_store e m0.locks p in let m1 = { m0 with locks = l1 } in assert (lock_store_invariant e m1.locks == p `star` lock_store_invariant e m0.locks); calc (equiv) { linv e m1; (equiv) {} (lock_store_invariant e m1.locks `star` ctr_validity m1.ctr (heap_of_mem m1)); (equiv) {} ((p `star` lock_store_invariant e m0.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); (equiv) { H.star_associative p (lock_store_invariant e m0.locks) (ctr_validity m1.ctr (heap_of_mem m1)) } (p `star` (lock_store_invariant e m0.locks `star` ctr_validity m1.ctr (heap_of_mem m1))); (equiv) { } (p `star` linv e m0); }; assert (iname_for_p_mem i p m1); assert (lock_store_evolves m0.locks l1); assert (mem_evolves m0 m1); hmem_with_inv_equiv e m0 p; assert (interp (p `star` lock_store_invariant e m0.locks) m1); assert (interp (lock_store_invariant e m1.locks) m1); H.emp_unit (lock_store_invariant e m1.locks); H.star_commutative (lock_store_invariant e m1.locks) emp; assert (interp (emp `star` lock_store_invariant e m1.locks) m1); hmem_with_inv_equiv e m1 emp; let m1 : hmem_with_inv_except e emp = m1 in let aux (frame:slprop) : Lemma (requires interp ((p `star` frame) `star` linv e m0) m0) (ensures interp ((emp `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) <==> mp (core_mem m1))) [SMTPat (p `star` frame)] = assert (interp ((p `star` frame) `star` linv e m0) m1); calc (equiv) { ((p `star` frame) `star` linv e m0); (equiv) { H.star_commutative p frame; H.star_congruence (p `star` frame) (linv e m0) (frame `star` p) (linv e m0); H.star_associative frame p (linv e m0) } (frame `star` (p `star` linv e m0)); (equiv) { H.star_congruence frame (p `star` linv e m0) frame (linv e m1) } (frame `star` linv e m1); (equiv) { H.emp_unit (frame `star` linv e m1); H.star_commutative (frame `star` linv e m1) emp; H.star_associative emp frame (linv e m1) } ((emp `star` frame) `star` linv e m1); }; assert (interp ((emp `star` frame) `star` linv e m1) m1) in assert (frame_related_mems p emp e m0 m1); ( i, m1 ) let name_is_ok (i:iname) (m0:full_mem u#1) : prop = i < List.Tot.length m0.locks let witnessed_name_is_ok (i:iname) = W.witnessed full_mem mem_evolves (name_is_ok i) let pre_inv = i:erased iname & witnessed_name_is_ok i let inv (p:slprop u#1) = i:erased iname & witnessed_name_is_ok i & (i >--> p) let pre_inv_of_inv #p (i:inv p) = let (|i, w, _|) = i in (|i,w|) let name_of_pre_inv (i:pre_inv) = dfst i let rec recall_all (ctx:list pre_inv) : NMSTTotal.NMSTATETOT unit (full_mem u#1) mem_evolves (requires fun _ -> True) (ensures fun m0 _ m1 -> m0==m1 /\ (forall i. i `List.Tot.memP` ctx ==> name_is_ok (name_of_pre_inv i) m0)) = match ctx with | [] -> () | hd::tl -> let (| q, i |) = hd in let i : W.witnessed full_mem mem_evolves (name_is_ok q) = i in NMSTTotal.recall _ mem_evolves (name_is_ok q) i; recall_all tl let fresh_invariant (e:inames) (p:slprop) (ctx:list pre_inv) (frame:slprop) : MstTot (i:inv p { not (mem_inv e i) /\ fresh_wrt ctx (name_of_inv i)}) e p (fun _ -> emp) frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in recall_all ctx; ac_reasoning_for_m_frame_preserving p frame (locks_invariant e m0) m0; assert (interp (p `star` locks_invariant e m0) m0); let r = new_invariant_tot_action e p m0 in let ( i, m1 ) = r in assert (i == List.Tot.length m0.locks); assert (not (Set.mem i e)); assert (mem_evolves m0 m1); NMSTTotal.put #full_mem #mem_evolves m1; iname_for_p_stable i p; let w = NMSTTotal.witness full_mem mem_evolves (iname_for_p_mem i p) in let w0 = NMSTTotal.witness full_mem mem_evolves (name_is_ok i) in (| hide i, w0, w |) let new_invariant (e:inames) (p:slprop) (frame:slprop) : MstTot (inv p) e p (fun _ -> emp) frame (fun _ -> True) (fun _ _ _ -> True) = fresh_invariant e p [] frame let rearrange_invariant (p q r : slprop) (q0 q1:slprop) : Lemma (requires q `equiv` (q0 `star` q1)) (ensures (p `star` (q `star` r)) `equiv` ((q0 `star` p) `star` (q1 `star` r))) = calc (equiv) { p `star` (q `star` r); (equiv) { calc (equiv) { (q `star` r); (equiv) { star_congruence q r (q0 `star` q1) r } (q0 `star` q1) `star` r; }; star_congruence p (q `star` r) p ((q0 `star` q1) `star` r) } (p `star` ((q0 `star` q1) `star` r)); (equiv) { star_associative q0 q1 r; star_congruence p ((q0 `star` q1) `star` r) p (q0 `star` (q1 `star` r)); star_associative p q0 (q1 `star` r) } (p `star` q0) `star` (q1 `star` r); (equiv) { star_commutative p q0; star_congruence (p `star` q0) (q1 `star` r) (q0 `star` p) (q1 `star` r) } (q0 `star` p) `star` (q1 `star` r); } let preserves_frame_invariant (fp fp':slprop) (opened_invariants:inames) (p:slprop) (i:inv p{not (mem_inv opened_invariants i)}) (m0:hmem_with_inv_except (add_inv opened_invariants i) (p `star` fp)) (m1:mem) : Lemma (requires preserves_frame (set_add (name_of_inv i) opened_invariants) (p `star` fp) (p `star` fp') m0 m1 /\ interp (fp' `star` linv opened_invariants m1) m1 /\ inames_ok opened_invariants m1 /\ (lock_store_invariant opened_invariants m0.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks)) /\ (lock_store_invariant opened_invariants m1.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks))) (ensures preserves_frame opened_invariants fp fp' m0 m1) = let aux (frame:slprop) : Lemma (requires interp ((fp `star` frame) `star` linv opened_invariants m0) m0) (ensures interp ((fp' `star` frame) `star` linv opened_invariants m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) [SMTPat()] = rearrange_invariant (fp `star` frame) (lock_store_invariant opened_invariants m0.locks) (ctr_validity m0.ctr (heap_of_mem m0)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks); assert (interp ((p `star` (fp `star` frame)) `star` linv (set_add (name_of_inv i) opened_invariants) m0) m0); star_associative p fp frame; star_congruence (p `star` (fp `star` frame)) (linv (set_add (name_of_inv i) opened_invariants) m0) ((p `star` fp) `star` frame) (linv (set_add (name_of_inv i) opened_invariants) m0); assert (interp (((p `star` fp) `star` frame) `star` linv (set_add (name_of_inv i) opened_invariants) m0) m0); assert (interp (((p `star` fp') `star` frame) `star` linv (set_add (name_of_inv i) opened_invariants) m1) m1); star_associative p fp' frame; star_congruence ((p `star` fp') `star` frame) (linv (set_add (name_of_inv i) opened_invariants) m1) (p `star` (fp' `star` frame)) (linv (set_add (name_of_inv i) opened_invariants) m1); assert (interp ((p `star` (fp' `star` frame)) `star` linv (set_add (name_of_inv i) opened_invariants) m1) m1); rearrange_invariant (fp' `star` frame) (lock_store_invariant opened_invariants m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks); assert (interp ((fp' `star` frame) `star` linv opened_invariants m1) m1); () in () let equiv_ext_right (p q r:slprop) : Lemma (requires q `equiv` r) (ensures (p `star` q) `equiv` (p `star` r)) = calc (equiv) { p `star` q; (equiv) { star_commutative p q } q `star` p; (equiv) { equiv_extensional_on_star q r p } r `star` p; (equiv) { star_commutative p r } p `star` r; }

{ "checked_file": "/", "dependencies": [ "Steel.Preorder.fst.checked", "Steel.Heap.fsti.checked", "prims.fst.checked", "FStar.Witnessed.Core.fsti.checked", "FStar.Set.fsti.checked", "FStar.Preorder.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.PCM.fst.checked", "FStar.NMSTTotal.fst.checked", "FStar.List.Tot.fst.checked", "FStar.IndefiniteDescription.fsti.checked", "FStar.Ghost.fsti.checked", "FStar.FunctionalExtensionality.fsti.checked", "FStar.Classical.Sugar.fsti.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Steel.Memory.fst" }

[ { "abbrev": true, "full_module": "Steel.Preorder", "short_module": "PP" }, { "abbrev": true, "full_module": "FStar.Witnessed.Core", "short_module": "W" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": true, "full_module": "Steel.Heap", "short_module": "H" }, { "abbrev": false, "full_module": "FStar.PCM", "short_module": null }, { "abbrev": false, "full_module": "FStar.FunctionalExtensionality", "short_module": null }, { "abbrev": true, "full_module": "FStar.FunctionalExtensionality", "short_module": "F" }, { "abbrev": false, "full_module": "FStar.PCM", "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

fp: Steel.Memory.slprop -> frame: Steel.Memory.slprop -> ls1: Steel.Memory.slprop -> ctr: Steel.Memory.slprop -> p: Steel.Memory.slprop -> ls2: Steel.Memory.slprop -> FStar.Pervasives.Lemma (requires Steel.Memory.equiv ls1 (Steel.Memory.star p ls2)) (ensures Steel.Memory.equiv (Steel.Memory.star (Steel.Memory.star fp frame) (Steel.Memory.star ls1 ctr)) (Steel.Memory.star (Steel.Memory.star (Steel.Memory.star p fp) frame) (Steel.Memory.star ls2 ctr)))

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Steel.Memory.slprop", "FStar.Calc.calc_finish", "Steel.Memory.equiv", "Steel.Memory.star", "Prims.Cons", "FStar.Preorder.relation", "Prims.Nil", "Prims.unit", "FStar.Calc.calc_step", "FStar.Calc.calc_init", "FStar.Calc.calc_pack", "Steel.Memory.equiv_ext_right", "Prims.squash", "Steel.Memory.star_associative", "Steel.Memory.equiv_extensional_on_star", "Steel.Memory.star_commutative", "FStar.Pervasives.pattern" ]

[]

false

true

false

let with_inv_helper (fp frame ls1 ctr p ls2: slprop) : Lemma (requires ls1 `equiv` (p `star` ls2)) (ensures ((fp `star` frame) `star` (ls1 `star` ctr)) `equiv` (((p `star` fp) `star` frame) `star` (ls2 `star` ctr))) =

calc (equiv) { ls1 `star` ctr; (equiv) { equiv_extensional_on_star ls1 (p `star` ls2) ctr } (p `star` ls2) `star` ctr; }; calc (equiv) { (p `star` ls2) `star` ctr; (equiv) { star_associative p ls2 ctr } p `star` (ls2 `star` ctr); }; calc (equiv) { (fp `star` frame) `star` p; (equiv) { star_commutative (fp `star` frame) p } p `star` (fp `star` frame); (equiv) { star_associative p fp frame } (p `star` fp) `star` frame; }; calc (equiv) { (fp `star` frame) `star` (ls1 `star` ctr); (equiv) { equiv_ext_right (fp `star` frame) (ls1 `star` ctr) ((p `star` ls2) `star` ctr) } (fp `star` frame) `star` ((p `star` ls2) `star` ctr); (equiv) { equiv_ext_right (fp `star` frame) ((p `star` ls2) `star` ctr) (p `star` (ls2 `star` ctr)) } (fp `star` frame) `star` (p `star` (ls2 `star` ctr)); (equiv) { star_associative (fp `star` frame) p (ls2 `star` ctr) } ((fp `star` frame) `star` p) `star` (ls2 `star` ctr); (equiv) { equiv_extensional_on_star ((fp `star` frame) `star` p) ((p `star` fp) `star` frame) (ls2 `star` ctr) } ((p `star` fp) `star` frame) `star` (ls2 `star` ctr); }

false

Platform.Bytes.fst

Platform.Bytes.byte

val byte:Type0

let byte:Type0 = FStar.UInt8.t

{ "file_name": "ucontrib/Platform/fst/Platform.Bytes.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }

{ "end_col": 37, "end_line": 54, "start_col": 7, "start_line": 54 }

(* Copyright 2008-2018 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 Platform.Bytes assume val repr_bytes : nat -> GTot (n:nat{n>0}) (* Integer literals are currently extracted to int32, rather than bigint, so the definition below breaks extraction: Unexpected error; please file a bug report, ideally with a minimized version of the source program that triggered the error. int_of_string Also, defining repr_bytes n <= 8 for all n is dubious *) (* let repr_bytes n = if n < 256 then 1 else if n < 65536 then 2 else if n < 16777216 then 3 else if n < 4294967296 then 4 else if n < 1099511627776 then 5 else if n < 281474976710656 then 6 else if n < 72057594037927936 then 7 else 8 *) (* NS: The two assumes below were previously defined as axioms. They are evil! They pollute the global environment and slow down verification enormously. I've made them assumed lemmas; if you want to make use of these axioms, call the lemmas as needed in the context. *) assume val lemma_repr_bytes_values: n:nat -> Lemma ( ( n < 256 <==> repr_bytes n = 1 ) /\ ( (n >= 256 /\ n < 65536) <==> repr_bytes n = 2 ) /\ ( (n >= 65536 /\ n < 16777216) <==> repr_bytes n = 3 ) /\ ( (n >= 16777216 /\ n < 4294967296) <==> repr_bytes n = 4 ) /\ ( (n >= 4294967296 /\ n < 1099511627776) <==> repr_bytes n = 5 ) /\ ( (n >= 1099511627776 /\ n < 281474976710656) <==> repr_bytes n = 6 ) /\ ( (n >= 281474976710656 /\ n < 72057594037927936) <==> repr_bytes n = 7 ) /\ ( (n >= 72057594037927936 /\ n < 18446744073709551616) <==> repr_bytes n = 8 ) )

{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.UInt8.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked" ], "interface_file": false, "source_file": "Platform.Bytes.fst" }

[ { "abbrev": false, "full_module": "Platform", "short_module": null }, { "abbrev": false, "full_module": "Platform", "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

Type0

Prims.Tot

[ "total" ]

[]

[ "FStar.UInt8.t" ]

[]

false

true

let byte:Type0 =

FStar.UInt8.t

false

Steel.Memory.fst

Steel.Memory.lift_h_exists

val lift_h_exists (#opened_invariants:_) (#a:_) (p:a -> slprop) : action_except unit opened_invariants (h_exists p) (fun _a -> h_exists #(U.raise_t a) (U.lift_dom p))

let lift_h_exists #opened_invariants p = lift_tot_action (lift_heap_action opened_invariants (H.lift_h_exists p))

{ "file_name": "lib/steel/Steel.Memory.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 113, "end_line": 1556, "start_col": 0, "start_line": 1556 }

(* 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.Memory module F = FStar.FunctionalExtensionality open FStar.FunctionalExtensionality open FStar.PCM module H = Steel.Heap noeq type lock_state : Type u#(a + 1) = | Invariant : inv:H.slprop u#a -> lock_state let lock_store : Type u#(a+1) = list (lock_state u#a) noeq type mem : Type u#(a + 1) = { ctr: nat; heap: H.heap u#a; locks: lock_store u#a; } let heap_of_mem (x:mem) : H.heap = x.heap let mem_of_heap (h:H.heap) : mem = { ctr = 0; heap = h; locks = [] } let mem_set_heap (m:mem) (h:H.heap) : mem = { ctr = m.ctr; heap = h; locks = m.locks; } let core_mem (m:mem) : mem = mem_of_heap (heap_of_mem m) let core_mem_invol m = () let disjoint (m0 m1:mem u#h) : prop = m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks let disjoint_sym m0 m1 = () let join m0 m1 = { ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = m0.locks } let join_commutative m0 m1 = H.join_commutative m0.heap m1.heap let disjoint_join m0 m1 m2 = H.disjoint_join m0.heap m1.heap m2.heap let join_associative m0 m1 m2 = H.join_associative m0.heap m1.heap m2.heap let slprop = H.slprop let interp p m = H.interp p m.heap let equiv p1 p2 = forall m. interp p1 m <==> interp p2 m let slprop_extensionality p q = assert (forall m. interp p m <==> interp q m); let aux (h:H.heap) : Lemma (H.interp p h <==> H.interp q h) [SMTPat (H.interp p h)] = let m : mem = { ctr = 0; heap = h; locks = [] } in assert (interp p m <==> interp q m) in assert (forall h. H.interp p h <==> H.interp q h); Steel.Heap.slprop_extensionality p q let reveal_equiv p1 p2 = () let core_ref = H.core_ref let core_ref_null = H.core_ref_null let core_ref_is_null r = H.core_ref_is_null r let emp : slprop u#a = H.emp let pure = H.pure let pts_to = H.pts_to let h_and = H.h_and let h_or = H.h_or let star = H.star let wand = H.wand let h_exists = H.h_exists let h_forall = H.h_forall //////////////////////////////////////////////////////////////////////////////// //properties of equiv //////////////////////////////////////////////////////////////////////////////// let equiv_symmetric (p1 p2:slprop u#a) = H.equiv_symmetric p1 p2 #push-options "--warn_error -271" let equiv_heap_iff_equiv (p1 p2:slprop u#a) : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat (equiv p1 p2)] = let aux_lr () : Lemma (requires H.equiv p1 p2) (ensures equiv p1 p2) [SMTPat ()] = () in let aux_rl_helper1 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p1 h) (ensures H.interp p2 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl_helper2 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p2 h) (ensures H.interp p1 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl () : Lemma (requires equiv p1 p2) (ensures H.equiv p1 p2) [SMTPat ()] = () in () let equiv_heap_iff_equiv_forall () : Lemma (ensures (forall p1 p2. H.equiv p1 p2 <==> equiv p1 p2)) = let aux p1 p2 : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat ()] = equiv_heap_iff_equiv p1 p2 in () #pop-options let equiv_extensional_on_star (p1 p2 p3:slprop u#a) = equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3 let emp_unit p = H.emp_unit p let intro_emp m = H.intro_emp (heap_of_mem m) let pure_equiv p q = H.pure_equiv p q let pure_interp q m = H.pure_interp q (heap_of_mem m) let pure_star_interp p q m = H.pure_star_interp p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// //pts_to //////////////////////////////////////////////////////////////////////////////// let pts_to_compatible #a #pcm x v0 v1 m = H.pts_to_compatible #a #pcm x v0 v1 (heap_of_mem m) let pts_to_compatible_equiv #a #pcm x v0 v1 = H.pts_to_compatible_equiv #a #pcm x v0 v1 let pts_to_not_null #a #pcm x v m = H.pts_to_not_null #a #pcm x v (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // star //////////////////////////////////////////////////////////////////////////////// let intro_star p q mp mq = H.intro_star p q (heap_of_mem mp) (heap_of_mem mq) let elim_star p q m = let h = heap_of_mem m in H.elim_star p q h; assert (exists hl hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr); let hl = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hl -> exists hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let hr = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hr -> H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let ml = mem_set_heap m hl in let mr = mem_set_heap m hr in assert (disjoint ml mr); assert (m == join ml mr); assert (interp p ml); assert (interp q mr); () let interp_star (p q: slprop) (m: mem) : Lemma (interp (p `star` q) m <==> (exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m)) = let left = interp (p `star` q) m in let right = exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m in let f () : Lemma (requires left) (ensures right) = elim_star p q m in let g () : Lemma (requires right) (ensures left) = Classical.exists_elim left #_ #(fun mp -> exists (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mp -> Classical.exists_elim left #_ #(fun mq -> disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mq -> intro_star p q mp mq ) ) in Classical.move_requires f (); Classical.move_requires g () let star_commutative (p1 p2:slprop) = H.star_commutative p1 p2 let star_associative (p1 p2 p3:slprop) = H.star_associative p1 p2 p3 let star_congruence (p1 p2 p3 p4:slprop) = equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4 let affine_star (p q:slprop) (m:mem) = H.affine_star p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // Invariants on the lock store //////////////////////////////////////////////////////////////////////////////// let iname = nat module S = FStar.Set module L = FStar.List.Tot module W = FStar.Witnessed.Core let rec lock_store_invariant (e:inames) (l:lock_store u#a) : slprop u#a = let current_addr = L.length l - 1 in match l with | [] -> emp | Invariant p :: tl -> if current_addr `S.mem` e then lock_store_invariant e tl else p `star` lock_store_invariant e tl let lock_i (i:iname) (l:lock_store { i < L.length l }) = let ix = L.length l - i - 1 in L.index l ix let iname_for_p (i:iname) (p:slprop) : W.s_predicate lock_store = fun l -> i < L.length l /\ (lock_i i l).inv == p let lock_store_evolves : FStar.Preorder.preorder lock_store = fun (l1 l2 : lock_store) -> L.length l2 >= L.length l1 /\ (forall (i:nat{i < L.length l1}). (lock_i i l1).inv == (lock_i i l2).inv) let inames_in (e:inames) (l:lock_store) : prop = forall i. Set.mem i e ==> i < L.length l let inames_ok e m = inames_in e m.locks let inames_ok_empty m = () let extend_lock_store (e:inames) (l:lock_store{e `inames_in` l}) (p:slprop) : i:iname & l':lock_store { lock_store_invariant e l' == p `star` lock_store_invariant e l /\ iname_for_p i p l' } = (| L.length l, Invariant p :: l |) let set_add (i:iname) (s:inames) = Set.union (Set.singleton i) s let rec move_invariant (e:inames) (l:lock_store) (p:slprop) (i:iname{iname_for_p i p l /\ ~(i `Set.mem` e)}) : Lemma (H.equiv (lock_store_invariant e l) (p `star` lock_store_invariant (set_add i e) l)) = let rec aux (i:iname) (m:lock_store) : Lemma (requires i >= L.length m) (ensures (lock_store_invariant e m `H.equiv` lock_store_invariant (set_add i e) m)) = match m with | [] -> () | Invariant p::tl -> aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl) in let current_addr = L.length l - 1 in match l with | [] -> () | Invariant q::tl -> if i = current_addr then begin assert (lock_store_invariant e l == p `star` lock_store_invariant e tl); aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl); () end else begin move_invariant e tl p i; assert (lock_store_invariant e tl `equiv` (p `star` lock_store_invariant (set_add i e) tl)); H.star_congruence q (lock_store_invariant e tl) q (p `star` lock_store_invariant (set_add i e) tl); if Set.mem current_addr e then () else begin let r = lock_store_invariant (set_add i e) tl in assert (lock_store_invariant e l `equiv` (q `star` (p `star` r))); H.star_associative q p r; H.star_commutative q p; H.star_congruence (q `star` p) r (p `star` q) r; H.star_associative p q r end end let heap_ctr_valid (ctr:nat) (h:H.heap u#a) : prop = h `H.free_above_addr` ctr let ctr_validity (ctr:nat) (h:H.heap) : slprop = H.pure (heap_ctr_valid ctr h) let locks_invariant (e:inames) (m:mem u#a) : slprop u#a = lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m) let full_mem_pred (m:mem) = H.full_heap_pred (heap_of_mem m) (***** Following lemmas are needed in Steel.Effect *****) let core_mem_interp (hp:slprop u#a) (m:mem u#a) = () let interp_depends_only_on (hp:slprop u#a) = H.interp_depends_only_on hp let a_mem_prop_as_a_heap_prop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (H.a_heap_prop u#a) = let g (h: H.heap u#a) : Tot prop = interp sl (mem_of_heap h) /\ f (mem_of_heap h) in let phi0 (h0 h1: H.heap u#a) : Lemma (requires (g h0 /\ H.disjoint h0 h1)) (ensures (g h0 /\ H.disjoint h0 h1 /\ g (H.join h0 h1))) = assert (mem_of_heap (H.join h0 h1) == mem_of_heap h0 `join` mem_of_heap h1); interp_depends_only_on sl in let phi1 (h0 h1: H.heap u#a) : Lemma (ensures ((g h0 /\ H.disjoint h0 h1) ==> g (H.join h0 h1))) = Classical.move_requires (phi0 h0) h1 in Classical.forall_intro_2 phi1; g let refine_slprop sl f = H.as_slprop (a_mem_prop_as_a_heap_prop sl f) let interp_refine_slprop sl f m = assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_mem m)) let dep_hprop (s: slprop) (f: (hmem s -> Tot slprop)) (h: H.heap) : Tot prop = exists (h1: H.heap) . exists (h2: H.heap) . interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 let dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq' : squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h')) = let p2 (h h1 h2: H.heap) : Tot prop = interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 in let p1 (h h1: H.heap) : Tot prop = (exists h2 . p2 h h1 h2) in let h1 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p1 h) in let h2 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p2 h h1) in H.disjoint_join h' h1 h2; assert (H.disjoint h2 h'); let h2' = H.join h2 h' in H.join_commutative h2 h' ; assert (h2' == H.join h' h2); assert (H.disjoint h1 h2'); assert (mem_of_heap h2' == mem_of_heap h2 `join` mem_of_heap h'); interp_depends_only_on (f (mem_of_heap h1)); assert (interp (f (mem_of_heap h1)) (mem_of_heap h2')); H.join_commutative h1 h2; H.join_associative h' h2 h1; H.join_commutative h' h; H.join_commutative h2' h1; assert (H.join h h' == h1 `H.join` h2') let impl_intro_gen (#p: Type0) (#q: Type0) ($prf: (squash p -> Lemma (q ))) : Lemma (p ==> q) = Classical.impl_intro_gen #p #(fun _ -> q) prf let dep_hprop_is_affine1 (s: slprop) (f: (hmem s -> Tot slprop)) (h0 h1: H.heap) : Lemma ((dep_hprop s f h0 /\ H.disjoint h0 h1) ==> (H.disjoint h0 h1 /\ dep_hprop s f (H.join h0 h1))) = impl_intro_gen (dep_hprop_is_affine0 s f h0 h1) let dep_hprop_is_affine (s: slprop) (f: (hmem s -> Tot slprop)) : Lemma (H.heap_prop_is_affine (dep_hprop s f)) = Classical.forall_intro_2 (dep_hprop_is_affine1 s f) let sdep (s: slprop) (f: (hmem s -> Tot slprop)) : Tot slprop = dep_hprop_is_affine s f; H.as_slprop (dep_hprop s f) let interp_sdep (s: slprop) (f: (hmem s -> Tot slprop)) (m: mem) : Lemma (requires (dep_slprop_is_affine s f)) (ensures ( interp (sdep s f) m <==> (exists m1 m2 . interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) )) = dep_hprop_is_affine s f; assert (forall m1 m2 . (interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) ==> ( interp s (mem_of_heap m1.heap) /\ interp (f (mem_of_heap m1.heap)) (mem_of_heap m2.heap) /\ H.disjoint m1.heap m2.heap /\ H.join m1.heap m2.heap == m.heap )); interp_depends_only_on s; Classical.forall_intro (fun m -> interp_depends_only_on (f m)); assert (forall h1 h2 . (interp s (mem_of_heap h1) /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ H.disjoint h1 h2 /\ H.join h1 h2 == m.heap) ==> ( core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ interp s (core_mem (mem_of_heap h1)) /\ interp s (mem_set_heap m h1) /\ core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ f (mem_set_heap m h1) `equiv` f (mem_of_heap h1) /\ interp (f (mem_set_heap m h1)) (mem_of_heap h2) /\ interp (f (mem_set_heap m h1)) (mem_set_heap m h2) /\ disjoint (mem_set_heap m h1) (mem_set_heap m h2) /\ join (mem_set_heap m h1) (mem_set_heap m h2) == m )); () let h_exists_cong (#a:Type) (p q : a -> slprop) : Lemma (requires (forall x. p x `equiv` q x)) (ensures (h_exists p `equiv` h_exists q)) = equiv_heap_iff_equiv_forall (); H.h_exists_cong p q let intro_h_exists #a x p m = H.intro_h_exists x p (heap_of_mem m) let elim_h_exists (#a:_) (p:a -> slprop) (m:mem) = H.elim_h_exists p (heap_of_mem m) let intro_h_forall (#a:_) (p:a -> slprop) (m:mem) = H.intro_h_forall p (heap_of_mem m) let elim_h_forall (#a:_) (p:a -> slprop) (m:mem) (x:a) = H.elim_h_forall p (heap_of_mem m) x let intro_h_and (p q: slprop) (m:mem) = H.intro_h_and p q (heap_of_mem m) let elim_h_and (p q: slprop) (m:mem) = H.elim_h_and p q (heap_of_mem m) let intro_h_or_left (p q: slprop) (m:mem) = H.intro_h_or_left p q (heap_of_mem m) let intro_h_or_right (p q: slprop) (m:mem) = H.intro_h_or_right p q (heap_of_mem m) let elim_h_or (p q: slprop) (m:mem) = H.elim_h_or p q (heap_of_mem m) let intro_wand (p1 p2: slprop u#a) (m:mem) = introduce (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)) ==> interp (wand p1 p2) m with _. ( assert (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)); H.intro_wand p1 p2 (heap_of_mem m); let h = heap_of_mem m in assert ((forall h1. h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) ==> H.interp (wand p1 p2) h); introduce forall h1. (h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) with ( introduce (h `H.disjoint` h1 /\ H.interp p1 h1) ==> H.interp p2 (H.join h h1) with _. ( assert (h `H.disjoint` h1); let m1 = { ctr = m.ctr; heap = h1; locks = m.locks } in assert (m `disjoint` m1) ) ) ) (** Eliminating a wand by proving a heap that satisfies the LHS **) let elim_wand (p1 p2: slprop u#a) (m:mem) (m1:mem) = H.elim_wand p1 p2 (heap_of_mem m) (heap_of_mem m1) //////////////////////////////////////////////////////////////////////////////// // Preorders and effects //////////////////////////////////////////////////////////////////////////////// module PP = Steel.Preorder let mem_evolves = fun (m0 m1:full_mem) -> H.heap_evolves (heap_of_mem m0) (heap_of_mem m1) /\ m0.ctr <= m1.ctr /\ lock_store_evolves m0.locks m1.locks (** See [Steel.Heap.is_frame_preserving]. We add in [lock_invariants] now *) let preserves_frame (e:inames) (pre post:slprop) (m0 m1:mem) = forall (frame:slprop). interp ((pre `star` frame) `star` locks_invariant e m0) m0 ==> (interp ((post `star` frame) `star` locks_invariant e m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) (** This is a version of MstTot with frame quantified, as part of preserves_frame *) effect MstTotNF (a:Type u#a) (except:inames) (expects:slprop u#1) (provides: a -> slprop u#1) = NMSTTotal.NMSTATETOT a (full_mem u#1) mem_evolves (requires fun m0 -> inames_ok except m0 /\ interp (expects `star` locks_invariant except m0) m0) (ensures fun m0 x m1 -> inames_ok except m1 /\ interp (provides x `star` locks_invariant except m1) m1 /\ preserves_frame except expects (provides x) m0 m1) //////////////////////////////////////////////////////////////////////////////// // Lifting heap actions //////////////////////////////////////////////////////////////////////////////// (** Heap actions come in two equivalent flavors: - one that take an explicit frame as argument (action_with_frame) - and one that quantify over all the frame We therefore define two lift routes: - a direct route for those with explicit frame - via MstTotNF for the rest *) let tot_pre_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = hmem_with_inv_except e fp -> (x:a & hmem_with_inv_except e (fp' x)) let tot_pre_action_nf = tot_pre_action_nf_except S.empty let ac_reasoning_for_m_frame_preserving (p q r:slprop u#a) (m:mem u#a) : Lemma (requires interp ((p `star` q) `star` r) m) (ensures interp (p `star` r) m) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_commutative p q; equiv_extensional_on_star (p `star` q) (q `star` p) r } (q `star` p) `star` r; (equiv) { star_associative q p r } q `star` (p `star` r); }; assert (interp (q `star` (p `star` r)) m); affine_star q (p `star` r) m let is_frame_preserving (#e:inames) (#a:Type u#b) (#fp:slprop u#a) (#fp':a -> slprop u#a) (f:tot_pre_action_nf_except e fp a fp') = forall (frame:slprop u#a) (m0:hmem_with_inv_except e (fp `star` frame)). (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = f:tot_pre_action_nf_except e fp a fp'{ is_frame_preserving f } let tot_action_nf = tot_action_nf_except S.empty let linv e (m:mem) = locks_invariant e m let hheap_of_hmem #fp #e (m:hmem_with_inv_except e fp) : h:H.hheap (fp `star` linv e m) { h `H.free_above_addr` m.ctr} = let h = heap_of_mem m in H.pure_interp (heap_ctr_valid m.ctr (heap_of_mem m)) h; h let hmem_of_hheap #e (#fp0 #fp1:slprop) (m:hmem_with_inv_except e fp0) (h:H.full_hheap (fp1 `star` linv e m) { h `Heap.free_above_addr` m.ctr }) : m1:hmem_with_inv_except e fp1{linv e m `equiv` linv e m1} = let m1 : mem = { m with heap = h } in assert (interp (fp1 `star` linv e m) m1); star_commutative fp1 (linv e m); assert (interp (linv e m `star` fp1) m1); assert (linv e m1 == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); assert (linv e m == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m)); H.pure_interp (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_of_mem m); assert (heap_ctr_valid m1.ctr (heap_of_mem m) <==> heap_ctr_valid m1.ctr (heap_of_mem m1)); H.pure_equiv (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_ctr_valid m1.ctr (heap_of_mem m1)); H.star_congruence (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m)); assert (linv e m `equiv` linv e m1); let _ = equiv_extensional_on_star (linv e m) (linv e m1) fp1 in assert ((linv e m `star` fp1) `equiv` (linv e m1 `star` fp1)); assert (interp (linv e m1 `star` fp1) m1); star_commutative (linv e m1) fp1; assert (interp (fp1 `star` linv e m1) m1); m1 let with_inv_except (m:mem) e (fp:slprop) = interp (fp `star` locks_invariant e m) m #push-options "--warn_error -271" let as_hprop (frame:slprop) (mp:mprop frame) : hp:H.hprop frame{forall m. mp (core_mem m) == hp (heap_of_mem m)} = let f = fun h -> mp (mem_of_heap h) in assert (forall m. mp (core_mem m) == f (heap_of_mem m)); let aux (m0:H.hheap frame) (m1:H.heap{H.disjoint m0 m1}) : Lemma (ensures (mem_of_heap (H.join m0 m1) == join (mem_of_heap m0) (mem_of_heap m1))) [SMTPat ()] = () in f let mprop_preservation_of_hprop_preservation (p:slprop) (m0 m1:mem) : Lemma (requires (forall (hp:H.hprop p). hp (heap_of_mem m0) == hp (heap_of_mem m1))) (ensures (forall (mp:mprop p). mp (core_mem m0) == mp (core_mem m1))) = let aux (mp:mprop p) : Lemma (mp (core_mem m0) == mp (core_mem m1)) [SMTPat()] = assert (as_hprop p mp (heap_of_mem m0) == as_hprop p mp (heap_of_mem m1)) in () let lift_heap_action (#fp:slprop) (#a:Type) (#fp':a -> slprop) (e:inames) ($f:H.action fp a fp') : tot_action_nf_except e fp a fp' = let g : tot_pre_action_nf_except e fp a fp' = fun m -> let h0 = hheap_of_hmem m in let (| x, h' |) = f h0 in (| x, hmem_of_hheap m h' |) in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in let h0 = hheap_of_hmem m0 in let (| x', h1 |) = f h0 in H.action_framing f (linv e m0) h0; assert (x == x'); star_associative fp frame (linv e m0); H.action_framing f (frame `star` linv e m0) h0; assert (H.interp ((fp' x) `star` (frame `star` linv e m0)) h1); star_associative (fp' x) frame (linv e m0); assert (H.interp ((fp' x `star` frame) `star` linv e m0) h1); let h1' : H.hheap ((fp' x `star` frame) `star` linv e m0) = h1 in assert (m1 == hmem_of_hheap m0 h1'); assert (with_inv_except m1 e (fp' x `star` frame)); assert (forall (hp:H.hprop frame). hp h0 == hp h1); mprop_preservation_of_hprop_preservation frame m0 m1; () in assert (is_frame_preserving g); g let frame_preserving_respects_preorder #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (m0:hmem_with_inv_except e fp) : Lemma (let (| x, m1 |) = f m0 in mem_evolves m0 m1) = let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1) = () in H.emp_unit fp; assert (interp (fp `star` linv e m0) m0); H.star_congruence (fp `star` emp) (linv e m0) fp (linv e m0); assert (interp ((fp `star` emp) `star` linv e m0) m0); aux emp m0 let lift_tot_action_nf #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') : MstTotNF a e fp fp' = let m0 = NMSTTotal.get () in let m0' : hmem_with_inv_except e fp = m0 in let r = f m0' in let (| x, m1 |) = r in let m1' : hmem_with_inv_except e (fp' x) = m1 in assert (is_frame_preserving f); assert (m1 == dsnd (f m0)); frame_preserving_respects_preorder f m0; NMSTTotal.put #_ #(mem_evolves) m1; x let lift_tot_action #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get #(full_mem) #_ () in ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); lift_tot_action_nf f (** Now defining the lift for heap actions with explicit frame *) let tot_action_with_frame_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = frame:slprop u#a -> m0:hmem_with_inv_except e (fp `star` frame) -> Pure (x:a & hmem_with_inv_except e (fp' x `star` frame)) (requires True) (ensures fun (| x, m1 |) -> mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_with_frame = tot_action_with_frame_except S.empty let lift_heap_action_with_frame (#fp:slprop u#a) (#a:Type u#b) (#fp':a -> slprop u#a) (e:inames) ($f:H.action_with_frame fp a fp') : tot_action_with_frame_except e fp a fp' = fun frame m0 -> let h0 = hheap_of_hmem m0 in calc (equiv) { fp `star` frame `star` locks_invariant e m0; (equiv) { star_associative fp frame (locks_invariant e m0) } fp `star` (frame `star` locks_invariant e m0); }; assert (H.interp (fp `star` frame `star` locks_invariant e m0) h0); assert (H.interp (fp `star` (frame `star` locks_invariant e m0)) h0); //key: apply the heap action with frame * locks_invariant e m0 let (| x, h1 |) = f (frame `star` locks_invariant e m0) h0 in calc (equiv) { fp' x `star` (frame `star` locks_invariant e m0); (equiv) { star_associative (fp' x) frame (locks_invariant e m0) } fp' x `star` frame `star` locks_invariant e m0; }; assert (H.interp (fp' x `star` (frame `star` locks_invariant e m0)) h1); assert (H.interp (fp' x `star` frame `star` locks_invariant e m0) h1); let m1 = hmem_of_hheap m0 h1 in assert (mem_evolves m0 m1); mprop_preservation_of_hprop_preservation (frame `star` locks_invariant e m0) m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)); (| x, m1 |) let lift_tot_action_with_frame #a #e #fp #fp' ($f:tot_action_with_frame_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in assert (inames_ok e m0); ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); let m0' : hmem_with_inv_except e fp = m0 in let r = f frame m0' in let (| x, m1 |) = r in ac_reasoning_for_m_frame_preserving (fp' x) frame (locks_invariant e m1) m1; assert (interp (fp' x `star` frame `star` locks_invariant e m1) m1); assert (interp (fp' x `star` locks_invariant e m1) m1); let m1' : hmem_with_inv_except e (fp' x) = m1 in NMSTTotal.put #_ #(mem_evolves) m1; x let sel_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.sel_action #a #pcm r v0)) let upd_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.upd_action #a #pcm r v0 v1)) let free_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.free_action #a #pcm r v0)) let split_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.split_action #a #pcm r v0 v1)) let gather_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.gather_action #a #pcm r v0 v1)) let weaken (p q r:slprop) (h:H.hheap (p `star` q) { H.stronger q r }) : H.hheap (p `star` r) = H.weaken p q r h; h let weaken_pure (q r: prop) : Lemma (requires (q ==> r)) (ensures H.stronger (H.pure q) (H.pure r)) = let aux (h:H.heap) : Lemma (ensures (H.interp (H.pure q) h ==> H.interp (H.pure r) h)) [SMTPat ()] = H.pure_interp q h; H.pure_interp r h in () let inc_ctr (#p:slprop) #e (m:hmem_with_inv_except e p) : m':hmem_with_inv_except e p{m'.ctr = m.ctr + 1 /\ H.stronger (linv e m) (linv e m')} = let m' : mem = { m with ctr = m.ctr + 1} in assert (interp (p `star` linv e m) m'); assert (linv e m == lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m)); assert (linv e m' == lock_store_invariant e m.locks `star` ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken_free_above (heap_of_mem m) m.ctr (m.ctr + 1); weaken_pure (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_ctr_valid (m.ctr + 1) (heap_of_mem m)); assert (H.stronger (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m))); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)); H.stronger_star (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken (p `star` lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)) (heap_of_mem m'); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity (m.ctr + 1) (heap_of_mem m)); let m' : hmem_with_inv_except e p = m' in m' let frame_related_mems (fp0 fp1:slprop u#a) e (m0:hmem_with_inv_except e fp0) (m1:hmem_with_inv_except e fp1) = forall (frame:slprop u#a). interp ((fp0 `star` frame) `star` linv e m0) m0 ==> interp ((fp1 `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) let refined_pre_action e (fp0:slprop) (a:Type) (fp1:a -> slprop) = m0:hmem_with_inv_except e fp0 -> Pure (x:a & hmem_with_inv_except e (fp1 x)) (requires True) (ensures fun (| x, m1 |) -> frame_related_mems fp0 (fp1 x) e m0 m1) let refined_pre_action_as_action (#fp0:slprop) (#a:Type) (#fp1:a -> slprop) #e ($f:refined_pre_action e fp0 a fp1) : tot_action_nf_except e fp0 a fp1 = let g : tot_pre_action_nf_except e fp0 a fp1 = fun m -> f m in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp0 `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp1 x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x', m1' |) = g m0 in let (| x, m1 |) = f m0 in assert (x == x' /\ m1 == m1') in g let alloc_action #a #pcm e x = let f : refined_pre_action e emp (ref a pcm) (fun r -> pts_to r x) = fun m0 -> (* NS: 9/29/22 I needed to annotate h : Heap.full_heap, for use with the Core checker which generates a guard for checking the implicit pattern "dot" term in the dependent pair pattern on the next line. That guard expects `h` to be a full_heap, which is it, because it is a projection of m0. However, this is not reflected in `h`'s type. So, the Core checker, which produces a guard for the pat_dot_term in isolation, cannot recheck the term. If we were to fold in the checking of pat_dot_terms and their guards with the rest of the VC, this would work. *) let h : Heap.full_heap = hheap_of_hmem m0 in let (|r, h'|) = H.extend #a #pcm x m0.ctr h in let m' : hmem_with_inv_except e emp = inc_ctr m0 in let h' : H.hheap (pts_to #a #pcm r x `star` linv e m') = weaken _ (linv e m0) (linv e m') h' in let m1 : hmem_with_inv_except e (pts_to #a #pcm r x) = hmem_of_hheap m' h' in assert (forall frame. H.frame_related_heaps h h' emp (pts_to #a #pcm r x) frame true); let aux (frame:slprop) : Lemma (requires interp ((emp `star` frame) `star` linv e m0) m0) (ensures interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) [SMTPat (emp `star` frame)] = star_associative emp frame (linv e m0); assert (H.interp (emp `star` (frame `star` linv e m0)) h); assert (H.interp (pts_to #a #pcm r x `star` (frame `star` linv e m0)) h'); star_associative (pts_to #a #pcm r x) frame (linv e m0); assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m0) h'); assert (H.stronger (linv e m0) (linv e m')); assert (H.equiv (linv e m') (linv e m1)); assert (H.stronger (linv e m0) (linv e m1)); let h' : H.hheap ((pts_to #a #pcm r x `star` frame) `star` linv e m1) = weaken _ (linv e m0) (linv e m1) h' in assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) h'); assert (forall (mp:H.hprop frame). mp h == mp h'); mprop_preservation_of_hprop_preservation frame m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) in assert (frame_related_mems emp (pts_to r x) e m0 m1); (| r, m1 |) in lift_tot_action (refined_pre_action_as_action f) let select_refine #a #p e r x f = lift_tot_action (lift_heap_action e (H.select_refine #a #p r x f)) let upd_gen #a #p e r x y f = lift_tot_action (lift_heap_action e (H.upd_gen_action r x y f)) //////////////////////////////////////////////////////////////////////////////// // witness / recall //////////////////////////////////////////////////////////////////////////////// let witnessed_ref #a #pcm (r:ref a pcm) (fact:property a) (m:full_mem) = H.witnessed_ref #a #pcm r fact (heap_of_mem m) let witnessed_ref_stability #a #pcm (r:ref a pcm) (fact:property a) : Lemma (requires FStar.Preorder.stable fact (Steel.Preorder.preorder_of_pcm pcm)) (ensures FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) = H.witnessed_ref_stability #a #pcm r fact let witnessed (#a:Type u#1) (#pcm:pcm a) (r:ref a pcm) (fact:property a) = W.witnessed _ mem_evolves (witnessed_ref r fact) let rearrange_pqr_prq (p q r:slprop) : Lemma (((p `star` q) `star` r) `equiv` ((p `star` r) `star` q)) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_associative p q r } p `star` (q `star` r); (equiv) { star_commutative q r; star_congruence p (q `star` r) p (r `star` q) } p `star` (r `star` q); (equiv) { star_associative p r q } (p `star` r) `star` q; } let preserves_frame_cong (e:inames) (p q:slprop) (r s:slprop) (m0 m1:mem) : Lemma (requires p `equiv` r /\ q `equiv` s /\ preserves_frame e p q m0 m1) (ensures preserves_frame e r s m0 m1) = let aux0 (p q r s:slprop) : Lemma (requires p `equiv` s) (ensures (((p `star` q) `star` r) `equiv` ((s `star` q) `star` r))) = star_congruence p q s q; star_congruence (p `star` q) r (s `star` q) r in let aux (frame:slprop) : Lemma (requires interp ((r `star` frame) `star` locks_invariant e m0) m0) (ensures interp ((s `star` frame) `star` locks_invariant e m1) m1 /\ interp ((p `star` frame) `star` locks_invariant e m0) m0) [SMTPat (r `star` frame)] = aux0 p frame (locks_invariant e m0) r; aux0 q frame (locks_invariant e m1) s; assert (((p `star` frame) `star` locks_invariant e m0) `equiv` ((r `star` frame) `star` locks_invariant e m0)); assert (interp ((p `star` frame) `star` locks_invariant e m0) m0); assert (interp ((q `star` frame) `star` locks_invariant e m1) m1); assert (((q `star` frame) `star` locks_invariant e m1) `equiv` ((s `star` frame) `star` locks_invariant e m1)); () in () let pure_true_equiv (p:slprop) : Lemma ((p `star` pure True) `equiv` p) = FStar.Classical.forall_intro (pure_star_interp p True); emp_unit p; assert ((p `star` pure True) `equiv` p) let preserves_frame_star_pure (e:inames) (p q:slprop) (r s:prop) (m:mem) : Lemma (requires r /\ s) (ensures preserves_frame e p q m m <==> preserves_frame e (p `star` pure r) (q `star` pure s) m m) = pure_equiv r True; star_congruence p (pure r) p (pure True); pure_equiv s True; star_congruence q (pure s) q (pure True); pure_true_equiv p; pure_true_equiv q; let fwd () : Lemma (requires preserves_frame e p q m m) (ensures preserves_frame e (p `star` pure r) (q `star` pure s) m m) [SMTPat ()] = preserves_frame_cong e p q (p `star` pure r) (q `star` pure s) m m in let bk () : Lemma (requires preserves_frame e (p `star` pure r) (q `star` pure s) m m) (ensures preserves_frame e p q m m) [SMTPat ()] = preserves_frame_cong e (p `star` pure r) (q `star` pure s) p q m m in () let witness (#a:Type) (#pcm:pcm a) (e:inames) (r:erased (ref a pcm)) (fact:stable_property pcm) (v:Ghost.erased a) (_:squash (forall z. compatible pcm v z ==> fact z)) (frame:slprop) : MstTot (witnessed r fact) e (pts_to r v) (fun _ -> pts_to r v) frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in let _ : unit = let hr : H.ref a pcm = r in let v' = H.sel_v hr v (heap_of_mem m0) in assert (interp (H.ptr hr) m0 /\ H.sel #a #pcm hr (heap_of_mem m0) == v'); assert (compatible pcm v v'); assert (fact v'); assert (witnessed_ref r fact m0); witnessed_ref_stability r fact; assert (FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) in let w = NMSTTotal.witness _ mem_evolves (witnessed_ref r fact) in w let recall (#a:Type u#1) (#pcm:pcm a) (#fact:property a) (e:inames) (r:erased (ref a pcm)) (v:Ghost.erased a) (w:witnessed r fact) (frame:slprop) = let m0 = NMSTTotal.get () in NMSTTotal.recall _ mem_evolves (witnessed_ref r fact) w; let hr : H.ref a pcm = r in assert (witnessed_ref r fact m0); let v1 = H.sel_v hr v (heap_of_mem m0) in assert (compatible pcm v v1); assert (H.sel hr (heap_of_mem m0) == v1); assert (fact v1); assert (interp ((pts_to r v `star` frame) `star` locks_invariant e m0) m0); emp_unit ((pts_to r v `star` frame) `star` locks_invariant e m0); pure_star_interp ((pts_to r v `star` frame) `star` locks_invariant e m0) (fact v1) m0; assert (interp (((pts_to r v `star` frame) `star` locks_invariant e m0) `star` pure (fact v1)) m0); rearrange_pqr_prq (pts_to r v `star` frame) (locks_invariant e m0) (pure (fact v1)); assert (interp (((pts_to r v `star` frame) `star` pure (fact v1)) `star` locks_invariant e m0) m0); rearrange_pqr_prq (pts_to r v) frame (pure (fact v1)); star_congruence ((pts_to r v `star` frame) `star` pure (fact v1)) (locks_invariant e m0) ((pts_to r v `star` pure (fact v1)) `star` frame) (locks_invariant e m0); Ghost.hide v1 let iname_for_p_mem (i:iname) (p:slprop) : W.s_predicate mem = fun m -> iname_for_p i p m.locks let iname_for_p_stable (i:iname) (p:slprop) : Lemma (W.stable full_mem mem_evolves (iname_for_p_mem i p)) = () let ( >--> ) (i:iname) (p:slprop) : Type0 = W.witnessed full_mem mem_evolves (iname_for_p_mem i p) let hmem_with_inv_equiv e (m:mem) (p:slprop) : Lemma (interp (p `star` linv e m) m <==> interp (p `star` lock_store_invariant e m.locks) m /\ heap_ctr_valid m.ctr (heap_of_mem m)) = calc (<==>) { interp (p `star` linv e m) m; (<==>) { H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) } interp ((p `star` lock_store_invariant e m.locks) `star` ctr_validity m.ctr (heap_of_mem m)) m; (<==>) { H.pure_star_interp (p `star` lock_store_invariant e m.locks) (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_of_mem m) } interp ((p `star` lock_store_invariant e m.locks) `star` emp) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); (<==>) { H.emp_unit (p `star` lock_store_invariant e m.locks) } interp (p `star` lock_store_invariant e m.locks) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); } let new_invariant_tot_action (e:inames) (p:slprop) (m0:hmem_with_inv_except e p{ e `inames_in` m0.locks }) : Pure (iname & hmem_with_inv_except e emp) (requires True) (ensures fun (i, m1) -> iname_for_p_mem i p m1 /\ frame_related_mems p emp e m0 m1 /\ mem_evolves m0 m1) = let (| i, l1 |) = extend_lock_store e m0.locks p in let m1 = { m0 with locks = l1 } in assert (lock_store_invariant e m1.locks == p `star` lock_store_invariant e m0.locks); calc (equiv) { linv e m1; (equiv) {} (lock_store_invariant e m1.locks `star` ctr_validity m1.ctr (heap_of_mem m1)); (equiv) {} ((p `star` lock_store_invariant e m0.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); (equiv) { H.star_associative p (lock_store_invariant e m0.locks) (ctr_validity m1.ctr (heap_of_mem m1)) } (p `star` (lock_store_invariant e m0.locks `star` ctr_validity m1.ctr (heap_of_mem m1))); (equiv) { } (p `star` linv e m0); }; assert (iname_for_p_mem i p m1); assert (lock_store_evolves m0.locks l1); assert (mem_evolves m0 m1); hmem_with_inv_equiv e m0 p; assert (interp (p `star` lock_store_invariant e m0.locks) m1); assert (interp (lock_store_invariant e m1.locks) m1); H.emp_unit (lock_store_invariant e m1.locks); H.star_commutative (lock_store_invariant e m1.locks) emp; assert (interp (emp `star` lock_store_invariant e m1.locks) m1); hmem_with_inv_equiv e m1 emp; let m1 : hmem_with_inv_except e emp = m1 in let aux (frame:slprop) : Lemma (requires interp ((p `star` frame) `star` linv e m0) m0) (ensures interp ((emp `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) <==> mp (core_mem m1))) [SMTPat (p `star` frame)] = assert (interp ((p `star` frame) `star` linv e m0) m1); calc (equiv) { ((p `star` frame) `star` linv e m0); (equiv) { H.star_commutative p frame; H.star_congruence (p `star` frame) (linv e m0) (frame `star` p) (linv e m0); H.star_associative frame p (linv e m0) } (frame `star` (p `star` linv e m0)); (equiv) { H.star_congruence frame (p `star` linv e m0) frame (linv e m1) } (frame `star` linv e m1); (equiv) { H.emp_unit (frame `star` linv e m1); H.star_commutative (frame `star` linv e m1) emp; H.star_associative emp frame (linv e m1) } ((emp `star` frame) `star` linv e m1); }; assert (interp ((emp `star` frame) `star` linv e m1) m1) in assert (frame_related_mems p emp e m0 m1); ( i, m1 ) let name_is_ok (i:iname) (m0:full_mem u#1) : prop = i < List.Tot.length m0.locks let witnessed_name_is_ok (i:iname) = W.witnessed full_mem mem_evolves (name_is_ok i) let pre_inv = i:erased iname & witnessed_name_is_ok i let inv (p:slprop u#1) = i:erased iname & witnessed_name_is_ok i & (i >--> p) let pre_inv_of_inv #p (i:inv p) = let (|i, w, _|) = i in (|i,w|) let name_of_pre_inv (i:pre_inv) = dfst i let rec recall_all (ctx:list pre_inv) : NMSTTotal.NMSTATETOT unit (full_mem u#1) mem_evolves (requires fun _ -> True) (ensures fun m0 _ m1 -> m0==m1 /\ (forall i. i `List.Tot.memP` ctx ==> name_is_ok (name_of_pre_inv i) m0)) = match ctx with | [] -> () | hd::tl -> let (| q, i |) = hd in let i : W.witnessed full_mem mem_evolves (name_is_ok q) = i in NMSTTotal.recall _ mem_evolves (name_is_ok q) i; recall_all tl let fresh_invariant (e:inames) (p:slprop) (ctx:list pre_inv) (frame:slprop) : MstTot (i:inv p { not (mem_inv e i) /\ fresh_wrt ctx (name_of_inv i)}) e p (fun _ -> emp) frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in recall_all ctx; ac_reasoning_for_m_frame_preserving p frame (locks_invariant e m0) m0; assert (interp (p `star` locks_invariant e m0) m0); let r = new_invariant_tot_action e p m0 in let ( i, m1 ) = r in assert (i == List.Tot.length m0.locks); assert (not (Set.mem i e)); assert (mem_evolves m0 m1); NMSTTotal.put #full_mem #mem_evolves m1; iname_for_p_stable i p; let w = NMSTTotal.witness full_mem mem_evolves (iname_for_p_mem i p) in let w0 = NMSTTotal.witness full_mem mem_evolves (name_is_ok i) in (| hide i, w0, w |) let new_invariant (e:inames) (p:slprop) (frame:slprop) : MstTot (inv p) e p (fun _ -> emp) frame (fun _ -> True) (fun _ _ _ -> True) = fresh_invariant e p [] frame let rearrange_invariant (p q r : slprop) (q0 q1:slprop) : Lemma (requires q `equiv` (q0 `star` q1)) (ensures (p `star` (q `star` r)) `equiv` ((q0 `star` p) `star` (q1 `star` r))) = calc (equiv) { p `star` (q `star` r); (equiv) { calc (equiv) { (q `star` r); (equiv) { star_congruence q r (q0 `star` q1) r } (q0 `star` q1) `star` r; }; star_congruence p (q `star` r) p ((q0 `star` q1) `star` r) } (p `star` ((q0 `star` q1) `star` r)); (equiv) { star_associative q0 q1 r; star_congruence p ((q0 `star` q1) `star` r) p (q0 `star` (q1 `star` r)); star_associative p q0 (q1 `star` r) } (p `star` q0) `star` (q1 `star` r); (equiv) { star_commutative p q0; star_congruence (p `star` q0) (q1 `star` r) (q0 `star` p) (q1 `star` r) } (q0 `star` p) `star` (q1 `star` r); } let preserves_frame_invariant (fp fp':slprop) (opened_invariants:inames) (p:slprop) (i:inv p{not (mem_inv opened_invariants i)}) (m0:hmem_with_inv_except (add_inv opened_invariants i) (p `star` fp)) (m1:mem) : Lemma (requires preserves_frame (set_add (name_of_inv i) opened_invariants) (p `star` fp) (p `star` fp') m0 m1 /\ interp (fp' `star` linv opened_invariants m1) m1 /\ inames_ok opened_invariants m1 /\ (lock_store_invariant opened_invariants m0.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks)) /\ (lock_store_invariant opened_invariants m1.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks))) (ensures preserves_frame opened_invariants fp fp' m0 m1) = let aux (frame:slprop) : Lemma (requires interp ((fp `star` frame) `star` linv opened_invariants m0) m0) (ensures interp ((fp' `star` frame) `star` linv opened_invariants m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) [SMTPat()] = rearrange_invariant (fp `star` frame) (lock_store_invariant opened_invariants m0.locks) (ctr_validity m0.ctr (heap_of_mem m0)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks); assert (interp ((p `star` (fp `star` frame)) `star` linv (set_add (name_of_inv i) opened_invariants) m0) m0); star_associative p fp frame; star_congruence (p `star` (fp `star` frame)) (linv (set_add (name_of_inv i) opened_invariants) m0) ((p `star` fp) `star` frame) (linv (set_add (name_of_inv i) opened_invariants) m0); assert (interp (((p `star` fp) `star` frame) `star` linv (set_add (name_of_inv i) opened_invariants) m0) m0); assert (interp (((p `star` fp') `star` frame) `star` linv (set_add (name_of_inv i) opened_invariants) m1) m1); star_associative p fp' frame; star_congruence ((p `star` fp') `star` frame) (linv (set_add (name_of_inv i) opened_invariants) m1) (p `star` (fp' `star` frame)) (linv (set_add (name_of_inv i) opened_invariants) m1); assert (interp ((p `star` (fp' `star` frame)) `star` linv (set_add (name_of_inv i) opened_invariants) m1) m1); rearrange_invariant (fp' `star` frame) (lock_store_invariant opened_invariants m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks); assert (interp ((fp' `star` frame) `star` linv opened_invariants m1) m1); () in () let equiv_ext_right (p q r:slprop) : Lemma (requires q `equiv` r) (ensures (p `star` q) `equiv` (p `star` r)) = calc (equiv) { p `star` q; (equiv) { star_commutative p q } q `star` p; (equiv) { equiv_extensional_on_star q r p } r `star` p; (equiv) { star_commutative p r } p `star` r; } let with_inv_helper (fp frame ls1 ctr p ls2:slprop) : Lemma (requires ls1 `equiv` (p `star` ls2)) (ensures (fp `star` frame `star` (ls1 `star` ctr)) `equiv` (p `star` fp `star` frame `star` (ls2 `star` ctr))) = calc (equiv) { ls1 `star` ctr; (equiv) { equiv_extensional_on_star ls1 (p `star` ls2) ctr } p `star` ls2 `star` ctr; }; calc (equiv) { p `star` ls2 `star` ctr; (equiv) { star_associative p ls2 ctr } p `star` (ls2 `star` ctr); }; calc (equiv) { fp `star` frame `star` p; (equiv) { star_commutative (fp `star` frame) p } p `star` (fp `star` frame); (equiv) { star_associative p fp frame } p `star` fp `star` frame; }; calc (equiv) { fp `star` frame `star` (ls1 `star` ctr); (equiv) { equiv_ext_right (fp `star` frame) (ls1 `star` ctr) (p `star` ls2 `star` ctr) } (fp `star` frame) `star` (p `star` ls2 `star` ctr); (equiv) { equiv_ext_right (fp `star` frame) (p `star` ls2 `star` ctr) (p `star` (ls2 `star` ctr)) } (fp `star` frame) `star` (p `star` (ls2 `star` ctr)); (equiv) { star_associative (fp `star` frame) p (ls2 `star` ctr) } (fp `star` frame `star` p) `star` (ls2 `star` ctr); (equiv) { equiv_extensional_on_star (fp `star` frame `star` p) (p `star` fp `star` frame) (ls2 `star` ctr) } (p `star` fp `star` frame) `star` (ls2 `star` ctr); } let token_of_inv #p (i:inv p) : (name_of_inv i >--> p) = let (| _, _, tok |) = i in tok let with_invariant (#a:Type) (#fp:slprop) (#fp':a -> slprop) (#opened_invariants:inames) (#p:slprop) (i:inv p{not (mem_inv opened_invariants i)}) (f:action_except a (add_inv opened_invariants i) (p `star` fp) (fun x -> p `star` fp' x)) (frame:slprop) : MstTot a opened_invariants fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in NMSTTotal.recall _ mem_evolves (iname_for_p_mem (name_of_inv i) p) (token_of_inv i); assert (iname_for_p (name_of_inv i) p m0.locks); assert (interp (fp `star` frame `star` locks_invariant opened_invariants m0) m0); assert (interp (fp `star` frame `star` (lock_store_invariant opened_invariants m0.locks `star` ctr_validity m0.ctr (heap_of_mem m0))) m0); move_invariant opened_invariants m0.locks p (name_of_inv i); assert (lock_store_invariant opened_invariants m0.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks)); with_inv_helper fp frame (lock_store_invariant opened_invariants m0.locks) (ctr_validity m0.ctr (heap_of_mem m0)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks); assert (interp (p `star` fp `star` frame `star` locks_invariant (set_add (name_of_inv i) opened_invariants) m0) m0); let r = f frame in let m1 : full_mem = NMSTTotal.get () in assert (interp (p `star` fp' r `star` frame `star` locks_invariant (set_add (name_of_inv i) opened_invariants) m1) m1); assert (interp (p `star` fp' r `star` frame `star` (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks `star` ctr_validity m1.ctr (heap_of_mem m1))) m1); NMSTTotal.recall _ mem_evolves (iname_for_p_mem (name_of_inv i) p) (token_of_inv i); move_invariant opened_invariants m1.locks p (name_of_inv i); assert (lock_store_invariant opened_invariants m1.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks)); with_inv_helper (fp' r) frame (lock_store_invariant opened_invariants m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks); assert (interp (fp' r `star` frame `star` locks_invariant opened_invariants m1) m1); assert (inames_ok opened_invariants m1); r let equiv_pqrs_p_qr_s (p q r s:slprop) : Lemma ((p `star` q `star` r `star` s) `equiv` (p `star` (q `star` r) `star` s)) = star_associative p q r; equiv_extensional_on_star (p `star` q `star` r) (p `star` (q `star` r)) s let frame (#a:Type) (#opened_invariants:inames) (#pre:slprop) (#post:a -> slprop) (#req:mprop pre) (#ens:mprop2 pre post) (frame:slprop) ($f:action_except_full a opened_invariants pre post req ens) (frame0:slprop) : MstTot a opened_invariants (pre `star` frame) (fun x -> post x `star` frame) frame0 req ens = let m0 : full_mem = NMSTTotal.get () in equiv_pqrs_p_qr_s pre frame frame0 (linv opened_invariants m0); assert (interp (pre `star` frame `star` frame0 `star` linv opened_invariants m0) m0); assert (interp (pre `star` (frame `star` frame0) `star` linv opened_invariants m0) m0); let x = f (frame `star` frame0) in let m1 : full_mem = NMSTTotal.get () in equiv_pqrs_p_qr_s (post x) frame frame0 (linv opened_invariants m1); assert (interp (post x `star` (frame `star` frame0) `star` linv opened_invariants m1) m1); assert (interp (post x `star` frame `star` frame0 `star` linv opened_invariants m1) m1); x let change_slprop (#opened_invariants:inames) (p q:slprop) (proof: (m:mem -> Lemma (requires interp p m) (ensures interp q m))) = let proof (h:H.heap) : Lemma (requires H.interp p h) (ensures H.interp q h) = proof (mem_of_heap h) in lift_tot_action (lift_heap_action opened_invariants (Steel.Heap.change_slprop p q proof)) (* This module reuses is_frame_monotonic from Heap, but does not expose that to clients, so we need this lemma to typecheck witness_h_exists below. *) let relate_frame_monotonic_1 #a p : Lemma (requires (H.is_frame_monotonic p)) (ensures (is_frame_monotonic p)) = () let relate_frame_monotonic_2 #a p : Lemma (requires (is_frame_monotonic p)) (ensures (H.is_frame_monotonic p)) = let aux (x y : a) (h : H.heap) (f : H.slprop) : Lemma (requires (H.interp (p x `H.star` f) h /\ H.interp (p y) h)) (ensures (H.interp (p y `H.star` f) h)) = let m = mem_of_heap h in assert (interp (p x `star` f) m); assert (interp (p y) m); assert (interp (p y `star` f) m) in Classical.forall_intro_4 (fun x y h f -> Classical.move_requires (aux x y h) f) let witness_h_exists #opened_invariants #a p = lift_tot_action_with_frame (lift_heap_action_with_frame opened_invariants (H.witness_h_exists p))

{ "checked_file": "/", "dependencies": [ "Steel.Preorder.fst.checked", "Steel.Heap.fsti.checked", "prims.fst.checked", "FStar.Witnessed.Core.fsti.checked", "FStar.Set.fsti.checked", "FStar.Preorder.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.PCM.fst.checked", "FStar.NMSTTotal.fst.checked", "FStar.List.Tot.fst.checked", "FStar.IndefiniteDescription.fsti.checked", "FStar.Ghost.fsti.checked", "FStar.FunctionalExtensionality.fsti.checked", "FStar.Classical.Sugar.fsti.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Steel.Memory.fst" }

[ { "abbrev": true, "full_module": "Steel.Preorder", "short_module": "PP" }, { "abbrev": true, "full_module": "FStar.Witnessed.Core", "short_module": "W" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": true, "full_module": "Steel.Heap", "short_module": "H" }, { "abbrev": false, "full_module": "FStar.FunctionalExtensionality", "short_module": null }, { "abbrev": true, "full_module": "FStar.FunctionalExtensionality", "short_module": "F" }, { "abbrev": true, "full_module": "FStar.Universe", "short_module": "U" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": false, "full_module": "FStar.PCM", "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

p: (_: a -> Steel.Memory.slprop) -> Steel.Memory.action_except Prims.unit opened_invariants (Steel.Memory.h_exists p) (fun _ -> Steel.Memory.h_exists (FStar.Universe.lift_dom p))

Prims.Tot

[ "total" ]

[]

[ "Steel.Memory.inames", "Steel.Memory.slprop", "Steel.Memory.lift_tot_action", "Prims.unit", "Steel.Heap.h_exists", "FStar.Universe.raise_t", "FStar.Universe.lift_dom", "Steel.Heap.slprop", "Steel.Memory.lift_heap_action", "Steel.Heap.lift_h_exists", "Steel.Memory.action_except", "Steel.Memory.h_exists" ]

[]

false

let lift_h_exists #opened_invariants p =

lift_tot_action (lift_heap_action opened_invariants (H.lift_h_exists p))

false

Steel.Memory.fst

Steel.Memory.token_of_inv

val token_of_inv (#p: _) (i: inv p) : (name_of_inv i >--> p)

let token_of_inv #p (i:inv p) : (name_of_inv i >--> p) = let (| _, _, tok |) = i in tok

{ "file_name": "lib/steel/Steel.Memory.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 87, "end_line": 1430, "start_col": 0, "start_line": 1430 }

(* 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.Memory module F = FStar.FunctionalExtensionality open FStar.FunctionalExtensionality open FStar.PCM module H = Steel.Heap noeq type lock_state : Type u#(a + 1) = | Invariant : inv:H.slprop u#a -> lock_state let lock_store : Type u#(a+1) = list (lock_state u#a) noeq type mem : Type u#(a + 1) = { ctr: nat; heap: H.heap u#a; locks: lock_store u#a; } let heap_of_mem (x:mem) : H.heap = x.heap let mem_of_heap (h:H.heap) : mem = { ctr = 0; heap = h; locks = [] } let mem_set_heap (m:mem) (h:H.heap) : mem = { ctr = m.ctr; heap = h; locks = m.locks; } let core_mem (m:mem) : mem = mem_of_heap (heap_of_mem m) let core_mem_invol m = () let disjoint (m0 m1:mem u#h) : prop = m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks let disjoint_sym m0 m1 = () let join m0 m1 = { ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = m0.locks } let join_commutative m0 m1 = H.join_commutative m0.heap m1.heap let disjoint_join m0 m1 m2 = H.disjoint_join m0.heap m1.heap m2.heap let join_associative m0 m1 m2 = H.join_associative m0.heap m1.heap m2.heap let slprop = H.slprop let interp p m = H.interp p m.heap let equiv p1 p2 = forall m. interp p1 m <==> interp p2 m let slprop_extensionality p q = assert (forall m. interp p m <==> interp q m); let aux (h:H.heap) : Lemma (H.interp p h <==> H.interp q h) [SMTPat (H.interp p h)] = let m : mem = { ctr = 0; heap = h; locks = [] } in assert (interp p m <==> interp q m) in assert (forall h. H.interp p h <==> H.interp q h); Steel.Heap.slprop_extensionality p q let reveal_equiv p1 p2 = () let core_ref = H.core_ref let core_ref_null = H.core_ref_null let core_ref_is_null r = H.core_ref_is_null r let emp : slprop u#a = H.emp let pure = H.pure let pts_to = H.pts_to let h_and = H.h_and let h_or = H.h_or let star = H.star let wand = H.wand let h_exists = H.h_exists let h_forall = H.h_forall //////////////////////////////////////////////////////////////////////////////// //properties of equiv //////////////////////////////////////////////////////////////////////////////// let equiv_symmetric (p1 p2:slprop u#a) = H.equiv_symmetric p1 p2 #push-options "--warn_error -271" let equiv_heap_iff_equiv (p1 p2:slprop u#a) : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat (equiv p1 p2)] = let aux_lr () : Lemma (requires H.equiv p1 p2) (ensures equiv p1 p2) [SMTPat ()] = () in let aux_rl_helper1 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p1 h) (ensures H.interp p2 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl_helper2 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p2 h) (ensures H.interp p1 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl () : Lemma (requires equiv p1 p2) (ensures H.equiv p1 p2) [SMTPat ()] = () in () let equiv_heap_iff_equiv_forall () : Lemma (ensures (forall p1 p2. H.equiv p1 p2 <==> equiv p1 p2)) = let aux p1 p2 : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat ()] = equiv_heap_iff_equiv p1 p2 in () #pop-options let equiv_extensional_on_star (p1 p2 p3:slprop u#a) = equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3 let emp_unit p = H.emp_unit p let intro_emp m = H.intro_emp (heap_of_mem m) let pure_equiv p q = H.pure_equiv p q let pure_interp q m = H.pure_interp q (heap_of_mem m) let pure_star_interp p q m = H.pure_star_interp p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// //pts_to //////////////////////////////////////////////////////////////////////////////// let pts_to_compatible #a #pcm x v0 v1 m = H.pts_to_compatible #a #pcm x v0 v1 (heap_of_mem m) let pts_to_compatible_equiv #a #pcm x v0 v1 = H.pts_to_compatible_equiv #a #pcm x v0 v1 let pts_to_not_null #a #pcm x v m = H.pts_to_not_null #a #pcm x v (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // star //////////////////////////////////////////////////////////////////////////////// let intro_star p q mp mq = H.intro_star p q (heap_of_mem mp) (heap_of_mem mq) let elim_star p q m = let h = heap_of_mem m in H.elim_star p q h; assert (exists hl hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr); let hl = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hl -> exists hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let hr = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hr -> H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let ml = mem_set_heap m hl in let mr = mem_set_heap m hr in assert (disjoint ml mr); assert (m == join ml mr); assert (interp p ml); assert (interp q mr); () let interp_star (p q: slprop) (m: mem) : Lemma (interp (p `star` q) m <==> (exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m)) = let left = interp (p `star` q) m in let right = exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m in let f () : Lemma (requires left) (ensures right) = elim_star p q m in let g () : Lemma (requires right) (ensures left) = Classical.exists_elim left #_ #(fun mp -> exists (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mp -> Classical.exists_elim left #_ #(fun mq -> disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mq -> intro_star p q mp mq ) ) in Classical.move_requires f (); Classical.move_requires g () let star_commutative (p1 p2:slprop) = H.star_commutative p1 p2 let star_associative (p1 p2 p3:slprop) = H.star_associative p1 p2 p3 let star_congruence (p1 p2 p3 p4:slprop) = equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4 let affine_star (p q:slprop) (m:mem) = H.affine_star p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // Invariants on the lock store //////////////////////////////////////////////////////////////////////////////// let iname = nat module S = FStar.Set module L = FStar.List.Tot module W = FStar.Witnessed.Core let rec lock_store_invariant (e:inames) (l:lock_store u#a) : slprop u#a = let current_addr = L.length l - 1 in match l with | [] -> emp | Invariant p :: tl -> if current_addr `S.mem` e then lock_store_invariant e tl else p `star` lock_store_invariant e tl let lock_i (i:iname) (l:lock_store { i < L.length l }) = let ix = L.length l - i - 1 in L.index l ix let iname_for_p (i:iname) (p:slprop) : W.s_predicate lock_store = fun l -> i < L.length l /\ (lock_i i l).inv == p let lock_store_evolves : FStar.Preorder.preorder lock_store = fun (l1 l2 : lock_store) -> L.length l2 >= L.length l1 /\ (forall (i:nat{i < L.length l1}). (lock_i i l1).inv == (lock_i i l2).inv) let inames_in (e:inames) (l:lock_store) : prop = forall i. Set.mem i e ==> i < L.length l let inames_ok e m = inames_in e m.locks let inames_ok_empty m = () let extend_lock_store (e:inames) (l:lock_store{e `inames_in` l}) (p:slprop) : i:iname & l':lock_store { lock_store_invariant e l' == p `star` lock_store_invariant e l /\ iname_for_p i p l' } = (| L.length l, Invariant p :: l |) let set_add (i:iname) (s:inames) = Set.union (Set.singleton i) s let rec move_invariant (e:inames) (l:lock_store) (p:slprop) (i:iname{iname_for_p i p l /\ ~(i `Set.mem` e)}) : Lemma (H.equiv (lock_store_invariant e l) (p `star` lock_store_invariant (set_add i e) l)) = let rec aux (i:iname) (m:lock_store) : Lemma (requires i >= L.length m) (ensures (lock_store_invariant e m `H.equiv` lock_store_invariant (set_add i e) m)) = match m with | [] -> () | Invariant p::tl -> aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl) in let current_addr = L.length l - 1 in match l with | [] -> () | Invariant q::tl -> if i = current_addr then begin assert (lock_store_invariant e l == p `star` lock_store_invariant e tl); aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl); () end else begin move_invariant e tl p i; assert (lock_store_invariant e tl `equiv` (p `star` lock_store_invariant (set_add i e) tl)); H.star_congruence q (lock_store_invariant e tl) q (p `star` lock_store_invariant (set_add i e) tl); if Set.mem current_addr e then () else begin let r = lock_store_invariant (set_add i e) tl in assert (lock_store_invariant e l `equiv` (q `star` (p `star` r))); H.star_associative q p r; H.star_commutative q p; H.star_congruence (q `star` p) r (p `star` q) r; H.star_associative p q r end end let heap_ctr_valid (ctr:nat) (h:H.heap u#a) : prop = h `H.free_above_addr` ctr let ctr_validity (ctr:nat) (h:H.heap) : slprop = H.pure (heap_ctr_valid ctr h) let locks_invariant (e:inames) (m:mem u#a) : slprop u#a = lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m) let full_mem_pred (m:mem) = H.full_heap_pred (heap_of_mem m) (***** Following lemmas are needed in Steel.Effect *****) let core_mem_interp (hp:slprop u#a) (m:mem u#a) = () let interp_depends_only_on (hp:slprop u#a) = H.interp_depends_only_on hp let a_mem_prop_as_a_heap_prop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (H.a_heap_prop u#a) = let g (h: H.heap u#a) : Tot prop = interp sl (mem_of_heap h) /\ f (mem_of_heap h) in let phi0 (h0 h1: H.heap u#a) : Lemma (requires (g h0 /\ H.disjoint h0 h1)) (ensures (g h0 /\ H.disjoint h0 h1 /\ g (H.join h0 h1))) = assert (mem_of_heap (H.join h0 h1) == mem_of_heap h0 `join` mem_of_heap h1); interp_depends_only_on sl in let phi1 (h0 h1: H.heap u#a) : Lemma (ensures ((g h0 /\ H.disjoint h0 h1) ==> g (H.join h0 h1))) = Classical.move_requires (phi0 h0) h1 in Classical.forall_intro_2 phi1; g let refine_slprop sl f = H.as_slprop (a_mem_prop_as_a_heap_prop sl f) let interp_refine_slprop sl f m = assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_mem m)) let dep_hprop (s: slprop) (f: (hmem s -> Tot slprop)) (h: H.heap) : Tot prop = exists (h1: H.heap) . exists (h2: H.heap) . interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 let dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq' : squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h')) = let p2 (h h1 h2: H.heap) : Tot prop = interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 in let p1 (h h1: H.heap) : Tot prop = (exists h2 . p2 h h1 h2) in let h1 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p1 h) in let h2 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p2 h h1) in H.disjoint_join h' h1 h2; assert (H.disjoint h2 h'); let h2' = H.join h2 h' in H.join_commutative h2 h' ; assert (h2' == H.join h' h2); assert (H.disjoint h1 h2'); assert (mem_of_heap h2' == mem_of_heap h2 `join` mem_of_heap h'); interp_depends_only_on (f (mem_of_heap h1)); assert (interp (f (mem_of_heap h1)) (mem_of_heap h2')); H.join_commutative h1 h2; H.join_associative h' h2 h1; H.join_commutative h' h; H.join_commutative h2' h1; assert (H.join h h' == h1 `H.join` h2') let impl_intro_gen (#p: Type0) (#q: Type0) ($prf: (squash p -> Lemma (q ))) : Lemma (p ==> q) = Classical.impl_intro_gen #p #(fun _ -> q) prf let dep_hprop_is_affine1 (s: slprop) (f: (hmem s -> Tot slprop)) (h0 h1: H.heap) : Lemma ((dep_hprop s f h0 /\ H.disjoint h0 h1) ==> (H.disjoint h0 h1 /\ dep_hprop s f (H.join h0 h1))) = impl_intro_gen (dep_hprop_is_affine0 s f h0 h1) let dep_hprop_is_affine (s: slprop) (f: (hmem s -> Tot slprop)) : Lemma (H.heap_prop_is_affine (dep_hprop s f)) = Classical.forall_intro_2 (dep_hprop_is_affine1 s f) let sdep (s: slprop) (f: (hmem s -> Tot slprop)) : Tot slprop = dep_hprop_is_affine s f; H.as_slprop (dep_hprop s f) let interp_sdep (s: slprop) (f: (hmem s -> Tot slprop)) (m: mem) : Lemma (requires (dep_slprop_is_affine s f)) (ensures ( interp (sdep s f) m <==> (exists m1 m2 . interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) )) = dep_hprop_is_affine s f; assert (forall m1 m2 . (interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) ==> ( interp s (mem_of_heap m1.heap) /\ interp (f (mem_of_heap m1.heap)) (mem_of_heap m2.heap) /\ H.disjoint m1.heap m2.heap /\ H.join m1.heap m2.heap == m.heap )); interp_depends_only_on s; Classical.forall_intro (fun m -> interp_depends_only_on (f m)); assert (forall h1 h2 . (interp s (mem_of_heap h1) /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ H.disjoint h1 h2 /\ H.join h1 h2 == m.heap) ==> ( core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ interp s (core_mem (mem_of_heap h1)) /\ interp s (mem_set_heap m h1) /\ core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ f (mem_set_heap m h1) `equiv` f (mem_of_heap h1) /\ interp (f (mem_set_heap m h1)) (mem_of_heap h2) /\ interp (f (mem_set_heap m h1)) (mem_set_heap m h2) /\ disjoint (mem_set_heap m h1) (mem_set_heap m h2) /\ join (mem_set_heap m h1) (mem_set_heap m h2) == m )); () let h_exists_cong (#a:Type) (p q : a -> slprop) : Lemma (requires (forall x. p x `equiv` q x)) (ensures (h_exists p `equiv` h_exists q)) = equiv_heap_iff_equiv_forall (); H.h_exists_cong p q let intro_h_exists #a x p m = H.intro_h_exists x p (heap_of_mem m) let elim_h_exists (#a:_) (p:a -> slprop) (m:mem) = H.elim_h_exists p (heap_of_mem m) let intro_h_forall (#a:_) (p:a -> slprop) (m:mem) = H.intro_h_forall p (heap_of_mem m) let elim_h_forall (#a:_) (p:a -> slprop) (m:mem) (x:a) = H.elim_h_forall p (heap_of_mem m) x let intro_h_and (p q: slprop) (m:mem) = H.intro_h_and p q (heap_of_mem m) let elim_h_and (p q: slprop) (m:mem) = H.elim_h_and p q (heap_of_mem m) let intro_h_or_left (p q: slprop) (m:mem) = H.intro_h_or_left p q (heap_of_mem m) let intro_h_or_right (p q: slprop) (m:mem) = H.intro_h_or_right p q (heap_of_mem m) let elim_h_or (p q: slprop) (m:mem) = H.elim_h_or p q (heap_of_mem m) let intro_wand (p1 p2: slprop u#a) (m:mem) = introduce (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)) ==> interp (wand p1 p2) m with _. ( assert (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)); H.intro_wand p1 p2 (heap_of_mem m); let h = heap_of_mem m in assert ((forall h1. h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) ==> H.interp (wand p1 p2) h); introduce forall h1. (h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) with ( introduce (h `H.disjoint` h1 /\ H.interp p1 h1) ==> H.interp p2 (H.join h h1) with _. ( assert (h `H.disjoint` h1); let m1 = { ctr = m.ctr; heap = h1; locks = m.locks } in assert (m `disjoint` m1) ) ) ) (** Eliminating a wand by proving a heap that satisfies the LHS **) let elim_wand (p1 p2: slprop u#a) (m:mem) (m1:mem) = H.elim_wand p1 p2 (heap_of_mem m) (heap_of_mem m1) //////////////////////////////////////////////////////////////////////////////// // Preorders and effects //////////////////////////////////////////////////////////////////////////////// module PP = Steel.Preorder let mem_evolves = fun (m0 m1:full_mem) -> H.heap_evolves (heap_of_mem m0) (heap_of_mem m1) /\ m0.ctr <= m1.ctr /\ lock_store_evolves m0.locks m1.locks (** See [Steel.Heap.is_frame_preserving]. We add in [lock_invariants] now *) let preserves_frame (e:inames) (pre post:slprop) (m0 m1:mem) = forall (frame:slprop). interp ((pre `star` frame) `star` locks_invariant e m0) m0 ==> (interp ((post `star` frame) `star` locks_invariant e m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) (** This is a version of MstTot with frame quantified, as part of preserves_frame *) effect MstTotNF (a:Type u#a) (except:inames) (expects:slprop u#1) (provides: a -> slprop u#1) = NMSTTotal.NMSTATETOT a (full_mem u#1) mem_evolves (requires fun m0 -> inames_ok except m0 /\ interp (expects `star` locks_invariant except m0) m0) (ensures fun m0 x m1 -> inames_ok except m1 /\ interp (provides x `star` locks_invariant except m1) m1 /\ preserves_frame except expects (provides x) m0 m1) //////////////////////////////////////////////////////////////////////////////// // Lifting heap actions //////////////////////////////////////////////////////////////////////////////// (** Heap actions come in two equivalent flavors: - one that take an explicit frame as argument (action_with_frame) - and one that quantify over all the frame We therefore define two lift routes: - a direct route for those with explicit frame - via MstTotNF for the rest *) let tot_pre_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = hmem_with_inv_except e fp -> (x:a & hmem_with_inv_except e (fp' x)) let tot_pre_action_nf = tot_pre_action_nf_except S.empty let ac_reasoning_for_m_frame_preserving (p q r:slprop u#a) (m:mem u#a) : Lemma (requires interp ((p `star` q) `star` r) m) (ensures interp (p `star` r) m) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_commutative p q; equiv_extensional_on_star (p `star` q) (q `star` p) r } (q `star` p) `star` r; (equiv) { star_associative q p r } q `star` (p `star` r); }; assert (interp (q `star` (p `star` r)) m); affine_star q (p `star` r) m let is_frame_preserving (#e:inames) (#a:Type u#b) (#fp:slprop u#a) (#fp':a -> slprop u#a) (f:tot_pre_action_nf_except e fp a fp') = forall (frame:slprop u#a) (m0:hmem_with_inv_except e (fp `star` frame)). (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = f:tot_pre_action_nf_except e fp a fp'{ is_frame_preserving f } let tot_action_nf = tot_action_nf_except S.empty let linv e (m:mem) = locks_invariant e m let hheap_of_hmem #fp #e (m:hmem_with_inv_except e fp) : h:H.hheap (fp `star` linv e m) { h `H.free_above_addr` m.ctr} = let h = heap_of_mem m in H.pure_interp (heap_ctr_valid m.ctr (heap_of_mem m)) h; h let hmem_of_hheap #e (#fp0 #fp1:slprop) (m:hmem_with_inv_except e fp0) (h:H.full_hheap (fp1 `star` linv e m) { h `Heap.free_above_addr` m.ctr }) : m1:hmem_with_inv_except e fp1{linv e m `equiv` linv e m1} = let m1 : mem = { m with heap = h } in assert (interp (fp1 `star` linv e m) m1); star_commutative fp1 (linv e m); assert (interp (linv e m `star` fp1) m1); assert (linv e m1 == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); assert (linv e m == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m)); H.pure_interp (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_of_mem m); assert (heap_ctr_valid m1.ctr (heap_of_mem m) <==> heap_ctr_valid m1.ctr (heap_of_mem m1)); H.pure_equiv (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_ctr_valid m1.ctr (heap_of_mem m1)); H.star_congruence (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m)); assert (linv e m `equiv` linv e m1); let _ = equiv_extensional_on_star (linv e m) (linv e m1) fp1 in assert ((linv e m `star` fp1) `equiv` (linv e m1 `star` fp1)); assert (interp (linv e m1 `star` fp1) m1); star_commutative (linv e m1) fp1; assert (interp (fp1 `star` linv e m1) m1); m1 let with_inv_except (m:mem) e (fp:slprop) = interp (fp `star` locks_invariant e m) m #push-options "--warn_error -271" let as_hprop (frame:slprop) (mp:mprop frame) : hp:H.hprop frame{forall m. mp (core_mem m) == hp (heap_of_mem m)} = let f = fun h -> mp (mem_of_heap h) in assert (forall m. mp (core_mem m) == f (heap_of_mem m)); let aux (m0:H.hheap frame) (m1:H.heap{H.disjoint m0 m1}) : Lemma (ensures (mem_of_heap (H.join m0 m1) == join (mem_of_heap m0) (mem_of_heap m1))) [SMTPat ()] = () in f let mprop_preservation_of_hprop_preservation (p:slprop) (m0 m1:mem) : Lemma (requires (forall (hp:H.hprop p). hp (heap_of_mem m0) == hp (heap_of_mem m1))) (ensures (forall (mp:mprop p). mp (core_mem m0) == mp (core_mem m1))) = let aux (mp:mprop p) : Lemma (mp (core_mem m0) == mp (core_mem m1)) [SMTPat()] = assert (as_hprop p mp (heap_of_mem m0) == as_hprop p mp (heap_of_mem m1)) in () let lift_heap_action (#fp:slprop) (#a:Type) (#fp':a -> slprop) (e:inames) ($f:H.action fp a fp') : tot_action_nf_except e fp a fp' = let g : tot_pre_action_nf_except e fp a fp' = fun m -> let h0 = hheap_of_hmem m in let (| x, h' |) = f h0 in (| x, hmem_of_hheap m h' |) in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in let h0 = hheap_of_hmem m0 in let (| x', h1 |) = f h0 in H.action_framing f (linv e m0) h0; assert (x == x'); star_associative fp frame (linv e m0); H.action_framing f (frame `star` linv e m0) h0; assert (H.interp ((fp' x) `star` (frame `star` linv e m0)) h1); star_associative (fp' x) frame (linv e m0); assert (H.interp ((fp' x `star` frame) `star` linv e m0) h1); let h1' : H.hheap ((fp' x `star` frame) `star` linv e m0) = h1 in assert (m1 == hmem_of_hheap m0 h1'); assert (with_inv_except m1 e (fp' x `star` frame)); assert (forall (hp:H.hprop frame). hp h0 == hp h1); mprop_preservation_of_hprop_preservation frame m0 m1; () in assert (is_frame_preserving g); g let frame_preserving_respects_preorder #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (m0:hmem_with_inv_except e fp) : Lemma (let (| x, m1 |) = f m0 in mem_evolves m0 m1) = let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1) = () in H.emp_unit fp; assert (interp (fp `star` linv e m0) m0); H.star_congruence (fp `star` emp) (linv e m0) fp (linv e m0); assert (interp ((fp `star` emp) `star` linv e m0) m0); aux emp m0 let lift_tot_action_nf #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') : MstTotNF a e fp fp' = let m0 = NMSTTotal.get () in let m0' : hmem_with_inv_except e fp = m0 in let r = f m0' in let (| x, m1 |) = r in let m1' : hmem_with_inv_except e (fp' x) = m1 in assert (is_frame_preserving f); assert (m1 == dsnd (f m0)); frame_preserving_respects_preorder f m0; NMSTTotal.put #_ #(mem_evolves) m1; x let lift_tot_action #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get #(full_mem) #_ () in ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); lift_tot_action_nf f (** Now defining the lift for heap actions with explicit frame *) let tot_action_with_frame_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = frame:slprop u#a -> m0:hmem_with_inv_except e (fp `star` frame) -> Pure (x:a & hmem_with_inv_except e (fp' x `star` frame)) (requires True) (ensures fun (| x, m1 |) -> mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_with_frame = tot_action_with_frame_except S.empty let lift_heap_action_with_frame (#fp:slprop u#a) (#a:Type u#b) (#fp':a -> slprop u#a) (e:inames) ($f:H.action_with_frame fp a fp') : tot_action_with_frame_except e fp a fp' = fun frame m0 -> let h0 = hheap_of_hmem m0 in calc (equiv) { fp `star` frame `star` locks_invariant e m0; (equiv) { star_associative fp frame (locks_invariant e m0) } fp `star` (frame `star` locks_invariant e m0); }; assert (H.interp (fp `star` frame `star` locks_invariant e m0) h0); assert (H.interp (fp `star` (frame `star` locks_invariant e m0)) h0); //key: apply the heap action with frame * locks_invariant e m0 let (| x, h1 |) = f (frame `star` locks_invariant e m0) h0 in calc (equiv) { fp' x `star` (frame `star` locks_invariant e m0); (equiv) { star_associative (fp' x) frame (locks_invariant e m0) } fp' x `star` frame `star` locks_invariant e m0; }; assert (H.interp (fp' x `star` (frame `star` locks_invariant e m0)) h1); assert (H.interp (fp' x `star` frame `star` locks_invariant e m0) h1); let m1 = hmem_of_hheap m0 h1 in assert (mem_evolves m0 m1); mprop_preservation_of_hprop_preservation (frame `star` locks_invariant e m0) m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)); (| x, m1 |) let lift_tot_action_with_frame #a #e #fp #fp' ($f:tot_action_with_frame_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in assert (inames_ok e m0); ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); let m0' : hmem_with_inv_except e fp = m0 in let r = f frame m0' in let (| x, m1 |) = r in ac_reasoning_for_m_frame_preserving (fp' x) frame (locks_invariant e m1) m1; assert (interp (fp' x `star` frame `star` locks_invariant e m1) m1); assert (interp (fp' x `star` locks_invariant e m1) m1); let m1' : hmem_with_inv_except e (fp' x) = m1 in NMSTTotal.put #_ #(mem_evolves) m1; x let sel_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.sel_action #a #pcm r v0)) let upd_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.upd_action #a #pcm r v0 v1)) let free_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.free_action #a #pcm r v0)) let split_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.split_action #a #pcm r v0 v1)) let gather_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.gather_action #a #pcm r v0 v1)) let weaken (p q r:slprop) (h:H.hheap (p `star` q) { H.stronger q r }) : H.hheap (p `star` r) = H.weaken p q r h; h let weaken_pure (q r: prop) : Lemma (requires (q ==> r)) (ensures H.stronger (H.pure q) (H.pure r)) = let aux (h:H.heap) : Lemma (ensures (H.interp (H.pure q) h ==> H.interp (H.pure r) h)) [SMTPat ()] = H.pure_interp q h; H.pure_interp r h in () let inc_ctr (#p:slprop) #e (m:hmem_with_inv_except e p) : m':hmem_with_inv_except e p{m'.ctr = m.ctr + 1 /\ H.stronger (linv e m) (linv e m')} = let m' : mem = { m with ctr = m.ctr + 1} in assert (interp (p `star` linv e m) m'); assert (linv e m == lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m)); assert (linv e m' == lock_store_invariant e m.locks `star` ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken_free_above (heap_of_mem m) m.ctr (m.ctr + 1); weaken_pure (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_ctr_valid (m.ctr + 1) (heap_of_mem m)); assert (H.stronger (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m))); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)); H.stronger_star (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken (p `star` lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)) (heap_of_mem m'); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity (m.ctr + 1) (heap_of_mem m)); let m' : hmem_with_inv_except e p = m' in m' let frame_related_mems (fp0 fp1:slprop u#a) e (m0:hmem_with_inv_except e fp0) (m1:hmem_with_inv_except e fp1) = forall (frame:slprop u#a). interp ((fp0 `star` frame) `star` linv e m0) m0 ==> interp ((fp1 `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) let refined_pre_action e (fp0:slprop) (a:Type) (fp1:a -> slprop) = m0:hmem_with_inv_except e fp0 -> Pure (x:a & hmem_with_inv_except e (fp1 x)) (requires True) (ensures fun (| x, m1 |) -> frame_related_mems fp0 (fp1 x) e m0 m1) let refined_pre_action_as_action (#fp0:slprop) (#a:Type) (#fp1:a -> slprop) #e ($f:refined_pre_action e fp0 a fp1) : tot_action_nf_except e fp0 a fp1 = let g : tot_pre_action_nf_except e fp0 a fp1 = fun m -> f m in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp0 `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp1 x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x', m1' |) = g m0 in let (| x, m1 |) = f m0 in assert (x == x' /\ m1 == m1') in g let alloc_action #a #pcm e x = let f : refined_pre_action e emp (ref a pcm) (fun r -> pts_to r x) = fun m0 -> (* NS: 9/29/22 I needed to annotate h : Heap.full_heap, for use with the Core checker which generates a guard for checking the implicit pattern "dot" term in the dependent pair pattern on the next line. That guard expects `h` to be a full_heap, which is it, because it is a projection of m0. However, this is not reflected in `h`'s type. So, the Core checker, which produces a guard for the pat_dot_term in isolation, cannot recheck the term. If we were to fold in the checking of pat_dot_terms and their guards with the rest of the VC, this would work. *) let h : Heap.full_heap = hheap_of_hmem m0 in let (|r, h'|) = H.extend #a #pcm x m0.ctr h in let m' : hmem_with_inv_except e emp = inc_ctr m0 in let h' : H.hheap (pts_to #a #pcm r x `star` linv e m') = weaken _ (linv e m0) (linv e m') h' in let m1 : hmem_with_inv_except e (pts_to #a #pcm r x) = hmem_of_hheap m' h' in assert (forall frame. H.frame_related_heaps h h' emp (pts_to #a #pcm r x) frame true); let aux (frame:slprop) : Lemma (requires interp ((emp `star` frame) `star` linv e m0) m0) (ensures interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) [SMTPat (emp `star` frame)] = star_associative emp frame (linv e m0); assert (H.interp (emp `star` (frame `star` linv e m0)) h); assert (H.interp (pts_to #a #pcm r x `star` (frame `star` linv e m0)) h'); star_associative (pts_to #a #pcm r x) frame (linv e m0); assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m0) h'); assert (H.stronger (linv e m0) (linv e m')); assert (H.equiv (linv e m') (linv e m1)); assert (H.stronger (linv e m0) (linv e m1)); let h' : H.hheap ((pts_to #a #pcm r x `star` frame) `star` linv e m1) = weaken _ (linv e m0) (linv e m1) h' in assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) h'); assert (forall (mp:H.hprop frame). mp h == mp h'); mprop_preservation_of_hprop_preservation frame m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) in assert (frame_related_mems emp (pts_to r x) e m0 m1); (| r, m1 |) in lift_tot_action (refined_pre_action_as_action f) let select_refine #a #p e r x f = lift_tot_action (lift_heap_action e (H.select_refine #a #p r x f)) let upd_gen #a #p e r x y f = lift_tot_action (lift_heap_action e (H.upd_gen_action r x y f)) //////////////////////////////////////////////////////////////////////////////// // witness / recall //////////////////////////////////////////////////////////////////////////////// let witnessed_ref #a #pcm (r:ref a pcm) (fact:property a) (m:full_mem) = H.witnessed_ref #a #pcm r fact (heap_of_mem m) let witnessed_ref_stability #a #pcm (r:ref a pcm) (fact:property a) : Lemma (requires FStar.Preorder.stable fact (Steel.Preorder.preorder_of_pcm pcm)) (ensures FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) = H.witnessed_ref_stability #a #pcm r fact let witnessed (#a:Type u#1) (#pcm:pcm a) (r:ref a pcm) (fact:property a) = W.witnessed _ mem_evolves (witnessed_ref r fact) let rearrange_pqr_prq (p q r:slprop) : Lemma (((p `star` q) `star` r) `equiv` ((p `star` r) `star` q)) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_associative p q r } p `star` (q `star` r); (equiv) { star_commutative q r; star_congruence p (q `star` r) p (r `star` q) } p `star` (r `star` q); (equiv) { star_associative p r q } (p `star` r) `star` q; } let preserves_frame_cong (e:inames) (p q:slprop) (r s:slprop) (m0 m1:mem) : Lemma (requires p `equiv` r /\ q `equiv` s /\ preserves_frame e p q m0 m1) (ensures preserves_frame e r s m0 m1) = let aux0 (p q r s:slprop) : Lemma (requires p `equiv` s) (ensures (((p `star` q) `star` r) `equiv` ((s `star` q) `star` r))) = star_congruence p q s q; star_congruence (p `star` q) r (s `star` q) r in let aux (frame:slprop) : Lemma (requires interp ((r `star` frame) `star` locks_invariant e m0) m0) (ensures interp ((s `star` frame) `star` locks_invariant e m1) m1 /\ interp ((p `star` frame) `star` locks_invariant e m0) m0) [SMTPat (r `star` frame)] = aux0 p frame (locks_invariant e m0) r; aux0 q frame (locks_invariant e m1) s; assert (((p `star` frame) `star` locks_invariant e m0) `equiv` ((r `star` frame) `star` locks_invariant e m0)); assert (interp ((p `star` frame) `star` locks_invariant e m0) m0); assert (interp ((q `star` frame) `star` locks_invariant e m1) m1); assert (((q `star` frame) `star` locks_invariant e m1) `equiv` ((s `star` frame) `star` locks_invariant e m1)); () in () let pure_true_equiv (p:slprop) : Lemma ((p `star` pure True) `equiv` p) = FStar.Classical.forall_intro (pure_star_interp p True); emp_unit p; assert ((p `star` pure True) `equiv` p) let preserves_frame_star_pure (e:inames) (p q:slprop) (r s:prop) (m:mem) : Lemma (requires r /\ s) (ensures preserves_frame e p q m m <==> preserves_frame e (p `star` pure r) (q `star` pure s) m m) = pure_equiv r True; star_congruence p (pure r) p (pure True); pure_equiv s True; star_congruence q (pure s) q (pure True); pure_true_equiv p; pure_true_equiv q; let fwd () : Lemma (requires preserves_frame e p q m m) (ensures preserves_frame e (p `star` pure r) (q `star` pure s) m m) [SMTPat ()] = preserves_frame_cong e p q (p `star` pure r) (q `star` pure s) m m in let bk () : Lemma (requires preserves_frame e (p `star` pure r) (q `star` pure s) m m) (ensures preserves_frame e p q m m) [SMTPat ()] = preserves_frame_cong e (p `star` pure r) (q `star` pure s) p q m m in () let witness (#a:Type) (#pcm:pcm a) (e:inames) (r:erased (ref a pcm)) (fact:stable_property pcm) (v:Ghost.erased a) (_:squash (forall z. compatible pcm v z ==> fact z)) (frame:slprop) : MstTot (witnessed r fact) e (pts_to r v) (fun _ -> pts_to r v) frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in let _ : unit = let hr : H.ref a pcm = r in let v' = H.sel_v hr v (heap_of_mem m0) in assert (interp (H.ptr hr) m0 /\ H.sel #a #pcm hr (heap_of_mem m0) == v'); assert (compatible pcm v v'); assert (fact v'); assert (witnessed_ref r fact m0); witnessed_ref_stability r fact; assert (FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) in let w = NMSTTotal.witness _ mem_evolves (witnessed_ref r fact) in w let recall (#a:Type u#1) (#pcm:pcm a) (#fact:property a) (e:inames) (r:erased (ref a pcm)) (v:Ghost.erased a) (w:witnessed r fact) (frame:slprop) = let m0 = NMSTTotal.get () in NMSTTotal.recall _ mem_evolves (witnessed_ref r fact) w; let hr : H.ref a pcm = r in assert (witnessed_ref r fact m0); let v1 = H.sel_v hr v (heap_of_mem m0) in assert (compatible pcm v v1); assert (H.sel hr (heap_of_mem m0) == v1); assert (fact v1); assert (interp ((pts_to r v `star` frame) `star` locks_invariant e m0) m0); emp_unit ((pts_to r v `star` frame) `star` locks_invariant e m0); pure_star_interp ((pts_to r v `star` frame) `star` locks_invariant e m0) (fact v1) m0; assert (interp (((pts_to r v `star` frame) `star` locks_invariant e m0) `star` pure (fact v1)) m0); rearrange_pqr_prq (pts_to r v `star` frame) (locks_invariant e m0) (pure (fact v1)); assert (interp (((pts_to r v `star` frame) `star` pure (fact v1)) `star` locks_invariant e m0) m0); rearrange_pqr_prq (pts_to r v) frame (pure (fact v1)); star_congruence ((pts_to r v `star` frame) `star` pure (fact v1)) (locks_invariant e m0) ((pts_to r v `star` pure (fact v1)) `star` frame) (locks_invariant e m0); Ghost.hide v1 let iname_for_p_mem (i:iname) (p:slprop) : W.s_predicate mem = fun m -> iname_for_p i p m.locks let iname_for_p_stable (i:iname) (p:slprop) : Lemma (W.stable full_mem mem_evolves (iname_for_p_mem i p)) = () let ( >--> ) (i:iname) (p:slprop) : Type0 = W.witnessed full_mem mem_evolves (iname_for_p_mem i p) let hmem_with_inv_equiv e (m:mem) (p:slprop) : Lemma (interp (p `star` linv e m) m <==> interp (p `star` lock_store_invariant e m.locks) m /\ heap_ctr_valid m.ctr (heap_of_mem m)) = calc (<==>) { interp (p `star` linv e m) m; (<==>) { H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) } interp ((p `star` lock_store_invariant e m.locks) `star` ctr_validity m.ctr (heap_of_mem m)) m; (<==>) { H.pure_star_interp (p `star` lock_store_invariant e m.locks) (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_of_mem m) } interp ((p `star` lock_store_invariant e m.locks) `star` emp) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); (<==>) { H.emp_unit (p `star` lock_store_invariant e m.locks) } interp (p `star` lock_store_invariant e m.locks) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); } let new_invariant_tot_action (e:inames) (p:slprop) (m0:hmem_with_inv_except e p{ e `inames_in` m0.locks }) : Pure (iname & hmem_with_inv_except e emp) (requires True) (ensures fun (i, m1) -> iname_for_p_mem i p m1 /\ frame_related_mems p emp e m0 m1 /\ mem_evolves m0 m1) = let (| i, l1 |) = extend_lock_store e m0.locks p in let m1 = { m0 with locks = l1 } in assert (lock_store_invariant e m1.locks == p `star` lock_store_invariant e m0.locks); calc (equiv) { linv e m1; (equiv) {} (lock_store_invariant e m1.locks `star` ctr_validity m1.ctr (heap_of_mem m1)); (equiv) {} ((p `star` lock_store_invariant e m0.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); (equiv) { H.star_associative p (lock_store_invariant e m0.locks) (ctr_validity m1.ctr (heap_of_mem m1)) } (p `star` (lock_store_invariant e m0.locks `star` ctr_validity m1.ctr (heap_of_mem m1))); (equiv) { } (p `star` linv e m0); }; assert (iname_for_p_mem i p m1); assert (lock_store_evolves m0.locks l1); assert (mem_evolves m0 m1); hmem_with_inv_equiv e m0 p; assert (interp (p `star` lock_store_invariant e m0.locks) m1); assert (interp (lock_store_invariant e m1.locks) m1); H.emp_unit (lock_store_invariant e m1.locks); H.star_commutative (lock_store_invariant e m1.locks) emp; assert (interp (emp `star` lock_store_invariant e m1.locks) m1); hmem_with_inv_equiv e m1 emp; let m1 : hmem_with_inv_except e emp = m1 in let aux (frame:slprop) : Lemma (requires interp ((p `star` frame) `star` linv e m0) m0) (ensures interp ((emp `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) <==> mp (core_mem m1))) [SMTPat (p `star` frame)] = assert (interp ((p `star` frame) `star` linv e m0) m1); calc (equiv) { ((p `star` frame) `star` linv e m0); (equiv) { H.star_commutative p frame; H.star_congruence (p `star` frame) (linv e m0) (frame `star` p) (linv e m0); H.star_associative frame p (linv e m0) } (frame `star` (p `star` linv e m0)); (equiv) { H.star_congruence frame (p `star` linv e m0) frame (linv e m1) } (frame `star` linv e m1); (equiv) { H.emp_unit (frame `star` linv e m1); H.star_commutative (frame `star` linv e m1) emp; H.star_associative emp frame (linv e m1) } ((emp `star` frame) `star` linv e m1); }; assert (interp ((emp `star` frame) `star` linv e m1) m1) in assert (frame_related_mems p emp e m0 m1); ( i, m1 ) let name_is_ok (i:iname) (m0:full_mem u#1) : prop = i < List.Tot.length m0.locks let witnessed_name_is_ok (i:iname) = W.witnessed full_mem mem_evolves (name_is_ok i) let pre_inv = i:erased iname & witnessed_name_is_ok i let inv (p:slprop u#1) = i:erased iname & witnessed_name_is_ok i & (i >--> p) let pre_inv_of_inv #p (i:inv p) = let (|i, w, _|) = i in (|i,w|) let name_of_pre_inv (i:pre_inv) = dfst i let rec recall_all (ctx:list pre_inv) : NMSTTotal.NMSTATETOT unit (full_mem u#1) mem_evolves (requires fun _ -> True) (ensures fun m0 _ m1 -> m0==m1 /\ (forall i. i `List.Tot.memP` ctx ==> name_is_ok (name_of_pre_inv i) m0)) = match ctx with | [] -> () | hd::tl -> let (| q, i |) = hd in let i : W.witnessed full_mem mem_evolves (name_is_ok q) = i in NMSTTotal.recall _ mem_evolves (name_is_ok q) i; recall_all tl let fresh_invariant (e:inames) (p:slprop) (ctx:list pre_inv) (frame:slprop) : MstTot (i:inv p { not (mem_inv e i) /\ fresh_wrt ctx (name_of_inv i)}) e p (fun _ -> emp) frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in recall_all ctx; ac_reasoning_for_m_frame_preserving p frame (locks_invariant e m0) m0; assert (interp (p `star` locks_invariant e m0) m0); let r = new_invariant_tot_action e p m0 in let ( i, m1 ) = r in assert (i == List.Tot.length m0.locks); assert (not (Set.mem i e)); assert (mem_evolves m0 m1); NMSTTotal.put #full_mem #mem_evolves m1; iname_for_p_stable i p; let w = NMSTTotal.witness full_mem mem_evolves (iname_for_p_mem i p) in let w0 = NMSTTotal.witness full_mem mem_evolves (name_is_ok i) in (| hide i, w0, w |) let new_invariant (e:inames) (p:slprop) (frame:slprop) : MstTot (inv p) e p (fun _ -> emp) frame (fun _ -> True) (fun _ _ _ -> True) = fresh_invariant e p [] frame let rearrange_invariant (p q r : slprop) (q0 q1:slprop) : Lemma (requires q `equiv` (q0 `star` q1)) (ensures (p `star` (q `star` r)) `equiv` ((q0 `star` p) `star` (q1 `star` r))) = calc (equiv) { p `star` (q `star` r); (equiv) { calc (equiv) { (q `star` r); (equiv) { star_congruence q r (q0 `star` q1) r } (q0 `star` q1) `star` r; }; star_congruence p (q `star` r) p ((q0 `star` q1) `star` r) } (p `star` ((q0 `star` q1) `star` r)); (equiv) { star_associative q0 q1 r; star_congruence p ((q0 `star` q1) `star` r) p (q0 `star` (q1 `star` r)); star_associative p q0 (q1 `star` r) } (p `star` q0) `star` (q1 `star` r); (equiv) { star_commutative p q0; star_congruence (p `star` q0) (q1 `star` r) (q0 `star` p) (q1 `star` r) } (q0 `star` p) `star` (q1 `star` r); } let preserves_frame_invariant (fp fp':slprop) (opened_invariants:inames) (p:slprop) (i:inv p{not (mem_inv opened_invariants i)}) (m0:hmem_with_inv_except (add_inv opened_invariants i) (p `star` fp)) (m1:mem) : Lemma (requires preserves_frame (set_add (name_of_inv i) opened_invariants) (p `star` fp) (p `star` fp') m0 m1 /\ interp (fp' `star` linv opened_invariants m1) m1 /\ inames_ok opened_invariants m1 /\ (lock_store_invariant opened_invariants m0.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks)) /\ (lock_store_invariant opened_invariants m1.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks))) (ensures preserves_frame opened_invariants fp fp' m0 m1) = let aux (frame:slprop) : Lemma (requires interp ((fp `star` frame) `star` linv opened_invariants m0) m0) (ensures interp ((fp' `star` frame) `star` linv opened_invariants m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) [SMTPat()] = rearrange_invariant (fp `star` frame) (lock_store_invariant opened_invariants m0.locks) (ctr_validity m0.ctr (heap_of_mem m0)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks); assert (interp ((p `star` (fp `star` frame)) `star` linv (set_add (name_of_inv i) opened_invariants) m0) m0); star_associative p fp frame; star_congruence (p `star` (fp `star` frame)) (linv (set_add (name_of_inv i) opened_invariants) m0) ((p `star` fp) `star` frame) (linv (set_add (name_of_inv i) opened_invariants) m0); assert (interp (((p `star` fp) `star` frame) `star` linv (set_add (name_of_inv i) opened_invariants) m0) m0); assert (interp (((p `star` fp') `star` frame) `star` linv (set_add (name_of_inv i) opened_invariants) m1) m1); star_associative p fp' frame; star_congruence ((p `star` fp') `star` frame) (linv (set_add (name_of_inv i) opened_invariants) m1) (p `star` (fp' `star` frame)) (linv (set_add (name_of_inv i) opened_invariants) m1); assert (interp ((p `star` (fp' `star` frame)) `star` linv (set_add (name_of_inv i) opened_invariants) m1) m1); rearrange_invariant (fp' `star` frame) (lock_store_invariant opened_invariants m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks); assert (interp ((fp' `star` frame) `star` linv opened_invariants m1) m1); () in () let equiv_ext_right (p q r:slprop) : Lemma (requires q `equiv` r) (ensures (p `star` q) `equiv` (p `star` r)) = calc (equiv) { p `star` q; (equiv) { star_commutative p q } q `star` p; (equiv) { equiv_extensional_on_star q r p } r `star` p; (equiv) { star_commutative p r } p `star` r; } let with_inv_helper (fp frame ls1 ctr p ls2:slprop) : Lemma (requires ls1 `equiv` (p `star` ls2)) (ensures (fp `star` frame `star` (ls1 `star` ctr)) `equiv` (p `star` fp `star` frame `star` (ls2 `star` ctr))) = calc (equiv) { ls1 `star` ctr; (equiv) { equiv_extensional_on_star ls1 (p `star` ls2) ctr } p `star` ls2 `star` ctr; }; calc (equiv) { p `star` ls2 `star` ctr; (equiv) { star_associative p ls2 ctr } p `star` (ls2 `star` ctr); }; calc (equiv) { fp `star` frame `star` p; (equiv) { star_commutative (fp `star` frame) p } p `star` (fp `star` frame); (equiv) { star_associative p fp frame } p `star` fp `star` frame; }; calc (equiv) { fp `star` frame `star` (ls1 `star` ctr); (equiv) { equiv_ext_right (fp `star` frame) (ls1 `star` ctr) (p `star` ls2 `star` ctr) } (fp `star` frame) `star` (p `star` ls2 `star` ctr); (equiv) { equiv_ext_right (fp `star` frame) (p `star` ls2 `star` ctr) (p `star` (ls2 `star` ctr)) } (fp `star` frame) `star` (p `star` (ls2 `star` ctr)); (equiv) { star_associative (fp `star` frame) p (ls2 `star` ctr) } (fp `star` frame `star` p) `star` (ls2 `star` ctr); (equiv) { equiv_extensional_on_star (fp `star` frame `star` p) (p `star` fp `star` frame) (ls2 `star` ctr) } (p `star` fp `star` frame) `star` (ls2 `star` ctr); }

{ "checked_file": "/", "dependencies": [ "Steel.Preorder.fst.checked", "Steel.Heap.fsti.checked", "prims.fst.checked", "FStar.Witnessed.Core.fsti.checked", "FStar.Set.fsti.checked", "FStar.Preorder.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.PCM.fst.checked", "FStar.NMSTTotal.fst.checked", "FStar.List.Tot.fst.checked", "FStar.IndefiniteDescription.fsti.checked", "FStar.Ghost.fsti.checked", "FStar.FunctionalExtensionality.fsti.checked", "FStar.Classical.Sugar.fsti.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Steel.Memory.fst" }

[ { "abbrev": true, "full_module": "Steel.Preorder", "short_module": "PP" }, { "abbrev": true, "full_module": "FStar.Witnessed.Core", "short_module": "W" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": true, "full_module": "Steel.Heap", "short_module": "H" }, { "abbrev": false, "full_module": "FStar.PCM", "short_module": null }, { "abbrev": false, "full_module": "FStar.FunctionalExtensionality", "short_module": null }, { "abbrev": true, "full_module": "FStar.FunctionalExtensionality", "short_module": "F" }, { "abbrev": false, "full_module": "FStar.PCM", "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

i: Steel.Memory.inv p -> Steel.Memory.name_of_inv i >--> p

Prims.Tot

[ "total" ]

[]

[ "Steel.Memory.slprop", "Steel.Memory.inv", "FStar.Ghost.erased", "Steel.Memory.iname", "Steel.Memory.witnessed_name_is_ok", "FStar.Ghost.reveal", "Steel.Memory.op_Greater_Subtraction_Subtraction_Greater", "Steel.Memory.name_of_inv" ]

[]

false

let token_of_inv #p (i: inv p) : (name_of_inv i >--> p) =

let (| _ , _ , tok |) = i in tok

false

Steel.Memory.fst

Steel.Memory.preserves_frame_invariant

val preserves_frame_invariant (fp fp': slprop) (opened_invariants: inames) (p: slprop) (i: inv p {not (mem_inv opened_invariants i)}) (m0: hmem_with_inv_except (add_inv opened_invariants i) (p `star` fp)) (m1: mem) : Lemma (requires preserves_frame (set_add (name_of_inv i) opened_invariants) (p `star` fp) (p `star` fp') m0 m1 /\ interp (fp' `star` (linv opened_invariants m1)) m1 /\ inames_ok opened_invariants m1 /\ ((lock_store_invariant opened_invariants m0.locks) `equiv` (p `star` (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks))) /\ ((lock_store_invariant opened_invariants m1.locks) `equiv` (p `star` (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks)))) (ensures preserves_frame opened_invariants fp fp' m0 m1)

let preserves_frame_invariant (fp fp':slprop) (opened_invariants:inames) (p:slprop) (i:inv p{not (mem_inv opened_invariants i)}) (m0:hmem_with_inv_except (add_inv opened_invariants i) (p `star` fp)) (m1:mem) : Lemma (requires preserves_frame (set_add (name_of_inv i) opened_invariants) (p `star` fp) (p `star` fp') m0 m1 /\ interp (fp' `star` linv opened_invariants m1) m1 /\ inames_ok opened_invariants m1 /\ (lock_store_invariant opened_invariants m0.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks)) /\ (lock_store_invariant opened_invariants m1.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks))) (ensures preserves_frame opened_invariants fp fp' m0 m1) = let aux (frame:slprop) : Lemma (requires interp ((fp `star` frame) `star` linv opened_invariants m0) m0) (ensures interp ((fp' `star` frame) `star` linv opened_invariants m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) [SMTPat()] = rearrange_invariant (fp `star` frame) (lock_store_invariant opened_invariants m0.locks) (ctr_validity m0.ctr (heap_of_mem m0)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks); assert (interp ((p `star` (fp `star` frame)) `star` linv (set_add (name_of_inv i) opened_invariants) m0) m0); star_associative p fp frame; star_congruence (p `star` (fp `star` frame)) (linv (set_add (name_of_inv i) opened_invariants) m0) ((p `star` fp) `star` frame) (linv (set_add (name_of_inv i) opened_invariants) m0); assert (interp (((p `star` fp) `star` frame) `star` linv (set_add (name_of_inv i) opened_invariants) m0) m0); assert (interp (((p `star` fp') `star` frame) `star` linv (set_add (name_of_inv i) opened_invariants) m1) m1); star_associative p fp' frame; star_congruence ((p `star` fp') `star` frame) (linv (set_add (name_of_inv i) opened_invariants) m1) (p `star` (fp' `star` frame)) (linv (set_add (name_of_inv i) opened_invariants) m1); assert (interp ((p `star` (fp' `star` frame)) `star` linv (set_add (name_of_inv i) opened_invariants) m1) m1); rearrange_invariant (fp' `star` frame) (lock_store_invariant opened_invariants m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks); assert (interp ((fp' `star` frame) `star` linv opened_invariants m1) m1); () in ()

{ "file_name": "lib/steel/Steel.Memory.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 8, "end_line": 1371, "start_col": 0, "start_line": 1330 }

(* 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.Memory module F = FStar.FunctionalExtensionality open FStar.FunctionalExtensionality open FStar.PCM module H = Steel.Heap noeq type lock_state : Type u#(a + 1) = | Invariant : inv:H.slprop u#a -> lock_state let lock_store : Type u#(a+1) = list (lock_state u#a) noeq type mem : Type u#(a + 1) = { ctr: nat; heap: H.heap u#a; locks: lock_store u#a; } let heap_of_mem (x:mem) : H.heap = x.heap let mem_of_heap (h:H.heap) : mem = { ctr = 0; heap = h; locks = [] } let mem_set_heap (m:mem) (h:H.heap) : mem = { ctr = m.ctr; heap = h; locks = m.locks; } let core_mem (m:mem) : mem = mem_of_heap (heap_of_mem m) let core_mem_invol m = () let disjoint (m0 m1:mem u#h) : prop = m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks let disjoint_sym m0 m1 = () let join m0 m1 = { ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = m0.locks } let join_commutative m0 m1 = H.join_commutative m0.heap m1.heap let disjoint_join m0 m1 m2 = H.disjoint_join m0.heap m1.heap m2.heap let join_associative m0 m1 m2 = H.join_associative m0.heap m1.heap m2.heap let slprop = H.slprop let interp p m = H.interp p m.heap let equiv p1 p2 = forall m. interp p1 m <==> interp p2 m let slprop_extensionality p q = assert (forall m. interp p m <==> interp q m); let aux (h:H.heap) : Lemma (H.interp p h <==> H.interp q h) [SMTPat (H.interp p h)] = let m : mem = { ctr = 0; heap = h; locks = [] } in assert (interp p m <==> interp q m) in assert (forall h. H.interp p h <==> H.interp q h); Steel.Heap.slprop_extensionality p q let reveal_equiv p1 p2 = () let core_ref = H.core_ref let core_ref_null = H.core_ref_null let core_ref_is_null r = H.core_ref_is_null r let emp : slprop u#a = H.emp let pure = H.pure let pts_to = H.pts_to let h_and = H.h_and let h_or = H.h_or let star = H.star let wand = H.wand let h_exists = H.h_exists let h_forall = H.h_forall //////////////////////////////////////////////////////////////////////////////// //properties of equiv //////////////////////////////////////////////////////////////////////////////// let equiv_symmetric (p1 p2:slprop u#a) = H.equiv_symmetric p1 p2 #push-options "--warn_error -271" let equiv_heap_iff_equiv (p1 p2:slprop u#a) : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat (equiv p1 p2)] = let aux_lr () : Lemma (requires H.equiv p1 p2) (ensures equiv p1 p2) [SMTPat ()] = () in let aux_rl_helper1 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p1 h) (ensures H.interp p2 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl_helper2 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p2 h) (ensures H.interp p1 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl () : Lemma (requires equiv p1 p2) (ensures H.equiv p1 p2) [SMTPat ()] = () in () let equiv_heap_iff_equiv_forall () : Lemma (ensures (forall p1 p2. H.equiv p1 p2 <==> equiv p1 p2)) = let aux p1 p2 : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat ()] = equiv_heap_iff_equiv p1 p2 in () #pop-options let equiv_extensional_on_star (p1 p2 p3:slprop u#a) = equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3 let emp_unit p = H.emp_unit p let intro_emp m = H.intro_emp (heap_of_mem m) let pure_equiv p q = H.pure_equiv p q let pure_interp q m = H.pure_interp q (heap_of_mem m) let pure_star_interp p q m = H.pure_star_interp p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// //pts_to //////////////////////////////////////////////////////////////////////////////// let pts_to_compatible #a #pcm x v0 v1 m = H.pts_to_compatible #a #pcm x v0 v1 (heap_of_mem m) let pts_to_compatible_equiv #a #pcm x v0 v1 = H.pts_to_compatible_equiv #a #pcm x v0 v1 let pts_to_not_null #a #pcm x v m = H.pts_to_not_null #a #pcm x v (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // star //////////////////////////////////////////////////////////////////////////////// let intro_star p q mp mq = H.intro_star p q (heap_of_mem mp) (heap_of_mem mq) let elim_star p q m = let h = heap_of_mem m in H.elim_star p q h; assert (exists hl hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr); let hl = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hl -> exists hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let hr = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hr -> H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let ml = mem_set_heap m hl in let mr = mem_set_heap m hr in assert (disjoint ml mr); assert (m == join ml mr); assert (interp p ml); assert (interp q mr); () let interp_star (p q: slprop) (m: mem) : Lemma (interp (p `star` q) m <==> (exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m)) = let left = interp (p `star` q) m in let right = exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m in let f () : Lemma (requires left) (ensures right) = elim_star p q m in let g () : Lemma (requires right) (ensures left) = Classical.exists_elim left #_ #(fun mp -> exists (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mp -> Classical.exists_elim left #_ #(fun mq -> disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mq -> intro_star p q mp mq ) ) in Classical.move_requires f (); Classical.move_requires g () let star_commutative (p1 p2:slprop) = H.star_commutative p1 p2 let star_associative (p1 p2 p3:slprop) = H.star_associative p1 p2 p3 let star_congruence (p1 p2 p3 p4:slprop) = equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4 let affine_star (p q:slprop) (m:mem) = H.affine_star p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // Invariants on the lock store //////////////////////////////////////////////////////////////////////////////// let iname = nat module S = FStar.Set module L = FStar.List.Tot module W = FStar.Witnessed.Core let rec lock_store_invariant (e:inames) (l:lock_store u#a) : slprop u#a = let current_addr = L.length l - 1 in match l with | [] -> emp | Invariant p :: tl -> if current_addr `S.mem` e then lock_store_invariant e tl else p `star` lock_store_invariant e tl let lock_i (i:iname) (l:lock_store { i < L.length l }) = let ix = L.length l - i - 1 in L.index l ix let iname_for_p (i:iname) (p:slprop) : W.s_predicate lock_store = fun l -> i < L.length l /\ (lock_i i l).inv == p let lock_store_evolves : FStar.Preorder.preorder lock_store = fun (l1 l2 : lock_store) -> L.length l2 >= L.length l1 /\ (forall (i:nat{i < L.length l1}). (lock_i i l1).inv == (lock_i i l2).inv) let inames_in (e:inames) (l:lock_store) : prop = forall i. Set.mem i e ==> i < L.length l let inames_ok e m = inames_in e m.locks let inames_ok_empty m = () let extend_lock_store (e:inames) (l:lock_store{e `inames_in` l}) (p:slprop) : i:iname & l':lock_store { lock_store_invariant e l' == p `star` lock_store_invariant e l /\ iname_for_p i p l' } = (| L.length l, Invariant p :: l |) let set_add (i:iname) (s:inames) = Set.union (Set.singleton i) s let rec move_invariant (e:inames) (l:lock_store) (p:slprop) (i:iname{iname_for_p i p l /\ ~(i `Set.mem` e)}) : Lemma (H.equiv (lock_store_invariant e l) (p `star` lock_store_invariant (set_add i e) l)) = let rec aux (i:iname) (m:lock_store) : Lemma (requires i >= L.length m) (ensures (lock_store_invariant e m `H.equiv` lock_store_invariant (set_add i e) m)) = match m with | [] -> () | Invariant p::tl -> aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl) in let current_addr = L.length l - 1 in match l with | [] -> () | Invariant q::tl -> if i = current_addr then begin assert (lock_store_invariant e l == p `star` lock_store_invariant e tl); aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl); () end else begin move_invariant e tl p i; assert (lock_store_invariant e tl `equiv` (p `star` lock_store_invariant (set_add i e) tl)); H.star_congruence q (lock_store_invariant e tl) q (p `star` lock_store_invariant (set_add i e) tl); if Set.mem current_addr e then () else begin let r = lock_store_invariant (set_add i e) tl in assert (lock_store_invariant e l `equiv` (q `star` (p `star` r))); H.star_associative q p r; H.star_commutative q p; H.star_congruence (q `star` p) r (p `star` q) r; H.star_associative p q r end end let heap_ctr_valid (ctr:nat) (h:H.heap u#a) : prop = h `H.free_above_addr` ctr let ctr_validity (ctr:nat) (h:H.heap) : slprop = H.pure (heap_ctr_valid ctr h) let locks_invariant (e:inames) (m:mem u#a) : slprop u#a = lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m) let full_mem_pred (m:mem) = H.full_heap_pred (heap_of_mem m) (***** Following lemmas are needed in Steel.Effect *****) let core_mem_interp (hp:slprop u#a) (m:mem u#a) = () let interp_depends_only_on (hp:slprop u#a) = H.interp_depends_only_on hp let a_mem_prop_as_a_heap_prop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (H.a_heap_prop u#a) = let g (h: H.heap u#a) : Tot prop = interp sl (mem_of_heap h) /\ f (mem_of_heap h) in let phi0 (h0 h1: H.heap u#a) : Lemma (requires (g h0 /\ H.disjoint h0 h1)) (ensures (g h0 /\ H.disjoint h0 h1 /\ g (H.join h0 h1))) = assert (mem_of_heap (H.join h0 h1) == mem_of_heap h0 `join` mem_of_heap h1); interp_depends_only_on sl in let phi1 (h0 h1: H.heap u#a) : Lemma (ensures ((g h0 /\ H.disjoint h0 h1) ==> g (H.join h0 h1))) = Classical.move_requires (phi0 h0) h1 in Classical.forall_intro_2 phi1; g let refine_slprop sl f = H.as_slprop (a_mem_prop_as_a_heap_prop sl f) let interp_refine_slprop sl f m = assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_mem m)) let dep_hprop (s: slprop) (f: (hmem s -> Tot slprop)) (h: H.heap) : Tot prop = exists (h1: H.heap) . exists (h2: H.heap) . interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 let dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq' : squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h')) = let p2 (h h1 h2: H.heap) : Tot prop = interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 in let p1 (h h1: H.heap) : Tot prop = (exists h2 . p2 h h1 h2) in let h1 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p1 h) in let h2 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p2 h h1) in H.disjoint_join h' h1 h2; assert (H.disjoint h2 h'); let h2' = H.join h2 h' in H.join_commutative h2 h' ; assert (h2' == H.join h' h2); assert (H.disjoint h1 h2'); assert (mem_of_heap h2' == mem_of_heap h2 `join` mem_of_heap h'); interp_depends_only_on (f (mem_of_heap h1)); assert (interp (f (mem_of_heap h1)) (mem_of_heap h2')); H.join_commutative h1 h2; H.join_associative h' h2 h1; H.join_commutative h' h; H.join_commutative h2' h1; assert (H.join h h' == h1 `H.join` h2') let impl_intro_gen (#p: Type0) (#q: Type0) ($prf: (squash p -> Lemma (q ))) : Lemma (p ==> q) = Classical.impl_intro_gen #p #(fun _ -> q) prf let dep_hprop_is_affine1 (s: slprop) (f: (hmem s -> Tot slprop)) (h0 h1: H.heap) : Lemma ((dep_hprop s f h0 /\ H.disjoint h0 h1) ==> (H.disjoint h0 h1 /\ dep_hprop s f (H.join h0 h1))) = impl_intro_gen (dep_hprop_is_affine0 s f h0 h1) let dep_hprop_is_affine (s: slprop) (f: (hmem s -> Tot slprop)) : Lemma (H.heap_prop_is_affine (dep_hprop s f)) = Classical.forall_intro_2 (dep_hprop_is_affine1 s f) let sdep (s: slprop) (f: (hmem s -> Tot slprop)) : Tot slprop = dep_hprop_is_affine s f; H.as_slprop (dep_hprop s f) let interp_sdep (s: slprop) (f: (hmem s -> Tot slprop)) (m: mem) : Lemma (requires (dep_slprop_is_affine s f)) (ensures ( interp (sdep s f) m <==> (exists m1 m2 . interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) )) = dep_hprop_is_affine s f; assert (forall m1 m2 . (interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) ==> ( interp s (mem_of_heap m1.heap) /\ interp (f (mem_of_heap m1.heap)) (mem_of_heap m2.heap) /\ H.disjoint m1.heap m2.heap /\ H.join m1.heap m2.heap == m.heap )); interp_depends_only_on s; Classical.forall_intro (fun m -> interp_depends_only_on (f m)); assert (forall h1 h2 . (interp s (mem_of_heap h1) /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ H.disjoint h1 h2 /\ H.join h1 h2 == m.heap) ==> ( core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ interp s (core_mem (mem_of_heap h1)) /\ interp s (mem_set_heap m h1) /\ core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ f (mem_set_heap m h1) `equiv` f (mem_of_heap h1) /\ interp (f (mem_set_heap m h1)) (mem_of_heap h2) /\ interp (f (mem_set_heap m h1)) (mem_set_heap m h2) /\ disjoint (mem_set_heap m h1) (mem_set_heap m h2) /\ join (mem_set_heap m h1) (mem_set_heap m h2) == m )); () let h_exists_cong (#a:Type) (p q : a -> slprop) : Lemma (requires (forall x. p x `equiv` q x)) (ensures (h_exists p `equiv` h_exists q)) = equiv_heap_iff_equiv_forall (); H.h_exists_cong p q let intro_h_exists #a x p m = H.intro_h_exists x p (heap_of_mem m) let elim_h_exists (#a:_) (p:a -> slprop) (m:mem) = H.elim_h_exists p (heap_of_mem m) let intro_h_forall (#a:_) (p:a -> slprop) (m:mem) = H.intro_h_forall p (heap_of_mem m) let elim_h_forall (#a:_) (p:a -> slprop) (m:mem) (x:a) = H.elim_h_forall p (heap_of_mem m) x let intro_h_and (p q: slprop) (m:mem) = H.intro_h_and p q (heap_of_mem m) let elim_h_and (p q: slprop) (m:mem) = H.elim_h_and p q (heap_of_mem m) let intro_h_or_left (p q: slprop) (m:mem) = H.intro_h_or_left p q (heap_of_mem m) let intro_h_or_right (p q: slprop) (m:mem) = H.intro_h_or_right p q (heap_of_mem m) let elim_h_or (p q: slprop) (m:mem) = H.elim_h_or p q (heap_of_mem m) let intro_wand (p1 p2: slprop u#a) (m:mem) = introduce (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)) ==> interp (wand p1 p2) m with _. ( assert (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)); H.intro_wand p1 p2 (heap_of_mem m); let h = heap_of_mem m in assert ((forall h1. h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) ==> H.interp (wand p1 p2) h); introduce forall h1. (h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) with ( introduce (h `H.disjoint` h1 /\ H.interp p1 h1) ==> H.interp p2 (H.join h h1) with _. ( assert (h `H.disjoint` h1); let m1 = { ctr = m.ctr; heap = h1; locks = m.locks } in assert (m `disjoint` m1) ) ) ) (** Eliminating a wand by proving a heap that satisfies the LHS **) let elim_wand (p1 p2: slprop u#a) (m:mem) (m1:mem) = H.elim_wand p1 p2 (heap_of_mem m) (heap_of_mem m1) //////////////////////////////////////////////////////////////////////////////// // Preorders and effects //////////////////////////////////////////////////////////////////////////////// module PP = Steel.Preorder let mem_evolves = fun (m0 m1:full_mem) -> H.heap_evolves (heap_of_mem m0) (heap_of_mem m1) /\ m0.ctr <= m1.ctr /\ lock_store_evolves m0.locks m1.locks (** See [Steel.Heap.is_frame_preserving]. We add in [lock_invariants] now *) let preserves_frame (e:inames) (pre post:slprop) (m0 m1:mem) = forall (frame:slprop). interp ((pre `star` frame) `star` locks_invariant e m0) m0 ==> (interp ((post `star` frame) `star` locks_invariant e m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) (** This is a version of MstTot with frame quantified, as part of preserves_frame *) effect MstTotNF (a:Type u#a) (except:inames) (expects:slprop u#1) (provides: a -> slprop u#1) = NMSTTotal.NMSTATETOT a (full_mem u#1) mem_evolves (requires fun m0 -> inames_ok except m0 /\ interp (expects `star` locks_invariant except m0) m0) (ensures fun m0 x m1 -> inames_ok except m1 /\ interp (provides x `star` locks_invariant except m1) m1 /\ preserves_frame except expects (provides x) m0 m1) //////////////////////////////////////////////////////////////////////////////// // Lifting heap actions //////////////////////////////////////////////////////////////////////////////// (** Heap actions come in two equivalent flavors: - one that take an explicit frame as argument (action_with_frame) - and one that quantify over all the frame We therefore define two lift routes: - a direct route for those with explicit frame - via MstTotNF for the rest *) let tot_pre_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = hmem_with_inv_except e fp -> (x:a & hmem_with_inv_except e (fp' x)) let tot_pre_action_nf = tot_pre_action_nf_except S.empty let ac_reasoning_for_m_frame_preserving (p q r:slprop u#a) (m:mem u#a) : Lemma (requires interp ((p `star` q) `star` r) m) (ensures interp (p `star` r) m) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_commutative p q; equiv_extensional_on_star (p `star` q) (q `star` p) r } (q `star` p) `star` r; (equiv) { star_associative q p r } q `star` (p `star` r); }; assert (interp (q `star` (p `star` r)) m); affine_star q (p `star` r) m let is_frame_preserving (#e:inames) (#a:Type u#b) (#fp:slprop u#a) (#fp':a -> slprop u#a) (f:tot_pre_action_nf_except e fp a fp') = forall (frame:slprop u#a) (m0:hmem_with_inv_except e (fp `star` frame)). (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = f:tot_pre_action_nf_except e fp a fp'{ is_frame_preserving f } let tot_action_nf = tot_action_nf_except S.empty let linv e (m:mem) = locks_invariant e m let hheap_of_hmem #fp #e (m:hmem_with_inv_except e fp) : h:H.hheap (fp `star` linv e m) { h `H.free_above_addr` m.ctr} = let h = heap_of_mem m in H.pure_interp (heap_ctr_valid m.ctr (heap_of_mem m)) h; h let hmem_of_hheap #e (#fp0 #fp1:slprop) (m:hmem_with_inv_except e fp0) (h:H.full_hheap (fp1 `star` linv e m) { h `Heap.free_above_addr` m.ctr }) : m1:hmem_with_inv_except e fp1{linv e m `equiv` linv e m1} = let m1 : mem = { m with heap = h } in assert (interp (fp1 `star` linv e m) m1); star_commutative fp1 (linv e m); assert (interp (linv e m `star` fp1) m1); assert (linv e m1 == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); assert (linv e m == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m)); H.pure_interp (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_of_mem m); assert (heap_ctr_valid m1.ctr (heap_of_mem m) <==> heap_ctr_valid m1.ctr (heap_of_mem m1)); H.pure_equiv (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_ctr_valid m1.ctr (heap_of_mem m1)); H.star_congruence (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m)); assert (linv e m `equiv` linv e m1); let _ = equiv_extensional_on_star (linv e m) (linv e m1) fp1 in assert ((linv e m `star` fp1) `equiv` (linv e m1 `star` fp1)); assert (interp (linv e m1 `star` fp1) m1); star_commutative (linv e m1) fp1; assert (interp (fp1 `star` linv e m1) m1); m1 let with_inv_except (m:mem) e (fp:slprop) = interp (fp `star` locks_invariant e m) m #push-options "--warn_error -271" let as_hprop (frame:slprop) (mp:mprop frame) : hp:H.hprop frame{forall m. mp (core_mem m) == hp (heap_of_mem m)} = let f = fun h -> mp (mem_of_heap h) in assert (forall m. mp (core_mem m) == f (heap_of_mem m)); let aux (m0:H.hheap frame) (m1:H.heap{H.disjoint m0 m1}) : Lemma (ensures (mem_of_heap (H.join m0 m1) == join (mem_of_heap m0) (mem_of_heap m1))) [SMTPat ()] = () in f let mprop_preservation_of_hprop_preservation (p:slprop) (m0 m1:mem) : Lemma (requires (forall (hp:H.hprop p). hp (heap_of_mem m0) == hp (heap_of_mem m1))) (ensures (forall (mp:mprop p). mp (core_mem m0) == mp (core_mem m1))) = let aux (mp:mprop p) : Lemma (mp (core_mem m0) == mp (core_mem m1)) [SMTPat()] = assert (as_hprop p mp (heap_of_mem m0) == as_hprop p mp (heap_of_mem m1)) in () let lift_heap_action (#fp:slprop) (#a:Type) (#fp':a -> slprop) (e:inames) ($f:H.action fp a fp') : tot_action_nf_except e fp a fp' = let g : tot_pre_action_nf_except e fp a fp' = fun m -> let h0 = hheap_of_hmem m in let (| x, h' |) = f h0 in (| x, hmem_of_hheap m h' |) in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in let h0 = hheap_of_hmem m0 in let (| x', h1 |) = f h0 in H.action_framing f (linv e m0) h0; assert (x == x'); star_associative fp frame (linv e m0); H.action_framing f (frame `star` linv e m0) h0; assert (H.interp ((fp' x) `star` (frame `star` linv e m0)) h1); star_associative (fp' x) frame (linv e m0); assert (H.interp ((fp' x `star` frame) `star` linv e m0) h1); let h1' : H.hheap ((fp' x `star` frame) `star` linv e m0) = h1 in assert (m1 == hmem_of_hheap m0 h1'); assert (with_inv_except m1 e (fp' x `star` frame)); assert (forall (hp:H.hprop frame). hp h0 == hp h1); mprop_preservation_of_hprop_preservation frame m0 m1; () in assert (is_frame_preserving g); g let frame_preserving_respects_preorder #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (m0:hmem_with_inv_except e fp) : Lemma (let (| x, m1 |) = f m0 in mem_evolves m0 m1) = let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1) = () in H.emp_unit fp; assert (interp (fp `star` linv e m0) m0); H.star_congruence (fp `star` emp) (linv e m0) fp (linv e m0); assert (interp ((fp `star` emp) `star` linv e m0) m0); aux emp m0 let lift_tot_action_nf #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') : MstTotNF a e fp fp' = let m0 = NMSTTotal.get () in let m0' : hmem_with_inv_except e fp = m0 in let r = f m0' in let (| x, m1 |) = r in let m1' : hmem_with_inv_except e (fp' x) = m1 in assert (is_frame_preserving f); assert (m1 == dsnd (f m0)); frame_preserving_respects_preorder f m0; NMSTTotal.put #_ #(mem_evolves) m1; x let lift_tot_action #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get #(full_mem) #_ () in ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); lift_tot_action_nf f (** Now defining the lift for heap actions with explicit frame *) let tot_action_with_frame_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = frame:slprop u#a -> m0:hmem_with_inv_except e (fp `star` frame) -> Pure (x:a & hmem_with_inv_except e (fp' x `star` frame)) (requires True) (ensures fun (| x, m1 |) -> mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_with_frame = tot_action_with_frame_except S.empty let lift_heap_action_with_frame (#fp:slprop u#a) (#a:Type u#b) (#fp':a -> slprop u#a) (e:inames) ($f:H.action_with_frame fp a fp') : tot_action_with_frame_except e fp a fp' = fun frame m0 -> let h0 = hheap_of_hmem m0 in calc (equiv) { fp `star` frame `star` locks_invariant e m0; (equiv) { star_associative fp frame (locks_invariant e m0) } fp `star` (frame `star` locks_invariant e m0); }; assert (H.interp (fp `star` frame `star` locks_invariant e m0) h0); assert (H.interp (fp `star` (frame `star` locks_invariant e m0)) h0); //key: apply the heap action with frame * locks_invariant e m0 let (| x, h1 |) = f (frame `star` locks_invariant e m0) h0 in calc (equiv) { fp' x `star` (frame `star` locks_invariant e m0); (equiv) { star_associative (fp' x) frame (locks_invariant e m0) } fp' x `star` frame `star` locks_invariant e m0; }; assert (H.interp (fp' x `star` (frame `star` locks_invariant e m0)) h1); assert (H.interp (fp' x `star` frame `star` locks_invariant e m0) h1); let m1 = hmem_of_hheap m0 h1 in assert (mem_evolves m0 m1); mprop_preservation_of_hprop_preservation (frame `star` locks_invariant e m0) m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)); (| x, m1 |) let lift_tot_action_with_frame #a #e #fp #fp' ($f:tot_action_with_frame_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in assert (inames_ok e m0); ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); let m0' : hmem_with_inv_except e fp = m0 in let r = f frame m0' in let (| x, m1 |) = r in ac_reasoning_for_m_frame_preserving (fp' x) frame (locks_invariant e m1) m1; assert (interp (fp' x `star` frame `star` locks_invariant e m1) m1); assert (interp (fp' x `star` locks_invariant e m1) m1); let m1' : hmem_with_inv_except e (fp' x) = m1 in NMSTTotal.put #_ #(mem_evolves) m1; x let sel_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.sel_action #a #pcm r v0)) let upd_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.upd_action #a #pcm r v0 v1)) let free_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.free_action #a #pcm r v0)) let split_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.split_action #a #pcm r v0 v1)) let gather_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.gather_action #a #pcm r v0 v1)) let weaken (p q r:slprop) (h:H.hheap (p `star` q) { H.stronger q r }) : H.hheap (p `star` r) = H.weaken p q r h; h let weaken_pure (q r: prop) : Lemma (requires (q ==> r)) (ensures H.stronger (H.pure q) (H.pure r)) = let aux (h:H.heap) : Lemma (ensures (H.interp (H.pure q) h ==> H.interp (H.pure r) h)) [SMTPat ()] = H.pure_interp q h; H.pure_interp r h in () let inc_ctr (#p:slprop) #e (m:hmem_with_inv_except e p) : m':hmem_with_inv_except e p{m'.ctr = m.ctr + 1 /\ H.stronger (linv e m) (linv e m')} = let m' : mem = { m with ctr = m.ctr + 1} in assert (interp (p `star` linv e m) m'); assert (linv e m == lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m)); assert (linv e m' == lock_store_invariant e m.locks `star` ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken_free_above (heap_of_mem m) m.ctr (m.ctr + 1); weaken_pure (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_ctr_valid (m.ctr + 1) (heap_of_mem m)); assert (H.stronger (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m))); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)); H.stronger_star (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken (p `star` lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)) (heap_of_mem m'); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity (m.ctr + 1) (heap_of_mem m)); let m' : hmem_with_inv_except e p = m' in m' let frame_related_mems (fp0 fp1:slprop u#a) e (m0:hmem_with_inv_except e fp0) (m1:hmem_with_inv_except e fp1) = forall (frame:slprop u#a). interp ((fp0 `star` frame) `star` linv e m0) m0 ==> interp ((fp1 `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) let refined_pre_action e (fp0:slprop) (a:Type) (fp1:a -> slprop) = m0:hmem_with_inv_except e fp0 -> Pure (x:a & hmem_with_inv_except e (fp1 x)) (requires True) (ensures fun (| x, m1 |) -> frame_related_mems fp0 (fp1 x) e m0 m1) let refined_pre_action_as_action (#fp0:slprop) (#a:Type) (#fp1:a -> slprop) #e ($f:refined_pre_action e fp0 a fp1) : tot_action_nf_except e fp0 a fp1 = let g : tot_pre_action_nf_except e fp0 a fp1 = fun m -> f m in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp0 `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp1 x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x', m1' |) = g m0 in let (| x, m1 |) = f m0 in assert (x == x' /\ m1 == m1') in g let alloc_action #a #pcm e x = let f : refined_pre_action e emp (ref a pcm) (fun r -> pts_to r x) = fun m0 -> (* NS: 9/29/22 I needed to annotate h : Heap.full_heap, for use with the Core checker which generates a guard for checking the implicit pattern "dot" term in the dependent pair pattern on the next line. That guard expects `h` to be a full_heap, which is it, because it is a projection of m0. However, this is not reflected in `h`'s type. So, the Core checker, which produces a guard for the pat_dot_term in isolation, cannot recheck the term. If we were to fold in the checking of pat_dot_terms and their guards with the rest of the VC, this would work. *) let h : Heap.full_heap = hheap_of_hmem m0 in let (|r, h'|) = H.extend #a #pcm x m0.ctr h in let m' : hmem_with_inv_except e emp = inc_ctr m0 in let h' : H.hheap (pts_to #a #pcm r x `star` linv e m') = weaken _ (linv e m0) (linv e m') h' in let m1 : hmem_with_inv_except e (pts_to #a #pcm r x) = hmem_of_hheap m' h' in assert (forall frame. H.frame_related_heaps h h' emp (pts_to #a #pcm r x) frame true); let aux (frame:slprop) : Lemma (requires interp ((emp `star` frame) `star` linv e m0) m0) (ensures interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) [SMTPat (emp `star` frame)] = star_associative emp frame (linv e m0); assert (H.interp (emp `star` (frame `star` linv e m0)) h); assert (H.interp (pts_to #a #pcm r x `star` (frame `star` linv e m0)) h'); star_associative (pts_to #a #pcm r x) frame (linv e m0); assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m0) h'); assert (H.stronger (linv e m0) (linv e m')); assert (H.equiv (linv e m') (linv e m1)); assert (H.stronger (linv e m0) (linv e m1)); let h' : H.hheap ((pts_to #a #pcm r x `star` frame) `star` linv e m1) = weaken _ (linv e m0) (linv e m1) h' in assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) h'); assert (forall (mp:H.hprop frame). mp h == mp h'); mprop_preservation_of_hprop_preservation frame m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) in assert (frame_related_mems emp (pts_to r x) e m0 m1); (| r, m1 |) in lift_tot_action (refined_pre_action_as_action f) let select_refine #a #p e r x f = lift_tot_action (lift_heap_action e (H.select_refine #a #p r x f)) let upd_gen #a #p e r x y f = lift_tot_action (lift_heap_action e (H.upd_gen_action r x y f)) //////////////////////////////////////////////////////////////////////////////// // witness / recall //////////////////////////////////////////////////////////////////////////////// let witnessed_ref #a #pcm (r:ref a pcm) (fact:property a) (m:full_mem) = H.witnessed_ref #a #pcm r fact (heap_of_mem m) let witnessed_ref_stability #a #pcm (r:ref a pcm) (fact:property a) : Lemma (requires FStar.Preorder.stable fact (Steel.Preorder.preorder_of_pcm pcm)) (ensures FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) = H.witnessed_ref_stability #a #pcm r fact let witnessed (#a:Type u#1) (#pcm:pcm a) (r:ref a pcm) (fact:property a) = W.witnessed _ mem_evolves (witnessed_ref r fact) let rearrange_pqr_prq (p q r:slprop) : Lemma (((p `star` q) `star` r) `equiv` ((p `star` r) `star` q)) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_associative p q r } p `star` (q `star` r); (equiv) { star_commutative q r; star_congruence p (q `star` r) p (r `star` q) } p `star` (r `star` q); (equiv) { star_associative p r q } (p `star` r) `star` q; } let preserves_frame_cong (e:inames) (p q:slprop) (r s:slprop) (m0 m1:mem) : Lemma (requires p `equiv` r /\ q `equiv` s /\ preserves_frame e p q m0 m1) (ensures preserves_frame e r s m0 m1) = let aux0 (p q r s:slprop) : Lemma (requires p `equiv` s) (ensures (((p `star` q) `star` r) `equiv` ((s `star` q) `star` r))) = star_congruence p q s q; star_congruence (p `star` q) r (s `star` q) r in let aux (frame:slprop) : Lemma (requires interp ((r `star` frame) `star` locks_invariant e m0) m0) (ensures interp ((s `star` frame) `star` locks_invariant e m1) m1 /\ interp ((p `star` frame) `star` locks_invariant e m0) m0) [SMTPat (r `star` frame)] = aux0 p frame (locks_invariant e m0) r; aux0 q frame (locks_invariant e m1) s; assert (((p `star` frame) `star` locks_invariant e m0) `equiv` ((r `star` frame) `star` locks_invariant e m0)); assert (interp ((p `star` frame) `star` locks_invariant e m0) m0); assert (interp ((q `star` frame) `star` locks_invariant e m1) m1); assert (((q `star` frame) `star` locks_invariant e m1) `equiv` ((s `star` frame) `star` locks_invariant e m1)); () in () let pure_true_equiv (p:slprop) : Lemma ((p `star` pure True) `equiv` p) = FStar.Classical.forall_intro (pure_star_interp p True); emp_unit p; assert ((p `star` pure True) `equiv` p) let preserves_frame_star_pure (e:inames) (p q:slprop) (r s:prop) (m:mem) : Lemma (requires r /\ s) (ensures preserves_frame e p q m m <==> preserves_frame e (p `star` pure r) (q `star` pure s) m m) = pure_equiv r True; star_congruence p (pure r) p (pure True); pure_equiv s True; star_congruence q (pure s) q (pure True); pure_true_equiv p; pure_true_equiv q; let fwd () : Lemma (requires preserves_frame e p q m m) (ensures preserves_frame e (p `star` pure r) (q `star` pure s) m m) [SMTPat ()] = preserves_frame_cong e p q (p `star` pure r) (q `star` pure s) m m in let bk () : Lemma (requires preserves_frame e (p `star` pure r) (q `star` pure s) m m) (ensures preserves_frame e p q m m) [SMTPat ()] = preserves_frame_cong e (p `star` pure r) (q `star` pure s) p q m m in () let witness (#a:Type) (#pcm:pcm a) (e:inames) (r:erased (ref a pcm)) (fact:stable_property pcm) (v:Ghost.erased a) (_:squash (forall z. compatible pcm v z ==> fact z)) (frame:slprop) : MstTot (witnessed r fact) e (pts_to r v) (fun _ -> pts_to r v) frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in let _ : unit = let hr : H.ref a pcm = r in let v' = H.sel_v hr v (heap_of_mem m0) in assert (interp (H.ptr hr) m0 /\ H.sel #a #pcm hr (heap_of_mem m0) == v'); assert (compatible pcm v v'); assert (fact v'); assert (witnessed_ref r fact m0); witnessed_ref_stability r fact; assert (FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) in let w = NMSTTotal.witness _ mem_evolves (witnessed_ref r fact) in w let recall (#a:Type u#1) (#pcm:pcm a) (#fact:property a) (e:inames) (r:erased (ref a pcm)) (v:Ghost.erased a) (w:witnessed r fact) (frame:slprop) = let m0 = NMSTTotal.get () in NMSTTotal.recall _ mem_evolves (witnessed_ref r fact) w; let hr : H.ref a pcm = r in assert (witnessed_ref r fact m0); let v1 = H.sel_v hr v (heap_of_mem m0) in assert (compatible pcm v v1); assert (H.sel hr (heap_of_mem m0) == v1); assert (fact v1); assert (interp ((pts_to r v `star` frame) `star` locks_invariant e m0) m0); emp_unit ((pts_to r v `star` frame) `star` locks_invariant e m0); pure_star_interp ((pts_to r v `star` frame) `star` locks_invariant e m0) (fact v1) m0; assert (interp (((pts_to r v `star` frame) `star` locks_invariant e m0) `star` pure (fact v1)) m0); rearrange_pqr_prq (pts_to r v `star` frame) (locks_invariant e m0) (pure (fact v1)); assert (interp (((pts_to r v `star` frame) `star` pure (fact v1)) `star` locks_invariant e m0) m0); rearrange_pqr_prq (pts_to r v) frame (pure (fact v1)); star_congruence ((pts_to r v `star` frame) `star` pure (fact v1)) (locks_invariant e m0) ((pts_to r v `star` pure (fact v1)) `star` frame) (locks_invariant e m0); Ghost.hide v1 let iname_for_p_mem (i:iname) (p:slprop) : W.s_predicate mem = fun m -> iname_for_p i p m.locks let iname_for_p_stable (i:iname) (p:slprop) : Lemma (W.stable full_mem mem_evolves (iname_for_p_mem i p)) = () let ( >--> ) (i:iname) (p:slprop) : Type0 = W.witnessed full_mem mem_evolves (iname_for_p_mem i p) let hmem_with_inv_equiv e (m:mem) (p:slprop) : Lemma (interp (p `star` linv e m) m <==> interp (p `star` lock_store_invariant e m.locks) m /\ heap_ctr_valid m.ctr (heap_of_mem m)) = calc (<==>) { interp (p `star` linv e m) m; (<==>) { H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) } interp ((p `star` lock_store_invariant e m.locks) `star` ctr_validity m.ctr (heap_of_mem m)) m; (<==>) { H.pure_star_interp (p `star` lock_store_invariant e m.locks) (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_of_mem m) } interp ((p `star` lock_store_invariant e m.locks) `star` emp) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); (<==>) { H.emp_unit (p `star` lock_store_invariant e m.locks) } interp (p `star` lock_store_invariant e m.locks) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); } let new_invariant_tot_action (e:inames) (p:slprop) (m0:hmem_with_inv_except e p{ e `inames_in` m0.locks }) : Pure (iname & hmem_with_inv_except e emp) (requires True) (ensures fun (i, m1) -> iname_for_p_mem i p m1 /\ frame_related_mems p emp e m0 m1 /\ mem_evolves m0 m1) = let (| i, l1 |) = extend_lock_store e m0.locks p in let m1 = { m0 with locks = l1 } in assert (lock_store_invariant e m1.locks == p `star` lock_store_invariant e m0.locks); calc (equiv) { linv e m1; (equiv) {} (lock_store_invariant e m1.locks `star` ctr_validity m1.ctr (heap_of_mem m1)); (equiv) {} ((p `star` lock_store_invariant e m0.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); (equiv) { H.star_associative p (lock_store_invariant e m0.locks) (ctr_validity m1.ctr (heap_of_mem m1)) } (p `star` (lock_store_invariant e m0.locks `star` ctr_validity m1.ctr (heap_of_mem m1))); (equiv) { } (p `star` linv e m0); }; assert (iname_for_p_mem i p m1); assert (lock_store_evolves m0.locks l1); assert (mem_evolves m0 m1); hmem_with_inv_equiv e m0 p; assert (interp (p `star` lock_store_invariant e m0.locks) m1); assert (interp (lock_store_invariant e m1.locks) m1); H.emp_unit (lock_store_invariant e m1.locks); H.star_commutative (lock_store_invariant e m1.locks) emp; assert (interp (emp `star` lock_store_invariant e m1.locks) m1); hmem_with_inv_equiv e m1 emp; let m1 : hmem_with_inv_except e emp = m1 in let aux (frame:slprop) : Lemma (requires interp ((p `star` frame) `star` linv e m0) m0) (ensures interp ((emp `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) <==> mp (core_mem m1))) [SMTPat (p `star` frame)] = assert (interp ((p `star` frame) `star` linv e m0) m1); calc (equiv) { ((p `star` frame) `star` linv e m0); (equiv) { H.star_commutative p frame; H.star_congruence (p `star` frame) (linv e m0) (frame `star` p) (linv e m0); H.star_associative frame p (linv e m0) } (frame `star` (p `star` linv e m0)); (equiv) { H.star_congruence frame (p `star` linv e m0) frame (linv e m1) } (frame `star` linv e m1); (equiv) { H.emp_unit (frame `star` linv e m1); H.star_commutative (frame `star` linv e m1) emp; H.star_associative emp frame (linv e m1) } ((emp `star` frame) `star` linv e m1); }; assert (interp ((emp `star` frame) `star` linv e m1) m1) in assert (frame_related_mems p emp e m0 m1); ( i, m1 ) let name_is_ok (i:iname) (m0:full_mem u#1) : prop = i < List.Tot.length m0.locks let witnessed_name_is_ok (i:iname) = W.witnessed full_mem mem_evolves (name_is_ok i) let pre_inv = i:erased iname & witnessed_name_is_ok i let inv (p:slprop u#1) = i:erased iname & witnessed_name_is_ok i & (i >--> p) let pre_inv_of_inv #p (i:inv p) = let (|i, w, _|) = i in (|i,w|) let name_of_pre_inv (i:pre_inv) = dfst i let rec recall_all (ctx:list pre_inv) : NMSTTotal.NMSTATETOT unit (full_mem u#1) mem_evolves (requires fun _ -> True) (ensures fun m0 _ m1 -> m0==m1 /\ (forall i. i `List.Tot.memP` ctx ==> name_is_ok (name_of_pre_inv i) m0)) = match ctx with | [] -> () | hd::tl -> let (| q, i |) = hd in let i : W.witnessed full_mem mem_evolves (name_is_ok q) = i in NMSTTotal.recall _ mem_evolves (name_is_ok q) i; recall_all tl let fresh_invariant (e:inames) (p:slprop) (ctx:list pre_inv) (frame:slprop) : MstTot (i:inv p { not (mem_inv e i) /\ fresh_wrt ctx (name_of_inv i)}) e p (fun _ -> emp) frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in recall_all ctx; ac_reasoning_for_m_frame_preserving p frame (locks_invariant e m0) m0; assert (interp (p `star` locks_invariant e m0) m0); let r = new_invariant_tot_action e p m0 in let ( i, m1 ) = r in assert (i == List.Tot.length m0.locks); assert (not (Set.mem i e)); assert (mem_evolves m0 m1); NMSTTotal.put #full_mem #mem_evolves m1; iname_for_p_stable i p; let w = NMSTTotal.witness full_mem mem_evolves (iname_for_p_mem i p) in let w0 = NMSTTotal.witness full_mem mem_evolves (name_is_ok i) in (| hide i, w0, w |) let new_invariant (e:inames) (p:slprop) (frame:slprop) : MstTot (inv p) e p (fun _ -> emp) frame (fun _ -> True) (fun _ _ _ -> True) = fresh_invariant e p [] frame let rearrange_invariant (p q r : slprop) (q0 q1:slprop) : Lemma (requires q `equiv` (q0 `star` q1)) (ensures (p `star` (q `star` r)) `equiv` ((q0 `star` p) `star` (q1 `star` r))) = calc (equiv) { p `star` (q `star` r); (equiv) { calc (equiv) { (q `star` r); (equiv) { star_congruence q r (q0 `star` q1) r } (q0 `star` q1) `star` r; }; star_congruence p (q `star` r) p ((q0 `star` q1) `star` r) } (p `star` ((q0 `star` q1) `star` r)); (equiv) { star_associative q0 q1 r; star_congruence p ((q0 `star` q1) `star` r) p (q0 `star` (q1 `star` r)); star_associative p q0 (q1 `star` r) } (p `star` q0) `star` (q1 `star` r); (equiv) { star_commutative p q0; star_congruence (p `star` q0) (q1 `star` r) (q0 `star` p) (q1 `star` r) } (q0 `star` p) `star` (q1 `star` r); }

{ "checked_file": "/", "dependencies": [ "Steel.Preorder.fst.checked", "Steel.Heap.fsti.checked", "prims.fst.checked", "FStar.Witnessed.Core.fsti.checked", "FStar.Set.fsti.checked", "FStar.Preorder.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.PCM.fst.checked", "FStar.NMSTTotal.fst.checked", "FStar.List.Tot.fst.checked", "FStar.IndefiniteDescription.fsti.checked", "FStar.Ghost.fsti.checked", "FStar.FunctionalExtensionality.fsti.checked", "FStar.Classical.Sugar.fsti.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Steel.Memory.fst" }

[ { "abbrev": true, "full_module": "Steel.Preorder", "short_module": "PP" }, { "abbrev": true, "full_module": "FStar.Witnessed.Core", "short_module": "W" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": true, "full_module": "Steel.Heap", "short_module": "H" }, { "abbrev": false, "full_module": "FStar.PCM", "short_module": null }, { "abbrev": false, "full_module": "FStar.FunctionalExtensionality", "short_module": null }, { "abbrev": true, "full_module": "FStar.FunctionalExtensionality", "short_module": "F" }, { "abbrev": false, "full_module": "FStar.PCM", "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

fp: Steel.Memory.slprop -> fp': Steel.Memory.slprop -> opened_invariants: Steel.Memory.inames -> p: Steel.Memory.slprop -> i: Steel.Memory.inv p {Prims.op_Negation (FStar.Ghost.reveal (Steel.Memory.mem_inv opened_invariants i))} -> m0: Steel.Memory.hmem_with_inv_except (Steel.Memory.add_inv opened_invariants i) (Steel.Memory.star p fp) -> m1: Steel.Memory.mem -> FStar.Pervasives.Lemma (requires Steel.Memory.preserves_frame (FStar.Ghost.hide (Steel.Memory.set_add (Steel.Memory.name_of_inv i) opened_invariants)) (Steel.Memory.star p fp) (Steel.Memory.star p fp') m0 m1 /\ Steel.Memory.interp (Steel.Memory.star fp' (Steel.Memory.linv opened_invariants m1)) m1 /\ Steel.Memory.inames_ok opened_invariants m1 /\ Steel.Memory.equiv (Steel.Memory.lock_store_invariant opened_invariants (Mkmem?.locks m0)) (Steel.Memory.star p (Steel.Memory.lock_store_invariant (FStar.Ghost.hide (Steel.Memory.set_add (Steel.Memory.name_of_inv i) opened_invariants)) (Mkmem?.locks m0))) /\ Steel.Memory.equiv (Steel.Memory.lock_store_invariant opened_invariants (Mkmem?.locks m1)) (Steel.Memory.star p (Steel.Memory.lock_store_invariant (FStar.Ghost.hide (Steel.Memory.set_add (Steel.Memory.name_of_inv i) opened_invariants)) (Mkmem?.locks m1)))) (ensures Steel.Memory.preserves_frame opened_invariants fp fp' m0 m1)

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Steel.Memory.slprop", "Steel.Memory.inames", "Steel.Memory.inv", "Prims.b2t", "Prims.op_Negation", "FStar.Ghost.reveal", "Prims.bool", "Steel.Memory.mem_inv", "Steel.Memory.hmem_with_inv_except", "Steel.Memory.add_inv", "Steel.Memory.star", "Steel.Memory.mem", "Prims.unit", "Steel.Memory.interp", "Steel.Memory.linv", "Prims.squash", "Prims.l_and", "Prims.l_Forall", "Steel.Memory.mprop", "Prims.eq2", "Prims.prop", "Steel.Memory.core_mem", "Prims.Cons", "FStar.Pervasives.pattern", "FStar.Pervasives.smt_pat", "Prims.Nil", "Prims._assert", "Steel.Memory.rearrange_invariant", "Steel.Memory.lock_store_invariant", "Steel.Memory.__proj__Mkmem__item__locks", "Steel.Memory.ctr_validity", "Steel.Memory.__proj__Mkmem__item__ctr", "Steel.Memory.heap_of_mem", "FStar.Ghost.hide", "FStar.Set.set", "Steel.Memory.iname", "Steel.Memory.set_add", "Steel.Memory.name_of_inv", "Steel.Memory.star_congruence", "Steel.Memory.star_associative", "Steel.Memory.preserves_frame", "Steel.Memory.inames_ok", "Steel.Memory.equiv" ]

[]

false

true

false

let preserves_frame_invariant (fp fp': slprop) (opened_invariants: inames) (p: slprop) (i: inv p {not (mem_inv opened_invariants i)}) (m0: hmem_with_inv_except (add_inv opened_invariants i) (p `star` fp)) (m1: mem) : Lemma (requires preserves_frame (set_add (name_of_inv i) opened_invariants) (p `star` fp) (p `star` fp') m0 m1 /\ interp (fp' `star` (linv opened_invariants m1)) m1 /\ inames_ok opened_invariants m1 /\ ((lock_store_invariant opened_invariants m0.locks) `equiv` (p `star` (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks))) /\ ((lock_store_invariant opened_invariants m1.locks) `equiv` (p `star` (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks)))) (ensures preserves_frame opened_invariants fp fp' m0 m1) =

let aux (frame: slprop) : Lemma (requires interp ((fp `star` frame) `star` (linv opened_invariants m0)) m0) (ensures interp ((fp' `star` frame) `star` (linv opened_invariants m1)) m1 /\ (forall (f_frame: mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) [SMTPat ()] = rearrange_invariant (fp `star` frame) (lock_store_invariant opened_invariants m0.locks) (ctr_validity m0.ctr (heap_of_mem m0)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks); assert (interp ((p `star` (fp `star` frame)) `star` (linv (set_add (name_of_inv i) opened_invariants) m0)) m0); star_associative p fp frame; star_congruence (p `star` (fp `star` frame)) (linv (set_add (name_of_inv i) opened_invariants) m0) ((p `star` fp) `star` frame) (linv (set_add (name_of_inv i) opened_invariants) m0); assert (interp (((p `star` fp) `star` frame) `star` (linv (set_add (name_of_inv i) opened_invariants) m0)) m0); assert (interp (((p `star` fp') `star` frame) `star` (linv (set_add (name_of_inv i) opened_invariants) m1)) m1); star_associative p fp' frame; star_congruence ((p `star` fp') `star` frame) (linv (set_add (name_of_inv i) opened_invariants) m1) (p `star` (fp' `star` frame)) (linv (set_add (name_of_inv i) opened_invariants) m1); assert (interp ((p `star` (fp' `star` frame)) `star` (linv (set_add (name_of_inv i) opened_invariants) m1)) m1); rearrange_invariant (fp' `star` frame) (lock_store_invariant opened_invariants m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks); assert (interp ((fp' `star` frame) `star` (linv opened_invariants m1)) m1); () in ()

false

Platform.Bytes.fst

Platform.Bytes.seq_of_bytes

val seq_of_bytes: b:bytes -> GTot (Seq.seq byte)

let seq_of_bytes b = b

{ "file_name": "ucontrib/Platform/fst/Platform.Bytes.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }

{ "end_col": 22, "end_line": 62, "start_col": 0, "start_line": 62 }

(* Copyright 2008-2018 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 Platform.Bytes assume val repr_bytes : nat -> GTot (n:nat{n>0}) (* Integer literals are currently extracted to int32, rather than bigint, so the definition below breaks extraction: Unexpected error; please file a bug report, ideally with a minimized version of the source program that triggered the error. int_of_string Also, defining repr_bytes n <= 8 for all n is dubious *) (* let repr_bytes n = if n < 256 then 1 else if n < 65536 then 2 else if n < 16777216 then 3 else if n < 4294967296 then 4 else if n < 1099511627776 then 5 else if n < 281474976710656 then 6 else if n < 72057594037927936 then 7 else 8 *) (* NS: The two assumes below were previously defined as axioms. They are evil! They pollute the global environment and slow down verification enormously. I've made them assumed lemmas; if you want to make use of these axioms, call the lemmas as needed in the context. *) assume val lemma_repr_bytes_values: n:nat -> Lemma ( ( n < 256 <==> repr_bytes n = 1 ) /\ ( (n >= 256 /\ n < 65536) <==> repr_bytes n = 2 ) /\ ( (n >= 65536 /\ n < 16777216) <==> repr_bytes n = 3 ) /\ ( (n >= 16777216 /\ n < 4294967296) <==> repr_bytes n = 4 ) /\ ( (n >= 4294967296 /\ n < 1099511627776) <==> repr_bytes n = 5 ) /\ ( (n >= 1099511627776 /\ n < 281474976710656) <==> repr_bytes n = 6 ) /\ ( (n >= 281474976710656 /\ n < 72057594037927936) <==> repr_bytes n = 7 ) /\ ( (n >= 72057594037927936 /\ n < 18446744073709551616) <==> repr_bytes n = 8 ) ) unfold let byte:Type0 = FStar.UInt8.t type cbytes = string (* abstract *) type bytes = Seq.seq byte (* AR: adding this *) assume HasEq_bytes: hasEq bytes

{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.UInt8.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked" ], "interface_file": false, "source_file": "Platform.Bytes.fst" }

[ { "abbrev": false, "full_module": "Platform", "short_module": null }, { "abbrev": false, "full_module": "Platform", "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

b: Platform.Bytes.bytes -> Prims.GTot (FStar.Seq.Base.seq Platform.Bytes.byte)

Prims.GTot

[ "sometrivial" ]

[]

[ "Platform.Bytes.bytes", "FStar.Seq.Base.seq", "Platform.Bytes.byte" ]

[]

false

let seq_of_bytes b =

b

false

Steel.Memory.fst

Steel.Memory.equiv_pqrs_p_qr_s

val equiv_pqrs_p_qr_s (p q r s: slprop) : Lemma ((((p `star` q) `star` r) `star` s) `equiv` ((p `star` (q `star` r)) `star` s))

let equiv_pqrs_p_qr_s (p q r s:slprop) : Lemma ((p `star` q `star` r `star` s) `equiv` (p `star` (q `star` r) `star` s)) = star_associative p q r; equiv_extensional_on_star (p `star` q `star` r) (p `star` (q `star` r)) s

{ "file_name": "lib/steel/Steel.Memory.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 7, "end_line": 1498, "start_col": 0, "start_line": 1491 }

(* 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.Memory module F = FStar.FunctionalExtensionality open FStar.FunctionalExtensionality open FStar.PCM module H = Steel.Heap noeq type lock_state : Type u#(a + 1) = | Invariant : inv:H.slprop u#a -> lock_state let lock_store : Type u#(a+1) = list (lock_state u#a) noeq type mem : Type u#(a + 1) = { ctr: nat; heap: H.heap u#a; locks: lock_store u#a; } let heap_of_mem (x:mem) : H.heap = x.heap let mem_of_heap (h:H.heap) : mem = { ctr = 0; heap = h; locks = [] } let mem_set_heap (m:mem) (h:H.heap) : mem = { ctr = m.ctr; heap = h; locks = m.locks; } let core_mem (m:mem) : mem = mem_of_heap (heap_of_mem m) let core_mem_invol m = () let disjoint (m0 m1:mem u#h) : prop = m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks let disjoint_sym m0 m1 = () let join m0 m1 = { ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = m0.locks } let join_commutative m0 m1 = H.join_commutative m0.heap m1.heap let disjoint_join m0 m1 m2 = H.disjoint_join m0.heap m1.heap m2.heap let join_associative m0 m1 m2 = H.join_associative m0.heap m1.heap m2.heap let slprop = H.slprop let interp p m = H.interp p m.heap let equiv p1 p2 = forall m. interp p1 m <==> interp p2 m let slprop_extensionality p q = assert (forall m. interp p m <==> interp q m); let aux (h:H.heap) : Lemma (H.interp p h <==> H.interp q h) [SMTPat (H.interp p h)] = let m : mem = { ctr = 0; heap = h; locks = [] } in assert (interp p m <==> interp q m) in assert (forall h. H.interp p h <==> H.interp q h); Steel.Heap.slprop_extensionality p q let reveal_equiv p1 p2 = () let core_ref = H.core_ref let core_ref_null = H.core_ref_null let core_ref_is_null r = H.core_ref_is_null r let emp : slprop u#a = H.emp let pure = H.pure let pts_to = H.pts_to let h_and = H.h_and let h_or = H.h_or let star = H.star let wand = H.wand let h_exists = H.h_exists let h_forall = H.h_forall //////////////////////////////////////////////////////////////////////////////// //properties of equiv //////////////////////////////////////////////////////////////////////////////// let equiv_symmetric (p1 p2:slprop u#a) = H.equiv_symmetric p1 p2 #push-options "--warn_error -271" let equiv_heap_iff_equiv (p1 p2:slprop u#a) : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat (equiv p1 p2)] = let aux_lr () : Lemma (requires H.equiv p1 p2) (ensures equiv p1 p2) [SMTPat ()] = () in let aux_rl_helper1 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p1 h) (ensures H.interp p2 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl_helper2 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p2 h) (ensures H.interp p1 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl () : Lemma (requires equiv p1 p2) (ensures H.equiv p1 p2) [SMTPat ()] = () in () let equiv_heap_iff_equiv_forall () : Lemma (ensures (forall p1 p2. H.equiv p1 p2 <==> equiv p1 p2)) = let aux p1 p2 : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat ()] = equiv_heap_iff_equiv p1 p2 in () #pop-options let equiv_extensional_on_star (p1 p2 p3:slprop u#a) = equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3 let emp_unit p = H.emp_unit p let intro_emp m = H.intro_emp (heap_of_mem m) let pure_equiv p q = H.pure_equiv p q let pure_interp q m = H.pure_interp q (heap_of_mem m) let pure_star_interp p q m = H.pure_star_interp p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// //pts_to //////////////////////////////////////////////////////////////////////////////// let pts_to_compatible #a #pcm x v0 v1 m = H.pts_to_compatible #a #pcm x v0 v1 (heap_of_mem m) let pts_to_compatible_equiv #a #pcm x v0 v1 = H.pts_to_compatible_equiv #a #pcm x v0 v1 let pts_to_not_null #a #pcm x v m = H.pts_to_not_null #a #pcm x v (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // star //////////////////////////////////////////////////////////////////////////////// let intro_star p q mp mq = H.intro_star p q (heap_of_mem mp) (heap_of_mem mq) let elim_star p q m = let h = heap_of_mem m in H.elim_star p q h; assert (exists hl hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr); let hl = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hl -> exists hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let hr = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hr -> H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let ml = mem_set_heap m hl in let mr = mem_set_heap m hr in assert (disjoint ml mr); assert (m == join ml mr); assert (interp p ml); assert (interp q mr); () let interp_star (p q: slprop) (m: mem) : Lemma (interp (p `star` q) m <==> (exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m)) = let left = interp (p `star` q) m in let right = exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m in let f () : Lemma (requires left) (ensures right) = elim_star p q m in let g () : Lemma (requires right) (ensures left) = Classical.exists_elim left #_ #(fun mp -> exists (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mp -> Classical.exists_elim left #_ #(fun mq -> disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mq -> intro_star p q mp mq ) ) in Classical.move_requires f (); Classical.move_requires g () let star_commutative (p1 p2:slprop) = H.star_commutative p1 p2 let star_associative (p1 p2 p3:slprop) = H.star_associative p1 p2 p3 let star_congruence (p1 p2 p3 p4:slprop) = equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4 let affine_star (p q:slprop) (m:mem) = H.affine_star p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // Invariants on the lock store //////////////////////////////////////////////////////////////////////////////// let iname = nat module S = FStar.Set module L = FStar.List.Tot module W = FStar.Witnessed.Core let rec lock_store_invariant (e:inames) (l:lock_store u#a) : slprop u#a = let current_addr = L.length l - 1 in match l with | [] -> emp | Invariant p :: tl -> if current_addr `S.mem` e then lock_store_invariant e tl else p `star` lock_store_invariant e tl let lock_i (i:iname) (l:lock_store { i < L.length l }) = let ix = L.length l - i - 1 in L.index l ix let iname_for_p (i:iname) (p:slprop) : W.s_predicate lock_store = fun l -> i < L.length l /\ (lock_i i l).inv == p let lock_store_evolves : FStar.Preorder.preorder lock_store = fun (l1 l2 : lock_store) -> L.length l2 >= L.length l1 /\ (forall (i:nat{i < L.length l1}). (lock_i i l1).inv == (lock_i i l2).inv) let inames_in (e:inames) (l:lock_store) : prop = forall i. Set.mem i e ==> i < L.length l let inames_ok e m = inames_in e m.locks let inames_ok_empty m = () let extend_lock_store (e:inames) (l:lock_store{e `inames_in` l}) (p:slprop) : i:iname & l':lock_store { lock_store_invariant e l' == p `star` lock_store_invariant e l /\ iname_for_p i p l' } = (| L.length l, Invariant p :: l |) let set_add (i:iname) (s:inames) = Set.union (Set.singleton i) s let rec move_invariant (e:inames) (l:lock_store) (p:slprop) (i:iname{iname_for_p i p l /\ ~(i `Set.mem` e)}) : Lemma (H.equiv (lock_store_invariant e l) (p `star` lock_store_invariant (set_add i e) l)) = let rec aux (i:iname) (m:lock_store) : Lemma (requires i >= L.length m) (ensures (lock_store_invariant e m `H.equiv` lock_store_invariant (set_add i e) m)) = match m with | [] -> () | Invariant p::tl -> aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl) in let current_addr = L.length l - 1 in match l with | [] -> () | Invariant q::tl -> if i = current_addr then begin assert (lock_store_invariant e l == p `star` lock_store_invariant e tl); aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl); () end else begin move_invariant e tl p i; assert (lock_store_invariant e tl `equiv` (p `star` lock_store_invariant (set_add i e) tl)); H.star_congruence q (lock_store_invariant e tl) q (p `star` lock_store_invariant (set_add i e) tl); if Set.mem current_addr e then () else begin let r = lock_store_invariant (set_add i e) tl in assert (lock_store_invariant e l `equiv` (q `star` (p `star` r))); H.star_associative q p r; H.star_commutative q p; H.star_congruence (q `star` p) r (p `star` q) r; H.star_associative p q r end end let heap_ctr_valid (ctr:nat) (h:H.heap u#a) : prop = h `H.free_above_addr` ctr let ctr_validity (ctr:nat) (h:H.heap) : slprop = H.pure (heap_ctr_valid ctr h) let locks_invariant (e:inames) (m:mem u#a) : slprop u#a = lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m) let full_mem_pred (m:mem) = H.full_heap_pred (heap_of_mem m) (***** Following lemmas are needed in Steel.Effect *****) let core_mem_interp (hp:slprop u#a) (m:mem u#a) = () let interp_depends_only_on (hp:slprop u#a) = H.interp_depends_only_on hp let a_mem_prop_as_a_heap_prop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (H.a_heap_prop u#a) = let g (h: H.heap u#a) : Tot prop = interp sl (mem_of_heap h) /\ f (mem_of_heap h) in let phi0 (h0 h1: H.heap u#a) : Lemma (requires (g h0 /\ H.disjoint h0 h1)) (ensures (g h0 /\ H.disjoint h0 h1 /\ g (H.join h0 h1))) = assert (mem_of_heap (H.join h0 h1) == mem_of_heap h0 `join` mem_of_heap h1); interp_depends_only_on sl in let phi1 (h0 h1: H.heap u#a) : Lemma (ensures ((g h0 /\ H.disjoint h0 h1) ==> g (H.join h0 h1))) = Classical.move_requires (phi0 h0) h1 in Classical.forall_intro_2 phi1; g let refine_slprop sl f = H.as_slprop (a_mem_prop_as_a_heap_prop sl f) let interp_refine_slprop sl f m = assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_mem m)) let dep_hprop (s: slprop) (f: (hmem s -> Tot slprop)) (h: H.heap) : Tot prop = exists (h1: H.heap) . exists (h2: H.heap) . interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 let dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq' : squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h')) = let p2 (h h1 h2: H.heap) : Tot prop = interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 in let p1 (h h1: H.heap) : Tot prop = (exists h2 . p2 h h1 h2) in let h1 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p1 h) in let h2 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p2 h h1) in H.disjoint_join h' h1 h2; assert (H.disjoint h2 h'); let h2' = H.join h2 h' in H.join_commutative h2 h' ; assert (h2' == H.join h' h2); assert (H.disjoint h1 h2'); assert (mem_of_heap h2' == mem_of_heap h2 `join` mem_of_heap h'); interp_depends_only_on (f (mem_of_heap h1)); assert (interp (f (mem_of_heap h1)) (mem_of_heap h2')); H.join_commutative h1 h2; H.join_associative h' h2 h1; H.join_commutative h' h; H.join_commutative h2' h1; assert (H.join h h' == h1 `H.join` h2') let impl_intro_gen (#p: Type0) (#q: Type0) ($prf: (squash p -> Lemma (q ))) : Lemma (p ==> q) = Classical.impl_intro_gen #p #(fun _ -> q) prf let dep_hprop_is_affine1 (s: slprop) (f: (hmem s -> Tot slprop)) (h0 h1: H.heap) : Lemma ((dep_hprop s f h0 /\ H.disjoint h0 h1) ==> (H.disjoint h0 h1 /\ dep_hprop s f (H.join h0 h1))) = impl_intro_gen (dep_hprop_is_affine0 s f h0 h1) let dep_hprop_is_affine (s: slprop) (f: (hmem s -> Tot slprop)) : Lemma (H.heap_prop_is_affine (dep_hprop s f)) = Classical.forall_intro_2 (dep_hprop_is_affine1 s f) let sdep (s: slprop) (f: (hmem s -> Tot slprop)) : Tot slprop = dep_hprop_is_affine s f; H.as_slprop (dep_hprop s f) let interp_sdep (s: slprop) (f: (hmem s -> Tot slprop)) (m: mem) : Lemma (requires (dep_slprop_is_affine s f)) (ensures ( interp (sdep s f) m <==> (exists m1 m2 . interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) )) = dep_hprop_is_affine s f; assert (forall m1 m2 . (interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) ==> ( interp s (mem_of_heap m1.heap) /\ interp (f (mem_of_heap m1.heap)) (mem_of_heap m2.heap) /\ H.disjoint m1.heap m2.heap /\ H.join m1.heap m2.heap == m.heap )); interp_depends_only_on s; Classical.forall_intro (fun m -> interp_depends_only_on (f m)); assert (forall h1 h2 . (interp s (mem_of_heap h1) /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ H.disjoint h1 h2 /\ H.join h1 h2 == m.heap) ==> ( core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ interp s (core_mem (mem_of_heap h1)) /\ interp s (mem_set_heap m h1) /\ core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ f (mem_set_heap m h1) `equiv` f (mem_of_heap h1) /\ interp (f (mem_set_heap m h1)) (mem_of_heap h2) /\ interp (f (mem_set_heap m h1)) (mem_set_heap m h2) /\ disjoint (mem_set_heap m h1) (mem_set_heap m h2) /\ join (mem_set_heap m h1) (mem_set_heap m h2) == m )); () let h_exists_cong (#a:Type) (p q : a -> slprop) : Lemma (requires (forall x. p x `equiv` q x)) (ensures (h_exists p `equiv` h_exists q)) = equiv_heap_iff_equiv_forall (); H.h_exists_cong p q let intro_h_exists #a x p m = H.intro_h_exists x p (heap_of_mem m) let elim_h_exists (#a:_) (p:a -> slprop) (m:mem) = H.elim_h_exists p (heap_of_mem m) let intro_h_forall (#a:_) (p:a -> slprop) (m:mem) = H.intro_h_forall p (heap_of_mem m) let elim_h_forall (#a:_) (p:a -> slprop) (m:mem) (x:a) = H.elim_h_forall p (heap_of_mem m) x let intro_h_and (p q: slprop) (m:mem) = H.intro_h_and p q (heap_of_mem m) let elim_h_and (p q: slprop) (m:mem) = H.elim_h_and p q (heap_of_mem m) let intro_h_or_left (p q: slprop) (m:mem) = H.intro_h_or_left p q (heap_of_mem m) let intro_h_or_right (p q: slprop) (m:mem) = H.intro_h_or_right p q (heap_of_mem m) let elim_h_or (p q: slprop) (m:mem) = H.elim_h_or p q (heap_of_mem m) let intro_wand (p1 p2: slprop u#a) (m:mem) = introduce (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)) ==> interp (wand p1 p2) m with _. ( assert (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)); H.intro_wand p1 p2 (heap_of_mem m); let h = heap_of_mem m in assert ((forall h1. h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) ==> H.interp (wand p1 p2) h); introduce forall h1. (h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) with ( introduce (h `H.disjoint` h1 /\ H.interp p1 h1) ==> H.interp p2 (H.join h h1) with _. ( assert (h `H.disjoint` h1); let m1 = { ctr = m.ctr; heap = h1; locks = m.locks } in assert (m `disjoint` m1) ) ) ) (** Eliminating a wand by proving a heap that satisfies the LHS **) let elim_wand (p1 p2: slprop u#a) (m:mem) (m1:mem) = H.elim_wand p1 p2 (heap_of_mem m) (heap_of_mem m1) //////////////////////////////////////////////////////////////////////////////// // Preorders and effects //////////////////////////////////////////////////////////////////////////////// module PP = Steel.Preorder let mem_evolves = fun (m0 m1:full_mem) -> H.heap_evolves (heap_of_mem m0) (heap_of_mem m1) /\ m0.ctr <= m1.ctr /\ lock_store_evolves m0.locks m1.locks (** See [Steel.Heap.is_frame_preserving]. We add in [lock_invariants] now *) let preserves_frame (e:inames) (pre post:slprop) (m0 m1:mem) = forall (frame:slprop). interp ((pre `star` frame) `star` locks_invariant e m0) m0 ==> (interp ((post `star` frame) `star` locks_invariant e m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) (** This is a version of MstTot with frame quantified, as part of preserves_frame *) effect MstTotNF (a:Type u#a) (except:inames) (expects:slprop u#1) (provides: a -> slprop u#1) = NMSTTotal.NMSTATETOT a (full_mem u#1) mem_evolves (requires fun m0 -> inames_ok except m0 /\ interp (expects `star` locks_invariant except m0) m0) (ensures fun m0 x m1 -> inames_ok except m1 /\ interp (provides x `star` locks_invariant except m1) m1 /\ preserves_frame except expects (provides x) m0 m1) //////////////////////////////////////////////////////////////////////////////// // Lifting heap actions //////////////////////////////////////////////////////////////////////////////// (** Heap actions come in two equivalent flavors: - one that take an explicit frame as argument (action_with_frame) - and one that quantify over all the frame We therefore define two lift routes: - a direct route for those with explicit frame - via MstTotNF for the rest *) let tot_pre_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = hmem_with_inv_except e fp -> (x:a & hmem_with_inv_except e (fp' x)) let tot_pre_action_nf = tot_pre_action_nf_except S.empty let ac_reasoning_for_m_frame_preserving (p q r:slprop u#a) (m:mem u#a) : Lemma (requires interp ((p `star` q) `star` r) m) (ensures interp (p `star` r) m) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_commutative p q; equiv_extensional_on_star (p `star` q) (q `star` p) r } (q `star` p) `star` r; (equiv) { star_associative q p r } q `star` (p `star` r); }; assert (interp (q `star` (p `star` r)) m); affine_star q (p `star` r) m let is_frame_preserving (#e:inames) (#a:Type u#b) (#fp:slprop u#a) (#fp':a -> slprop u#a) (f:tot_pre_action_nf_except e fp a fp') = forall (frame:slprop u#a) (m0:hmem_with_inv_except e (fp `star` frame)). (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = f:tot_pre_action_nf_except e fp a fp'{ is_frame_preserving f } let tot_action_nf = tot_action_nf_except S.empty let linv e (m:mem) = locks_invariant e m let hheap_of_hmem #fp #e (m:hmem_with_inv_except e fp) : h:H.hheap (fp `star` linv e m) { h `H.free_above_addr` m.ctr} = let h = heap_of_mem m in H.pure_interp (heap_ctr_valid m.ctr (heap_of_mem m)) h; h let hmem_of_hheap #e (#fp0 #fp1:slprop) (m:hmem_with_inv_except e fp0) (h:H.full_hheap (fp1 `star` linv e m) { h `Heap.free_above_addr` m.ctr }) : m1:hmem_with_inv_except e fp1{linv e m `equiv` linv e m1} = let m1 : mem = { m with heap = h } in assert (interp (fp1 `star` linv e m) m1); star_commutative fp1 (linv e m); assert (interp (linv e m `star` fp1) m1); assert (linv e m1 == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); assert (linv e m == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m)); H.pure_interp (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_of_mem m); assert (heap_ctr_valid m1.ctr (heap_of_mem m) <==> heap_ctr_valid m1.ctr (heap_of_mem m1)); H.pure_equiv (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_ctr_valid m1.ctr (heap_of_mem m1)); H.star_congruence (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m)); assert (linv e m `equiv` linv e m1); let _ = equiv_extensional_on_star (linv e m) (linv e m1) fp1 in assert ((linv e m `star` fp1) `equiv` (linv e m1 `star` fp1)); assert (interp (linv e m1 `star` fp1) m1); star_commutative (linv e m1) fp1; assert (interp (fp1 `star` linv e m1) m1); m1 let with_inv_except (m:mem) e (fp:slprop) = interp (fp `star` locks_invariant e m) m #push-options "--warn_error -271" let as_hprop (frame:slprop) (mp:mprop frame) : hp:H.hprop frame{forall m. mp (core_mem m) == hp (heap_of_mem m)} = let f = fun h -> mp (mem_of_heap h) in assert (forall m. mp (core_mem m) == f (heap_of_mem m)); let aux (m0:H.hheap frame) (m1:H.heap{H.disjoint m0 m1}) : Lemma (ensures (mem_of_heap (H.join m0 m1) == join (mem_of_heap m0) (mem_of_heap m1))) [SMTPat ()] = () in f let mprop_preservation_of_hprop_preservation (p:slprop) (m0 m1:mem) : Lemma (requires (forall (hp:H.hprop p). hp (heap_of_mem m0) == hp (heap_of_mem m1))) (ensures (forall (mp:mprop p). mp (core_mem m0) == mp (core_mem m1))) = let aux (mp:mprop p) : Lemma (mp (core_mem m0) == mp (core_mem m1)) [SMTPat()] = assert (as_hprop p mp (heap_of_mem m0) == as_hprop p mp (heap_of_mem m1)) in () let lift_heap_action (#fp:slprop) (#a:Type) (#fp':a -> slprop) (e:inames) ($f:H.action fp a fp') : tot_action_nf_except e fp a fp' = let g : tot_pre_action_nf_except e fp a fp' = fun m -> let h0 = hheap_of_hmem m in let (| x, h' |) = f h0 in (| x, hmem_of_hheap m h' |) in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in let h0 = hheap_of_hmem m0 in let (| x', h1 |) = f h0 in H.action_framing f (linv e m0) h0; assert (x == x'); star_associative fp frame (linv e m0); H.action_framing f (frame `star` linv e m0) h0; assert (H.interp ((fp' x) `star` (frame `star` linv e m0)) h1); star_associative (fp' x) frame (linv e m0); assert (H.interp ((fp' x `star` frame) `star` linv e m0) h1); let h1' : H.hheap ((fp' x `star` frame) `star` linv e m0) = h1 in assert (m1 == hmem_of_hheap m0 h1'); assert (with_inv_except m1 e (fp' x `star` frame)); assert (forall (hp:H.hprop frame). hp h0 == hp h1); mprop_preservation_of_hprop_preservation frame m0 m1; () in assert (is_frame_preserving g); g let frame_preserving_respects_preorder #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (m0:hmem_with_inv_except e fp) : Lemma (let (| x, m1 |) = f m0 in mem_evolves m0 m1) = let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1) = () in H.emp_unit fp; assert (interp (fp `star` linv e m0) m0); H.star_congruence (fp `star` emp) (linv e m0) fp (linv e m0); assert (interp ((fp `star` emp) `star` linv e m0) m0); aux emp m0 let lift_tot_action_nf #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') : MstTotNF a e fp fp' = let m0 = NMSTTotal.get () in let m0' : hmem_with_inv_except e fp = m0 in let r = f m0' in let (| x, m1 |) = r in let m1' : hmem_with_inv_except e (fp' x) = m1 in assert (is_frame_preserving f); assert (m1 == dsnd (f m0)); frame_preserving_respects_preorder f m0; NMSTTotal.put #_ #(mem_evolves) m1; x let lift_tot_action #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get #(full_mem) #_ () in ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); lift_tot_action_nf f (** Now defining the lift for heap actions with explicit frame *) let tot_action_with_frame_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = frame:slprop u#a -> m0:hmem_with_inv_except e (fp `star` frame) -> Pure (x:a & hmem_with_inv_except e (fp' x `star` frame)) (requires True) (ensures fun (| x, m1 |) -> mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_with_frame = tot_action_with_frame_except S.empty let lift_heap_action_with_frame (#fp:slprop u#a) (#a:Type u#b) (#fp':a -> slprop u#a) (e:inames) ($f:H.action_with_frame fp a fp') : tot_action_with_frame_except e fp a fp' = fun frame m0 -> let h0 = hheap_of_hmem m0 in calc (equiv) { fp `star` frame `star` locks_invariant e m0; (equiv) { star_associative fp frame (locks_invariant e m0) } fp `star` (frame `star` locks_invariant e m0); }; assert (H.interp (fp `star` frame `star` locks_invariant e m0) h0); assert (H.interp (fp `star` (frame `star` locks_invariant e m0)) h0); //key: apply the heap action with frame * locks_invariant e m0 let (| x, h1 |) = f (frame `star` locks_invariant e m0) h0 in calc (equiv) { fp' x `star` (frame `star` locks_invariant e m0); (equiv) { star_associative (fp' x) frame (locks_invariant e m0) } fp' x `star` frame `star` locks_invariant e m0; }; assert (H.interp (fp' x `star` (frame `star` locks_invariant e m0)) h1); assert (H.interp (fp' x `star` frame `star` locks_invariant e m0) h1); let m1 = hmem_of_hheap m0 h1 in assert (mem_evolves m0 m1); mprop_preservation_of_hprop_preservation (frame `star` locks_invariant e m0) m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)); (| x, m1 |) let lift_tot_action_with_frame #a #e #fp #fp' ($f:tot_action_with_frame_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in assert (inames_ok e m0); ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); let m0' : hmem_with_inv_except e fp = m0 in let r = f frame m0' in let (| x, m1 |) = r in ac_reasoning_for_m_frame_preserving (fp' x) frame (locks_invariant e m1) m1; assert (interp (fp' x `star` frame `star` locks_invariant e m1) m1); assert (interp (fp' x `star` locks_invariant e m1) m1); let m1' : hmem_with_inv_except e (fp' x) = m1 in NMSTTotal.put #_ #(mem_evolves) m1; x let sel_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.sel_action #a #pcm r v0)) let upd_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.upd_action #a #pcm r v0 v1)) let free_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.free_action #a #pcm r v0)) let split_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.split_action #a #pcm r v0 v1)) let gather_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.gather_action #a #pcm r v0 v1)) let weaken (p q r:slprop) (h:H.hheap (p `star` q) { H.stronger q r }) : H.hheap (p `star` r) = H.weaken p q r h; h let weaken_pure (q r: prop) : Lemma (requires (q ==> r)) (ensures H.stronger (H.pure q) (H.pure r)) = let aux (h:H.heap) : Lemma (ensures (H.interp (H.pure q) h ==> H.interp (H.pure r) h)) [SMTPat ()] = H.pure_interp q h; H.pure_interp r h in () let inc_ctr (#p:slprop) #e (m:hmem_with_inv_except e p) : m':hmem_with_inv_except e p{m'.ctr = m.ctr + 1 /\ H.stronger (linv e m) (linv e m')} = let m' : mem = { m with ctr = m.ctr + 1} in assert (interp (p `star` linv e m) m'); assert (linv e m == lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m)); assert (linv e m' == lock_store_invariant e m.locks `star` ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken_free_above (heap_of_mem m) m.ctr (m.ctr + 1); weaken_pure (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_ctr_valid (m.ctr + 1) (heap_of_mem m)); assert (H.stronger (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m))); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)); H.stronger_star (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken (p `star` lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)) (heap_of_mem m'); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity (m.ctr + 1) (heap_of_mem m)); let m' : hmem_with_inv_except e p = m' in m' let frame_related_mems (fp0 fp1:slprop u#a) e (m0:hmem_with_inv_except e fp0) (m1:hmem_with_inv_except e fp1) = forall (frame:slprop u#a). interp ((fp0 `star` frame) `star` linv e m0) m0 ==> interp ((fp1 `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) let refined_pre_action e (fp0:slprop) (a:Type) (fp1:a -> slprop) = m0:hmem_with_inv_except e fp0 -> Pure (x:a & hmem_with_inv_except e (fp1 x)) (requires True) (ensures fun (| x, m1 |) -> frame_related_mems fp0 (fp1 x) e m0 m1) let refined_pre_action_as_action (#fp0:slprop) (#a:Type) (#fp1:a -> slprop) #e ($f:refined_pre_action e fp0 a fp1) : tot_action_nf_except e fp0 a fp1 = let g : tot_pre_action_nf_except e fp0 a fp1 = fun m -> f m in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp0 `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp1 x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x', m1' |) = g m0 in let (| x, m1 |) = f m0 in assert (x == x' /\ m1 == m1') in g let alloc_action #a #pcm e x = let f : refined_pre_action e emp (ref a pcm) (fun r -> pts_to r x) = fun m0 -> (* NS: 9/29/22 I needed to annotate h : Heap.full_heap, for use with the Core checker which generates a guard for checking the implicit pattern "dot" term in the dependent pair pattern on the next line. That guard expects `h` to be a full_heap, which is it, because it is a projection of m0. However, this is not reflected in `h`'s type. So, the Core checker, which produces a guard for the pat_dot_term in isolation, cannot recheck the term. If we were to fold in the checking of pat_dot_terms and their guards with the rest of the VC, this would work. *) let h : Heap.full_heap = hheap_of_hmem m0 in let (|r, h'|) = H.extend #a #pcm x m0.ctr h in let m' : hmem_with_inv_except e emp = inc_ctr m0 in let h' : H.hheap (pts_to #a #pcm r x `star` linv e m') = weaken _ (linv e m0) (linv e m') h' in let m1 : hmem_with_inv_except e (pts_to #a #pcm r x) = hmem_of_hheap m' h' in assert (forall frame. H.frame_related_heaps h h' emp (pts_to #a #pcm r x) frame true); let aux (frame:slprop) : Lemma (requires interp ((emp `star` frame) `star` linv e m0) m0) (ensures interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) [SMTPat (emp `star` frame)] = star_associative emp frame (linv e m0); assert (H.interp (emp `star` (frame `star` linv e m0)) h); assert (H.interp (pts_to #a #pcm r x `star` (frame `star` linv e m0)) h'); star_associative (pts_to #a #pcm r x) frame (linv e m0); assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m0) h'); assert (H.stronger (linv e m0) (linv e m')); assert (H.equiv (linv e m') (linv e m1)); assert (H.stronger (linv e m0) (linv e m1)); let h' : H.hheap ((pts_to #a #pcm r x `star` frame) `star` linv e m1) = weaken _ (linv e m0) (linv e m1) h' in assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) h'); assert (forall (mp:H.hprop frame). mp h == mp h'); mprop_preservation_of_hprop_preservation frame m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) in assert (frame_related_mems emp (pts_to r x) e m0 m1); (| r, m1 |) in lift_tot_action (refined_pre_action_as_action f) let select_refine #a #p e r x f = lift_tot_action (lift_heap_action e (H.select_refine #a #p r x f)) let upd_gen #a #p e r x y f = lift_tot_action (lift_heap_action e (H.upd_gen_action r x y f)) //////////////////////////////////////////////////////////////////////////////// // witness / recall //////////////////////////////////////////////////////////////////////////////// let witnessed_ref #a #pcm (r:ref a pcm) (fact:property a) (m:full_mem) = H.witnessed_ref #a #pcm r fact (heap_of_mem m) let witnessed_ref_stability #a #pcm (r:ref a pcm) (fact:property a) : Lemma (requires FStar.Preorder.stable fact (Steel.Preorder.preorder_of_pcm pcm)) (ensures FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) = H.witnessed_ref_stability #a #pcm r fact let witnessed (#a:Type u#1) (#pcm:pcm a) (r:ref a pcm) (fact:property a) = W.witnessed _ mem_evolves (witnessed_ref r fact) let rearrange_pqr_prq (p q r:slprop) : Lemma (((p `star` q) `star` r) `equiv` ((p `star` r) `star` q)) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_associative p q r } p `star` (q `star` r); (equiv) { star_commutative q r; star_congruence p (q `star` r) p (r `star` q) } p `star` (r `star` q); (equiv) { star_associative p r q } (p `star` r) `star` q; } let preserves_frame_cong (e:inames) (p q:slprop) (r s:slprop) (m0 m1:mem) : Lemma (requires p `equiv` r /\ q `equiv` s /\ preserves_frame e p q m0 m1) (ensures preserves_frame e r s m0 m1) = let aux0 (p q r s:slprop) : Lemma (requires p `equiv` s) (ensures (((p `star` q) `star` r) `equiv` ((s `star` q) `star` r))) = star_congruence p q s q; star_congruence (p `star` q) r (s `star` q) r in let aux (frame:slprop) : Lemma (requires interp ((r `star` frame) `star` locks_invariant e m0) m0) (ensures interp ((s `star` frame) `star` locks_invariant e m1) m1 /\ interp ((p `star` frame) `star` locks_invariant e m0) m0) [SMTPat (r `star` frame)] = aux0 p frame (locks_invariant e m0) r; aux0 q frame (locks_invariant e m1) s; assert (((p `star` frame) `star` locks_invariant e m0) `equiv` ((r `star` frame) `star` locks_invariant e m0)); assert (interp ((p `star` frame) `star` locks_invariant e m0) m0); assert (interp ((q `star` frame) `star` locks_invariant e m1) m1); assert (((q `star` frame) `star` locks_invariant e m1) `equiv` ((s `star` frame) `star` locks_invariant e m1)); () in () let pure_true_equiv (p:slprop) : Lemma ((p `star` pure True) `equiv` p) = FStar.Classical.forall_intro (pure_star_interp p True); emp_unit p; assert ((p `star` pure True) `equiv` p) let preserves_frame_star_pure (e:inames) (p q:slprop) (r s:prop) (m:mem) : Lemma (requires r /\ s) (ensures preserves_frame e p q m m <==> preserves_frame e (p `star` pure r) (q `star` pure s) m m) = pure_equiv r True; star_congruence p (pure r) p (pure True); pure_equiv s True; star_congruence q (pure s) q (pure True); pure_true_equiv p; pure_true_equiv q; let fwd () : Lemma (requires preserves_frame e p q m m) (ensures preserves_frame e (p `star` pure r) (q `star` pure s) m m) [SMTPat ()] = preserves_frame_cong e p q (p `star` pure r) (q `star` pure s) m m in let bk () : Lemma (requires preserves_frame e (p `star` pure r) (q `star` pure s) m m) (ensures preserves_frame e p q m m) [SMTPat ()] = preserves_frame_cong e (p `star` pure r) (q `star` pure s) p q m m in () let witness (#a:Type) (#pcm:pcm a) (e:inames) (r:erased (ref a pcm)) (fact:stable_property pcm) (v:Ghost.erased a) (_:squash (forall z. compatible pcm v z ==> fact z)) (frame:slprop) : MstTot (witnessed r fact) e (pts_to r v) (fun _ -> pts_to r v) frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in let _ : unit = let hr : H.ref a pcm = r in let v' = H.sel_v hr v (heap_of_mem m0) in assert (interp (H.ptr hr) m0 /\ H.sel #a #pcm hr (heap_of_mem m0) == v'); assert (compatible pcm v v'); assert (fact v'); assert (witnessed_ref r fact m0); witnessed_ref_stability r fact; assert (FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) in let w = NMSTTotal.witness _ mem_evolves (witnessed_ref r fact) in w let recall (#a:Type u#1) (#pcm:pcm a) (#fact:property a) (e:inames) (r:erased (ref a pcm)) (v:Ghost.erased a) (w:witnessed r fact) (frame:slprop) = let m0 = NMSTTotal.get () in NMSTTotal.recall _ mem_evolves (witnessed_ref r fact) w; let hr : H.ref a pcm = r in assert (witnessed_ref r fact m0); let v1 = H.sel_v hr v (heap_of_mem m0) in assert (compatible pcm v v1); assert (H.sel hr (heap_of_mem m0) == v1); assert (fact v1); assert (interp ((pts_to r v `star` frame) `star` locks_invariant e m0) m0); emp_unit ((pts_to r v `star` frame) `star` locks_invariant e m0); pure_star_interp ((pts_to r v `star` frame) `star` locks_invariant e m0) (fact v1) m0; assert (interp (((pts_to r v `star` frame) `star` locks_invariant e m0) `star` pure (fact v1)) m0); rearrange_pqr_prq (pts_to r v `star` frame) (locks_invariant e m0) (pure (fact v1)); assert (interp (((pts_to r v `star` frame) `star` pure (fact v1)) `star` locks_invariant e m0) m0); rearrange_pqr_prq (pts_to r v) frame (pure (fact v1)); star_congruence ((pts_to r v `star` frame) `star` pure (fact v1)) (locks_invariant e m0) ((pts_to r v `star` pure (fact v1)) `star` frame) (locks_invariant e m0); Ghost.hide v1 let iname_for_p_mem (i:iname) (p:slprop) : W.s_predicate mem = fun m -> iname_for_p i p m.locks let iname_for_p_stable (i:iname) (p:slprop) : Lemma (W.stable full_mem mem_evolves (iname_for_p_mem i p)) = () let ( >--> ) (i:iname) (p:slprop) : Type0 = W.witnessed full_mem mem_evolves (iname_for_p_mem i p) let hmem_with_inv_equiv e (m:mem) (p:slprop) : Lemma (interp (p `star` linv e m) m <==> interp (p `star` lock_store_invariant e m.locks) m /\ heap_ctr_valid m.ctr (heap_of_mem m)) = calc (<==>) { interp (p `star` linv e m) m; (<==>) { H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) } interp ((p `star` lock_store_invariant e m.locks) `star` ctr_validity m.ctr (heap_of_mem m)) m; (<==>) { H.pure_star_interp (p `star` lock_store_invariant e m.locks) (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_of_mem m) } interp ((p `star` lock_store_invariant e m.locks) `star` emp) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); (<==>) { H.emp_unit (p `star` lock_store_invariant e m.locks) } interp (p `star` lock_store_invariant e m.locks) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); } let new_invariant_tot_action (e:inames) (p:slprop) (m0:hmem_with_inv_except e p{ e `inames_in` m0.locks }) : Pure (iname & hmem_with_inv_except e emp) (requires True) (ensures fun (i, m1) -> iname_for_p_mem i p m1 /\ frame_related_mems p emp e m0 m1 /\ mem_evolves m0 m1) = let (| i, l1 |) = extend_lock_store e m0.locks p in let m1 = { m0 with locks = l1 } in assert (lock_store_invariant e m1.locks == p `star` lock_store_invariant e m0.locks); calc (equiv) { linv e m1; (equiv) {} (lock_store_invariant e m1.locks `star` ctr_validity m1.ctr (heap_of_mem m1)); (equiv) {} ((p `star` lock_store_invariant e m0.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); (equiv) { H.star_associative p (lock_store_invariant e m0.locks) (ctr_validity m1.ctr (heap_of_mem m1)) } (p `star` (lock_store_invariant e m0.locks `star` ctr_validity m1.ctr (heap_of_mem m1))); (equiv) { } (p `star` linv e m0); }; assert (iname_for_p_mem i p m1); assert (lock_store_evolves m0.locks l1); assert (mem_evolves m0 m1); hmem_with_inv_equiv e m0 p; assert (interp (p `star` lock_store_invariant e m0.locks) m1); assert (interp (lock_store_invariant e m1.locks) m1); H.emp_unit (lock_store_invariant e m1.locks); H.star_commutative (lock_store_invariant e m1.locks) emp; assert (interp (emp `star` lock_store_invariant e m1.locks) m1); hmem_with_inv_equiv e m1 emp; let m1 : hmem_with_inv_except e emp = m1 in let aux (frame:slprop) : Lemma (requires interp ((p `star` frame) `star` linv e m0) m0) (ensures interp ((emp `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) <==> mp (core_mem m1))) [SMTPat (p `star` frame)] = assert (interp ((p `star` frame) `star` linv e m0) m1); calc (equiv) { ((p `star` frame) `star` linv e m0); (equiv) { H.star_commutative p frame; H.star_congruence (p `star` frame) (linv e m0) (frame `star` p) (linv e m0); H.star_associative frame p (linv e m0) } (frame `star` (p `star` linv e m0)); (equiv) { H.star_congruence frame (p `star` linv e m0) frame (linv e m1) } (frame `star` linv e m1); (equiv) { H.emp_unit (frame `star` linv e m1); H.star_commutative (frame `star` linv e m1) emp; H.star_associative emp frame (linv e m1) } ((emp `star` frame) `star` linv e m1); }; assert (interp ((emp `star` frame) `star` linv e m1) m1) in assert (frame_related_mems p emp e m0 m1); ( i, m1 ) let name_is_ok (i:iname) (m0:full_mem u#1) : prop = i < List.Tot.length m0.locks let witnessed_name_is_ok (i:iname) = W.witnessed full_mem mem_evolves (name_is_ok i) let pre_inv = i:erased iname & witnessed_name_is_ok i let inv (p:slprop u#1) = i:erased iname & witnessed_name_is_ok i & (i >--> p) let pre_inv_of_inv #p (i:inv p) = let (|i, w, _|) = i in (|i,w|) let name_of_pre_inv (i:pre_inv) = dfst i let rec recall_all (ctx:list pre_inv) : NMSTTotal.NMSTATETOT unit (full_mem u#1) mem_evolves (requires fun _ -> True) (ensures fun m0 _ m1 -> m0==m1 /\ (forall i. i `List.Tot.memP` ctx ==> name_is_ok (name_of_pre_inv i) m0)) = match ctx with | [] -> () | hd::tl -> let (| q, i |) = hd in let i : W.witnessed full_mem mem_evolves (name_is_ok q) = i in NMSTTotal.recall _ mem_evolves (name_is_ok q) i; recall_all tl let fresh_invariant (e:inames) (p:slprop) (ctx:list pre_inv) (frame:slprop) : MstTot (i:inv p { not (mem_inv e i) /\ fresh_wrt ctx (name_of_inv i)}) e p (fun _ -> emp) frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in recall_all ctx; ac_reasoning_for_m_frame_preserving p frame (locks_invariant e m0) m0; assert (interp (p `star` locks_invariant e m0) m0); let r = new_invariant_tot_action e p m0 in let ( i, m1 ) = r in assert (i == List.Tot.length m0.locks); assert (not (Set.mem i e)); assert (mem_evolves m0 m1); NMSTTotal.put #full_mem #mem_evolves m1; iname_for_p_stable i p; let w = NMSTTotal.witness full_mem mem_evolves (iname_for_p_mem i p) in let w0 = NMSTTotal.witness full_mem mem_evolves (name_is_ok i) in (| hide i, w0, w |) let new_invariant (e:inames) (p:slprop) (frame:slprop) : MstTot (inv p) e p (fun _ -> emp) frame (fun _ -> True) (fun _ _ _ -> True) = fresh_invariant e p [] frame let rearrange_invariant (p q r : slprop) (q0 q1:slprop) : Lemma (requires q `equiv` (q0 `star` q1)) (ensures (p `star` (q `star` r)) `equiv` ((q0 `star` p) `star` (q1 `star` r))) = calc (equiv) { p `star` (q `star` r); (equiv) { calc (equiv) { (q `star` r); (equiv) { star_congruence q r (q0 `star` q1) r } (q0 `star` q1) `star` r; }; star_congruence p (q `star` r) p ((q0 `star` q1) `star` r) } (p `star` ((q0 `star` q1) `star` r)); (equiv) { star_associative q0 q1 r; star_congruence p ((q0 `star` q1) `star` r) p (q0 `star` (q1 `star` r)); star_associative p q0 (q1 `star` r) } (p `star` q0) `star` (q1 `star` r); (equiv) { star_commutative p q0; star_congruence (p `star` q0) (q1 `star` r) (q0 `star` p) (q1 `star` r) } (q0 `star` p) `star` (q1 `star` r); } let preserves_frame_invariant (fp fp':slprop) (opened_invariants:inames) (p:slprop) (i:inv p{not (mem_inv opened_invariants i)}) (m0:hmem_with_inv_except (add_inv opened_invariants i) (p `star` fp)) (m1:mem) : Lemma (requires preserves_frame (set_add (name_of_inv i) opened_invariants) (p `star` fp) (p `star` fp') m0 m1 /\ interp (fp' `star` linv opened_invariants m1) m1 /\ inames_ok opened_invariants m1 /\ (lock_store_invariant opened_invariants m0.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks)) /\ (lock_store_invariant opened_invariants m1.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks))) (ensures preserves_frame opened_invariants fp fp' m0 m1) = let aux (frame:slprop) : Lemma (requires interp ((fp `star` frame) `star` linv opened_invariants m0) m0) (ensures interp ((fp' `star` frame) `star` linv opened_invariants m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) [SMTPat()] = rearrange_invariant (fp `star` frame) (lock_store_invariant opened_invariants m0.locks) (ctr_validity m0.ctr (heap_of_mem m0)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks); assert (interp ((p `star` (fp `star` frame)) `star` linv (set_add (name_of_inv i) opened_invariants) m0) m0); star_associative p fp frame; star_congruence (p `star` (fp `star` frame)) (linv (set_add (name_of_inv i) opened_invariants) m0) ((p `star` fp) `star` frame) (linv (set_add (name_of_inv i) opened_invariants) m0); assert (interp (((p `star` fp) `star` frame) `star` linv (set_add (name_of_inv i) opened_invariants) m0) m0); assert (interp (((p `star` fp') `star` frame) `star` linv (set_add (name_of_inv i) opened_invariants) m1) m1); star_associative p fp' frame; star_congruence ((p `star` fp') `star` frame) (linv (set_add (name_of_inv i) opened_invariants) m1) (p `star` (fp' `star` frame)) (linv (set_add (name_of_inv i) opened_invariants) m1); assert (interp ((p `star` (fp' `star` frame)) `star` linv (set_add (name_of_inv i) opened_invariants) m1) m1); rearrange_invariant (fp' `star` frame) (lock_store_invariant opened_invariants m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks); assert (interp ((fp' `star` frame) `star` linv opened_invariants m1) m1); () in () let equiv_ext_right (p q r:slprop) : Lemma (requires q `equiv` r) (ensures (p `star` q) `equiv` (p `star` r)) = calc (equiv) { p `star` q; (equiv) { star_commutative p q } q `star` p; (equiv) { equiv_extensional_on_star q r p } r `star` p; (equiv) { star_commutative p r } p `star` r; } let with_inv_helper (fp frame ls1 ctr p ls2:slprop) : Lemma (requires ls1 `equiv` (p `star` ls2)) (ensures (fp `star` frame `star` (ls1 `star` ctr)) `equiv` (p `star` fp `star` frame `star` (ls2 `star` ctr))) = calc (equiv) { ls1 `star` ctr; (equiv) { equiv_extensional_on_star ls1 (p `star` ls2) ctr } p `star` ls2 `star` ctr; }; calc (equiv) { p `star` ls2 `star` ctr; (equiv) { star_associative p ls2 ctr } p `star` (ls2 `star` ctr); }; calc (equiv) { fp `star` frame `star` p; (equiv) { star_commutative (fp `star` frame) p } p `star` (fp `star` frame); (equiv) { star_associative p fp frame } p `star` fp `star` frame; }; calc (equiv) { fp `star` frame `star` (ls1 `star` ctr); (equiv) { equiv_ext_right (fp `star` frame) (ls1 `star` ctr) (p `star` ls2 `star` ctr) } (fp `star` frame) `star` (p `star` ls2 `star` ctr); (equiv) { equiv_ext_right (fp `star` frame) (p `star` ls2 `star` ctr) (p `star` (ls2 `star` ctr)) } (fp `star` frame) `star` (p `star` (ls2 `star` ctr)); (equiv) { star_associative (fp `star` frame) p (ls2 `star` ctr) } (fp `star` frame `star` p) `star` (ls2 `star` ctr); (equiv) { equiv_extensional_on_star (fp `star` frame `star` p) (p `star` fp `star` frame) (ls2 `star` ctr) } (p `star` fp `star` frame) `star` (ls2 `star` ctr); } let token_of_inv #p (i:inv p) : (name_of_inv i >--> p) = let (| _, _, tok |) = i in tok let with_invariant (#a:Type) (#fp:slprop) (#fp':a -> slprop) (#opened_invariants:inames) (#p:slprop) (i:inv p{not (mem_inv opened_invariants i)}) (f:action_except a (add_inv opened_invariants i) (p `star` fp) (fun x -> p `star` fp' x)) (frame:slprop) : MstTot a opened_invariants fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in NMSTTotal.recall _ mem_evolves (iname_for_p_mem (name_of_inv i) p) (token_of_inv i); assert (iname_for_p (name_of_inv i) p m0.locks); assert (interp (fp `star` frame `star` locks_invariant opened_invariants m0) m0); assert (interp (fp `star` frame `star` (lock_store_invariant opened_invariants m0.locks `star` ctr_validity m0.ctr (heap_of_mem m0))) m0); move_invariant opened_invariants m0.locks p (name_of_inv i); assert (lock_store_invariant opened_invariants m0.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks)); with_inv_helper fp frame (lock_store_invariant opened_invariants m0.locks) (ctr_validity m0.ctr (heap_of_mem m0)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks); assert (interp (p `star` fp `star` frame `star` locks_invariant (set_add (name_of_inv i) opened_invariants) m0) m0); let r = f frame in let m1 : full_mem = NMSTTotal.get () in assert (interp (p `star` fp' r `star` frame `star` locks_invariant (set_add (name_of_inv i) opened_invariants) m1) m1); assert (interp (p `star` fp' r `star` frame `star` (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks `star` ctr_validity m1.ctr (heap_of_mem m1))) m1); NMSTTotal.recall _ mem_evolves (iname_for_p_mem (name_of_inv i) p) (token_of_inv i); move_invariant opened_invariants m1.locks p (name_of_inv i); assert (lock_store_invariant opened_invariants m1.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks)); with_inv_helper (fp' r) frame (lock_store_invariant opened_invariants m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks); assert (interp (fp' r `star` frame `star` locks_invariant opened_invariants m1) m1); assert (inames_ok opened_invariants m1); r

{ "checked_file": "/", "dependencies": [ "Steel.Preorder.fst.checked", "Steel.Heap.fsti.checked", "prims.fst.checked", "FStar.Witnessed.Core.fsti.checked", "FStar.Set.fsti.checked", "FStar.Preorder.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.PCM.fst.checked", "FStar.NMSTTotal.fst.checked", "FStar.List.Tot.fst.checked", "FStar.IndefiniteDescription.fsti.checked", "FStar.Ghost.fsti.checked", "FStar.FunctionalExtensionality.fsti.checked", "FStar.Classical.Sugar.fsti.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Steel.Memory.fst" }

[ { "abbrev": true, "full_module": "Steel.Preorder", "short_module": "PP" }, { "abbrev": true, "full_module": "FStar.Witnessed.Core", "short_module": "W" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": true, "full_module": "Steel.Heap", "short_module": "H" }, { "abbrev": false, "full_module": "FStar.PCM", "short_module": null }, { "abbrev": false, "full_module": "FStar.FunctionalExtensionality", "short_module": null }, { "abbrev": true, "full_module": "FStar.FunctionalExtensionality", "short_module": "F" }, { "abbrev": false, "full_module": "FStar.PCM", "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

p: Steel.Memory.slprop -> q: Steel.Memory.slprop -> r: Steel.Memory.slprop -> s: Steel.Memory.slprop -> FStar.Pervasives.Lemma (ensures Steel.Memory.equiv (Steel.Memory.star (Steel.Memory.star (Steel.Memory.star p q) r) s) (Steel.Memory.star (Steel.Memory.star p (Steel.Memory.star q r)) s))

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Steel.Memory.slprop", "Steel.Memory.equiv_extensional_on_star", "Steel.Memory.star", "Prims.unit", "Steel.Memory.star_associative", "Prims.l_True", "Prims.squash", "Steel.Memory.equiv", "Prims.Nil", "FStar.Pervasives.pattern" ]

[]

true

false

true

false

let equiv_pqrs_p_qr_s (p q r s: slprop) : Lemma ((((p `star` q) `star` r) `star` s) `equiv` ((p `star` (q `star` r)) `star` s)) =

star_associative p q r; equiv_extensional_on_star ((p `star` q) `star` r) (p `star` (q `star` r)) s

false

Platform.Bytes.fst

Platform.Bytes.op_At_Bar

val op_At_Bar: bytes -> bytes -> Tot bytes

let op_At_Bar (b1:bytes) (b2:bytes) = Seq.append b1 b2

{ "file_name": "ucontrib/Platform/fst/Platform.Bytes.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }

{ "end_col": 54, "end_line": 65, "start_col": 0, "start_line": 65 }

(* Copyright 2008-2018 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 Platform.Bytes assume val repr_bytes : nat -> GTot (n:nat{n>0}) (* Integer literals are currently extracted to int32, rather than bigint, so the definition below breaks extraction: Unexpected error; please file a bug report, ideally with a minimized version of the source program that triggered the error. int_of_string Also, defining repr_bytes n <= 8 for all n is dubious *) (* let repr_bytes n = if n < 256 then 1 else if n < 65536 then 2 else if n < 16777216 then 3 else if n < 4294967296 then 4 else if n < 1099511627776 then 5 else if n < 281474976710656 then 6 else if n < 72057594037927936 then 7 else 8 *) (* NS: The two assumes below were previously defined as axioms. They are evil! They pollute the global environment and slow down verification enormously. I've made them assumed lemmas; if you want to make use of these axioms, call the lemmas as needed in the context. *) assume val lemma_repr_bytes_values: n:nat -> Lemma ( ( n < 256 <==> repr_bytes n = 1 ) /\ ( (n >= 256 /\ n < 65536) <==> repr_bytes n = 2 ) /\ ( (n >= 65536 /\ n < 16777216) <==> repr_bytes n = 3 ) /\ ( (n >= 16777216 /\ n < 4294967296) <==> repr_bytes n = 4 ) /\ ( (n >= 4294967296 /\ n < 1099511627776) <==> repr_bytes n = 5 ) /\ ( (n >= 1099511627776 /\ n < 281474976710656) <==> repr_bytes n = 6 ) /\ ( (n >= 281474976710656 /\ n < 72057594037927936) <==> repr_bytes n = 7 ) /\ ( (n >= 72057594037927936 /\ n < 18446744073709551616) <==> repr_bytes n = 8 ) ) unfold let byte:Type0 = FStar.UInt8.t type cbytes = string (* abstract *) type bytes = Seq.seq byte (* AR: adding this *) assume HasEq_bytes: hasEq bytes val seq_of_bytes: b:bytes -> GTot (Seq.seq byte) let seq_of_bytes b = b

{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.UInt8.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked" ], "interface_file": false, "source_file": "Platform.Bytes.fst" }

[ { "abbrev": false, "full_module": "Platform", "short_module": null }, { "abbrev": false, "full_module": "Platform", "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

b1: Platform.Bytes.bytes -> b2: Platform.Bytes.bytes -> Platform.Bytes.bytes

Prims.Tot

[ "total" ]

[]

[ "Platform.Bytes.bytes", "FStar.Seq.Base.append", "Platform.Bytes.byte" ]

[]

false

true

false

let ( @| ) (b1 b2: bytes) =

Seq.append b1 b2

false

Steel.Memory.fst

Steel.Memory.pts_to_join

val pts_to_join (#a:Type) (#pcm:pcm a) (r:ref a pcm) (x y : a) (m:mem) : Lemma (requires (interp (pts_to r x) m /\ interp (pts_to r y) m)) (ensures (joinable pcm x y))

let pts_to_join (#a:Type) (#pcm:pcm a) (r:ref a pcm) (x y : a) (m:mem) : Lemma (requires (interp (pts_to r x) m /\ interp (pts_to r y) m)) (ensures (joinable pcm x y)) = H.pts_to_join #a #pcm r x y (heap_of_mem m)

{ "file_name": "lib/steel/Steel.Memory.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 45, "end_line": 1563, "start_col": 0, "start_line": 1560 }

(* 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.Memory module F = FStar.FunctionalExtensionality open FStar.FunctionalExtensionality open FStar.PCM module H = Steel.Heap noeq type lock_state : Type u#(a + 1) = | Invariant : inv:H.slprop u#a -> lock_state let lock_store : Type u#(a+1) = list (lock_state u#a) noeq type mem : Type u#(a + 1) = { ctr: nat; heap: H.heap u#a; locks: lock_store u#a; } let heap_of_mem (x:mem) : H.heap = x.heap let mem_of_heap (h:H.heap) : mem = { ctr = 0; heap = h; locks = [] } let mem_set_heap (m:mem) (h:H.heap) : mem = { ctr = m.ctr; heap = h; locks = m.locks; } let core_mem (m:mem) : mem = mem_of_heap (heap_of_mem m) let core_mem_invol m = () let disjoint (m0 m1:mem u#h) : prop = m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks let disjoint_sym m0 m1 = () let join m0 m1 = { ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = m0.locks } let join_commutative m0 m1 = H.join_commutative m0.heap m1.heap let disjoint_join m0 m1 m2 = H.disjoint_join m0.heap m1.heap m2.heap let join_associative m0 m1 m2 = H.join_associative m0.heap m1.heap m2.heap let slprop = H.slprop let interp p m = H.interp p m.heap let equiv p1 p2 = forall m. interp p1 m <==> interp p2 m let slprop_extensionality p q = assert (forall m. interp p m <==> interp q m); let aux (h:H.heap) : Lemma (H.interp p h <==> H.interp q h) [SMTPat (H.interp p h)] = let m : mem = { ctr = 0; heap = h; locks = [] } in assert (interp p m <==> interp q m) in assert (forall h. H.interp p h <==> H.interp q h); Steel.Heap.slprop_extensionality p q let reveal_equiv p1 p2 = () let core_ref = H.core_ref let core_ref_null = H.core_ref_null let core_ref_is_null r = H.core_ref_is_null r let emp : slprop u#a = H.emp let pure = H.pure let pts_to = H.pts_to let h_and = H.h_and let h_or = H.h_or let star = H.star let wand = H.wand let h_exists = H.h_exists let h_forall = H.h_forall //////////////////////////////////////////////////////////////////////////////// //properties of equiv //////////////////////////////////////////////////////////////////////////////// let equiv_symmetric (p1 p2:slprop u#a) = H.equiv_symmetric p1 p2 #push-options "--warn_error -271" let equiv_heap_iff_equiv (p1 p2:slprop u#a) : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat (equiv p1 p2)] = let aux_lr () : Lemma (requires H.equiv p1 p2) (ensures equiv p1 p2) [SMTPat ()] = () in let aux_rl_helper1 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p1 h) (ensures H.interp p2 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl_helper2 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p2 h) (ensures H.interp p1 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl () : Lemma (requires equiv p1 p2) (ensures H.equiv p1 p2) [SMTPat ()] = () in () let equiv_heap_iff_equiv_forall () : Lemma (ensures (forall p1 p2. H.equiv p1 p2 <==> equiv p1 p2)) = let aux p1 p2 : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat ()] = equiv_heap_iff_equiv p1 p2 in () #pop-options let equiv_extensional_on_star (p1 p2 p3:slprop u#a) = equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3 let emp_unit p = H.emp_unit p let intro_emp m = H.intro_emp (heap_of_mem m) let pure_equiv p q = H.pure_equiv p q let pure_interp q m = H.pure_interp q (heap_of_mem m) let pure_star_interp p q m = H.pure_star_interp p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// //pts_to //////////////////////////////////////////////////////////////////////////////// let pts_to_compatible #a #pcm x v0 v1 m = H.pts_to_compatible #a #pcm x v0 v1 (heap_of_mem m) let pts_to_compatible_equiv #a #pcm x v0 v1 = H.pts_to_compatible_equiv #a #pcm x v0 v1 let pts_to_not_null #a #pcm x v m = H.pts_to_not_null #a #pcm x v (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // star //////////////////////////////////////////////////////////////////////////////// let intro_star p q mp mq = H.intro_star p q (heap_of_mem mp) (heap_of_mem mq) let elim_star p q m = let h = heap_of_mem m in H.elim_star p q h; assert (exists hl hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr); let hl = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hl -> exists hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let hr = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hr -> H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let ml = mem_set_heap m hl in let mr = mem_set_heap m hr in assert (disjoint ml mr); assert (m == join ml mr); assert (interp p ml); assert (interp q mr); () let interp_star (p q: slprop) (m: mem) : Lemma (interp (p `star` q) m <==> (exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m)) = let left = interp (p `star` q) m in let right = exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m in let f () : Lemma (requires left) (ensures right) = elim_star p q m in let g () : Lemma (requires right) (ensures left) = Classical.exists_elim left #_ #(fun mp -> exists (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mp -> Classical.exists_elim left #_ #(fun mq -> disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mq -> intro_star p q mp mq ) ) in Classical.move_requires f (); Classical.move_requires g () let star_commutative (p1 p2:slprop) = H.star_commutative p1 p2 let star_associative (p1 p2 p3:slprop) = H.star_associative p1 p2 p3 let star_congruence (p1 p2 p3 p4:slprop) = equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4 let affine_star (p q:slprop) (m:mem) = H.affine_star p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // Invariants on the lock store //////////////////////////////////////////////////////////////////////////////// let iname = nat module S = FStar.Set module L = FStar.List.Tot module W = FStar.Witnessed.Core let rec lock_store_invariant (e:inames) (l:lock_store u#a) : slprop u#a = let current_addr = L.length l - 1 in match l with | [] -> emp | Invariant p :: tl -> if current_addr `S.mem` e then lock_store_invariant e tl else p `star` lock_store_invariant e tl let lock_i (i:iname) (l:lock_store { i < L.length l }) = let ix = L.length l - i - 1 in L.index l ix let iname_for_p (i:iname) (p:slprop) : W.s_predicate lock_store = fun l -> i < L.length l /\ (lock_i i l).inv == p let lock_store_evolves : FStar.Preorder.preorder lock_store = fun (l1 l2 : lock_store) -> L.length l2 >= L.length l1 /\ (forall (i:nat{i < L.length l1}). (lock_i i l1).inv == (lock_i i l2).inv) let inames_in (e:inames) (l:lock_store) : prop = forall i. Set.mem i e ==> i < L.length l let inames_ok e m = inames_in e m.locks let inames_ok_empty m = () let extend_lock_store (e:inames) (l:lock_store{e `inames_in` l}) (p:slprop) : i:iname & l':lock_store { lock_store_invariant e l' == p `star` lock_store_invariant e l /\ iname_for_p i p l' } = (| L.length l, Invariant p :: l |) let set_add (i:iname) (s:inames) = Set.union (Set.singleton i) s let rec move_invariant (e:inames) (l:lock_store) (p:slprop) (i:iname{iname_for_p i p l /\ ~(i `Set.mem` e)}) : Lemma (H.equiv (lock_store_invariant e l) (p `star` lock_store_invariant (set_add i e) l)) = let rec aux (i:iname) (m:lock_store) : Lemma (requires i >= L.length m) (ensures (lock_store_invariant e m `H.equiv` lock_store_invariant (set_add i e) m)) = match m with | [] -> () | Invariant p::tl -> aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl) in let current_addr = L.length l - 1 in match l with | [] -> () | Invariant q::tl -> if i = current_addr then begin assert (lock_store_invariant e l == p `star` lock_store_invariant e tl); aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl); () end else begin move_invariant e tl p i; assert (lock_store_invariant e tl `equiv` (p `star` lock_store_invariant (set_add i e) tl)); H.star_congruence q (lock_store_invariant e tl) q (p `star` lock_store_invariant (set_add i e) tl); if Set.mem current_addr e then () else begin let r = lock_store_invariant (set_add i e) tl in assert (lock_store_invariant e l `equiv` (q `star` (p `star` r))); H.star_associative q p r; H.star_commutative q p; H.star_congruence (q `star` p) r (p `star` q) r; H.star_associative p q r end end let heap_ctr_valid (ctr:nat) (h:H.heap u#a) : prop = h `H.free_above_addr` ctr let ctr_validity (ctr:nat) (h:H.heap) : slprop = H.pure (heap_ctr_valid ctr h) let locks_invariant (e:inames) (m:mem u#a) : slprop u#a = lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m) let full_mem_pred (m:mem) = H.full_heap_pred (heap_of_mem m) (***** Following lemmas are needed in Steel.Effect *****) let core_mem_interp (hp:slprop u#a) (m:mem u#a) = () let interp_depends_only_on (hp:slprop u#a) = H.interp_depends_only_on hp let a_mem_prop_as_a_heap_prop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (H.a_heap_prop u#a) = let g (h: H.heap u#a) : Tot prop = interp sl (mem_of_heap h) /\ f (mem_of_heap h) in let phi0 (h0 h1: H.heap u#a) : Lemma (requires (g h0 /\ H.disjoint h0 h1)) (ensures (g h0 /\ H.disjoint h0 h1 /\ g (H.join h0 h1))) = assert (mem_of_heap (H.join h0 h1) == mem_of_heap h0 `join` mem_of_heap h1); interp_depends_only_on sl in let phi1 (h0 h1: H.heap u#a) : Lemma (ensures ((g h0 /\ H.disjoint h0 h1) ==> g (H.join h0 h1))) = Classical.move_requires (phi0 h0) h1 in Classical.forall_intro_2 phi1; g let refine_slprop sl f = H.as_slprop (a_mem_prop_as_a_heap_prop sl f) let interp_refine_slprop sl f m = assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_mem m)) let dep_hprop (s: slprop) (f: (hmem s -> Tot slprop)) (h: H.heap) : Tot prop = exists (h1: H.heap) . exists (h2: H.heap) . interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 let dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq' : squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h')) = let p2 (h h1 h2: H.heap) : Tot prop = interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 in let p1 (h h1: H.heap) : Tot prop = (exists h2 . p2 h h1 h2) in let h1 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p1 h) in let h2 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p2 h h1) in H.disjoint_join h' h1 h2; assert (H.disjoint h2 h'); let h2' = H.join h2 h' in H.join_commutative h2 h' ; assert (h2' == H.join h' h2); assert (H.disjoint h1 h2'); assert (mem_of_heap h2' == mem_of_heap h2 `join` mem_of_heap h'); interp_depends_only_on (f (mem_of_heap h1)); assert (interp (f (mem_of_heap h1)) (mem_of_heap h2')); H.join_commutative h1 h2; H.join_associative h' h2 h1; H.join_commutative h' h; H.join_commutative h2' h1; assert (H.join h h' == h1 `H.join` h2') let impl_intro_gen (#p: Type0) (#q: Type0) ($prf: (squash p -> Lemma (q ))) : Lemma (p ==> q) = Classical.impl_intro_gen #p #(fun _ -> q) prf let dep_hprop_is_affine1 (s: slprop) (f: (hmem s -> Tot slprop)) (h0 h1: H.heap) : Lemma ((dep_hprop s f h0 /\ H.disjoint h0 h1) ==> (H.disjoint h0 h1 /\ dep_hprop s f (H.join h0 h1))) = impl_intro_gen (dep_hprop_is_affine0 s f h0 h1) let dep_hprop_is_affine (s: slprop) (f: (hmem s -> Tot slprop)) : Lemma (H.heap_prop_is_affine (dep_hprop s f)) = Classical.forall_intro_2 (dep_hprop_is_affine1 s f) let sdep (s: slprop) (f: (hmem s -> Tot slprop)) : Tot slprop = dep_hprop_is_affine s f; H.as_slprop (dep_hprop s f) let interp_sdep (s: slprop) (f: (hmem s -> Tot slprop)) (m: mem) : Lemma (requires (dep_slprop_is_affine s f)) (ensures ( interp (sdep s f) m <==> (exists m1 m2 . interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) )) = dep_hprop_is_affine s f; assert (forall m1 m2 . (interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) ==> ( interp s (mem_of_heap m1.heap) /\ interp (f (mem_of_heap m1.heap)) (mem_of_heap m2.heap) /\ H.disjoint m1.heap m2.heap /\ H.join m1.heap m2.heap == m.heap )); interp_depends_only_on s; Classical.forall_intro (fun m -> interp_depends_only_on (f m)); assert (forall h1 h2 . (interp s (mem_of_heap h1) /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ H.disjoint h1 h2 /\ H.join h1 h2 == m.heap) ==> ( core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ interp s (core_mem (mem_of_heap h1)) /\ interp s (mem_set_heap m h1) /\ core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ f (mem_set_heap m h1) `equiv` f (mem_of_heap h1) /\ interp (f (mem_set_heap m h1)) (mem_of_heap h2) /\ interp (f (mem_set_heap m h1)) (mem_set_heap m h2) /\ disjoint (mem_set_heap m h1) (mem_set_heap m h2) /\ join (mem_set_heap m h1) (mem_set_heap m h2) == m )); () let h_exists_cong (#a:Type) (p q : a -> slprop) : Lemma (requires (forall x. p x `equiv` q x)) (ensures (h_exists p `equiv` h_exists q)) = equiv_heap_iff_equiv_forall (); H.h_exists_cong p q let intro_h_exists #a x p m = H.intro_h_exists x p (heap_of_mem m) let elim_h_exists (#a:_) (p:a -> slprop) (m:mem) = H.elim_h_exists p (heap_of_mem m) let intro_h_forall (#a:_) (p:a -> slprop) (m:mem) = H.intro_h_forall p (heap_of_mem m) let elim_h_forall (#a:_) (p:a -> slprop) (m:mem) (x:a) = H.elim_h_forall p (heap_of_mem m) x let intro_h_and (p q: slprop) (m:mem) = H.intro_h_and p q (heap_of_mem m) let elim_h_and (p q: slprop) (m:mem) = H.elim_h_and p q (heap_of_mem m) let intro_h_or_left (p q: slprop) (m:mem) = H.intro_h_or_left p q (heap_of_mem m) let intro_h_or_right (p q: slprop) (m:mem) = H.intro_h_or_right p q (heap_of_mem m) let elim_h_or (p q: slprop) (m:mem) = H.elim_h_or p q (heap_of_mem m) let intro_wand (p1 p2: slprop u#a) (m:mem) = introduce (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)) ==> interp (wand p1 p2) m with _. ( assert (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)); H.intro_wand p1 p2 (heap_of_mem m); let h = heap_of_mem m in assert ((forall h1. h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) ==> H.interp (wand p1 p2) h); introduce forall h1. (h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) with ( introduce (h `H.disjoint` h1 /\ H.interp p1 h1) ==> H.interp p2 (H.join h h1) with _. ( assert (h `H.disjoint` h1); let m1 = { ctr = m.ctr; heap = h1; locks = m.locks } in assert (m `disjoint` m1) ) ) ) (** Eliminating a wand by proving a heap that satisfies the LHS **) let elim_wand (p1 p2: slprop u#a) (m:mem) (m1:mem) = H.elim_wand p1 p2 (heap_of_mem m) (heap_of_mem m1) //////////////////////////////////////////////////////////////////////////////// // Preorders and effects //////////////////////////////////////////////////////////////////////////////// module PP = Steel.Preorder let mem_evolves = fun (m0 m1:full_mem) -> H.heap_evolves (heap_of_mem m0) (heap_of_mem m1) /\ m0.ctr <= m1.ctr /\ lock_store_evolves m0.locks m1.locks (** See [Steel.Heap.is_frame_preserving]. We add in [lock_invariants] now *) let preserves_frame (e:inames) (pre post:slprop) (m0 m1:mem) = forall (frame:slprop). interp ((pre `star` frame) `star` locks_invariant e m0) m0 ==> (interp ((post `star` frame) `star` locks_invariant e m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) (** This is a version of MstTot with frame quantified, as part of preserves_frame *) effect MstTotNF (a:Type u#a) (except:inames) (expects:slprop u#1) (provides: a -> slprop u#1) = NMSTTotal.NMSTATETOT a (full_mem u#1) mem_evolves (requires fun m0 -> inames_ok except m0 /\ interp (expects `star` locks_invariant except m0) m0) (ensures fun m0 x m1 -> inames_ok except m1 /\ interp (provides x `star` locks_invariant except m1) m1 /\ preserves_frame except expects (provides x) m0 m1) //////////////////////////////////////////////////////////////////////////////// // Lifting heap actions //////////////////////////////////////////////////////////////////////////////// (** Heap actions come in two equivalent flavors: - one that take an explicit frame as argument (action_with_frame) - and one that quantify over all the frame We therefore define two lift routes: - a direct route for those with explicit frame - via MstTotNF for the rest *) let tot_pre_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = hmem_with_inv_except e fp -> (x:a & hmem_with_inv_except e (fp' x)) let tot_pre_action_nf = tot_pre_action_nf_except S.empty let ac_reasoning_for_m_frame_preserving (p q r:slprop u#a) (m:mem u#a) : Lemma (requires interp ((p `star` q) `star` r) m) (ensures interp (p `star` r) m) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_commutative p q; equiv_extensional_on_star (p `star` q) (q `star` p) r } (q `star` p) `star` r; (equiv) { star_associative q p r } q `star` (p `star` r); }; assert (interp (q `star` (p `star` r)) m); affine_star q (p `star` r) m let is_frame_preserving (#e:inames) (#a:Type u#b) (#fp:slprop u#a) (#fp':a -> slprop u#a) (f:tot_pre_action_nf_except e fp a fp') = forall (frame:slprop u#a) (m0:hmem_with_inv_except e (fp `star` frame)). (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = f:tot_pre_action_nf_except e fp a fp'{ is_frame_preserving f } let tot_action_nf = tot_action_nf_except S.empty let linv e (m:mem) = locks_invariant e m let hheap_of_hmem #fp #e (m:hmem_with_inv_except e fp) : h:H.hheap (fp `star` linv e m) { h `H.free_above_addr` m.ctr} = let h = heap_of_mem m in H.pure_interp (heap_ctr_valid m.ctr (heap_of_mem m)) h; h let hmem_of_hheap #e (#fp0 #fp1:slprop) (m:hmem_with_inv_except e fp0) (h:H.full_hheap (fp1 `star` linv e m) { h `Heap.free_above_addr` m.ctr }) : m1:hmem_with_inv_except e fp1{linv e m `equiv` linv e m1} = let m1 : mem = { m with heap = h } in assert (interp (fp1 `star` linv e m) m1); star_commutative fp1 (linv e m); assert (interp (linv e m `star` fp1) m1); assert (linv e m1 == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); assert (linv e m == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m)); H.pure_interp (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_of_mem m); assert (heap_ctr_valid m1.ctr (heap_of_mem m) <==> heap_ctr_valid m1.ctr (heap_of_mem m1)); H.pure_equiv (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_ctr_valid m1.ctr (heap_of_mem m1)); H.star_congruence (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m)); assert (linv e m `equiv` linv e m1); let _ = equiv_extensional_on_star (linv e m) (linv e m1) fp1 in assert ((linv e m `star` fp1) `equiv` (linv e m1 `star` fp1)); assert (interp (linv e m1 `star` fp1) m1); star_commutative (linv e m1) fp1; assert (interp (fp1 `star` linv e m1) m1); m1 let with_inv_except (m:mem) e (fp:slprop) = interp (fp `star` locks_invariant e m) m #push-options "--warn_error -271" let as_hprop (frame:slprop) (mp:mprop frame) : hp:H.hprop frame{forall m. mp (core_mem m) == hp (heap_of_mem m)} = let f = fun h -> mp (mem_of_heap h) in assert (forall m. mp (core_mem m) == f (heap_of_mem m)); let aux (m0:H.hheap frame) (m1:H.heap{H.disjoint m0 m1}) : Lemma (ensures (mem_of_heap (H.join m0 m1) == join (mem_of_heap m0) (mem_of_heap m1))) [SMTPat ()] = () in f let mprop_preservation_of_hprop_preservation (p:slprop) (m0 m1:mem) : Lemma (requires (forall (hp:H.hprop p). hp (heap_of_mem m0) == hp (heap_of_mem m1))) (ensures (forall (mp:mprop p). mp (core_mem m0) == mp (core_mem m1))) = let aux (mp:mprop p) : Lemma (mp (core_mem m0) == mp (core_mem m1)) [SMTPat()] = assert (as_hprop p mp (heap_of_mem m0) == as_hprop p mp (heap_of_mem m1)) in () let lift_heap_action (#fp:slprop) (#a:Type) (#fp':a -> slprop) (e:inames) ($f:H.action fp a fp') : tot_action_nf_except e fp a fp' = let g : tot_pre_action_nf_except e fp a fp' = fun m -> let h0 = hheap_of_hmem m in let (| x, h' |) = f h0 in (| x, hmem_of_hheap m h' |) in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in let h0 = hheap_of_hmem m0 in let (| x', h1 |) = f h0 in H.action_framing f (linv e m0) h0; assert (x == x'); star_associative fp frame (linv e m0); H.action_framing f (frame `star` linv e m0) h0; assert (H.interp ((fp' x) `star` (frame `star` linv e m0)) h1); star_associative (fp' x) frame (linv e m0); assert (H.interp ((fp' x `star` frame) `star` linv e m0) h1); let h1' : H.hheap ((fp' x `star` frame) `star` linv e m0) = h1 in assert (m1 == hmem_of_hheap m0 h1'); assert (with_inv_except m1 e (fp' x `star` frame)); assert (forall (hp:H.hprop frame). hp h0 == hp h1); mprop_preservation_of_hprop_preservation frame m0 m1; () in assert (is_frame_preserving g); g let frame_preserving_respects_preorder #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (m0:hmem_with_inv_except e fp) : Lemma (let (| x, m1 |) = f m0 in mem_evolves m0 m1) = let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1) = () in H.emp_unit fp; assert (interp (fp `star` linv e m0) m0); H.star_congruence (fp `star` emp) (linv e m0) fp (linv e m0); assert (interp ((fp `star` emp) `star` linv e m0) m0); aux emp m0 let lift_tot_action_nf #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') : MstTotNF a e fp fp' = let m0 = NMSTTotal.get () in let m0' : hmem_with_inv_except e fp = m0 in let r = f m0' in let (| x, m1 |) = r in let m1' : hmem_with_inv_except e (fp' x) = m1 in assert (is_frame_preserving f); assert (m1 == dsnd (f m0)); frame_preserving_respects_preorder f m0; NMSTTotal.put #_ #(mem_evolves) m1; x let lift_tot_action #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get #(full_mem) #_ () in ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); lift_tot_action_nf f (** Now defining the lift for heap actions with explicit frame *) let tot_action_with_frame_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = frame:slprop u#a -> m0:hmem_with_inv_except e (fp `star` frame) -> Pure (x:a & hmem_with_inv_except e (fp' x `star` frame)) (requires True) (ensures fun (| x, m1 |) -> mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_with_frame = tot_action_with_frame_except S.empty let lift_heap_action_with_frame (#fp:slprop u#a) (#a:Type u#b) (#fp':a -> slprop u#a) (e:inames) ($f:H.action_with_frame fp a fp') : tot_action_with_frame_except e fp a fp' = fun frame m0 -> let h0 = hheap_of_hmem m0 in calc (equiv) { fp `star` frame `star` locks_invariant e m0; (equiv) { star_associative fp frame (locks_invariant e m0) } fp `star` (frame `star` locks_invariant e m0); }; assert (H.interp (fp `star` frame `star` locks_invariant e m0) h0); assert (H.interp (fp `star` (frame `star` locks_invariant e m0)) h0); //key: apply the heap action with frame * locks_invariant e m0 let (| x, h1 |) = f (frame `star` locks_invariant e m0) h0 in calc (equiv) { fp' x `star` (frame `star` locks_invariant e m0); (equiv) { star_associative (fp' x) frame (locks_invariant e m0) } fp' x `star` frame `star` locks_invariant e m0; }; assert (H.interp (fp' x `star` (frame `star` locks_invariant e m0)) h1); assert (H.interp (fp' x `star` frame `star` locks_invariant e m0) h1); let m1 = hmem_of_hheap m0 h1 in assert (mem_evolves m0 m1); mprop_preservation_of_hprop_preservation (frame `star` locks_invariant e m0) m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)); (| x, m1 |) let lift_tot_action_with_frame #a #e #fp #fp' ($f:tot_action_with_frame_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in assert (inames_ok e m0); ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); let m0' : hmem_with_inv_except e fp = m0 in let r = f frame m0' in let (| x, m1 |) = r in ac_reasoning_for_m_frame_preserving (fp' x) frame (locks_invariant e m1) m1; assert (interp (fp' x `star` frame `star` locks_invariant e m1) m1); assert (interp (fp' x `star` locks_invariant e m1) m1); let m1' : hmem_with_inv_except e (fp' x) = m1 in NMSTTotal.put #_ #(mem_evolves) m1; x let sel_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.sel_action #a #pcm r v0)) let upd_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.upd_action #a #pcm r v0 v1)) let free_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.free_action #a #pcm r v0)) let split_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.split_action #a #pcm r v0 v1)) let gather_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.gather_action #a #pcm r v0 v1)) let weaken (p q r:slprop) (h:H.hheap (p `star` q) { H.stronger q r }) : H.hheap (p `star` r) = H.weaken p q r h; h let weaken_pure (q r: prop) : Lemma (requires (q ==> r)) (ensures H.stronger (H.pure q) (H.pure r)) = let aux (h:H.heap) : Lemma (ensures (H.interp (H.pure q) h ==> H.interp (H.pure r) h)) [SMTPat ()] = H.pure_interp q h; H.pure_interp r h in () let inc_ctr (#p:slprop) #e (m:hmem_with_inv_except e p) : m':hmem_with_inv_except e p{m'.ctr = m.ctr + 1 /\ H.stronger (linv e m) (linv e m')} = let m' : mem = { m with ctr = m.ctr + 1} in assert (interp (p `star` linv e m) m'); assert (linv e m == lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m)); assert (linv e m' == lock_store_invariant e m.locks `star` ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken_free_above (heap_of_mem m) m.ctr (m.ctr + 1); weaken_pure (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_ctr_valid (m.ctr + 1) (heap_of_mem m)); assert (H.stronger (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m))); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)); H.stronger_star (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken (p `star` lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)) (heap_of_mem m'); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity (m.ctr + 1) (heap_of_mem m)); let m' : hmem_with_inv_except e p = m' in m' let frame_related_mems (fp0 fp1:slprop u#a) e (m0:hmem_with_inv_except e fp0) (m1:hmem_with_inv_except e fp1) = forall (frame:slprop u#a). interp ((fp0 `star` frame) `star` linv e m0) m0 ==> interp ((fp1 `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) let refined_pre_action e (fp0:slprop) (a:Type) (fp1:a -> slprop) = m0:hmem_with_inv_except e fp0 -> Pure (x:a & hmem_with_inv_except e (fp1 x)) (requires True) (ensures fun (| x, m1 |) -> frame_related_mems fp0 (fp1 x) e m0 m1) let refined_pre_action_as_action (#fp0:slprop) (#a:Type) (#fp1:a -> slprop) #e ($f:refined_pre_action e fp0 a fp1) : tot_action_nf_except e fp0 a fp1 = let g : tot_pre_action_nf_except e fp0 a fp1 = fun m -> f m in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp0 `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp1 x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x', m1' |) = g m0 in let (| x, m1 |) = f m0 in assert (x == x' /\ m1 == m1') in g let alloc_action #a #pcm e x = let f : refined_pre_action e emp (ref a pcm) (fun r -> pts_to r x) = fun m0 -> (* NS: 9/29/22 I needed to annotate h : Heap.full_heap, for use with the Core checker which generates a guard for checking the implicit pattern "dot" term in the dependent pair pattern on the next line. That guard expects `h` to be a full_heap, which is it, because it is a projection of m0. However, this is not reflected in `h`'s type. So, the Core checker, which produces a guard for the pat_dot_term in isolation, cannot recheck the term. If we were to fold in the checking of pat_dot_terms and their guards with the rest of the VC, this would work. *) let h : Heap.full_heap = hheap_of_hmem m0 in let (|r, h'|) = H.extend #a #pcm x m0.ctr h in let m' : hmem_with_inv_except e emp = inc_ctr m0 in let h' : H.hheap (pts_to #a #pcm r x `star` linv e m') = weaken _ (linv e m0) (linv e m') h' in let m1 : hmem_with_inv_except e (pts_to #a #pcm r x) = hmem_of_hheap m' h' in assert (forall frame. H.frame_related_heaps h h' emp (pts_to #a #pcm r x) frame true); let aux (frame:slprop) : Lemma (requires interp ((emp `star` frame) `star` linv e m0) m0) (ensures interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) [SMTPat (emp `star` frame)] = star_associative emp frame (linv e m0); assert (H.interp (emp `star` (frame `star` linv e m0)) h); assert (H.interp (pts_to #a #pcm r x `star` (frame `star` linv e m0)) h'); star_associative (pts_to #a #pcm r x) frame (linv e m0); assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m0) h'); assert (H.stronger (linv e m0) (linv e m')); assert (H.equiv (linv e m') (linv e m1)); assert (H.stronger (linv e m0) (linv e m1)); let h' : H.hheap ((pts_to #a #pcm r x `star` frame) `star` linv e m1) = weaken _ (linv e m0) (linv e m1) h' in assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) h'); assert (forall (mp:H.hprop frame). mp h == mp h'); mprop_preservation_of_hprop_preservation frame m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) in assert (frame_related_mems emp (pts_to r x) e m0 m1); (| r, m1 |) in lift_tot_action (refined_pre_action_as_action f) let select_refine #a #p e r x f = lift_tot_action (lift_heap_action e (H.select_refine #a #p r x f)) let upd_gen #a #p e r x y f = lift_tot_action (lift_heap_action e (H.upd_gen_action r x y f)) //////////////////////////////////////////////////////////////////////////////// // witness / recall //////////////////////////////////////////////////////////////////////////////// let witnessed_ref #a #pcm (r:ref a pcm) (fact:property a) (m:full_mem) = H.witnessed_ref #a #pcm r fact (heap_of_mem m) let witnessed_ref_stability #a #pcm (r:ref a pcm) (fact:property a) : Lemma (requires FStar.Preorder.stable fact (Steel.Preorder.preorder_of_pcm pcm)) (ensures FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) = H.witnessed_ref_stability #a #pcm r fact let witnessed (#a:Type u#1) (#pcm:pcm a) (r:ref a pcm) (fact:property a) = W.witnessed _ mem_evolves (witnessed_ref r fact) let rearrange_pqr_prq (p q r:slprop) : Lemma (((p `star` q) `star` r) `equiv` ((p `star` r) `star` q)) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_associative p q r } p `star` (q `star` r); (equiv) { star_commutative q r; star_congruence p (q `star` r) p (r `star` q) } p `star` (r `star` q); (equiv) { star_associative p r q } (p `star` r) `star` q; } let preserves_frame_cong (e:inames) (p q:slprop) (r s:slprop) (m0 m1:mem) : Lemma (requires p `equiv` r /\ q `equiv` s /\ preserves_frame e p q m0 m1) (ensures preserves_frame e r s m0 m1) = let aux0 (p q r s:slprop) : Lemma (requires p `equiv` s) (ensures (((p `star` q) `star` r) `equiv` ((s `star` q) `star` r))) = star_congruence p q s q; star_congruence (p `star` q) r (s `star` q) r in let aux (frame:slprop) : Lemma (requires interp ((r `star` frame) `star` locks_invariant e m0) m0) (ensures interp ((s `star` frame) `star` locks_invariant e m1) m1 /\ interp ((p `star` frame) `star` locks_invariant e m0) m0) [SMTPat (r `star` frame)] = aux0 p frame (locks_invariant e m0) r; aux0 q frame (locks_invariant e m1) s; assert (((p `star` frame) `star` locks_invariant e m0) `equiv` ((r `star` frame) `star` locks_invariant e m0)); assert (interp ((p `star` frame) `star` locks_invariant e m0) m0); assert (interp ((q `star` frame) `star` locks_invariant e m1) m1); assert (((q `star` frame) `star` locks_invariant e m1) `equiv` ((s `star` frame) `star` locks_invariant e m1)); () in () let pure_true_equiv (p:slprop) : Lemma ((p `star` pure True) `equiv` p) = FStar.Classical.forall_intro (pure_star_interp p True); emp_unit p; assert ((p `star` pure True) `equiv` p) let preserves_frame_star_pure (e:inames) (p q:slprop) (r s:prop) (m:mem) : Lemma (requires r /\ s) (ensures preserves_frame e p q m m <==> preserves_frame e (p `star` pure r) (q `star` pure s) m m) = pure_equiv r True; star_congruence p (pure r) p (pure True); pure_equiv s True; star_congruence q (pure s) q (pure True); pure_true_equiv p; pure_true_equiv q; let fwd () : Lemma (requires preserves_frame e p q m m) (ensures preserves_frame e (p `star` pure r) (q `star` pure s) m m) [SMTPat ()] = preserves_frame_cong e p q (p `star` pure r) (q `star` pure s) m m in let bk () : Lemma (requires preserves_frame e (p `star` pure r) (q `star` pure s) m m) (ensures preserves_frame e p q m m) [SMTPat ()] = preserves_frame_cong e (p `star` pure r) (q `star` pure s) p q m m in () let witness (#a:Type) (#pcm:pcm a) (e:inames) (r:erased (ref a pcm)) (fact:stable_property pcm) (v:Ghost.erased a) (_:squash (forall z. compatible pcm v z ==> fact z)) (frame:slprop) : MstTot (witnessed r fact) e (pts_to r v) (fun _ -> pts_to r v) frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in let _ : unit = let hr : H.ref a pcm = r in let v' = H.sel_v hr v (heap_of_mem m0) in assert (interp (H.ptr hr) m0 /\ H.sel #a #pcm hr (heap_of_mem m0) == v'); assert (compatible pcm v v'); assert (fact v'); assert (witnessed_ref r fact m0); witnessed_ref_stability r fact; assert (FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) in let w = NMSTTotal.witness _ mem_evolves (witnessed_ref r fact) in w let recall (#a:Type u#1) (#pcm:pcm a) (#fact:property a) (e:inames) (r:erased (ref a pcm)) (v:Ghost.erased a) (w:witnessed r fact) (frame:slprop) = let m0 = NMSTTotal.get () in NMSTTotal.recall _ mem_evolves (witnessed_ref r fact) w; let hr : H.ref a pcm = r in assert (witnessed_ref r fact m0); let v1 = H.sel_v hr v (heap_of_mem m0) in assert (compatible pcm v v1); assert (H.sel hr (heap_of_mem m0) == v1); assert (fact v1); assert (interp ((pts_to r v `star` frame) `star` locks_invariant e m0) m0); emp_unit ((pts_to r v `star` frame) `star` locks_invariant e m0); pure_star_interp ((pts_to r v `star` frame) `star` locks_invariant e m0) (fact v1) m0; assert (interp (((pts_to r v `star` frame) `star` locks_invariant e m0) `star` pure (fact v1)) m0); rearrange_pqr_prq (pts_to r v `star` frame) (locks_invariant e m0) (pure (fact v1)); assert (interp (((pts_to r v `star` frame) `star` pure (fact v1)) `star` locks_invariant e m0) m0); rearrange_pqr_prq (pts_to r v) frame (pure (fact v1)); star_congruence ((pts_to r v `star` frame) `star` pure (fact v1)) (locks_invariant e m0) ((pts_to r v `star` pure (fact v1)) `star` frame) (locks_invariant e m0); Ghost.hide v1 let iname_for_p_mem (i:iname) (p:slprop) : W.s_predicate mem = fun m -> iname_for_p i p m.locks let iname_for_p_stable (i:iname) (p:slprop) : Lemma (W.stable full_mem mem_evolves (iname_for_p_mem i p)) = () let ( >--> ) (i:iname) (p:slprop) : Type0 = W.witnessed full_mem mem_evolves (iname_for_p_mem i p) let hmem_with_inv_equiv e (m:mem) (p:slprop) : Lemma (interp (p `star` linv e m) m <==> interp (p `star` lock_store_invariant e m.locks) m /\ heap_ctr_valid m.ctr (heap_of_mem m)) = calc (<==>) { interp (p `star` linv e m) m; (<==>) { H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) } interp ((p `star` lock_store_invariant e m.locks) `star` ctr_validity m.ctr (heap_of_mem m)) m; (<==>) { H.pure_star_interp (p `star` lock_store_invariant e m.locks) (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_of_mem m) } interp ((p `star` lock_store_invariant e m.locks) `star` emp) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); (<==>) { H.emp_unit (p `star` lock_store_invariant e m.locks) } interp (p `star` lock_store_invariant e m.locks) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); } let new_invariant_tot_action (e:inames) (p:slprop) (m0:hmem_with_inv_except e p{ e `inames_in` m0.locks }) : Pure (iname & hmem_with_inv_except e emp) (requires True) (ensures fun (i, m1) -> iname_for_p_mem i p m1 /\ frame_related_mems p emp e m0 m1 /\ mem_evolves m0 m1) = let (| i, l1 |) = extend_lock_store e m0.locks p in let m1 = { m0 with locks = l1 } in assert (lock_store_invariant e m1.locks == p `star` lock_store_invariant e m0.locks); calc (equiv) { linv e m1; (equiv) {} (lock_store_invariant e m1.locks `star` ctr_validity m1.ctr (heap_of_mem m1)); (equiv) {} ((p `star` lock_store_invariant e m0.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); (equiv) { H.star_associative p (lock_store_invariant e m0.locks) (ctr_validity m1.ctr (heap_of_mem m1)) } (p `star` (lock_store_invariant e m0.locks `star` ctr_validity m1.ctr (heap_of_mem m1))); (equiv) { } (p `star` linv e m0); }; assert (iname_for_p_mem i p m1); assert (lock_store_evolves m0.locks l1); assert (mem_evolves m0 m1); hmem_with_inv_equiv e m0 p; assert (interp (p `star` lock_store_invariant e m0.locks) m1); assert (interp (lock_store_invariant e m1.locks) m1); H.emp_unit (lock_store_invariant e m1.locks); H.star_commutative (lock_store_invariant e m1.locks) emp; assert (interp (emp `star` lock_store_invariant e m1.locks) m1); hmem_with_inv_equiv e m1 emp; let m1 : hmem_with_inv_except e emp = m1 in let aux (frame:slprop) : Lemma (requires interp ((p `star` frame) `star` linv e m0) m0) (ensures interp ((emp `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) <==> mp (core_mem m1))) [SMTPat (p `star` frame)] = assert (interp ((p `star` frame) `star` linv e m0) m1); calc (equiv) { ((p `star` frame) `star` linv e m0); (equiv) { H.star_commutative p frame; H.star_congruence (p `star` frame) (linv e m0) (frame `star` p) (linv e m0); H.star_associative frame p (linv e m0) } (frame `star` (p `star` linv e m0)); (equiv) { H.star_congruence frame (p `star` linv e m0) frame (linv e m1) } (frame `star` linv e m1); (equiv) { H.emp_unit (frame `star` linv e m1); H.star_commutative (frame `star` linv e m1) emp; H.star_associative emp frame (linv e m1) } ((emp `star` frame) `star` linv e m1); }; assert (interp ((emp `star` frame) `star` linv e m1) m1) in assert (frame_related_mems p emp e m0 m1); ( i, m1 ) let name_is_ok (i:iname) (m0:full_mem u#1) : prop = i < List.Tot.length m0.locks let witnessed_name_is_ok (i:iname) = W.witnessed full_mem mem_evolves (name_is_ok i) let pre_inv = i:erased iname & witnessed_name_is_ok i let inv (p:slprop u#1) = i:erased iname & witnessed_name_is_ok i & (i >--> p) let pre_inv_of_inv #p (i:inv p) = let (|i, w, _|) = i in (|i,w|) let name_of_pre_inv (i:pre_inv) = dfst i let rec recall_all (ctx:list pre_inv) : NMSTTotal.NMSTATETOT unit (full_mem u#1) mem_evolves (requires fun _ -> True) (ensures fun m0 _ m1 -> m0==m1 /\ (forall i. i `List.Tot.memP` ctx ==> name_is_ok (name_of_pre_inv i) m0)) = match ctx with | [] -> () | hd::tl -> let (| q, i |) = hd in let i : W.witnessed full_mem mem_evolves (name_is_ok q) = i in NMSTTotal.recall _ mem_evolves (name_is_ok q) i; recall_all tl let fresh_invariant (e:inames) (p:slprop) (ctx:list pre_inv) (frame:slprop) : MstTot (i:inv p { not (mem_inv e i) /\ fresh_wrt ctx (name_of_inv i)}) e p (fun _ -> emp) frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in recall_all ctx; ac_reasoning_for_m_frame_preserving p frame (locks_invariant e m0) m0; assert (interp (p `star` locks_invariant e m0) m0); let r = new_invariant_tot_action e p m0 in let ( i, m1 ) = r in assert (i == List.Tot.length m0.locks); assert (not (Set.mem i e)); assert (mem_evolves m0 m1); NMSTTotal.put #full_mem #mem_evolves m1; iname_for_p_stable i p; let w = NMSTTotal.witness full_mem mem_evolves (iname_for_p_mem i p) in let w0 = NMSTTotal.witness full_mem mem_evolves (name_is_ok i) in (| hide i, w0, w |) let new_invariant (e:inames) (p:slprop) (frame:slprop) : MstTot (inv p) e p (fun _ -> emp) frame (fun _ -> True) (fun _ _ _ -> True) = fresh_invariant e p [] frame let rearrange_invariant (p q r : slprop) (q0 q1:slprop) : Lemma (requires q `equiv` (q0 `star` q1)) (ensures (p `star` (q `star` r)) `equiv` ((q0 `star` p) `star` (q1 `star` r))) = calc (equiv) { p `star` (q `star` r); (equiv) { calc (equiv) { (q `star` r); (equiv) { star_congruence q r (q0 `star` q1) r } (q0 `star` q1) `star` r; }; star_congruence p (q `star` r) p ((q0 `star` q1) `star` r) } (p `star` ((q0 `star` q1) `star` r)); (equiv) { star_associative q0 q1 r; star_congruence p ((q0 `star` q1) `star` r) p (q0 `star` (q1 `star` r)); star_associative p q0 (q1 `star` r) } (p `star` q0) `star` (q1 `star` r); (equiv) { star_commutative p q0; star_congruence (p `star` q0) (q1 `star` r) (q0 `star` p) (q1 `star` r) } (q0 `star` p) `star` (q1 `star` r); } let preserves_frame_invariant (fp fp':slprop) (opened_invariants:inames) (p:slprop) (i:inv p{not (mem_inv opened_invariants i)}) (m0:hmem_with_inv_except (add_inv opened_invariants i) (p `star` fp)) (m1:mem) : Lemma (requires preserves_frame (set_add (name_of_inv i) opened_invariants) (p `star` fp) (p `star` fp') m0 m1 /\ interp (fp' `star` linv opened_invariants m1) m1 /\ inames_ok opened_invariants m1 /\ (lock_store_invariant opened_invariants m0.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks)) /\ (lock_store_invariant opened_invariants m1.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks))) (ensures preserves_frame opened_invariants fp fp' m0 m1) = let aux (frame:slprop) : Lemma (requires interp ((fp `star` frame) `star` linv opened_invariants m0) m0) (ensures interp ((fp' `star` frame) `star` linv opened_invariants m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) [SMTPat()] = rearrange_invariant (fp `star` frame) (lock_store_invariant opened_invariants m0.locks) (ctr_validity m0.ctr (heap_of_mem m0)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks); assert (interp ((p `star` (fp `star` frame)) `star` linv (set_add (name_of_inv i) opened_invariants) m0) m0); star_associative p fp frame; star_congruence (p `star` (fp `star` frame)) (linv (set_add (name_of_inv i) opened_invariants) m0) ((p `star` fp) `star` frame) (linv (set_add (name_of_inv i) opened_invariants) m0); assert (interp (((p `star` fp) `star` frame) `star` linv (set_add (name_of_inv i) opened_invariants) m0) m0); assert (interp (((p `star` fp') `star` frame) `star` linv (set_add (name_of_inv i) opened_invariants) m1) m1); star_associative p fp' frame; star_congruence ((p `star` fp') `star` frame) (linv (set_add (name_of_inv i) opened_invariants) m1) (p `star` (fp' `star` frame)) (linv (set_add (name_of_inv i) opened_invariants) m1); assert (interp ((p `star` (fp' `star` frame)) `star` linv (set_add (name_of_inv i) opened_invariants) m1) m1); rearrange_invariant (fp' `star` frame) (lock_store_invariant opened_invariants m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks); assert (interp ((fp' `star` frame) `star` linv opened_invariants m1) m1); () in () let equiv_ext_right (p q r:slprop) : Lemma (requires q `equiv` r) (ensures (p `star` q) `equiv` (p `star` r)) = calc (equiv) { p `star` q; (equiv) { star_commutative p q } q `star` p; (equiv) { equiv_extensional_on_star q r p } r `star` p; (equiv) { star_commutative p r } p `star` r; } let with_inv_helper (fp frame ls1 ctr p ls2:slprop) : Lemma (requires ls1 `equiv` (p `star` ls2)) (ensures (fp `star` frame `star` (ls1 `star` ctr)) `equiv` (p `star` fp `star` frame `star` (ls2 `star` ctr))) = calc (equiv) { ls1 `star` ctr; (equiv) { equiv_extensional_on_star ls1 (p `star` ls2) ctr } p `star` ls2 `star` ctr; }; calc (equiv) { p `star` ls2 `star` ctr; (equiv) { star_associative p ls2 ctr } p `star` (ls2 `star` ctr); }; calc (equiv) { fp `star` frame `star` p; (equiv) { star_commutative (fp `star` frame) p } p `star` (fp `star` frame); (equiv) { star_associative p fp frame } p `star` fp `star` frame; }; calc (equiv) { fp `star` frame `star` (ls1 `star` ctr); (equiv) { equiv_ext_right (fp `star` frame) (ls1 `star` ctr) (p `star` ls2 `star` ctr) } (fp `star` frame) `star` (p `star` ls2 `star` ctr); (equiv) { equiv_ext_right (fp `star` frame) (p `star` ls2 `star` ctr) (p `star` (ls2 `star` ctr)) } (fp `star` frame) `star` (p `star` (ls2 `star` ctr)); (equiv) { star_associative (fp `star` frame) p (ls2 `star` ctr) } (fp `star` frame `star` p) `star` (ls2 `star` ctr); (equiv) { equiv_extensional_on_star (fp `star` frame `star` p) (p `star` fp `star` frame) (ls2 `star` ctr) } (p `star` fp `star` frame) `star` (ls2 `star` ctr); } let token_of_inv #p (i:inv p) : (name_of_inv i >--> p) = let (| _, _, tok |) = i in tok let with_invariant (#a:Type) (#fp:slprop) (#fp':a -> slprop) (#opened_invariants:inames) (#p:slprop) (i:inv p{not (mem_inv opened_invariants i)}) (f:action_except a (add_inv opened_invariants i) (p `star` fp) (fun x -> p `star` fp' x)) (frame:slprop) : MstTot a opened_invariants fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in NMSTTotal.recall _ mem_evolves (iname_for_p_mem (name_of_inv i) p) (token_of_inv i); assert (iname_for_p (name_of_inv i) p m0.locks); assert (interp (fp `star` frame `star` locks_invariant opened_invariants m0) m0); assert (interp (fp `star` frame `star` (lock_store_invariant opened_invariants m0.locks `star` ctr_validity m0.ctr (heap_of_mem m0))) m0); move_invariant opened_invariants m0.locks p (name_of_inv i); assert (lock_store_invariant opened_invariants m0.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks)); with_inv_helper fp frame (lock_store_invariant opened_invariants m0.locks) (ctr_validity m0.ctr (heap_of_mem m0)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks); assert (interp (p `star` fp `star` frame `star` locks_invariant (set_add (name_of_inv i) opened_invariants) m0) m0); let r = f frame in let m1 : full_mem = NMSTTotal.get () in assert (interp (p `star` fp' r `star` frame `star` locks_invariant (set_add (name_of_inv i) opened_invariants) m1) m1); assert (interp (p `star` fp' r `star` frame `star` (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks `star` ctr_validity m1.ctr (heap_of_mem m1))) m1); NMSTTotal.recall _ mem_evolves (iname_for_p_mem (name_of_inv i) p) (token_of_inv i); move_invariant opened_invariants m1.locks p (name_of_inv i); assert (lock_store_invariant opened_invariants m1.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks)); with_inv_helper (fp' r) frame (lock_store_invariant opened_invariants m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks); assert (interp (fp' r `star` frame `star` locks_invariant opened_invariants m1) m1); assert (inames_ok opened_invariants m1); r let equiv_pqrs_p_qr_s (p q r s:slprop) : Lemma ((p `star` q `star` r `star` s) `equiv` (p `star` (q `star` r) `star` s)) = star_associative p q r; equiv_extensional_on_star (p `star` q `star` r) (p `star` (q `star` r)) s let frame (#a:Type) (#opened_invariants:inames) (#pre:slprop) (#post:a -> slprop) (#req:mprop pre) (#ens:mprop2 pre post) (frame:slprop) ($f:action_except_full a opened_invariants pre post req ens) (frame0:slprop) : MstTot a opened_invariants (pre `star` frame) (fun x -> post x `star` frame) frame0 req ens = let m0 : full_mem = NMSTTotal.get () in equiv_pqrs_p_qr_s pre frame frame0 (linv opened_invariants m0); assert (interp (pre `star` frame `star` frame0 `star` linv opened_invariants m0) m0); assert (interp (pre `star` (frame `star` frame0) `star` linv opened_invariants m0) m0); let x = f (frame `star` frame0) in let m1 : full_mem = NMSTTotal.get () in equiv_pqrs_p_qr_s (post x) frame frame0 (linv opened_invariants m1); assert (interp (post x `star` (frame `star` frame0) `star` linv opened_invariants m1) m1); assert (interp (post x `star` frame `star` frame0 `star` linv opened_invariants m1) m1); x let change_slprop (#opened_invariants:inames) (p q:slprop) (proof: (m:mem -> Lemma (requires interp p m) (ensures interp q m))) = let proof (h:H.heap) : Lemma (requires H.interp p h) (ensures H.interp q h) = proof (mem_of_heap h) in lift_tot_action (lift_heap_action opened_invariants (Steel.Heap.change_slprop p q proof)) (* This module reuses is_frame_monotonic from Heap, but does not expose that to clients, so we need this lemma to typecheck witness_h_exists below. *) let relate_frame_monotonic_1 #a p : Lemma (requires (H.is_frame_monotonic p)) (ensures (is_frame_monotonic p)) = () let relate_frame_monotonic_2 #a p : Lemma (requires (is_frame_monotonic p)) (ensures (H.is_frame_monotonic p)) = let aux (x y : a) (h : H.heap) (f : H.slprop) : Lemma (requires (H.interp (p x `H.star` f) h /\ H.interp (p y) h)) (ensures (H.interp (p y `H.star` f) h)) = let m = mem_of_heap h in assert (interp (p x `star` f) m); assert (interp (p y) m); assert (interp (p y `star` f) m) in Classical.forall_intro_4 (fun x y h f -> Classical.move_requires (aux x y h) f) let witness_h_exists #opened_invariants #a p = lift_tot_action_with_frame (lift_heap_action_with_frame opened_invariants (H.witness_h_exists p)) let lift_h_exists #opened_invariants p = lift_tot_action (lift_heap_action opened_invariants (H.lift_h_exists p)) let elim_pure #opened_invariants p = lift_tot_action (lift_heap_action opened_invariants (H.elim_pure p))

{ "checked_file": "/", "dependencies": [ "Steel.Preorder.fst.checked", "Steel.Heap.fsti.checked", "prims.fst.checked", "FStar.Witnessed.Core.fsti.checked", "FStar.Set.fsti.checked", "FStar.Preorder.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.PCM.fst.checked", "FStar.NMSTTotal.fst.checked", "FStar.List.Tot.fst.checked", "FStar.IndefiniteDescription.fsti.checked", "FStar.Ghost.fsti.checked", "FStar.FunctionalExtensionality.fsti.checked", "FStar.Classical.Sugar.fsti.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Steel.Memory.fst" }

[ { "abbrev": true, "full_module": "Steel.Preorder", "short_module": "PP" }, { "abbrev": true, "full_module": "FStar.Witnessed.Core", "short_module": "W" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": true, "full_module": "Steel.Heap", "short_module": "H" }, { "abbrev": false, "full_module": "FStar.FunctionalExtensionality", "short_module": null }, { "abbrev": true, "full_module": "FStar.FunctionalExtensionality", "short_module": "F" }, { "abbrev": true, "full_module": "FStar.Universe", "short_module": "U" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": false, "full_module": "FStar.PCM", "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.Memory.ref a pcm -> x: a -> y: a -> m: Steel.Memory.mem -> FStar.Pervasives.Lemma (requires Steel.Memory.interp (Steel.Memory.pts_to r x) m /\ Steel.Memory.interp (Steel.Memory.pts_to r y) m) (ensures FStar.PCM.joinable pcm x y)

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "FStar.PCM.pcm", "Steel.Memory.ref", "Steel.Memory.mem", "Steel.Heap.pts_to_join", "Steel.Memory.heap_of_mem", "Prims.unit", "Prims.l_and", "Steel.Memory.interp", "Steel.Memory.pts_to", "Prims.squash", "FStar.PCM.joinable", "Prims.Nil", "FStar.Pervasives.pattern" ]

[]

true

false

true

false

let pts_to_join (#a: Type) (#pcm: pcm a) (r: ref a pcm) (x y: a) (m: mem) : Lemma (requires (interp (pts_to r x) m /\ interp (pts_to r y) m)) (ensures (joinable pcm x y)) =

H.pts_to_join #a #pcm r x y (heap_of_mem m)

false

Platform.Bytes.fst

Platform.Bytes.length

val length : bytes -> Tot nat

let length b = Seq.length b

{ "file_name": "ucontrib/Platform/fst/Platform.Bytes.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }

{ "end_col": 27, "end_line": 71, "start_col": 0, "start_line": 71 }

(* Copyright 2008-2018 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 Platform.Bytes assume val repr_bytes : nat -> GTot (n:nat{n>0}) (* Integer literals are currently extracted to int32, rather than bigint, so the definition below breaks extraction: Unexpected error; please file a bug report, ideally with a minimized version of the source program that triggered the error. int_of_string Also, defining repr_bytes n <= 8 for all n is dubious *) (* let repr_bytes n = if n < 256 then 1 else if n < 65536 then 2 else if n < 16777216 then 3 else if n < 4294967296 then 4 else if n < 1099511627776 then 5 else if n < 281474976710656 then 6 else if n < 72057594037927936 then 7 else 8 *) (* NS: The two assumes below were previously defined as axioms. They are evil! They pollute the global environment and slow down verification enormously. I've made them assumed lemmas; if you want to make use of these axioms, call the lemmas as needed in the context. *) assume val lemma_repr_bytes_values: n:nat -> Lemma ( ( n < 256 <==> repr_bytes n = 1 ) /\ ( (n >= 256 /\ n < 65536) <==> repr_bytes n = 2 ) /\ ( (n >= 65536 /\ n < 16777216) <==> repr_bytes n = 3 ) /\ ( (n >= 16777216 /\ n < 4294967296) <==> repr_bytes n = 4 ) /\ ( (n >= 4294967296 /\ n < 1099511627776) <==> repr_bytes n = 5 ) /\ ( (n >= 1099511627776 /\ n < 281474976710656) <==> repr_bytes n = 6 ) /\ ( (n >= 281474976710656 /\ n < 72057594037927936) <==> repr_bytes n = 7 ) /\ ( (n >= 72057594037927936 /\ n < 18446744073709551616) <==> repr_bytes n = 8 ) ) unfold let byte:Type0 = FStar.UInt8.t type cbytes = string (* abstract *) type bytes = Seq.seq byte (* AR: adding this *) assume HasEq_bytes: hasEq bytes val seq_of_bytes: b:bytes -> GTot (Seq.seq byte) let seq_of_bytes b = b val op_At_Bar: bytes -> bytes -> Tot bytes let op_At_Bar (b1:bytes) (b2:bytes) = Seq.append b1 b2 (*@ function val B : (bytes -> byte array) @*) (*@ assume val length : (b:bytes -> (l:nat){Length (b) = l}) @*)

{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.UInt8.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked" ], "interface_file": false, "source_file": "Platform.Bytes.fst" }

[ { "abbrev": false, "full_module": "Platform", "short_module": null }, { "abbrev": false, "full_module": "Platform", "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

b: Platform.Bytes.bytes -> Prims.nat

Prims.Tot

[ "total" ]

[]

[ "Platform.Bytes.bytes", "FStar.Seq.Base.length", "Platform.Bytes.byte", "Prims.nat" ]

[]

false

true

false

let length b =

Seq.length b

false

Steel.Memory.fst

Steel.Memory.change_slprop

val change_slprop (#opened_invariants:inames) (p q:slprop) (proof: (m:mem -> Lemma (requires interp p m) (ensures interp q m))) : action_except unit opened_invariants p (fun _ -> q)

let change_slprop (#opened_invariants:inames) (p q:slprop) (proof: (m:mem -> Lemma (requires interp p m) (ensures interp q m))) = let proof (h:H.heap) : Lemma (requires H.interp p h) (ensures H.interp q h) = proof (mem_of_heap h) in lift_tot_action (lift_heap_action opened_invariants (Steel.Heap.change_slprop p q proof))

{ "file_name": "lib/steel/Steel.Memory.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 93, "end_line": 1530, "start_col": 0, "start_line": 1522 }

(* 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.Memory module F = FStar.FunctionalExtensionality open FStar.FunctionalExtensionality open FStar.PCM module H = Steel.Heap noeq type lock_state : Type u#(a + 1) = | Invariant : inv:H.slprop u#a -> lock_state let lock_store : Type u#(a+1) = list (lock_state u#a) noeq type mem : Type u#(a + 1) = { ctr: nat; heap: H.heap u#a; locks: lock_store u#a; } let heap_of_mem (x:mem) : H.heap = x.heap let mem_of_heap (h:H.heap) : mem = { ctr = 0; heap = h; locks = [] } let mem_set_heap (m:mem) (h:H.heap) : mem = { ctr = m.ctr; heap = h; locks = m.locks; } let core_mem (m:mem) : mem = mem_of_heap (heap_of_mem m) let core_mem_invol m = () let disjoint (m0 m1:mem u#h) : prop = m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks let disjoint_sym m0 m1 = () let join m0 m1 = { ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = m0.locks } let join_commutative m0 m1 = H.join_commutative m0.heap m1.heap let disjoint_join m0 m1 m2 = H.disjoint_join m0.heap m1.heap m2.heap let join_associative m0 m1 m2 = H.join_associative m0.heap m1.heap m2.heap let slprop = H.slprop let interp p m = H.interp p m.heap let equiv p1 p2 = forall m. interp p1 m <==> interp p2 m let slprop_extensionality p q = assert (forall m. interp p m <==> interp q m); let aux (h:H.heap) : Lemma (H.interp p h <==> H.interp q h) [SMTPat (H.interp p h)] = let m : mem = { ctr = 0; heap = h; locks = [] } in assert (interp p m <==> interp q m) in assert (forall h. H.interp p h <==> H.interp q h); Steel.Heap.slprop_extensionality p q let reveal_equiv p1 p2 = () let core_ref = H.core_ref let core_ref_null = H.core_ref_null let core_ref_is_null r = H.core_ref_is_null r let emp : slprop u#a = H.emp let pure = H.pure let pts_to = H.pts_to let h_and = H.h_and let h_or = H.h_or let star = H.star let wand = H.wand let h_exists = H.h_exists let h_forall = H.h_forall //////////////////////////////////////////////////////////////////////////////// //properties of equiv //////////////////////////////////////////////////////////////////////////////// let equiv_symmetric (p1 p2:slprop u#a) = H.equiv_symmetric p1 p2 #push-options "--warn_error -271" let equiv_heap_iff_equiv (p1 p2:slprop u#a) : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat (equiv p1 p2)] = let aux_lr () : Lemma (requires H.equiv p1 p2) (ensures equiv p1 p2) [SMTPat ()] = () in let aux_rl_helper1 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p1 h) (ensures H.interp p2 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl_helper2 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p2 h) (ensures H.interp p1 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl () : Lemma (requires equiv p1 p2) (ensures H.equiv p1 p2) [SMTPat ()] = () in () let equiv_heap_iff_equiv_forall () : Lemma (ensures (forall p1 p2. H.equiv p1 p2 <==> equiv p1 p2)) = let aux p1 p2 : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat ()] = equiv_heap_iff_equiv p1 p2 in () #pop-options let equiv_extensional_on_star (p1 p2 p3:slprop u#a) = equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3 let emp_unit p = H.emp_unit p let intro_emp m = H.intro_emp (heap_of_mem m) let pure_equiv p q = H.pure_equiv p q let pure_interp q m = H.pure_interp q (heap_of_mem m) let pure_star_interp p q m = H.pure_star_interp p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// //pts_to //////////////////////////////////////////////////////////////////////////////// let pts_to_compatible #a #pcm x v0 v1 m = H.pts_to_compatible #a #pcm x v0 v1 (heap_of_mem m) let pts_to_compatible_equiv #a #pcm x v0 v1 = H.pts_to_compatible_equiv #a #pcm x v0 v1 let pts_to_not_null #a #pcm x v m = H.pts_to_not_null #a #pcm x v (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // star //////////////////////////////////////////////////////////////////////////////// let intro_star p q mp mq = H.intro_star p q (heap_of_mem mp) (heap_of_mem mq) let elim_star p q m = let h = heap_of_mem m in H.elim_star p q h; assert (exists hl hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr); let hl = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hl -> exists hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let hr = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hr -> H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let ml = mem_set_heap m hl in let mr = mem_set_heap m hr in assert (disjoint ml mr); assert (m == join ml mr); assert (interp p ml); assert (interp q mr); () let interp_star (p q: slprop) (m: mem) : Lemma (interp (p `star` q) m <==> (exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m)) = let left = interp (p `star` q) m in let right = exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m in let f () : Lemma (requires left) (ensures right) = elim_star p q m in let g () : Lemma (requires right) (ensures left) = Classical.exists_elim left #_ #(fun mp -> exists (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mp -> Classical.exists_elim left #_ #(fun mq -> disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mq -> intro_star p q mp mq ) ) in Classical.move_requires f (); Classical.move_requires g () let star_commutative (p1 p2:slprop) = H.star_commutative p1 p2 let star_associative (p1 p2 p3:slprop) = H.star_associative p1 p2 p3 let star_congruence (p1 p2 p3 p4:slprop) = equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4 let affine_star (p q:slprop) (m:mem) = H.affine_star p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // Invariants on the lock store //////////////////////////////////////////////////////////////////////////////// let iname = nat module S = FStar.Set module L = FStar.List.Tot module W = FStar.Witnessed.Core let rec lock_store_invariant (e:inames) (l:lock_store u#a) : slprop u#a = let current_addr = L.length l - 1 in match l with | [] -> emp | Invariant p :: tl -> if current_addr `S.mem` e then lock_store_invariant e tl else p `star` lock_store_invariant e tl let lock_i (i:iname) (l:lock_store { i < L.length l }) = let ix = L.length l - i - 1 in L.index l ix let iname_for_p (i:iname) (p:slprop) : W.s_predicate lock_store = fun l -> i < L.length l /\ (lock_i i l).inv == p let lock_store_evolves : FStar.Preorder.preorder lock_store = fun (l1 l2 : lock_store) -> L.length l2 >= L.length l1 /\ (forall (i:nat{i < L.length l1}). (lock_i i l1).inv == (lock_i i l2).inv) let inames_in (e:inames) (l:lock_store) : prop = forall i. Set.mem i e ==> i < L.length l let inames_ok e m = inames_in e m.locks let inames_ok_empty m = () let extend_lock_store (e:inames) (l:lock_store{e `inames_in` l}) (p:slprop) : i:iname & l':lock_store { lock_store_invariant e l' == p `star` lock_store_invariant e l /\ iname_for_p i p l' } = (| L.length l, Invariant p :: l |) let set_add (i:iname) (s:inames) = Set.union (Set.singleton i) s let rec move_invariant (e:inames) (l:lock_store) (p:slprop) (i:iname{iname_for_p i p l /\ ~(i `Set.mem` e)}) : Lemma (H.equiv (lock_store_invariant e l) (p `star` lock_store_invariant (set_add i e) l)) = let rec aux (i:iname) (m:lock_store) : Lemma (requires i >= L.length m) (ensures (lock_store_invariant e m `H.equiv` lock_store_invariant (set_add i e) m)) = match m with | [] -> () | Invariant p::tl -> aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl) in let current_addr = L.length l - 1 in match l with | [] -> () | Invariant q::tl -> if i = current_addr then begin assert (lock_store_invariant e l == p `star` lock_store_invariant e tl); aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl); () end else begin move_invariant e tl p i; assert (lock_store_invariant e tl `equiv` (p `star` lock_store_invariant (set_add i e) tl)); H.star_congruence q (lock_store_invariant e tl) q (p `star` lock_store_invariant (set_add i e) tl); if Set.mem current_addr e then () else begin let r = lock_store_invariant (set_add i e) tl in assert (lock_store_invariant e l `equiv` (q `star` (p `star` r))); H.star_associative q p r; H.star_commutative q p; H.star_congruence (q `star` p) r (p `star` q) r; H.star_associative p q r end end let heap_ctr_valid (ctr:nat) (h:H.heap u#a) : prop = h `H.free_above_addr` ctr let ctr_validity (ctr:nat) (h:H.heap) : slprop = H.pure (heap_ctr_valid ctr h) let locks_invariant (e:inames) (m:mem u#a) : slprop u#a = lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m) let full_mem_pred (m:mem) = H.full_heap_pred (heap_of_mem m) (***** Following lemmas are needed in Steel.Effect *****) let core_mem_interp (hp:slprop u#a) (m:mem u#a) = () let interp_depends_only_on (hp:slprop u#a) = H.interp_depends_only_on hp let a_mem_prop_as_a_heap_prop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (H.a_heap_prop u#a) = let g (h: H.heap u#a) : Tot prop = interp sl (mem_of_heap h) /\ f (mem_of_heap h) in let phi0 (h0 h1: H.heap u#a) : Lemma (requires (g h0 /\ H.disjoint h0 h1)) (ensures (g h0 /\ H.disjoint h0 h1 /\ g (H.join h0 h1))) = assert (mem_of_heap (H.join h0 h1) == mem_of_heap h0 `join` mem_of_heap h1); interp_depends_only_on sl in let phi1 (h0 h1: H.heap u#a) : Lemma (ensures ((g h0 /\ H.disjoint h0 h1) ==> g (H.join h0 h1))) = Classical.move_requires (phi0 h0) h1 in Classical.forall_intro_2 phi1; g let refine_slprop sl f = H.as_slprop (a_mem_prop_as_a_heap_prop sl f) let interp_refine_slprop sl f m = assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_mem m)) let dep_hprop (s: slprop) (f: (hmem s -> Tot slprop)) (h: H.heap) : Tot prop = exists (h1: H.heap) . exists (h2: H.heap) . interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 let dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq' : squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h')) = let p2 (h h1 h2: H.heap) : Tot prop = interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 in let p1 (h h1: H.heap) : Tot prop = (exists h2 . p2 h h1 h2) in let h1 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p1 h) in let h2 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p2 h h1) in H.disjoint_join h' h1 h2; assert (H.disjoint h2 h'); let h2' = H.join h2 h' in H.join_commutative h2 h' ; assert (h2' == H.join h' h2); assert (H.disjoint h1 h2'); assert (mem_of_heap h2' == mem_of_heap h2 `join` mem_of_heap h'); interp_depends_only_on (f (mem_of_heap h1)); assert (interp (f (mem_of_heap h1)) (mem_of_heap h2')); H.join_commutative h1 h2; H.join_associative h' h2 h1; H.join_commutative h' h; H.join_commutative h2' h1; assert (H.join h h' == h1 `H.join` h2') let impl_intro_gen (#p: Type0) (#q: Type0) ($prf: (squash p -> Lemma (q ))) : Lemma (p ==> q) = Classical.impl_intro_gen #p #(fun _ -> q) prf let dep_hprop_is_affine1 (s: slprop) (f: (hmem s -> Tot slprop)) (h0 h1: H.heap) : Lemma ((dep_hprop s f h0 /\ H.disjoint h0 h1) ==> (H.disjoint h0 h1 /\ dep_hprop s f (H.join h0 h1))) = impl_intro_gen (dep_hprop_is_affine0 s f h0 h1) let dep_hprop_is_affine (s: slprop) (f: (hmem s -> Tot slprop)) : Lemma (H.heap_prop_is_affine (dep_hprop s f)) = Classical.forall_intro_2 (dep_hprop_is_affine1 s f) let sdep (s: slprop) (f: (hmem s -> Tot slprop)) : Tot slprop = dep_hprop_is_affine s f; H.as_slprop (dep_hprop s f) let interp_sdep (s: slprop) (f: (hmem s -> Tot slprop)) (m: mem) : Lemma (requires (dep_slprop_is_affine s f)) (ensures ( interp (sdep s f) m <==> (exists m1 m2 . interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) )) = dep_hprop_is_affine s f; assert (forall m1 m2 . (interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) ==> ( interp s (mem_of_heap m1.heap) /\ interp (f (mem_of_heap m1.heap)) (mem_of_heap m2.heap) /\ H.disjoint m1.heap m2.heap /\ H.join m1.heap m2.heap == m.heap )); interp_depends_only_on s; Classical.forall_intro (fun m -> interp_depends_only_on (f m)); assert (forall h1 h2 . (interp s (mem_of_heap h1) /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ H.disjoint h1 h2 /\ H.join h1 h2 == m.heap) ==> ( core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ interp s (core_mem (mem_of_heap h1)) /\ interp s (mem_set_heap m h1) /\ core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ f (mem_set_heap m h1) `equiv` f (mem_of_heap h1) /\ interp (f (mem_set_heap m h1)) (mem_of_heap h2) /\ interp (f (mem_set_heap m h1)) (mem_set_heap m h2) /\ disjoint (mem_set_heap m h1) (mem_set_heap m h2) /\ join (mem_set_heap m h1) (mem_set_heap m h2) == m )); () let h_exists_cong (#a:Type) (p q : a -> slprop) : Lemma (requires (forall x. p x `equiv` q x)) (ensures (h_exists p `equiv` h_exists q)) = equiv_heap_iff_equiv_forall (); H.h_exists_cong p q let intro_h_exists #a x p m = H.intro_h_exists x p (heap_of_mem m) let elim_h_exists (#a:_) (p:a -> slprop) (m:mem) = H.elim_h_exists p (heap_of_mem m) let intro_h_forall (#a:_) (p:a -> slprop) (m:mem) = H.intro_h_forall p (heap_of_mem m) let elim_h_forall (#a:_) (p:a -> slprop) (m:mem) (x:a) = H.elim_h_forall p (heap_of_mem m) x let intro_h_and (p q: slprop) (m:mem) = H.intro_h_and p q (heap_of_mem m) let elim_h_and (p q: slprop) (m:mem) = H.elim_h_and p q (heap_of_mem m) let intro_h_or_left (p q: slprop) (m:mem) = H.intro_h_or_left p q (heap_of_mem m) let intro_h_or_right (p q: slprop) (m:mem) = H.intro_h_or_right p q (heap_of_mem m) let elim_h_or (p q: slprop) (m:mem) = H.elim_h_or p q (heap_of_mem m) let intro_wand (p1 p2: slprop u#a) (m:mem) = introduce (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)) ==> interp (wand p1 p2) m with _. ( assert (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)); H.intro_wand p1 p2 (heap_of_mem m); let h = heap_of_mem m in assert ((forall h1. h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) ==> H.interp (wand p1 p2) h); introduce forall h1. (h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) with ( introduce (h `H.disjoint` h1 /\ H.interp p1 h1) ==> H.interp p2 (H.join h h1) with _. ( assert (h `H.disjoint` h1); let m1 = { ctr = m.ctr; heap = h1; locks = m.locks } in assert (m `disjoint` m1) ) ) ) (** Eliminating a wand by proving a heap that satisfies the LHS **) let elim_wand (p1 p2: slprop u#a) (m:mem) (m1:mem) = H.elim_wand p1 p2 (heap_of_mem m) (heap_of_mem m1) //////////////////////////////////////////////////////////////////////////////// // Preorders and effects //////////////////////////////////////////////////////////////////////////////// module PP = Steel.Preorder let mem_evolves = fun (m0 m1:full_mem) -> H.heap_evolves (heap_of_mem m0) (heap_of_mem m1) /\ m0.ctr <= m1.ctr /\ lock_store_evolves m0.locks m1.locks (** See [Steel.Heap.is_frame_preserving]. We add in [lock_invariants] now *) let preserves_frame (e:inames) (pre post:slprop) (m0 m1:mem) = forall (frame:slprop). interp ((pre `star` frame) `star` locks_invariant e m0) m0 ==> (interp ((post `star` frame) `star` locks_invariant e m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) (** This is a version of MstTot with frame quantified, as part of preserves_frame *) effect MstTotNF (a:Type u#a) (except:inames) (expects:slprop u#1) (provides: a -> slprop u#1) = NMSTTotal.NMSTATETOT a (full_mem u#1) mem_evolves (requires fun m0 -> inames_ok except m0 /\ interp (expects `star` locks_invariant except m0) m0) (ensures fun m0 x m1 -> inames_ok except m1 /\ interp (provides x `star` locks_invariant except m1) m1 /\ preserves_frame except expects (provides x) m0 m1) //////////////////////////////////////////////////////////////////////////////// // Lifting heap actions //////////////////////////////////////////////////////////////////////////////// (** Heap actions come in two equivalent flavors: - one that take an explicit frame as argument (action_with_frame) - and one that quantify over all the frame We therefore define two lift routes: - a direct route for those with explicit frame - via MstTotNF for the rest *) let tot_pre_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = hmem_with_inv_except e fp -> (x:a & hmem_with_inv_except e (fp' x)) let tot_pre_action_nf = tot_pre_action_nf_except S.empty let ac_reasoning_for_m_frame_preserving (p q r:slprop u#a) (m:mem u#a) : Lemma (requires interp ((p `star` q) `star` r) m) (ensures interp (p `star` r) m) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_commutative p q; equiv_extensional_on_star (p `star` q) (q `star` p) r } (q `star` p) `star` r; (equiv) { star_associative q p r } q `star` (p `star` r); }; assert (interp (q `star` (p `star` r)) m); affine_star q (p `star` r) m let is_frame_preserving (#e:inames) (#a:Type u#b) (#fp:slprop u#a) (#fp':a -> slprop u#a) (f:tot_pre_action_nf_except e fp a fp') = forall (frame:slprop u#a) (m0:hmem_with_inv_except e (fp `star` frame)). (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = f:tot_pre_action_nf_except e fp a fp'{ is_frame_preserving f } let tot_action_nf = tot_action_nf_except S.empty let linv e (m:mem) = locks_invariant e m let hheap_of_hmem #fp #e (m:hmem_with_inv_except e fp) : h:H.hheap (fp `star` linv e m) { h `H.free_above_addr` m.ctr} = let h = heap_of_mem m in H.pure_interp (heap_ctr_valid m.ctr (heap_of_mem m)) h; h let hmem_of_hheap #e (#fp0 #fp1:slprop) (m:hmem_with_inv_except e fp0) (h:H.full_hheap (fp1 `star` linv e m) { h `Heap.free_above_addr` m.ctr }) : m1:hmem_with_inv_except e fp1{linv e m `equiv` linv e m1} = let m1 : mem = { m with heap = h } in assert (interp (fp1 `star` linv e m) m1); star_commutative fp1 (linv e m); assert (interp (linv e m `star` fp1) m1); assert (linv e m1 == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); assert (linv e m == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m)); H.pure_interp (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_of_mem m); assert (heap_ctr_valid m1.ctr (heap_of_mem m) <==> heap_ctr_valid m1.ctr (heap_of_mem m1)); H.pure_equiv (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_ctr_valid m1.ctr (heap_of_mem m1)); H.star_congruence (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m)); assert (linv e m `equiv` linv e m1); let _ = equiv_extensional_on_star (linv e m) (linv e m1) fp1 in assert ((linv e m `star` fp1) `equiv` (linv e m1 `star` fp1)); assert (interp (linv e m1 `star` fp1) m1); star_commutative (linv e m1) fp1; assert (interp (fp1 `star` linv e m1) m1); m1 let with_inv_except (m:mem) e (fp:slprop) = interp (fp `star` locks_invariant e m) m #push-options "--warn_error -271" let as_hprop (frame:slprop) (mp:mprop frame) : hp:H.hprop frame{forall m. mp (core_mem m) == hp (heap_of_mem m)} = let f = fun h -> mp (mem_of_heap h) in assert (forall m. mp (core_mem m) == f (heap_of_mem m)); let aux (m0:H.hheap frame) (m1:H.heap{H.disjoint m0 m1}) : Lemma (ensures (mem_of_heap (H.join m0 m1) == join (mem_of_heap m0) (mem_of_heap m1))) [SMTPat ()] = () in f let mprop_preservation_of_hprop_preservation (p:slprop) (m0 m1:mem) : Lemma (requires (forall (hp:H.hprop p). hp (heap_of_mem m0) == hp (heap_of_mem m1))) (ensures (forall (mp:mprop p). mp (core_mem m0) == mp (core_mem m1))) = let aux (mp:mprop p) : Lemma (mp (core_mem m0) == mp (core_mem m1)) [SMTPat()] = assert (as_hprop p mp (heap_of_mem m0) == as_hprop p mp (heap_of_mem m1)) in () let lift_heap_action (#fp:slprop) (#a:Type) (#fp':a -> slprop) (e:inames) ($f:H.action fp a fp') : tot_action_nf_except e fp a fp' = let g : tot_pre_action_nf_except e fp a fp' = fun m -> let h0 = hheap_of_hmem m in let (| x, h' |) = f h0 in (| x, hmem_of_hheap m h' |) in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in let h0 = hheap_of_hmem m0 in let (| x', h1 |) = f h0 in H.action_framing f (linv e m0) h0; assert (x == x'); star_associative fp frame (linv e m0); H.action_framing f (frame `star` linv e m0) h0; assert (H.interp ((fp' x) `star` (frame `star` linv e m0)) h1); star_associative (fp' x) frame (linv e m0); assert (H.interp ((fp' x `star` frame) `star` linv e m0) h1); let h1' : H.hheap ((fp' x `star` frame) `star` linv e m0) = h1 in assert (m1 == hmem_of_hheap m0 h1'); assert (with_inv_except m1 e (fp' x `star` frame)); assert (forall (hp:H.hprop frame). hp h0 == hp h1); mprop_preservation_of_hprop_preservation frame m0 m1; () in assert (is_frame_preserving g); g let frame_preserving_respects_preorder #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (m0:hmem_with_inv_except e fp) : Lemma (let (| x, m1 |) = f m0 in mem_evolves m0 m1) = let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1) = () in H.emp_unit fp; assert (interp (fp `star` linv e m0) m0); H.star_congruence (fp `star` emp) (linv e m0) fp (linv e m0); assert (interp ((fp `star` emp) `star` linv e m0) m0); aux emp m0 let lift_tot_action_nf #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') : MstTotNF a e fp fp' = let m0 = NMSTTotal.get () in let m0' : hmem_with_inv_except e fp = m0 in let r = f m0' in let (| x, m1 |) = r in let m1' : hmem_with_inv_except e (fp' x) = m1 in assert (is_frame_preserving f); assert (m1 == dsnd (f m0)); frame_preserving_respects_preorder f m0; NMSTTotal.put #_ #(mem_evolves) m1; x let lift_tot_action #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get #(full_mem) #_ () in ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); lift_tot_action_nf f (** Now defining the lift for heap actions with explicit frame *) let tot_action_with_frame_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = frame:slprop u#a -> m0:hmem_with_inv_except e (fp `star` frame) -> Pure (x:a & hmem_with_inv_except e (fp' x `star` frame)) (requires True) (ensures fun (| x, m1 |) -> mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_with_frame = tot_action_with_frame_except S.empty let lift_heap_action_with_frame (#fp:slprop u#a) (#a:Type u#b) (#fp':a -> slprop u#a) (e:inames) ($f:H.action_with_frame fp a fp') : tot_action_with_frame_except e fp a fp' = fun frame m0 -> let h0 = hheap_of_hmem m0 in calc (equiv) { fp `star` frame `star` locks_invariant e m0; (equiv) { star_associative fp frame (locks_invariant e m0) } fp `star` (frame `star` locks_invariant e m0); }; assert (H.interp (fp `star` frame `star` locks_invariant e m0) h0); assert (H.interp (fp `star` (frame `star` locks_invariant e m0)) h0); //key: apply the heap action with frame * locks_invariant e m0 let (| x, h1 |) = f (frame `star` locks_invariant e m0) h0 in calc (equiv) { fp' x `star` (frame `star` locks_invariant e m0); (equiv) { star_associative (fp' x) frame (locks_invariant e m0) } fp' x `star` frame `star` locks_invariant e m0; }; assert (H.interp (fp' x `star` (frame `star` locks_invariant e m0)) h1); assert (H.interp (fp' x `star` frame `star` locks_invariant e m0) h1); let m1 = hmem_of_hheap m0 h1 in assert (mem_evolves m0 m1); mprop_preservation_of_hprop_preservation (frame `star` locks_invariant e m0) m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)); (| x, m1 |) let lift_tot_action_with_frame #a #e #fp #fp' ($f:tot_action_with_frame_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in assert (inames_ok e m0); ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); let m0' : hmem_with_inv_except e fp = m0 in let r = f frame m0' in let (| x, m1 |) = r in ac_reasoning_for_m_frame_preserving (fp' x) frame (locks_invariant e m1) m1; assert (interp (fp' x `star` frame `star` locks_invariant e m1) m1); assert (interp (fp' x `star` locks_invariant e m1) m1); let m1' : hmem_with_inv_except e (fp' x) = m1 in NMSTTotal.put #_ #(mem_evolves) m1; x let sel_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.sel_action #a #pcm r v0)) let upd_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.upd_action #a #pcm r v0 v1)) let free_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.free_action #a #pcm r v0)) let split_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.split_action #a #pcm r v0 v1)) let gather_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.gather_action #a #pcm r v0 v1)) let weaken (p q r:slprop) (h:H.hheap (p `star` q) { H.stronger q r }) : H.hheap (p `star` r) = H.weaken p q r h; h let weaken_pure (q r: prop) : Lemma (requires (q ==> r)) (ensures H.stronger (H.pure q) (H.pure r)) = let aux (h:H.heap) : Lemma (ensures (H.interp (H.pure q) h ==> H.interp (H.pure r) h)) [SMTPat ()] = H.pure_interp q h; H.pure_interp r h in () let inc_ctr (#p:slprop) #e (m:hmem_with_inv_except e p) : m':hmem_with_inv_except e p{m'.ctr = m.ctr + 1 /\ H.stronger (linv e m) (linv e m')} = let m' : mem = { m with ctr = m.ctr + 1} in assert (interp (p `star` linv e m) m'); assert (linv e m == lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m)); assert (linv e m' == lock_store_invariant e m.locks `star` ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken_free_above (heap_of_mem m) m.ctr (m.ctr + 1); weaken_pure (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_ctr_valid (m.ctr + 1) (heap_of_mem m)); assert (H.stronger (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m))); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)); H.stronger_star (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken (p `star` lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)) (heap_of_mem m'); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity (m.ctr + 1) (heap_of_mem m)); let m' : hmem_with_inv_except e p = m' in m' let frame_related_mems (fp0 fp1:slprop u#a) e (m0:hmem_with_inv_except e fp0) (m1:hmem_with_inv_except e fp1) = forall (frame:slprop u#a). interp ((fp0 `star` frame) `star` linv e m0) m0 ==> interp ((fp1 `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) let refined_pre_action e (fp0:slprop) (a:Type) (fp1:a -> slprop) = m0:hmem_with_inv_except e fp0 -> Pure (x:a & hmem_with_inv_except e (fp1 x)) (requires True) (ensures fun (| x, m1 |) -> frame_related_mems fp0 (fp1 x) e m0 m1) let refined_pre_action_as_action (#fp0:slprop) (#a:Type) (#fp1:a -> slprop) #e ($f:refined_pre_action e fp0 a fp1) : tot_action_nf_except e fp0 a fp1 = let g : tot_pre_action_nf_except e fp0 a fp1 = fun m -> f m in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp0 `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp1 x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x', m1' |) = g m0 in let (| x, m1 |) = f m0 in assert (x == x' /\ m1 == m1') in g let alloc_action #a #pcm e x = let f : refined_pre_action e emp (ref a pcm) (fun r -> pts_to r x) = fun m0 -> (* NS: 9/29/22 I needed to annotate h : Heap.full_heap, for use with the Core checker which generates a guard for checking the implicit pattern "dot" term in the dependent pair pattern on the next line. That guard expects `h` to be a full_heap, which is it, because it is a projection of m0. However, this is not reflected in `h`'s type. So, the Core checker, which produces a guard for the pat_dot_term in isolation, cannot recheck the term. If we were to fold in the checking of pat_dot_terms and their guards with the rest of the VC, this would work. *) let h : Heap.full_heap = hheap_of_hmem m0 in let (|r, h'|) = H.extend #a #pcm x m0.ctr h in let m' : hmem_with_inv_except e emp = inc_ctr m0 in let h' : H.hheap (pts_to #a #pcm r x `star` linv e m') = weaken _ (linv e m0) (linv e m') h' in let m1 : hmem_with_inv_except e (pts_to #a #pcm r x) = hmem_of_hheap m' h' in assert (forall frame. H.frame_related_heaps h h' emp (pts_to #a #pcm r x) frame true); let aux (frame:slprop) : Lemma (requires interp ((emp `star` frame) `star` linv e m0) m0) (ensures interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) [SMTPat (emp `star` frame)] = star_associative emp frame (linv e m0); assert (H.interp (emp `star` (frame `star` linv e m0)) h); assert (H.interp (pts_to #a #pcm r x `star` (frame `star` linv e m0)) h'); star_associative (pts_to #a #pcm r x) frame (linv e m0); assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m0) h'); assert (H.stronger (linv e m0) (linv e m')); assert (H.equiv (linv e m') (linv e m1)); assert (H.stronger (linv e m0) (linv e m1)); let h' : H.hheap ((pts_to #a #pcm r x `star` frame) `star` linv e m1) = weaken _ (linv e m0) (linv e m1) h' in assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) h'); assert (forall (mp:H.hprop frame). mp h == mp h'); mprop_preservation_of_hprop_preservation frame m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) in assert (frame_related_mems emp (pts_to r x) e m0 m1); (| r, m1 |) in lift_tot_action (refined_pre_action_as_action f) let select_refine #a #p e r x f = lift_tot_action (lift_heap_action e (H.select_refine #a #p r x f)) let upd_gen #a #p e r x y f = lift_tot_action (lift_heap_action e (H.upd_gen_action r x y f)) //////////////////////////////////////////////////////////////////////////////// // witness / recall //////////////////////////////////////////////////////////////////////////////// let witnessed_ref #a #pcm (r:ref a pcm) (fact:property a) (m:full_mem) = H.witnessed_ref #a #pcm r fact (heap_of_mem m) let witnessed_ref_stability #a #pcm (r:ref a pcm) (fact:property a) : Lemma (requires FStar.Preorder.stable fact (Steel.Preorder.preorder_of_pcm pcm)) (ensures FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) = H.witnessed_ref_stability #a #pcm r fact let witnessed (#a:Type u#1) (#pcm:pcm a) (r:ref a pcm) (fact:property a) = W.witnessed _ mem_evolves (witnessed_ref r fact) let rearrange_pqr_prq (p q r:slprop) : Lemma (((p `star` q) `star` r) `equiv` ((p `star` r) `star` q)) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_associative p q r } p `star` (q `star` r); (equiv) { star_commutative q r; star_congruence p (q `star` r) p (r `star` q) } p `star` (r `star` q); (equiv) { star_associative p r q } (p `star` r) `star` q; } let preserves_frame_cong (e:inames) (p q:slprop) (r s:slprop) (m0 m1:mem) : Lemma (requires p `equiv` r /\ q `equiv` s /\ preserves_frame e p q m0 m1) (ensures preserves_frame e r s m0 m1) = let aux0 (p q r s:slprop) : Lemma (requires p `equiv` s) (ensures (((p `star` q) `star` r) `equiv` ((s `star` q) `star` r))) = star_congruence p q s q; star_congruence (p `star` q) r (s `star` q) r in let aux (frame:slprop) : Lemma (requires interp ((r `star` frame) `star` locks_invariant e m0) m0) (ensures interp ((s `star` frame) `star` locks_invariant e m1) m1 /\ interp ((p `star` frame) `star` locks_invariant e m0) m0) [SMTPat (r `star` frame)] = aux0 p frame (locks_invariant e m0) r; aux0 q frame (locks_invariant e m1) s; assert (((p `star` frame) `star` locks_invariant e m0) `equiv` ((r `star` frame) `star` locks_invariant e m0)); assert (interp ((p `star` frame) `star` locks_invariant e m0) m0); assert (interp ((q `star` frame) `star` locks_invariant e m1) m1); assert (((q `star` frame) `star` locks_invariant e m1) `equiv` ((s `star` frame) `star` locks_invariant e m1)); () in () let pure_true_equiv (p:slprop) : Lemma ((p `star` pure True) `equiv` p) = FStar.Classical.forall_intro (pure_star_interp p True); emp_unit p; assert ((p `star` pure True) `equiv` p) let preserves_frame_star_pure (e:inames) (p q:slprop) (r s:prop) (m:mem) : Lemma (requires r /\ s) (ensures preserves_frame e p q m m <==> preserves_frame e (p `star` pure r) (q `star` pure s) m m) = pure_equiv r True; star_congruence p (pure r) p (pure True); pure_equiv s True; star_congruence q (pure s) q (pure True); pure_true_equiv p; pure_true_equiv q; let fwd () : Lemma (requires preserves_frame e p q m m) (ensures preserves_frame e (p `star` pure r) (q `star` pure s) m m) [SMTPat ()] = preserves_frame_cong e p q (p `star` pure r) (q `star` pure s) m m in let bk () : Lemma (requires preserves_frame e (p `star` pure r) (q `star` pure s) m m) (ensures preserves_frame e p q m m) [SMTPat ()] = preserves_frame_cong e (p `star` pure r) (q `star` pure s) p q m m in () let witness (#a:Type) (#pcm:pcm a) (e:inames) (r:erased (ref a pcm)) (fact:stable_property pcm) (v:Ghost.erased a) (_:squash (forall z. compatible pcm v z ==> fact z)) (frame:slprop) : MstTot (witnessed r fact) e (pts_to r v) (fun _ -> pts_to r v) frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in let _ : unit = let hr : H.ref a pcm = r in let v' = H.sel_v hr v (heap_of_mem m0) in assert (interp (H.ptr hr) m0 /\ H.sel #a #pcm hr (heap_of_mem m0) == v'); assert (compatible pcm v v'); assert (fact v'); assert (witnessed_ref r fact m0); witnessed_ref_stability r fact; assert (FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) in let w = NMSTTotal.witness _ mem_evolves (witnessed_ref r fact) in w let recall (#a:Type u#1) (#pcm:pcm a) (#fact:property a) (e:inames) (r:erased (ref a pcm)) (v:Ghost.erased a) (w:witnessed r fact) (frame:slprop) = let m0 = NMSTTotal.get () in NMSTTotal.recall _ mem_evolves (witnessed_ref r fact) w; let hr : H.ref a pcm = r in assert (witnessed_ref r fact m0); let v1 = H.sel_v hr v (heap_of_mem m0) in assert (compatible pcm v v1); assert (H.sel hr (heap_of_mem m0) == v1); assert (fact v1); assert (interp ((pts_to r v `star` frame) `star` locks_invariant e m0) m0); emp_unit ((pts_to r v `star` frame) `star` locks_invariant e m0); pure_star_interp ((pts_to r v `star` frame) `star` locks_invariant e m0) (fact v1) m0; assert (interp (((pts_to r v `star` frame) `star` locks_invariant e m0) `star` pure (fact v1)) m0); rearrange_pqr_prq (pts_to r v `star` frame) (locks_invariant e m0) (pure (fact v1)); assert (interp (((pts_to r v `star` frame) `star` pure (fact v1)) `star` locks_invariant e m0) m0); rearrange_pqr_prq (pts_to r v) frame (pure (fact v1)); star_congruence ((pts_to r v `star` frame) `star` pure (fact v1)) (locks_invariant e m0) ((pts_to r v `star` pure (fact v1)) `star` frame) (locks_invariant e m0); Ghost.hide v1 let iname_for_p_mem (i:iname) (p:slprop) : W.s_predicate mem = fun m -> iname_for_p i p m.locks let iname_for_p_stable (i:iname) (p:slprop) : Lemma (W.stable full_mem mem_evolves (iname_for_p_mem i p)) = () let ( >--> ) (i:iname) (p:slprop) : Type0 = W.witnessed full_mem mem_evolves (iname_for_p_mem i p) let hmem_with_inv_equiv e (m:mem) (p:slprop) : Lemma (interp (p `star` linv e m) m <==> interp (p `star` lock_store_invariant e m.locks) m /\ heap_ctr_valid m.ctr (heap_of_mem m)) = calc (<==>) { interp (p `star` linv e m) m; (<==>) { H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) } interp ((p `star` lock_store_invariant e m.locks) `star` ctr_validity m.ctr (heap_of_mem m)) m; (<==>) { H.pure_star_interp (p `star` lock_store_invariant e m.locks) (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_of_mem m) } interp ((p `star` lock_store_invariant e m.locks) `star` emp) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); (<==>) { H.emp_unit (p `star` lock_store_invariant e m.locks) } interp (p `star` lock_store_invariant e m.locks) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); } let new_invariant_tot_action (e:inames) (p:slprop) (m0:hmem_with_inv_except e p{ e `inames_in` m0.locks }) : Pure (iname & hmem_with_inv_except e emp) (requires True) (ensures fun (i, m1) -> iname_for_p_mem i p m1 /\ frame_related_mems p emp e m0 m1 /\ mem_evolves m0 m1) = let (| i, l1 |) = extend_lock_store e m0.locks p in let m1 = { m0 with locks = l1 } in assert (lock_store_invariant e m1.locks == p `star` lock_store_invariant e m0.locks); calc (equiv) { linv e m1; (equiv) {} (lock_store_invariant e m1.locks `star` ctr_validity m1.ctr (heap_of_mem m1)); (equiv) {} ((p `star` lock_store_invariant e m0.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); (equiv) { H.star_associative p (lock_store_invariant e m0.locks) (ctr_validity m1.ctr (heap_of_mem m1)) } (p `star` (lock_store_invariant e m0.locks `star` ctr_validity m1.ctr (heap_of_mem m1))); (equiv) { } (p `star` linv e m0); }; assert (iname_for_p_mem i p m1); assert (lock_store_evolves m0.locks l1); assert (mem_evolves m0 m1); hmem_with_inv_equiv e m0 p; assert (interp (p `star` lock_store_invariant e m0.locks) m1); assert (interp (lock_store_invariant e m1.locks) m1); H.emp_unit (lock_store_invariant e m1.locks); H.star_commutative (lock_store_invariant e m1.locks) emp; assert (interp (emp `star` lock_store_invariant e m1.locks) m1); hmem_with_inv_equiv e m1 emp; let m1 : hmem_with_inv_except e emp = m1 in let aux (frame:slprop) : Lemma (requires interp ((p `star` frame) `star` linv e m0) m0) (ensures interp ((emp `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) <==> mp (core_mem m1))) [SMTPat (p `star` frame)] = assert (interp ((p `star` frame) `star` linv e m0) m1); calc (equiv) { ((p `star` frame) `star` linv e m0); (equiv) { H.star_commutative p frame; H.star_congruence (p `star` frame) (linv e m0) (frame `star` p) (linv e m0); H.star_associative frame p (linv e m0) } (frame `star` (p `star` linv e m0)); (equiv) { H.star_congruence frame (p `star` linv e m0) frame (linv e m1) } (frame `star` linv e m1); (equiv) { H.emp_unit (frame `star` linv e m1); H.star_commutative (frame `star` linv e m1) emp; H.star_associative emp frame (linv e m1) } ((emp `star` frame) `star` linv e m1); }; assert (interp ((emp `star` frame) `star` linv e m1) m1) in assert (frame_related_mems p emp e m0 m1); ( i, m1 ) let name_is_ok (i:iname) (m0:full_mem u#1) : prop = i < List.Tot.length m0.locks let witnessed_name_is_ok (i:iname) = W.witnessed full_mem mem_evolves (name_is_ok i) let pre_inv = i:erased iname & witnessed_name_is_ok i let inv (p:slprop u#1) = i:erased iname & witnessed_name_is_ok i & (i >--> p) let pre_inv_of_inv #p (i:inv p) = let (|i, w, _|) = i in (|i,w|) let name_of_pre_inv (i:pre_inv) = dfst i let rec recall_all (ctx:list pre_inv) : NMSTTotal.NMSTATETOT unit (full_mem u#1) mem_evolves (requires fun _ -> True) (ensures fun m0 _ m1 -> m0==m1 /\ (forall i. i `List.Tot.memP` ctx ==> name_is_ok (name_of_pre_inv i) m0)) = match ctx with | [] -> () | hd::tl -> let (| q, i |) = hd in let i : W.witnessed full_mem mem_evolves (name_is_ok q) = i in NMSTTotal.recall _ mem_evolves (name_is_ok q) i; recall_all tl let fresh_invariant (e:inames) (p:slprop) (ctx:list pre_inv) (frame:slprop) : MstTot (i:inv p { not (mem_inv e i) /\ fresh_wrt ctx (name_of_inv i)}) e p (fun _ -> emp) frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in recall_all ctx; ac_reasoning_for_m_frame_preserving p frame (locks_invariant e m0) m0; assert (interp (p `star` locks_invariant e m0) m0); let r = new_invariant_tot_action e p m0 in let ( i, m1 ) = r in assert (i == List.Tot.length m0.locks); assert (not (Set.mem i e)); assert (mem_evolves m0 m1); NMSTTotal.put #full_mem #mem_evolves m1; iname_for_p_stable i p; let w = NMSTTotal.witness full_mem mem_evolves (iname_for_p_mem i p) in let w0 = NMSTTotal.witness full_mem mem_evolves (name_is_ok i) in (| hide i, w0, w |) let new_invariant (e:inames) (p:slprop) (frame:slprop) : MstTot (inv p) e p (fun _ -> emp) frame (fun _ -> True) (fun _ _ _ -> True) = fresh_invariant e p [] frame let rearrange_invariant (p q r : slprop) (q0 q1:slprop) : Lemma (requires q `equiv` (q0 `star` q1)) (ensures (p `star` (q `star` r)) `equiv` ((q0 `star` p) `star` (q1 `star` r))) = calc (equiv) { p `star` (q `star` r); (equiv) { calc (equiv) { (q `star` r); (equiv) { star_congruence q r (q0 `star` q1) r } (q0 `star` q1) `star` r; }; star_congruence p (q `star` r) p ((q0 `star` q1) `star` r) } (p `star` ((q0 `star` q1) `star` r)); (equiv) { star_associative q0 q1 r; star_congruence p ((q0 `star` q1) `star` r) p (q0 `star` (q1 `star` r)); star_associative p q0 (q1 `star` r) } (p `star` q0) `star` (q1 `star` r); (equiv) { star_commutative p q0; star_congruence (p `star` q0) (q1 `star` r) (q0 `star` p) (q1 `star` r) } (q0 `star` p) `star` (q1 `star` r); } let preserves_frame_invariant (fp fp':slprop) (opened_invariants:inames) (p:slprop) (i:inv p{not (mem_inv opened_invariants i)}) (m0:hmem_with_inv_except (add_inv opened_invariants i) (p `star` fp)) (m1:mem) : Lemma (requires preserves_frame (set_add (name_of_inv i) opened_invariants) (p `star` fp) (p `star` fp') m0 m1 /\ interp (fp' `star` linv opened_invariants m1) m1 /\ inames_ok opened_invariants m1 /\ (lock_store_invariant opened_invariants m0.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks)) /\ (lock_store_invariant opened_invariants m1.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks))) (ensures preserves_frame opened_invariants fp fp' m0 m1) = let aux (frame:slprop) : Lemma (requires interp ((fp `star` frame) `star` linv opened_invariants m0) m0) (ensures interp ((fp' `star` frame) `star` linv opened_invariants m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) [SMTPat()] = rearrange_invariant (fp `star` frame) (lock_store_invariant opened_invariants m0.locks) (ctr_validity m0.ctr (heap_of_mem m0)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks); assert (interp ((p `star` (fp `star` frame)) `star` linv (set_add (name_of_inv i) opened_invariants) m0) m0); star_associative p fp frame; star_congruence (p `star` (fp `star` frame)) (linv (set_add (name_of_inv i) opened_invariants) m0) ((p `star` fp) `star` frame) (linv (set_add (name_of_inv i) opened_invariants) m0); assert (interp (((p `star` fp) `star` frame) `star` linv (set_add (name_of_inv i) opened_invariants) m0) m0); assert (interp (((p `star` fp') `star` frame) `star` linv (set_add (name_of_inv i) opened_invariants) m1) m1); star_associative p fp' frame; star_congruence ((p `star` fp') `star` frame) (linv (set_add (name_of_inv i) opened_invariants) m1) (p `star` (fp' `star` frame)) (linv (set_add (name_of_inv i) opened_invariants) m1); assert (interp ((p `star` (fp' `star` frame)) `star` linv (set_add (name_of_inv i) opened_invariants) m1) m1); rearrange_invariant (fp' `star` frame) (lock_store_invariant opened_invariants m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks); assert (interp ((fp' `star` frame) `star` linv opened_invariants m1) m1); () in () let equiv_ext_right (p q r:slprop) : Lemma (requires q `equiv` r) (ensures (p `star` q) `equiv` (p `star` r)) = calc (equiv) { p `star` q; (equiv) { star_commutative p q } q `star` p; (equiv) { equiv_extensional_on_star q r p } r `star` p; (equiv) { star_commutative p r } p `star` r; } let with_inv_helper (fp frame ls1 ctr p ls2:slprop) : Lemma (requires ls1 `equiv` (p `star` ls2)) (ensures (fp `star` frame `star` (ls1 `star` ctr)) `equiv` (p `star` fp `star` frame `star` (ls2 `star` ctr))) = calc (equiv) { ls1 `star` ctr; (equiv) { equiv_extensional_on_star ls1 (p `star` ls2) ctr } p `star` ls2 `star` ctr; }; calc (equiv) { p `star` ls2 `star` ctr; (equiv) { star_associative p ls2 ctr } p `star` (ls2 `star` ctr); }; calc (equiv) { fp `star` frame `star` p; (equiv) { star_commutative (fp `star` frame) p } p `star` (fp `star` frame); (equiv) { star_associative p fp frame } p `star` fp `star` frame; }; calc (equiv) { fp `star` frame `star` (ls1 `star` ctr); (equiv) { equiv_ext_right (fp `star` frame) (ls1 `star` ctr) (p `star` ls2 `star` ctr) } (fp `star` frame) `star` (p `star` ls2 `star` ctr); (equiv) { equiv_ext_right (fp `star` frame) (p `star` ls2 `star` ctr) (p `star` (ls2 `star` ctr)) } (fp `star` frame) `star` (p `star` (ls2 `star` ctr)); (equiv) { star_associative (fp `star` frame) p (ls2 `star` ctr) } (fp `star` frame `star` p) `star` (ls2 `star` ctr); (equiv) { equiv_extensional_on_star (fp `star` frame `star` p) (p `star` fp `star` frame) (ls2 `star` ctr) } (p `star` fp `star` frame) `star` (ls2 `star` ctr); } let token_of_inv #p (i:inv p) : (name_of_inv i >--> p) = let (| _, _, tok |) = i in tok let with_invariant (#a:Type) (#fp:slprop) (#fp':a -> slprop) (#opened_invariants:inames) (#p:slprop) (i:inv p{not (mem_inv opened_invariants i)}) (f:action_except a (add_inv opened_invariants i) (p `star` fp) (fun x -> p `star` fp' x)) (frame:slprop) : MstTot a opened_invariants fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in NMSTTotal.recall _ mem_evolves (iname_for_p_mem (name_of_inv i) p) (token_of_inv i); assert (iname_for_p (name_of_inv i) p m0.locks); assert (interp (fp `star` frame `star` locks_invariant opened_invariants m0) m0); assert (interp (fp `star` frame `star` (lock_store_invariant opened_invariants m0.locks `star` ctr_validity m0.ctr (heap_of_mem m0))) m0); move_invariant opened_invariants m0.locks p (name_of_inv i); assert (lock_store_invariant opened_invariants m0.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks)); with_inv_helper fp frame (lock_store_invariant opened_invariants m0.locks) (ctr_validity m0.ctr (heap_of_mem m0)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks); assert (interp (p `star` fp `star` frame `star` locks_invariant (set_add (name_of_inv i) opened_invariants) m0) m0); let r = f frame in let m1 : full_mem = NMSTTotal.get () in assert (interp (p `star` fp' r `star` frame `star` locks_invariant (set_add (name_of_inv i) opened_invariants) m1) m1); assert (interp (p `star` fp' r `star` frame `star` (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks `star` ctr_validity m1.ctr (heap_of_mem m1))) m1); NMSTTotal.recall _ mem_evolves (iname_for_p_mem (name_of_inv i) p) (token_of_inv i); move_invariant opened_invariants m1.locks p (name_of_inv i); assert (lock_store_invariant opened_invariants m1.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks)); with_inv_helper (fp' r) frame (lock_store_invariant opened_invariants m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks); assert (interp (fp' r `star` frame `star` locks_invariant opened_invariants m1) m1); assert (inames_ok opened_invariants m1); r let equiv_pqrs_p_qr_s (p q r s:slprop) : Lemma ((p `star` q `star` r `star` s) `equiv` (p `star` (q `star` r) `star` s)) = star_associative p q r; equiv_extensional_on_star (p `star` q `star` r) (p `star` (q `star` r)) s let frame (#a:Type) (#opened_invariants:inames) (#pre:slprop) (#post:a -> slprop) (#req:mprop pre) (#ens:mprop2 pre post) (frame:slprop) ($f:action_except_full a opened_invariants pre post req ens) (frame0:slprop) : MstTot a opened_invariants (pre `star` frame) (fun x -> post x `star` frame) frame0 req ens = let m0 : full_mem = NMSTTotal.get () in equiv_pqrs_p_qr_s pre frame frame0 (linv opened_invariants m0); assert (interp (pre `star` frame `star` frame0 `star` linv opened_invariants m0) m0); assert (interp (pre `star` (frame `star` frame0) `star` linv opened_invariants m0) m0); let x = f (frame `star` frame0) in let m1 : full_mem = NMSTTotal.get () in equiv_pqrs_p_qr_s (post x) frame frame0 (linv opened_invariants m1); assert (interp (post x `star` (frame `star` frame0) `star` linv opened_invariants m1) m1); assert (interp (post x `star` frame `star` frame0 `star` linv opened_invariants m1) m1); x

{ "checked_file": "/", "dependencies": [ "Steel.Preorder.fst.checked", "Steel.Heap.fsti.checked", "prims.fst.checked", "FStar.Witnessed.Core.fsti.checked", "FStar.Set.fsti.checked", "FStar.Preorder.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.PCM.fst.checked", "FStar.NMSTTotal.fst.checked", "FStar.List.Tot.fst.checked", "FStar.IndefiniteDescription.fsti.checked", "FStar.Ghost.fsti.checked", "FStar.FunctionalExtensionality.fsti.checked", "FStar.Classical.Sugar.fsti.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Steel.Memory.fst" }

[ { "abbrev": true, "full_module": "Steel.Preorder", "short_module": "PP" }, { "abbrev": true, "full_module": "FStar.Witnessed.Core", "short_module": "W" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": true, "full_module": "Steel.Heap", "short_module": "H" }, { "abbrev": false, "full_module": "FStar.FunctionalExtensionality", "short_module": null }, { "abbrev": true, "full_module": "FStar.FunctionalExtensionality", "short_module": "F" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": false, "full_module": "FStar.PCM", "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

p: Steel.Memory.slprop -> q: Steel.Memory.slprop -> proof: (m: Steel.Memory.mem -> FStar.Pervasives.Lemma (requires Steel.Memory.interp p m) (ensures Steel.Memory.interp q m)) -> Steel.Memory.action_except Prims.unit opened_invariants p (fun _ -> q)

Prims.Tot

[ "total" ]

[]

[ "Steel.Memory.inames", "Steel.Memory.slprop", "Steel.Memory.mem", "Prims.unit", "Steel.Memory.interp", "Prims.squash", "Prims.Nil", "FStar.Pervasives.pattern", "Steel.Memory.lift_tot_action", "Steel.Memory.lift_heap_action", "Steel.Heap.change_slprop", "Steel.Heap.heap", "Steel.Heap.interp", "Steel.Memory.mem_of_heap", "Steel.Memory.action_except" ]

[]

false

let change_slprop (#opened_invariants: inames) (p q: slprop) (proof: (m: mem -> Lemma (requires interp p m) (ensures interp q m))) =

let proof (h: H.heap) : Lemma (requires H.interp p h) (ensures H.interp q h) = proof (mem_of_heap h) in lift_tot_action (lift_heap_action opened_invariants (Steel.Heap.change_slprop p q proof))

false

Steel.Memory.fst

Steel.Memory.elim_pure

val elim_pure (#opened_invariants:_) (p:prop) : action_except (u:unit{p}) opened_invariants (pure p) (fun _ -> emp)

let elim_pure #opened_invariants p = lift_tot_action (lift_heap_action opened_invariants (H.elim_pure p))

{ "file_name": "lib/steel/Steel.Memory.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 105, "end_line": 1558, "start_col": 0, "start_line": 1558 }

(* 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.Memory module F = FStar.FunctionalExtensionality open FStar.FunctionalExtensionality open FStar.PCM module H = Steel.Heap noeq type lock_state : Type u#(a + 1) = | Invariant : inv:H.slprop u#a -> lock_state let lock_store : Type u#(a+1) = list (lock_state u#a) noeq type mem : Type u#(a + 1) = { ctr: nat; heap: H.heap u#a; locks: lock_store u#a; } let heap_of_mem (x:mem) : H.heap = x.heap let mem_of_heap (h:H.heap) : mem = { ctr = 0; heap = h; locks = [] } let mem_set_heap (m:mem) (h:H.heap) : mem = { ctr = m.ctr; heap = h; locks = m.locks; } let core_mem (m:mem) : mem = mem_of_heap (heap_of_mem m) let core_mem_invol m = () let disjoint (m0 m1:mem u#h) : prop = m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks let disjoint_sym m0 m1 = () let join m0 m1 = { ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = m0.locks } let join_commutative m0 m1 = H.join_commutative m0.heap m1.heap let disjoint_join m0 m1 m2 = H.disjoint_join m0.heap m1.heap m2.heap let join_associative m0 m1 m2 = H.join_associative m0.heap m1.heap m2.heap let slprop = H.slprop let interp p m = H.interp p m.heap let equiv p1 p2 = forall m. interp p1 m <==> interp p2 m let slprop_extensionality p q = assert (forall m. interp p m <==> interp q m); let aux (h:H.heap) : Lemma (H.interp p h <==> H.interp q h) [SMTPat (H.interp p h)] = let m : mem = { ctr = 0; heap = h; locks = [] } in assert (interp p m <==> interp q m) in assert (forall h. H.interp p h <==> H.interp q h); Steel.Heap.slprop_extensionality p q let reveal_equiv p1 p2 = () let core_ref = H.core_ref let core_ref_null = H.core_ref_null let core_ref_is_null r = H.core_ref_is_null r let emp : slprop u#a = H.emp let pure = H.pure let pts_to = H.pts_to let h_and = H.h_and let h_or = H.h_or let star = H.star let wand = H.wand let h_exists = H.h_exists let h_forall = H.h_forall //////////////////////////////////////////////////////////////////////////////// //properties of equiv //////////////////////////////////////////////////////////////////////////////// let equiv_symmetric (p1 p2:slprop u#a) = H.equiv_symmetric p1 p2 #push-options "--warn_error -271" let equiv_heap_iff_equiv (p1 p2:slprop u#a) : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat (equiv p1 p2)] = let aux_lr () : Lemma (requires H.equiv p1 p2) (ensures equiv p1 p2) [SMTPat ()] = () in let aux_rl_helper1 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p1 h) (ensures H.interp p2 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl_helper2 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p2 h) (ensures H.interp p1 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl () : Lemma (requires equiv p1 p2) (ensures H.equiv p1 p2) [SMTPat ()] = () in () let equiv_heap_iff_equiv_forall () : Lemma (ensures (forall p1 p2. H.equiv p1 p2 <==> equiv p1 p2)) = let aux p1 p2 : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat ()] = equiv_heap_iff_equiv p1 p2 in () #pop-options let equiv_extensional_on_star (p1 p2 p3:slprop u#a) = equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3 let emp_unit p = H.emp_unit p let intro_emp m = H.intro_emp (heap_of_mem m) let pure_equiv p q = H.pure_equiv p q let pure_interp q m = H.pure_interp q (heap_of_mem m) let pure_star_interp p q m = H.pure_star_interp p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// //pts_to //////////////////////////////////////////////////////////////////////////////// let pts_to_compatible #a #pcm x v0 v1 m = H.pts_to_compatible #a #pcm x v0 v1 (heap_of_mem m) let pts_to_compatible_equiv #a #pcm x v0 v1 = H.pts_to_compatible_equiv #a #pcm x v0 v1 let pts_to_not_null #a #pcm x v m = H.pts_to_not_null #a #pcm x v (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // star //////////////////////////////////////////////////////////////////////////////// let intro_star p q mp mq = H.intro_star p q (heap_of_mem mp) (heap_of_mem mq) let elim_star p q m = let h = heap_of_mem m in H.elim_star p q h; assert (exists hl hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr); let hl = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hl -> exists hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let hr = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hr -> H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let ml = mem_set_heap m hl in let mr = mem_set_heap m hr in assert (disjoint ml mr); assert (m == join ml mr); assert (interp p ml); assert (interp q mr); () let interp_star (p q: slprop) (m: mem) : Lemma (interp (p `star` q) m <==> (exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m)) = let left = interp (p `star` q) m in let right = exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m in let f () : Lemma (requires left) (ensures right) = elim_star p q m in let g () : Lemma (requires right) (ensures left) = Classical.exists_elim left #_ #(fun mp -> exists (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mp -> Classical.exists_elim left #_ #(fun mq -> disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mq -> intro_star p q mp mq ) ) in Classical.move_requires f (); Classical.move_requires g () let star_commutative (p1 p2:slprop) = H.star_commutative p1 p2 let star_associative (p1 p2 p3:slprop) = H.star_associative p1 p2 p3 let star_congruence (p1 p2 p3 p4:slprop) = equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4 let affine_star (p q:slprop) (m:mem) = H.affine_star p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // Invariants on the lock store //////////////////////////////////////////////////////////////////////////////// let iname = nat module S = FStar.Set module L = FStar.List.Tot module W = FStar.Witnessed.Core let rec lock_store_invariant (e:inames) (l:lock_store u#a) : slprop u#a = let current_addr = L.length l - 1 in match l with | [] -> emp | Invariant p :: tl -> if current_addr `S.mem` e then lock_store_invariant e tl else p `star` lock_store_invariant e tl let lock_i (i:iname) (l:lock_store { i < L.length l }) = let ix = L.length l - i - 1 in L.index l ix let iname_for_p (i:iname) (p:slprop) : W.s_predicate lock_store = fun l -> i < L.length l /\ (lock_i i l).inv == p let lock_store_evolves : FStar.Preorder.preorder lock_store = fun (l1 l2 : lock_store) -> L.length l2 >= L.length l1 /\ (forall (i:nat{i < L.length l1}). (lock_i i l1).inv == (lock_i i l2).inv) let inames_in (e:inames) (l:lock_store) : prop = forall i. Set.mem i e ==> i < L.length l let inames_ok e m = inames_in e m.locks let inames_ok_empty m = () let extend_lock_store (e:inames) (l:lock_store{e `inames_in` l}) (p:slprop) : i:iname & l':lock_store { lock_store_invariant e l' == p `star` lock_store_invariant e l /\ iname_for_p i p l' } = (| L.length l, Invariant p :: l |) let set_add (i:iname) (s:inames) = Set.union (Set.singleton i) s let rec move_invariant (e:inames) (l:lock_store) (p:slprop) (i:iname{iname_for_p i p l /\ ~(i `Set.mem` e)}) : Lemma (H.equiv (lock_store_invariant e l) (p `star` lock_store_invariant (set_add i e) l)) = let rec aux (i:iname) (m:lock_store) : Lemma (requires i >= L.length m) (ensures (lock_store_invariant e m `H.equiv` lock_store_invariant (set_add i e) m)) = match m with | [] -> () | Invariant p::tl -> aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl) in let current_addr = L.length l - 1 in match l with | [] -> () | Invariant q::tl -> if i = current_addr then begin assert (lock_store_invariant e l == p `star` lock_store_invariant e tl); aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl); () end else begin move_invariant e tl p i; assert (lock_store_invariant e tl `equiv` (p `star` lock_store_invariant (set_add i e) tl)); H.star_congruence q (lock_store_invariant e tl) q (p `star` lock_store_invariant (set_add i e) tl); if Set.mem current_addr e then () else begin let r = lock_store_invariant (set_add i e) tl in assert (lock_store_invariant e l `equiv` (q `star` (p `star` r))); H.star_associative q p r; H.star_commutative q p; H.star_congruence (q `star` p) r (p `star` q) r; H.star_associative p q r end end let heap_ctr_valid (ctr:nat) (h:H.heap u#a) : prop = h `H.free_above_addr` ctr let ctr_validity (ctr:nat) (h:H.heap) : slprop = H.pure (heap_ctr_valid ctr h) let locks_invariant (e:inames) (m:mem u#a) : slprop u#a = lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m) let full_mem_pred (m:mem) = H.full_heap_pred (heap_of_mem m) (***** Following lemmas are needed in Steel.Effect *****) let core_mem_interp (hp:slprop u#a) (m:mem u#a) = () let interp_depends_only_on (hp:slprop u#a) = H.interp_depends_only_on hp let a_mem_prop_as_a_heap_prop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (H.a_heap_prop u#a) = let g (h: H.heap u#a) : Tot prop = interp sl (mem_of_heap h) /\ f (mem_of_heap h) in let phi0 (h0 h1: H.heap u#a) : Lemma (requires (g h0 /\ H.disjoint h0 h1)) (ensures (g h0 /\ H.disjoint h0 h1 /\ g (H.join h0 h1))) = assert (mem_of_heap (H.join h0 h1) == mem_of_heap h0 `join` mem_of_heap h1); interp_depends_only_on sl in let phi1 (h0 h1: H.heap u#a) : Lemma (ensures ((g h0 /\ H.disjoint h0 h1) ==> g (H.join h0 h1))) = Classical.move_requires (phi0 h0) h1 in Classical.forall_intro_2 phi1; g let refine_slprop sl f = H.as_slprop (a_mem_prop_as_a_heap_prop sl f) let interp_refine_slprop sl f m = assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_mem m)) let dep_hprop (s: slprop) (f: (hmem s -> Tot slprop)) (h: H.heap) : Tot prop = exists (h1: H.heap) . exists (h2: H.heap) . interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 let dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq' : squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h')) = let p2 (h h1 h2: H.heap) : Tot prop = interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 in let p1 (h h1: H.heap) : Tot prop = (exists h2 . p2 h h1 h2) in let h1 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p1 h) in let h2 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p2 h h1) in H.disjoint_join h' h1 h2; assert (H.disjoint h2 h'); let h2' = H.join h2 h' in H.join_commutative h2 h' ; assert (h2' == H.join h' h2); assert (H.disjoint h1 h2'); assert (mem_of_heap h2' == mem_of_heap h2 `join` mem_of_heap h'); interp_depends_only_on (f (mem_of_heap h1)); assert (interp (f (mem_of_heap h1)) (mem_of_heap h2')); H.join_commutative h1 h2; H.join_associative h' h2 h1; H.join_commutative h' h; H.join_commutative h2' h1; assert (H.join h h' == h1 `H.join` h2') let impl_intro_gen (#p: Type0) (#q: Type0) ($prf: (squash p -> Lemma (q ))) : Lemma (p ==> q) = Classical.impl_intro_gen #p #(fun _ -> q) prf let dep_hprop_is_affine1 (s: slprop) (f: (hmem s -> Tot slprop)) (h0 h1: H.heap) : Lemma ((dep_hprop s f h0 /\ H.disjoint h0 h1) ==> (H.disjoint h0 h1 /\ dep_hprop s f (H.join h0 h1))) = impl_intro_gen (dep_hprop_is_affine0 s f h0 h1) let dep_hprop_is_affine (s: slprop) (f: (hmem s -> Tot slprop)) : Lemma (H.heap_prop_is_affine (dep_hprop s f)) = Classical.forall_intro_2 (dep_hprop_is_affine1 s f) let sdep (s: slprop) (f: (hmem s -> Tot slprop)) : Tot slprop = dep_hprop_is_affine s f; H.as_slprop (dep_hprop s f) let interp_sdep (s: slprop) (f: (hmem s -> Tot slprop)) (m: mem) : Lemma (requires (dep_slprop_is_affine s f)) (ensures ( interp (sdep s f) m <==> (exists m1 m2 . interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) )) = dep_hprop_is_affine s f; assert (forall m1 m2 . (interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) ==> ( interp s (mem_of_heap m1.heap) /\ interp (f (mem_of_heap m1.heap)) (mem_of_heap m2.heap) /\ H.disjoint m1.heap m2.heap /\ H.join m1.heap m2.heap == m.heap )); interp_depends_only_on s; Classical.forall_intro (fun m -> interp_depends_only_on (f m)); assert (forall h1 h2 . (interp s (mem_of_heap h1) /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ H.disjoint h1 h2 /\ H.join h1 h2 == m.heap) ==> ( core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ interp s (core_mem (mem_of_heap h1)) /\ interp s (mem_set_heap m h1) /\ core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ f (mem_set_heap m h1) `equiv` f (mem_of_heap h1) /\ interp (f (mem_set_heap m h1)) (mem_of_heap h2) /\ interp (f (mem_set_heap m h1)) (mem_set_heap m h2) /\ disjoint (mem_set_heap m h1) (mem_set_heap m h2) /\ join (mem_set_heap m h1) (mem_set_heap m h2) == m )); () let h_exists_cong (#a:Type) (p q : a -> slprop) : Lemma (requires (forall x. p x `equiv` q x)) (ensures (h_exists p `equiv` h_exists q)) = equiv_heap_iff_equiv_forall (); H.h_exists_cong p q let intro_h_exists #a x p m = H.intro_h_exists x p (heap_of_mem m) let elim_h_exists (#a:_) (p:a -> slprop) (m:mem) = H.elim_h_exists p (heap_of_mem m) let intro_h_forall (#a:_) (p:a -> slprop) (m:mem) = H.intro_h_forall p (heap_of_mem m) let elim_h_forall (#a:_) (p:a -> slprop) (m:mem) (x:a) = H.elim_h_forall p (heap_of_mem m) x let intro_h_and (p q: slprop) (m:mem) = H.intro_h_and p q (heap_of_mem m) let elim_h_and (p q: slprop) (m:mem) = H.elim_h_and p q (heap_of_mem m) let intro_h_or_left (p q: slprop) (m:mem) = H.intro_h_or_left p q (heap_of_mem m) let intro_h_or_right (p q: slprop) (m:mem) = H.intro_h_or_right p q (heap_of_mem m) let elim_h_or (p q: slprop) (m:mem) = H.elim_h_or p q (heap_of_mem m) let intro_wand (p1 p2: slprop u#a) (m:mem) = introduce (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)) ==> interp (wand p1 p2) m with _. ( assert (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)); H.intro_wand p1 p2 (heap_of_mem m); let h = heap_of_mem m in assert ((forall h1. h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) ==> H.interp (wand p1 p2) h); introduce forall h1. (h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) with ( introduce (h `H.disjoint` h1 /\ H.interp p1 h1) ==> H.interp p2 (H.join h h1) with _. ( assert (h `H.disjoint` h1); let m1 = { ctr = m.ctr; heap = h1; locks = m.locks } in assert (m `disjoint` m1) ) ) ) (** Eliminating a wand by proving a heap that satisfies the LHS **) let elim_wand (p1 p2: slprop u#a) (m:mem) (m1:mem) = H.elim_wand p1 p2 (heap_of_mem m) (heap_of_mem m1) //////////////////////////////////////////////////////////////////////////////// // Preorders and effects //////////////////////////////////////////////////////////////////////////////// module PP = Steel.Preorder let mem_evolves = fun (m0 m1:full_mem) -> H.heap_evolves (heap_of_mem m0) (heap_of_mem m1) /\ m0.ctr <= m1.ctr /\ lock_store_evolves m0.locks m1.locks (** See [Steel.Heap.is_frame_preserving]. We add in [lock_invariants] now *) let preserves_frame (e:inames) (pre post:slprop) (m0 m1:mem) = forall (frame:slprop). interp ((pre `star` frame) `star` locks_invariant e m0) m0 ==> (interp ((post `star` frame) `star` locks_invariant e m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) (** This is a version of MstTot with frame quantified, as part of preserves_frame *) effect MstTotNF (a:Type u#a) (except:inames) (expects:slprop u#1) (provides: a -> slprop u#1) = NMSTTotal.NMSTATETOT a (full_mem u#1) mem_evolves (requires fun m0 -> inames_ok except m0 /\ interp (expects `star` locks_invariant except m0) m0) (ensures fun m0 x m1 -> inames_ok except m1 /\ interp (provides x `star` locks_invariant except m1) m1 /\ preserves_frame except expects (provides x) m0 m1) //////////////////////////////////////////////////////////////////////////////// // Lifting heap actions //////////////////////////////////////////////////////////////////////////////// (** Heap actions come in two equivalent flavors: - one that take an explicit frame as argument (action_with_frame) - and one that quantify over all the frame We therefore define two lift routes: - a direct route for those with explicit frame - via MstTotNF for the rest *) let tot_pre_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = hmem_with_inv_except e fp -> (x:a & hmem_with_inv_except e (fp' x)) let tot_pre_action_nf = tot_pre_action_nf_except S.empty let ac_reasoning_for_m_frame_preserving (p q r:slprop u#a) (m:mem u#a) : Lemma (requires interp ((p `star` q) `star` r) m) (ensures interp (p `star` r) m) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_commutative p q; equiv_extensional_on_star (p `star` q) (q `star` p) r } (q `star` p) `star` r; (equiv) { star_associative q p r } q `star` (p `star` r); }; assert (interp (q `star` (p `star` r)) m); affine_star q (p `star` r) m let is_frame_preserving (#e:inames) (#a:Type u#b) (#fp:slprop u#a) (#fp':a -> slprop u#a) (f:tot_pre_action_nf_except e fp a fp') = forall (frame:slprop u#a) (m0:hmem_with_inv_except e (fp `star` frame)). (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = f:tot_pre_action_nf_except e fp a fp'{ is_frame_preserving f } let tot_action_nf = tot_action_nf_except S.empty let linv e (m:mem) = locks_invariant e m let hheap_of_hmem #fp #e (m:hmem_with_inv_except e fp) : h:H.hheap (fp `star` linv e m) { h `H.free_above_addr` m.ctr} = let h = heap_of_mem m in H.pure_interp (heap_ctr_valid m.ctr (heap_of_mem m)) h; h let hmem_of_hheap #e (#fp0 #fp1:slprop) (m:hmem_with_inv_except e fp0) (h:H.full_hheap (fp1 `star` linv e m) { h `Heap.free_above_addr` m.ctr }) : m1:hmem_with_inv_except e fp1{linv e m `equiv` linv e m1} = let m1 : mem = { m with heap = h } in assert (interp (fp1 `star` linv e m) m1); star_commutative fp1 (linv e m); assert (interp (linv e m `star` fp1) m1); assert (linv e m1 == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); assert (linv e m == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m)); H.pure_interp (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_of_mem m); assert (heap_ctr_valid m1.ctr (heap_of_mem m) <==> heap_ctr_valid m1.ctr (heap_of_mem m1)); H.pure_equiv (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_ctr_valid m1.ctr (heap_of_mem m1)); H.star_congruence (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m)); assert (linv e m `equiv` linv e m1); let _ = equiv_extensional_on_star (linv e m) (linv e m1) fp1 in assert ((linv e m `star` fp1) `equiv` (linv e m1 `star` fp1)); assert (interp (linv e m1 `star` fp1) m1); star_commutative (linv e m1) fp1; assert (interp (fp1 `star` linv e m1) m1); m1 let with_inv_except (m:mem) e (fp:slprop) = interp (fp `star` locks_invariant e m) m #push-options "--warn_error -271" let as_hprop (frame:slprop) (mp:mprop frame) : hp:H.hprop frame{forall m. mp (core_mem m) == hp (heap_of_mem m)} = let f = fun h -> mp (mem_of_heap h) in assert (forall m. mp (core_mem m) == f (heap_of_mem m)); let aux (m0:H.hheap frame) (m1:H.heap{H.disjoint m0 m1}) : Lemma (ensures (mem_of_heap (H.join m0 m1) == join (mem_of_heap m0) (mem_of_heap m1))) [SMTPat ()] = () in f let mprop_preservation_of_hprop_preservation (p:slprop) (m0 m1:mem) : Lemma (requires (forall (hp:H.hprop p). hp (heap_of_mem m0) == hp (heap_of_mem m1))) (ensures (forall (mp:mprop p). mp (core_mem m0) == mp (core_mem m1))) = let aux (mp:mprop p) : Lemma (mp (core_mem m0) == mp (core_mem m1)) [SMTPat()] = assert (as_hprop p mp (heap_of_mem m0) == as_hprop p mp (heap_of_mem m1)) in () let lift_heap_action (#fp:slprop) (#a:Type) (#fp':a -> slprop) (e:inames) ($f:H.action fp a fp') : tot_action_nf_except e fp a fp' = let g : tot_pre_action_nf_except e fp a fp' = fun m -> let h0 = hheap_of_hmem m in let (| x, h' |) = f h0 in (| x, hmem_of_hheap m h' |) in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in let h0 = hheap_of_hmem m0 in let (| x', h1 |) = f h0 in H.action_framing f (linv e m0) h0; assert (x == x'); star_associative fp frame (linv e m0); H.action_framing f (frame `star` linv e m0) h0; assert (H.interp ((fp' x) `star` (frame `star` linv e m0)) h1); star_associative (fp' x) frame (linv e m0); assert (H.interp ((fp' x `star` frame) `star` linv e m0) h1); let h1' : H.hheap ((fp' x `star` frame) `star` linv e m0) = h1 in assert (m1 == hmem_of_hheap m0 h1'); assert (with_inv_except m1 e (fp' x `star` frame)); assert (forall (hp:H.hprop frame). hp h0 == hp h1); mprop_preservation_of_hprop_preservation frame m0 m1; () in assert (is_frame_preserving g); g let frame_preserving_respects_preorder #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (m0:hmem_with_inv_except e fp) : Lemma (let (| x, m1 |) = f m0 in mem_evolves m0 m1) = let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1) = () in H.emp_unit fp; assert (interp (fp `star` linv e m0) m0); H.star_congruence (fp `star` emp) (linv e m0) fp (linv e m0); assert (interp ((fp `star` emp) `star` linv e m0) m0); aux emp m0 let lift_tot_action_nf #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') : MstTotNF a e fp fp' = let m0 = NMSTTotal.get () in let m0' : hmem_with_inv_except e fp = m0 in let r = f m0' in let (| x, m1 |) = r in let m1' : hmem_with_inv_except e (fp' x) = m1 in assert (is_frame_preserving f); assert (m1 == dsnd (f m0)); frame_preserving_respects_preorder f m0; NMSTTotal.put #_ #(mem_evolves) m1; x let lift_tot_action #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get #(full_mem) #_ () in ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); lift_tot_action_nf f (** Now defining the lift for heap actions with explicit frame *) let tot_action_with_frame_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = frame:slprop u#a -> m0:hmem_with_inv_except e (fp `star` frame) -> Pure (x:a & hmem_with_inv_except e (fp' x `star` frame)) (requires True) (ensures fun (| x, m1 |) -> mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_with_frame = tot_action_with_frame_except S.empty let lift_heap_action_with_frame (#fp:slprop u#a) (#a:Type u#b) (#fp':a -> slprop u#a) (e:inames) ($f:H.action_with_frame fp a fp') : tot_action_with_frame_except e fp a fp' = fun frame m0 -> let h0 = hheap_of_hmem m0 in calc (equiv) { fp `star` frame `star` locks_invariant e m0; (equiv) { star_associative fp frame (locks_invariant e m0) } fp `star` (frame `star` locks_invariant e m0); }; assert (H.interp (fp `star` frame `star` locks_invariant e m0) h0); assert (H.interp (fp `star` (frame `star` locks_invariant e m0)) h0); //key: apply the heap action with frame * locks_invariant e m0 let (| x, h1 |) = f (frame `star` locks_invariant e m0) h0 in calc (equiv) { fp' x `star` (frame `star` locks_invariant e m0); (equiv) { star_associative (fp' x) frame (locks_invariant e m0) } fp' x `star` frame `star` locks_invariant e m0; }; assert (H.interp (fp' x `star` (frame `star` locks_invariant e m0)) h1); assert (H.interp (fp' x `star` frame `star` locks_invariant e m0) h1); let m1 = hmem_of_hheap m0 h1 in assert (mem_evolves m0 m1); mprop_preservation_of_hprop_preservation (frame `star` locks_invariant e m0) m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)); (| x, m1 |) let lift_tot_action_with_frame #a #e #fp #fp' ($f:tot_action_with_frame_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in assert (inames_ok e m0); ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); let m0' : hmem_with_inv_except e fp = m0 in let r = f frame m0' in let (| x, m1 |) = r in ac_reasoning_for_m_frame_preserving (fp' x) frame (locks_invariant e m1) m1; assert (interp (fp' x `star` frame `star` locks_invariant e m1) m1); assert (interp (fp' x `star` locks_invariant e m1) m1); let m1' : hmem_with_inv_except e (fp' x) = m1 in NMSTTotal.put #_ #(mem_evolves) m1; x let sel_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.sel_action #a #pcm r v0)) let upd_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.upd_action #a #pcm r v0 v1)) let free_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.free_action #a #pcm r v0)) let split_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.split_action #a #pcm r v0 v1)) let gather_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.gather_action #a #pcm r v0 v1)) let weaken (p q r:slprop) (h:H.hheap (p `star` q) { H.stronger q r }) : H.hheap (p `star` r) = H.weaken p q r h; h let weaken_pure (q r: prop) : Lemma (requires (q ==> r)) (ensures H.stronger (H.pure q) (H.pure r)) = let aux (h:H.heap) : Lemma (ensures (H.interp (H.pure q) h ==> H.interp (H.pure r) h)) [SMTPat ()] = H.pure_interp q h; H.pure_interp r h in () let inc_ctr (#p:slprop) #e (m:hmem_with_inv_except e p) : m':hmem_with_inv_except e p{m'.ctr = m.ctr + 1 /\ H.stronger (linv e m) (linv e m')} = let m' : mem = { m with ctr = m.ctr + 1} in assert (interp (p `star` linv e m) m'); assert (linv e m == lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m)); assert (linv e m' == lock_store_invariant e m.locks `star` ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken_free_above (heap_of_mem m) m.ctr (m.ctr + 1); weaken_pure (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_ctr_valid (m.ctr + 1) (heap_of_mem m)); assert (H.stronger (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m))); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)); H.stronger_star (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken (p `star` lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)) (heap_of_mem m'); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity (m.ctr + 1) (heap_of_mem m)); let m' : hmem_with_inv_except e p = m' in m' let frame_related_mems (fp0 fp1:slprop u#a) e (m0:hmem_with_inv_except e fp0) (m1:hmem_with_inv_except e fp1) = forall (frame:slprop u#a). interp ((fp0 `star` frame) `star` linv e m0) m0 ==> interp ((fp1 `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) let refined_pre_action e (fp0:slprop) (a:Type) (fp1:a -> slprop) = m0:hmem_with_inv_except e fp0 -> Pure (x:a & hmem_with_inv_except e (fp1 x)) (requires True) (ensures fun (| x, m1 |) -> frame_related_mems fp0 (fp1 x) e m0 m1) let refined_pre_action_as_action (#fp0:slprop) (#a:Type) (#fp1:a -> slprop) #e ($f:refined_pre_action e fp0 a fp1) : tot_action_nf_except e fp0 a fp1 = let g : tot_pre_action_nf_except e fp0 a fp1 = fun m -> f m in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp0 `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp1 x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x', m1' |) = g m0 in let (| x, m1 |) = f m0 in assert (x == x' /\ m1 == m1') in g let alloc_action #a #pcm e x = let f : refined_pre_action e emp (ref a pcm) (fun r -> pts_to r x) = fun m0 -> (* NS: 9/29/22 I needed to annotate h : Heap.full_heap, for use with the Core checker which generates a guard for checking the implicit pattern "dot" term in the dependent pair pattern on the next line. That guard expects `h` to be a full_heap, which is it, because it is a projection of m0. However, this is not reflected in `h`'s type. So, the Core checker, which produces a guard for the pat_dot_term in isolation, cannot recheck the term. If we were to fold in the checking of pat_dot_terms and their guards with the rest of the VC, this would work. *) let h : Heap.full_heap = hheap_of_hmem m0 in let (|r, h'|) = H.extend #a #pcm x m0.ctr h in let m' : hmem_with_inv_except e emp = inc_ctr m0 in let h' : H.hheap (pts_to #a #pcm r x `star` linv e m') = weaken _ (linv e m0) (linv e m') h' in let m1 : hmem_with_inv_except e (pts_to #a #pcm r x) = hmem_of_hheap m' h' in assert (forall frame. H.frame_related_heaps h h' emp (pts_to #a #pcm r x) frame true); let aux (frame:slprop) : Lemma (requires interp ((emp `star` frame) `star` linv e m0) m0) (ensures interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) [SMTPat (emp `star` frame)] = star_associative emp frame (linv e m0); assert (H.interp (emp `star` (frame `star` linv e m0)) h); assert (H.interp (pts_to #a #pcm r x `star` (frame `star` linv e m0)) h'); star_associative (pts_to #a #pcm r x) frame (linv e m0); assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m0) h'); assert (H.stronger (linv e m0) (linv e m')); assert (H.equiv (linv e m') (linv e m1)); assert (H.stronger (linv e m0) (linv e m1)); let h' : H.hheap ((pts_to #a #pcm r x `star` frame) `star` linv e m1) = weaken _ (linv e m0) (linv e m1) h' in assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) h'); assert (forall (mp:H.hprop frame). mp h == mp h'); mprop_preservation_of_hprop_preservation frame m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) in assert (frame_related_mems emp (pts_to r x) e m0 m1); (| r, m1 |) in lift_tot_action (refined_pre_action_as_action f) let select_refine #a #p e r x f = lift_tot_action (lift_heap_action e (H.select_refine #a #p r x f)) let upd_gen #a #p e r x y f = lift_tot_action (lift_heap_action e (H.upd_gen_action r x y f)) //////////////////////////////////////////////////////////////////////////////// // witness / recall //////////////////////////////////////////////////////////////////////////////// let witnessed_ref #a #pcm (r:ref a pcm) (fact:property a) (m:full_mem) = H.witnessed_ref #a #pcm r fact (heap_of_mem m) let witnessed_ref_stability #a #pcm (r:ref a pcm) (fact:property a) : Lemma (requires FStar.Preorder.stable fact (Steel.Preorder.preorder_of_pcm pcm)) (ensures FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) = H.witnessed_ref_stability #a #pcm r fact let witnessed (#a:Type u#1) (#pcm:pcm a) (r:ref a pcm) (fact:property a) = W.witnessed _ mem_evolves (witnessed_ref r fact) let rearrange_pqr_prq (p q r:slprop) : Lemma (((p `star` q) `star` r) `equiv` ((p `star` r) `star` q)) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_associative p q r } p `star` (q `star` r); (equiv) { star_commutative q r; star_congruence p (q `star` r) p (r `star` q) } p `star` (r `star` q); (equiv) { star_associative p r q } (p `star` r) `star` q; } let preserves_frame_cong (e:inames) (p q:slprop) (r s:slprop) (m0 m1:mem) : Lemma (requires p `equiv` r /\ q `equiv` s /\ preserves_frame e p q m0 m1) (ensures preserves_frame e r s m0 m1) = let aux0 (p q r s:slprop) : Lemma (requires p `equiv` s) (ensures (((p `star` q) `star` r) `equiv` ((s `star` q) `star` r))) = star_congruence p q s q; star_congruence (p `star` q) r (s `star` q) r in let aux (frame:slprop) : Lemma (requires interp ((r `star` frame) `star` locks_invariant e m0) m0) (ensures interp ((s `star` frame) `star` locks_invariant e m1) m1 /\ interp ((p `star` frame) `star` locks_invariant e m0) m0) [SMTPat (r `star` frame)] = aux0 p frame (locks_invariant e m0) r; aux0 q frame (locks_invariant e m1) s; assert (((p `star` frame) `star` locks_invariant e m0) `equiv` ((r `star` frame) `star` locks_invariant e m0)); assert (interp ((p `star` frame) `star` locks_invariant e m0) m0); assert (interp ((q `star` frame) `star` locks_invariant e m1) m1); assert (((q `star` frame) `star` locks_invariant e m1) `equiv` ((s `star` frame) `star` locks_invariant e m1)); () in () let pure_true_equiv (p:slprop) : Lemma ((p `star` pure True) `equiv` p) = FStar.Classical.forall_intro (pure_star_interp p True); emp_unit p; assert ((p `star` pure True) `equiv` p) let preserves_frame_star_pure (e:inames) (p q:slprop) (r s:prop) (m:mem) : Lemma (requires r /\ s) (ensures preserves_frame e p q m m <==> preserves_frame e (p `star` pure r) (q `star` pure s) m m) = pure_equiv r True; star_congruence p (pure r) p (pure True); pure_equiv s True; star_congruence q (pure s) q (pure True); pure_true_equiv p; pure_true_equiv q; let fwd () : Lemma (requires preserves_frame e p q m m) (ensures preserves_frame e (p `star` pure r) (q `star` pure s) m m) [SMTPat ()] = preserves_frame_cong e p q (p `star` pure r) (q `star` pure s) m m in let bk () : Lemma (requires preserves_frame e (p `star` pure r) (q `star` pure s) m m) (ensures preserves_frame e p q m m) [SMTPat ()] = preserves_frame_cong e (p `star` pure r) (q `star` pure s) p q m m in () let witness (#a:Type) (#pcm:pcm a) (e:inames) (r:erased (ref a pcm)) (fact:stable_property pcm) (v:Ghost.erased a) (_:squash (forall z. compatible pcm v z ==> fact z)) (frame:slprop) : MstTot (witnessed r fact) e (pts_to r v) (fun _ -> pts_to r v) frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in let _ : unit = let hr : H.ref a pcm = r in let v' = H.sel_v hr v (heap_of_mem m0) in assert (interp (H.ptr hr) m0 /\ H.sel #a #pcm hr (heap_of_mem m0) == v'); assert (compatible pcm v v'); assert (fact v'); assert (witnessed_ref r fact m0); witnessed_ref_stability r fact; assert (FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) in let w = NMSTTotal.witness _ mem_evolves (witnessed_ref r fact) in w let recall (#a:Type u#1) (#pcm:pcm a) (#fact:property a) (e:inames) (r:erased (ref a pcm)) (v:Ghost.erased a) (w:witnessed r fact) (frame:slprop) = let m0 = NMSTTotal.get () in NMSTTotal.recall _ mem_evolves (witnessed_ref r fact) w; let hr : H.ref a pcm = r in assert (witnessed_ref r fact m0); let v1 = H.sel_v hr v (heap_of_mem m0) in assert (compatible pcm v v1); assert (H.sel hr (heap_of_mem m0) == v1); assert (fact v1); assert (interp ((pts_to r v `star` frame) `star` locks_invariant e m0) m0); emp_unit ((pts_to r v `star` frame) `star` locks_invariant e m0); pure_star_interp ((pts_to r v `star` frame) `star` locks_invariant e m0) (fact v1) m0; assert (interp (((pts_to r v `star` frame) `star` locks_invariant e m0) `star` pure (fact v1)) m0); rearrange_pqr_prq (pts_to r v `star` frame) (locks_invariant e m0) (pure (fact v1)); assert (interp (((pts_to r v `star` frame) `star` pure (fact v1)) `star` locks_invariant e m0) m0); rearrange_pqr_prq (pts_to r v) frame (pure (fact v1)); star_congruence ((pts_to r v `star` frame) `star` pure (fact v1)) (locks_invariant e m0) ((pts_to r v `star` pure (fact v1)) `star` frame) (locks_invariant e m0); Ghost.hide v1 let iname_for_p_mem (i:iname) (p:slprop) : W.s_predicate mem = fun m -> iname_for_p i p m.locks let iname_for_p_stable (i:iname) (p:slprop) : Lemma (W.stable full_mem mem_evolves (iname_for_p_mem i p)) = () let ( >--> ) (i:iname) (p:slprop) : Type0 = W.witnessed full_mem mem_evolves (iname_for_p_mem i p) let hmem_with_inv_equiv e (m:mem) (p:slprop) : Lemma (interp (p `star` linv e m) m <==> interp (p `star` lock_store_invariant e m.locks) m /\ heap_ctr_valid m.ctr (heap_of_mem m)) = calc (<==>) { interp (p `star` linv e m) m; (<==>) { H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) } interp ((p `star` lock_store_invariant e m.locks) `star` ctr_validity m.ctr (heap_of_mem m)) m; (<==>) { H.pure_star_interp (p `star` lock_store_invariant e m.locks) (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_of_mem m) } interp ((p `star` lock_store_invariant e m.locks) `star` emp) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); (<==>) { H.emp_unit (p `star` lock_store_invariant e m.locks) } interp (p `star` lock_store_invariant e m.locks) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); } let new_invariant_tot_action (e:inames) (p:slprop) (m0:hmem_with_inv_except e p{ e `inames_in` m0.locks }) : Pure (iname & hmem_with_inv_except e emp) (requires True) (ensures fun (i, m1) -> iname_for_p_mem i p m1 /\ frame_related_mems p emp e m0 m1 /\ mem_evolves m0 m1) = let (| i, l1 |) = extend_lock_store e m0.locks p in let m1 = { m0 with locks = l1 } in assert (lock_store_invariant e m1.locks == p `star` lock_store_invariant e m0.locks); calc (equiv) { linv e m1; (equiv) {} (lock_store_invariant e m1.locks `star` ctr_validity m1.ctr (heap_of_mem m1)); (equiv) {} ((p `star` lock_store_invariant e m0.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); (equiv) { H.star_associative p (lock_store_invariant e m0.locks) (ctr_validity m1.ctr (heap_of_mem m1)) } (p `star` (lock_store_invariant e m0.locks `star` ctr_validity m1.ctr (heap_of_mem m1))); (equiv) { } (p `star` linv e m0); }; assert (iname_for_p_mem i p m1); assert (lock_store_evolves m0.locks l1); assert (mem_evolves m0 m1); hmem_with_inv_equiv e m0 p; assert (interp (p `star` lock_store_invariant e m0.locks) m1); assert (interp (lock_store_invariant e m1.locks) m1); H.emp_unit (lock_store_invariant e m1.locks); H.star_commutative (lock_store_invariant e m1.locks) emp; assert (interp (emp `star` lock_store_invariant e m1.locks) m1); hmem_with_inv_equiv e m1 emp; let m1 : hmem_with_inv_except e emp = m1 in let aux (frame:slprop) : Lemma (requires interp ((p `star` frame) `star` linv e m0) m0) (ensures interp ((emp `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) <==> mp (core_mem m1))) [SMTPat (p `star` frame)] = assert (interp ((p `star` frame) `star` linv e m0) m1); calc (equiv) { ((p `star` frame) `star` linv e m0); (equiv) { H.star_commutative p frame; H.star_congruence (p `star` frame) (linv e m0) (frame `star` p) (linv e m0); H.star_associative frame p (linv e m0) } (frame `star` (p `star` linv e m0)); (equiv) { H.star_congruence frame (p `star` linv e m0) frame (linv e m1) } (frame `star` linv e m1); (equiv) { H.emp_unit (frame `star` linv e m1); H.star_commutative (frame `star` linv e m1) emp; H.star_associative emp frame (linv e m1) } ((emp `star` frame) `star` linv e m1); }; assert (interp ((emp `star` frame) `star` linv e m1) m1) in assert (frame_related_mems p emp e m0 m1); ( i, m1 ) let name_is_ok (i:iname) (m0:full_mem u#1) : prop = i < List.Tot.length m0.locks let witnessed_name_is_ok (i:iname) = W.witnessed full_mem mem_evolves (name_is_ok i) let pre_inv = i:erased iname & witnessed_name_is_ok i let inv (p:slprop u#1) = i:erased iname & witnessed_name_is_ok i & (i >--> p) let pre_inv_of_inv #p (i:inv p) = let (|i, w, _|) = i in (|i,w|) let name_of_pre_inv (i:pre_inv) = dfst i let rec recall_all (ctx:list pre_inv) : NMSTTotal.NMSTATETOT unit (full_mem u#1) mem_evolves (requires fun _ -> True) (ensures fun m0 _ m1 -> m0==m1 /\ (forall i. i `List.Tot.memP` ctx ==> name_is_ok (name_of_pre_inv i) m0)) = match ctx with | [] -> () | hd::tl -> let (| q, i |) = hd in let i : W.witnessed full_mem mem_evolves (name_is_ok q) = i in NMSTTotal.recall _ mem_evolves (name_is_ok q) i; recall_all tl let fresh_invariant (e:inames) (p:slprop) (ctx:list pre_inv) (frame:slprop) : MstTot (i:inv p { not (mem_inv e i) /\ fresh_wrt ctx (name_of_inv i)}) e p (fun _ -> emp) frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in recall_all ctx; ac_reasoning_for_m_frame_preserving p frame (locks_invariant e m0) m0; assert (interp (p `star` locks_invariant e m0) m0); let r = new_invariant_tot_action e p m0 in let ( i, m1 ) = r in assert (i == List.Tot.length m0.locks); assert (not (Set.mem i e)); assert (mem_evolves m0 m1); NMSTTotal.put #full_mem #mem_evolves m1; iname_for_p_stable i p; let w = NMSTTotal.witness full_mem mem_evolves (iname_for_p_mem i p) in let w0 = NMSTTotal.witness full_mem mem_evolves (name_is_ok i) in (| hide i, w0, w |) let new_invariant (e:inames) (p:slprop) (frame:slprop) : MstTot (inv p) e p (fun _ -> emp) frame (fun _ -> True) (fun _ _ _ -> True) = fresh_invariant e p [] frame let rearrange_invariant (p q r : slprop) (q0 q1:slprop) : Lemma (requires q `equiv` (q0 `star` q1)) (ensures (p `star` (q `star` r)) `equiv` ((q0 `star` p) `star` (q1 `star` r))) = calc (equiv) { p `star` (q `star` r); (equiv) { calc (equiv) { (q `star` r); (equiv) { star_congruence q r (q0 `star` q1) r } (q0 `star` q1) `star` r; }; star_congruence p (q `star` r) p ((q0 `star` q1) `star` r) } (p `star` ((q0 `star` q1) `star` r)); (equiv) { star_associative q0 q1 r; star_congruence p ((q0 `star` q1) `star` r) p (q0 `star` (q1 `star` r)); star_associative p q0 (q1 `star` r) } (p `star` q0) `star` (q1 `star` r); (equiv) { star_commutative p q0; star_congruence (p `star` q0) (q1 `star` r) (q0 `star` p) (q1 `star` r) } (q0 `star` p) `star` (q1 `star` r); } let preserves_frame_invariant (fp fp':slprop) (opened_invariants:inames) (p:slprop) (i:inv p{not (mem_inv opened_invariants i)}) (m0:hmem_with_inv_except (add_inv opened_invariants i) (p `star` fp)) (m1:mem) : Lemma (requires preserves_frame (set_add (name_of_inv i) opened_invariants) (p `star` fp) (p `star` fp') m0 m1 /\ interp (fp' `star` linv opened_invariants m1) m1 /\ inames_ok opened_invariants m1 /\ (lock_store_invariant opened_invariants m0.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks)) /\ (lock_store_invariant opened_invariants m1.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks))) (ensures preserves_frame opened_invariants fp fp' m0 m1) = let aux (frame:slprop) : Lemma (requires interp ((fp `star` frame) `star` linv opened_invariants m0) m0) (ensures interp ((fp' `star` frame) `star` linv opened_invariants m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) [SMTPat()] = rearrange_invariant (fp `star` frame) (lock_store_invariant opened_invariants m0.locks) (ctr_validity m0.ctr (heap_of_mem m0)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks); assert (interp ((p `star` (fp `star` frame)) `star` linv (set_add (name_of_inv i) opened_invariants) m0) m0); star_associative p fp frame; star_congruence (p `star` (fp `star` frame)) (linv (set_add (name_of_inv i) opened_invariants) m0) ((p `star` fp) `star` frame) (linv (set_add (name_of_inv i) opened_invariants) m0); assert (interp (((p `star` fp) `star` frame) `star` linv (set_add (name_of_inv i) opened_invariants) m0) m0); assert (interp (((p `star` fp') `star` frame) `star` linv (set_add (name_of_inv i) opened_invariants) m1) m1); star_associative p fp' frame; star_congruence ((p `star` fp') `star` frame) (linv (set_add (name_of_inv i) opened_invariants) m1) (p `star` (fp' `star` frame)) (linv (set_add (name_of_inv i) opened_invariants) m1); assert (interp ((p `star` (fp' `star` frame)) `star` linv (set_add (name_of_inv i) opened_invariants) m1) m1); rearrange_invariant (fp' `star` frame) (lock_store_invariant opened_invariants m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks); assert (interp ((fp' `star` frame) `star` linv opened_invariants m1) m1); () in () let equiv_ext_right (p q r:slprop) : Lemma (requires q `equiv` r) (ensures (p `star` q) `equiv` (p `star` r)) = calc (equiv) { p `star` q; (equiv) { star_commutative p q } q `star` p; (equiv) { equiv_extensional_on_star q r p } r `star` p; (equiv) { star_commutative p r } p `star` r; } let with_inv_helper (fp frame ls1 ctr p ls2:slprop) : Lemma (requires ls1 `equiv` (p `star` ls2)) (ensures (fp `star` frame `star` (ls1 `star` ctr)) `equiv` (p `star` fp `star` frame `star` (ls2 `star` ctr))) = calc (equiv) { ls1 `star` ctr; (equiv) { equiv_extensional_on_star ls1 (p `star` ls2) ctr } p `star` ls2 `star` ctr; }; calc (equiv) { p `star` ls2 `star` ctr; (equiv) { star_associative p ls2 ctr } p `star` (ls2 `star` ctr); }; calc (equiv) { fp `star` frame `star` p; (equiv) { star_commutative (fp `star` frame) p } p `star` (fp `star` frame); (equiv) { star_associative p fp frame } p `star` fp `star` frame; }; calc (equiv) { fp `star` frame `star` (ls1 `star` ctr); (equiv) { equiv_ext_right (fp `star` frame) (ls1 `star` ctr) (p `star` ls2 `star` ctr) } (fp `star` frame) `star` (p `star` ls2 `star` ctr); (equiv) { equiv_ext_right (fp `star` frame) (p `star` ls2 `star` ctr) (p `star` (ls2 `star` ctr)) } (fp `star` frame) `star` (p `star` (ls2 `star` ctr)); (equiv) { star_associative (fp `star` frame) p (ls2 `star` ctr) } (fp `star` frame `star` p) `star` (ls2 `star` ctr); (equiv) { equiv_extensional_on_star (fp `star` frame `star` p) (p `star` fp `star` frame) (ls2 `star` ctr) } (p `star` fp `star` frame) `star` (ls2 `star` ctr); } let token_of_inv #p (i:inv p) : (name_of_inv i >--> p) = let (| _, _, tok |) = i in tok let with_invariant (#a:Type) (#fp:slprop) (#fp':a -> slprop) (#opened_invariants:inames) (#p:slprop) (i:inv p{not (mem_inv opened_invariants i)}) (f:action_except a (add_inv opened_invariants i) (p `star` fp) (fun x -> p `star` fp' x)) (frame:slprop) : MstTot a opened_invariants fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in NMSTTotal.recall _ mem_evolves (iname_for_p_mem (name_of_inv i) p) (token_of_inv i); assert (iname_for_p (name_of_inv i) p m0.locks); assert (interp (fp `star` frame `star` locks_invariant opened_invariants m0) m0); assert (interp (fp `star` frame `star` (lock_store_invariant opened_invariants m0.locks `star` ctr_validity m0.ctr (heap_of_mem m0))) m0); move_invariant opened_invariants m0.locks p (name_of_inv i); assert (lock_store_invariant opened_invariants m0.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks)); with_inv_helper fp frame (lock_store_invariant opened_invariants m0.locks) (ctr_validity m0.ctr (heap_of_mem m0)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks); assert (interp (p `star` fp `star` frame `star` locks_invariant (set_add (name_of_inv i) opened_invariants) m0) m0); let r = f frame in let m1 : full_mem = NMSTTotal.get () in assert (interp (p `star` fp' r `star` frame `star` locks_invariant (set_add (name_of_inv i) opened_invariants) m1) m1); assert (interp (p `star` fp' r `star` frame `star` (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks `star` ctr_validity m1.ctr (heap_of_mem m1))) m1); NMSTTotal.recall _ mem_evolves (iname_for_p_mem (name_of_inv i) p) (token_of_inv i); move_invariant opened_invariants m1.locks p (name_of_inv i); assert (lock_store_invariant opened_invariants m1.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks)); with_inv_helper (fp' r) frame (lock_store_invariant opened_invariants m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks); assert (interp (fp' r `star` frame `star` locks_invariant opened_invariants m1) m1); assert (inames_ok opened_invariants m1); r let equiv_pqrs_p_qr_s (p q r s:slprop) : Lemma ((p `star` q `star` r `star` s) `equiv` (p `star` (q `star` r) `star` s)) = star_associative p q r; equiv_extensional_on_star (p `star` q `star` r) (p `star` (q `star` r)) s let frame (#a:Type) (#opened_invariants:inames) (#pre:slprop) (#post:a -> slprop) (#req:mprop pre) (#ens:mprop2 pre post) (frame:slprop) ($f:action_except_full a opened_invariants pre post req ens) (frame0:slprop) : MstTot a opened_invariants (pre `star` frame) (fun x -> post x `star` frame) frame0 req ens = let m0 : full_mem = NMSTTotal.get () in equiv_pqrs_p_qr_s pre frame frame0 (linv opened_invariants m0); assert (interp (pre `star` frame `star` frame0 `star` linv opened_invariants m0) m0); assert (interp (pre `star` (frame `star` frame0) `star` linv opened_invariants m0) m0); let x = f (frame `star` frame0) in let m1 : full_mem = NMSTTotal.get () in equiv_pqrs_p_qr_s (post x) frame frame0 (linv opened_invariants m1); assert (interp (post x `star` (frame `star` frame0) `star` linv opened_invariants m1) m1); assert (interp (post x `star` frame `star` frame0 `star` linv opened_invariants m1) m1); x let change_slprop (#opened_invariants:inames) (p q:slprop) (proof: (m:mem -> Lemma (requires interp p m) (ensures interp q m))) = let proof (h:H.heap) : Lemma (requires H.interp p h) (ensures H.interp q h) = proof (mem_of_heap h) in lift_tot_action (lift_heap_action opened_invariants (Steel.Heap.change_slprop p q proof)) (* This module reuses is_frame_monotonic from Heap, but does not expose that to clients, so we need this lemma to typecheck witness_h_exists below. *) let relate_frame_monotonic_1 #a p : Lemma (requires (H.is_frame_monotonic p)) (ensures (is_frame_monotonic p)) = () let relate_frame_monotonic_2 #a p : Lemma (requires (is_frame_monotonic p)) (ensures (H.is_frame_monotonic p)) = let aux (x y : a) (h : H.heap) (f : H.slprop) : Lemma (requires (H.interp (p x `H.star` f) h /\ H.interp (p y) h)) (ensures (H.interp (p y `H.star` f) h)) = let m = mem_of_heap h in assert (interp (p x `star` f) m); assert (interp (p y) m); assert (interp (p y `star` f) m) in Classical.forall_intro_4 (fun x y h f -> Classical.move_requires (aux x y h) f) let witness_h_exists #opened_invariants #a p = lift_tot_action_with_frame (lift_heap_action_with_frame opened_invariants (H.witness_h_exists p)) let lift_h_exists #opened_invariants p = lift_tot_action (lift_heap_action opened_invariants (H.lift_h_exists p))

{ "checked_file": "/", "dependencies": [ "Steel.Preorder.fst.checked", "Steel.Heap.fsti.checked", "prims.fst.checked", "FStar.Witnessed.Core.fsti.checked", "FStar.Set.fsti.checked", "FStar.Preorder.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.PCM.fst.checked", "FStar.NMSTTotal.fst.checked", "FStar.List.Tot.fst.checked", "FStar.IndefiniteDescription.fsti.checked", "FStar.Ghost.fsti.checked", "FStar.FunctionalExtensionality.fsti.checked", "FStar.Classical.Sugar.fsti.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Steel.Memory.fst" }

[ { "abbrev": true, "full_module": "Steel.Preorder", "short_module": "PP" }, { "abbrev": true, "full_module": "FStar.Witnessed.Core", "short_module": "W" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": true, "full_module": "Steel.Heap", "short_module": "H" }, { "abbrev": false, "full_module": "FStar.FunctionalExtensionality", "short_module": null }, { "abbrev": true, "full_module": "FStar.FunctionalExtensionality", "short_module": "F" }, { "abbrev": true, "full_module": "FStar.Universe", "short_module": "U" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": false, "full_module": "FStar.PCM", "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

p: Prims.prop -> Steel.Memory.action_except (u1594: Prims.unit{p}) opened_invariants (Steel.Memory.pure p) (fun _ -> Steel.Memory.emp)

Prims.Tot

[ "total" ]

[]

[ "Steel.Memory.inames", "Prims.prop", "Steel.Memory.lift_tot_action", "Prims.unit", "Steel.Heap.pure", "Steel.Heap.emp", "Steel.Memory.slprop", "Steel.Memory.lift_heap_action", "Steel.Heap.elim_pure", "Steel.Memory.action_except", "Steel.Memory.pure", "Steel.Memory.emp" ]

[]

false

let elim_pure #opened_invariants p =

lift_tot_action (lift_heap_action opened_invariants (H.elim_pure p))

false

Steel.Memory.fst

Steel.Memory.witness_h_exists

val witness_h_exists (#opened_invariants:_) (#a:_) (p:a -> slprop) : action_except (erased a) opened_invariants (h_exists p) (fun x -> p x)

let witness_h_exists #opened_invariants #a p = lift_tot_action_with_frame (lift_heap_action_with_frame opened_invariants (H.witness_h_exists p))

{ "file_name": "lib/steel/Steel.Memory.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 99, "end_line": 1554, "start_col": 0, "start_line": 1553 }

(* 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.Memory module F = FStar.FunctionalExtensionality open FStar.FunctionalExtensionality open FStar.PCM module H = Steel.Heap noeq type lock_state : Type u#(a + 1) = | Invariant : inv:H.slprop u#a -> lock_state let lock_store : Type u#(a+1) = list (lock_state u#a) noeq type mem : Type u#(a + 1) = { ctr: nat; heap: H.heap u#a; locks: lock_store u#a; } let heap_of_mem (x:mem) : H.heap = x.heap let mem_of_heap (h:H.heap) : mem = { ctr = 0; heap = h; locks = [] } let mem_set_heap (m:mem) (h:H.heap) : mem = { ctr = m.ctr; heap = h; locks = m.locks; } let core_mem (m:mem) : mem = mem_of_heap (heap_of_mem m) let core_mem_invol m = () let disjoint (m0 m1:mem u#h) : prop = m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks let disjoint_sym m0 m1 = () let join m0 m1 = { ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = m0.locks } let join_commutative m0 m1 = H.join_commutative m0.heap m1.heap let disjoint_join m0 m1 m2 = H.disjoint_join m0.heap m1.heap m2.heap let join_associative m0 m1 m2 = H.join_associative m0.heap m1.heap m2.heap let slprop = H.slprop let interp p m = H.interp p m.heap let equiv p1 p2 = forall m. interp p1 m <==> interp p2 m let slprop_extensionality p q = assert (forall m. interp p m <==> interp q m); let aux (h:H.heap) : Lemma (H.interp p h <==> H.interp q h) [SMTPat (H.interp p h)] = let m : mem = { ctr = 0; heap = h; locks = [] } in assert (interp p m <==> interp q m) in assert (forall h. H.interp p h <==> H.interp q h); Steel.Heap.slprop_extensionality p q let reveal_equiv p1 p2 = () let core_ref = H.core_ref let core_ref_null = H.core_ref_null let core_ref_is_null r = H.core_ref_is_null r let emp : slprop u#a = H.emp let pure = H.pure let pts_to = H.pts_to let h_and = H.h_and let h_or = H.h_or let star = H.star let wand = H.wand let h_exists = H.h_exists let h_forall = H.h_forall //////////////////////////////////////////////////////////////////////////////// //properties of equiv //////////////////////////////////////////////////////////////////////////////// let equiv_symmetric (p1 p2:slprop u#a) = H.equiv_symmetric p1 p2 #push-options "--warn_error -271" let equiv_heap_iff_equiv (p1 p2:slprop u#a) : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat (equiv p1 p2)] = let aux_lr () : Lemma (requires H.equiv p1 p2) (ensures equiv p1 p2) [SMTPat ()] = () in let aux_rl_helper1 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p1 h) (ensures H.interp p2 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl_helper2 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p2 h) (ensures H.interp p1 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl () : Lemma (requires equiv p1 p2) (ensures H.equiv p1 p2) [SMTPat ()] = () in () let equiv_heap_iff_equiv_forall () : Lemma (ensures (forall p1 p2. H.equiv p1 p2 <==> equiv p1 p2)) = let aux p1 p2 : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat ()] = equiv_heap_iff_equiv p1 p2 in () #pop-options let equiv_extensional_on_star (p1 p2 p3:slprop u#a) = equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3 let emp_unit p = H.emp_unit p let intro_emp m = H.intro_emp (heap_of_mem m) let pure_equiv p q = H.pure_equiv p q let pure_interp q m = H.pure_interp q (heap_of_mem m) let pure_star_interp p q m = H.pure_star_interp p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// //pts_to //////////////////////////////////////////////////////////////////////////////// let pts_to_compatible #a #pcm x v0 v1 m = H.pts_to_compatible #a #pcm x v0 v1 (heap_of_mem m) let pts_to_compatible_equiv #a #pcm x v0 v1 = H.pts_to_compatible_equiv #a #pcm x v0 v1 let pts_to_not_null #a #pcm x v m = H.pts_to_not_null #a #pcm x v (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // star //////////////////////////////////////////////////////////////////////////////// let intro_star p q mp mq = H.intro_star p q (heap_of_mem mp) (heap_of_mem mq) let elim_star p q m = let h = heap_of_mem m in H.elim_star p q h; assert (exists hl hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr); let hl = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hl -> exists hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let hr = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hr -> H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let ml = mem_set_heap m hl in let mr = mem_set_heap m hr in assert (disjoint ml mr); assert (m == join ml mr); assert (interp p ml); assert (interp q mr); () let interp_star (p q: slprop) (m: mem) : Lemma (interp (p `star` q) m <==> (exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m)) = let left = interp (p `star` q) m in let right = exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m in let f () : Lemma (requires left) (ensures right) = elim_star p q m in let g () : Lemma (requires right) (ensures left) = Classical.exists_elim left #_ #(fun mp -> exists (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mp -> Classical.exists_elim left #_ #(fun mq -> disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mq -> intro_star p q mp mq ) ) in Classical.move_requires f (); Classical.move_requires g () let star_commutative (p1 p2:slprop) = H.star_commutative p1 p2 let star_associative (p1 p2 p3:slprop) = H.star_associative p1 p2 p3 let star_congruence (p1 p2 p3 p4:slprop) = equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4 let affine_star (p q:slprop) (m:mem) = H.affine_star p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // Invariants on the lock store //////////////////////////////////////////////////////////////////////////////// let iname = nat module S = FStar.Set module L = FStar.List.Tot module W = FStar.Witnessed.Core let rec lock_store_invariant (e:inames) (l:lock_store u#a) : slprop u#a = let current_addr = L.length l - 1 in match l with | [] -> emp | Invariant p :: tl -> if current_addr `S.mem` e then lock_store_invariant e tl else p `star` lock_store_invariant e tl let lock_i (i:iname) (l:lock_store { i < L.length l }) = let ix = L.length l - i - 1 in L.index l ix let iname_for_p (i:iname) (p:slprop) : W.s_predicate lock_store = fun l -> i < L.length l /\ (lock_i i l).inv == p let lock_store_evolves : FStar.Preorder.preorder lock_store = fun (l1 l2 : lock_store) -> L.length l2 >= L.length l1 /\ (forall (i:nat{i < L.length l1}). (lock_i i l1).inv == (lock_i i l2).inv) let inames_in (e:inames) (l:lock_store) : prop = forall i. Set.mem i e ==> i < L.length l let inames_ok e m = inames_in e m.locks let inames_ok_empty m = () let extend_lock_store (e:inames) (l:lock_store{e `inames_in` l}) (p:slprop) : i:iname & l':lock_store { lock_store_invariant e l' == p `star` lock_store_invariant e l /\ iname_for_p i p l' } = (| L.length l, Invariant p :: l |) let set_add (i:iname) (s:inames) = Set.union (Set.singleton i) s let rec move_invariant (e:inames) (l:lock_store) (p:slprop) (i:iname{iname_for_p i p l /\ ~(i `Set.mem` e)}) : Lemma (H.equiv (lock_store_invariant e l) (p `star` lock_store_invariant (set_add i e) l)) = let rec aux (i:iname) (m:lock_store) : Lemma (requires i >= L.length m) (ensures (lock_store_invariant e m `H.equiv` lock_store_invariant (set_add i e) m)) = match m with | [] -> () | Invariant p::tl -> aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl) in let current_addr = L.length l - 1 in match l with | [] -> () | Invariant q::tl -> if i = current_addr then begin assert (lock_store_invariant e l == p `star` lock_store_invariant e tl); aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl); () end else begin move_invariant e tl p i; assert (lock_store_invariant e tl `equiv` (p `star` lock_store_invariant (set_add i e) tl)); H.star_congruence q (lock_store_invariant e tl) q (p `star` lock_store_invariant (set_add i e) tl); if Set.mem current_addr e then () else begin let r = lock_store_invariant (set_add i e) tl in assert (lock_store_invariant e l `equiv` (q `star` (p `star` r))); H.star_associative q p r; H.star_commutative q p; H.star_congruence (q `star` p) r (p `star` q) r; H.star_associative p q r end end let heap_ctr_valid (ctr:nat) (h:H.heap u#a) : prop = h `H.free_above_addr` ctr let ctr_validity (ctr:nat) (h:H.heap) : slprop = H.pure (heap_ctr_valid ctr h) let locks_invariant (e:inames) (m:mem u#a) : slprop u#a = lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m) let full_mem_pred (m:mem) = H.full_heap_pred (heap_of_mem m) (***** Following lemmas are needed in Steel.Effect *****) let core_mem_interp (hp:slprop u#a) (m:mem u#a) = () let interp_depends_only_on (hp:slprop u#a) = H.interp_depends_only_on hp let a_mem_prop_as_a_heap_prop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (H.a_heap_prop u#a) = let g (h: H.heap u#a) : Tot prop = interp sl (mem_of_heap h) /\ f (mem_of_heap h) in let phi0 (h0 h1: H.heap u#a) : Lemma (requires (g h0 /\ H.disjoint h0 h1)) (ensures (g h0 /\ H.disjoint h0 h1 /\ g (H.join h0 h1))) = assert (mem_of_heap (H.join h0 h1) == mem_of_heap h0 `join` mem_of_heap h1); interp_depends_only_on sl in let phi1 (h0 h1: H.heap u#a) : Lemma (ensures ((g h0 /\ H.disjoint h0 h1) ==> g (H.join h0 h1))) = Classical.move_requires (phi0 h0) h1 in Classical.forall_intro_2 phi1; g let refine_slprop sl f = H.as_slprop (a_mem_prop_as_a_heap_prop sl f) let interp_refine_slprop sl f m = assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_mem m)) let dep_hprop (s: slprop) (f: (hmem s -> Tot slprop)) (h: H.heap) : Tot prop = exists (h1: H.heap) . exists (h2: H.heap) . interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 let dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq' : squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h')) = let p2 (h h1 h2: H.heap) : Tot prop = interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 in let p1 (h h1: H.heap) : Tot prop = (exists h2 . p2 h h1 h2) in let h1 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p1 h) in let h2 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p2 h h1) in H.disjoint_join h' h1 h2; assert (H.disjoint h2 h'); let h2' = H.join h2 h' in H.join_commutative h2 h' ; assert (h2' == H.join h' h2); assert (H.disjoint h1 h2'); assert (mem_of_heap h2' == mem_of_heap h2 `join` mem_of_heap h'); interp_depends_only_on (f (mem_of_heap h1)); assert (interp (f (mem_of_heap h1)) (mem_of_heap h2')); H.join_commutative h1 h2; H.join_associative h' h2 h1; H.join_commutative h' h; H.join_commutative h2' h1; assert (H.join h h' == h1 `H.join` h2') let impl_intro_gen (#p: Type0) (#q: Type0) ($prf: (squash p -> Lemma (q ))) : Lemma (p ==> q) = Classical.impl_intro_gen #p #(fun _ -> q) prf let dep_hprop_is_affine1 (s: slprop) (f: (hmem s -> Tot slprop)) (h0 h1: H.heap) : Lemma ((dep_hprop s f h0 /\ H.disjoint h0 h1) ==> (H.disjoint h0 h1 /\ dep_hprop s f (H.join h0 h1))) = impl_intro_gen (dep_hprop_is_affine0 s f h0 h1) let dep_hprop_is_affine (s: slprop) (f: (hmem s -> Tot slprop)) : Lemma (H.heap_prop_is_affine (dep_hprop s f)) = Classical.forall_intro_2 (dep_hprop_is_affine1 s f) let sdep (s: slprop) (f: (hmem s -> Tot slprop)) : Tot slprop = dep_hprop_is_affine s f; H.as_slprop (dep_hprop s f) let interp_sdep (s: slprop) (f: (hmem s -> Tot slprop)) (m: mem) : Lemma (requires (dep_slprop_is_affine s f)) (ensures ( interp (sdep s f) m <==> (exists m1 m2 . interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) )) = dep_hprop_is_affine s f; assert (forall m1 m2 . (interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) ==> ( interp s (mem_of_heap m1.heap) /\ interp (f (mem_of_heap m1.heap)) (mem_of_heap m2.heap) /\ H.disjoint m1.heap m2.heap /\ H.join m1.heap m2.heap == m.heap )); interp_depends_only_on s; Classical.forall_intro (fun m -> interp_depends_only_on (f m)); assert (forall h1 h2 . (interp s (mem_of_heap h1) /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ H.disjoint h1 h2 /\ H.join h1 h2 == m.heap) ==> ( core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ interp s (core_mem (mem_of_heap h1)) /\ interp s (mem_set_heap m h1) /\ core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ f (mem_set_heap m h1) `equiv` f (mem_of_heap h1) /\ interp (f (mem_set_heap m h1)) (mem_of_heap h2) /\ interp (f (mem_set_heap m h1)) (mem_set_heap m h2) /\ disjoint (mem_set_heap m h1) (mem_set_heap m h2) /\ join (mem_set_heap m h1) (mem_set_heap m h2) == m )); () let h_exists_cong (#a:Type) (p q : a -> slprop) : Lemma (requires (forall x. p x `equiv` q x)) (ensures (h_exists p `equiv` h_exists q)) = equiv_heap_iff_equiv_forall (); H.h_exists_cong p q let intro_h_exists #a x p m = H.intro_h_exists x p (heap_of_mem m) let elim_h_exists (#a:_) (p:a -> slprop) (m:mem) = H.elim_h_exists p (heap_of_mem m) let intro_h_forall (#a:_) (p:a -> slprop) (m:mem) = H.intro_h_forall p (heap_of_mem m) let elim_h_forall (#a:_) (p:a -> slprop) (m:mem) (x:a) = H.elim_h_forall p (heap_of_mem m) x let intro_h_and (p q: slprop) (m:mem) = H.intro_h_and p q (heap_of_mem m) let elim_h_and (p q: slprop) (m:mem) = H.elim_h_and p q (heap_of_mem m) let intro_h_or_left (p q: slprop) (m:mem) = H.intro_h_or_left p q (heap_of_mem m) let intro_h_or_right (p q: slprop) (m:mem) = H.intro_h_or_right p q (heap_of_mem m) let elim_h_or (p q: slprop) (m:mem) = H.elim_h_or p q (heap_of_mem m) let intro_wand (p1 p2: slprop u#a) (m:mem) = introduce (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)) ==> interp (wand p1 p2) m with _. ( assert (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)); H.intro_wand p1 p2 (heap_of_mem m); let h = heap_of_mem m in assert ((forall h1. h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) ==> H.interp (wand p1 p2) h); introduce forall h1. (h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) with ( introduce (h `H.disjoint` h1 /\ H.interp p1 h1) ==> H.interp p2 (H.join h h1) with _. ( assert (h `H.disjoint` h1); let m1 = { ctr = m.ctr; heap = h1; locks = m.locks } in assert (m `disjoint` m1) ) ) ) (** Eliminating a wand by proving a heap that satisfies the LHS **) let elim_wand (p1 p2: slprop u#a) (m:mem) (m1:mem) = H.elim_wand p1 p2 (heap_of_mem m) (heap_of_mem m1) //////////////////////////////////////////////////////////////////////////////// // Preorders and effects //////////////////////////////////////////////////////////////////////////////// module PP = Steel.Preorder let mem_evolves = fun (m0 m1:full_mem) -> H.heap_evolves (heap_of_mem m0) (heap_of_mem m1) /\ m0.ctr <= m1.ctr /\ lock_store_evolves m0.locks m1.locks (** See [Steel.Heap.is_frame_preserving]. We add in [lock_invariants] now *) let preserves_frame (e:inames) (pre post:slprop) (m0 m1:mem) = forall (frame:slprop). interp ((pre `star` frame) `star` locks_invariant e m0) m0 ==> (interp ((post `star` frame) `star` locks_invariant e m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) (** This is a version of MstTot with frame quantified, as part of preserves_frame *) effect MstTotNF (a:Type u#a) (except:inames) (expects:slprop u#1) (provides: a -> slprop u#1) = NMSTTotal.NMSTATETOT a (full_mem u#1) mem_evolves (requires fun m0 -> inames_ok except m0 /\ interp (expects `star` locks_invariant except m0) m0) (ensures fun m0 x m1 -> inames_ok except m1 /\ interp (provides x `star` locks_invariant except m1) m1 /\ preserves_frame except expects (provides x) m0 m1) //////////////////////////////////////////////////////////////////////////////// // Lifting heap actions //////////////////////////////////////////////////////////////////////////////// (** Heap actions come in two equivalent flavors: - one that take an explicit frame as argument (action_with_frame) - and one that quantify over all the frame We therefore define two lift routes: - a direct route for those with explicit frame - via MstTotNF for the rest *) let tot_pre_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = hmem_with_inv_except e fp -> (x:a & hmem_with_inv_except e (fp' x)) let tot_pre_action_nf = tot_pre_action_nf_except S.empty let ac_reasoning_for_m_frame_preserving (p q r:slprop u#a) (m:mem u#a) : Lemma (requires interp ((p `star` q) `star` r) m) (ensures interp (p `star` r) m) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_commutative p q; equiv_extensional_on_star (p `star` q) (q `star` p) r } (q `star` p) `star` r; (equiv) { star_associative q p r } q `star` (p `star` r); }; assert (interp (q `star` (p `star` r)) m); affine_star q (p `star` r) m let is_frame_preserving (#e:inames) (#a:Type u#b) (#fp:slprop u#a) (#fp':a -> slprop u#a) (f:tot_pre_action_nf_except e fp a fp') = forall (frame:slprop u#a) (m0:hmem_with_inv_except e (fp `star` frame)). (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = f:tot_pre_action_nf_except e fp a fp'{ is_frame_preserving f } let tot_action_nf = tot_action_nf_except S.empty let linv e (m:mem) = locks_invariant e m let hheap_of_hmem #fp #e (m:hmem_with_inv_except e fp) : h:H.hheap (fp `star` linv e m) { h `H.free_above_addr` m.ctr} = let h = heap_of_mem m in H.pure_interp (heap_ctr_valid m.ctr (heap_of_mem m)) h; h let hmem_of_hheap #e (#fp0 #fp1:slprop) (m:hmem_with_inv_except e fp0) (h:H.full_hheap (fp1 `star` linv e m) { h `Heap.free_above_addr` m.ctr }) : m1:hmem_with_inv_except e fp1{linv e m `equiv` linv e m1} = let m1 : mem = { m with heap = h } in assert (interp (fp1 `star` linv e m) m1); star_commutative fp1 (linv e m); assert (interp (linv e m `star` fp1) m1); assert (linv e m1 == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); assert (linv e m == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m)); H.pure_interp (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_of_mem m); assert (heap_ctr_valid m1.ctr (heap_of_mem m) <==> heap_ctr_valid m1.ctr (heap_of_mem m1)); H.pure_equiv (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_ctr_valid m1.ctr (heap_of_mem m1)); H.star_congruence (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m)); assert (linv e m `equiv` linv e m1); let _ = equiv_extensional_on_star (linv e m) (linv e m1) fp1 in assert ((linv e m `star` fp1) `equiv` (linv e m1 `star` fp1)); assert (interp (linv e m1 `star` fp1) m1); star_commutative (linv e m1) fp1; assert (interp (fp1 `star` linv e m1) m1); m1 let with_inv_except (m:mem) e (fp:slprop) = interp (fp `star` locks_invariant e m) m #push-options "--warn_error -271" let as_hprop (frame:slprop) (mp:mprop frame) : hp:H.hprop frame{forall m. mp (core_mem m) == hp (heap_of_mem m)} = let f = fun h -> mp (mem_of_heap h) in assert (forall m. mp (core_mem m) == f (heap_of_mem m)); let aux (m0:H.hheap frame) (m1:H.heap{H.disjoint m0 m1}) : Lemma (ensures (mem_of_heap (H.join m0 m1) == join (mem_of_heap m0) (mem_of_heap m1))) [SMTPat ()] = () in f let mprop_preservation_of_hprop_preservation (p:slprop) (m0 m1:mem) : Lemma (requires (forall (hp:H.hprop p). hp (heap_of_mem m0) == hp (heap_of_mem m1))) (ensures (forall (mp:mprop p). mp (core_mem m0) == mp (core_mem m1))) = let aux (mp:mprop p) : Lemma (mp (core_mem m0) == mp (core_mem m1)) [SMTPat()] = assert (as_hprop p mp (heap_of_mem m0) == as_hprop p mp (heap_of_mem m1)) in () let lift_heap_action (#fp:slprop) (#a:Type) (#fp':a -> slprop) (e:inames) ($f:H.action fp a fp') : tot_action_nf_except e fp a fp' = let g : tot_pre_action_nf_except e fp a fp' = fun m -> let h0 = hheap_of_hmem m in let (| x, h' |) = f h0 in (| x, hmem_of_hheap m h' |) in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in let h0 = hheap_of_hmem m0 in let (| x', h1 |) = f h0 in H.action_framing f (linv e m0) h0; assert (x == x'); star_associative fp frame (linv e m0); H.action_framing f (frame `star` linv e m0) h0; assert (H.interp ((fp' x) `star` (frame `star` linv e m0)) h1); star_associative (fp' x) frame (linv e m0); assert (H.interp ((fp' x `star` frame) `star` linv e m0) h1); let h1' : H.hheap ((fp' x `star` frame) `star` linv e m0) = h1 in assert (m1 == hmem_of_hheap m0 h1'); assert (with_inv_except m1 e (fp' x `star` frame)); assert (forall (hp:H.hprop frame). hp h0 == hp h1); mprop_preservation_of_hprop_preservation frame m0 m1; () in assert (is_frame_preserving g); g let frame_preserving_respects_preorder #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (m0:hmem_with_inv_except e fp) : Lemma (let (| x, m1 |) = f m0 in mem_evolves m0 m1) = let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1) = () in H.emp_unit fp; assert (interp (fp `star` linv e m0) m0); H.star_congruence (fp `star` emp) (linv e m0) fp (linv e m0); assert (interp ((fp `star` emp) `star` linv e m0) m0); aux emp m0 let lift_tot_action_nf #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') : MstTotNF a e fp fp' = let m0 = NMSTTotal.get () in let m0' : hmem_with_inv_except e fp = m0 in let r = f m0' in let (| x, m1 |) = r in let m1' : hmem_with_inv_except e (fp' x) = m1 in assert (is_frame_preserving f); assert (m1 == dsnd (f m0)); frame_preserving_respects_preorder f m0; NMSTTotal.put #_ #(mem_evolves) m1; x let lift_tot_action #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get #(full_mem) #_ () in ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); lift_tot_action_nf f (** Now defining the lift for heap actions with explicit frame *) let tot_action_with_frame_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = frame:slprop u#a -> m0:hmem_with_inv_except e (fp `star` frame) -> Pure (x:a & hmem_with_inv_except e (fp' x `star` frame)) (requires True) (ensures fun (| x, m1 |) -> mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_with_frame = tot_action_with_frame_except S.empty let lift_heap_action_with_frame (#fp:slprop u#a) (#a:Type u#b) (#fp':a -> slprop u#a) (e:inames) ($f:H.action_with_frame fp a fp') : tot_action_with_frame_except e fp a fp' = fun frame m0 -> let h0 = hheap_of_hmem m0 in calc (equiv) { fp `star` frame `star` locks_invariant e m0; (equiv) { star_associative fp frame (locks_invariant e m0) } fp `star` (frame `star` locks_invariant e m0); }; assert (H.interp (fp `star` frame `star` locks_invariant e m0) h0); assert (H.interp (fp `star` (frame `star` locks_invariant e m0)) h0); //key: apply the heap action with frame * locks_invariant e m0 let (| x, h1 |) = f (frame `star` locks_invariant e m0) h0 in calc (equiv) { fp' x `star` (frame `star` locks_invariant e m0); (equiv) { star_associative (fp' x) frame (locks_invariant e m0) } fp' x `star` frame `star` locks_invariant e m0; }; assert (H.interp (fp' x `star` (frame `star` locks_invariant e m0)) h1); assert (H.interp (fp' x `star` frame `star` locks_invariant e m0) h1); let m1 = hmem_of_hheap m0 h1 in assert (mem_evolves m0 m1); mprop_preservation_of_hprop_preservation (frame `star` locks_invariant e m0) m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)); (| x, m1 |) let lift_tot_action_with_frame #a #e #fp #fp' ($f:tot_action_with_frame_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in assert (inames_ok e m0); ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); let m0' : hmem_with_inv_except e fp = m0 in let r = f frame m0' in let (| x, m1 |) = r in ac_reasoning_for_m_frame_preserving (fp' x) frame (locks_invariant e m1) m1; assert (interp (fp' x `star` frame `star` locks_invariant e m1) m1); assert (interp (fp' x `star` locks_invariant e m1) m1); let m1' : hmem_with_inv_except e (fp' x) = m1 in NMSTTotal.put #_ #(mem_evolves) m1; x let sel_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.sel_action #a #pcm r v0)) let upd_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.upd_action #a #pcm r v0 v1)) let free_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.free_action #a #pcm r v0)) let split_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.split_action #a #pcm r v0 v1)) let gather_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.gather_action #a #pcm r v0 v1)) let weaken (p q r:slprop) (h:H.hheap (p `star` q) { H.stronger q r }) : H.hheap (p `star` r) = H.weaken p q r h; h let weaken_pure (q r: prop) : Lemma (requires (q ==> r)) (ensures H.stronger (H.pure q) (H.pure r)) = let aux (h:H.heap) : Lemma (ensures (H.interp (H.pure q) h ==> H.interp (H.pure r) h)) [SMTPat ()] = H.pure_interp q h; H.pure_interp r h in () let inc_ctr (#p:slprop) #e (m:hmem_with_inv_except e p) : m':hmem_with_inv_except e p{m'.ctr = m.ctr + 1 /\ H.stronger (linv e m) (linv e m')} = let m' : mem = { m with ctr = m.ctr + 1} in assert (interp (p `star` linv e m) m'); assert (linv e m == lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m)); assert (linv e m' == lock_store_invariant e m.locks `star` ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken_free_above (heap_of_mem m) m.ctr (m.ctr + 1); weaken_pure (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_ctr_valid (m.ctr + 1) (heap_of_mem m)); assert (H.stronger (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m))); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)); H.stronger_star (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken (p `star` lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)) (heap_of_mem m'); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity (m.ctr + 1) (heap_of_mem m)); let m' : hmem_with_inv_except e p = m' in m' let frame_related_mems (fp0 fp1:slprop u#a) e (m0:hmem_with_inv_except e fp0) (m1:hmem_with_inv_except e fp1) = forall (frame:slprop u#a). interp ((fp0 `star` frame) `star` linv e m0) m0 ==> interp ((fp1 `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) let refined_pre_action e (fp0:slprop) (a:Type) (fp1:a -> slprop) = m0:hmem_with_inv_except e fp0 -> Pure (x:a & hmem_with_inv_except e (fp1 x)) (requires True) (ensures fun (| x, m1 |) -> frame_related_mems fp0 (fp1 x) e m0 m1) let refined_pre_action_as_action (#fp0:slprop) (#a:Type) (#fp1:a -> slprop) #e ($f:refined_pre_action e fp0 a fp1) : tot_action_nf_except e fp0 a fp1 = let g : tot_pre_action_nf_except e fp0 a fp1 = fun m -> f m in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp0 `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp1 x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x', m1' |) = g m0 in let (| x, m1 |) = f m0 in assert (x == x' /\ m1 == m1') in g let alloc_action #a #pcm e x = let f : refined_pre_action e emp (ref a pcm) (fun r -> pts_to r x) = fun m0 -> (* NS: 9/29/22 I needed to annotate h : Heap.full_heap, for use with the Core checker which generates a guard for checking the implicit pattern "dot" term in the dependent pair pattern on the next line. That guard expects `h` to be a full_heap, which is it, because it is a projection of m0. However, this is not reflected in `h`'s type. So, the Core checker, which produces a guard for the pat_dot_term in isolation, cannot recheck the term. If we were to fold in the checking of pat_dot_terms and their guards with the rest of the VC, this would work. *) let h : Heap.full_heap = hheap_of_hmem m0 in let (|r, h'|) = H.extend #a #pcm x m0.ctr h in let m' : hmem_with_inv_except e emp = inc_ctr m0 in let h' : H.hheap (pts_to #a #pcm r x `star` linv e m') = weaken _ (linv e m0) (linv e m') h' in let m1 : hmem_with_inv_except e (pts_to #a #pcm r x) = hmem_of_hheap m' h' in assert (forall frame. H.frame_related_heaps h h' emp (pts_to #a #pcm r x) frame true); let aux (frame:slprop) : Lemma (requires interp ((emp `star` frame) `star` linv e m0) m0) (ensures interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) [SMTPat (emp `star` frame)] = star_associative emp frame (linv e m0); assert (H.interp (emp `star` (frame `star` linv e m0)) h); assert (H.interp (pts_to #a #pcm r x `star` (frame `star` linv e m0)) h'); star_associative (pts_to #a #pcm r x) frame (linv e m0); assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m0) h'); assert (H.stronger (linv e m0) (linv e m')); assert (H.equiv (linv e m') (linv e m1)); assert (H.stronger (linv e m0) (linv e m1)); let h' : H.hheap ((pts_to #a #pcm r x `star` frame) `star` linv e m1) = weaken _ (linv e m0) (linv e m1) h' in assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) h'); assert (forall (mp:H.hprop frame). mp h == mp h'); mprop_preservation_of_hprop_preservation frame m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) in assert (frame_related_mems emp (pts_to r x) e m0 m1); (| r, m1 |) in lift_tot_action (refined_pre_action_as_action f) let select_refine #a #p e r x f = lift_tot_action (lift_heap_action e (H.select_refine #a #p r x f)) let upd_gen #a #p e r x y f = lift_tot_action (lift_heap_action e (H.upd_gen_action r x y f)) //////////////////////////////////////////////////////////////////////////////// // witness / recall //////////////////////////////////////////////////////////////////////////////// let witnessed_ref #a #pcm (r:ref a pcm) (fact:property a) (m:full_mem) = H.witnessed_ref #a #pcm r fact (heap_of_mem m) let witnessed_ref_stability #a #pcm (r:ref a pcm) (fact:property a) : Lemma (requires FStar.Preorder.stable fact (Steel.Preorder.preorder_of_pcm pcm)) (ensures FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) = H.witnessed_ref_stability #a #pcm r fact let witnessed (#a:Type u#1) (#pcm:pcm a) (r:ref a pcm) (fact:property a) = W.witnessed _ mem_evolves (witnessed_ref r fact) let rearrange_pqr_prq (p q r:slprop) : Lemma (((p `star` q) `star` r) `equiv` ((p `star` r) `star` q)) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_associative p q r } p `star` (q `star` r); (equiv) { star_commutative q r; star_congruence p (q `star` r) p (r `star` q) } p `star` (r `star` q); (equiv) { star_associative p r q } (p `star` r) `star` q; } let preserves_frame_cong (e:inames) (p q:slprop) (r s:slprop) (m0 m1:mem) : Lemma (requires p `equiv` r /\ q `equiv` s /\ preserves_frame e p q m0 m1) (ensures preserves_frame e r s m0 m1) = let aux0 (p q r s:slprop) : Lemma (requires p `equiv` s) (ensures (((p `star` q) `star` r) `equiv` ((s `star` q) `star` r))) = star_congruence p q s q; star_congruence (p `star` q) r (s `star` q) r in let aux (frame:slprop) : Lemma (requires interp ((r `star` frame) `star` locks_invariant e m0) m0) (ensures interp ((s `star` frame) `star` locks_invariant e m1) m1 /\ interp ((p `star` frame) `star` locks_invariant e m0) m0) [SMTPat (r `star` frame)] = aux0 p frame (locks_invariant e m0) r; aux0 q frame (locks_invariant e m1) s; assert (((p `star` frame) `star` locks_invariant e m0) `equiv` ((r `star` frame) `star` locks_invariant e m0)); assert (interp ((p `star` frame) `star` locks_invariant e m0) m0); assert (interp ((q `star` frame) `star` locks_invariant e m1) m1); assert (((q `star` frame) `star` locks_invariant e m1) `equiv` ((s `star` frame) `star` locks_invariant e m1)); () in () let pure_true_equiv (p:slprop) : Lemma ((p `star` pure True) `equiv` p) = FStar.Classical.forall_intro (pure_star_interp p True); emp_unit p; assert ((p `star` pure True) `equiv` p) let preserves_frame_star_pure (e:inames) (p q:slprop) (r s:prop) (m:mem) : Lemma (requires r /\ s) (ensures preserves_frame e p q m m <==> preserves_frame e (p `star` pure r) (q `star` pure s) m m) = pure_equiv r True; star_congruence p (pure r) p (pure True); pure_equiv s True; star_congruence q (pure s) q (pure True); pure_true_equiv p; pure_true_equiv q; let fwd () : Lemma (requires preserves_frame e p q m m) (ensures preserves_frame e (p `star` pure r) (q `star` pure s) m m) [SMTPat ()] = preserves_frame_cong e p q (p `star` pure r) (q `star` pure s) m m in let bk () : Lemma (requires preserves_frame e (p `star` pure r) (q `star` pure s) m m) (ensures preserves_frame e p q m m) [SMTPat ()] = preserves_frame_cong e (p `star` pure r) (q `star` pure s) p q m m in () let witness (#a:Type) (#pcm:pcm a) (e:inames) (r:erased (ref a pcm)) (fact:stable_property pcm) (v:Ghost.erased a) (_:squash (forall z. compatible pcm v z ==> fact z)) (frame:slprop) : MstTot (witnessed r fact) e (pts_to r v) (fun _ -> pts_to r v) frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in let _ : unit = let hr : H.ref a pcm = r in let v' = H.sel_v hr v (heap_of_mem m0) in assert (interp (H.ptr hr) m0 /\ H.sel #a #pcm hr (heap_of_mem m0) == v'); assert (compatible pcm v v'); assert (fact v'); assert (witnessed_ref r fact m0); witnessed_ref_stability r fact; assert (FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) in let w = NMSTTotal.witness _ mem_evolves (witnessed_ref r fact) in w let recall (#a:Type u#1) (#pcm:pcm a) (#fact:property a) (e:inames) (r:erased (ref a pcm)) (v:Ghost.erased a) (w:witnessed r fact) (frame:slprop) = let m0 = NMSTTotal.get () in NMSTTotal.recall _ mem_evolves (witnessed_ref r fact) w; let hr : H.ref a pcm = r in assert (witnessed_ref r fact m0); let v1 = H.sel_v hr v (heap_of_mem m0) in assert (compatible pcm v v1); assert (H.sel hr (heap_of_mem m0) == v1); assert (fact v1); assert (interp ((pts_to r v `star` frame) `star` locks_invariant e m0) m0); emp_unit ((pts_to r v `star` frame) `star` locks_invariant e m0); pure_star_interp ((pts_to r v `star` frame) `star` locks_invariant e m0) (fact v1) m0; assert (interp (((pts_to r v `star` frame) `star` locks_invariant e m0) `star` pure (fact v1)) m0); rearrange_pqr_prq (pts_to r v `star` frame) (locks_invariant e m0) (pure (fact v1)); assert (interp (((pts_to r v `star` frame) `star` pure (fact v1)) `star` locks_invariant e m0) m0); rearrange_pqr_prq (pts_to r v) frame (pure (fact v1)); star_congruence ((pts_to r v `star` frame) `star` pure (fact v1)) (locks_invariant e m0) ((pts_to r v `star` pure (fact v1)) `star` frame) (locks_invariant e m0); Ghost.hide v1 let iname_for_p_mem (i:iname) (p:slprop) : W.s_predicate mem = fun m -> iname_for_p i p m.locks let iname_for_p_stable (i:iname) (p:slprop) : Lemma (W.stable full_mem mem_evolves (iname_for_p_mem i p)) = () let ( >--> ) (i:iname) (p:slprop) : Type0 = W.witnessed full_mem mem_evolves (iname_for_p_mem i p) let hmem_with_inv_equiv e (m:mem) (p:slprop) : Lemma (interp (p `star` linv e m) m <==> interp (p `star` lock_store_invariant e m.locks) m /\ heap_ctr_valid m.ctr (heap_of_mem m)) = calc (<==>) { interp (p `star` linv e m) m; (<==>) { H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) } interp ((p `star` lock_store_invariant e m.locks) `star` ctr_validity m.ctr (heap_of_mem m)) m; (<==>) { H.pure_star_interp (p `star` lock_store_invariant e m.locks) (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_of_mem m) } interp ((p `star` lock_store_invariant e m.locks) `star` emp) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); (<==>) { H.emp_unit (p `star` lock_store_invariant e m.locks) } interp (p `star` lock_store_invariant e m.locks) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); } let new_invariant_tot_action (e:inames) (p:slprop) (m0:hmem_with_inv_except e p{ e `inames_in` m0.locks }) : Pure (iname & hmem_with_inv_except e emp) (requires True) (ensures fun (i, m1) -> iname_for_p_mem i p m1 /\ frame_related_mems p emp e m0 m1 /\ mem_evolves m0 m1) = let (| i, l1 |) = extend_lock_store e m0.locks p in let m1 = { m0 with locks = l1 } in assert (lock_store_invariant e m1.locks == p `star` lock_store_invariant e m0.locks); calc (equiv) { linv e m1; (equiv) {} (lock_store_invariant e m1.locks `star` ctr_validity m1.ctr (heap_of_mem m1)); (equiv) {} ((p `star` lock_store_invariant e m0.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); (equiv) { H.star_associative p (lock_store_invariant e m0.locks) (ctr_validity m1.ctr (heap_of_mem m1)) } (p `star` (lock_store_invariant e m0.locks `star` ctr_validity m1.ctr (heap_of_mem m1))); (equiv) { } (p `star` linv e m0); }; assert (iname_for_p_mem i p m1); assert (lock_store_evolves m0.locks l1); assert (mem_evolves m0 m1); hmem_with_inv_equiv e m0 p; assert (interp (p `star` lock_store_invariant e m0.locks) m1); assert (interp (lock_store_invariant e m1.locks) m1); H.emp_unit (lock_store_invariant e m1.locks); H.star_commutative (lock_store_invariant e m1.locks) emp; assert (interp (emp `star` lock_store_invariant e m1.locks) m1); hmem_with_inv_equiv e m1 emp; let m1 : hmem_with_inv_except e emp = m1 in let aux (frame:slprop) : Lemma (requires interp ((p `star` frame) `star` linv e m0) m0) (ensures interp ((emp `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) <==> mp (core_mem m1))) [SMTPat (p `star` frame)] = assert (interp ((p `star` frame) `star` linv e m0) m1); calc (equiv) { ((p `star` frame) `star` linv e m0); (equiv) { H.star_commutative p frame; H.star_congruence (p `star` frame) (linv e m0) (frame `star` p) (linv e m0); H.star_associative frame p (linv e m0) } (frame `star` (p `star` linv e m0)); (equiv) { H.star_congruence frame (p `star` linv e m0) frame (linv e m1) } (frame `star` linv e m1); (equiv) { H.emp_unit (frame `star` linv e m1); H.star_commutative (frame `star` linv e m1) emp; H.star_associative emp frame (linv e m1) } ((emp `star` frame) `star` linv e m1); }; assert (interp ((emp `star` frame) `star` linv e m1) m1) in assert (frame_related_mems p emp e m0 m1); ( i, m1 ) let name_is_ok (i:iname) (m0:full_mem u#1) : prop = i < List.Tot.length m0.locks let witnessed_name_is_ok (i:iname) = W.witnessed full_mem mem_evolves (name_is_ok i) let pre_inv = i:erased iname & witnessed_name_is_ok i let inv (p:slprop u#1) = i:erased iname & witnessed_name_is_ok i & (i >--> p) let pre_inv_of_inv #p (i:inv p) = let (|i, w, _|) = i in (|i,w|) let name_of_pre_inv (i:pre_inv) = dfst i let rec recall_all (ctx:list pre_inv) : NMSTTotal.NMSTATETOT unit (full_mem u#1) mem_evolves (requires fun _ -> True) (ensures fun m0 _ m1 -> m0==m1 /\ (forall i. i `List.Tot.memP` ctx ==> name_is_ok (name_of_pre_inv i) m0)) = match ctx with | [] -> () | hd::tl -> let (| q, i |) = hd in let i : W.witnessed full_mem mem_evolves (name_is_ok q) = i in NMSTTotal.recall _ mem_evolves (name_is_ok q) i; recall_all tl let fresh_invariant (e:inames) (p:slprop) (ctx:list pre_inv) (frame:slprop) : MstTot (i:inv p { not (mem_inv e i) /\ fresh_wrt ctx (name_of_inv i)}) e p (fun _ -> emp) frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in recall_all ctx; ac_reasoning_for_m_frame_preserving p frame (locks_invariant e m0) m0; assert (interp (p `star` locks_invariant e m0) m0); let r = new_invariant_tot_action e p m0 in let ( i, m1 ) = r in assert (i == List.Tot.length m0.locks); assert (not (Set.mem i e)); assert (mem_evolves m0 m1); NMSTTotal.put #full_mem #mem_evolves m1; iname_for_p_stable i p; let w = NMSTTotal.witness full_mem mem_evolves (iname_for_p_mem i p) in let w0 = NMSTTotal.witness full_mem mem_evolves (name_is_ok i) in (| hide i, w0, w |) let new_invariant (e:inames) (p:slprop) (frame:slprop) : MstTot (inv p) e p (fun _ -> emp) frame (fun _ -> True) (fun _ _ _ -> True) = fresh_invariant e p [] frame let rearrange_invariant (p q r : slprop) (q0 q1:slprop) : Lemma (requires q `equiv` (q0 `star` q1)) (ensures (p `star` (q `star` r)) `equiv` ((q0 `star` p) `star` (q1 `star` r))) = calc (equiv) { p `star` (q `star` r); (equiv) { calc (equiv) { (q `star` r); (equiv) { star_congruence q r (q0 `star` q1) r } (q0 `star` q1) `star` r; }; star_congruence p (q `star` r) p ((q0 `star` q1) `star` r) } (p `star` ((q0 `star` q1) `star` r)); (equiv) { star_associative q0 q1 r; star_congruence p ((q0 `star` q1) `star` r) p (q0 `star` (q1 `star` r)); star_associative p q0 (q1 `star` r) } (p `star` q0) `star` (q1 `star` r); (equiv) { star_commutative p q0; star_congruence (p `star` q0) (q1 `star` r) (q0 `star` p) (q1 `star` r) } (q0 `star` p) `star` (q1 `star` r); } let preserves_frame_invariant (fp fp':slprop) (opened_invariants:inames) (p:slprop) (i:inv p{not (mem_inv opened_invariants i)}) (m0:hmem_with_inv_except (add_inv opened_invariants i) (p `star` fp)) (m1:mem) : Lemma (requires preserves_frame (set_add (name_of_inv i) opened_invariants) (p `star` fp) (p `star` fp') m0 m1 /\ interp (fp' `star` linv opened_invariants m1) m1 /\ inames_ok opened_invariants m1 /\ (lock_store_invariant opened_invariants m0.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks)) /\ (lock_store_invariant opened_invariants m1.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks))) (ensures preserves_frame opened_invariants fp fp' m0 m1) = let aux (frame:slprop) : Lemma (requires interp ((fp `star` frame) `star` linv opened_invariants m0) m0) (ensures interp ((fp' `star` frame) `star` linv opened_invariants m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) [SMTPat()] = rearrange_invariant (fp `star` frame) (lock_store_invariant opened_invariants m0.locks) (ctr_validity m0.ctr (heap_of_mem m0)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks); assert (interp ((p `star` (fp `star` frame)) `star` linv (set_add (name_of_inv i) opened_invariants) m0) m0); star_associative p fp frame; star_congruence (p `star` (fp `star` frame)) (linv (set_add (name_of_inv i) opened_invariants) m0) ((p `star` fp) `star` frame) (linv (set_add (name_of_inv i) opened_invariants) m0); assert (interp (((p `star` fp) `star` frame) `star` linv (set_add (name_of_inv i) opened_invariants) m0) m0); assert (interp (((p `star` fp') `star` frame) `star` linv (set_add (name_of_inv i) opened_invariants) m1) m1); star_associative p fp' frame; star_congruence ((p `star` fp') `star` frame) (linv (set_add (name_of_inv i) opened_invariants) m1) (p `star` (fp' `star` frame)) (linv (set_add (name_of_inv i) opened_invariants) m1); assert (interp ((p `star` (fp' `star` frame)) `star` linv (set_add (name_of_inv i) opened_invariants) m1) m1); rearrange_invariant (fp' `star` frame) (lock_store_invariant opened_invariants m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks); assert (interp ((fp' `star` frame) `star` linv opened_invariants m1) m1); () in () let equiv_ext_right (p q r:slprop) : Lemma (requires q `equiv` r) (ensures (p `star` q) `equiv` (p `star` r)) = calc (equiv) { p `star` q; (equiv) { star_commutative p q } q `star` p; (equiv) { equiv_extensional_on_star q r p } r `star` p; (equiv) { star_commutative p r } p `star` r; } let with_inv_helper (fp frame ls1 ctr p ls2:slprop) : Lemma (requires ls1 `equiv` (p `star` ls2)) (ensures (fp `star` frame `star` (ls1 `star` ctr)) `equiv` (p `star` fp `star` frame `star` (ls2 `star` ctr))) = calc (equiv) { ls1 `star` ctr; (equiv) { equiv_extensional_on_star ls1 (p `star` ls2) ctr } p `star` ls2 `star` ctr; }; calc (equiv) { p `star` ls2 `star` ctr; (equiv) { star_associative p ls2 ctr } p `star` (ls2 `star` ctr); }; calc (equiv) { fp `star` frame `star` p; (equiv) { star_commutative (fp `star` frame) p } p `star` (fp `star` frame); (equiv) { star_associative p fp frame } p `star` fp `star` frame; }; calc (equiv) { fp `star` frame `star` (ls1 `star` ctr); (equiv) { equiv_ext_right (fp `star` frame) (ls1 `star` ctr) (p `star` ls2 `star` ctr) } (fp `star` frame) `star` (p `star` ls2 `star` ctr); (equiv) { equiv_ext_right (fp `star` frame) (p `star` ls2 `star` ctr) (p `star` (ls2 `star` ctr)) } (fp `star` frame) `star` (p `star` (ls2 `star` ctr)); (equiv) { star_associative (fp `star` frame) p (ls2 `star` ctr) } (fp `star` frame `star` p) `star` (ls2 `star` ctr); (equiv) { equiv_extensional_on_star (fp `star` frame `star` p) (p `star` fp `star` frame) (ls2 `star` ctr) } (p `star` fp `star` frame) `star` (ls2 `star` ctr); } let token_of_inv #p (i:inv p) : (name_of_inv i >--> p) = let (| _, _, tok |) = i in tok let with_invariant (#a:Type) (#fp:slprop) (#fp':a -> slprop) (#opened_invariants:inames) (#p:slprop) (i:inv p{not (mem_inv opened_invariants i)}) (f:action_except a (add_inv opened_invariants i) (p `star` fp) (fun x -> p `star` fp' x)) (frame:slprop) : MstTot a opened_invariants fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in NMSTTotal.recall _ mem_evolves (iname_for_p_mem (name_of_inv i) p) (token_of_inv i); assert (iname_for_p (name_of_inv i) p m0.locks); assert (interp (fp `star` frame `star` locks_invariant opened_invariants m0) m0); assert (interp (fp `star` frame `star` (lock_store_invariant opened_invariants m0.locks `star` ctr_validity m0.ctr (heap_of_mem m0))) m0); move_invariant opened_invariants m0.locks p (name_of_inv i); assert (lock_store_invariant opened_invariants m0.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks)); with_inv_helper fp frame (lock_store_invariant opened_invariants m0.locks) (ctr_validity m0.ctr (heap_of_mem m0)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks); assert (interp (p `star` fp `star` frame `star` locks_invariant (set_add (name_of_inv i) opened_invariants) m0) m0); let r = f frame in let m1 : full_mem = NMSTTotal.get () in assert (interp (p `star` fp' r `star` frame `star` locks_invariant (set_add (name_of_inv i) opened_invariants) m1) m1); assert (interp (p `star` fp' r `star` frame `star` (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks `star` ctr_validity m1.ctr (heap_of_mem m1))) m1); NMSTTotal.recall _ mem_evolves (iname_for_p_mem (name_of_inv i) p) (token_of_inv i); move_invariant opened_invariants m1.locks p (name_of_inv i); assert (lock_store_invariant opened_invariants m1.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks)); with_inv_helper (fp' r) frame (lock_store_invariant opened_invariants m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks); assert (interp (fp' r `star` frame `star` locks_invariant opened_invariants m1) m1); assert (inames_ok opened_invariants m1); r let equiv_pqrs_p_qr_s (p q r s:slprop) : Lemma ((p `star` q `star` r `star` s) `equiv` (p `star` (q `star` r) `star` s)) = star_associative p q r; equiv_extensional_on_star (p `star` q `star` r) (p `star` (q `star` r)) s let frame (#a:Type) (#opened_invariants:inames) (#pre:slprop) (#post:a -> slprop) (#req:mprop pre) (#ens:mprop2 pre post) (frame:slprop) ($f:action_except_full a opened_invariants pre post req ens) (frame0:slprop) : MstTot a opened_invariants (pre `star` frame) (fun x -> post x `star` frame) frame0 req ens = let m0 : full_mem = NMSTTotal.get () in equiv_pqrs_p_qr_s pre frame frame0 (linv opened_invariants m0); assert (interp (pre `star` frame `star` frame0 `star` linv opened_invariants m0) m0); assert (interp (pre `star` (frame `star` frame0) `star` linv opened_invariants m0) m0); let x = f (frame `star` frame0) in let m1 : full_mem = NMSTTotal.get () in equiv_pqrs_p_qr_s (post x) frame frame0 (linv opened_invariants m1); assert (interp (post x `star` (frame `star` frame0) `star` linv opened_invariants m1) m1); assert (interp (post x `star` frame `star` frame0 `star` linv opened_invariants m1) m1); x let change_slprop (#opened_invariants:inames) (p q:slprop) (proof: (m:mem -> Lemma (requires interp p m) (ensures interp q m))) = let proof (h:H.heap) : Lemma (requires H.interp p h) (ensures H.interp q h) = proof (mem_of_heap h) in lift_tot_action (lift_heap_action opened_invariants (Steel.Heap.change_slprop p q proof)) (* This module reuses is_frame_monotonic from Heap, but does not expose that to clients, so we need this lemma to typecheck witness_h_exists below. *) let relate_frame_monotonic_1 #a p : Lemma (requires (H.is_frame_monotonic p)) (ensures (is_frame_monotonic p)) = () let relate_frame_monotonic_2 #a p : Lemma (requires (is_frame_monotonic p)) (ensures (H.is_frame_monotonic p)) = let aux (x y : a) (h : H.heap) (f : H.slprop) : Lemma (requires (H.interp (p x `H.star` f) h /\ H.interp (p y) h)) (ensures (H.interp (p y `H.star` f) h)) = let m = mem_of_heap h in assert (interp (p x `star` f) m); assert (interp (p y) m); assert (interp (p y `star` f) m) in Classical.forall_intro_4 (fun x y h f -> Classical.move_requires (aux x y h) f)

{ "checked_file": "/", "dependencies": [ "Steel.Preorder.fst.checked", "Steel.Heap.fsti.checked", "prims.fst.checked", "FStar.Witnessed.Core.fsti.checked", "FStar.Set.fsti.checked", "FStar.Preorder.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.PCM.fst.checked", "FStar.NMSTTotal.fst.checked", "FStar.List.Tot.fst.checked", "FStar.IndefiniteDescription.fsti.checked", "FStar.Ghost.fsti.checked", "FStar.FunctionalExtensionality.fsti.checked", "FStar.Classical.Sugar.fsti.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Steel.Memory.fst" }

[ { "abbrev": true, "full_module": "Steel.Preorder", "short_module": "PP" }, { "abbrev": true, "full_module": "FStar.Witnessed.Core", "short_module": "W" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": true, "full_module": "Steel.Heap", "short_module": "H" }, { "abbrev": false, "full_module": "FStar.FunctionalExtensionality", "short_module": null }, { "abbrev": true, "full_module": "FStar.FunctionalExtensionality", "short_module": "F" }, { "abbrev": true, "full_module": "FStar.Universe", "short_module": "U" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": false, "full_module": "FStar.PCM", "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

p: (_: a -> Steel.Memory.slprop) -> Steel.Memory.action_except (FStar.Ghost.erased a) opened_invariants (Steel.Memory.h_exists p) (fun x -> p (FStar.Ghost.reveal x))

Prims.Tot

[ "total" ]

[]

[ "Steel.Memory.inames", "Steel.Memory.slprop", "Steel.Memory.lift_tot_action_with_frame", "FStar.Ghost.erased", "Steel.Heap.h_exists", "FStar.Ghost.reveal", "Steel.Memory.lift_heap_action_with_frame", "Steel.Heap.witness_h_exists", "Steel.Memory.action_except", "Steel.Memory.h_exists" ]

[]

false

let witness_h_exists #opened_invariants #a p =

lift_tot_action_with_frame (lift_heap_action_with_frame opened_invariants (H.witness_h_exists p))

false

Platform.Bytes.fst

Platform.Bytes.abyte2

val abyte2 : (FStar.UInt8.t * FStar.UInt8.t) -> Tot bytes

let abyte2 (b1, b2) = Seq.append (Seq.create 1 b1) (Seq.create 1 b2)

{ "file_name": "ucontrib/Platform/fst/Platform.Bytes.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }

{ "end_col": 68, "end_line": 88, "start_col": 0, "start_line": 88 }

(* Copyright 2008-2018 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 Platform.Bytes assume val repr_bytes : nat -> GTot (n:nat{n>0}) (* Integer literals are currently extracted to int32, rather than bigint, so the definition below breaks extraction: Unexpected error; please file a bug report, ideally with a minimized version of the source program that triggered the error. int_of_string Also, defining repr_bytes n <= 8 for all n is dubious *) (* let repr_bytes n = if n < 256 then 1 else if n < 65536 then 2 else if n < 16777216 then 3 else if n < 4294967296 then 4 else if n < 1099511627776 then 5 else if n < 281474976710656 then 6 else if n < 72057594037927936 then 7 else 8 *) (* NS: The two assumes below were previously defined as axioms. They are evil! They pollute the global environment and slow down verification enormously. I've made them assumed lemmas; if you want to make use of these axioms, call the lemmas as needed in the context. *) assume val lemma_repr_bytes_values: n:nat -> Lemma ( ( n < 256 <==> repr_bytes n = 1 ) /\ ( (n >= 256 /\ n < 65536) <==> repr_bytes n = 2 ) /\ ( (n >= 65536 /\ n < 16777216) <==> repr_bytes n = 3 ) /\ ( (n >= 16777216 /\ n < 4294967296) <==> repr_bytes n = 4 ) /\ ( (n >= 4294967296 /\ n < 1099511627776) <==> repr_bytes n = 5 ) /\ ( (n >= 1099511627776 /\ n < 281474976710656) <==> repr_bytes n = 6 ) /\ ( (n >= 281474976710656 /\ n < 72057594037927936) <==> repr_bytes n = 7 ) /\ ( (n >= 72057594037927936 /\ n < 18446744073709551616) <==> repr_bytes n = 8 ) ) unfold let byte:Type0 = FStar.UInt8.t type cbytes = string (* abstract *) type bytes = Seq.seq byte (* AR: adding this *) assume HasEq_bytes: hasEq bytes val seq_of_bytes: b:bytes -> GTot (Seq.seq byte) let seq_of_bytes b = b val op_At_Bar: bytes -> bytes -> Tot bytes let op_At_Bar (b1:bytes) (b2:bytes) = Seq.append b1 b2 (*@ function val B : (bytes -> byte array) @*) (*@ assume val length : (b:bytes -> (l:nat){Length (b) = l}) @*) val length : bytes -> Tot nat let length b = Seq.length b (*@ type (l:nat) lbytes = (b:bytes){Length (b) = l} @*) type lbytes (l:nat) = b:bytes{length b = l} (*@ val empty_bytes : (b:bytes){B (b) = C_array_of_list C_op_Nil ()} @*) val empty_bytes : lbytes 0 let empty_bytes = Seq.empty #byte (*@ assume val abytes : (b:cbytes -> (a:bytes){B (a) = b}) @*) assume val abytes : (cbytes -> Tot bytes) (*@ assume val abyte : (b:byte -> (a:bytes){B (a) = C_array_of_list C_op_ColonColon (b, C_op_Nil ())}) @*) val abyte : (FStar.UInt8.t -> Tot bytes) let abyte b = Seq.create 1 b

{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.UInt8.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked" ], "interface_file": false, "source_file": "Platform.Bytes.fst" }

[ { "abbrev": false, "full_module": "Platform", "short_module": null }, { "abbrev": false, "full_module": "Platform", "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

_: (FStar.UInt8.t * FStar.UInt8.t) -> Platform.Bytes.bytes

Prims.Tot

[ "total" ]

[]

[ "FStar.Pervasives.Native.tuple2", "FStar.UInt8.t", "FStar.Seq.Base.append", "Platform.Bytes.byte", "FStar.Seq.Base.create", "Platform.Bytes.bytes" ]

[]

false

true

false

let abyte2 (b1, b2) =

Seq.append (Seq.create 1 b1) (Seq.create 1 b2)

false

Steel.Memory.fst

Steel.Memory.new_invariant_tot_action

val new_invariant_tot_action (e: inames) (p: slprop) (m0: hmem_with_inv_except e p {e `inames_in` m0.locks}) : Pure (iname & hmem_with_inv_except e emp) (requires True) (ensures fun (i, m1) -> iname_for_p_mem i p m1 /\ frame_related_mems p emp e m0 m1 /\ mem_evolves m0 m1)

let new_invariant_tot_action (e:inames) (p:slprop) (m0:hmem_with_inv_except e p{ e `inames_in` m0.locks }) : Pure (iname & hmem_with_inv_except e emp) (requires True) (ensures fun (i, m1) -> iname_for_p_mem i p m1 /\ frame_related_mems p emp e m0 m1 /\ mem_evolves m0 m1) = let (| i, l1 |) = extend_lock_store e m0.locks p in let m1 = { m0 with locks = l1 } in assert (lock_store_invariant e m1.locks == p `star` lock_store_invariant e m0.locks); calc (equiv) { linv e m1; (equiv) {} (lock_store_invariant e m1.locks `star` ctr_validity m1.ctr (heap_of_mem m1)); (equiv) {} ((p `star` lock_store_invariant e m0.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); (equiv) { H.star_associative p (lock_store_invariant e m0.locks) (ctr_validity m1.ctr (heap_of_mem m1)) } (p `star` (lock_store_invariant e m0.locks `star` ctr_validity m1.ctr (heap_of_mem m1))); (equiv) { } (p `star` linv e m0); }; assert (iname_for_p_mem i p m1); assert (lock_store_evolves m0.locks l1); assert (mem_evolves m0 m1); hmem_with_inv_equiv e m0 p; assert (interp (p `star` lock_store_invariant e m0.locks) m1); assert (interp (lock_store_invariant e m1.locks) m1); H.emp_unit (lock_store_invariant e m1.locks); H.star_commutative (lock_store_invariant e m1.locks) emp; assert (interp (emp `star` lock_store_invariant e m1.locks) m1); hmem_with_inv_equiv e m1 emp; let m1 : hmem_with_inv_except e emp = m1 in let aux (frame:slprop) : Lemma (requires interp ((p `star` frame) `star` linv e m0) m0) (ensures interp ((emp `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) <==> mp (core_mem m1))) [SMTPat (p `star` frame)] = assert (interp ((p `star` frame) `star` linv e m0) m1); calc (equiv) { ((p `star` frame) `star` linv e m0); (equiv) { H.star_commutative p frame; H.star_congruence (p `star` frame) (linv e m0) (frame `star` p) (linv e m0); H.star_associative frame p (linv e m0) } (frame `star` (p `star` linv e m0)); (equiv) { H.star_congruence frame (p `star` linv e m0) frame (linv e m1) } (frame `star` linv e m1); (equiv) { H.emp_unit (frame `star` linv e m1); H.star_commutative (frame `star` linv e m1) emp; H.star_associative emp frame (linv e m1) } ((emp `star` frame) `star` linv e m1); }; assert (interp ((emp `star` frame) `star` linv e m1) m1) in assert (frame_related_mems p emp e m0 m1); ( i, m1 )

{ "file_name": "lib/steel/Steel.Memory.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 13, "end_line": 1248, "start_col": 0, "start_line": 1177 }

(* 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.Memory module F = FStar.FunctionalExtensionality open FStar.FunctionalExtensionality open FStar.PCM module H = Steel.Heap noeq type lock_state : Type u#(a + 1) = | Invariant : inv:H.slprop u#a -> lock_state let lock_store : Type u#(a+1) = list (lock_state u#a) noeq type mem : Type u#(a + 1) = { ctr: nat; heap: H.heap u#a; locks: lock_store u#a; } let heap_of_mem (x:mem) : H.heap = x.heap let mem_of_heap (h:H.heap) : mem = { ctr = 0; heap = h; locks = [] } let mem_set_heap (m:mem) (h:H.heap) : mem = { ctr = m.ctr; heap = h; locks = m.locks; } let core_mem (m:mem) : mem = mem_of_heap (heap_of_mem m) let core_mem_invol m = () let disjoint (m0 m1:mem u#h) : prop = m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks let disjoint_sym m0 m1 = () let join m0 m1 = { ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = m0.locks } let join_commutative m0 m1 = H.join_commutative m0.heap m1.heap let disjoint_join m0 m1 m2 = H.disjoint_join m0.heap m1.heap m2.heap let join_associative m0 m1 m2 = H.join_associative m0.heap m1.heap m2.heap let slprop = H.slprop let interp p m = H.interp p m.heap let equiv p1 p2 = forall m. interp p1 m <==> interp p2 m let slprop_extensionality p q = assert (forall m. interp p m <==> interp q m); let aux (h:H.heap) : Lemma (H.interp p h <==> H.interp q h) [SMTPat (H.interp p h)] = let m : mem = { ctr = 0; heap = h; locks = [] } in assert (interp p m <==> interp q m) in assert (forall h. H.interp p h <==> H.interp q h); Steel.Heap.slprop_extensionality p q let reveal_equiv p1 p2 = () let core_ref = H.core_ref let core_ref_null = H.core_ref_null let core_ref_is_null r = H.core_ref_is_null r let emp : slprop u#a = H.emp let pure = H.pure let pts_to = H.pts_to let h_and = H.h_and let h_or = H.h_or let star = H.star let wand = H.wand let h_exists = H.h_exists let h_forall = H.h_forall //////////////////////////////////////////////////////////////////////////////// //properties of equiv //////////////////////////////////////////////////////////////////////////////// let equiv_symmetric (p1 p2:slprop u#a) = H.equiv_symmetric p1 p2 #push-options "--warn_error -271" let equiv_heap_iff_equiv (p1 p2:slprop u#a) : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat (equiv p1 p2)] = let aux_lr () : Lemma (requires H.equiv p1 p2) (ensures equiv p1 p2) [SMTPat ()] = () in let aux_rl_helper1 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p1 h) (ensures H.interp p2 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl_helper2 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p2 h) (ensures H.interp p1 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl () : Lemma (requires equiv p1 p2) (ensures H.equiv p1 p2) [SMTPat ()] = () in () let equiv_heap_iff_equiv_forall () : Lemma (ensures (forall p1 p2. H.equiv p1 p2 <==> equiv p1 p2)) = let aux p1 p2 : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat ()] = equiv_heap_iff_equiv p1 p2 in () #pop-options let equiv_extensional_on_star (p1 p2 p3:slprop u#a) = equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3 let emp_unit p = H.emp_unit p let intro_emp m = H.intro_emp (heap_of_mem m) let pure_equiv p q = H.pure_equiv p q let pure_interp q m = H.pure_interp q (heap_of_mem m) let pure_star_interp p q m = H.pure_star_interp p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// //pts_to //////////////////////////////////////////////////////////////////////////////// let pts_to_compatible #a #pcm x v0 v1 m = H.pts_to_compatible #a #pcm x v0 v1 (heap_of_mem m) let pts_to_compatible_equiv #a #pcm x v0 v1 = H.pts_to_compatible_equiv #a #pcm x v0 v1 let pts_to_not_null #a #pcm x v m = H.pts_to_not_null #a #pcm x v (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // star //////////////////////////////////////////////////////////////////////////////// let intro_star p q mp mq = H.intro_star p q (heap_of_mem mp) (heap_of_mem mq) let elim_star p q m = let h = heap_of_mem m in H.elim_star p q h; assert (exists hl hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr); let hl = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hl -> exists hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let hr = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hr -> H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let ml = mem_set_heap m hl in let mr = mem_set_heap m hr in assert (disjoint ml mr); assert (m == join ml mr); assert (interp p ml); assert (interp q mr); () let interp_star (p q: slprop) (m: mem) : Lemma (interp (p `star` q) m <==> (exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m)) = let left = interp (p `star` q) m in let right = exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m in let f () : Lemma (requires left) (ensures right) = elim_star p q m in let g () : Lemma (requires right) (ensures left) = Classical.exists_elim left #_ #(fun mp -> exists (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mp -> Classical.exists_elim left #_ #(fun mq -> disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mq -> intro_star p q mp mq ) ) in Classical.move_requires f (); Classical.move_requires g () let star_commutative (p1 p2:slprop) = H.star_commutative p1 p2 let star_associative (p1 p2 p3:slprop) = H.star_associative p1 p2 p3 let star_congruence (p1 p2 p3 p4:slprop) = equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4 let affine_star (p q:slprop) (m:mem) = H.affine_star p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // Invariants on the lock store //////////////////////////////////////////////////////////////////////////////// let iname = nat module S = FStar.Set module L = FStar.List.Tot module W = FStar.Witnessed.Core let rec lock_store_invariant (e:inames) (l:lock_store u#a) : slprop u#a = let current_addr = L.length l - 1 in match l with | [] -> emp | Invariant p :: tl -> if current_addr `S.mem` e then lock_store_invariant e tl else p `star` lock_store_invariant e tl let lock_i (i:iname) (l:lock_store { i < L.length l }) = let ix = L.length l - i - 1 in L.index l ix let iname_for_p (i:iname) (p:slprop) : W.s_predicate lock_store = fun l -> i < L.length l /\ (lock_i i l).inv == p let lock_store_evolves : FStar.Preorder.preorder lock_store = fun (l1 l2 : lock_store) -> L.length l2 >= L.length l1 /\ (forall (i:nat{i < L.length l1}). (lock_i i l1).inv == (lock_i i l2).inv) let inames_in (e:inames) (l:lock_store) : prop = forall i. Set.mem i e ==> i < L.length l let inames_ok e m = inames_in e m.locks let inames_ok_empty m = () let extend_lock_store (e:inames) (l:lock_store{e `inames_in` l}) (p:slprop) : i:iname & l':lock_store { lock_store_invariant e l' == p `star` lock_store_invariant e l /\ iname_for_p i p l' } = (| L.length l, Invariant p :: l |) let set_add (i:iname) (s:inames) = Set.union (Set.singleton i) s let rec move_invariant (e:inames) (l:lock_store) (p:slprop) (i:iname{iname_for_p i p l /\ ~(i `Set.mem` e)}) : Lemma (H.equiv (lock_store_invariant e l) (p `star` lock_store_invariant (set_add i e) l)) = let rec aux (i:iname) (m:lock_store) : Lemma (requires i >= L.length m) (ensures (lock_store_invariant e m `H.equiv` lock_store_invariant (set_add i e) m)) = match m with | [] -> () | Invariant p::tl -> aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl) in let current_addr = L.length l - 1 in match l with | [] -> () | Invariant q::tl -> if i = current_addr then begin assert (lock_store_invariant e l == p `star` lock_store_invariant e tl); aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl); () end else begin move_invariant e tl p i; assert (lock_store_invariant e tl `equiv` (p `star` lock_store_invariant (set_add i e) tl)); H.star_congruence q (lock_store_invariant e tl) q (p `star` lock_store_invariant (set_add i e) tl); if Set.mem current_addr e then () else begin let r = lock_store_invariant (set_add i e) tl in assert (lock_store_invariant e l `equiv` (q `star` (p `star` r))); H.star_associative q p r; H.star_commutative q p; H.star_congruence (q `star` p) r (p `star` q) r; H.star_associative p q r end end let heap_ctr_valid (ctr:nat) (h:H.heap u#a) : prop = h `H.free_above_addr` ctr let ctr_validity (ctr:nat) (h:H.heap) : slprop = H.pure (heap_ctr_valid ctr h) let locks_invariant (e:inames) (m:mem u#a) : slprop u#a = lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m) let full_mem_pred (m:mem) = H.full_heap_pred (heap_of_mem m) (***** Following lemmas are needed in Steel.Effect *****) let core_mem_interp (hp:slprop u#a) (m:mem u#a) = () let interp_depends_only_on (hp:slprop u#a) = H.interp_depends_only_on hp let a_mem_prop_as_a_heap_prop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (H.a_heap_prop u#a) = let g (h: H.heap u#a) : Tot prop = interp sl (mem_of_heap h) /\ f (mem_of_heap h) in let phi0 (h0 h1: H.heap u#a) : Lemma (requires (g h0 /\ H.disjoint h0 h1)) (ensures (g h0 /\ H.disjoint h0 h1 /\ g (H.join h0 h1))) = assert (mem_of_heap (H.join h0 h1) == mem_of_heap h0 `join` mem_of_heap h1); interp_depends_only_on sl in let phi1 (h0 h1: H.heap u#a) : Lemma (ensures ((g h0 /\ H.disjoint h0 h1) ==> g (H.join h0 h1))) = Classical.move_requires (phi0 h0) h1 in Classical.forall_intro_2 phi1; g let refine_slprop sl f = H.as_slprop (a_mem_prop_as_a_heap_prop sl f) let interp_refine_slprop sl f m = assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_mem m)) let dep_hprop (s: slprop) (f: (hmem s -> Tot slprop)) (h: H.heap) : Tot prop = exists (h1: H.heap) . exists (h2: H.heap) . interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 let dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq' : squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h')) = let p2 (h h1 h2: H.heap) : Tot prop = interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 in let p1 (h h1: H.heap) : Tot prop = (exists h2 . p2 h h1 h2) in let h1 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p1 h) in let h2 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p2 h h1) in H.disjoint_join h' h1 h2; assert (H.disjoint h2 h'); let h2' = H.join h2 h' in H.join_commutative h2 h' ; assert (h2' == H.join h' h2); assert (H.disjoint h1 h2'); assert (mem_of_heap h2' == mem_of_heap h2 `join` mem_of_heap h'); interp_depends_only_on (f (mem_of_heap h1)); assert (interp (f (mem_of_heap h1)) (mem_of_heap h2')); H.join_commutative h1 h2; H.join_associative h' h2 h1; H.join_commutative h' h; H.join_commutative h2' h1; assert (H.join h h' == h1 `H.join` h2') let impl_intro_gen (#p: Type0) (#q: Type0) ($prf: (squash p -> Lemma (q ))) : Lemma (p ==> q) = Classical.impl_intro_gen #p #(fun _ -> q) prf let dep_hprop_is_affine1 (s: slprop) (f: (hmem s -> Tot slprop)) (h0 h1: H.heap) : Lemma ((dep_hprop s f h0 /\ H.disjoint h0 h1) ==> (H.disjoint h0 h1 /\ dep_hprop s f (H.join h0 h1))) = impl_intro_gen (dep_hprop_is_affine0 s f h0 h1) let dep_hprop_is_affine (s: slprop) (f: (hmem s -> Tot slprop)) : Lemma (H.heap_prop_is_affine (dep_hprop s f)) = Classical.forall_intro_2 (dep_hprop_is_affine1 s f) let sdep (s: slprop) (f: (hmem s -> Tot slprop)) : Tot slprop = dep_hprop_is_affine s f; H.as_slprop (dep_hprop s f) let interp_sdep (s: slprop) (f: (hmem s -> Tot slprop)) (m: mem) : Lemma (requires (dep_slprop_is_affine s f)) (ensures ( interp (sdep s f) m <==> (exists m1 m2 . interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) )) = dep_hprop_is_affine s f; assert (forall m1 m2 . (interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) ==> ( interp s (mem_of_heap m1.heap) /\ interp (f (mem_of_heap m1.heap)) (mem_of_heap m2.heap) /\ H.disjoint m1.heap m2.heap /\ H.join m1.heap m2.heap == m.heap )); interp_depends_only_on s; Classical.forall_intro (fun m -> interp_depends_only_on (f m)); assert (forall h1 h2 . (interp s (mem_of_heap h1) /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ H.disjoint h1 h2 /\ H.join h1 h2 == m.heap) ==> ( core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ interp s (core_mem (mem_of_heap h1)) /\ interp s (mem_set_heap m h1) /\ core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ f (mem_set_heap m h1) `equiv` f (mem_of_heap h1) /\ interp (f (mem_set_heap m h1)) (mem_of_heap h2) /\ interp (f (mem_set_heap m h1)) (mem_set_heap m h2) /\ disjoint (mem_set_heap m h1) (mem_set_heap m h2) /\ join (mem_set_heap m h1) (mem_set_heap m h2) == m )); () let h_exists_cong (#a:Type) (p q : a -> slprop) : Lemma (requires (forall x. p x `equiv` q x)) (ensures (h_exists p `equiv` h_exists q)) = equiv_heap_iff_equiv_forall (); H.h_exists_cong p q let intro_h_exists #a x p m = H.intro_h_exists x p (heap_of_mem m) let elim_h_exists (#a:_) (p:a -> slprop) (m:mem) = H.elim_h_exists p (heap_of_mem m) let intro_h_forall (#a:_) (p:a -> slprop) (m:mem) = H.intro_h_forall p (heap_of_mem m) let elim_h_forall (#a:_) (p:a -> slprop) (m:mem) (x:a) = H.elim_h_forall p (heap_of_mem m) x let intro_h_and (p q: slprop) (m:mem) = H.intro_h_and p q (heap_of_mem m) let elim_h_and (p q: slprop) (m:mem) = H.elim_h_and p q (heap_of_mem m) let intro_h_or_left (p q: slprop) (m:mem) = H.intro_h_or_left p q (heap_of_mem m) let intro_h_or_right (p q: slprop) (m:mem) = H.intro_h_or_right p q (heap_of_mem m) let elim_h_or (p q: slprop) (m:mem) = H.elim_h_or p q (heap_of_mem m) let intro_wand (p1 p2: slprop u#a) (m:mem) = introduce (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)) ==> interp (wand p1 p2) m with _. ( assert (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)); H.intro_wand p1 p2 (heap_of_mem m); let h = heap_of_mem m in assert ((forall h1. h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) ==> H.interp (wand p1 p2) h); introduce forall h1. (h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) with ( introduce (h `H.disjoint` h1 /\ H.interp p1 h1) ==> H.interp p2 (H.join h h1) with _. ( assert (h `H.disjoint` h1); let m1 = { ctr = m.ctr; heap = h1; locks = m.locks } in assert (m `disjoint` m1) ) ) ) (** Eliminating a wand by proving a heap that satisfies the LHS **) let elim_wand (p1 p2: slprop u#a) (m:mem) (m1:mem) = H.elim_wand p1 p2 (heap_of_mem m) (heap_of_mem m1) //////////////////////////////////////////////////////////////////////////////// // Preorders and effects //////////////////////////////////////////////////////////////////////////////// module PP = Steel.Preorder let mem_evolves = fun (m0 m1:full_mem) -> H.heap_evolves (heap_of_mem m0) (heap_of_mem m1) /\ m0.ctr <= m1.ctr /\ lock_store_evolves m0.locks m1.locks (** See [Steel.Heap.is_frame_preserving]. We add in [lock_invariants] now *) let preserves_frame (e:inames) (pre post:slprop) (m0 m1:mem) = forall (frame:slprop). interp ((pre `star` frame) `star` locks_invariant e m0) m0 ==> (interp ((post `star` frame) `star` locks_invariant e m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) (** This is a version of MstTot with frame quantified, as part of preserves_frame *) effect MstTotNF (a:Type u#a) (except:inames) (expects:slprop u#1) (provides: a -> slprop u#1) = NMSTTotal.NMSTATETOT a (full_mem u#1) mem_evolves (requires fun m0 -> inames_ok except m0 /\ interp (expects `star` locks_invariant except m0) m0) (ensures fun m0 x m1 -> inames_ok except m1 /\ interp (provides x `star` locks_invariant except m1) m1 /\ preserves_frame except expects (provides x) m0 m1) //////////////////////////////////////////////////////////////////////////////// // Lifting heap actions //////////////////////////////////////////////////////////////////////////////// (** Heap actions come in two equivalent flavors: - one that take an explicit frame as argument (action_with_frame) - and one that quantify over all the frame We therefore define two lift routes: - a direct route for those with explicit frame - via MstTotNF for the rest *) let tot_pre_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = hmem_with_inv_except e fp -> (x:a & hmem_with_inv_except e (fp' x)) let tot_pre_action_nf = tot_pre_action_nf_except S.empty let ac_reasoning_for_m_frame_preserving (p q r:slprop u#a) (m:mem u#a) : Lemma (requires interp ((p `star` q) `star` r) m) (ensures interp (p `star` r) m) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_commutative p q; equiv_extensional_on_star (p `star` q) (q `star` p) r } (q `star` p) `star` r; (equiv) { star_associative q p r } q `star` (p `star` r); }; assert (interp (q `star` (p `star` r)) m); affine_star q (p `star` r) m let is_frame_preserving (#e:inames) (#a:Type u#b) (#fp:slprop u#a) (#fp':a -> slprop u#a) (f:tot_pre_action_nf_except e fp a fp') = forall (frame:slprop u#a) (m0:hmem_with_inv_except e (fp `star` frame)). (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = f:tot_pre_action_nf_except e fp a fp'{ is_frame_preserving f } let tot_action_nf = tot_action_nf_except S.empty let linv e (m:mem) = locks_invariant e m let hheap_of_hmem #fp #e (m:hmem_with_inv_except e fp) : h:H.hheap (fp `star` linv e m) { h `H.free_above_addr` m.ctr} = let h = heap_of_mem m in H.pure_interp (heap_ctr_valid m.ctr (heap_of_mem m)) h; h let hmem_of_hheap #e (#fp0 #fp1:slprop) (m:hmem_with_inv_except e fp0) (h:H.full_hheap (fp1 `star` linv e m) { h `Heap.free_above_addr` m.ctr }) : m1:hmem_with_inv_except e fp1{linv e m `equiv` linv e m1} = let m1 : mem = { m with heap = h } in assert (interp (fp1 `star` linv e m) m1); star_commutative fp1 (linv e m); assert (interp (linv e m `star` fp1) m1); assert (linv e m1 == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); assert (linv e m == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m)); H.pure_interp (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_of_mem m); assert (heap_ctr_valid m1.ctr (heap_of_mem m) <==> heap_ctr_valid m1.ctr (heap_of_mem m1)); H.pure_equiv (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_ctr_valid m1.ctr (heap_of_mem m1)); H.star_congruence (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m)); assert (linv e m `equiv` linv e m1); let _ = equiv_extensional_on_star (linv e m) (linv e m1) fp1 in assert ((linv e m `star` fp1) `equiv` (linv e m1 `star` fp1)); assert (interp (linv e m1 `star` fp1) m1); star_commutative (linv e m1) fp1; assert (interp (fp1 `star` linv e m1) m1); m1 let with_inv_except (m:mem) e (fp:slprop) = interp (fp `star` locks_invariant e m) m #push-options "--warn_error -271" let as_hprop (frame:slprop) (mp:mprop frame) : hp:H.hprop frame{forall m. mp (core_mem m) == hp (heap_of_mem m)} = let f = fun h -> mp (mem_of_heap h) in assert (forall m. mp (core_mem m) == f (heap_of_mem m)); let aux (m0:H.hheap frame) (m1:H.heap{H.disjoint m0 m1}) : Lemma (ensures (mem_of_heap (H.join m0 m1) == join (mem_of_heap m0) (mem_of_heap m1))) [SMTPat ()] = () in f let mprop_preservation_of_hprop_preservation (p:slprop) (m0 m1:mem) : Lemma (requires (forall (hp:H.hprop p). hp (heap_of_mem m0) == hp (heap_of_mem m1))) (ensures (forall (mp:mprop p). mp (core_mem m0) == mp (core_mem m1))) = let aux (mp:mprop p) : Lemma (mp (core_mem m0) == mp (core_mem m1)) [SMTPat()] = assert (as_hprop p mp (heap_of_mem m0) == as_hprop p mp (heap_of_mem m1)) in () let lift_heap_action (#fp:slprop) (#a:Type) (#fp':a -> slprop) (e:inames) ($f:H.action fp a fp') : tot_action_nf_except e fp a fp' = let g : tot_pre_action_nf_except e fp a fp' = fun m -> let h0 = hheap_of_hmem m in let (| x, h' |) = f h0 in (| x, hmem_of_hheap m h' |) in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in let h0 = hheap_of_hmem m0 in let (| x', h1 |) = f h0 in H.action_framing f (linv e m0) h0; assert (x == x'); star_associative fp frame (linv e m0); H.action_framing f (frame `star` linv e m0) h0; assert (H.interp ((fp' x) `star` (frame `star` linv e m0)) h1); star_associative (fp' x) frame (linv e m0); assert (H.interp ((fp' x `star` frame) `star` linv e m0) h1); let h1' : H.hheap ((fp' x `star` frame) `star` linv e m0) = h1 in assert (m1 == hmem_of_hheap m0 h1'); assert (with_inv_except m1 e (fp' x `star` frame)); assert (forall (hp:H.hprop frame). hp h0 == hp h1); mprop_preservation_of_hprop_preservation frame m0 m1; () in assert (is_frame_preserving g); g let frame_preserving_respects_preorder #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (m0:hmem_with_inv_except e fp) : Lemma (let (| x, m1 |) = f m0 in mem_evolves m0 m1) = let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1) = () in H.emp_unit fp; assert (interp (fp `star` linv e m0) m0); H.star_congruence (fp `star` emp) (linv e m0) fp (linv e m0); assert (interp ((fp `star` emp) `star` linv e m0) m0); aux emp m0 let lift_tot_action_nf #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') : MstTotNF a e fp fp' = let m0 = NMSTTotal.get () in let m0' : hmem_with_inv_except e fp = m0 in let r = f m0' in let (| x, m1 |) = r in let m1' : hmem_with_inv_except e (fp' x) = m1 in assert (is_frame_preserving f); assert (m1 == dsnd (f m0)); frame_preserving_respects_preorder f m0; NMSTTotal.put #_ #(mem_evolves) m1; x let lift_tot_action #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get #(full_mem) #_ () in ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); lift_tot_action_nf f (** Now defining the lift for heap actions with explicit frame *) let tot_action_with_frame_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = frame:slprop u#a -> m0:hmem_with_inv_except e (fp `star` frame) -> Pure (x:a & hmem_with_inv_except e (fp' x `star` frame)) (requires True) (ensures fun (| x, m1 |) -> mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_with_frame = tot_action_with_frame_except S.empty let lift_heap_action_with_frame (#fp:slprop u#a) (#a:Type u#b) (#fp':a -> slprop u#a) (e:inames) ($f:H.action_with_frame fp a fp') : tot_action_with_frame_except e fp a fp' = fun frame m0 -> let h0 = hheap_of_hmem m0 in calc (equiv) { fp `star` frame `star` locks_invariant e m0; (equiv) { star_associative fp frame (locks_invariant e m0) } fp `star` (frame `star` locks_invariant e m0); }; assert (H.interp (fp `star` frame `star` locks_invariant e m0) h0); assert (H.interp (fp `star` (frame `star` locks_invariant e m0)) h0); //key: apply the heap action with frame * locks_invariant e m0 let (| x, h1 |) = f (frame `star` locks_invariant e m0) h0 in calc (equiv) { fp' x `star` (frame `star` locks_invariant e m0); (equiv) { star_associative (fp' x) frame (locks_invariant e m0) } fp' x `star` frame `star` locks_invariant e m0; }; assert (H.interp (fp' x `star` (frame `star` locks_invariant e m0)) h1); assert (H.interp (fp' x `star` frame `star` locks_invariant e m0) h1); let m1 = hmem_of_hheap m0 h1 in assert (mem_evolves m0 m1); mprop_preservation_of_hprop_preservation (frame `star` locks_invariant e m0) m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)); (| x, m1 |) let lift_tot_action_with_frame #a #e #fp #fp' ($f:tot_action_with_frame_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in assert (inames_ok e m0); ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); let m0' : hmem_with_inv_except e fp = m0 in let r = f frame m0' in let (| x, m1 |) = r in ac_reasoning_for_m_frame_preserving (fp' x) frame (locks_invariant e m1) m1; assert (interp (fp' x `star` frame `star` locks_invariant e m1) m1); assert (interp (fp' x `star` locks_invariant e m1) m1); let m1' : hmem_with_inv_except e (fp' x) = m1 in NMSTTotal.put #_ #(mem_evolves) m1; x let sel_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.sel_action #a #pcm r v0)) let upd_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.upd_action #a #pcm r v0 v1)) let free_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.free_action #a #pcm r v0)) let split_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.split_action #a #pcm r v0 v1)) let gather_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.gather_action #a #pcm r v0 v1)) let weaken (p q r:slprop) (h:H.hheap (p `star` q) { H.stronger q r }) : H.hheap (p `star` r) = H.weaken p q r h; h let weaken_pure (q r: prop) : Lemma (requires (q ==> r)) (ensures H.stronger (H.pure q) (H.pure r)) = let aux (h:H.heap) : Lemma (ensures (H.interp (H.pure q) h ==> H.interp (H.pure r) h)) [SMTPat ()] = H.pure_interp q h; H.pure_interp r h in () let inc_ctr (#p:slprop) #e (m:hmem_with_inv_except e p) : m':hmem_with_inv_except e p{m'.ctr = m.ctr + 1 /\ H.stronger (linv e m) (linv e m')} = let m' : mem = { m with ctr = m.ctr + 1} in assert (interp (p `star` linv e m) m'); assert (linv e m == lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m)); assert (linv e m' == lock_store_invariant e m.locks `star` ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken_free_above (heap_of_mem m) m.ctr (m.ctr + 1); weaken_pure (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_ctr_valid (m.ctr + 1) (heap_of_mem m)); assert (H.stronger (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m))); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)); H.stronger_star (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken (p `star` lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)) (heap_of_mem m'); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity (m.ctr + 1) (heap_of_mem m)); let m' : hmem_with_inv_except e p = m' in m' let frame_related_mems (fp0 fp1:slprop u#a) e (m0:hmem_with_inv_except e fp0) (m1:hmem_with_inv_except e fp1) = forall (frame:slprop u#a). interp ((fp0 `star` frame) `star` linv e m0) m0 ==> interp ((fp1 `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) let refined_pre_action e (fp0:slprop) (a:Type) (fp1:a -> slprop) = m0:hmem_with_inv_except e fp0 -> Pure (x:a & hmem_with_inv_except e (fp1 x)) (requires True) (ensures fun (| x, m1 |) -> frame_related_mems fp0 (fp1 x) e m0 m1) let refined_pre_action_as_action (#fp0:slprop) (#a:Type) (#fp1:a -> slprop) #e ($f:refined_pre_action e fp0 a fp1) : tot_action_nf_except e fp0 a fp1 = let g : tot_pre_action_nf_except e fp0 a fp1 = fun m -> f m in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp0 `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp1 x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x', m1' |) = g m0 in let (| x, m1 |) = f m0 in assert (x == x' /\ m1 == m1') in g let alloc_action #a #pcm e x = let f : refined_pre_action e emp (ref a pcm) (fun r -> pts_to r x) = fun m0 -> (* NS: 9/29/22 I needed to annotate h : Heap.full_heap, for use with the Core checker which generates a guard for checking the implicit pattern "dot" term in the dependent pair pattern on the next line. That guard expects `h` to be a full_heap, which is it, because it is a projection of m0. However, this is not reflected in `h`'s type. So, the Core checker, which produces a guard for the pat_dot_term in isolation, cannot recheck the term. If we were to fold in the checking of pat_dot_terms and their guards with the rest of the VC, this would work. *) let h : Heap.full_heap = hheap_of_hmem m0 in let (|r, h'|) = H.extend #a #pcm x m0.ctr h in let m' : hmem_with_inv_except e emp = inc_ctr m0 in let h' : H.hheap (pts_to #a #pcm r x `star` linv e m') = weaken _ (linv e m0) (linv e m') h' in let m1 : hmem_with_inv_except e (pts_to #a #pcm r x) = hmem_of_hheap m' h' in assert (forall frame. H.frame_related_heaps h h' emp (pts_to #a #pcm r x) frame true); let aux (frame:slprop) : Lemma (requires interp ((emp `star` frame) `star` linv e m0) m0) (ensures interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) [SMTPat (emp `star` frame)] = star_associative emp frame (linv e m0); assert (H.interp (emp `star` (frame `star` linv e m0)) h); assert (H.interp (pts_to #a #pcm r x `star` (frame `star` linv e m0)) h'); star_associative (pts_to #a #pcm r x) frame (linv e m0); assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m0) h'); assert (H.stronger (linv e m0) (linv e m')); assert (H.equiv (linv e m') (linv e m1)); assert (H.stronger (linv e m0) (linv e m1)); let h' : H.hheap ((pts_to #a #pcm r x `star` frame) `star` linv e m1) = weaken _ (linv e m0) (linv e m1) h' in assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) h'); assert (forall (mp:H.hprop frame). mp h == mp h'); mprop_preservation_of_hprop_preservation frame m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) in assert (frame_related_mems emp (pts_to r x) e m0 m1); (| r, m1 |) in lift_tot_action (refined_pre_action_as_action f) let select_refine #a #p e r x f = lift_tot_action (lift_heap_action e (H.select_refine #a #p r x f)) let upd_gen #a #p e r x y f = lift_tot_action (lift_heap_action e (H.upd_gen_action r x y f)) //////////////////////////////////////////////////////////////////////////////// // witness / recall //////////////////////////////////////////////////////////////////////////////// let witnessed_ref #a #pcm (r:ref a pcm) (fact:property a) (m:full_mem) = H.witnessed_ref #a #pcm r fact (heap_of_mem m) let witnessed_ref_stability #a #pcm (r:ref a pcm) (fact:property a) : Lemma (requires FStar.Preorder.stable fact (Steel.Preorder.preorder_of_pcm pcm)) (ensures FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) = H.witnessed_ref_stability #a #pcm r fact let witnessed (#a:Type u#1) (#pcm:pcm a) (r:ref a pcm) (fact:property a) = W.witnessed _ mem_evolves (witnessed_ref r fact) let rearrange_pqr_prq (p q r:slprop) : Lemma (((p `star` q) `star` r) `equiv` ((p `star` r) `star` q)) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_associative p q r } p `star` (q `star` r); (equiv) { star_commutative q r; star_congruence p (q `star` r) p (r `star` q) } p `star` (r `star` q); (equiv) { star_associative p r q } (p `star` r) `star` q; } let preserves_frame_cong (e:inames) (p q:slprop) (r s:slprop) (m0 m1:mem) : Lemma (requires p `equiv` r /\ q `equiv` s /\ preserves_frame e p q m0 m1) (ensures preserves_frame e r s m0 m1) = let aux0 (p q r s:slprop) : Lemma (requires p `equiv` s) (ensures (((p `star` q) `star` r) `equiv` ((s `star` q) `star` r))) = star_congruence p q s q; star_congruence (p `star` q) r (s `star` q) r in let aux (frame:slprop) : Lemma (requires interp ((r `star` frame) `star` locks_invariant e m0) m0) (ensures interp ((s `star` frame) `star` locks_invariant e m1) m1 /\ interp ((p `star` frame) `star` locks_invariant e m0) m0) [SMTPat (r `star` frame)] = aux0 p frame (locks_invariant e m0) r; aux0 q frame (locks_invariant e m1) s; assert (((p `star` frame) `star` locks_invariant e m0) `equiv` ((r `star` frame) `star` locks_invariant e m0)); assert (interp ((p `star` frame) `star` locks_invariant e m0) m0); assert (interp ((q `star` frame) `star` locks_invariant e m1) m1); assert (((q `star` frame) `star` locks_invariant e m1) `equiv` ((s `star` frame) `star` locks_invariant e m1)); () in () let pure_true_equiv (p:slprop) : Lemma ((p `star` pure True) `equiv` p) = FStar.Classical.forall_intro (pure_star_interp p True); emp_unit p; assert ((p `star` pure True) `equiv` p) let preserves_frame_star_pure (e:inames) (p q:slprop) (r s:prop) (m:mem) : Lemma (requires r /\ s) (ensures preserves_frame e p q m m <==> preserves_frame e (p `star` pure r) (q `star` pure s) m m) = pure_equiv r True; star_congruence p (pure r) p (pure True); pure_equiv s True; star_congruence q (pure s) q (pure True); pure_true_equiv p; pure_true_equiv q; let fwd () : Lemma (requires preserves_frame e p q m m) (ensures preserves_frame e (p `star` pure r) (q `star` pure s) m m) [SMTPat ()] = preserves_frame_cong e p q (p `star` pure r) (q `star` pure s) m m in let bk () : Lemma (requires preserves_frame e (p `star` pure r) (q `star` pure s) m m) (ensures preserves_frame e p q m m) [SMTPat ()] = preserves_frame_cong e (p `star` pure r) (q `star` pure s) p q m m in () let witness (#a:Type) (#pcm:pcm a) (e:inames) (r:erased (ref a pcm)) (fact:stable_property pcm) (v:Ghost.erased a) (_:squash (forall z. compatible pcm v z ==> fact z)) (frame:slprop) : MstTot (witnessed r fact) e (pts_to r v) (fun _ -> pts_to r v) frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in let _ : unit = let hr : H.ref a pcm = r in let v' = H.sel_v hr v (heap_of_mem m0) in assert (interp (H.ptr hr) m0 /\ H.sel #a #pcm hr (heap_of_mem m0) == v'); assert (compatible pcm v v'); assert (fact v'); assert (witnessed_ref r fact m0); witnessed_ref_stability r fact; assert (FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) in let w = NMSTTotal.witness _ mem_evolves (witnessed_ref r fact) in w let recall (#a:Type u#1) (#pcm:pcm a) (#fact:property a) (e:inames) (r:erased (ref a pcm)) (v:Ghost.erased a) (w:witnessed r fact) (frame:slprop) = let m0 = NMSTTotal.get () in NMSTTotal.recall _ mem_evolves (witnessed_ref r fact) w; let hr : H.ref a pcm = r in assert (witnessed_ref r fact m0); let v1 = H.sel_v hr v (heap_of_mem m0) in assert (compatible pcm v v1); assert (H.sel hr (heap_of_mem m0) == v1); assert (fact v1); assert (interp ((pts_to r v `star` frame) `star` locks_invariant e m0) m0); emp_unit ((pts_to r v `star` frame) `star` locks_invariant e m0); pure_star_interp ((pts_to r v `star` frame) `star` locks_invariant e m0) (fact v1) m0; assert (interp (((pts_to r v `star` frame) `star` locks_invariant e m0) `star` pure (fact v1)) m0); rearrange_pqr_prq (pts_to r v `star` frame) (locks_invariant e m0) (pure (fact v1)); assert (interp (((pts_to r v `star` frame) `star` pure (fact v1)) `star` locks_invariant e m0) m0); rearrange_pqr_prq (pts_to r v) frame (pure (fact v1)); star_congruence ((pts_to r v `star` frame) `star` pure (fact v1)) (locks_invariant e m0) ((pts_to r v `star` pure (fact v1)) `star` frame) (locks_invariant e m0); Ghost.hide v1 let iname_for_p_mem (i:iname) (p:slprop) : W.s_predicate mem = fun m -> iname_for_p i p m.locks let iname_for_p_stable (i:iname) (p:slprop) : Lemma (W.stable full_mem mem_evolves (iname_for_p_mem i p)) = () let ( >--> ) (i:iname) (p:slprop) : Type0 = W.witnessed full_mem mem_evolves (iname_for_p_mem i p) let hmem_with_inv_equiv e (m:mem) (p:slprop) : Lemma (interp (p `star` linv e m) m <==> interp (p `star` lock_store_invariant e m.locks) m /\ heap_ctr_valid m.ctr (heap_of_mem m)) = calc (<==>) { interp (p `star` linv e m) m; (<==>) { H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) } interp ((p `star` lock_store_invariant e m.locks) `star` ctr_validity m.ctr (heap_of_mem m)) m; (<==>) { H.pure_star_interp (p `star` lock_store_invariant e m.locks) (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_of_mem m) } interp ((p `star` lock_store_invariant e m.locks) `star` emp) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); (<==>) { H.emp_unit (p `star` lock_store_invariant e m.locks) } interp (p `star` lock_store_invariant e m.locks) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); }

{ "checked_file": "/", "dependencies": [ "Steel.Preorder.fst.checked", "Steel.Heap.fsti.checked", "prims.fst.checked", "FStar.Witnessed.Core.fsti.checked", "FStar.Set.fsti.checked", "FStar.Preorder.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.PCM.fst.checked", "FStar.NMSTTotal.fst.checked", "FStar.List.Tot.fst.checked", "FStar.IndefiniteDescription.fsti.checked", "FStar.Ghost.fsti.checked", "FStar.FunctionalExtensionality.fsti.checked", "FStar.Classical.Sugar.fsti.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Steel.Memory.fst" }

[ { "abbrev": true, "full_module": "Steel.Preorder", "short_module": "PP" }, { "abbrev": true, "full_module": "FStar.Witnessed.Core", "short_module": "W" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": true, "full_module": "Steel.Heap", "short_module": "H" }, { "abbrev": false, "full_module": "FStar.PCM", "short_module": null }, { "abbrev": false, "full_module": "FStar.FunctionalExtensionality", "short_module": null }, { "abbrev": true, "full_module": "FStar.FunctionalExtensionality", "short_module": "F" }, { "abbrev": false, "full_module": "FStar.PCM", "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

e: Steel.Memory.inames -> p: Steel.Memory.slprop -> m0: Steel.Memory.hmem_with_inv_except e p {Steel.Memory.inames_in e (Mkmem?.locks m0)} -> Prims.Pure (Steel.Memory.iname * Steel.Memory.hmem_with_inv_except e Steel.Memory.emp)

Prims.Pure

[]

[ "Steel.Memory.inames", "Steel.Memory.slprop", "Steel.Memory.hmem_with_inv_except", "Steel.Memory.inames_in", "Steel.Memory.__proj__Mkmem__item__locks", "Steel.Memory.iname", "Steel.Memory.lock_store", "Prims.l_and", "Prims.eq2", "Steel.Memory.lock_store_invariant", "Steel.Memory.star", "Steel.Memory.iname_for_p", "FStar.Pervasives.Native.Mktuple2", "Steel.Memory.emp", "Prims.unit", "Prims._assert", "Steel.Memory.frame_related_mems", "Steel.Memory.interp", "Steel.Memory.linv", "Prims.squash", "Steel.Memory.mem_evolves", "Prims.l_Forall", "Steel.Memory.mprop", "Prims.l_iff", "Steel.Memory.core_mem", "Prims.Cons", "FStar.Pervasives.pattern", "FStar.Pervasives.smt_pat", "Prims.Nil", "FStar.Calc.calc_finish", "Steel.Memory.equiv", "FStar.Preorder.relation", "FStar.Calc.calc_step", "FStar.Calc.calc_init", "FStar.Calc.calc_pack", "Steel.Heap.star_associative", "Steel.Heap.star_congruence", "Steel.Heap.star_commutative", "Steel.Heap.emp_unit", "Steel.Memory.hmem_with_inv_equiv", "Steel.Memory.lock_store_evolves", "Steel.Memory.iname_for_p_mem", "Steel.Memory.ctr_validity", "Steel.Memory.__proj__Mkmem__item__ctr", "Steel.Memory.heap_of_mem", "Steel.Memory.mem", "Steel.Memory.Mkmem", "Steel.Memory.__proj__Mkmem__item__heap", "FStar.Pervasives.Native.tuple2", "Prims.dtuple2", "Steel.Memory.extend_lock_store", "Prims.l_True" ]

[]

false

let new_invariant_tot_action (e: inames) (p: slprop) (m0: hmem_with_inv_except e p {e `inames_in` m0.locks}) : Pure (iname & hmem_with_inv_except e emp) (requires True) (ensures fun (i, m1) -> iname_for_p_mem i p m1 /\ frame_related_mems p emp e m0 m1 /\ mem_evolves m0 m1) =

let (| i , l1 |) = extend_lock_store e m0.locks p in let m1 = { m0 with locks = l1 } in assert (lock_store_invariant e m1.locks == p `star` (lock_store_invariant e m0.locks)); calc (equiv) { linv e m1; (equiv) { () } ((lock_store_invariant e m1.locks) `star` (ctr_validity m1.ctr (heap_of_mem m1))); (equiv) { () } ((p `star` (lock_store_invariant e m0.locks)) `star` (ctr_validity m1.ctr (heap_of_mem m1))); (equiv) { H.star_associative p (lock_store_invariant e m0.locks) (ctr_validity m1.ctr (heap_of_mem m1)) } (p `star` ((lock_store_invariant e m0.locks) `star` (ctr_validity m1.ctr (heap_of_mem m1)))); (equiv) { () } (p `star` (linv e m0)); }; assert (iname_for_p_mem i p m1); assert (lock_store_evolves m0.locks l1); assert (mem_evolves m0 m1); hmem_with_inv_equiv e m0 p; assert (interp (p `star` (lock_store_invariant e m0.locks)) m1); assert (interp (lock_store_invariant e m1.locks) m1); H.emp_unit (lock_store_invariant e m1.locks); H.star_commutative (lock_store_invariant e m1.locks) emp; assert (interp (emp `star` (lock_store_invariant e m1.locks)) m1); hmem_with_inv_equiv e m1 emp; let m1:hmem_with_inv_except e emp = m1 in let aux (frame: slprop) : Lemma (requires interp ((p `star` frame) `star` (linv e m0)) m0) (ensures interp ((emp `star` frame) `star` (linv e m1)) m1 /\ mem_evolves m0 m1 /\ (forall (mp: mprop frame). mp (core_mem m0) <==> mp (core_mem m1))) [SMTPat (p `star` frame)] = assert (interp ((p `star` frame) `star` (linv e m0)) m1); calc (equiv) { ((p `star` frame) `star` (linv e m0)); (equiv) { (H.star_commutative p frame; H.star_congruence (p `star` frame) (linv e m0) (frame `star` p) (linv e m0); H.star_associative frame p (linv e m0)) } (frame `star` (p `star` (linv e m0))); (equiv) { H.star_congruence frame (p `star` (linv e m0)) frame (linv e m1) } (frame `star` (linv e m1)); (equiv) { (H.emp_unit (frame `star` (linv e m1)); H.star_commutative (frame `star` (linv e m1)) emp; H.star_associative emp frame (linv e m1)) } ((emp `star` frame) `star` (linv e m1)); }; assert (interp ((emp `star` frame) `star` (linv e m1)) m1) in assert (frame_related_mems p emp e m0 m1); (i, m1)

false

Steel.Memory.fst

Steel.Memory.recall

val recall (#a:Type u#1) (#pcm:pcm a) (#fact:property a) (e:inames) (r:erased (ref a pcm)) (v:Ghost.erased a) (w:witnessed r fact) : action_except (v1:Ghost.erased a{compatible pcm v v1}) e (pts_to r v) (fun v1 -> pts_to r v `star` pure (fact v1))

let recall (#a:Type u#1) (#pcm:pcm a) (#fact:property a) (e:inames) (r:erased (ref a pcm)) (v:Ghost.erased a) (w:witnessed r fact) (frame:slprop) = let m0 = NMSTTotal.get () in NMSTTotal.recall _ mem_evolves (witnessed_ref r fact) w; let hr : H.ref a pcm = r in assert (witnessed_ref r fact m0); let v1 = H.sel_v hr v (heap_of_mem m0) in assert (compatible pcm v v1); assert (H.sel hr (heap_of_mem m0) == v1); assert (fact v1); assert (interp ((pts_to r v `star` frame) `star` locks_invariant e m0) m0); emp_unit ((pts_to r v `star` frame) `star` locks_invariant e m0); pure_star_interp ((pts_to r v `star` frame) `star` locks_invariant e m0) (fact v1) m0; assert (interp (((pts_to r v `star` frame) `star` locks_invariant e m0) `star` pure (fact v1)) m0); rearrange_pqr_prq (pts_to r v `star` frame) (locks_invariant e m0) (pure (fact v1)); assert (interp (((pts_to r v `star` frame) `star` pure (fact v1)) `star` locks_invariant e m0) m0); rearrange_pqr_prq (pts_to r v) frame (pure (fact v1)); star_congruence ((pts_to r v `star` frame) `star` pure (fact v1)) (locks_invariant e m0) ((pts_to r v `star` pure (fact v1)) `star` frame) (locks_invariant e m0); Ghost.hide v1

{ "file_name": "lib/steel/Steel.Memory.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 17, "end_line": 1149, "start_col": 0, "start_line": 1119 }

(* 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.Memory module F = FStar.FunctionalExtensionality open FStar.FunctionalExtensionality open FStar.PCM module H = Steel.Heap noeq type lock_state : Type u#(a + 1) = | Invariant : inv:H.slprop u#a -> lock_state let lock_store : Type u#(a+1) = list (lock_state u#a) noeq type mem : Type u#(a + 1) = { ctr: nat; heap: H.heap u#a; locks: lock_store u#a; } let heap_of_mem (x:mem) : H.heap = x.heap let mem_of_heap (h:H.heap) : mem = { ctr = 0; heap = h; locks = [] } let mem_set_heap (m:mem) (h:H.heap) : mem = { ctr = m.ctr; heap = h; locks = m.locks; } let core_mem (m:mem) : mem = mem_of_heap (heap_of_mem m) let core_mem_invol m = () let disjoint (m0 m1:mem u#h) : prop = m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks let disjoint_sym m0 m1 = () let join m0 m1 = { ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = m0.locks } let join_commutative m0 m1 = H.join_commutative m0.heap m1.heap let disjoint_join m0 m1 m2 = H.disjoint_join m0.heap m1.heap m2.heap let join_associative m0 m1 m2 = H.join_associative m0.heap m1.heap m2.heap let slprop = H.slprop let interp p m = H.interp p m.heap let equiv p1 p2 = forall m. interp p1 m <==> interp p2 m let slprop_extensionality p q = assert (forall m. interp p m <==> interp q m); let aux (h:H.heap) : Lemma (H.interp p h <==> H.interp q h) [SMTPat (H.interp p h)] = let m : mem = { ctr = 0; heap = h; locks = [] } in assert (interp p m <==> interp q m) in assert (forall h. H.interp p h <==> H.interp q h); Steel.Heap.slprop_extensionality p q let reveal_equiv p1 p2 = () let core_ref = H.core_ref let core_ref_null = H.core_ref_null let core_ref_is_null r = H.core_ref_is_null r let emp : slprop u#a = H.emp let pure = H.pure let pts_to = H.pts_to let h_and = H.h_and let h_or = H.h_or let star = H.star let wand = H.wand let h_exists = H.h_exists let h_forall = H.h_forall //////////////////////////////////////////////////////////////////////////////// //properties of equiv //////////////////////////////////////////////////////////////////////////////// let equiv_symmetric (p1 p2:slprop u#a) = H.equiv_symmetric p1 p2 #push-options "--warn_error -271" let equiv_heap_iff_equiv (p1 p2:slprop u#a) : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat (equiv p1 p2)] = let aux_lr () : Lemma (requires H.equiv p1 p2) (ensures equiv p1 p2) [SMTPat ()] = () in let aux_rl_helper1 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p1 h) (ensures H.interp p2 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl_helper2 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p2 h) (ensures H.interp p1 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl () : Lemma (requires equiv p1 p2) (ensures H.equiv p1 p2) [SMTPat ()] = () in () let equiv_heap_iff_equiv_forall () : Lemma (ensures (forall p1 p2. H.equiv p1 p2 <==> equiv p1 p2)) = let aux p1 p2 : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat ()] = equiv_heap_iff_equiv p1 p2 in () #pop-options let equiv_extensional_on_star (p1 p2 p3:slprop u#a) = equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3 let emp_unit p = H.emp_unit p let intro_emp m = H.intro_emp (heap_of_mem m) let pure_equiv p q = H.pure_equiv p q let pure_interp q m = H.pure_interp q (heap_of_mem m) let pure_star_interp p q m = H.pure_star_interp p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// //pts_to //////////////////////////////////////////////////////////////////////////////// let pts_to_compatible #a #pcm x v0 v1 m = H.pts_to_compatible #a #pcm x v0 v1 (heap_of_mem m) let pts_to_compatible_equiv #a #pcm x v0 v1 = H.pts_to_compatible_equiv #a #pcm x v0 v1 let pts_to_not_null #a #pcm x v m = H.pts_to_not_null #a #pcm x v (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // star //////////////////////////////////////////////////////////////////////////////// let intro_star p q mp mq = H.intro_star p q (heap_of_mem mp) (heap_of_mem mq) let elim_star p q m = let h = heap_of_mem m in H.elim_star p q h; assert (exists hl hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr); let hl = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hl -> exists hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let hr = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hr -> H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let ml = mem_set_heap m hl in let mr = mem_set_heap m hr in assert (disjoint ml mr); assert (m == join ml mr); assert (interp p ml); assert (interp q mr); () let interp_star (p q: slprop) (m: mem) : Lemma (interp (p `star` q) m <==> (exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m)) = let left = interp (p `star` q) m in let right = exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m in let f () : Lemma (requires left) (ensures right) = elim_star p q m in let g () : Lemma (requires right) (ensures left) = Classical.exists_elim left #_ #(fun mp -> exists (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mp -> Classical.exists_elim left #_ #(fun mq -> disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mq -> intro_star p q mp mq ) ) in Classical.move_requires f (); Classical.move_requires g () let star_commutative (p1 p2:slprop) = H.star_commutative p1 p2 let star_associative (p1 p2 p3:slprop) = H.star_associative p1 p2 p3 let star_congruence (p1 p2 p3 p4:slprop) = equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4 let affine_star (p q:slprop) (m:mem) = H.affine_star p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // Invariants on the lock store //////////////////////////////////////////////////////////////////////////////// let iname = nat module S = FStar.Set module L = FStar.List.Tot module W = FStar.Witnessed.Core let rec lock_store_invariant (e:inames) (l:lock_store u#a) : slprop u#a = let current_addr = L.length l - 1 in match l with | [] -> emp | Invariant p :: tl -> if current_addr `S.mem` e then lock_store_invariant e tl else p `star` lock_store_invariant e tl let lock_i (i:iname) (l:lock_store { i < L.length l }) = let ix = L.length l - i - 1 in L.index l ix let iname_for_p (i:iname) (p:slprop) : W.s_predicate lock_store = fun l -> i < L.length l /\ (lock_i i l).inv == p let lock_store_evolves : FStar.Preorder.preorder lock_store = fun (l1 l2 : lock_store) -> L.length l2 >= L.length l1 /\ (forall (i:nat{i < L.length l1}). (lock_i i l1).inv == (lock_i i l2).inv) let inames_in (e:inames) (l:lock_store) : prop = forall i. Set.mem i e ==> i < L.length l let inames_ok e m = inames_in e m.locks let inames_ok_empty m = () let extend_lock_store (e:inames) (l:lock_store{e `inames_in` l}) (p:slprop) : i:iname & l':lock_store { lock_store_invariant e l' == p `star` lock_store_invariant e l /\ iname_for_p i p l' } = (| L.length l, Invariant p :: l |) let set_add (i:iname) (s:inames) = Set.union (Set.singleton i) s let rec move_invariant (e:inames) (l:lock_store) (p:slprop) (i:iname{iname_for_p i p l /\ ~(i `Set.mem` e)}) : Lemma (H.equiv (lock_store_invariant e l) (p `star` lock_store_invariant (set_add i e) l)) = let rec aux (i:iname) (m:lock_store) : Lemma (requires i >= L.length m) (ensures (lock_store_invariant e m `H.equiv` lock_store_invariant (set_add i e) m)) = match m with | [] -> () | Invariant p::tl -> aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl) in let current_addr = L.length l - 1 in match l with | [] -> () | Invariant q::tl -> if i = current_addr then begin assert (lock_store_invariant e l == p `star` lock_store_invariant e tl); aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl); () end else begin move_invariant e tl p i; assert (lock_store_invariant e tl `equiv` (p `star` lock_store_invariant (set_add i e) tl)); H.star_congruence q (lock_store_invariant e tl) q (p `star` lock_store_invariant (set_add i e) tl); if Set.mem current_addr e then () else begin let r = lock_store_invariant (set_add i e) tl in assert (lock_store_invariant e l `equiv` (q `star` (p `star` r))); H.star_associative q p r; H.star_commutative q p; H.star_congruence (q `star` p) r (p `star` q) r; H.star_associative p q r end end let heap_ctr_valid (ctr:nat) (h:H.heap u#a) : prop = h `H.free_above_addr` ctr let ctr_validity (ctr:nat) (h:H.heap) : slprop = H.pure (heap_ctr_valid ctr h) let locks_invariant (e:inames) (m:mem u#a) : slprop u#a = lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m) let full_mem_pred (m:mem) = H.full_heap_pred (heap_of_mem m) (***** Following lemmas are needed in Steel.Effect *****) let core_mem_interp (hp:slprop u#a) (m:mem u#a) = () let interp_depends_only_on (hp:slprop u#a) = H.interp_depends_only_on hp let a_mem_prop_as_a_heap_prop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (H.a_heap_prop u#a) = let g (h: H.heap u#a) : Tot prop = interp sl (mem_of_heap h) /\ f (mem_of_heap h) in let phi0 (h0 h1: H.heap u#a) : Lemma (requires (g h0 /\ H.disjoint h0 h1)) (ensures (g h0 /\ H.disjoint h0 h1 /\ g (H.join h0 h1))) = assert (mem_of_heap (H.join h0 h1) == mem_of_heap h0 `join` mem_of_heap h1); interp_depends_only_on sl in let phi1 (h0 h1: H.heap u#a) : Lemma (ensures ((g h0 /\ H.disjoint h0 h1) ==> g (H.join h0 h1))) = Classical.move_requires (phi0 h0) h1 in Classical.forall_intro_2 phi1; g let refine_slprop sl f = H.as_slprop (a_mem_prop_as_a_heap_prop sl f) let interp_refine_slprop sl f m = assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_mem m)) let dep_hprop (s: slprop) (f: (hmem s -> Tot slprop)) (h: H.heap) : Tot prop = exists (h1: H.heap) . exists (h2: H.heap) . interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 let dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq' : squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h')) = let p2 (h h1 h2: H.heap) : Tot prop = interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 in let p1 (h h1: H.heap) : Tot prop = (exists h2 . p2 h h1 h2) in let h1 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p1 h) in let h2 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p2 h h1) in H.disjoint_join h' h1 h2; assert (H.disjoint h2 h'); let h2' = H.join h2 h' in H.join_commutative h2 h' ; assert (h2' == H.join h' h2); assert (H.disjoint h1 h2'); assert (mem_of_heap h2' == mem_of_heap h2 `join` mem_of_heap h'); interp_depends_only_on (f (mem_of_heap h1)); assert (interp (f (mem_of_heap h1)) (mem_of_heap h2')); H.join_commutative h1 h2; H.join_associative h' h2 h1; H.join_commutative h' h; H.join_commutative h2' h1; assert (H.join h h' == h1 `H.join` h2') let impl_intro_gen (#p: Type0) (#q: Type0) ($prf: (squash p -> Lemma (q ))) : Lemma (p ==> q) = Classical.impl_intro_gen #p #(fun _ -> q) prf let dep_hprop_is_affine1 (s: slprop) (f: (hmem s -> Tot slprop)) (h0 h1: H.heap) : Lemma ((dep_hprop s f h0 /\ H.disjoint h0 h1) ==> (H.disjoint h0 h1 /\ dep_hprop s f (H.join h0 h1))) = impl_intro_gen (dep_hprop_is_affine0 s f h0 h1) let dep_hprop_is_affine (s: slprop) (f: (hmem s -> Tot slprop)) : Lemma (H.heap_prop_is_affine (dep_hprop s f)) = Classical.forall_intro_2 (dep_hprop_is_affine1 s f) let sdep (s: slprop) (f: (hmem s -> Tot slprop)) : Tot slprop = dep_hprop_is_affine s f; H.as_slprop (dep_hprop s f) let interp_sdep (s: slprop) (f: (hmem s -> Tot slprop)) (m: mem) : Lemma (requires (dep_slprop_is_affine s f)) (ensures ( interp (sdep s f) m <==> (exists m1 m2 . interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) )) = dep_hprop_is_affine s f; assert (forall m1 m2 . (interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) ==> ( interp s (mem_of_heap m1.heap) /\ interp (f (mem_of_heap m1.heap)) (mem_of_heap m2.heap) /\ H.disjoint m1.heap m2.heap /\ H.join m1.heap m2.heap == m.heap )); interp_depends_only_on s; Classical.forall_intro (fun m -> interp_depends_only_on (f m)); assert (forall h1 h2 . (interp s (mem_of_heap h1) /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ H.disjoint h1 h2 /\ H.join h1 h2 == m.heap) ==> ( core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ interp s (core_mem (mem_of_heap h1)) /\ interp s (mem_set_heap m h1) /\ core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ f (mem_set_heap m h1) `equiv` f (mem_of_heap h1) /\ interp (f (mem_set_heap m h1)) (mem_of_heap h2) /\ interp (f (mem_set_heap m h1)) (mem_set_heap m h2) /\ disjoint (mem_set_heap m h1) (mem_set_heap m h2) /\ join (mem_set_heap m h1) (mem_set_heap m h2) == m )); () let h_exists_cong (#a:Type) (p q : a -> slprop) : Lemma (requires (forall x. p x `equiv` q x)) (ensures (h_exists p `equiv` h_exists q)) = equiv_heap_iff_equiv_forall (); H.h_exists_cong p q let intro_h_exists #a x p m = H.intro_h_exists x p (heap_of_mem m) let elim_h_exists (#a:_) (p:a -> slprop) (m:mem) = H.elim_h_exists p (heap_of_mem m) let intro_h_forall (#a:_) (p:a -> slprop) (m:mem) = H.intro_h_forall p (heap_of_mem m) let elim_h_forall (#a:_) (p:a -> slprop) (m:mem) (x:a) = H.elim_h_forall p (heap_of_mem m) x let intro_h_and (p q: slprop) (m:mem) = H.intro_h_and p q (heap_of_mem m) let elim_h_and (p q: slprop) (m:mem) = H.elim_h_and p q (heap_of_mem m) let intro_h_or_left (p q: slprop) (m:mem) = H.intro_h_or_left p q (heap_of_mem m) let intro_h_or_right (p q: slprop) (m:mem) = H.intro_h_or_right p q (heap_of_mem m) let elim_h_or (p q: slprop) (m:mem) = H.elim_h_or p q (heap_of_mem m) let intro_wand (p1 p2: slprop u#a) (m:mem) = introduce (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)) ==> interp (wand p1 p2) m with _. ( assert (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)); H.intro_wand p1 p2 (heap_of_mem m); let h = heap_of_mem m in assert ((forall h1. h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) ==> H.interp (wand p1 p2) h); introduce forall h1. (h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) with ( introduce (h `H.disjoint` h1 /\ H.interp p1 h1) ==> H.interp p2 (H.join h h1) with _. ( assert (h `H.disjoint` h1); let m1 = { ctr = m.ctr; heap = h1; locks = m.locks } in assert (m `disjoint` m1) ) ) ) (** Eliminating a wand by proving a heap that satisfies the LHS **) let elim_wand (p1 p2: slprop u#a) (m:mem) (m1:mem) = H.elim_wand p1 p2 (heap_of_mem m) (heap_of_mem m1) //////////////////////////////////////////////////////////////////////////////// // Preorders and effects //////////////////////////////////////////////////////////////////////////////// module PP = Steel.Preorder let mem_evolves = fun (m0 m1:full_mem) -> H.heap_evolves (heap_of_mem m0) (heap_of_mem m1) /\ m0.ctr <= m1.ctr /\ lock_store_evolves m0.locks m1.locks (** See [Steel.Heap.is_frame_preserving]. We add in [lock_invariants] now *) let preserves_frame (e:inames) (pre post:slprop) (m0 m1:mem) = forall (frame:slprop). interp ((pre `star` frame) `star` locks_invariant e m0) m0 ==> (interp ((post `star` frame) `star` locks_invariant e m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) (** This is a version of MstTot with frame quantified, as part of preserves_frame *) effect MstTotNF (a:Type u#a) (except:inames) (expects:slprop u#1) (provides: a -> slprop u#1) = NMSTTotal.NMSTATETOT a (full_mem u#1) mem_evolves (requires fun m0 -> inames_ok except m0 /\ interp (expects `star` locks_invariant except m0) m0) (ensures fun m0 x m1 -> inames_ok except m1 /\ interp (provides x `star` locks_invariant except m1) m1 /\ preserves_frame except expects (provides x) m0 m1) //////////////////////////////////////////////////////////////////////////////// // Lifting heap actions //////////////////////////////////////////////////////////////////////////////// (** Heap actions come in two equivalent flavors: - one that take an explicit frame as argument (action_with_frame) - and one that quantify over all the frame We therefore define two lift routes: - a direct route for those with explicit frame - via MstTotNF for the rest *) let tot_pre_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = hmem_with_inv_except e fp -> (x:a & hmem_with_inv_except e (fp' x)) let tot_pre_action_nf = tot_pre_action_nf_except S.empty let ac_reasoning_for_m_frame_preserving (p q r:slprop u#a) (m:mem u#a) : Lemma (requires interp ((p `star` q) `star` r) m) (ensures interp (p `star` r) m) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_commutative p q; equiv_extensional_on_star (p `star` q) (q `star` p) r } (q `star` p) `star` r; (equiv) { star_associative q p r } q `star` (p `star` r); }; assert (interp (q `star` (p `star` r)) m); affine_star q (p `star` r) m let is_frame_preserving (#e:inames) (#a:Type u#b) (#fp:slprop u#a) (#fp':a -> slprop u#a) (f:tot_pre_action_nf_except e fp a fp') = forall (frame:slprop u#a) (m0:hmem_with_inv_except e (fp `star` frame)). (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = f:tot_pre_action_nf_except e fp a fp'{ is_frame_preserving f } let tot_action_nf = tot_action_nf_except S.empty let linv e (m:mem) = locks_invariant e m let hheap_of_hmem #fp #e (m:hmem_with_inv_except e fp) : h:H.hheap (fp `star` linv e m) { h `H.free_above_addr` m.ctr} = let h = heap_of_mem m in H.pure_interp (heap_ctr_valid m.ctr (heap_of_mem m)) h; h let hmem_of_hheap #e (#fp0 #fp1:slprop) (m:hmem_with_inv_except e fp0) (h:H.full_hheap (fp1 `star` linv e m) { h `Heap.free_above_addr` m.ctr }) : m1:hmem_with_inv_except e fp1{linv e m `equiv` linv e m1} = let m1 : mem = { m with heap = h } in assert (interp (fp1 `star` linv e m) m1); star_commutative fp1 (linv e m); assert (interp (linv e m `star` fp1) m1); assert (linv e m1 == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); assert (linv e m == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m)); H.pure_interp (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_of_mem m); assert (heap_ctr_valid m1.ctr (heap_of_mem m) <==> heap_ctr_valid m1.ctr (heap_of_mem m1)); H.pure_equiv (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_ctr_valid m1.ctr (heap_of_mem m1)); H.star_congruence (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m)); assert (linv e m `equiv` linv e m1); let _ = equiv_extensional_on_star (linv e m) (linv e m1) fp1 in assert ((linv e m `star` fp1) `equiv` (linv e m1 `star` fp1)); assert (interp (linv e m1 `star` fp1) m1); star_commutative (linv e m1) fp1; assert (interp (fp1 `star` linv e m1) m1); m1 let with_inv_except (m:mem) e (fp:slprop) = interp (fp `star` locks_invariant e m) m #push-options "--warn_error -271" let as_hprop (frame:slprop) (mp:mprop frame) : hp:H.hprop frame{forall m. mp (core_mem m) == hp (heap_of_mem m)} = let f = fun h -> mp (mem_of_heap h) in assert (forall m. mp (core_mem m) == f (heap_of_mem m)); let aux (m0:H.hheap frame) (m1:H.heap{H.disjoint m0 m1}) : Lemma (ensures (mem_of_heap (H.join m0 m1) == join (mem_of_heap m0) (mem_of_heap m1))) [SMTPat ()] = () in f let mprop_preservation_of_hprop_preservation (p:slprop) (m0 m1:mem) : Lemma (requires (forall (hp:H.hprop p). hp (heap_of_mem m0) == hp (heap_of_mem m1))) (ensures (forall (mp:mprop p). mp (core_mem m0) == mp (core_mem m1))) = let aux (mp:mprop p) : Lemma (mp (core_mem m0) == mp (core_mem m1)) [SMTPat()] = assert (as_hprop p mp (heap_of_mem m0) == as_hprop p mp (heap_of_mem m1)) in () let lift_heap_action (#fp:slprop) (#a:Type) (#fp':a -> slprop) (e:inames) ($f:H.action fp a fp') : tot_action_nf_except e fp a fp' = let g : tot_pre_action_nf_except e fp a fp' = fun m -> let h0 = hheap_of_hmem m in let (| x, h' |) = f h0 in (| x, hmem_of_hheap m h' |) in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in let h0 = hheap_of_hmem m0 in let (| x', h1 |) = f h0 in H.action_framing f (linv e m0) h0; assert (x == x'); star_associative fp frame (linv e m0); H.action_framing f (frame `star` linv e m0) h0; assert (H.interp ((fp' x) `star` (frame `star` linv e m0)) h1); star_associative (fp' x) frame (linv e m0); assert (H.interp ((fp' x `star` frame) `star` linv e m0) h1); let h1' : H.hheap ((fp' x `star` frame) `star` linv e m0) = h1 in assert (m1 == hmem_of_hheap m0 h1'); assert (with_inv_except m1 e (fp' x `star` frame)); assert (forall (hp:H.hprop frame). hp h0 == hp h1); mprop_preservation_of_hprop_preservation frame m0 m1; () in assert (is_frame_preserving g); g let frame_preserving_respects_preorder #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (m0:hmem_with_inv_except e fp) : Lemma (let (| x, m1 |) = f m0 in mem_evolves m0 m1) = let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1) = () in H.emp_unit fp; assert (interp (fp `star` linv e m0) m0); H.star_congruence (fp `star` emp) (linv e m0) fp (linv e m0); assert (interp ((fp `star` emp) `star` linv e m0) m0); aux emp m0 let lift_tot_action_nf #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') : MstTotNF a e fp fp' = let m0 = NMSTTotal.get () in let m0' : hmem_with_inv_except e fp = m0 in let r = f m0' in let (| x, m1 |) = r in let m1' : hmem_with_inv_except e (fp' x) = m1 in assert (is_frame_preserving f); assert (m1 == dsnd (f m0)); frame_preserving_respects_preorder f m0; NMSTTotal.put #_ #(mem_evolves) m1; x let lift_tot_action #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get #(full_mem) #_ () in ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); lift_tot_action_nf f (** Now defining the lift for heap actions with explicit frame *) let tot_action_with_frame_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = frame:slprop u#a -> m0:hmem_with_inv_except e (fp `star` frame) -> Pure (x:a & hmem_with_inv_except e (fp' x `star` frame)) (requires True) (ensures fun (| x, m1 |) -> mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_with_frame = tot_action_with_frame_except S.empty let lift_heap_action_with_frame (#fp:slprop u#a) (#a:Type u#b) (#fp':a -> slprop u#a) (e:inames) ($f:H.action_with_frame fp a fp') : tot_action_with_frame_except e fp a fp' = fun frame m0 -> let h0 = hheap_of_hmem m0 in calc (equiv) { fp `star` frame `star` locks_invariant e m0; (equiv) { star_associative fp frame (locks_invariant e m0) } fp `star` (frame `star` locks_invariant e m0); }; assert (H.interp (fp `star` frame `star` locks_invariant e m0) h0); assert (H.interp (fp `star` (frame `star` locks_invariant e m0)) h0); //key: apply the heap action with frame * locks_invariant e m0 let (| x, h1 |) = f (frame `star` locks_invariant e m0) h0 in calc (equiv) { fp' x `star` (frame `star` locks_invariant e m0); (equiv) { star_associative (fp' x) frame (locks_invariant e m0) } fp' x `star` frame `star` locks_invariant e m0; }; assert (H.interp (fp' x `star` (frame `star` locks_invariant e m0)) h1); assert (H.interp (fp' x `star` frame `star` locks_invariant e m0) h1); let m1 = hmem_of_hheap m0 h1 in assert (mem_evolves m0 m1); mprop_preservation_of_hprop_preservation (frame `star` locks_invariant e m0) m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)); (| x, m1 |) let lift_tot_action_with_frame #a #e #fp #fp' ($f:tot_action_with_frame_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in assert (inames_ok e m0); ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); let m0' : hmem_with_inv_except e fp = m0 in let r = f frame m0' in let (| x, m1 |) = r in ac_reasoning_for_m_frame_preserving (fp' x) frame (locks_invariant e m1) m1; assert (interp (fp' x `star` frame `star` locks_invariant e m1) m1); assert (interp (fp' x `star` locks_invariant e m1) m1); let m1' : hmem_with_inv_except e (fp' x) = m1 in NMSTTotal.put #_ #(mem_evolves) m1; x let sel_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.sel_action #a #pcm r v0)) let upd_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.upd_action #a #pcm r v0 v1)) let free_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.free_action #a #pcm r v0)) let split_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.split_action #a #pcm r v0 v1)) let gather_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.gather_action #a #pcm r v0 v1)) let weaken (p q r:slprop) (h:H.hheap (p `star` q) { H.stronger q r }) : H.hheap (p `star` r) = H.weaken p q r h; h let weaken_pure (q r: prop) : Lemma (requires (q ==> r)) (ensures H.stronger (H.pure q) (H.pure r)) = let aux (h:H.heap) : Lemma (ensures (H.interp (H.pure q) h ==> H.interp (H.pure r) h)) [SMTPat ()] = H.pure_interp q h; H.pure_interp r h in () let inc_ctr (#p:slprop) #e (m:hmem_with_inv_except e p) : m':hmem_with_inv_except e p{m'.ctr = m.ctr + 1 /\ H.stronger (linv e m) (linv e m')} = let m' : mem = { m with ctr = m.ctr + 1} in assert (interp (p `star` linv e m) m'); assert (linv e m == lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m)); assert (linv e m' == lock_store_invariant e m.locks `star` ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken_free_above (heap_of_mem m) m.ctr (m.ctr + 1); weaken_pure (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_ctr_valid (m.ctr + 1) (heap_of_mem m)); assert (H.stronger (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m))); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)); H.stronger_star (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken (p `star` lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)) (heap_of_mem m'); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity (m.ctr + 1) (heap_of_mem m)); let m' : hmem_with_inv_except e p = m' in m' let frame_related_mems (fp0 fp1:slprop u#a) e (m0:hmem_with_inv_except e fp0) (m1:hmem_with_inv_except e fp1) = forall (frame:slprop u#a). interp ((fp0 `star` frame) `star` linv e m0) m0 ==> interp ((fp1 `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) let refined_pre_action e (fp0:slprop) (a:Type) (fp1:a -> slprop) = m0:hmem_with_inv_except e fp0 -> Pure (x:a & hmem_with_inv_except e (fp1 x)) (requires True) (ensures fun (| x, m1 |) -> frame_related_mems fp0 (fp1 x) e m0 m1) let refined_pre_action_as_action (#fp0:slprop) (#a:Type) (#fp1:a -> slprop) #e ($f:refined_pre_action e fp0 a fp1) : tot_action_nf_except e fp0 a fp1 = let g : tot_pre_action_nf_except e fp0 a fp1 = fun m -> f m in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp0 `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp1 x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x', m1' |) = g m0 in let (| x, m1 |) = f m0 in assert (x == x' /\ m1 == m1') in g let alloc_action #a #pcm e x = let f : refined_pre_action e emp (ref a pcm) (fun r -> pts_to r x) = fun m0 -> (* NS: 9/29/22 I needed to annotate h : Heap.full_heap, for use with the Core checker which generates a guard for checking the implicit pattern "dot" term in the dependent pair pattern on the next line. That guard expects `h` to be a full_heap, which is it, because it is a projection of m0. However, this is not reflected in `h`'s type. So, the Core checker, which produces a guard for the pat_dot_term in isolation, cannot recheck the term. If we were to fold in the checking of pat_dot_terms and their guards with the rest of the VC, this would work. *) let h : Heap.full_heap = hheap_of_hmem m0 in let (|r, h'|) = H.extend #a #pcm x m0.ctr h in let m' : hmem_with_inv_except e emp = inc_ctr m0 in let h' : H.hheap (pts_to #a #pcm r x `star` linv e m') = weaken _ (linv e m0) (linv e m') h' in let m1 : hmem_with_inv_except e (pts_to #a #pcm r x) = hmem_of_hheap m' h' in assert (forall frame. H.frame_related_heaps h h' emp (pts_to #a #pcm r x) frame true); let aux (frame:slprop) : Lemma (requires interp ((emp `star` frame) `star` linv e m0) m0) (ensures interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) [SMTPat (emp `star` frame)] = star_associative emp frame (linv e m0); assert (H.interp (emp `star` (frame `star` linv e m0)) h); assert (H.interp (pts_to #a #pcm r x `star` (frame `star` linv e m0)) h'); star_associative (pts_to #a #pcm r x) frame (linv e m0); assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m0) h'); assert (H.stronger (linv e m0) (linv e m')); assert (H.equiv (linv e m') (linv e m1)); assert (H.stronger (linv e m0) (linv e m1)); let h' : H.hheap ((pts_to #a #pcm r x `star` frame) `star` linv e m1) = weaken _ (linv e m0) (linv e m1) h' in assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) h'); assert (forall (mp:H.hprop frame). mp h == mp h'); mprop_preservation_of_hprop_preservation frame m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) in assert (frame_related_mems emp (pts_to r x) e m0 m1); (| r, m1 |) in lift_tot_action (refined_pre_action_as_action f) let select_refine #a #p e r x f = lift_tot_action (lift_heap_action e (H.select_refine #a #p r x f)) let upd_gen #a #p e r x y f = lift_tot_action (lift_heap_action e (H.upd_gen_action r x y f)) //////////////////////////////////////////////////////////////////////////////// // witness / recall //////////////////////////////////////////////////////////////////////////////// let witnessed_ref #a #pcm (r:ref a pcm) (fact:property a) (m:full_mem) = H.witnessed_ref #a #pcm r fact (heap_of_mem m) let witnessed_ref_stability #a #pcm (r:ref a pcm) (fact:property a) : Lemma (requires FStar.Preorder.stable fact (Steel.Preorder.preorder_of_pcm pcm)) (ensures FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) = H.witnessed_ref_stability #a #pcm r fact let witnessed (#a:Type u#1) (#pcm:pcm a) (r:ref a pcm) (fact:property a) = W.witnessed _ mem_evolves (witnessed_ref r fact) let rearrange_pqr_prq (p q r:slprop) : Lemma (((p `star` q) `star` r) `equiv` ((p `star` r) `star` q)) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_associative p q r } p `star` (q `star` r); (equiv) { star_commutative q r; star_congruence p (q `star` r) p (r `star` q) } p `star` (r `star` q); (equiv) { star_associative p r q } (p `star` r) `star` q; } let preserves_frame_cong (e:inames) (p q:slprop) (r s:slprop) (m0 m1:mem) : Lemma (requires p `equiv` r /\ q `equiv` s /\ preserves_frame e p q m0 m1) (ensures preserves_frame e r s m0 m1) = let aux0 (p q r s:slprop) : Lemma (requires p `equiv` s) (ensures (((p `star` q) `star` r) `equiv` ((s `star` q) `star` r))) = star_congruence p q s q; star_congruence (p `star` q) r (s `star` q) r in let aux (frame:slprop) : Lemma (requires interp ((r `star` frame) `star` locks_invariant e m0) m0) (ensures interp ((s `star` frame) `star` locks_invariant e m1) m1 /\ interp ((p `star` frame) `star` locks_invariant e m0) m0) [SMTPat (r `star` frame)] = aux0 p frame (locks_invariant e m0) r; aux0 q frame (locks_invariant e m1) s; assert (((p `star` frame) `star` locks_invariant e m0) `equiv` ((r `star` frame) `star` locks_invariant e m0)); assert (interp ((p `star` frame) `star` locks_invariant e m0) m0); assert (interp ((q `star` frame) `star` locks_invariant e m1) m1); assert (((q `star` frame) `star` locks_invariant e m1) `equiv` ((s `star` frame) `star` locks_invariant e m1)); () in () let pure_true_equiv (p:slprop) : Lemma ((p `star` pure True) `equiv` p) = FStar.Classical.forall_intro (pure_star_interp p True); emp_unit p; assert ((p `star` pure True) `equiv` p) let preserves_frame_star_pure (e:inames) (p q:slprop) (r s:prop) (m:mem) : Lemma (requires r /\ s) (ensures preserves_frame e p q m m <==> preserves_frame e (p `star` pure r) (q `star` pure s) m m) = pure_equiv r True; star_congruence p (pure r) p (pure True); pure_equiv s True; star_congruence q (pure s) q (pure True); pure_true_equiv p; pure_true_equiv q; let fwd () : Lemma (requires preserves_frame e p q m m) (ensures preserves_frame e (p `star` pure r) (q `star` pure s) m m) [SMTPat ()] = preserves_frame_cong e p q (p `star` pure r) (q `star` pure s) m m in let bk () : Lemma (requires preserves_frame e (p `star` pure r) (q `star` pure s) m m) (ensures preserves_frame e p q m m) [SMTPat ()] = preserves_frame_cong e (p `star` pure r) (q `star` pure s) p q m m in () let witness (#a:Type) (#pcm:pcm a) (e:inames) (r:erased (ref a pcm)) (fact:stable_property pcm) (v:Ghost.erased a) (_:squash (forall z. compatible pcm v z ==> fact z)) (frame:slprop) : MstTot (witnessed r fact) e (pts_to r v) (fun _ -> pts_to r v) frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in let _ : unit = let hr : H.ref a pcm = r in let v' = H.sel_v hr v (heap_of_mem m0) in assert (interp (H.ptr hr) m0 /\ H.sel #a #pcm hr (heap_of_mem m0) == v'); assert (compatible pcm v v'); assert (fact v'); assert (witnessed_ref r fact m0); witnessed_ref_stability r fact; assert (FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) in let w = NMSTTotal.witness _ mem_evolves (witnessed_ref r fact) in w

{ "checked_file": "/", "dependencies": [ "Steel.Preorder.fst.checked", "Steel.Heap.fsti.checked", "prims.fst.checked", "FStar.Witnessed.Core.fsti.checked", "FStar.Set.fsti.checked", "FStar.Preorder.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.PCM.fst.checked", "FStar.NMSTTotal.fst.checked", "FStar.List.Tot.fst.checked", "FStar.IndefiniteDescription.fsti.checked", "FStar.Ghost.fsti.checked", "FStar.FunctionalExtensionality.fsti.checked", "FStar.Classical.Sugar.fsti.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Steel.Memory.fst" }

[ { "abbrev": true, "full_module": "Steel.Preorder", "short_module": "PP" }, { "abbrev": true, "full_module": "FStar.Witnessed.Core", "short_module": "W" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": true, "full_module": "Steel.Heap", "short_module": "H" }, { "abbrev": false, "full_module": "FStar.FunctionalExtensionality", "short_module": null }, { "abbrev": true, "full_module": "FStar.FunctionalExtensionality", "short_module": "F" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": false, "full_module": "FStar.PCM", "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

e: Steel.Memory.inames -> r: FStar.Ghost.erased (Steel.Memory.ref a pcm) -> v: FStar.Ghost.erased a -> w: Steel.Memory.witnessed (FStar.Ghost.reveal r) fact -> Steel.Memory.action_except (v1: FStar.Ghost.erased a {FStar.PCM.compatible pcm (FStar.Ghost.reveal v) (FStar.Ghost.reveal v1)}) e (Steel.Memory.pts_to (FStar.Ghost.reveal r) (FStar.Ghost.reveal v)) (fun v1 -> Steel.Memory.star (Steel.Memory.pts_to (FStar.Ghost.reveal r) (FStar.Ghost.reveal v)) (Steel.Memory.pure (fact (FStar.Ghost.reveal v1))))

Prims.Tot

[ "total" ]

[]

[ "FStar.PCM.pcm", "Steel.Memory.property", "Steel.Memory.inames", "FStar.Ghost.erased", "Steel.Memory.ref", "Steel.Memory.witnessed", "FStar.Ghost.reveal", "Steel.Memory.slprop", "FStar.Ghost.hide", "Prims.unit", "Steel.Memory.star_congruence", "Steel.Memory.star", "Steel.Memory.pts_to", "Steel.Memory.pure", "Steel.Memory.locks_invariant", "Steel.Memory.rearrange_pqr_prq", "Prims._assert", "Steel.Memory.interp", "Steel.Memory.pure_star_interp", "Steel.Memory.emp_unit", "Prims.eq2", "Steel.Heap.sel", "Steel.Memory.heap_of_mem", "FStar.PCM.compatible", "Prims.l_and", "FStar.PCM.__proj__Mkpcm__item__refine", "Steel.Heap.interp", "Steel.Heap.ptr", "Steel.Heap.sel_v", "Steel.Memory.witnessed_ref", "Steel.Heap.ref", "FStar.NMSTTotal.recall", "Steel.Memory.full_mem", "Steel.Memory.mem_evolves", "Steel.Memory.mem", "Steel.Memory.full_mem_pred", "FStar.NMSTTotal.get" ]

[]

false

let recall (#a: Type u#1) (#pcm: pcm a) (#fact: property a) (e: inames) (r: erased (ref a pcm)) (v: Ghost.erased a) (w: witnessed r fact) (frame: slprop) =

let m0 = NMSTTotal.get () in NMSTTotal.recall _ mem_evolves (witnessed_ref r fact) w; let hr:H.ref a pcm = r in assert (witnessed_ref r fact m0); let v1 = H.sel_v hr v (heap_of_mem m0) in assert (compatible pcm v v1); assert (H.sel hr (heap_of_mem m0) == v1); assert (fact v1); assert (interp (((pts_to r v) `star` frame) `star` (locks_invariant e m0)) m0); emp_unit (((pts_to r v) `star` frame) `star` (locks_invariant e m0)); pure_star_interp (((pts_to r v) `star` frame) `star` (locks_invariant e m0)) (fact v1) m0; assert (interp ((((pts_to r v) `star` frame) `star` (locks_invariant e m0)) `star` (pure (fact v1))) m0); rearrange_pqr_prq ((pts_to r v) `star` frame) (locks_invariant e m0) (pure (fact v1)); assert (interp ((((pts_to r v) `star` frame) `star` (pure (fact v1))) `star` (locks_invariant e m0)) m0); rearrange_pqr_prq (pts_to r v) frame (pure (fact v1)); star_congruence (((pts_to r v) `star` frame) `star` (pure (fact v1))) (locks_invariant e m0) (((pts_to r v) `star` (pure (fact v1))) `star` frame) (locks_invariant e m0); Ghost.hide v1

false

Platform.Bytes.fst

Platform.Bytes.abyte

val abyte : (FStar.UInt8.t -> Tot bytes)

let abyte b = Seq.create 1 b

{ "file_name": "ucontrib/Platform/fst/Platform.Bytes.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }

{ "end_col": 28, "end_line": 85, "start_col": 0, "start_line": 85 }

(* Copyright 2008-2018 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 Platform.Bytes assume val repr_bytes : nat -> GTot (n:nat{n>0}) (* Integer literals are currently extracted to int32, rather than bigint, so the definition below breaks extraction: Unexpected error; please file a bug report, ideally with a minimized version of the source program that triggered the error. int_of_string Also, defining repr_bytes n <= 8 for all n is dubious *) (* let repr_bytes n = if n < 256 then 1 else if n < 65536 then 2 else if n < 16777216 then 3 else if n < 4294967296 then 4 else if n < 1099511627776 then 5 else if n < 281474976710656 then 6 else if n < 72057594037927936 then 7 else 8 *) (* NS: The two assumes below were previously defined as axioms. They are evil! They pollute the global environment and slow down verification enormously. I've made them assumed lemmas; if you want to make use of these axioms, call the lemmas as needed in the context. *) assume val lemma_repr_bytes_values: n:nat -> Lemma ( ( n < 256 <==> repr_bytes n = 1 ) /\ ( (n >= 256 /\ n < 65536) <==> repr_bytes n = 2 ) /\ ( (n >= 65536 /\ n < 16777216) <==> repr_bytes n = 3 ) /\ ( (n >= 16777216 /\ n < 4294967296) <==> repr_bytes n = 4 ) /\ ( (n >= 4294967296 /\ n < 1099511627776) <==> repr_bytes n = 5 ) /\ ( (n >= 1099511627776 /\ n < 281474976710656) <==> repr_bytes n = 6 ) /\ ( (n >= 281474976710656 /\ n < 72057594037927936) <==> repr_bytes n = 7 ) /\ ( (n >= 72057594037927936 /\ n < 18446744073709551616) <==> repr_bytes n = 8 ) ) unfold let byte:Type0 = FStar.UInt8.t type cbytes = string (* abstract *) type bytes = Seq.seq byte (* AR: adding this *) assume HasEq_bytes: hasEq bytes val seq_of_bytes: b:bytes -> GTot (Seq.seq byte) let seq_of_bytes b = b val op_At_Bar: bytes -> bytes -> Tot bytes let op_At_Bar (b1:bytes) (b2:bytes) = Seq.append b1 b2 (*@ function val B : (bytes -> byte array) @*) (*@ assume val length : (b:bytes -> (l:nat){Length (b) = l}) @*) val length : bytes -> Tot nat let length b = Seq.length b (*@ type (l:nat) lbytes = (b:bytes){Length (b) = l} @*) type lbytes (l:nat) = b:bytes{length b = l} (*@ val empty_bytes : (b:bytes){B (b) = C_array_of_list C_op_Nil ()} @*) val empty_bytes : lbytes 0 let empty_bytes = Seq.empty #byte (*@ assume val abytes : (b:cbytes -> (a:bytes){B (a) = b}) @*) assume val abytes : (cbytes -> Tot bytes) (*@ assume val abyte : (b:byte -> (a:bytes){B (a) = C_array_of_list C_op_ColonColon (b, C_op_Nil ())}) @*)

{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.UInt8.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked" ], "interface_file": false, "source_file": "Platform.Bytes.fst" }

[ { "abbrev": false, "full_module": "Platform", "short_module": null }, { "abbrev": false, "full_module": "Platform", "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

b: FStar.UInt8.t -> Platform.Bytes.bytes

Prims.Tot

[ "total" ]

[]

[ "FStar.UInt8.t", "FStar.Seq.Base.create", "Platform.Bytes.byte", "Platform.Bytes.bytes" ]

[]

false

true

false

let abyte b =

Seq.create 1 b

false

Steel.Memory.fst

Steel.Memory.pts_to_evolve

val pts_to_evolve (#a:Type u#a) (#pcm:_) (r:ref a pcm) (x y : a) (m:mem) : Lemma (requires (interp (pts_to r x) m /\ compatible pcm y x)) (ensures (interp (pts_to r y) m))

let pts_to_evolve (#a:Type u#a) (#pcm:_) (r:ref a pcm) (x y : a) (m:mem) : Lemma (requires (interp (pts_to r x) m /\ compatible pcm y x)) (ensures (interp (pts_to r y) m)) = H.pts_to_evolve #a #pcm r x y (heap_of_mem m)

{ "file_name": "lib/steel/Steel.Memory.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 49, "end_line": 1568, "start_col": 0, "start_line": 1565 }

(* 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.Memory module F = FStar.FunctionalExtensionality open FStar.FunctionalExtensionality open FStar.PCM module H = Steel.Heap noeq type lock_state : Type u#(a + 1) = | Invariant : inv:H.slprop u#a -> lock_state let lock_store : Type u#(a+1) = list (lock_state u#a) noeq type mem : Type u#(a + 1) = { ctr: nat; heap: H.heap u#a; locks: lock_store u#a; } let heap_of_mem (x:mem) : H.heap = x.heap let mem_of_heap (h:H.heap) : mem = { ctr = 0; heap = h; locks = [] } let mem_set_heap (m:mem) (h:H.heap) : mem = { ctr = m.ctr; heap = h; locks = m.locks; } let core_mem (m:mem) : mem = mem_of_heap (heap_of_mem m) let core_mem_invol m = () let disjoint (m0 m1:mem u#h) : prop = m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks let disjoint_sym m0 m1 = () let join m0 m1 = { ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = m0.locks } let join_commutative m0 m1 = H.join_commutative m0.heap m1.heap let disjoint_join m0 m1 m2 = H.disjoint_join m0.heap m1.heap m2.heap let join_associative m0 m1 m2 = H.join_associative m0.heap m1.heap m2.heap let slprop = H.slprop let interp p m = H.interp p m.heap let equiv p1 p2 = forall m. interp p1 m <==> interp p2 m let slprop_extensionality p q = assert (forall m. interp p m <==> interp q m); let aux (h:H.heap) : Lemma (H.interp p h <==> H.interp q h) [SMTPat (H.interp p h)] = let m : mem = { ctr = 0; heap = h; locks = [] } in assert (interp p m <==> interp q m) in assert (forall h. H.interp p h <==> H.interp q h); Steel.Heap.slprop_extensionality p q let reveal_equiv p1 p2 = () let core_ref = H.core_ref let core_ref_null = H.core_ref_null let core_ref_is_null r = H.core_ref_is_null r let emp : slprop u#a = H.emp let pure = H.pure let pts_to = H.pts_to let h_and = H.h_and let h_or = H.h_or let star = H.star let wand = H.wand let h_exists = H.h_exists let h_forall = H.h_forall //////////////////////////////////////////////////////////////////////////////// //properties of equiv //////////////////////////////////////////////////////////////////////////////// let equiv_symmetric (p1 p2:slprop u#a) = H.equiv_symmetric p1 p2 #push-options "--warn_error -271" let equiv_heap_iff_equiv (p1 p2:slprop u#a) : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat (equiv p1 p2)] = let aux_lr () : Lemma (requires H.equiv p1 p2) (ensures equiv p1 p2) [SMTPat ()] = () in let aux_rl_helper1 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p1 h) (ensures H.interp p2 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl_helper2 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p2 h) (ensures H.interp p1 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl () : Lemma (requires equiv p1 p2) (ensures H.equiv p1 p2) [SMTPat ()] = () in () let equiv_heap_iff_equiv_forall () : Lemma (ensures (forall p1 p2. H.equiv p1 p2 <==> equiv p1 p2)) = let aux p1 p2 : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat ()] = equiv_heap_iff_equiv p1 p2 in () #pop-options let equiv_extensional_on_star (p1 p2 p3:slprop u#a) = equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3 let emp_unit p = H.emp_unit p let intro_emp m = H.intro_emp (heap_of_mem m) let pure_equiv p q = H.pure_equiv p q let pure_interp q m = H.pure_interp q (heap_of_mem m) let pure_star_interp p q m = H.pure_star_interp p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// //pts_to //////////////////////////////////////////////////////////////////////////////// let pts_to_compatible #a #pcm x v0 v1 m = H.pts_to_compatible #a #pcm x v0 v1 (heap_of_mem m) let pts_to_compatible_equiv #a #pcm x v0 v1 = H.pts_to_compatible_equiv #a #pcm x v0 v1 let pts_to_not_null #a #pcm x v m = H.pts_to_not_null #a #pcm x v (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // star //////////////////////////////////////////////////////////////////////////////// let intro_star p q mp mq = H.intro_star p q (heap_of_mem mp) (heap_of_mem mq) let elim_star p q m = let h = heap_of_mem m in H.elim_star p q h; assert (exists hl hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr); let hl = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hl -> exists hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let hr = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hr -> H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let ml = mem_set_heap m hl in let mr = mem_set_heap m hr in assert (disjoint ml mr); assert (m == join ml mr); assert (interp p ml); assert (interp q mr); () let interp_star (p q: slprop) (m: mem) : Lemma (interp (p `star` q) m <==> (exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m)) = let left = interp (p `star` q) m in let right = exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m in let f () : Lemma (requires left) (ensures right) = elim_star p q m in let g () : Lemma (requires right) (ensures left) = Classical.exists_elim left #_ #(fun mp -> exists (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mp -> Classical.exists_elim left #_ #(fun mq -> disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mq -> intro_star p q mp mq ) ) in Classical.move_requires f (); Classical.move_requires g () let star_commutative (p1 p2:slprop) = H.star_commutative p1 p2 let star_associative (p1 p2 p3:slprop) = H.star_associative p1 p2 p3 let star_congruence (p1 p2 p3 p4:slprop) = equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4 let affine_star (p q:slprop) (m:mem) = H.affine_star p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // Invariants on the lock store //////////////////////////////////////////////////////////////////////////////// let iname = nat module S = FStar.Set module L = FStar.List.Tot module W = FStar.Witnessed.Core let rec lock_store_invariant (e:inames) (l:lock_store u#a) : slprop u#a = let current_addr = L.length l - 1 in match l with | [] -> emp | Invariant p :: tl -> if current_addr `S.mem` e then lock_store_invariant e tl else p `star` lock_store_invariant e tl let lock_i (i:iname) (l:lock_store { i < L.length l }) = let ix = L.length l - i - 1 in L.index l ix let iname_for_p (i:iname) (p:slprop) : W.s_predicate lock_store = fun l -> i < L.length l /\ (lock_i i l).inv == p let lock_store_evolves : FStar.Preorder.preorder lock_store = fun (l1 l2 : lock_store) -> L.length l2 >= L.length l1 /\ (forall (i:nat{i < L.length l1}). (lock_i i l1).inv == (lock_i i l2).inv) let inames_in (e:inames) (l:lock_store) : prop = forall i. Set.mem i e ==> i < L.length l let inames_ok e m = inames_in e m.locks let inames_ok_empty m = () let extend_lock_store (e:inames) (l:lock_store{e `inames_in` l}) (p:slprop) : i:iname & l':lock_store { lock_store_invariant e l' == p `star` lock_store_invariant e l /\ iname_for_p i p l' } = (| L.length l, Invariant p :: l |) let set_add (i:iname) (s:inames) = Set.union (Set.singleton i) s let rec move_invariant (e:inames) (l:lock_store) (p:slprop) (i:iname{iname_for_p i p l /\ ~(i `Set.mem` e)}) : Lemma (H.equiv (lock_store_invariant e l) (p `star` lock_store_invariant (set_add i e) l)) = let rec aux (i:iname) (m:lock_store) : Lemma (requires i >= L.length m) (ensures (lock_store_invariant e m `H.equiv` lock_store_invariant (set_add i e) m)) = match m with | [] -> () | Invariant p::tl -> aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl) in let current_addr = L.length l - 1 in match l with | [] -> () | Invariant q::tl -> if i = current_addr then begin assert (lock_store_invariant e l == p `star` lock_store_invariant e tl); aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl); () end else begin move_invariant e tl p i; assert (lock_store_invariant e tl `equiv` (p `star` lock_store_invariant (set_add i e) tl)); H.star_congruence q (lock_store_invariant e tl) q (p `star` lock_store_invariant (set_add i e) tl); if Set.mem current_addr e then () else begin let r = lock_store_invariant (set_add i e) tl in assert (lock_store_invariant e l `equiv` (q `star` (p `star` r))); H.star_associative q p r; H.star_commutative q p; H.star_congruence (q `star` p) r (p `star` q) r; H.star_associative p q r end end let heap_ctr_valid (ctr:nat) (h:H.heap u#a) : prop = h `H.free_above_addr` ctr let ctr_validity (ctr:nat) (h:H.heap) : slprop = H.pure (heap_ctr_valid ctr h) let locks_invariant (e:inames) (m:mem u#a) : slprop u#a = lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m) let full_mem_pred (m:mem) = H.full_heap_pred (heap_of_mem m) (***** Following lemmas are needed in Steel.Effect *****) let core_mem_interp (hp:slprop u#a) (m:mem u#a) = () let interp_depends_only_on (hp:slprop u#a) = H.interp_depends_only_on hp let a_mem_prop_as_a_heap_prop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (H.a_heap_prop u#a) = let g (h: H.heap u#a) : Tot prop = interp sl (mem_of_heap h) /\ f (mem_of_heap h) in let phi0 (h0 h1: H.heap u#a) : Lemma (requires (g h0 /\ H.disjoint h0 h1)) (ensures (g h0 /\ H.disjoint h0 h1 /\ g (H.join h0 h1))) = assert (mem_of_heap (H.join h0 h1) == mem_of_heap h0 `join` mem_of_heap h1); interp_depends_only_on sl in let phi1 (h0 h1: H.heap u#a) : Lemma (ensures ((g h0 /\ H.disjoint h0 h1) ==> g (H.join h0 h1))) = Classical.move_requires (phi0 h0) h1 in Classical.forall_intro_2 phi1; g let refine_slprop sl f = H.as_slprop (a_mem_prop_as_a_heap_prop sl f) let interp_refine_slprop sl f m = assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_mem m)) let dep_hprop (s: slprop) (f: (hmem s -> Tot slprop)) (h: H.heap) : Tot prop = exists (h1: H.heap) . exists (h2: H.heap) . interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 let dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq' : squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h')) = let p2 (h h1 h2: H.heap) : Tot prop = interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 in let p1 (h h1: H.heap) : Tot prop = (exists h2 . p2 h h1 h2) in let h1 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p1 h) in let h2 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p2 h h1) in H.disjoint_join h' h1 h2; assert (H.disjoint h2 h'); let h2' = H.join h2 h' in H.join_commutative h2 h' ; assert (h2' == H.join h' h2); assert (H.disjoint h1 h2'); assert (mem_of_heap h2' == mem_of_heap h2 `join` mem_of_heap h'); interp_depends_only_on (f (mem_of_heap h1)); assert (interp (f (mem_of_heap h1)) (mem_of_heap h2')); H.join_commutative h1 h2; H.join_associative h' h2 h1; H.join_commutative h' h; H.join_commutative h2' h1; assert (H.join h h' == h1 `H.join` h2') let impl_intro_gen (#p: Type0) (#q: Type0) ($prf: (squash p -> Lemma (q ))) : Lemma (p ==> q) = Classical.impl_intro_gen #p #(fun _ -> q) prf let dep_hprop_is_affine1 (s: slprop) (f: (hmem s -> Tot slprop)) (h0 h1: H.heap) : Lemma ((dep_hprop s f h0 /\ H.disjoint h0 h1) ==> (H.disjoint h0 h1 /\ dep_hprop s f (H.join h0 h1))) = impl_intro_gen (dep_hprop_is_affine0 s f h0 h1) let dep_hprop_is_affine (s: slprop) (f: (hmem s -> Tot slprop)) : Lemma (H.heap_prop_is_affine (dep_hprop s f)) = Classical.forall_intro_2 (dep_hprop_is_affine1 s f) let sdep (s: slprop) (f: (hmem s -> Tot slprop)) : Tot slprop = dep_hprop_is_affine s f; H.as_slprop (dep_hprop s f) let interp_sdep (s: slprop) (f: (hmem s -> Tot slprop)) (m: mem) : Lemma (requires (dep_slprop_is_affine s f)) (ensures ( interp (sdep s f) m <==> (exists m1 m2 . interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) )) = dep_hprop_is_affine s f; assert (forall m1 m2 . (interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) ==> ( interp s (mem_of_heap m1.heap) /\ interp (f (mem_of_heap m1.heap)) (mem_of_heap m2.heap) /\ H.disjoint m1.heap m2.heap /\ H.join m1.heap m2.heap == m.heap )); interp_depends_only_on s; Classical.forall_intro (fun m -> interp_depends_only_on (f m)); assert (forall h1 h2 . (interp s (mem_of_heap h1) /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ H.disjoint h1 h2 /\ H.join h1 h2 == m.heap) ==> ( core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ interp s (core_mem (mem_of_heap h1)) /\ interp s (mem_set_heap m h1) /\ core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ f (mem_set_heap m h1) `equiv` f (mem_of_heap h1) /\ interp (f (mem_set_heap m h1)) (mem_of_heap h2) /\ interp (f (mem_set_heap m h1)) (mem_set_heap m h2) /\ disjoint (mem_set_heap m h1) (mem_set_heap m h2) /\ join (mem_set_heap m h1) (mem_set_heap m h2) == m )); () let h_exists_cong (#a:Type) (p q : a -> slprop) : Lemma (requires (forall x. p x `equiv` q x)) (ensures (h_exists p `equiv` h_exists q)) = equiv_heap_iff_equiv_forall (); H.h_exists_cong p q let intro_h_exists #a x p m = H.intro_h_exists x p (heap_of_mem m) let elim_h_exists (#a:_) (p:a -> slprop) (m:mem) = H.elim_h_exists p (heap_of_mem m) let intro_h_forall (#a:_) (p:a -> slprop) (m:mem) = H.intro_h_forall p (heap_of_mem m) let elim_h_forall (#a:_) (p:a -> slprop) (m:mem) (x:a) = H.elim_h_forall p (heap_of_mem m) x let intro_h_and (p q: slprop) (m:mem) = H.intro_h_and p q (heap_of_mem m) let elim_h_and (p q: slprop) (m:mem) = H.elim_h_and p q (heap_of_mem m) let intro_h_or_left (p q: slprop) (m:mem) = H.intro_h_or_left p q (heap_of_mem m) let intro_h_or_right (p q: slprop) (m:mem) = H.intro_h_or_right p q (heap_of_mem m) let elim_h_or (p q: slprop) (m:mem) = H.elim_h_or p q (heap_of_mem m) let intro_wand (p1 p2: slprop u#a) (m:mem) = introduce (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)) ==> interp (wand p1 p2) m with _. ( assert (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)); H.intro_wand p1 p2 (heap_of_mem m); let h = heap_of_mem m in assert ((forall h1. h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) ==> H.interp (wand p1 p2) h); introduce forall h1. (h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) with ( introduce (h `H.disjoint` h1 /\ H.interp p1 h1) ==> H.interp p2 (H.join h h1) with _. ( assert (h `H.disjoint` h1); let m1 = { ctr = m.ctr; heap = h1; locks = m.locks } in assert (m `disjoint` m1) ) ) ) (** Eliminating a wand by proving a heap that satisfies the LHS **) let elim_wand (p1 p2: slprop u#a) (m:mem) (m1:mem) = H.elim_wand p1 p2 (heap_of_mem m) (heap_of_mem m1) //////////////////////////////////////////////////////////////////////////////// // Preorders and effects //////////////////////////////////////////////////////////////////////////////// module PP = Steel.Preorder let mem_evolves = fun (m0 m1:full_mem) -> H.heap_evolves (heap_of_mem m0) (heap_of_mem m1) /\ m0.ctr <= m1.ctr /\ lock_store_evolves m0.locks m1.locks (** See [Steel.Heap.is_frame_preserving]. We add in [lock_invariants] now *) let preserves_frame (e:inames) (pre post:slprop) (m0 m1:mem) = forall (frame:slprop). interp ((pre `star` frame) `star` locks_invariant e m0) m0 ==> (interp ((post `star` frame) `star` locks_invariant e m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) (** This is a version of MstTot with frame quantified, as part of preserves_frame *) effect MstTotNF (a:Type u#a) (except:inames) (expects:slprop u#1) (provides: a -> slprop u#1) = NMSTTotal.NMSTATETOT a (full_mem u#1) mem_evolves (requires fun m0 -> inames_ok except m0 /\ interp (expects `star` locks_invariant except m0) m0) (ensures fun m0 x m1 -> inames_ok except m1 /\ interp (provides x `star` locks_invariant except m1) m1 /\ preserves_frame except expects (provides x) m0 m1) //////////////////////////////////////////////////////////////////////////////// // Lifting heap actions //////////////////////////////////////////////////////////////////////////////// (** Heap actions come in two equivalent flavors: - one that take an explicit frame as argument (action_with_frame) - and one that quantify over all the frame We therefore define two lift routes: - a direct route for those with explicit frame - via MstTotNF for the rest *) let tot_pre_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = hmem_with_inv_except e fp -> (x:a & hmem_with_inv_except e (fp' x)) let tot_pre_action_nf = tot_pre_action_nf_except S.empty let ac_reasoning_for_m_frame_preserving (p q r:slprop u#a) (m:mem u#a) : Lemma (requires interp ((p `star` q) `star` r) m) (ensures interp (p `star` r) m) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_commutative p q; equiv_extensional_on_star (p `star` q) (q `star` p) r } (q `star` p) `star` r; (equiv) { star_associative q p r } q `star` (p `star` r); }; assert (interp (q `star` (p `star` r)) m); affine_star q (p `star` r) m let is_frame_preserving (#e:inames) (#a:Type u#b) (#fp:slprop u#a) (#fp':a -> slprop u#a) (f:tot_pre_action_nf_except e fp a fp') = forall (frame:slprop u#a) (m0:hmem_with_inv_except e (fp `star` frame)). (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = f:tot_pre_action_nf_except e fp a fp'{ is_frame_preserving f } let tot_action_nf = tot_action_nf_except S.empty let linv e (m:mem) = locks_invariant e m let hheap_of_hmem #fp #e (m:hmem_with_inv_except e fp) : h:H.hheap (fp `star` linv e m) { h `H.free_above_addr` m.ctr} = let h = heap_of_mem m in H.pure_interp (heap_ctr_valid m.ctr (heap_of_mem m)) h; h let hmem_of_hheap #e (#fp0 #fp1:slprop) (m:hmem_with_inv_except e fp0) (h:H.full_hheap (fp1 `star` linv e m) { h `Heap.free_above_addr` m.ctr }) : m1:hmem_with_inv_except e fp1{linv e m `equiv` linv e m1} = let m1 : mem = { m with heap = h } in assert (interp (fp1 `star` linv e m) m1); star_commutative fp1 (linv e m); assert (interp (linv e m `star` fp1) m1); assert (linv e m1 == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); assert (linv e m == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m)); H.pure_interp (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_of_mem m); assert (heap_ctr_valid m1.ctr (heap_of_mem m) <==> heap_ctr_valid m1.ctr (heap_of_mem m1)); H.pure_equiv (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_ctr_valid m1.ctr (heap_of_mem m1)); H.star_congruence (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m)); assert (linv e m `equiv` linv e m1); let _ = equiv_extensional_on_star (linv e m) (linv e m1) fp1 in assert ((linv e m `star` fp1) `equiv` (linv e m1 `star` fp1)); assert (interp (linv e m1 `star` fp1) m1); star_commutative (linv e m1) fp1; assert (interp (fp1 `star` linv e m1) m1); m1 let with_inv_except (m:mem) e (fp:slprop) = interp (fp `star` locks_invariant e m) m #push-options "--warn_error -271" let as_hprop (frame:slprop) (mp:mprop frame) : hp:H.hprop frame{forall m. mp (core_mem m) == hp (heap_of_mem m)} = let f = fun h -> mp (mem_of_heap h) in assert (forall m. mp (core_mem m) == f (heap_of_mem m)); let aux (m0:H.hheap frame) (m1:H.heap{H.disjoint m0 m1}) : Lemma (ensures (mem_of_heap (H.join m0 m1) == join (mem_of_heap m0) (mem_of_heap m1))) [SMTPat ()] = () in f let mprop_preservation_of_hprop_preservation (p:slprop) (m0 m1:mem) : Lemma (requires (forall (hp:H.hprop p). hp (heap_of_mem m0) == hp (heap_of_mem m1))) (ensures (forall (mp:mprop p). mp (core_mem m0) == mp (core_mem m1))) = let aux (mp:mprop p) : Lemma (mp (core_mem m0) == mp (core_mem m1)) [SMTPat()] = assert (as_hprop p mp (heap_of_mem m0) == as_hprop p mp (heap_of_mem m1)) in () let lift_heap_action (#fp:slprop) (#a:Type) (#fp':a -> slprop) (e:inames) ($f:H.action fp a fp') : tot_action_nf_except e fp a fp' = let g : tot_pre_action_nf_except e fp a fp' = fun m -> let h0 = hheap_of_hmem m in let (| x, h' |) = f h0 in (| x, hmem_of_hheap m h' |) in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in let h0 = hheap_of_hmem m0 in let (| x', h1 |) = f h0 in H.action_framing f (linv e m0) h0; assert (x == x'); star_associative fp frame (linv e m0); H.action_framing f (frame `star` linv e m0) h0; assert (H.interp ((fp' x) `star` (frame `star` linv e m0)) h1); star_associative (fp' x) frame (linv e m0); assert (H.interp ((fp' x `star` frame) `star` linv e m0) h1); let h1' : H.hheap ((fp' x `star` frame) `star` linv e m0) = h1 in assert (m1 == hmem_of_hheap m0 h1'); assert (with_inv_except m1 e (fp' x `star` frame)); assert (forall (hp:H.hprop frame). hp h0 == hp h1); mprop_preservation_of_hprop_preservation frame m0 m1; () in assert (is_frame_preserving g); g let frame_preserving_respects_preorder #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (m0:hmem_with_inv_except e fp) : Lemma (let (| x, m1 |) = f m0 in mem_evolves m0 m1) = let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1) = () in H.emp_unit fp; assert (interp (fp `star` linv e m0) m0); H.star_congruence (fp `star` emp) (linv e m0) fp (linv e m0); assert (interp ((fp `star` emp) `star` linv e m0) m0); aux emp m0 let lift_tot_action_nf #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') : MstTotNF a e fp fp' = let m0 = NMSTTotal.get () in let m0' : hmem_with_inv_except e fp = m0 in let r = f m0' in let (| x, m1 |) = r in let m1' : hmem_with_inv_except e (fp' x) = m1 in assert (is_frame_preserving f); assert (m1 == dsnd (f m0)); frame_preserving_respects_preorder f m0; NMSTTotal.put #_ #(mem_evolves) m1; x let lift_tot_action #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get #(full_mem) #_ () in ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); lift_tot_action_nf f (** Now defining the lift for heap actions with explicit frame *) let tot_action_with_frame_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = frame:slprop u#a -> m0:hmem_with_inv_except e (fp `star` frame) -> Pure (x:a & hmem_with_inv_except e (fp' x `star` frame)) (requires True) (ensures fun (| x, m1 |) -> mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_with_frame = tot_action_with_frame_except S.empty let lift_heap_action_with_frame (#fp:slprop u#a) (#a:Type u#b) (#fp':a -> slprop u#a) (e:inames) ($f:H.action_with_frame fp a fp') : tot_action_with_frame_except e fp a fp' = fun frame m0 -> let h0 = hheap_of_hmem m0 in calc (equiv) { fp `star` frame `star` locks_invariant e m0; (equiv) { star_associative fp frame (locks_invariant e m0) } fp `star` (frame `star` locks_invariant e m0); }; assert (H.interp (fp `star` frame `star` locks_invariant e m0) h0); assert (H.interp (fp `star` (frame `star` locks_invariant e m0)) h0); //key: apply the heap action with frame * locks_invariant e m0 let (| x, h1 |) = f (frame `star` locks_invariant e m0) h0 in calc (equiv) { fp' x `star` (frame `star` locks_invariant e m0); (equiv) { star_associative (fp' x) frame (locks_invariant e m0) } fp' x `star` frame `star` locks_invariant e m0; }; assert (H.interp (fp' x `star` (frame `star` locks_invariant e m0)) h1); assert (H.interp (fp' x `star` frame `star` locks_invariant e m0) h1); let m1 = hmem_of_hheap m0 h1 in assert (mem_evolves m0 m1); mprop_preservation_of_hprop_preservation (frame `star` locks_invariant e m0) m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)); (| x, m1 |) let lift_tot_action_with_frame #a #e #fp #fp' ($f:tot_action_with_frame_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in assert (inames_ok e m0); ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); let m0' : hmem_with_inv_except e fp = m0 in let r = f frame m0' in let (| x, m1 |) = r in ac_reasoning_for_m_frame_preserving (fp' x) frame (locks_invariant e m1) m1; assert (interp (fp' x `star` frame `star` locks_invariant e m1) m1); assert (interp (fp' x `star` locks_invariant e m1) m1); let m1' : hmem_with_inv_except e (fp' x) = m1 in NMSTTotal.put #_ #(mem_evolves) m1; x let sel_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.sel_action #a #pcm r v0)) let upd_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.upd_action #a #pcm r v0 v1)) let free_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.free_action #a #pcm r v0)) let split_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.split_action #a #pcm r v0 v1)) let gather_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.gather_action #a #pcm r v0 v1)) let weaken (p q r:slprop) (h:H.hheap (p `star` q) { H.stronger q r }) : H.hheap (p `star` r) = H.weaken p q r h; h let weaken_pure (q r: prop) : Lemma (requires (q ==> r)) (ensures H.stronger (H.pure q) (H.pure r)) = let aux (h:H.heap) : Lemma (ensures (H.interp (H.pure q) h ==> H.interp (H.pure r) h)) [SMTPat ()] = H.pure_interp q h; H.pure_interp r h in () let inc_ctr (#p:slprop) #e (m:hmem_with_inv_except e p) : m':hmem_with_inv_except e p{m'.ctr = m.ctr + 1 /\ H.stronger (linv e m) (linv e m')} = let m' : mem = { m with ctr = m.ctr + 1} in assert (interp (p `star` linv e m) m'); assert (linv e m == lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m)); assert (linv e m' == lock_store_invariant e m.locks `star` ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken_free_above (heap_of_mem m) m.ctr (m.ctr + 1); weaken_pure (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_ctr_valid (m.ctr + 1) (heap_of_mem m)); assert (H.stronger (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m))); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)); H.stronger_star (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken (p `star` lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)) (heap_of_mem m'); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity (m.ctr + 1) (heap_of_mem m)); let m' : hmem_with_inv_except e p = m' in m' let frame_related_mems (fp0 fp1:slprop u#a) e (m0:hmem_with_inv_except e fp0) (m1:hmem_with_inv_except e fp1) = forall (frame:slprop u#a). interp ((fp0 `star` frame) `star` linv e m0) m0 ==> interp ((fp1 `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) let refined_pre_action e (fp0:slprop) (a:Type) (fp1:a -> slprop) = m0:hmem_with_inv_except e fp0 -> Pure (x:a & hmem_with_inv_except e (fp1 x)) (requires True) (ensures fun (| x, m1 |) -> frame_related_mems fp0 (fp1 x) e m0 m1) let refined_pre_action_as_action (#fp0:slprop) (#a:Type) (#fp1:a -> slprop) #e ($f:refined_pre_action e fp0 a fp1) : tot_action_nf_except e fp0 a fp1 = let g : tot_pre_action_nf_except e fp0 a fp1 = fun m -> f m in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp0 `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp1 x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x', m1' |) = g m0 in let (| x, m1 |) = f m0 in assert (x == x' /\ m1 == m1') in g let alloc_action #a #pcm e x = let f : refined_pre_action e emp (ref a pcm) (fun r -> pts_to r x) = fun m0 -> (* NS: 9/29/22 I needed to annotate h : Heap.full_heap, for use with the Core checker which generates a guard for checking the implicit pattern "dot" term in the dependent pair pattern on the next line. That guard expects `h` to be a full_heap, which is it, because it is a projection of m0. However, this is not reflected in `h`'s type. So, the Core checker, which produces a guard for the pat_dot_term in isolation, cannot recheck the term. If we were to fold in the checking of pat_dot_terms and their guards with the rest of the VC, this would work. *) let h : Heap.full_heap = hheap_of_hmem m0 in let (|r, h'|) = H.extend #a #pcm x m0.ctr h in let m' : hmem_with_inv_except e emp = inc_ctr m0 in let h' : H.hheap (pts_to #a #pcm r x `star` linv e m') = weaken _ (linv e m0) (linv e m') h' in let m1 : hmem_with_inv_except e (pts_to #a #pcm r x) = hmem_of_hheap m' h' in assert (forall frame. H.frame_related_heaps h h' emp (pts_to #a #pcm r x) frame true); let aux (frame:slprop) : Lemma (requires interp ((emp `star` frame) `star` linv e m0) m0) (ensures interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) [SMTPat (emp `star` frame)] = star_associative emp frame (linv e m0); assert (H.interp (emp `star` (frame `star` linv e m0)) h); assert (H.interp (pts_to #a #pcm r x `star` (frame `star` linv e m0)) h'); star_associative (pts_to #a #pcm r x) frame (linv e m0); assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m0) h'); assert (H.stronger (linv e m0) (linv e m')); assert (H.equiv (linv e m') (linv e m1)); assert (H.stronger (linv e m0) (linv e m1)); let h' : H.hheap ((pts_to #a #pcm r x `star` frame) `star` linv e m1) = weaken _ (linv e m0) (linv e m1) h' in assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) h'); assert (forall (mp:H.hprop frame). mp h == mp h'); mprop_preservation_of_hprop_preservation frame m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) in assert (frame_related_mems emp (pts_to r x) e m0 m1); (| r, m1 |) in lift_tot_action (refined_pre_action_as_action f) let select_refine #a #p e r x f = lift_tot_action (lift_heap_action e (H.select_refine #a #p r x f)) let upd_gen #a #p e r x y f = lift_tot_action (lift_heap_action e (H.upd_gen_action r x y f)) //////////////////////////////////////////////////////////////////////////////// // witness / recall //////////////////////////////////////////////////////////////////////////////// let witnessed_ref #a #pcm (r:ref a pcm) (fact:property a) (m:full_mem) = H.witnessed_ref #a #pcm r fact (heap_of_mem m) let witnessed_ref_stability #a #pcm (r:ref a pcm) (fact:property a) : Lemma (requires FStar.Preorder.stable fact (Steel.Preorder.preorder_of_pcm pcm)) (ensures FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) = H.witnessed_ref_stability #a #pcm r fact let witnessed (#a:Type u#1) (#pcm:pcm a) (r:ref a pcm) (fact:property a) = W.witnessed _ mem_evolves (witnessed_ref r fact) let rearrange_pqr_prq (p q r:slprop) : Lemma (((p `star` q) `star` r) `equiv` ((p `star` r) `star` q)) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_associative p q r } p `star` (q `star` r); (equiv) { star_commutative q r; star_congruence p (q `star` r) p (r `star` q) } p `star` (r `star` q); (equiv) { star_associative p r q } (p `star` r) `star` q; } let preserves_frame_cong (e:inames) (p q:slprop) (r s:slprop) (m0 m1:mem) : Lemma (requires p `equiv` r /\ q `equiv` s /\ preserves_frame e p q m0 m1) (ensures preserves_frame e r s m0 m1) = let aux0 (p q r s:slprop) : Lemma (requires p `equiv` s) (ensures (((p `star` q) `star` r) `equiv` ((s `star` q) `star` r))) = star_congruence p q s q; star_congruence (p `star` q) r (s `star` q) r in let aux (frame:slprop) : Lemma (requires interp ((r `star` frame) `star` locks_invariant e m0) m0) (ensures interp ((s `star` frame) `star` locks_invariant e m1) m1 /\ interp ((p `star` frame) `star` locks_invariant e m0) m0) [SMTPat (r `star` frame)] = aux0 p frame (locks_invariant e m0) r; aux0 q frame (locks_invariant e m1) s; assert (((p `star` frame) `star` locks_invariant e m0) `equiv` ((r `star` frame) `star` locks_invariant e m0)); assert (interp ((p `star` frame) `star` locks_invariant e m0) m0); assert (interp ((q `star` frame) `star` locks_invariant e m1) m1); assert (((q `star` frame) `star` locks_invariant e m1) `equiv` ((s `star` frame) `star` locks_invariant e m1)); () in () let pure_true_equiv (p:slprop) : Lemma ((p `star` pure True) `equiv` p) = FStar.Classical.forall_intro (pure_star_interp p True); emp_unit p; assert ((p `star` pure True) `equiv` p) let preserves_frame_star_pure (e:inames) (p q:slprop) (r s:prop) (m:mem) : Lemma (requires r /\ s) (ensures preserves_frame e p q m m <==> preserves_frame e (p `star` pure r) (q `star` pure s) m m) = pure_equiv r True; star_congruence p (pure r) p (pure True); pure_equiv s True; star_congruence q (pure s) q (pure True); pure_true_equiv p; pure_true_equiv q; let fwd () : Lemma (requires preserves_frame e p q m m) (ensures preserves_frame e (p `star` pure r) (q `star` pure s) m m) [SMTPat ()] = preserves_frame_cong e p q (p `star` pure r) (q `star` pure s) m m in let bk () : Lemma (requires preserves_frame e (p `star` pure r) (q `star` pure s) m m) (ensures preserves_frame e p q m m) [SMTPat ()] = preserves_frame_cong e (p `star` pure r) (q `star` pure s) p q m m in () let witness (#a:Type) (#pcm:pcm a) (e:inames) (r:erased (ref a pcm)) (fact:stable_property pcm) (v:Ghost.erased a) (_:squash (forall z. compatible pcm v z ==> fact z)) (frame:slprop) : MstTot (witnessed r fact) e (pts_to r v) (fun _ -> pts_to r v) frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in let _ : unit = let hr : H.ref a pcm = r in let v' = H.sel_v hr v (heap_of_mem m0) in assert (interp (H.ptr hr) m0 /\ H.sel #a #pcm hr (heap_of_mem m0) == v'); assert (compatible pcm v v'); assert (fact v'); assert (witnessed_ref r fact m0); witnessed_ref_stability r fact; assert (FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) in let w = NMSTTotal.witness _ mem_evolves (witnessed_ref r fact) in w let recall (#a:Type u#1) (#pcm:pcm a) (#fact:property a) (e:inames) (r:erased (ref a pcm)) (v:Ghost.erased a) (w:witnessed r fact) (frame:slprop) = let m0 = NMSTTotal.get () in NMSTTotal.recall _ mem_evolves (witnessed_ref r fact) w; let hr : H.ref a pcm = r in assert (witnessed_ref r fact m0); let v1 = H.sel_v hr v (heap_of_mem m0) in assert (compatible pcm v v1); assert (H.sel hr (heap_of_mem m0) == v1); assert (fact v1); assert (interp ((pts_to r v `star` frame) `star` locks_invariant e m0) m0); emp_unit ((pts_to r v `star` frame) `star` locks_invariant e m0); pure_star_interp ((pts_to r v `star` frame) `star` locks_invariant e m0) (fact v1) m0; assert (interp (((pts_to r v `star` frame) `star` locks_invariant e m0) `star` pure (fact v1)) m0); rearrange_pqr_prq (pts_to r v `star` frame) (locks_invariant e m0) (pure (fact v1)); assert (interp (((pts_to r v `star` frame) `star` pure (fact v1)) `star` locks_invariant e m0) m0); rearrange_pqr_prq (pts_to r v) frame (pure (fact v1)); star_congruence ((pts_to r v `star` frame) `star` pure (fact v1)) (locks_invariant e m0) ((pts_to r v `star` pure (fact v1)) `star` frame) (locks_invariant e m0); Ghost.hide v1 let iname_for_p_mem (i:iname) (p:slprop) : W.s_predicate mem = fun m -> iname_for_p i p m.locks let iname_for_p_stable (i:iname) (p:slprop) : Lemma (W.stable full_mem mem_evolves (iname_for_p_mem i p)) = () let ( >--> ) (i:iname) (p:slprop) : Type0 = W.witnessed full_mem mem_evolves (iname_for_p_mem i p) let hmem_with_inv_equiv e (m:mem) (p:slprop) : Lemma (interp (p `star` linv e m) m <==> interp (p `star` lock_store_invariant e m.locks) m /\ heap_ctr_valid m.ctr (heap_of_mem m)) = calc (<==>) { interp (p `star` linv e m) m; (<==>) { H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) } interp ((p `star` lock_store_invariant e m.locks) `star` ctr_validity m.ctr (heap_of_mem m)) m; (<==>) { H.pure_star_interp (p `star` lock_store_invariant e m.locks) (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_of_mem m) } interp ((p `star` lock_store_invariant e m.locks) `star` emp) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); (<==>) { H.emp_unit (p `star` lock_store_invariant e m.locks) } interp (p `star` lock_store_invariant e m.locks) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); } let new_invariant_tot_action (e:inames) (p:slprop) (m0:hmem_with_inv_except e p{ e `inames_in` m0.locks }) : Pure (iname & hmem_with_inv_except e emp) (requires True) (ensures fun (i, m1) -> iname_for_p_mem i p m1 /\ frame_related_mems p emp e m0 m1 /\ mem_evolves m0 m1) = let (| i, l1 |) = extend_lock_store e m0.locks p in let m1 = { m0 with locks = l1 } in assert (lock_store_invariant e m1.locks == p `star` lock_store_invariant e m0.locks); calc (equiv) { linv e m1; (equiv) {} (lock_store_invariant e m1.locks `star` ctr_validity m1.ctr (heap_of_mem m1)); (equiv) {} ((p `star` lock_store_invariant e m0.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); (equiv) { H.star_associative p (lock_store_invariant e m0.locks) (ctr_validity m1.ctr (heap_of_mem m1)) } (p `star` (lock_store_invariant e m0.locks `star` ctr_validity m1.ctr (heap_of_mem m1))); (equiv) { } (p `star` linv e m0); }; assert (iname_for_p_mem i p m1); assert (lock_store_evolves m0.locks l1); assert (mem_evolves m0 m1); hmem_with_inv_equiv e m0 p; assert (interp (p `star` lock_store_invariant e m0.locks) m1); assert (interp (lock_store_invariant e m1.locks) m1); H.emp_unit (lock_store_invariant e m1.locks); H.star_commutative (lock_store_invariant e m1.locks) emp; assert (interp (emp `star` lock_store_invariant e m1.locks) m1); hmem_with_inv_equiv e m1 emp; let m1 : hmem_with_inv_except e emp = m1 in let aux (frame:slprop) : Lemma (requires interp ((p `star` frame) `star` linv e m0) m0) (ensures interp ((emp `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) <==> mp (core_mem m1))) [SMTPat (p `star` frame)] = assert (interp ((p `star` frame) `star` linv e m0) m1); calc (equiv) { ((p `star` frame) `star` linv e m0); (equiv) { H.star_commutative p frame; H.star_congruence (p `star` frame) (linv e m0) (frame `star` p) (linv e m0); H.star_associative frame p (linv e m0) } (frame `star` (p `star` linv e m0)); (equiv) { H.star_congruence frame (p `star` linv e m0) frame (linv e m1) } (frame `star` linv e m1); (equiv) { H.emp_unit (frame `star` linv e m1); H.star_commutative (frame `star` linv e m1) emp; H.star_associative emp frame (linv e m1) } ((emp `star` frame) `star` linv e m1); }; assert (interp ((emp `star` frame) `star` linv e m1) m1) in assert (frame_related_mems p emp e m0 m1); ( i, m1 ) let name_is_ok (i:iname) (m0:full_mem u#1) : prop = i < List.Tot.length m0.locks let witnessed_name_is_ok (i:iname) = W.witnessed full_mem mem_evolves (name_is_ok i) let pre_inv = i:erased iname & witnessed_name_is_ok i let inv (p:slprop u#1) = i:erased iname & witnessed_name_is_ok i & (i >--> p) let pre_inv_of_inv #p (i:inv p) = let (|i, w, _|) = i in (|i,w|) let name_of_pre_inv (i:pre_inv) = dfst i let rec recall_all (ctx:list pre_inv) : NMSTTotal.NMSTATETOT unit (full_mem u#1) mem_evolves (requires fun _ -> True) (ensures fun m0 _ m1 -> m0==m1 /\ (forall i. i `List.Tot.memP` ctx ==> name_is_ok (name_of_pre_inv i) m0)) = match ctx with | [] -> () | hd::tl -> let (| q, i |) = hd in let i : W.witnessed full_mem mem_evolves (name_is_ok q) = i in NMSTTotal.recall _ mem_evolves (name_is_ok q) i; recall_all tl let fresh_invariant (e:inames) (p:slprop) (ctx:list pre_inv) (frame:slprop) : MstTot (i:inv p { not (mem_inv e i) /\ fresh_wrt ctx (name_of_inv i)}) e p (fun _ -> emp) frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in recall_all ctx; ac_reasoning_for_m_frame_preserving p frame (locks_invariant e m0) m0; assert (interp (p `star` locks_invariant e m0) m0); let r = new_invariant_tot_action e p m0 in let ( i, m1 ) = r in assert (i == List.Tot.length m0.locks); assert (not (Set.mem i e)); assert (mem_evolves m0 m1); NMSTTotal.put #full_mem #mem_evolves m1; iname_for_p_stable i p; let w = NMSTTotal.witness full_mem mem_evolves (iname_for_p_mem i p) in let w0 = NMSTTotal.witness full_mem mem_evolves (name_is_ok i) in (| hide i, w0, w |) let new_invariant (e:inames) (p:slprop) (frame:slprop) : MstTot (inv p) e p (fun _ -> emp) frame (fun _ -> True) (fun _ _ _ -> True) = fresh_invariant e p [] frame let rearrange_invariant (p q r : slprop) (q0 q1:slprop) : Lemma (requires q `equiv` (q0 `star` q1)) (ensures (p `star` (q `star` r)) `equiv` ((q0 `star` p) `star` (q1 `star` r))) = calc (equiv) { p `star` (q `star` r); (equiv) { calc (equiv) { (q `star` r); (equiv) { star_congruence q r (q0 `star` q1) r } (q0 `star` q1) `star` r; }; star_congruence p (q `star` r) p ((q0 `star` q1) `star` r) } (p `star` ((q0 `star` q1) `star` r)); (equiv) { star_associative q0 q1 r; star_congruence p ((q0 `star` q1) `star` r) p (q0 `star` (q1 `star` r)); star_associative p q0 (q1 `star` r) } (p `star` q0) `star` (q1 `star` r); (equiv) { star_commutative p q0; star_congruence (p `star` q0) (q1 `star` r) (q0 `star` p) (q1 `star` r) } (q0 `star` p) `star` (q1 `star` r); } let preserves_frame_invariant (fp fp':slprop) (opened_invariants:inames) (p:slprop) (i:inv p{not (mem_inv opened_invariants i)}) (m0:hmem_with_inv_except (add_inv opened_invariants i) (p `star` fp)) (m1:mem) : Lemma (requires preserves_frame (set_add (name_of_inv i) opened_invariants) (p `star` fp) (p `star` fp') m0 m1 /\ interp (fp' `star` linv opened_invariants m1) m1 /\ inames_ok opened_invariants m1 /\ (lock_store_invariant opened_invariants m0.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks)) /\ (lock_store_invariant opened_invariants m1.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks))) (ensures preserves_frame opened_invariants fp fp' m0 m1) = let aux (frame:slprop) : Lemma (requires interp ((fp `star` frame) `star` linv opened_invariants m0) m0) (ensures interp ((fp' `star` frame) `star` linv opened_invariants m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) [SMTPat()] = rearrange_invariant (fp `star` frame) (lock_store_invariant opened_invariants m0.locks) (ctr_validity m0.ctr (heap_of_mem m0)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks); assert (interp ((p `star` (fp `star` frame)) `star` linv (set_add (name_of_inv i) opened_invariants) m0) m0); star_associative p fp frame; star_congruence (p `star` (fp `star` frame)) (linv (set_add (name_of_inv i) opened_invariants) m0) ((p `star` fp) `star` frame) (linv (set_add (name_of_inv i) opened_invariants) m0); assert (interp (((p `star` fp) `star` frame) `star` linv (set_add (name_of_inv i) opened_invariants) m0) m0); assert (interp (((p `star` fp') `star` frame) `star` linv (set_add (name_of_inv i) opened_invariants) m1) m1); star_associative p fp' frame; star_congruence ((p `star` fp') `star` frame) (linv (set_add (name_of_inv i) opened_invariants) m1) (p `star` (fp' `star` frame)) (linv (set_add (name_of_inv i) opened_invariants) m1); assert (interp ((p `star` (fp' `star` frame)) `star` linv (set_add (name_of_inv i) opened_invariants) m1) m1); rearrange_invariant (fp' `star` frame) (lock_store_invariant opened_invariants m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks); assert (interp ((fp' `star` frame) `star` linv opened_invariants m1) m1); () in () let equiv_ext_right (p q r:slprop) : Lemma (requires q `equiv` r) (ensures (p `star` q) `equiv` (p `star` r)) = calc (equiv) { p `star` q; (equiv) { star_commutative p q } q `star` p; (equiv) { equiv_extensional_on_star q r p } r `star` p; (equiv) { star_commutative p r } p `star` r; } let with_inv_helper (fp frame ls1 ctr p ls2:slprop) : Lemma (requires ls1 `equiv` (p `star` ls2)) (ensures (fp `star` frame `star` (ls1 `star` ctr)) `equiv` (p `star` fp `star` frame `star` (ls2 `star` ctr))) = calc (equiv) { ls1 `star` ctr; (equiv) { equiv_extensional_on_star ls1 (p `star` ls2) ctr } p `star` ls2 `star` ctr; }; calc (equiv) { p `star` ls2 `star` ctr; (equiv) { star_associative p ls2 ctr } p `star` (ls2 `star` ctr); }; calc (equiv) { fp `star` frame `star` p; (equiv) { star_commutative (fp `star` frame) p } p `star` (fp `star` frame); (equiv) { star_associative p fp frame } p `star` fp `star` frame; }; calc (equiv) { fp `star` frame `star` (ls1 `star` ctr); (equiv) { equiv_ext_right (fp `star` frame) (ls1 `star` ctr) (p `star` ls2 `star` ctr) } (fp `star` frame) `star` (p `star` ls2 `star` ctr); (equiv) { equiv_ext_right (fp `star` frame) (p `star` ls2 `star` ctr) (p `star` (ls2 `star` ctr)) } (fp `star` frame) `star` (p `star` (ls2 `star` ctr)); (equiv) { star_associative (fp `star` frame) p (ls2 `star` ctr) } (fp `star` frame `star` p) `star` (ls2 `star` ctr); (equiv) { equiv_extensional_on_star (fp `star` frame `star` p) (p `star` fp `star` frame) (ls2 `star` ctr) } (p `star` fp `star` frame) `star` (ls2 `star` ctr); } let token_of_inv #p (i:inv p) : (name_of_inv i >--> p) = let (| _, _, tok |) = i in tok let with_invariant (#a:Type) (#fp:slprop) (#fp':a -> slprop) (#opened_invariants:inames) (#p:slprop) (i:inv p{not (mem_inv opened_invariants i)}) (f:action_except a (add_inv opened_invariants i) (p `star` fp) (fun x -> p `star` fp' x)) (frame:slprop) : MstTot a opened_invariants fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in NMSTTotal.recall _ mem_evolves (iname_for_p_mem (name_of_inv i) p) (token_of_inv i); assert (iname_for_p (name_of_inv i) p m0.locks); assert (interp (fp `star` frame `star` locks_invariant opened_invariants m0) m0); assert (interp (fp `star` frame `star` (lock_store_invariant opened_invariants m0.locks `star` ctr_validity m0.ctr (heap_of_mem m0))) m0); move_invariant opened_invariants m0.locks p (name_of_inv i); assert (lock_store_invariant opened_invariants m0.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks)); with_inv_helper fp frame (lock_store_invariant opened_invariants m0.locks) (ctr_validity m0.ctr (heap_of_mem m0)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks); assert (interp (p `star` fp `star` frame `star` locks_invariant (set_add (name_of_inv i) opened_invariants) m0) m0); let r = f frame in let m1 : full_mem = NMSTTotal.get () in assert (interp (p `star` fp' r `star` frame `star` locks_invariant (set_add (name_of_inv i) opened_invariants) m1) m1); assert (interp (p `star` fp' r `star` frame `star` (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks `star` ctr_validity m1.ctr (heap_of_mem m1))) m1); NMSTTotal.recall _ mem_evolves (iname_for_p_mem (name_of_inv i) p) (token_of_inv i); move_invariant opened_invariants m1.locks p (name_of_inv i); assert (lock_store_invariant opened_invariants m1.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks)); with_inv_helper (fp' r) frame (lock_store_invariant opened_invariants m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks); assert (interp (fp' r `star` frame `star` locks_invariant opened_invariants m1) m1); assert (inames_ok opened_invariants m1); r let equiv_pqrs_p_qr_s (p q r s:slprop) : Lemma ((p `star` q `star` r `star` s) `equiv` (p `star` (q `star` r) `star` s)) = star_associative p q r; equiv_extensional_on_star (p `star` q `star` r) (p `star` (q `star` r)) s let frame (#a:Type) (#opened_invariants:inames) (#pre:slprop) (#post:a -> slprop) (#req:mprop pre) (#ens:mprop2 pre post) (frame:slprop) ($f:action_except_full a opened_invariants pre post req ens) (frame0:slprop) : MstTot a opened_invariants (pre `star` frame) (fun x -> post x `star` frame) frame0 req ens = let m0 : full_mem = NMSTTotal.get () in equiv_pqrs_p_qr_s pre frame frame0 (linv opened_invariants m0); assert (interp (pre `star` frame `star` frame0 `star` linv opened_invariants m0) m0); assert (interp (pre `star` (frame `star` frame0) `star` linv opened_invariants m0) m0); let x = f (frame `star` frame0) in let m1 : full_mem = NMSTTotal.get () in equiv_pqrs_p_qr_s (post x) frame frame0 (linv opened_invariants m1); assert (interp (post x `star` (frame `star` frame0) `star` linv opened_invariants m1) m1); assert (interp (post x `star` frame `star` frame0 `star` linv opened_invariants m1) m1); x let change_slprop (#opened_invariants:inames) (p q:slprop) (proof: (m:mem -> Lemma (requires interp p m) (ensures interp q m))) = let proof (h:H.heap) : Lemma (requires H.interp p h) (ensures H.interp q h) = proof (mem_of_heap h) in lift_tot_action (lift_heap_action opened_invariants (Steel.Heap.change_slprop p q proof)) (* This module reuses is_frame_monotonic from Heap, but does not expose that to clients, so we need this lemma to typecheck witness_h_exists below. *) let relate_frame_monotonic_1 #a p : Lemma (requires (H.is_frame_monotonic p)) (ensures (is_frame_monotonic p)) = () let relate_frame_monotonic_2 #a p : Lemma (requires (is_frame_monotonic p)) (ensures (H.is_frame_monotonic p)) = let aux (x y : a) (h : H.heap) (f : H.slprop) : Lemma (requires (H.interp (p x `H.star` f) h /\ H.interp (p y) h)) (ensures (H.interp (p y `H.star` f) h)) = let m = mem_of_heap h in assert (interp (p x `star` f) m); assert (interp (p y) m); assert (interp (p y `star` f) m) in Classical.forall_intro_4 (fun x y h f -> Classical.move_requires (aux x y h) f) let witness_h_exists #opened_invariants #a p = lift_tot_action_with_frame (lift_heap_action_with_frame opened_invariants (H.witness_h_exists p)) let lift_h_exists #opened_invariants p = lift_tot_action (lift_heap_action opened_invariants (H.lift_h_exists p)) let elim_pure #opened_invariants p = lift_tot_action (lift_heap_action opened_invariants (H.elim_pure p)) let pts_to_join (#a:Type) (#pcm:pcm a) (r:ref a pcm) (x y : a) (m:mem) : Lemma (requires (interp (pts_to r x) m /\ interp (pts_to r y) m)) (ensures (joinable pcm x y)) = H.pts_to_join #a #pcm r x y (heap_of_mem m)

{ "checked_file": "/", "dependencies": [ "Steel.Preorder.fst.checked", "Steel.Heap.fsti.checked", "prims.fst.checked", "FStar.Witnessed.Core.fsti.checked", "FStar.Set.fsti.checked", "FStar.Preorder.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.PCM.fst.checked", "FStar.NMSTTotal.fst.checked", "FStar.List.Tot.fst.checked", "FStar.IndefiniteDescription.fsti.checked", "FStar.Ghost.fsti.checked", "FStar.FunctionalExtensionality.fsti.checked", "FStar.Classical.Sugar.fsti.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Steel.Memory.fst" }

[ { "abbrev": true, "full_module": "Steel.Preorder", "short_module": "PP" }, { "abbrev": true, "full_module": "FStar.Witnessed.Core", "short_module": "W" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": true, "full_module": "Steel.Heap", "short_module": "H" }, { "abbrev": false, "full_module": "FStar.FunctionalExtensionality", "short_module": null }, { "abbrev": true, "full_module": "FStar.FunctionalExtensionality", "short_module": "F" }, { "abbrev": true, "full_module": "FStar.Universe", "short_module": "U" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": false, "full_module": "FStar.PCM", "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.Memory.ref a pcm -> x: a -> y: a -> m: Steel.Memory.mem -> FStar.Pervasives.Lemma (requires Steel.Memory.interp (Steel.Memory.pts_to r x) m /\ FStar.PCM.compatible pcm y x) (ensures Steel.Memory.interp (Steel.Memory.pts_to r y) m)

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "FStar.PCM.pcm", "Steel.Memory.ref", "Steel.Memory.mem", "Steel.Heap.pts_to_evolve", "Steel.Memory.heap_of_mem", "Prims.unit", "Prims.l_and", "Steel.Memory.interp", "Steel.Memory.pts_to", "FStar.PCM.compatible", "Prims.squash", "Prims.Nil", "FStar.Pervasives.pattern" ]

[]

true

false

true

false

let pts_to_evolve (#a: Type u#a) (#pcm: _) (r: ref a pcm) (x y: a) (m: mem) : Lemma (requires (interp (pts_to r x) m /\ compatible pcm y x)) (ensures (interp (pts_to r y) m)) =

H.pts_to_evolve #a #pcm r x y (heap_of_mem m)

false

Steel.Memory.fst

Steel.Memory.star_is_frame_monotonic

val star_is_frame_monotonic (#a:Type) (f g : a -> slprop) : Lemma (requires (is_frame_monotonic f /\ is_frame_monotonic g)) (ensures (is_frame_monotonic (fun x -> f x `star` g x)))

let star_is_frame_monotonic (#a:Type) (f g : a -> slprop) : Lemma (requires (is_frame_monotonic f /\ is_frame_monotonic g)) (ensures (is_frame_monotonic (fun x -> f x `star` g x))) = let aux (x y : a) (m:mem) (frame : slprop) : Lemma (requires interp ((f x `star` g x) `star` frame) m /\ interp (f y `star` g y) m) (ensures (interp ((f y `star` g y) `star` frame) m)) = star_associative (f x) (g x) frame; let (m1, m23) = id_elim_star (f x) (g x `star` frame) m in let (m2, m3) = id_elim_star (g x) frame m23 in affine_star (f y) (g y) m; assert (interp (f y) m); assert (interp (g y) m); assert (interp (f x `star` (g x `star` frame)) m); assert (interp (f y `star` (g x `star` frame)) m); (* flip and do the same reasoning *) star_associative (f y) (g x) frame; star_commutative (f y) (g x); star_congruence (f y `star` g x) frame (g x `star` f y) frame; star_associative (g x) (f y) frame; assert (interp (g x `star` (f y `star` frame)) m); assert (interp (g y `star` (f y `star` frame)) m); (* get back in shape *) star_associative (f y) (g y) frame; star_commutative (f y) (g y); star_congruence (f y `star` g y) frame (g y `star` f y) frame; star_associative (g y) (f y) frame; assert (interp (f y `star` (g y `star` frame)) m); () in Classical.forall_intro_4 (fun x y m -> Classical.move_requires (aux x y m)); ()

{ "file_name": "lib/steel/Steel.Memory.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 6, "end_line": 1648, "start_col": 0, "start_line": 1614 }

(* 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.Memory module F = FStar.FunctionalExtensionality open FStar.FunctionalExtensionality open FStar.PCM module H = Steel.Heap noeq type lock_state : Type u#(a + 1) = | Invariant : inv:H.slprop u#a -> lock_state let lock_store : Type u#(a+1) = list (lock_state u#a) noeq type mem : Type u#(a + 1) = { ctr: nat; heap: H.heap u#a; locks: lock_store u#a; } let heap_of_mem (x:mem) : H.heap = x.heap let mem_of_heap (h:H.heap) : mem = { ctr = 0; heap = h; locks = [] } let mem_set_heap (m:mem) (h:H.heap) : mem = { ctr = m.ctr; heap = h; locks = m.locks; } let core_mem (m:mem) : mem = mem_of_heap (heap_of_mem m) let core_mem_invol m = () let disjoint (m0 m1:mem u#h) : prop = m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks let disjoint_sym m0 m1 = () let join m0 m1 = { ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = m0.locks } let join_commutative m0 m1 = H.join_commutative m0.heap m1.heap let disjoint_join m0 m1 m2 = H.disjoint_join m0.heap m1.heap m2.heap let join_associative m0 m1 m2 = H.join_associative m0.heap m1.heap m2.heap let slprop = H.slprop let interp p m = H.interp p m.heap let equiv p1 p2 = forall m. interp p1 m <==> interp p2 m let slprop_extensionality p q = assert (forall m. interp p m <==> interp q m); let aux (h:H.heap) : Lemma (H.interp p h <==> H.interp q h) [SMTPat (H.interp p h)] = let m : mem = { ctr = 0; heap = h; locks = [] } in assert (interp p m <==> interp q m) in assert (forall h. H.interp p h <==> H.interp q h); Steel.Heap.slprop_extensionality p q let reveal_equiv p1 p2 = () let core_ref = H.core_ref let core_ref_null = H.core_ref_null let core_ref_is_null r = H.core_ref_is_null r let emp : slprop u#a = H.emp let pure = H.pure let pts_to = H.pts_to let h_and = H.h_and let h_or = H.h_or let star = H.star let wand = H.wand let h_exists = H.h_exists let h_forall = H.h_forall //////////////////////////////////////////////////////////////////////////////// //properties of equiv //////////////////////////////////////////////////////////////////////////////// let equiv_symmetric (p1 p2:slprop u#a) = H.equiv_symmetric p1 p2 #push-options "--warn_error -271" let equiv_heap_iff_equiv (p1 p2:slprop u#a) : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat (equiv p1 p2)] = let aux_lr () : Lemma (requires H.equiv p1 p2) (ensures equiv p1 p2) [SMTPat ()] = () in let aux_rl_helper1 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p1 h) (ensures H.interp p2 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl_helper2 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p2 h) (ensures H.interp p1 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl () : Lemma (requires equiv p1 p2) (ensures H.equiv p1 p2) [SMTPat ()] = () in () let equiv_heap_iff_equiv_forall () : Lemma (ensures (forall p1 p2. H.equiv p1 p2 <==> equiv p1 p2)) = let aux p1 p2 : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat ()] = equiv_heap_iff_equiv p1 p2 in () #pop-options let equiv_extensional_on_star (p1 p2 p3:slprop u#a) = equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3 let emp_unit p = H.emp_unit p let intro_emp m = H.intro_emp (heap_of_mem m) let pure_equiv p q = H.pure_equiv p q let pure_interp q m = H.pure_interp q (heap_of_mem m) let pure_star_interp p q m = H.pure_star_interp p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// //pts_to //////////////////////////////////////////////////////////////////////////////// let pts_to_compatible #a #pcm x v0 v1 m = H.pts_to_compatible #a #pcm x v0 v1 (heap_of_mem m) let pts_to_compatible_equiv #a #pcm x v0 v1 = H.pts_to_compatible_equiv #a #pcm x v0 v1 let pts_to_not_null #a #pcm x v m = H.pts_to_not_null #a #pcm x v (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // star //////////////////////////////////////////////////////////////////////////////// let intro_star p q mp mq = H.intro_star p q (heap_of_mem mp) (heap_of_mem mq) let elim_star p q m = let h = heap_of_mem m in H.elim_star p q h; assert (exists hl hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr); let hl = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hl -> exists hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let hr = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hr -> H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let ml = mem_set_heap m hl in let mr = mem_set_heap m hr in assert (disjoint ml mr); assert (m == join ml mr); assert (interp p ml); assert (interp q mr); () let interp_star (p q: slprop) (m: mem) : Lemma (interp (p `star` q) m <==> (exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m)) = let left = interp (p `star` q) m in let right = exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m in let f () : Lemma (requires left) (ensures right) = elim_star p q m in let g () : Lemma (requires right) (ensures left) = Classical.exists_elim left #_ #(fun mp -> exists (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mp -> Classical.exists_elim left #_ #(fun mq -> disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mq -> intro_star p q mp mq ) ) in Classical.move_requires f (); Classical.move_requires g () let star_commutative (p1 p2:slprop) = H.star_commutative p1 p2 let star_associative (p1 p2 p3:slprop) = H.star_associative p1 p2 p3 let star_congruence (p1 p2 p3 p4:slprop) = equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4 let affine_star (p q:slprop) (m:mem) = H.affine_star p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // Invariants on the lock store //////////////////////////////////////////////////////////////////////////////// let iname = nat module S = FStar.Set module L = FStar.List.Tot module W = FStar.Witnessed.Core let rec lock_store_invariant (e:inames) (l:lock_store u#a) : slprop u#a = let current_addr = L.length l - 1 in match l with | [] -> emp | Invariant p :: tl -> if current_addr `S.mem` e then lock_store_invariant e tl else p `star` lock_store_invariant e tl let lock_i (i:iname) (l:lock_store { i < L.length l }) = let ix = L.length l - i - 1 in L.index l ix let iname_for_p (i:iname) (p:slprop) : W.s_predicate lock_store = fun l -> i < L.length l /\ (lock_i i l).inv == p let lock_store_evolves : FStar.Preorder.preorder lock_store = fun (l1 l2 : lock_store) -> L.length l2 >= L.length l1 /\ (forall (i:nat{i < L.length l1}). (lock_i i l1).inv == (lock_i i l2).inv) let inames_in (e:inames) (l:lock_store) : prop = forall i. Set.mem i e ==> i < L.length l let inames_ok e m = inames_in e m.locks let inames_ok_empty m = () let extend_lock_store (e:inames) (l:lock_store{e `inames_in` l}) (p:slprop) : i:iname & l':lock_store { lock_store_invariant e l' == p `star` lock_store_invariant e l /\ iname_for_p i p l' } = (| L.length l, Invariant p :: l |) let set_add (i:iname) (s:inames) = Set.union (Set.singleton i) s let rec move_invariant (e:inames) (l:lock_store) (p:slprop) (i:iname{iname_for_p i p l /\ ~(i `Set.mem` e)}) : Lemma (H.equiv (lock_store_invariant e l) (p `star` lock_store_invariant (set_add i e) l)) = let rec aux (i:iname) (m:lock_store) : Lemma (requires i >= L.length m) (ensures (lock_store_invariant e m `H.equiv` lock_store_invariant (set_add i e) m)) = match m with | [] -> () | Invariant p::tl -> aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl) in let current_addr = L.length l - 1 in match l with | [] -> () | Invariant q::tl -> if i = current_addr then begin assert (lock_store_invariant e l == p `star` lock_store_invariant e tl); aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl); () end else begin move_invariant e tl p i; assert (lock_store_invariant e tl `equiv` (p `star` lock_store_invariant (set_add i e) tl)); H.star_congruence q (lock_store_invariant e tl) q (p `star` lock_store_invariant (set_add i e) tl); if Set.mem current_addr e then () else begin let r = lock_store_invariant (set_add i e) tl in assert (lock_store_invariant e l `equiv` (q `star` (p `star` r))); H.star_associative q p r; H.star_commutative q p; H.star_congruence (q `star` p) r (p `star` q) r; H.star_associative p q r end end let heap_ctr_valid (ctr:nat) (h:H.heap u#a) : prop = h `H.free_above_addr` ctr let ctr_validity (ctr:nat) (h:H.heap) : slprop = H.pure (heap_ctr_valid ctr h) let locks_invariant (e:inames) (m:mem u#a) : slprop u#a = lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m) let full_mem_pred (m:mem) = H.full_heap_pred (heap_of_mem m) (***** Following lemmas are needed in Steel.Effect *****) let core_mem_interp (hp:slprop u#a) (m:mem u#a) = () let interp_depends_only_on (hp:slprop u#a) = H.interp_depends_only_on hp let a_mem_prop_as_a_heap_prop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (H.a_heap_prop u#a) = let g (h: H.heap u#a) : Tot prop = interp sl (mem_of_heap h) /\ f (mem_of_heap h) in let phi0 (h0 h1: H.heap u#a) : Lemma (requires (g h0 /\ H.disjoint h0 h1)) (ensures (g h0 /\ H.disjoint h0 h1 /\ g (H.join h0 h1))) = assert (mem_of_heap (H.join h0 h1) == mem_of_heap h0 `join` mem_of_heap h1); interp_depends_only_on sl in let phi1 (h0 h1: H.heap u#a) : Lemma (ensures ((g h0 /\ H.disjoint h0 h1) ==> g (H.join h0 h1))) = Classical.move_requires (phi0 h0) h1 in Classical.forall_intro_2 phi1; g let refine_slprop sl f = H.as_slprop (a_mem_prop_as_a_heap_prop sl f) let interp_refine_slprop sl f m = assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_mem m)) let dep_hprop (s: slprop) (f: (hmem s -> Tot slprop)) (h: H.heap) : Tot prop = exists (h1: H.heap) . exists (h2: H.heap) . interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 let dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq' : squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h')) = let p2 (h h1 h2: H.heap) : Tot prop = interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 in let p1 (h h1: H.heap) : Tot prop = (exists h2 . p2 h h1 h2) in let h1 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p1 h) in let h2 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p2 h h1) in H.disjoint_join h' h1 h2; assert (H.disjoint h2 h'); let h2' = H.join h2 h' in H.join_commutative h2 h' ; assert (h2' == H.join h' h2); assert (H.disjoint h1 h2'); assert (mem_of_heap h2' == mem_of_heap h2 `join` mem_of_heap h'); interp_depends_only_on (f (mem_of_heap h1)); assert (interp (f (mem_of_heap h1)) (mem_of_heap h2')); H.join_commutative h1 h2; H.join_associative h' h2 h1; H.join_commutative h' h; H.join_commutative h2' h1; assert (H.join h h' == h1 `H.join` h2') let impl_intro_gen (#p: Type0) (#q: Type0) ($prf: (squash p -> Lemma (q ))) : Lemma (p ==> q) = Classical.impl_intro_gen #p #(fun _ -> q) prf let dep_hprop_is_affine1 (s: slprop) (f: (hmem s -> Tot slprop)) (h0 h1: H.heap) : Lemma ((dep_hprop s f h0 /\ H.disjoint h0 h1) ==> (H.disjoint h0 h1 /\ dep_hprop s f (H.join h0 h1))) = impl_intro_gen (dep_hprop_is_affine0 s f h0 h1) let dep_hprop_is_affine (s: slprop) (f: (hmem s -> Tot slprop)) : Lemma (H.heap_prop_is_affine (dep_hprop s f)) = Classical.forall_intro_2 (dep_hprop_is_affine1 s f) let sdep (s: slprop) (f: (hmem s -> Tot slprop)) : Tot slprop = dep_hprop_is_affine s f; H.as_slprop (dep_hprop s f) let interp_sdep (s: slprop) (f: (hmem s -> Tot slprop)) (m: mem) : Lemma (requires (dep_slprop_is_affine s f)) (ensures ( interp (sdep s f) m <==> (exists m1 m2 . interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) )) = dep_hprop_is_affine s f; assert (forall m1 m2 . (interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) ==> ( interp s (mem_of_heap m1.heap) /\ interp (f (mem_of_heap m1.heap)) (mem_of_heap m2.heap) /\ H.disjoint m1.heap m2.heap /\ H.join m1.heap m2.heap == m.heap )); interp_depends_only_on s; Classical.forall_intro (fun m -> interp_depends_only_on (f m)); assert (forall h1 h2 . (interp s (mem_of_heap h1) /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ H.disjoint h1 h2 /\ H.join h1 h2 == m.heap) ==> ( core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ interp s (core_mem (mem_of_heap h1)) /\ interp s (mem_set_heap m h1) /\ core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ f (mem_set_heap m h1) `equiv` f (mem_of_heap h1) /\ interp (f (mem_set_heap m h1)) (mem_of_heap h2) /\ interp (f (mem_set_heap m h1)) (mem_set_heap m h2) /\ disjoint (mem_set_heap m h1) (mem_set_heap m h2) /\ join (mem_set_heap m h1) (mem_set_heap m h2) == m )); () let h_exists_cong (#a:Type) (p q : a -> slprop) : Lemma (requires (forall x. p x `equiv` q x)) (ensures (h_exists p `equiv` h_exists q)) = equiv_heap_iff_equiv_forall (); H.h_exists_cong p q let intro_h_exists #a x p m = H.intro_h_exists x p (heap_of_mem m) let elim_h_exists (#a:_) (p:a -> slprop) (m:mem) = H.elim_h_exists p (heap_of_mem m) let intro_h_forall (#a:_) (p:a -> slprop) (m:mem) = H.intro_h_forall p (heap_of_mem m) let elim_h_forall (#a:_) (p:a -> slprop) (m:mem) (x:a) = H.elim_h_forall p (heap_of_mem m) x let intro_h_and (p q: slprop) (m:mem) = H.intro_h_and p q (heap_of_mem m) let elim_h_and (p q: slprop) (m:mem) = H.elim_h_and p q (heap_of_mem m) let intro_h_or_left (p q: slprop) (m:mem) = H.intro_h_or_left p q (heap_of_mem m) let intro_h_or_right (p q: slprop) (m:mem) = H.intro_h_or_right p q (heap_of_mem m) let elim_h_or (p q: slprop) (m:mem) = H.elim_h_or p q (heap_of_mem m) let intro_wand (p1 p2: slprop u#a) (m:mem) = introduce (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)) ==> interp (wand p1 p2) m with _. ( assert (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)); H.intro_wand p1 p2 (heap_of_mem m); let h = heap_of_mem m in assert ((forall h1. h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) ==> H.interp (wand p1 p2) h); introduce forall h1. (h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) with ( introduce (h `H.disjoint` h1 /\ H.interp p1 h1) ==> H.interp p2 (H.join h h1) with _. ( assert (h `H.disjoint` h1); let m1 = { ctr = m.ctr; heap = h1; locks = m.locks } in assert (m `disjoint` m1) ) ) ) (** Eliminating a wand by proving a heap that satisfies the LHS **) let elim_wand (p1 p2: slprop u#a) (m:mem) (m1:mem) = H.elim_wand p1 p2 (heap_of_mem m) (heap_of_mem m1) //////////////////////////////////////////////////////////////////////////////// // Preorders and effects //////////////////////////////////////////////////////////////////////////////// module PP = Steel.Preorder let mem_evolves = fun (m0 m1:full_mem) -> H.heap_evolves (heap_of_mem m0) (heap_of_mem m1) /\ m0.ctr <= m1.ctr /\ lock_store_evolves m0.locks m1.locks (** See [Steel.Heap.is_frame_preserving]. We add in [lock_invariants] now *) let preserves_frame (e:inames) (pre post:slprop) (m0 m1:mem) = forall (frame:slprop). interp ((pre `star` frame) `star` locks_invariant e m0) m0 ==> (interp ((post `star` frame) `star` locks_invariant e m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) (** This is a version of MstTot with frame quantified, as part of preserves_frame *) effect MstTotNF (a:Type u#a) (except:inames) (expects:slprop u#1) (provides: a -> slprop u#1) = NMSTTotal.NMSTATETOT a (full_mem u#1) mem_evolves (requires fun m0 -> inames_ok except m0 /\ interp (expects `star` locks_invariant except m0) m0) (ensures fun m0 x m1 -> inames_ok except m1 /\ interp (provides x `star` locks_invariant except m1) m1 /\ preserves_frame except expects (provides x) m0 m1) //////////////////////////////////////////////////////////////////////////////// // Lifting heap actions //////////////////////////////////////////////////////////////////////////////// (** Heap actions come in two equivalent flavors: - one that take an explicit frame as argument (action_with_frame) - and one that quantify over all the frame We therefore define two lift routes: - a direct route for those with explicit frame - via MstTotNF for the rest *) let tot_pre_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = hmem_with_inv_except e fp -> (x:a & hmem_with_inv_except e (fp' x)) let tot_pre_action_nf = tot_pre_action_nf_except S.empty let ac_reasoning_for_m_frame_preserving (p q r:slprop u#a) (m:mem u#a) : Lemma (requires interp ((p `star` q) `star` r) m) (ensures interp (p `star` r) m) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_commutative p q; equiv_extensional_on_star (p `star` q) (q `star` p) r } (q `star` p) `star` r; (equiv) { star_associative q p r } q `star` (p `star` r); }; assert (interp (q `star` (p `star` r)) m); affine_star q (p `star` r) m let is_frame_preserving (#e:inames) (#a:Type u#b) (#fp:slprop u#a) (#fp':a -> slprop u#a) (f:tot_pre_action_nf_except e fp a fp') = forall (frame:slprop u#a) (m0:hmem_with_inv_except e (fp `star` frame)). (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = f:tot_pre_action_nf_except e fp a fp'{ is_frame_preserving f } let tot_action_nf = tot_action_nf_except S.empty let linv e (m:mem) = locks_invariant e m let hheap_of_hmem #fp #e (m:hmem_with_inv_except e fp) : h:H.hheap (fp `star` linv e m) { h `H.free_above_addr` m.ctr} = let h = heap_of_mem m in H.pure_interp (heap_ctr_valid m.ctr (heap_of_mem m)) h; h let hmem_of_hheap #e (#fp0 #fp1:slprop) (m:hmem_with_inv_except e fp0) (h:H.full_hheap (fp1 `star` linv e m) { h `Heap.free_above_addr` m.ctr }) : m1:hmem_with_inv_except e fp1{linv e m `equiv` linv e m1} = let m1 : mem = { m with heap = h } in assert (interp (fp1 `star` linv e m) m1); star_commutative fp1 (linv e m); assert (interp (linv e m `star` fp1) m1); assert (linv e m1 == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); assert (linv e m == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m)); H.pure_interp (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_of_mem m); assert (heap_ctr_valid m1.ctr (heap_of_mem m) <==> heap_ctr_valid m1.ctr (heap_of_mem m1)); H.pure_equiv (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_ctr_valid m1.ctr (heap_of_mem m1)); H.star_congruence (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m)); assert (linv e m `equiv` linv e m1); let _ = equiv_extensional_on_star (linv e m) (linv e m1) fp1 in assert ((linv e m `star` fp1) `equiv` (linv e m1 `star` fp1)); assert (interp (linv e m1 `star` fp1) m1); star_commutative (linv e m1) fp1; assert (interp (fp1 `star` linv e m1) m1); m1 let with_inv_except (m:mem) e (fp:slprop) = interp (fp `star` locks_invariant e m) m #push-options "--warn_error -271" let as_hprop (frame:slprop) (mp:mprop frame) : hp:H.hprop frame{forall m. mp (core_mem m) == hp (heap_of_mem m)} = let f = fun h -> mp (mem_of_heap h) in assert (forall m. mp (core_mem m) == f (heap_of_mem m)); let aux (m0:H.hheap frame) (m1:H.heap{H.disjoint m0 m1}) : Lemma (ensures (mem_of_heap (H.join m0 m1) == join (mem_of_heap m0) (mem_of_heap m1))) [SMTPat ()] = () in f let mprop_preservation_of_hprop_preservation (p:slprop) (m0 m1:mem) : Lemma (requires (forall (hp:H.hprop p). hp (heap_of_mem m0) == hp (heap_of_mem m1))) (ensures (forall (mp:mprop p). mp (core_mem m0) == mp (core_mem m1))) = let aux (mp:mprop p) : Lemma (mp (core_mem m0) == mp (core_mem m1)) [SMTPat()] = assert (as_hprop p mp (heap_of_mem m0) == as_hprop p mp (heap_of_mem m1)) in () let lift_heap_action (#fp:slprop) (#a:Type) (#fp':a -> slprop) (e:inames) ($f:H.action fp a fp') : tot_action_nf_except e fp a fp' = let g : tot_pre_action_nf_except e fp a fp' = fun m -> let h0 = hheap_of_hmem m in let (| x, h' |) = f h0 in (| x, hmem_of_hheap m h' |) in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in let h0 = hheap_of_hmem m0 in let (| x', h1 |) = f h0 in H.action_framing f (linv e m0) h0; assert (x == x'); star_associative fp frame (linv e m0); H.action_framing f (frame `star` linv e m0) h0; assert (H.interp ((fp' x) `star` (frame `star` linv e m0)) h1); star_associative (fp' x) frame (linv e m0); assert (H.interp ((fp' x `star` frame) `star` linv e m0) h1); let h1' : H.hheap ((fp' x `star` frame) `star` linv e m0) = h1 in assert (m1 == hmem_of_hheap m0 h1'); assert (with_inv_except m1 e (fp' x `star` frame)); assert (forall (hp:H.hprop frame). hp h0 == hp h1); mprop_preservation_of_hprop_preservation frame m0 m1; () in assert (is_frame_preserving g); g let frame_preserving_respects_preorder #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (m0:hmem_with_inv_except e fp) : Lemma (let (| x, m1 |) = f m0 in mem_evolves m0 m1) = let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1) = () in H.emp_unit fp; assert (interp (fp `star` linv e m0) m0); H.star_congruence (fp `star` emp) (linv e m0) fp (linv e m0); assert (interp ((fp `star` emp) `star` linv e m0) m0); aux emp m0 let lift_tot_action_nf #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') : MstTotNF a e fp fp' = let m0 = NMSTTotal.get () in let m0' : hmem_with_inv_except e fp = m0 in let r = f m0' in let (| x, m1 |) = r in let m1' : hmem_with_inv_except e (fp' x) = m1 in assert (is_frame_preserving f); assert (m1 == dsnd (f m0)); frame_preserving_respects_preorder f m0; NMSTTotal.put #_ #(mem_evolves) m1; x let lift_tot_action #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get #(full_mem) #_ () in ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); lift_tot_action_nf f (** Now defining the lift for heap actions with explicit frame *) let tot_action_with_frame_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = frame:slprop u#a -> m0:hmem_with_inv_except e (fp `star` frame) -> Pure (x:a & hmem_with_inv_except e (fp' x `star` frame)) (requires True) (ensures fun (| x, m1 |) -> mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_with_frame = tot_action_with_frame_except S.empty let lift_heap_action_with_frame (#fp:slprop u#a) (#a:Type u#b) (#fp':a -> slprop u#a) (e:inames) ($f:H.action_with_frame fp a fp') : tot_action_with_frame_except e fp a fp' = fun frame m0 -> let h0 = hheap_of_hmem m0 in calc (equiv) { fp `star` frame `star` locks_invariant e m0; (equiv) { star_associative fp frame (locks_invariant e m0) } fp `star` (frame `star` locks_invariant e m0); }; assert (H.interp (fp `star` frame `star` locks_invariant e m0) h0); assert (H.interp (fp `star` (frame `star` locks_invariant e m0)) h0); //key: apply the heap action with frame * locks_invariant e m0 let (| x, h1 |) = f (frame `star` locks_invariant e m0) h0 in calc (equiv) { fp' x `star` (frame `star` locks_invariant e m0); (equiv) { star_associative (fp' x) frame (locks_invariant e m0) } fp' x `star` frame `star` locks_invariant e m0; }; assert (H.interp (fp' x `star` (frame `star` locks_invariant e m0)) h1); assert (H.interp (fp' x `star` frame `star` locks_invariant e m0) h1); let m1 = hmem_of_hheap m0 h1 in assert (mem_evolves m0 m1); mprop_preservation_of_hprop_preservation (frame `star` locks_invariant e m0) m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)); (| x, m1 |) let lift_tot_action_with_frame #a #e #fp #fp' ($f:tot_action_with_frame_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in assert (inames_ok e m0); ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); let m0' : hmem_with_inv_except e fp = m0 in let r = f frame m0' in let (| x, m1 |) = r in ac_reasoning_for_m_frame_preserving (fp' x) frame (locks_invariant e m1) m1; assert (interp (fp' x `star` frame `star` locks_invariant e m1) m1); assert (interp (fp' x `star` locks_invariant e m1) m1); let m1' : hmem_with_inv_except e (fp' x) = m1 in NMSTTotal.put #_ #(mem_evolves) m1; x let sel_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.sel_action #a #pcm r v0)) let upd_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.upd_action #a #pcm r v0 v1)) let free_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.free_action #a #pcm r v0)) let split_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.split_action #a #pcm r v0 v1)) let gather_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.gather_action #a #pcm r v0 v1)) let weaken (p q r:slprop) (h:H.hheap (p `star` q) { H.stronger q r }) : H.hheap (p `star` r) = H.weaken p q r h; h let weaken_pure (q r: prop) : Lemma (requires (q ==> r)) (ensures H.stronger (H.pure q) (H.pure r)) = let aux (h:H.heap) : Lemma (ensures (H.interp (H.pure q) h ==> H.interp (H.pure r) h)) [SMTPat ()] = H.pure_interp q h; H.pure_interp r h in () let inc_ctr (#p:slprop) #e (m:hmem_with_inv_except e p) : m':hmem_with_inv_except e p{m'.ctr = m.ctr + 1 /\ H.stronger (linv e m) (linv e m')} = let m' : mem = { m with ctr = m.ctr + 1} in assert (interp (p `star` linv e m) m'); assert (linv e m == lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m)); assert (linv e m' == lock_store_invariant e m.locks `star` ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken_free_above (heap_of_mem m) m.ctr (m.ctr + 1); weaken_pure (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_ctr_valid (m.ctr + 1) (heap_of_mem m)); assert (H.stronger (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m))); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)); H.stronger_star (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken (p `star` lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)) (heap_of_mem m'); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity (m.ctr + 1) (heap_of_mem m)); let m' : hmem_with_inv_except e p = m' in m' let frame_related_mems (fp0 fp1:slprop u#a) e (m0:hmem_with_inv_except e fp0) (m1:hmem_with_inv_except e fp1) = forall (frame:slprop u#a). interp ((fp0 `star` frame) `star` linv e m0) m0 ==> interp ((fp1 `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) let refined_pre_action e (fp0:slprop) (a:Type) (fp1:a -> slprop) = m0:hmem_with_inv_except e fp0 -> Pure (x:a & hmem_with_inv_except e (fp1 x)) (requires True) (ensures fun (| x, m1 |) -> frame_related_mems fp0 (fp1 x) e m0 m1) let refined_pre_action_as_action (#fp0:slprop) (#a:Type) (#fp1:a -> slprop) #e ($f:refined_pre_action e fp0 a fp1) : tot_action_nf_except e fp0 a fp1 = let g : tot_pre_action_nf_except e fp0 a fp1 = fun m -> f m in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp0 `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp1 x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x', m1' |) = g m0 in let (| x, m1 |) = f m0 in assert (x == x' /\ m1 == m1') in g let alloc_action #a #pcm e x = let f : refined_pre_action e emp (ref a pcm) (fun r -> pts_to r x) = fun m0 -> (* NS: 9/29/22 I needed to annotate h : Heap.full_heap, for use with the Core checker which generates a guard for checking the implicit pattern "dot" term in the dependent pair pattern on the next line. That guard expects `h` to be a full_heap, which is it, because it is a projection of m0. However, this is not reflected in `h`'s type. So, the Core checker, which produces a guard for the pat_dot_term in isolation, cannot recheck the term. If we were to fold in the checking of pat_dot_terms and their guards with the rest of the VC, this would work. *) let h : Heap.full_heap = hheap_of_hmem m0 in let (|r, h'|) = H.extend #a #pcm x m0.ctr h in let m' : hmem_with_inv_except e emp = inc_ctr m0 in let h' : H.hheap (pts_to #a #pcm r x `star` linv e m') = weaken _ (linv e m0) (linv e m') h' in let m1 : hmem_with_inv_except e (pts_to #a #pcm r x) = hmem_of_hheap m' h' in assert (forall frame. H.frame_related_heaps h h' emp (pts_to #a #pcm r x) frame true); let aux (frame:slprop) : Lemma (requires interp ((emp `star` frame) `star` linv e m0) m0) (ensures interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) [SMTPat (emp `star` frame)] = star_associative emp frame (linv e m0); assert (H.interp (emp `star` (frame `star` linv e m0)) h); assert (H.interp (pts_to #a #pcm r x `star` (frame `star` linv e m0)) h'); star_associative (pts_to #a #pcm r x) frame (linv e m0); assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m0) h'); assert (H.stronger (linv e m0) (linv e m')); assert (H.equiv (linv e m') (linv e m1)); assert (H.stronger (linv e m0) (linv e m1)); let h' : H.hheap ((pts_to #a #pcm r x `star` frame) `star` linv e m1) = weaken _ (linv e m0) (linv e m1) h' in assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) h'); assert (forall (mp:H.hprop frame). mp h == mp h'); mprop_preservation_of_hprop_preservation frame m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) in assert (frame_related_mems emp (pts_to r x) e m0 m1); (| r, m1 |) in lift_tot_action (refined_pre_action_as_action f) let select_refine #a #p e r x f = lift_tot_action (lift_heap_action e (H.select_refine #a #p r x f)) let upd_gen #a #p e r x y f = lift_tot_action (lift_heap_action e (H.upd_gen_action r x y f)) //////////////////////////////////////////////////////////////////////////////// // witness / recall //////////////////////////////////////////////////////////////////////////////// let witnessed_ref #a #pcm (r:ref a pcm) (fact:property a) (m:full_mem) = H.witnessed_ref #a #pcm r fact (heap_of_mem m) let witnessed_ref_stability #a #pcm (r:ref a pcm) (fact:property a) : Lemma (requires FStar.Preorder.stable fact (Steel.Preorder.preorder_of_pcm pcm)) (ensures FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) = H.witnessed_ref_stability #a #pcm r fact let witnessed (#a:Type u#1) (#pcm:pcm a) (r:ref a pcm) (fact:property a) = W.witnessed _ mem_evolves (witnessed_ref r fact) let rearrange_pqr_prq (p q r:slprop) : Lemma (((p `star` q) `star` r) `equiv` ((p `star` r) `star` q)) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_associative p q r } p `star` (q `star` r); (equiv) { star_commutative q r; star_congruence p (q `star` r) p (r `star` q) } p `star` (r `star` q); (equiv) { star_associative p r q } (p `star` r) `star` q; } let preserves_frame_cong (e:inames) (p q:slprop) (r s:slprop) (m0 m1:mem) : Lemma (requires p `equiv` r /\ q `equiv` s /\ preserves_frame e p q m0 m1) (ensures preserves_frame e r s m0 m1) = let aux0 (p q r s:slprop) : Lemma (requires p `equiv` s) (ensures (((p `star` q) `star` r) `equiv` ((s `star` q) `star` r))) = star_congruence p q s q; star_congruence (p `star` q) r (s `star` q) r in let aux (frame:slprop) : Lemma (requires interp ((r `star` frame) `star` locks_invariant e m0) m0) (ensures interp ((s `star` frame) `star` locks_invariant e m1) m1 /\ interp ((p `star` frame) `star` locks_invariant e m0) m0) [SMTPat (r `star` frame)] = aux0 p frame (locks_invariant e m0) r; aux0 q frame (locks_invariant e m1) s; assert (((p `star` frame) `star` locks_invariant e m0) `equiv` ((r `star` frame) `star` locks_invariant e m0)); assert (interp ((p `star` frame) `star` locks_invariant e m0) m0); assert (interp ((q `star` frame) `star` locks_invariant e m1) m1); assert (((q `star` frame) `star` locks_invariant e m1) `equiv` ((s `star` frame) `star` locks_invariant e m1)); () in () let pure_true_equiv (p:slprop) : Lemma ((p `star` pure True) `equiv` p) = FStar.Classical.forall_intro (pure_star_interp p True); emp_unit p; assert ((p `star` pure True) `equiv` p) let preserves_frame_star_pure (e:inames) (p q:slprop) (r s:prop) (m:mem) : Lemma (requires r /\ s) (ensures preserves_frame e p q m m <==> preserves_frame e (p `star` pure r) (q `star` pure s) m m) = pure_equiv r True; star_congruence p (pure r) p (pure True); pure_equiv s True; star_congruence q (pure s) q (pure True); pure_true_equiv p; pure_true_equiv q; let fwd () : Lemma (requires preserves_frame e p q m m) (ensures preserves_frame e (p `star` pure r) (q `star` pure s) m m) [SMTPat ()] = preserves_frame_cong e p q (p `star` pure r) (q `star` pure s) m m in let bk () : Lemma (requires preserves_frame e (p `star` pure r) (q `star` pure s) m m) (ensures preserves_frame e p q m m) [SMTPat ()] = preserves_frame_cong e (p `star` pure r) (q `star` pure s) p q m m in () let witness (#a:Type) (#pcm:pcm a) (e:inames) (r:erased (ref a pcm)) (fact:stable_property pcm) (v:Ghost.erased a) (_:squash (forall z. compatible pcm v z ==> fact z)) (frame:slprop) : MstTot (witnessed r fact) e (pts_to r v) (fun _ -> pts_to r v) frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in let _ : unit = let hr : H.ref a pcm = r in let v' = H.sel_v hr v (heap_of_mem m0) in assert (interp (H.ptr hr) m0 /\ H.sel #a #pcm hr (heap_of_mem m0) == v'); assert (compatible pcm v v'); assert (fact v'); assert (witnessed_ref r fact m0); witnessed_ref_stability r fact; assert (FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) in let w = NMSTTotal.witness _ mem_evolves (witnessed_ref r fact) in w let recall (#a:Type u#1) (#pcm:pcm a) (#fact:property a) (e:inames) (r:erased (ref a pcm)) (v:Ghost.erased a) (w:witnessed r fact) (frame:slprop) = let m0 = NMSTTotal.get () in NMSTTotal.recall _ mem_evolves (witnessed_ref r fact) w; let hr : H.ref a pcm = r in assert (witnessed_ref r fact m0); let v1 = H.sel_v hr v (heap_of_mem m0) in assert (compatible pcm v v1); assert (H.sel hr (heap_of_mem m0) == v1); assert (fact v1); assert (interp ((pts_to r v `star` frame) `star` locks_invariant e m0) m0); emp_unit ((pts_to r v `star` frame) `star` locks_invariant e m0); pure_star_interp ((pts_to r v `star` frame) `star` locks_invariant e m0) (fact v1) m0; assert (interp (((pts_to r v `star` frame) `star` locks_invariant e m0) `star` pure (fact v1)) m0); rearrange_pqr_prq (pts_to r v `star` frame) (locks_invariant e m0) (pure (fact v1)); assert (interp (((pts_to r v `star` frame) `star` pure (fact v1)) `star` locks_invariant e m0) m0); rearrange_pqr_prq (pts_to r v) frame (pure (fact v1)); star_congruence ((pts_to r v `star` frame) `star` pure (fact v1)) (locks_invariant e m0) ((pts_to r v `star` pure (fact v1)) `star` frame) (locks_invariant e m0); Ghost.hide v1 let iname_for_p_mem (i:iname) (p:slprop) : W.s_predicate mem = fun m -> iname_for_p i p m.locks let iname_for_p_stable (i:iname) (p:slprop) : Lemma (W.stable full_mem mem_evolves (iname_for_p_mem i p)) = () let ( >--> ) (i:iname) (p:slprop) : Type0 = W.witnessed full_mem mem_evolves (iname_for_p_mem i p) let hmem_with_inv_equiv e (m:mem) (p:slprop) : Lemma (interp (p `star` linv e m) m <==> interp (p `star` lock_store_invariant e m.locks) m /\ heap_ctr_valid m.ctr (heap_of_mem m)) = calc (<==>) { interp (p `star` linv e m) m; (<==>) { H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) } interp ((p `star` lock_store_invariant e m.locks) `star` ctr_validity m.ctr (heap_of_mem m)) m; (<==>) { H.pure_star_interp (p `star` lock_store_invariant e m.locks) (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_of_mem m) } interp ((p `star` lock_store_invariant e m.locks) `star` emp) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); (<==>) { H.emp_unit (p `star` lock_store_invariant e m.locks) } interp (p `star` lock_store_invariant e m.locks) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); } let new_invariant_tot_action (e:inames) (p:slprop) (m0:hmem_with_inv_except e p{ e `inames_in` m0.locks }) : Pure (iname & hmem_with_inv_except e emp) (requires True) (ensures fun (i, m1) -> iname_for_p_mem i p m1 /\ frame_related_mems p emp e m0 m1 /\ mem_evolves m0 m1) = let (| i, l1 |) = extend_lock_store e m0.locks p in let m1 = { m0 with locks = l1 } in assert (lock_store_invariant e m1.locks == p `star` lock_store_invariant e m0.locks); calc (equiv) { linv e m1; (equiv) {} (lock_store_invariant e m1.locks `star` ctr_validity m1.ctr (heap_of_mem m1)); (equiv) {} ((p `star` lock_store_invariant e m0.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); (equiv) { H.star_associative p (lock_store_invariant e m0.locks) (ctr_validity m1.ctr (heap_of_mem m1)) } (p `star` (lock_store_invariant e m0.locks `star` ctr_validity m1.ctr (heap_of_mem m1))); (equiv) { } (p `star` linv e m0); }; assert (iname_for_p_mem i p m1); assert (lock_store_evolves m0.locks l1); assert (mem_evolves m0 m1); hmem_with_inv_equiv e m0 p; assert (interp (p `star` lock_store_invariant e m0.locks) m1); assert (interp (lock_store_invariant e m1.locks) m1); H.emp_unit (lock_store_invariant e m1.locks); H.star_commutative (lock_store_invariant e m1.locks) emp; assert (interp (emp `star` lock_store_invariant e m1.locks) m1); hmem_with_inv_equiv e m1 emp; let m1 : hmem_with_inv_except e emp = m1 in let aux (frame:slprop) : Lemma (requires interp ((p `star` frame) `star` linv e m0) m0) (ensures interp ((emp `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) <==> mp (core_mem m1))) [SMTPat (p `star` frame)] = assert (interp ((p `star` frame) `star` linv e m0) m1); calc (equiv) { ((p `star` frame) `star` linv e m0); (equiv) { H.star_commutative p frame; H.star_congruence (p `star` frame) (linv e m0) (frame `star` p) (linv e m0); H.star_associative frame p (linv e m0) } (frame `star` (p `star` linv e m0)); (equiv) { H.star_congruence frame (p `star` linv e m0) frame (linv e m1) } (frame `star` linv e m1); (equiv) { H.emp_unit (frame `star` linv e m1); H.star_commutative (frame `star` linv e m1) emp; H.star_associative emp frame (linv e m1) } ((emp `star` frame) `star` linv e m1); }; assert (interp ((emp `star` frame) `star` linv e m1) m1) in assert (frame_related_mems p emp e m0 m1); ( i, m1 ) let name_is_ok (i:iname) (m0:full_mem u#1) : prop = i < List.Tot.length m0.locks let witnessed_name_is_ok (i:iname) = W.witnessed full_mem mem_evolves (name_is_ok i) let pre_inv = i:erased iname & witnessed_name_is_ok i let inv (p:slprop u#1) = i:erased iname & witnessed_name_is_ok i & (i >--> p) let pre_inv_of_inv #p (i:inv p) = let (|i, w, _|) = i in (|i,w|) let name_of_pre_inv (i:pre_inv) = dfst i let rec recall_all (ctx:list pre_inv) : NMSTTotal.NMSTATETOT unit (full_mem u#1) mem_evolves (requires fun _ -> True) (ensures fun m0 _ m1 -> m0==m1 /\ (forall i. i `List.Tot.memP` ctx ==> name_is_ok (name_of_pre_inv i) m0)) = match ctx with | [] -> () | hd::tl -> let (| q, i |) = hd in let i : W.witnessed full_mem mem_evolves (name_is_ok q) = i in NMSTTotal.recall _ mem_evolves (name_is_ok q) i; recall_all tl let fresh_invariant (e:inames) (p:slprop) (ctx:list pre_inv) (frame:slprop) : MstTot (i:inv p { not (mem_inv e i) /\ fresh_wrt ctx (name_of_inv i)}) e p (fun _ -> emp) frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in recall_all ctx; ac_reasoning_for_m_frame_preserving p frame (locks_invariant e m0) m0; assert (interp (p `star` locks_invariant e m0) m0); let r = new_invariant_tot_action e p m0 in let ( i, m1 ) = r in assert (i == List.Tot.length m0.locks); assert (not (Set.mem i e)); assert (mem_evolves m0 m1); NMSTTotal.put #full_mem #mem_evolves m1; iname_for_p_stable i p; let w = NMSTTotal.witness full_mem mem_evolves (iname_for_p_mem i p) in let w0 = NMSTTotal.witness full_mem mem_evolves (name_is_ok i) in (| hide i, w0, w |) let new_invariant (e:inames) (p:slprop) (frame:slprop) : MstTot (inv p) e p (fun _ -> emp) frame (fun _ -> True) (fun _ _ _ -> True) = fresh_invariant e p [] frame let rearrange_invariant (p q r : slprop) (q0 q1:slprop) : Lemma (requires q `equiv` (q0 `star` q1)) (ensures (p `star` (q `star` r)) `equiv` ((q0 `star` p) `star` (q1 `star` r))) = calc (equiv) { p `star` (q `star` r); (equiv) { calc (equiv) { (q `star` r); (equiv) { star_congruence q r (q0 `star` q1) r } (q0 `star` q1) `star` r; }; star_congruence p (q `star` r) p ((q0 `star` q1) `star` r) } (p `star` ((q0 `star` q1) `star` r)); (equiv) { star_associative q0 q1 r; star_congruence p ((q0 `star` q1) `star` r) p (q0 `star` (q1 `star` r)); star_associative p q0 (q1 `star` r) } (p `star` q0) `star` (q1 `star` r); (equiv) { star_commutative p q0; star_congruence (p `star` q0) (q1 `star` r) (q0 `star` p) (q1 `star` r) } (q0 `star` p) `star` (q1 `star` r); } let preserves_frame_invariant (fp fp':slprop) (opened_invariants:inames) (p:slprop) (i:inv p{not (mem_inv opened_invariants i)}) (m0:hmem_with_inv_except (add_inv opened_invariants i) (p `star` fp)) (m1:mem) : Lemma (requires preserves_frame (set_add (name_of_inv i) opened_invariants) (p `star` fp) (p `star` fp') m0 m1 /\ interp (fp' `star` linv opened_invariants m1) m1 /\ inames_ok opened_invariants m1 /\ (lock_store_invariant opened_invariants m0.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks)) /\ (lock_store_invariant opened_invariants m1.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks))) (ensures preserves_frame opened_invariants fp fp' m0 m1) = let aux (frame:slprop) : Lemma (requires interp ((fp `star` frame) `star` linv opened_invariants m0) m0) (ensures interp ((fp' `star` frame) `star` linv opened_invariants m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) [SMTPat()] = rearrange_invariant (fp `star` frame) (lock_store_invariant opened_invariants m0.locks) (ctr_validity m0.ctr (heap_of_mem m0)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks); assert (interp ((p `star` (fp `star` frame)) `star` linv (set_add (name_of_inv i) opened_invariants) m0) m0); star_associative p fp frame; star_congruence (p `star` (fp `star` frame)) (linv (set_add (name_of_inv i) opened_invariants) m0) ((p `star` fp) `star` frame) (linv (set_add (name_of_inv i) opened_invariants) m0); assert (interp (((p `star` fp) `star` frame) `star` linv (set_add (name_of_inv i) opened_invariants) m0) m0); assert (interp (((p `star` fp') `star` frame) `star` linv (set_add (name_of_inv i) opened_invariants) m1) m1); star_associative p fp' frame; star_congruence ((p `star` fp') `star` frame) (linv (set_add (name_of_inv i) opened_invariants) m1) (p `star` (fp' `star` frame)) (linv (set_add (name_of_inv i) opened_invariants) m1); assert (interp ((p `star` (fp' `star` frame)) `star` linv (set_add (name_of_inv i) opened_invariants) m1) m1); rearrange_invariant (fp' `star` frame) (lock_store_invariant opened_invariants m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks); assert (interp ((fp' `star` frame) `star` linv opened_invariants m1) m1); () in () let equiv_ext_right (p q r:slprop) : Lemma (requires q `equiv` r) (ensures (p `star` q) `equiv` (p `star` r)) = calc (equiv) { p `star` q; (equiv) { star_commutative p q } q `star` p; (equiv) { equiv_extensional_on_star q r p } r `star` p; (equiv) { star_commutative p r } p `star` r; } let with_inv_helper (fp frame ls1 ctr p ls2:slprop) : Lemma (requires ls1 `equiv` (p `star` ls2)) (ensures (fp `star` frame `star` (ls1 `star` ctr)) `equiv` (p `star` fp `star` frame `star` (ls2 `star` ctr))) = calc (equiv) { ls1 `star` ctr; (equiv) { equiv_extensional_on_star ls1 (p `star` ls2) ctr } p `star` ls2 `star` ctr; }; calc (equiv) { p `star` ls2 `star` ctr; (equiv) { star_associative p ls2 ctr } p `star` (ls2 `star` ctr); }; calc (equiv) { fp `star` frame `star` p; (equiv) { star_commutative (fp `star` frame) p } p `star` (fp `star` frame); (equiv) { star_associative p fp frame } p `star` fp `star` frame; }; calc (equiv) { fp `star` frame `star` (ls1 `star` ctr); (equiv) { equiv_ext_right (fp `star` frame) (ls1 `star` ctr) (p `star` ls2 `star` ctr) } (fp `star` frame) `star` (p `star` ls2 `star` ctr); (equiv) { equiv_ext_right (fp `star` frame) (p `star` ls2 `star` ctr) (p `star` (ls2 `star` ctr)) } (fp `star` frame) `star` (p `star` (ls2 `star` ctr)); (equiv) { star_associative (fp `star` frame) p (ls2 `star` ctr) } (fp `star` frame `star` p) `star` (ls2 `star` ctr); (equiv) { equiv_extensional_on_star (fp `star` frame `star` p) (p `star` fp `star` frame) (ls2 `star` ctr) } (p `star` fp `star` frame) `star` (ls2 `star` ctr); } let token_of_inv #p (i:inv p) : (name_of_inv i >--> p) = let (| _, _, tok |) = i in tok let with_invariant (#a:Type) (#fp:slprop) (#fp':a -> slprop) (#opened_invariants:inames) (#p:slprop) (i:inv p{not (mem_inv opened_invariants i)}) (f:action_except a (add_inv opened_invariants i) (p `star` fp) (fun x -> p `star` fp' x)) (frame:slprop) : MstTot a opened_invariants fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in NMSTTotal.recall _ mem_evolves (iname_for_p_mem (name_of_inv i) p) (token_of_inv i); assert (iname_for_p (name_of_inv i) p m0.locks); assert (interp (fp `star` frame `star` locks_invariant opened_invariants m0) m0); assert (interp (fp `star` frame `star` (lock_store_invariant opened_invariants m0.locks `star` ctr_validity m0.ctr (heap_of_mem m0))) m0); move_invariant opened_invariants m0.locks p (name_of_inv i); assert (lock_store_invariant opened_invariants m0.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks)); with_inv_helper fp frame (lock_store_invariant opened_invariants m0.locks) (ctr_validity m0.ctr (heap_of_mem m0)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks); assert (interp (p `star` fp `star` frame `star` locks_invariant (set_add (name_of_inv i) opened_invariants) m0) m0); let r = f frame in let m1 : full_mem = NMSTTotal.get () in assert (interp (p `star` fp' r `star` frame `star` locks_invariant (set_add (name_of_inv i) opened_invariants) m1) m1); assert (interp (p `star` fp' r `star` frame `star` (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks `star` ctr_validity m1.ctr (heap_of_mem m1))) m1); NMSTTotal.recall _ mem_evolves (iname_for_p_mem (name_of_inv i) p) (token_of_inv i); move_invariant opened_invariants m1.locks p (name_of_inv i); assert (lock_store_invariant opened_invariants m1.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks)); with_inv_helper (fp' r) frame (lock_store_invariant opened_invariants m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks); assert (interp (fp' r `star` frame `star` locks_invariant opened_invariants m1) m1); assert (inames_ok opened_invariants m1); r let equiv_pqrs_p_qr_s (p q r s:slprop) : Lemma ((p `star` q `star` r `star` s) `equiv` (p `star` (q `star` r) `star` s)) = star_associative p q r; equiv_extensional_on_star (p `star` q `star` r) (p `star` (q `star` r)) s let frame (#a:Type) (#opened_invariants:inames) (#pre:slprop) (#post:a -> slprop) (#req:mprop pre) (#ens:mprop2 pre post) (frame:slprop) ($f:action_except_full a opened_invariants pre post req ens) (frame0:slprop) : MstTot a opened_invariants (pre `star` frame) (fun x -> post x `star` frame) frame0 req ens = let m0 : full_mem = NMSTTotal.get () in equiv_pqrs_p_qr_s pre frame frame0 (linv opened_invariants m0); assert (interp (pre `star` frame `star` frame0 `star` linv opened_invariants m0) m0); assert (interp (pre `star` (frame `star` frame0) `star` linv opened_invariants m0) m0); let x = f (frame `star` frame0) in let m1 : full_mem = NMSTTotal.get () in equiv_pqrs_p_qr_s (post x) frame frame0 (linv opened_invariants m1); assert (interp (post x `star` (frame `star` frame0) `star` linv opened_invariants m1) m1); assert (interp (post x `star` frame `star` frame0 `star` linv opened_invariants m1) m1); x let change_slprop (#opened_invariants:inames) (p q:slprop) (proof: (m:mem -> Lemma (requires interp p m) (ensures interp q m))) = let proof (h:H.heap) : Lemma (requires H.interp p h) (ensures H.interp q h) = proof (mem_of_heap h) in lift_tot_action (lift_heap_action opened_invariants (Steel.Heap.change_slprop p q proof)) (* This module reuses is_frame_monotonic from Heap, but does not expose that to clients, so we need this lemma to typecheck witness_h_exists below. *) let relate_frame_monotonic_1 #a p : Lemma (requires (H.is_frame_monotonic p)) (ensures (is_frame_monotonic p)) = () let relate_frame_monotonic_2 #a p : Lemma (requires (is_frame_monotonic p)) (ensures (H.is_frame_monotonic p)) = let aux (x y : a) (h : H.heap) (f : H.slprop) : Lemma (requires (H.interp (p x `H.star` f) h /\ H.interp (p y) h)) (ensures (H.interp (p y `H.star` f) h)) = let m = mem_of_heap h in assert (interp (p x `star` f) m); assert (interp (p y) m); assert (interp (p y `star` f) m) in Classical.forall_intro_4 (fun x y h f -> Classical.move_requires (aux x y h) f) let witness_h_exists #opened_invariants #a p = lift_tot_action_with_frame (lift_heap_action_with_frame opened_invariants (H.witness_h_exists p)) let lift_h_exists #opened_invariants p = lift_tot_action (lift_heap_action opened_invariants (H.lift_h_exists p)) let elim_pure #opened_invariants p = lift_tot_action (lift_heap_action opened_invariants (H.elim_pure p)) let pts_to_join (#a:Type) (#pcm:pcm a) (r:ref a pcm) (x y : a) (m:mem) : Lemma (requires (interp (pts_to r x) m /\ interp (pts_to r y) m)) (ensures (joinable pcm x y)) = H.pts_to_join #a #pcm r x y (heap_of_mem m) let pts_to_evolve (#a:Type u#a) (#pcm:_) (r:ref a pcm) (x y : a) (m:mem) : Lemma (requires (interp (pts_to r x) m /\ compatible pcm y x)) (ensures (interp (pts_to r y) m)) = H.pts_to_evolve #a #pcm r x y (heap_of_mem m) let id_elim_star p q m = let starprop (ml:mem) (mr:mem) = disjoint ml mr /\ m == join ml mr /\ interp p ml /\ interp q mr in elim_star p q m; let p1 : mem -> prop = fun ml -> (exists mr. starprop ml mr) in let ml = IndefiniteDescription.indefinite_description_tot _ p1 in let starpropml mr : prop = starprop ml mr in // this prop annotation seems needed let mr = IndefiniteDescription.indefinite_description_tot _ starpropml in (ml, mr) let id_elim_exists #a p m = let existsprop (x:a) = interp (p x) m in elim_h_exists p m; let x = IndefiniteDescription.indefinite_description_tot _ existsprop in x let slimp_star (p q r s : slprop) : Lemma (requires (slimp p q /\ slimp r s)) (ensures (slimp (p `star` r) (q `star` s))) = let aux (m:mem) : Lemma (requires (interp (p `star` r) m)) (ensures (interp (q `star` s) m)) = let (ml, mr) = id_elim_star p r m in intro_star q s ml mr in Classical.forall_intro (Classical.move_requires aux) let elim_wi #a (p : a -> slprop{is_witness_invariant p}) (x y : a) (m : mem) : Lemma (requires (interp (p x) m /\ interp (p y) m)) (ensures (x == y)) = () let witinv_framon (#a:Type) (p : a -> slprop) : Lemma (is_witness_invariant p ==> is_frame_monotonic p) [SMTPatOr [[SMTPat (is_witness_invariant p)]; [SMTPat (is_frame_monotonic p)]]] = ()

{ "checked_file": "/", "dependencies": [ "Steel.Preorder.fst.checked", "Steel.Heap.fsti.checked", "prims.fst.checked", "FStar.Witnessed.Core.fsti.checked", "FStar.Set.fsti.checked", "FStar.Preorder.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.PCM.fst.checked", "FStar.NMSTTotal.fst.checked", "FStar.List.Tot.fst.checked", "FStar.IndefiniteDescription.fsti.checked", "FStar.Ghost.fsti.checked", "FStar.FunctionalExtensionality.fsti.checked", "FStar.Classical.Sugar.fsti.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Steel.Memory.fst" }

[ { "abbrev": true, "full_module": "Steel.Preorder", "short_module": "PP" }, { "abbrev": true, "full_module": "FStar.Witnessed.Core", "short_module": "W" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": true, "full_module": "Steel.Heap", "short_module": "H" }, { "abbrev": false, "full_module": "FStar.FunctionalExtensionality", "short_module": null }, { "abbrev": true, "full_module": "FStar.FunctionalExtensionality", "short_module": "F" }, { "abbrev": true, "full_module": "FStar.Universe", "short_module": "U" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": false, "full_module": "FStar.PCM", "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

f: (_: a -> Steel.Memory.slprop) -> g: (_: a -> Steel.Memory.slprop) -> FStar.Pervasives.Lemma (requires Steel.Memory.is_frame_monotonic f /\ Steel.Memory.is_frame_monotonic g) (ensures Steel.Memory.is_frame_monotonic (fun x -> Steel.Memory.star (f x) (g x)))

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Steel.Memory.slprop", "Prims.unit", "FStar.Classical.forall_intro_4", "Steel.Memory.mem", "Prims.l_imp", "Prims.l_and", "Steel.Memory.interp", "Steel.Memory.star", "FStar.Classical.move_requires", "Prims.l_True", "Prims.squash", "Prims.Nil", "FStar.Pervasives.pattern", "FStar.Ghost.erased", "Prims._assert", "Steel.Memory.star_associative", "Steel.Memory.star_congruence", "Steel.Memory.star_commutative", "Steel.Memory.affine_star", "FStar.Pervasives.Native.tuple2", "Steel.Memory.id_elim_star", "FStar.Ghost.reveal", "Steel.Memory.is_frame_monotonic" ]

[]

false

true

false

let star_is_frame_monotonic (#a: Type) (f g: (a -> slprop)) : Lemma (requires (is_frame_monotonic f /\ is_frame_monotonic g)) (ensures (is_frame_monotonic (fun x -> (f x) `star` (g x)))) =

let aux (x y: a) (m: mem) (frame: slprop) : Lemma (requires interp (((f x) `star` (g x)) `star` frame) m /\ interp ((f y) `star` (g y)) m) (ensures (interp (((f y) `star` (g y)) `star` frame) m)) = star_associative (f x) (g x) frame; let m1, m23 = id_elim_star (f x) ((g x) `star` frame) m in let m2, m3 = id_elim_star (g x) frame m23 in affine_star (f y) (g y) m; assert (interp (f y) m); assert (interp (g y) m); assert (interp ((f x) `star` ((g x) `star` frame)) m); assert (interp ((f y) `star` ((g x) `star` frame)) m); star_associative (f y) (g x) frame; star_commutative (f y) (g x); star_congruence ((f y) `star` (g x)) frame ((g x) `star` (f y)) frame; star_associative (g x) (f y) frame; assert (interp ((g x) `star` ((f y) `star` frame)) m); assert (interp ((g y) `star` ((f y) `star` frame)) m); star_associative (f y) (g y) frame; star_commutative (f y) (g y); star_congruence ((f y) `star` (g y)) frame ((g y) `star` (f y)) frame; star_associative (g y) (f y) frame; assert (interp ((f y) `star` ((g y) `star` frame)) m); () in Classical.forall_intro_4 (fun x y m -> Classical.move_requires (aux x y m)); ()

false

Steel.Memory.fst

Steel.Memory.id_elim_exists

val id_elim_exists (#a:Type) (p : a -> slprop) (m:mem) : Pure (erased a) (requires (interp (h_exists p) m)) (ensures (fun x -> interp (p x) m))

let id_elim_exists #a p m = let existsprop (x:a) = interp (p x) m in elim_h_exists p m; let x = IndefiniteDescription.indefinite_description_tot _ existsprop in x

{ "file_name": "lib/steel/Steel.Memory.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 3, "end_line": 1590, "start_col": 0, "start_line": 1584 }

(* 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.Memory module F = FStar.FunctionalExtensionality open FStar.FunctionalExtensionality open FStar.PCM module H = Steel.Heap noeq type lock_state : Type u#(a + 1) = | Invariant : inv:H.slprop u#a -> lock_state let lock_store : Type u#(a+1) = list (lock_state u#a) noeq type mem : Type u#(a + 1) = { ctr: nat; heap: H.heap u#a; locks: lock_store u#a; } let heap_of_mem (x:mem) : H.heap = x.heap let mem_of_heap (h:H.heap) : mem = { ctr = 0; heap = h; locks = [] } let mem_set_heap (m:mem) (h:H.heap) : mem = { ctr = m.ctr; heap = h; locks = m.locks; } let core_mem (m:mem) : mem = mem_of_heap (heap_of_mem m) let core_mem_invol m = () let disjoint (m0 m1:mem u#h) : prop = m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks let disjoint_sym m0 m1 = () let join m0 m1 = { ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = m0.locks } let join_commutative m0 m1 = H.join_commutative m0.heap m1.heap let disjoint_join m0 m1 m2 = H.disjoint_join m0.heap m1.heap m2.heap let join_associative m0 m1 m2 = H.join_associative m0.heap m1.heap m2.heap let slprop = H.slprop let interp p m = H.interp p m.heap let equiv p1 p2 = forall m. interp p1 m <==> interp p2 m let slprop_extensionality p q = assert (forall m. interp p m <==> interp q m); let aux (h:H.heap) : Lemma (H.interp p h <==> H.interp q h) [SMTPat (H.interp p h)] = let m : mem = { ctr = 0; heap = h; locks = [] } in assert (interp p m <==> interp q m) in assert (forall h. H.interp p h <==> H.interp q h); Steel.Heap.slprop_extensionality p q let reveal_equiv p1 p2 = () let core_ref = H.core_ref let core_ref_null = H.core_ref_null let core_ref_is_null r = H.core_ref_is_null r let emp : slprop u#a = H.emp let pure = H.pure let pts_to = H.pts_to let h_and = H.h_and let h_or = H.h_or let star = H.star let wand = H.wand let h_exists = H.h_exists let h_forall = H.h_forall //////////////////////////////////////////////////////////////////////////////// //properties of equiv //////////////////////////////////////////////////////////////////////////////// let equiv_symmetric (p1 p2:slprop u#a) = H.equiv_symmetric p1 p2 #push-options "--warn_error -271" let equiv_heap_iff_equiv (p1 p2:slprop u#a) : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat (equiv p1 p2)] = let aux_lr () : Lemma (requires H.equiv p1 p2) (ensures equiv p1 p2) [SMTPat ()] = () in let aux_rl_helper1 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p1 h) (ensures H.interp p2 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl_helper2 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p2 h) (ensures H.interp p1 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl () : Lemma (requires equiv p1 p2) (ensures H.equiv p1 p2) [SMTPat ()] = () in () let equiv_heap_iff_equiv_forall () : Lemma (ensures (forall p1 p2. H.equiv p1 p2 <==> equiv p1 p2)) = let aux p1 p2 : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat ()] = equiv_heap_iff_equiv p1 p2 in () #pop-options let equiv_extensional_on_star (p1 p2 p3:slprop u#a) = equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3 let emp_unit p = H.emp_unit p let intro_emp m = H.intro_emp (heap_of_mem m) let pure_equiv p q = H.pure_equiv p q let pure_interp q m = H.pure_interp q (heap_of_mem m) let pure_star_interp p q m = H.pure_star_interp p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// //pts_to //////////////////////////////////////////////////////////////////////////////// let pts_to_compatible #a #pcm x v0 v1 m = H.pts_to_compatible #a #pcm x v0 v1 (heap_of_mem m) let pts_to_compatible_equiv #a #pcm x v0 v1 = H.pts_to_compatible_equiv #a #pcm x v0 v1 let pts_to_not_null #a #pcm x v m = H.pts_to_not_null #a #pcm x v (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // star //////////////////////////////////////////////////////////////////////////////// let intro_star p q mp mq = H.intro_star p q (heap_of_mem mp) (heap_of_mem mq) let elim_star p q m = let h = heap_of_mem m in H.elim_star p q h; assert (exists hl hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr); let hl = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hl -> exists hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let hr = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hr -> H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let ml = mem_set_heap m hl in let mr = mem_set_heap m hr in assert (disjoint ml mr); assert (m == join ml mr); assert (interp p ml); assert (interp q mr); () let interp_star (p q: slprop) (m: mem) : Lemma (interp (p `star` q) m <==> (exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m)) = let left = interp (p `star` q) m in let right = exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m in let f () : Lemma (requires left) (ensures right) = elim_star p q m in let g () : Lemma (requires right) (ensures left) = Classical.exists_elim left #_ #(fun mp -> exists (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mp -> Classical.exists_elim left #_ #(fun mq -> disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mq -> intro_star p q mp mq ) ) in Classical.move_requires f (); Classical.move_requires g () let star_commutative (p1 p2:slprop) = H.star_commutative p1 p2 let star_associative (p1 p2 p3:slprop) = H.star_associative p1 p2 p3 let star_congruence (p1 p2 p3 p4:slprop) = equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4 let affine_star (p q:slprop) (m:mem) = H.affine_star p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // Invariants on the lock store //////////////////////////////////////////////////////////////////////////////// let iname = nat module S = FStar.Set module L = FStar.List.Tot module W = FStar.Witnessed.Core let rec lock_store_invariant (e:inames) (l:lock_store u#a) : slprop u#a = let current_addr = L.length l - 1 in match l with | [] -> emp | Invariant p :: tl -> if current_addr `S.mem` e then lock_store_invariant e tl else p `star` lock_store_invariant e tl let lock_i (i:iname) (l:lock_store { i < L.length l }) = let ix = L.length l - i - 1 in L.index l ix let iname_for_p (i:iname) (p:slprop) : W.s_predicate lock_store = fun l -> i < L.length l /\ (lock_i i l).inv == p let lock_store_evolves : FStar.Preorder.preorder lock_store = fun (l1 l2 : lock_store) -> L.length l2 >= L.length l1 /\ (forall (i:nat{i < L.length l1}). (lock_i i l1).inv == (lock_i i l2).inv) let inames_in (e:inames) (l:lock_store) : prop = forall i. Set.mem i e ==> i < L.length l let inames_ok e m = inames_in e m.locks let inames_ok_empty m = () let extend_lock_store (e:inames) (l:lock_store{e `inames_in` l}) (p:slprop) : i:iname & l':lock_store { lock_store_invariant e l' == p `star` lock_store_invariant e l /\ iname_for_p i p l' } = (| L.length l, Invariant p :: l |) let set_add (i:iname) (s:inames) = Set.union (Set.singleton i) s let rec move_invariant (e:inames) (l:lock_store) (p:slprop) (i:iname{iname_for_p i p l /\ ~(i `Set.mem` e)}) : Lemma (H.equiv (lock_store_invariant e l) (p `star` lock_store_invariant (set_add i e) l)) = let rec aux (i:iname) (m:lock_store) : Lemma (requires i >= L.length m) (ensures (lock_store_invariant e m `H.equiv` lock_store_invariant (set_add i e) m)) = match m with | [] -> () | Invariant p::tl -> aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl) in let current_addr = L.length l - 1 in match l with | [] -> () | Invariant q::tl -> if i = current_addr then begin assert (lock_store_invariant e l == p `star` lock_store_invariant e tl); aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl); () end else begin move_invariant e tl p i; assert (lock_store_invariant e tl `equiv` (p `star` lock_store_invariant (set_add i e) tl)); H.star_congruence q (lock_store_invariant e tl) q (p `star` lock_store_invariant (set_add i e) tl); if Set.mem current_addr e then () else begin let r = lock_store_invariant (set_add i e) tl in assert (lock_store_invariant e l `equiv` (q `star` (p `star` r))); H.star_associative q p r; H.star_commutative q p; H.star_congruence (q `star` p) r (p `star` q) r; H.star_associative p q r end end let heap_ctr_valid (ctr:nat) (h:H.heap u#a) : prop = h `H.free_above_addr` ctr let ctr_validity (ctr:nat) (h:H.heap) : slprop = H.pure (heap_ctr_valid ctr h) let locks_invariant (e:inames) (m:mem u#a) : slprop u#a = lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m) let full_mem_pred (m:mem) = H.full_heap_pred (heap_of_mem m) (***** Following lemmas are needed in Steel.Effect *****) let core_mem_interp (hp:slprop u#a) (m:mem u#a) = () let interp_depends_only_on (hp:slprop u#a) = H.interp_depends_only_on hp let a_mem_prop_as_a_heap_prop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (H.a_heap_prop u#a) = let g (h: H.heap u#a) : Tot prop = interp sl (mem_of_heap h) /\ f (mem_of_heap h) in let phi0 (h0 h1: H.heap u#a) : Lemma (requires (g h0 /\ H.disjoint h0 h1)) (ensures (g h0 /\ H.disjoint h0 h1 /\ g (H.join h0 h1))) = assert (mem_of_heap (H.join h0 h1) == mem_of_heap h0 `join` mem_of_heap h1); interp_depends_only_on sl in let phi1 (h0 h1: H.heap u#a) : Lemma (ensures ((g h0 /\ H.disjoint h0 h1) ==> g (H.join h0 h1))) = Classical.move_requires (phi0 h0) h1 in Classical.forall_intro_2 phi1; g let refine_slprop sl f = H.as_slprop (a_mem_prop_as_a_heap_prop sl f) let interp_refine_slprop sl f m = assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_mem m)) let dep_hprop (s: slprop) (f: (hmem s -> Tot slprop)) (h: H.heap) : Tot prop = exists (h1: H.heap) . exists (h2: H.heap) . interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 let dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq' : squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h')) = let p2 (h h1 h2: H.heap) : Tot prop = interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 in let p1 (h h1: H.heap) : Tot prop = (exists h2 . p2 h h1 h2) in let h1 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p1 h) in let h2 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p2 h h1) in H.disjoint_join h' h1 h2; assert (H.disjoint h2 h'); let h2' = H.join h2 h' in H.join_commutative h2 h' ; assert (h2' == H.join h' h2); assert (H.disjoint h1 h2'); assert (mem_of_heap h2' == mem_of_heap h2 `join` mem_of_heap h'); interp_depends_only_on (f (mem_of_heap h1)); assert (interp (f (mem_of_heap h1)) (mem_of_heap h2')); H.join_commutative h1 h2; H.join_associative h' h2 h1; H.join_commutative h' h; H.join_commutative h2' h1; assert (H.join h h' == h1 `H.join` h2') let impl_intro_gen (#p: Type0) (#q: Type0) ($prf: (squash p -> Lemma (q ))) : Lemma (p ==> q) = Classical.impl_intro_gen #p #(fun _ -> q) prf let dep_hprop_is_affine1 (s: slprop) (f: (hmem s -> Tot slprop)) (h0 h1: H.heap) : Lemma ((dep_hprop s f h0 /\ H.disjoint h0 h1) ==> (H.disjoint h0 h1 /\ dep_hprop s f (H.join h0 h1))) = impl_intro_gen (dep_hprop_is_affine0 s f h0 h1) let dep_hprop_is_affine (s: slprop) (f: (hmem s -> Tot slprop)) : Lemma (H.heap_prop_is_affine (dep_hprop s f)) = Classical.forall_intro_2 (dep_hprop_is_affine1 s f) let sdep (s: slprop) (f: (hmem s -> Tot slprop)) : Tot slprop = dep_hprop_is_affine s f; H.as_slprop (dep_hprop s f) let interp_sdep (s: slprop) (f: (hmem s -> Tot slprop)) (m: mem) : Lemma (requires (dep_slprop_is_affine s f)) (ensures ( interp (sdep s f) m <==> (exists m1 m2 . interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) )) = dep_hprop_is_affine s f; assert (forall m1 m2 . (interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) ==> ( interp s (mem_of_heap m1.heap) /\ interp (f (mem_of_heap m1.heap)) (mem_of_heap m2.heap) /\ H.disjoint m1.heap m2.heap /\ H.join m1.heap m2.heap == m.heap )); interp_depends_only_on s; Classical.forall_intro (fun m -> interp_depends_only_on (f m)); assert (forall h1 h2 . (interp s (mem_of_heap h1) /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ H.disjoint h1 h2 /\ H.join h1 h2 == m.heap) ==> ( core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ interp s (core_mem (mem_of_heap h1)) /\ interp s (mem_set_heap m h1) /\ core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ f (mem_set_heap m h1) `equiv` f (mem_of_heap h1) /\ interp (f (mem_set_heap m h1)) (mem_of_heap h2) /\ interp (f (mem_set_heap m h1)) (mem_set_heap m h2) /\ disjoint (mem_set_heap m h1) (mem_set_heap m h2) /\ join (mem_set_heap m h1) (mem_set_heap m h2) == m )); () let h_exists_cong (#a:Type) (p q : a -> slprop) : Lemma (requires (forall x. p x `equiv` q x)) (ensures (h_exists p `equiv` h_exists q)) = equiv_heap_iff_equiv_forall (); H.h_exists_cong p q let intro_h_exists #a x p m = H.intro_h_exists x p (heap_of_mem m) let elim_h_exists (#a:_) (p:a -> slprop) (m:mem) = H.elim_h_exists p (heap_of_mem m) let intro_h_forall (#a:_) (p:a -> slprop) (m:mem) = H.intro_h_forall p (heap_of_mem m) let elim_h_forall (#a:_) (p:a -> slprop) (m:mem) (x:a) = H.elim_h_forall p (heap_of_mem m) x let intro_h_and (p q: slprop) (m:mem) = H.intro_h_and p q (heap_of_mem m) let elim_h_and (p q: slprop) (m:mem) = H.elim_h_and p q (heap_of_mem m) let intro_h_or_left (p q: slprop) (m:mem) = H.intro_h_or_left p q (heap_of_mem m) let intro_h_or_right (p q: slprop) (m:mem) = H.intro_h_or_right p q (heap_of_mem m) let elim_h_or (p q: slprop) (m:mem) = H.elim_h_or p q (heap_of_mem m) let intro_wand (p1 p2: slprop u#a) (m:mem) = introduce (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)) ==> interp (wand p1 p2) m with _. ( assert (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)); H.intro_wand p1 p2 (heap_of_mem m); let h = heap_of_mem m in assert ((forall h1. h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) ==> H.interp (wand p1 p2) h); introduce forall h1. (h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) with ( introduce (h `H.disjoint` h1 /\ H.interp p1 h1) ==> H.interp p2 (H.join h h1) with _. ( assert (h `H.disjoint` h1); let m1 = { ctr = m.ctr; heap = h1; locks = m.locks } in assert (m `disjoint` m1) ) ) ) (** Eliminating a wand by proving a heap that satisfies the LHS **) let elim_wand (p1 p2: slprop u#a) (m:mem) (m1:mem) = H.elim_wand p1 p2 (heap_of_mem m) (heap_of_mem m1) //////////////////////////////////////////////////////////////////////////////// // Preorders and effects //////////////////////////////////////////////////////////////////////////////// module PP = Steel.Preorder let mem_evolves = fun (m0 m1:full_mem) -> H.heap_evolves (heap_of_mem m0) (heap_of_mem m1) /\ m0.ctr <= m1.ctr /\ lock_store_evolves m0.locks m1.locks (** See [Steel.Heap.is_frame_preserving]. We add in [lock_invariants] now *) let preserves_frame (e:inames) (pre post:slprop) (m0 m1:mem) = forall (frame:slprop). interp ((pre `star` frame) `star` locks_invariant e m0) m0 ==> (interp ((post `star` frame) `star` locks_invariant e m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) (** This is a version of MstTot with frame quantified, as part of preserves_frame *) effect MstTotNF (a:Type u#a) (except:inames) (expects:slprop u#1) (provides: a -> slprop u#1) = NMSTTotal.NMSTATETOT a (full_mem u#1) mem_evolves (requires fun m0 -> inames_ok except m0 /\ interp (expects `star` locks_invariant except m0) m0) (ensures fun m0 x m1 -> inames_ok except m1 /\ interp (provides x `star` locks_invariant except m1) m1 /\ preserves_frame except expects (provides x) m0 m1) //////////////////////////////////////////////////////////////////////////////// // Lifting heap actions //////////////////////////////////////////////////////////////////////////////// (** Heap actions come in two equivalent flavors: - one that take an explicit frame as argument (action_with_frame) - and one that quantify over all the frame We therefore define two lift routes: - a direct route for those with explicit frame - via MstTotNF for the rest *) let tot_pre_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = hmem_with_inv_except e fp -> (x:a & hmem_with_inv_except e (fp' x)) let tot_pre_action_nf = tot_pre_action_nf_except S.empty let ac_reasoning_for_m_frame_preserving (p q r:slprop u#a) (m:mem u#a) : Lemma (requires interp ((p `star` q) `star` r) m) (ensures interp (p `star` r) m) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_commutative p q; equiv_extensional_on_star (p `star` q) (q `star` p) r } (q `star` p) `star` r; (equiv) { star_associative q p r } q `star` (p `star` r); }; assert (interp (q `star` (p `star` r)) m); affine_star q (p `star` r) m let is_frame_preserving (#e:inames) (#a:Type u#b) (#fp:slprop u#a) (#fp':a -> slprop u#a) (f:tot_pre_action_nf_except e fp a fp') = forall (frame:slprop u#a) (m0:hmem_with_inv_except e (fp `star` frame)). (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = f:tot_pre_action_nf_except e fp a fp'{ is_frame_preserving f } let tot_action_nf = tot_action_nf_except S.empty let linv e (m:mem) = locks_invariant e m let hheap_of_hmem #fp #e (m:hmem_with_inv_except e fp) : h:H.hheap (fp `star` linv e m) { h `H.free_above_addr` m.ctr} = let h = heap_of_mem m in H.pure_interp (heap_ctr_valid m.ctr (heap_of_mem m)) h; h let hmem_of_hheap #e (#fp0 #fp1:slprop) (m:hmem_with_inv_except e fp0) (h:H.full_hheap (fp1 `star` linv e m) { h `Heap.free_above_addr` m.ctr }) : m1:hmem_with_inv_except e fp1{linv e m `equiv` linv e m1} = let m1 : mem = { m with heap = h } in assert (interp (fp1 `star` linv e m) m1); star_commutative fp1 (linv e m); assert (interp (linv e m `star` fp1) m1); assert (linv e m1 == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); assert (linv e m == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m)); H.pure_interp (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_of_mem m); assert (heap_ctr_valid m1.ctr (heap_of_mem m) <==> heap_ctr_valid m1.ctr (heap_of_mem m1)); H.pure_equiv (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_ctr_valid m1.ctr (heap_of_mem m1)); H.star_congruence (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m)); assert (linv e m `equiv` linv e m1); let _ = equiv_extensional_on_star (linv e m) (linv e m1) fp1 in assert ((linv e m `star` fp1) `equiv` (linv e m1 `star` fp1)); assert (interp (linv e m1 `star` fp1) m1); star_commutative (linv e m1) fp1; assert (interp (fp1 `star` linv e m1) m1); m1 let with_inv_except (m:mem) e (fp:slprop) = interp (fp `star` locks_invariant e m) m #push-options "--warn_error -271" let as_hprop (frame:slprop) (mp:mprop frame) : hp:H.hprop frame{forall m. mp (core_mem m) == hp (heap_of_mem m)} = let f = fun h -> mp (mem_of_heap h) in assert (forall m. mp (core_mem m) == f (heap_of_mem m)); let aux (m0:H.hheap frame) (m1:H.heap{H.disjoint m0 m1}) : Lemma (ensures (mem_of_heap (H.join m0 m1) == join (mem_of_heap m0) (mem_of_heap m1))) [SMTPat ()] = () in f let mprop_preservation_of_hprop_preservation (p:slprop) (m0 m1:mem) : Lemma (requires (forall (hp:H.hprop p). hp (heap_of_mem m0) == hp (heap_of_mem m1))) (ensures (forall (mp:mprop p). mp (core_mem m0) == mp (core_mem m1))) = let aux (mp:mprop p) : Lemma (mp (core_mem m0) == mp (core_mem m1)) [SMTPat()] = assert (as_hprop p mp (heap_of_mem m0) == as_hprop p mp (heap_of_mem m1)) in () let lift_heap_action (#fp:slprop) (#a:Type) (#fp':a -> slprop) (e:inames) ($f:H.action fp a fp') : tot_action_nf_except e fp a fp' = let g : tot_pre_action_nf_except e fp a fp' = fun m -> let h0 = hheap_of_hmem m in let (| x, h' |) = f h0 in (| x, hmem_of_hheap m h' |) in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in let h0 = hheap_of_hmem m0 in let (| x', h1 |) = f h0 in H.action_framing f (linv e m0) h0; assert (x == x'); star_associative fp frame (linv e m0); H.action_framing f (frame `star` linv e m0) h0; assert (H.interp ((fp' x) `star` (frame `star` linv e m0)) h1); star_associative (fp' x) frame (linv e m0); assert (H.interp ((fp' x `star` frame) `star` linv e m0) h1); let h1' : H.hheap ((fp' x `star` frame) `star` linv e m0) = h1 in assert (m1 == hmem_of_hheap m0 h1'); assert (with_inv_except m1 e (fp' x `star` frame)); assert (forall (hp:H.hprop frame). hp h0 == hp h1); mprop_preservation_of_hprop_preservation frame m0 m1; () in assert (is_frame_preserving g); g let frame_preserving_respects_preorder #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (m0:hmem_with_inv_except e fp) : Lemma (let (| x, m1 |) = f m0 in mem_evolves m0 m1) = let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1) = () in H.emp_unit fp; assert (interp (fp `star` linv e m0) m0); H.star_congruence (fp `star` emp) (linv e m0) fp (linv e m0); assert (interp ((fp `star` emp) `star` linv e m0) m0); aux emp m0 let lift_tot_action_nf #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') : MstTotNF a e fp fp' = let m0 = NMSTTotal.get () in let m0' : hmem_with_inv_except e fp = m0 in let r = f m0' in let (| x, m1 |) = r in let m1' : hmem_with_inv_except e (fp' x) = m1 in assert (is_frame_preserving f); assert (m1 == dsnd (f m0)); frame_preserving_respects_preorder f m0; NMSTTotal.put #_ #(mem_evolves) m1; x let lift_tot_action #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get #(full_mem) #_ () in ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); lift_tot_action_nf f (** Now defining the lift for heap actions with explicit frame *) let tot_action_with_frame_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = frame:slprop u#a -> m0:hmem_with_inv_except e (fp `star` frame) -> Pure (x:a & hmem_with_inv_except e (fp' x `star` frame)) (requires True) (ensures fun (| x, m1 |) -> mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_with_frame = tot_action_with_frame_except S.empty let lift_heap_action_with_frame (#fp:slprop u#a) (#a:Type u#b) (#fp':a -> slprop u#a) (e:inames) ($f:H.action_with_frame fp a fp') : tot_action_with_frame_except e fp a fp' = fun frame m0 -> let h0 = hheap_of_hmem m0 in calc (equiv) { fp `star` frame `star` locks_invariant e m0; (equiv) { star_associative fp frame (locks_invariant e m0) } fp `star` (frame `star` locks_invariant e m0); }; assert (H.interp (fp `star` frame `star` locks_invariant e m0) h0); assert (H.interp (fp `star` (frame `star` locks_invariant e m0)) h0); //key: apply the heap action with frame * locks_invariant e m0 let (| x, h1 |) = f (frame `star` locks_invariant e m0) h0 in calc (equiv) { fp' x `star` (frame `star` locks_invariant e m0); (equiv) { star_associative (fp' x) frame (locks_invariant e m0) } fp' x `star` frame `star` locks_invariant e m0; }; assert (H.interp (fp' x `star` (frame `star` locks_invariant e m0)) h1); assert (H.interp (fp' x `star` frame `star` locks_invariant e m0) h1); let m1 = hmem_of_hheap m0 h1 in assert (mem_evolves m0 m1); mprop_preservation_of_hprop_preservation (frame `star` locks_invariant e m0) m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)); (| x, m1 |) let lift_tot_action_with_frame #a #e #fp #fp' ($f:tot_action_with_frame_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in assert (inames_ok e m0); ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); let m0' : hmem_with_inv_except e fp = m0 in let r = f frame m0' in let (| x, m1 |) = r in ac_reasoning_for_m_frame_preserving (fp' x) frame (locks_invariant e m1) m1; assert (interp (fp' x `star` frame `star` locks_invariant e m1) m1); assert (interp (fp' x `star` locks_invariant e m1) m1); let m1' : hmem_with_inv_except e (fp' x) = m1 in NMSTTotal.put #_ #(mem_evolves) m1; x let sel_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.sel_action #a #pcm r v0)) let upd_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.upd_action #a #pcm r v0 v1)) let free_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.free_action #a #pcm r v0)) let split_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.split_action #a #pcm r v0 v1)) let gather_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.gather_action #a #pcm r v0 v1)) let weaken (p q r:slprop) (h:H.hheap (p `star` q) { H.stronger q r }) : H.hheap (p `star` r) = H.weaken p q r h; h let weaken_pure (q r: prop) : Lemma (requires (q ==> r)) (ensures H.stronger (H.pure q) (H.pure r)) = let aux (h:H.heap) : Lemma (ensures (H.interp (H.pure q) h ==> H.interp (H.pure r) h)) [SMTPat ()] = H.pure_interp q h; H.pure_interp r h in () let inc_ctr (#p:slprop) #e (m:hmem_with_inv_except e p) : m':hmem_with_inv_except e p{m'.ctr = m.ctr + 1 /\ H.stronger (linv e m) (linv e m')} = let m' : mem = { m with ctr = m.ctr + 1} in assert (interp (p `star` linv e m) m'); assert (linv e m == lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m)); assert (linv e m' == lock_store_invariant e m.locks `star` ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken_free_above (heap_of_mem m) m.ctr (m.ctr + 1); weaken_pure (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_ctr_valid (m.ctr + 1) (heap_of_mem m)); assert (H.stronger (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m))); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)); H.stronger_star (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken (p `star` lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)) (heap_of_mem m'); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity (m.ctr + 1) (heap_of_mem m)); let m' : hmem_with_inv_except e p = m' in m' let frame_related_mems (fp0 fp1:slprop u#a) e (m0:hmem_with_inv_except e fp0) (m1:hmem_with_inv_except e fp1) = forall (frame:slprop u#a). interp ((fp0 `star` frame) `star` linv e m0) m0 ==> interp ((fp1 `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) let refined_pre_action e (fp0:slprop) (a:Type) (fp1:a -> slprop) = m0:hmem_with_inv_except e fp0 -> Pure (x:a & hmem_with_inv_except e (fp1 x)) (requires True) (ensures fun (| x, m1 |) -> frame_related_mems fp0 (fp1 x) e m0 m1) let refined_pre_action_as_action (#fp0:slprop) (#a:Type) (#fp1:a -> slprop) #e ($f:refined_pre_action e fp0 a fp1) : tot_action_nf_except e fp0 a fp1 = let g : tot_pre_action_nf_except e fp0 a fp1 = fun m -> f m in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp0 `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp1 x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x', m1' |) = g m0 in let (| x, m1 |) = f m0 in assert (x == x' /\ m1 == m1') in g let alloc_action #a #pcm e x = let f : refined_pre_action e emp (ref a pcm) (fun r -> pts_to r x) = fun m0 -> (* NS: 9/29/22 I needed to annotate h : Heap.full_heap, for use with the Core checker which generates a guard for checking the implicit pattern "dot" term in the dependent pair pattern on the next line. That guard expects `h` to be a full_heap, which is it, because it is a projection of m0. However, this is not reflected in `h`'s type. So, the Core checker, which produces a guard for the pat_dot_term in isolation, cannot recheck the term. If we were to fold in the checking of pat_dot_terms and their guards with the rest of the VC, this would work. *) let h : Heap.full_heap = hheap_of_hmem m0 in let (|r, h'|) = H.extend #a #pcm x m0.ctr h in let m' : hmem_with_inv_except e emp = inc_ctr m0 in let h' : H.hheap (pts_to #a #pcm r x `star` linv e m') = weaken _ (linv e m0) (linv e m') h' in let m1 : hmem_with_inv_except e (pts_to #a #pcm r x) = hmem_of_hheap m' h' in assert (forall frame. H.frame_related_heaps h h' emp (pts_to #a #pcm r x) frame true); let aux (frame:slprop) : Lemma (requires interp ((emp `star` frame) `star` linv e m0) m0) (ensures interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) [SMTPat (emp `star` frame)] = star_associative emp frame (linv e m0); assert (H.interp (emp `star` (frame `star` linv e m0)) h); assert (H.interp (pts_to #a #pcm r x `star` (frame `star` linv e m0)) h'); star_associative (pts_to #a #pcm r x) frame (linv e m0); assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m0) h'); assert (H.stronger (linv e m0) (linv e m')); assert (H.equiv (linv e m') (linv e m1)); assert (H.stronger (linv e m0) (linv e m1)); let h' : H.hheap ((pts_to #a #pcm r x `star` frame) `star` linv e m1) = weaken _ (linv e m0) (linv e m1) h' in assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) h'); assert (forall (mp:H.hprop frame). mp h == mp h'); mprop_preservation_of_hprop_preservation frame m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) in assert (frame_related_mems emp (pts_to r x) e m0 m1); (| r, m1 |) in lift_tot_action (refined_pre_action_as_action f) let select_refine #a #p e r x f = lift_tot_action (lift_heap_action e (H.select_refine #a #p r x f)) let upd_gen #a #p e r x y f = lift_tot_action (lift_heap_action e (H.upd_gen_action r x y f)) //////////////////////////////////////////////////////////////////////////////// // witness / recall //////////////////////////////////////////////////////////////////////////////// let witnessed_ref #a #pcm (r:ref a pcm) (fact:property a) (m:full_mem) = H.witnessed_ref #a #pcm r fact (heap_of_mem m) let witnessed_ref_stability #a #pcm (r:ref a pcm) (fact:property a) : Lemma (requires FStar.Preorder.stable fact (Steel.Preorder.preorder_of_pcm pcm)) (ensures FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) = H.witnessed_ref_stability #a #pcm r fact let witnessed (#a:Type u#1) (#pcm:pcm a) (r:ref a pcm) (fact:property a) = W.witnessed _ mem_evolves (witnessed_ref r fact) let rearrange_pqr_prq (p q r:slprop) : Lemma (((p `star` q) `star` r) `equiv` ((p `star` r) `star` q)) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_associative p q r } p `star` (q `star` r); (equiv) { star_commutative q r; star_congruence p (q `star` r) p (r `star` q) } p `star` (r `star` q); (equiv) { star_associative p r q } (p `star` r) `star` q; } let preserves_frame_cong (e:inames) (p q:slprop) (r s:slprop) (m0 m1:mem) : Lemma (requires p `equiv` r /\ q `equiv` s /\ preserves_frame e p q m0 m1) (ensures preserves_frame e r s m0 m1) = let aux0 (p q r s:slprop) : Lemma (requires p `equiv` s) (ensures (((p `star` q) `star` r) `equiv` ((s `star` q) `star` r))) = star_congruence p q s q; star_congruence (p `star` q) r (s `star` q) r in let aux (frame:slprop) : Lemma (requires interp ((r `star` frame) `star` locks_invariant e m0) m0) (ensures interp ((s `star` frame) `star` locks_invariant e m1) m1 /\ interp ((p `star` frame) `star` locks_invariant e m0) m0) [SMTPat (r `star` frame)] = aux0 p frame (locks_invariant e m0) r; aux0 q frame (locks_invariant e m1) s; assert (((p `star` frame) `star` locks_invariant e m0) `equiv` ((r `star` frame) `star` locks_invariant e m0)); assert (interp ((p `star` frame) `star` locks_invariant e m0) m0); assert (interp ((q `star` frame) `star` locks_invariant e m1) m1); assert (((q `star` frame) `star` locks_invariant e m1) `equiv` ((s `star` frame) `star` locks_invariant e m1)); () in () let pure_true_equiv (p:slprop) : Lemma ((p `star` pure True) `equiv` p) = FStar.Classical.forall_intro (pure_star_interp p True); emp_unit p; assert ((p `star` pure True) `equiv` p) let preserves_frame_star_pure (e:inames) (p q:slprop) (r s:prop) (m:mem) : Lemma (requires r /\ s) (ensures preserves_frame e p q m m <==> preserves_frame e (p `star` pure r) (q `star` pure s) m m) = pure_equiv r True; star_congruence p (pure r) p (pure True); pure_equiv s True; star_congruence q (pure s) q (pure True); pure_true_equiv p; pure_true_equiv q; let fwd () : Lemma (requires preserves_frame e p q m m) (ensures preserves_frame e (p `star` pure r) (q `star` pure s) m m) [SMTPat ()] = preserves_frame_cong e p q (p `star` pure r) (q `star` pure s) m m in let bk () : Lemma (requires preserves_frame e (p `star` pure r) (q `star` pure s) m m) (ensures preserves_frame e p q m m) [SMTPat ()] = preserves_frame_cong e (p `star` pure r) (q `star` pure s) p q m m in () let witness (#a:Type) (#pcm:pcm a) (e:inames) (r:erased (ref a pcm)) (fact:stable_property pcm) (v:Ghost.erased a) (_:squash (forall z. compatible pcm v z ==> fact z)) (frame:slprop) : MstTot (witnessed r fact) e (pts_to r v) (fun _ -> pts_to r v) frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in let _ : unit = let hr : H.ref a pcm = r in let v' = H.sel_v hr v (heap_of_mem m0) in assert (interp (H.ptr hr) m0 /\ H.sel #a #pcm hr (heap_of_mem m0) == v'); assert (compatible pcm v v'); assert (fact v'); assert (witnessed_ref r fact m0); witnessed_ref_stability r fact; assert (FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) in let w = NMSTTotal.witness _ mem_evolves (witnessed_ref r fact) in w let recall (#a:Type u#1) (#pcm:pcm a) (#fact:property a) (e:inames) (r:erased (ref a pcm)) (v:Ghost.erased a) (w:witnessed r fact) (frame:slprop) = let m0 = NMSTTotal.get () in NMSTTotal.recall _ mem_evolves (witnessed_ref r fact) w; let hr : H.ref a pcm = r in assert (witnessed_ref r fact m0); let v1 = H.sel_v hr v (heap_of_mem m0) in assert (compatible pcm v v1); assert (H.sel hr (heap_of_mem m0) == v1); assert (fact v1); assert (interp ((pts_to r v `star` frame) `star` locks_invariant e m0) m0); emp_unit ((pts_to r v `star` frame) `star` locks_invariant e m0); pure_star_interp ((pts_to r v `star` frame) `star` locks_invariant e m0) (fact v1) m0; assert (interp (((pts_to r v `star` frame) `star` locks_invariant e m0) `star` pure (fact v1)) m0); rearrange_pqr_prq (pts_to r v `star` frame) (locks_invariant e m0) (pure (fact v1)); assert (interp (((pts_to r v `star` frame) `star` pure (fact v1)) `star` locks_invariant e m0) m0); rearrange_pqr_prq (pts_to r v) frame (pure (fact v1)); star_congruence ((pts_to r v `star` frame) `star` pure (fact v1)) (locks_invariant e m0) ((pts_to r v `star` pure (fact v1)) `star` frame) (locks_invariant e m0); Ghost.hide v1 let iname_for_p_mem (i:iname) (p:slprop) : W.s_predicate mem = fun m -> iname_for_p i p m.locks let iname_for_p_stable (i:iname) (p:slprop) : Lemma (W.stable full_mem mem_evolves (iname_for_p_mem i p)) = () let ( >--> ) (i:iname) (p:slprop) : Type0 = W.witnessed full_mem mem_evolves (iname_for_p_mem i p) let hmem_with_inv_equiv e (m:mem) (p:slprop) : Lemma (interp (p `star` linv e m) m <==> interp (p `star` lock_store_invariant e m.locks) m /\ heap_ctr_valid m.ctr (heap_of_mem m)) = calc (<==>) { interp (p `star` linv e m) m; (<==>) { H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) } interp ((p `star` lock_store_invariant e m.locks) `star` ctr_validity m.ctr (heap_of_mem m)) m; (<==>) { H.pure_star_interp (p `star` lock_store_invariant e m.locks) (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_of_mem m) } interp ((p `star` lock_store_invariant e m.locks) `star` emp) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); (<==>) { H.emp_unit (p `star` lock_store_invariant e m.locks) } interp (p `star` lock_store_invariant e m.locks) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); } let new_invariant_tot_action (e:inames) (p:slprop) (m0:hmem_with_inv_except e p{ e `inames_in` m0.locks }) : Pure (iname & hmem_with_inv_except e emp) (requires True) (ensures fun (i, m1) -> iname_for_p_mem i p m1 /\ frame_related_mems p emp e m0 m1 /\ mem_evolves m0 m1) = let (| i, l1 |) = extend_lock_store e m0.locks p in let m1 = { m0 with locks = l1 } in assert (lock_store_invariant e m1.locks == p `star` lock_store_invariant e m0.locks); calc (equiv) { linv e m1; (equiv) {} (lock_store_invariant e m1.locks `star` ctr_validity m1.ctr (heap_of_mem m1)); (equiv) {} ((p `star` lock_store_invariant e m0.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); (equiv) { H.star_associative p (lock_store_invariant e m0.locks) (ctr_validity m1.ctr (heap_of_mem m1)) } (p `star` (lock_store_invariant e m0.locks `star` ctr_validity m1.ctr (heap_of_mem m1))); (equiv) { } (p `star` linv e m0); }; assert (iname_for_p_mem i p m1); assert (lock_store_evolves m0.locks l1); assert (mem_evolves m0 m1); hmem_with_inv_equiv e m0 p; assert (interp (p `star` lock_store_invariant e m0.locks) m1); assert (interp (lock_store_invariant e m1.locks) m1); H.emp_unit (lock_store_invariant e m1.locks); H.star_commutative (lock_store_invariant e m1.locks) emp; assert (interp (emp `star` lock_store_invariant e m1.locks) m1); hmem_with_inv_equiv e m1 emp; let m1 : hmem_with_inv_except e emp = m1 in let aux (frame:slprop) : Lemma (requires interp ((p `star` frame) `star` linv e m0) m0) (ensures interp ((emp `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) <==> mp (core_mem m1))) [SMTPat (p `star` frame)] = assert (interp ((p `star` frame) `star` linv e m0) m1); calc (equiv) { ((p `star` frame) `star` linv e m0); (equiv) { H.star_commutative p frame; H.star_congruence (p `star` frame) (linv e m0) (frame `star` p) (linv e m0); H.star_associative frame p (linv e m0) } (frame `star` (p `star` linv e m0)); (equiv) { H.star_congruence frame (p `star` linv e m0) frame (linv e m1) } (frame `star` linv e m1); (equiv) { H.emp_unit (frame `star` linv e m1); H.star_commutative (frame `star` linv e m1) emp; H.star_associative emp frame (linv e m1) } ((emp `star` frame) `star` linv e m1); }; assert (interp ((emp `star` frame) `star` linv e m1) m1) in assert (frame_related_mems p emp e m0 m1); ( i, m1 ) let name_is_ok (i:iname) (m0:full_mem u#1) : prop = i < List.Tot.length m0.locks let witnessed_name_is_ok (i:iname) = W.witnessed full_mem mem_evolves (name_is_ok i) let pre_inv = i:erased iname & witnessed_name_is_ok i let inv (p:slprop u#1) = i:erased iname & witnessed_name_is_ok i & (i >--> p) let pre_inv_of_inv #p (i:inv p) = let (|i, w, _|) = i in (|i,w|) let name_of_pre_inv (i:pre_inv) = dfst i let rec recall_all (ctx:list pre_inv) : NMSTTotal.NMSTATETOT unit (full_mem u#1) mem_evolves (requires fun _ -> True) (ensures fun m0 _ m1 -> m0==m1 /\ (forall i. i `List.Tot.memP` ctx ==> name_is_ok (name_of_pre_inv i) m0)) = match ctx with | [] -> () | hd::tl -> let (| q, i |) = hd in let i : W.witnessed full_mem mem_evolves (name_is_ok q) = i in NMSTTotal.recall _ mem_evolves (name_is_ok q) i; recall_all tl let fresh_invariant (e:inames) (p:slprop) (ctx:list pre_inv) (frame:slprop) : MstTot (i:inv p { not (mem_inv e i) /\ fresh_wrt ctx (name_of_inv i)}) e p (fun _ -> emp) frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in recall_all ctx; ac_reasoning_for_m_frame_preserving p frame (locks_invariant e m0) m0; assert (interp (p `star` locks_invariant e m0) m0); let r = new_invariant_tot_action e p m0 in let ( i, m1 ) = r in assert (i == List.Tot.length m0.locks); assert (not (Set.mem i e)); assert (mem_evolves m0 m1); NMSTTotal.put #full_mem #mem_evolves m1; iname_for_p_stable i p; let w = NMSTTotal.witness full_mem mem_evolves (iname_for_p_mem i p) in let w0 = NMSTTotal.witness full_mem mem_evolves (name_is_ok i) in (| hide i, w0, w |) let new_invariant (e:inames) (p:slprop) (frame:slprop) : MstTot (inv p) e p (fun _ -> emp) frame (fun _ -> True) (fun _ _ _ -> True) = fresh_invariant e p [] frame let rearrange_invariant (p q r : slprop) (q0 q1:slprop) : Lemma (requires q `equiv` (q0 `star` q1)) (ensures (p `star` (q `star` r)) `equiv` ((q0 `star` p) `star` (q1 `star` r))) = calc (equiv) { p `star` (q `star` r); (equiv) { calc (equiv) { (q `star` r); (equiv) { star_congruence q r (q0 `star` q1) r } (q0 `star` q1) `star` r; }; star_congruence p (q `star` r) p ((q0 `star` q1) `star` r) } (p `star` ((q0 `star` q1) `star` r)); (equiv) { star_associative q0 q1 r; star_congruence p ((q0 `star` q1) `star` r) p (q0 `star` (q1 `star` r)); star_associative p q0 (q1 `star` r) } (p `star` q0) `star` (q1 `star` r); (equiv) { star_commutative p q0; star_congruence (p `star` q0) (q1 `star` r) (q0 `star` p) (q1 `star` r) } (q0 `star` p) `star` (q1 `star` r); } let preserves_frame_invariant (fp fp':slprop) (opened_invariants:inames) (p:slprop) (i:inv p{not (mem_inv opened_invariants i)}) (m0:hmem_with_inv_except (add_inv opened_invariants i) (p `star` fp)) (m1:mem) : Lemma (requires preserves_frame (set_add (name_of_inv i) opened_invariants) (p `star` fp) (p `star` fp') m0 m1 /\ interp (fp' `star` linv opened_invariants m1) m1 /\ inames_ok opened_invariants m1 /\ (lock_store_invariant opened_invariants m0.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks)) /\ (lock_store_invariant opened_invariants m1.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks))) (ensures preserves_frame opened_invariants fp fp' m0 m1) = let aux (frame:slprop) : Lemma (requires interp ((fp `star` frame) `star` linv opened_invariants m0) m0) (ensures interp ((fp' `star` frame) `star` linv opened_invariants m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) [SMTPat()] = rearrange_invariant (fp `star` frame) (lock_store_invariant opened_invariants m0.locks) (ctr_validity m0.ctr (heap_of_mem m0)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks); assert (interp ((p `star` (fp `star` frame)) `star` linv (set_add (name_of_inv i) opened_invariants) m0) m0); star_associative p fp frame; star_congruence (p `star` (fp `star` frame)) (linv (set_add (name_of_inv i) opened_invariants) m0) ((p `star` fp) `star` frame) (linv (set_add (name_of_inv i) opened_invariants) m0); assert (interp (((p `star` fp) `star` frame) `star` linv (set_add (name_of_inv i) opened_invariants) m0) m0); assert (interp (((p `star` fp') `star` frame) `star` linv (set_add (name_of_inv i) opened_invariants) m1) m1); star_associative p fp' frame; star_congruence ((p `star` fp') `star` frame) (linv (set_add (name_of_inv i) opened_invariants) m1) (p `star` (fp' `star` frame)) (linv (set_add (name_of_inv i) opened_invariants) m1); assert (interp ((p `star` (fp' `star` frame)) `star` linv (set_add (name_of_inv i) opened_invariants) m1) m1); rearrange_invariant (fp' `star` frame) (lock_store_invariant opened_invariants m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks); assert (interp ((fp' `star` frame) `star` linv opened_invariants m1) m1); () in () let equiv_ext_right (p q r:slprop) : Lemma (requires q `equiv` r) (ensures (p `star` q) `equiv` (p `star` r)) = calc (equiv) { p `star` q; (equiv) { star_commutative p q } q `star` p; (equiv) { equiv_extensional_on_star q r p } r `star` p; (equiv) { star_commutative p r } p `star` r; } let with_inv_helper (fp frame ls1 ctr p ls2:slprop) : Lemma (requires ls1 `equiv` (p `star` ls2)) (ensures (fp `star` frame `star` (ls1 `star` ctr)) `equiv` (p `star` fp `star` frame `star` (ls2 `star` ctr))) = calc (equiv) { ls1 `star` ctr; (equiv) { equiv_extensional_on_star ls1 (p `star` ls2) ctr } p `star` ls2 `star` ctr; }; calc (equiv) { p `star` ls2 `star` ctr; (equiv) { star_associative p ls2 ctr } p `star` (ls2 `star` ctr); }; calc (equiv) { fp `star` frame `star` p; (equiv) { star_commutative (fp `star` frame) p } p `star` (fp `star` frame); (equiv) { star_associative p fp frame } p `star` fp `star` frame; }; calc (equiv) { fp `star` frame `star` (ls1 `star` ctr); (equiv) { equiv_ext_right (fp `star` frame) (ls1 `star` ctr) (p `star` ls2 `star` ctr) } (fp `star` frame) `star` (p `star` ls2 `star` ctr); (equiv) { equiv_ext_right (fp `star` frame) (p `star` ls2 `star` ctr) (p `star` (ls2 `star` ctr)) } (fp `star` frame) `star` (p `star` (ls2 `star` ctr)); (equiv) { star_associative (fp `star` frame) p (ls2 `star` ctr) } (fp `star` frame `star` p) `star` (ls2 `star` ctr); (equiv) { equiv_extensional_on_star (fp `star` frame `star` p) (p `star` fp `star` frame) (ls2 `star` ctr) } (p `star` fp `star` frame) `star` (ls2 `star` ctr); } let token_of_inv #p (i:inv p) : (name_of_inv i >--> p) = let (| _, _, tok |) = i in tok let with_invariant (#a:Type) (#fp:slprop) (#fp':a -> slprop) (#opened_invariants:inames) (#p:slprop) (i:inv p{not (mem_inv opened_invariants i)}) (f:action_except a (add_inv opened_invariants i) (p `star` fp) (fun x -> p `star` fp' x)) (frame:slprop) : MstTot a opened_invariants fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in NMSTTotal.recall _ mem_evolves (iname_for_p_mem (name_of_inv i) p) (token_of_inv i); assert (iname_for_p (name_of_inv i) p m0.locks); assert (interp (fp `star` frame `star` locks_invariant opened_invariants m0) m0); assert (interp (fp `star` frame `star` (lock_store_invariant opened_invariants m0.locks `star` ctr_validity m0.ctr (heap_of_mem m0))) m0); move_invariant opened_invariants m0.locks p (name_of_inv i); assert (lock_store_invariant opened_invariants m0.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks)); with_inv_helper fp frame (lock_store_invariant opened_invariants m0.locks) (ctr_validity m0.ctr (heap_of_mem m0)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks); assert (interp (p `star` fp `star` frame `star` locks_invariant (set_add (name_of_inv i) opened_invariants) m0) m0); let r = f frame in let m1 : full_mem = NMSTTotal.get () in assert (interp (p `star` fp' r `star` frame `star` locks_invariant (set_add (name_of_inv i) opened_invariants) m1) m1); assert (interp (p `star` fp' r `star` frame `star` (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks `star` ctr_validity m1.ctr (heap_of_mem m1))) m1); NMSTTotal.recall _ mem_evolves (iname_for_p_mem (name_of_inv i) p) (token_of_inv i); move_invariant opened_invariants m1.locks p (name_of_inv i); assert (lock_store_invariant opened_invariants m1.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks)); with_inv_helper (fp' r) frame (lock_store_invariant opened_invariants m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks); assert (interp (fp' r `star` frame `star` locks_invariant opened_invariants m1) m1); assert (inames_ok opened_invariants m1); r let equiv_pqrs_p_qr_s (p q r s:slprop) : Lemma ((p `star` q `star` r `star` s) `equiv` (p `star` (q `star` r) `star` s)) = star_associative p q r; equiv_extensional_on_star (p `star` q `star` r) (p `star` (q `star` r)) s let frame (#a:Type) (#opened_invariants:inames) (#pre:slprop) (#post:a -> slprop) (#req:mprop pre) (#ens:mprop2 pre post) (frame:slprop) ($f:action_except_full a opened_invariants pre post req ens) (frame0:slprop) : MstTot a opened_invariants (pre `star` frame) (fun x -> post x `star` frame) frame0 req ens = let m0 : full_mem = NMSTTotal.get () in equiv_pqrs_p_qr_s pre frame frame0 (linv opened_invariants m0); assert (interp (pre `star` frame `star` frame0 `star` linv opened_invariants m0) m0); assert (interp (pre `star` (frame `star` frame0) `star` linv opened_invariants m0) m0); let x = f (frame `star` frame0) in let m1 : full_mem = NMSTTotal.get () in equiv_pqrs_p_qr_s (post x) frame frame0 (linv opened_invariants m1); assert (interp (post x `star` (frame `star` frame0) `star` linv opened_invariants m1) m1); assert (interp (post x `star` frame `star` frame0 `star` linv opened_invariants m1) m1); x let change_slprop (#opened_invariants:inames) (p q:slprop) (proof: (m:mem -> Lemma (requires interp p m) (ensures interp q m))) = let proof (h:H.heap) : Lemma (requires H.interp p h) (ensures H.interp q h) = proof (mem_of_heap h) in lift_tot_action (lift_heap_action opened_invariants (Steel.Heap.change_slprop p q proof)) (* This module reuses is_frame_monotonic from Heap, but does not expose that to clients, so we need this lemma to typecheck witness_h_exists below. *) let relate_frame_monotonic_1 #a p : Lemma (requires (H.is_frame_monotonic p)) (ensures (is_frame_monotonic p)) = () let relate_frame_monotonic_2 #a p : Lemma (requires (is_frame_monotonic p)) (ensures (H.is_frame_monotonic p)) = let aux (x y : a) (h : H.heap) (f : H.slprop) : Lemma (requires (H.interp (p x `H.star` f) h /\ H.interp (p y) h)) (ensures (H.interp (p y `H.star` f) h)) = let m = mem_of_heap h in assert (interp (p x `star` f) m); assert (interp (p y) m); assert (interp (p y `star` f) m) in Classical.forall_intro_4 (fun x y h f -> Classical.move_requires (aux x y h) f) let witness_h_exists #opened_invariants #a p = lift_tot_action_with_frame (lift_heap_action_with_frame opened_invariants (H.witness_h_exists p)) let lift_h_exists #opened_invariants p = lift_tot_action (lift_heap_action opened_invariants (H.lift_h_exists p)) let elim_pure #opened_invariants p = lift_tot_action (lift_heap_action opened_invariants (H.elim_pure p)) let pts_to_join (#a:Type) (#pcm:pcm a) (r:ref a pcm) (x y : a) (m:mem) : Lemma (requires (interp (pts_to r x) m /\ interp (pts_to r y) m)) (ensures (joinable pcm x y)) = H.pts_to_join #a #pcm r x y (heap_of_mem m) let pts_to_evolve (#a:Type u#a) (#pcm:_) (r:ref a pcm) (x y : a) (m:mem) : Lemma (requires (interp (pts_to r x) m /\ compatible pcm y x)) (ensures (interp (pts_to r y) m)) = H.pts_to_evolve #a #pcm r x y (heap_of_mem m) let id_elim_star p q m = let starprop (ml:mem) (mr:mem) = disjoint ml mr /\ m == join ml mr /\ interp p ml /\ interp q mr in elim_star p q m; let p1 : mem -> prop = fun ml -> (exists mr. starprop ml mr) in let ml = IndefiniteDescription.indefinite_description_tot _ p1 in let starpropml mr : prop = starprop ml mr in // this prop annotation seems needed let mr = IndefiniteDescription.indefinite_description_tot _ starpropml in (ml, mr)

{ "checked_file": "/", "dependencies": [ "Steel.Preorder.fst.checked", "Steel.Heap.fsti.checked", "prims.fst.checked", "FStar.Witnessed.Core.fsti.checked", "FStar.Set.fsti.checked", "FStar.Preorder.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.PCM.fst.checked", "FStar.NMSTTotal.fst.checked", "FStar.List.Tot.fst.checked", "FStar.IndefiniteDescription.fsti.checked", "FStar.Ghost.fsti.checked", "FStar.FunctionalExtensionality.fsti.checked", "FStar.Classical.Sugar.fsti.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Steel.Memory.fst" }

[ { "abbrev": true, "full_module": "Steel.Preorder", "short_module": "PP" }, { "abbrev": true, "full_module": "FStar.Witnessed.Core", "short_module": "W" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": true, "full_module": "Steel.Heap", "short_module": "H" }, { "abbrev": false, "full_module": "FStar.FunctionalExtensionality", "short_module": null }, { "abbrev": true, "full_module": "FStar.FunctionalExtensionality", "short_module": "F" }, { "abbrev": true, "full_module": "FStar.Universe", "short_module": "U" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": false, "full_module": "FStar.PCM", "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

p: (_: a -> Steel.Memory.slprop) -> m: Steel.Memory.mem -> Prims.Pure (FStar.Ghost.erased a)

Prims.Pure

[]

[ "Steel.Memory.slprop", "Steel.Memory.mem", "FStar.Ghost.erased", "FStar.Ghost.reveal", "FStar.IndefiniteDescription.indefinite_description_tot", "Prims.unit", "Steel.Memory.elim_h_exists", "Prims.prop", "Steel.Memory.interp" ]

[]

false

let id_elim_exists #a p m =

let existsprop (x: a) = interp (p x) m in elim_h_exists p m; let x = IndefiniteDescription.indefinite_description_tot _ existsprop in x

false

Steel.Memory.fst

Steel.Memory.id_elim_star

val id_elim_star (p q:slprop) (m:mem) : Pure (erased mem & erased mem) (requires (interp (p `star` q) m)) (ensures (fun (ml, mr) -> disjoint ml mr /\ m == join ml mr /\ interp p ml /\ interp q mr))

let id_elim_star p q m = let starprop (ml:mem) (mr:mem) = disjoint ml mr /\ m == join ml mr /\ interp p ml /\ interp q mr in elim_star p q m; let p1 : mem -> prop = fun ml -> (exists mr. starprop ml mr) in let ml = IndefiniteDescription.indefinite_description_tot _ p1 in let starpropml mr : prop = starprop ml mr in // this prop annotation seems needed let mr = IndefiniteDescription.indefinite_description_tot _ starpropml in (ml, mr)

{ "file_name": "lib/steel/Steel.Memory.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 10, "end_line": 1582, "start_col": 0, "start_line": 1570 }

(* 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.Memory module F = FStar.FunctionalExtensionality open FStar.FunctionalExtensionality open FStar.PCM module H = Steel.Heap noeq type lock_state : Type u#(a + 1) = | Invariant : inv:H.slprop u#a -> lock_state let lock_store : Type u#(a+1) = list (lock_state u#a) noeq type mem : Type u#(a + 1) = { ctr: nat; heap: H.heap u#a; locks: lock_store u#a; } let heap_of_mem (x:mem) : H.heap = x.heap let mem_of_heap (h:H.heap) : mem = { ctr = 0; heap = h; locks = [] } let mem_set_heap (m:mem) (h:H.heap) : mem = { ctr = m.ctr; heap = h; locks = m.locks; } let core_mem (m:mem) : mem = mem_of_heap (heap_of_mem m) let core_mem_invol m = () let disjoint (m0 m1:mem u#h) : prop = m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks let disjoint_sym m0 m1 = () let join m0 m1 = { ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = m0.locks } let join_commutative m0 m1 = H.join_commutative m0.heap m1.heap let disjoint_join m0 m1 m2 = H.disjoint_join m0.heap m1.heap m2.heap let join_associative m0 m1 m2 = H.join_associative m0.heap m1.heap m2.heap let slprop = H.slprop let interp p m = H.interp p m.heap let equiv p1 p2 = forall m. interp p1 m <==> interp p2 m let slprop_extensionality p q = assert (forall m. interp p m <==> interp q m); let aux (h:H.heap) : Lemma (H.interp p h <==> H.interp q h) [SMTPat (H.interp p h)] = let m : mem = { ctr = 0; heap = h; locks = [] } in assert (interp p m <==> interp q m) in assert (forall h. H.interp p h <==> H.interp q h); Steel.Heap.slprop_extensionality p q let reveal_equiv p1 p2 = () let core_ref = H.core_ref let core_ref_null = H.core_ref_null let core_ref_is_null r = H.core_ref_is_null r let emp : slprop u#a = H.emp let pure = H.pure let pts_to = H.pts_to let h_and = H.h_and let h_or = H.h_or let star = H.star let wand = H.wand let h_exists = H.h_exists let h_forall = H.h_forall //////////////////////////////////////////////////////////////////////////////// //properties of equiv //////////////////////////////////////////////////////////////////////////////// let equiv_symmetric (p1 p2:slprop u#a) = H.equiv_symmetric p1 p2 #push-options "--warn_error -271" let equiv_heap_iff_equiv (p1 p2:slprop u#a) : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat (equiv p1 p2)] = let aux_lr () : Lemma (requires H.equiv p1 p2) (ensures equiv p1 p2) [SMTPat ()] = () in let aux_rl_helper1 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p1 h) (ensures H.interp p2 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl_helper2 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p2 h) (ensures H.interp p1 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl () : Lemma (requires equiv p1 p2) (ensures H.equiv p1 p2) [SMTPat ()] = () in () let equiv_heap_iff_equiv_forall () : Lemma (ensures (forall p1 p2. H.equiv p1 p2 <==> equiv p1 p2)) = let aux p1 p2 : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat ()] = equiv_heap_iff_equiv p1 p2 in () #pop-options let equiv_extensional_on_star (p1 p2 p3:slprop u#a) = equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3 let emp_unit p = H.emp_unit p let intro_emp m = H.intro_emp (heap_of_mem m) let pure_equiv p q = H.pure_equiv p q let pure_interp q m = H.pure_interp q (heap_of_mem m) let pure_star_interp p q m = H.pure_star_interp p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// //pts_to //////////////////////////////////////////////////////////////////////////////// let pts_to_compatible #a #pcm x v0 v1 m = H.pts_to_compatible #a #pcm x v0 v1 (heap_of_mem m) let pts_to_compatible_equiv #a #pcm x v0 v1 = H.pts_to_compatible_equiv #a #pcm x v0 v1 let pts_to_not_null #a #pcm x v m = H.pts_to_not_null #a #pcm x v (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // star //////////////////////////////////////////////////////////////////////////////// let intro_star p q mp mq = H.intro_star p q (heap_of_mem mp) (heap_of_mem mq) let elim_star p q m = let h = heap_of_mem m in H.elim_star p q h; assert (exists hl hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr); let hl = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hl -> exists hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let hr = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hr -> H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let ml = mem_set_heap m hl in let mr = mem_set_heap m hr in assert (disjoint ml mr); assert (m == join ml mr); assert (interp p ml); assert (interp q mr); () let interp_star (p q: slprop) (m: mem) : Lemma (interp (p `star` q) m <==> (exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m)) = let left = interp (p `star` q) m in let right = exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m in let f () : Lemma (requires left) (ensures right) = elim_star p q m in let g () : Lemma (requires right) (ensures left) = Classical.exists_elim left #_ #(fun mp -> exists (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mp -> Classical.exists_elim left #_ #(fun mq -> disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mq -> intro_star p q mp mq ) ) in Classical.move_requires f (); Classical.move_requires g () let star_commutative (p1 p2:slprop) = H.star_commutative p1 p2 let star_associative (p1 p2 p3:slprop) = H.star_associative p1 p2 p3 let star_congruence (p1 p2 p3 p4:slprop) = equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4 let affine_star (p q:slprop) (m:mem) = H.affine_star p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // Invariants on the lock store //////////////////////////////////////////////////////////////////////////////// let iname = nat module S = FStar.Set module L = FStar.List.Tot module W = FStar.Witnessed.Core let rec lock_store_invariant (e:inames) (l:lock_store u#a) : slprop u#a = let current_addr = L.length l - 1 in match l with | [] -> emp | Invariant p :: tl -> if current_addr `S.mem` e then lock_store_invariant e tl else p `star` lock_store_invariant e tl let lock_i (i:iname) (l:lock_store { i < L.length l }) = let ix = L.length l - i - 1 in L.index l ix let iname_for_p (i:iname) (p:slprop) : W.s_predicate lock_store = fun l -> i < L.length l /\ (lock_i i l).inv == p let lock_store_evolves : FStar.Preorder.preorder lock_store = fun (l1 l2 : lock_store) -> L.length l2 >= L.length l1 /\ (forall (i:nat{i < L.length l1}). (lock_i i l1).inv == (lock_i i l2).inv) let inames_in (e:inames) (l:lock_store) : prop = forall i. Set.mem i e ==> i < L.length l let inames_ok e m = inames_in e m.locks let inames_ok_empty m = () let extend_lock_store (e:inames) (l:lock_store{e `inames_in` l}) (p:slprop) : i:iname & l':lock_store { lock_store_invariant e l' == p `star` lock_store_invariant e l /\ iname_for_p i p l' } = (| L.length l, Invariant p :: l |) let set_add (i:iname) (s:inames) = Set.union (Set.singleton i) s let rec move_invariant (e:inames) (l:lock_store) (p:slprop) (i:iname{iname_for_p i p l /\ ~(i `Set.mem` e)}) : Lemma (H.equiv (lock_store_invariant e l) (p `star` lock_store_invariant (set_add i e) l)) = let rec aux (i:iname) (m:lock_store) : Lemma (requires i >= L.length m) (ensures (lock_store_invariant e m `H.equiv` lock_store_invariant (set_add i e) m)) = match m with | [] -> () | Invariant p::tl -> aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl) in let current_addr = L.length l - 1 in match l with | [] -> () | Invariant q::tl -> if i = current_addr then begin assert (lock_store_invariant e l == p `star` lock_store_invariant e tl); aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl); () end else begin move_invariant e tl p i; assert (lock_store_invariant e tl `equiv` (p `star` lock_store_invariant (set_add i e) tl)); H.star_congruence q (lock_store_invariant e tl) q (p `star` lock_store_invariant (set_add i e) tl); if Set.mem current_addr e then () else begin let r = lock_store_invariant (set_add i e) tl in assert (lock_store_invariant e l `equiv` (q `star` (p `star` r))); H.star_associative q p r; H.star_commutative q p; H.star_congruence (q `star` p) r (p `star` q) r; H.star_associative p q r end end let heap_ctr_valid (ctr:nat) (h:H.heap u#a) : prop = h `H.free_above_addr` ctr let ctr_validity (ctr:nat) (h:H.heap) : slprop = H.pure (heap_ctr_valid ctr h) let locks_invariant (e:inames) (m:mem u#a) : slprop u#a = lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m) let full_mem_pred (m:mem) = H.full_heap_pred (heap_of_mem m) (***** Following lemmas are needed in Steel.Effect *****) let core_mem_interp (hp:slprop u#a) (m:mem u#a) = () let interp_depends_only_on (hp:slprop u#a) = H.interp_depends_only_on hp let a_mem_prop_as_a_heap_prop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (H.a_heap_prop u#a) = let g (h: H.heap u#a) : Tot prop = interp sl (mem_of_heap h) /\ f (mem_of_heap h) in let phi0 (h0 h1: H.heap u#a) : Lemma (requires (g h0 /\ H.disjoint h0 h1)) (ensures (g h0 /\ H.disjoint h0 h1 /\ g (H.join h0 h1))) = assert (mem_of_heap (H.join h0 h1) == mem_of_heap h0 `join` mem_of_heap h1); interp_depends_only_on sl in let phi1 (h0 h1: H.heap u#a) : Lemma (ensures ((g h0 /\ H.disjoint h0 h1) ==> g (H.join h0 h1))) = Classical.move_requires (phi0 h0) h1 in Classical.forall_intro_2 phi1; g let refine_slprop sl f = H.as_slprop (a_mem_prop_as_a_heap_prop sl f) let interp_refine_slprop sl f m = assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_mem m)) let dep_hprop (s: slprop) (f: (hmem s -> Tot slprop)) (h: H.heap) : Tot prop = exists (h1: H.heap) . exists (h2: H.heap) . interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 let dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq' : squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h')) = let p2 (h h1 h2: H.heap) : Tot prop = interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 in let p1 (h h1: H.heap) : Tot prop = (exists h2 . p2 h h1 h2) in let h1 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p1 h) in let h2 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p2 h h1) in H.disjoint_join h' h1 h2; assert (H.disjoint h2 h'); let h2' = H.join h2 h' in H.join_commutative h2 h' ; assert (h2' == H.join h' h2); assert (H.disjoint h1 h2'); assert (mem_of_heap h2' == mem_of_heap h2 `join` mem_of_heap h'); interp_depends_only_on (f (mem_of_heap h1)); assert (interp (f (mem_of_heap h1)) (mem_of_heap h2')); H.join_commutative h1 h2; H.join_associative h' h2 h1; H.join_commutative h' h; H.join_commutative h2' h1; assert (H.join h h' == h1 `H.join` h2') let impl_intro_gen (#p: Type0) (#q: Type0) ($prf: (squash p -> Lemma (q ))) : Lemma (p ==> q) = Classical.impl_intro_gen #p #(fun _ -> q) prf let dep_hprop_is_affine1 (s: slprop) (f: (hmem s -> Tot slprop)) (h0 h1: H.heap) : Lemma ((dep_hprop s f h0 /\ H.disjoint h0 h1) ==> (H.disjoint h0 h1 /\ dep_hprop s f (H.join h0 h1))) = impl_intro_gen (dep_hprop_is_affine0 s f h0 h1) let dep_hprop_is_affine (s: slprop) (f: (hmem s -> Tot slprop)) : Lemma (H.heap_prop_is_affine (dep_hprop s f)) = Classical.forall_intro_2 (dep_hprop_is_affine1 s f) let sdep (s: slprop) (f: (hmem s -> Tot slprop)) : Tot slprop = dep_hprop_is_affine s f; H.as_slprop (dep_hprop s f) let interp_sdep (s: slprop) (f: (hmem s -> Tot slprop)) (m: mem) : Lemma (requires (dep_slprop_is_affine s f)) (ensures ( interp (sdep s f) m <==> (exists m1 m2 . interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) )) = dep_hprop_is_affine s f; assert (forall m1 m2 . (interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) ==> ( interp s (mem_of_heap m1.heap) /\ interp (f (mem_of_heap m1.heap)) (mem_of_heap m2.heap) /\ H.disjoint m1.heap m2.heap /\ H.join m1.heap m2.heap == m.heap )); interp_depends_only_on s; Classical.forall_intro (fun m -> interp_depends_only_on (f m)); assert (forall h1 h2 . (interp s (mem_of_heap h1) /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ H.disjoint h1 h2 /\ H.join h1 h2 == m.heap) ==> ( core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ interp s (core_mem (mem_of_heap h1)) /\ interp s (mem_set_heap m h1) /\ core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ f (mem_set_heap m h1) `equiv` f (mem_of_heap h1) /\ interp (f (mem_set_heap m h1)) (mem_of_heap h2) /\ interp (f (mem_set_heap m h1)) (mem_set_heap m h2) /\ disjoint (mem_set_heap m h1) (mem_set_heap m h2) /\ join (mem_set_heap m h1) (mem_set_heap m h2) == m )); () let h_exists_cong (#a:Type) (p q : a -> slprop) : Lemma (requires (forall x. p x `equiv` q x)) (ensures (h_exists p `equiv` h_exists q)) = equiv_heap_iff_equiv_forall (); H.h_exists_cong p q let intro_h_exists #a x p m = H.intro_h_exists x p (heap_of_mem m) let elim_h_exists (#a:_) (p:a -> slprop) (m:mem) = H.elim_h_exists p (heap_of_mem m) let intro_h_forall (#a:_) (p:a -> slprop) (m:mem) = H.intro_h_forall p (heap_of_mem m) let elim_h_forall (#a:_) (p:a -> slprop) (m:mem) (x:a) = H.elim_h_forall p (heap_of_mem m) x let intro_h_and (p q: slprop) (m:mem) = H.intro_h_and p q (heap_of_mem m) let elim_h_and (p q: slprop) (m:mem) = H.elim_h_and p q (heap_of_mem m) let intro_h_or_left (p q: slprop) (m:mem) = H.intro_h_or_left p q (heap_of_mem m) let intro_h_or_right (p q: slprop) (m:mem) = H.intro_h_or_right p q (heap_of_mem m) let elim_h_or (p q: slprop) (m:mem) = H.elim_h_or p q (heap_of_mem m) let intro_wand (p1 p2: slprop u#a) (m:mem) = introduce (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)) ==> interp (wand p1 p2) m with _. ( assert (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)); H.intro_wand p1 p2 (heap_of_mem m); let h = heap_of_mem m in assert ((forall h1. h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) ==> H.interp (wand p1 p2) h); introduce forall h1. (h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) with ( introduce (h `H.disjoint` h1 /\ H.interp p1 h1) ==> H.interp p2 (H.join h h1) with _. ( assert (h `H.disjoint` h1); let m1 = { ctr = m.ctr; heap = h1; locks = m.locks } in assert (m `disjoint` m1) ) ) ) (** Eliminating a wand by proving a heap that satisfies the LHS **) let elim_wand (p1 p2: slprop u#a) (m:mem) (m1:mem) = H.elim_wand p1 p2 (heap_of_mem m) (heap_of_mem m1) //////////////////////////////////////////////////////////////////////////////// // Preorders and effects //////////////////////////////////////////////////////////////////////////////// module PP = Steel.Preorder let mem_evolves = fun (m0 m1:full_mem) -> H.heap_evolves (heap_of_mem m0) (heap_of_mem m1) /\ m0.ctr <= m1.ctr /\ lock_store_evolves m0.locks m1.locks (** See [Steel.Heap.is_frame_preserving]. We add in [lock_invariants] now *) let preserves_frame (e:inames) (pre post:slprop) (m0 m1:mem) = forall (frame:slprop). interp ((pre `star` frame) `star` locks_invariant e m0) m0 ==> (interp ((post `star` frame) `star` locks_invariant e m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) (** This is a version of MstTot with frame quantified, as part of preserves_frame *) effect MstTotNF (a:Type u#a) (except:inames) (expects:slprop u#1) (provides: a -> slprop u#1) = NMSTTotal.NMSTATETOT a (full_mem u#1) mem_evolves (requires fun m0 -> inames_ok except m0 /\ interp (expects `star` locks_invariant except m0) m0) (ensures fun m0 x m1 -> inames_ok except m1 /\ interp (provides x `star` locks_invariant except m1) m1 /\ preserves_frame except expects (provides x) m0 m1) //////////////////////////////////////////////////////////////////////////////// // Lifting heap actions //////////////////////////////////////////////////////////////////////////////// (** Heap actions come in two equivalent flavors: - one that take an explicit frame as argument (action_with_frame) - and one that quantify over all the frame We therefore define two lift routes: - a direct route for those with explicit frame - via MstTotNF for the rest *) let tot_pre_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = hmem_with_inv_except e fp -> (x:a & hmem_with_inv_except e (fp' x)) let tot_pre_action_nf = tot_pre_action_nf_except S.empty let ac_reasoning_for_m_frame_preserving (p q r:slprop u#a) (m:mem u#a) : Lemma (requires interp ((p `star` q) `star` r) m) (ensures interp (p `star` r) m) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_commutative p q; equiv_extensional_on_star (p `star` q) (q `star` p) r } (q `star` p) `star` r; (equiv) { star_associative q p r } q `star` (p `star` r); }; assert (interp (q `star` (p `star` r)) m); affine_star q (p `star` r) m let is_frame_preserving (#e:inames) (#a:Type u#b) (#fp:slprop u#a) (#fp':a -> slprop u#a) (f:tot_pre_action_nf_except e fp a fp') = forall (frame:slprop u#a) (m0:hmem_with_inv_except e (fp `star` frame)). (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = f:tot_pre_action_nf_except e fp a fp'{ is_frame_preserving f } let tot_action_nf = tot_action_nf_except S.empty let linv e (m:mem) = locks_invariant e m let hheap_of_hmem #fp #e (m:hmem_with_inv_except e fp) : h:H.hheap (fp `star` linv e m) { h `H.free_above_addr` m.ctr} = let h = heap_of_mem m in H.pure_interp (heap_ctr_valid m.ctr (heap_of_mem m)) h; h let hmem_of_hheap #e (#fp0 #fp1:slprop) (m:hmem_with_inv_except e fp0) (h:H.full_hheap (fp1 `star` linv e m) { h `Heap.free_above_addr` m.ctr }) : m1:hmem_with_inv_except e fp1{linv e m `equiv` linv e m1} = let m1 : mem = { m with heap = h } in assert (interp (fp1 `star` linv e m) m1); star_commutative fp1 (linv e m); assert (interp (linv e m `star` fp1) m1); assert (linv e m1 == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); assert (linv e m == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m)); H.pure_interp (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_of_mem m); assert (heap_ctr_valid m1.ctr (heap_of_mem m) <==> heap_ctr_valid m1.ctr (heap_of_mem m1)); H.pure_equiv (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_ctr_valid m1.ctr (heap_of_mem m1)); H.star_congruence (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m)); assert (linv e m `equiv` linv e m1); let _ = equiv_extensional_on_star (linv e m) (linv e m1) fp1 in assert ((linv e m `star` fp1) `equiv` (linv e m1 `star` fp1)); assert (interp (linv e m1 `star` fp1) m1); star_commutative (linv e m1) fp1; assert (interp (fp1 `star` linv e m1) m1); m1 let with_inv_except (m:mem) e (fp:slprop) = interp (fp `star` locks_invariant e m) m #push-options "--warn_error -271" let as_hprop (frame:slprop) (mp:mprop frame) : hp:H.hprop frame{forall m. mp (core_mem m) == hp (heap_of_mem m)} = let f = fun h -> mp (mem_of_heap h) in assert (forall m. mp (core_mem m) == f (heap_of_mem m)); let aux (m0:H.hheap frame) (m1:H.heap{H.disjoint m0 m1}) : Lemma (ensures (mem_of_heap (H.join m0 m1) == join (mem_of_heap m0) (mem_of_heap m1))) [SMTPat ()] = () in f let mprop_preservation_of_hprop_preservation (p:slprop) (m0 m1:mem) : Lemma (requires (forall (hp:H.hprop p). hp (heap_of_mem m0) == hp (heap_of_mem m1))) (ensures (forall (mp:mprop p). mp (core_mem m0) == mp (core_mem m1))) = let aux (mp:mprop p) : Lemma (mp (core_mem m0) == mp (core_mem m1)) [SMTPat()] = assert (as_hprop p mp (heap_of_mem m0) == as_hprop p mp (heap_of_mem m1)) in () let lift_heap_action (#fp:slprop) (#a:Type) (#fp':a -> slprop) (e:inames) ($f:H.action fp a fp') : tot_action_nf_except e fp a fp' = let g : tot_pre_action_nf_except e fp a fp' = fun m -> let h0 = hheap_of_hmem m in let (| x, h' |) = f h0 in (| x, hmem_of_hheap m h' |) in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in let h0 = hheap_of_hmem m0 in let (| x', h1 |) = f h0 in H.action_framing f (linv e m0) h0; assert (x == x'); star_associative fp frame (linv e m0); H.action_framing f (frame `star` linv e m0) h0; assert (H.interp ((fp' x) `star` (frame `star` linv e m0)) h1); star_associative (fp' x) frame (linv e m0); assert (H.interp ((fp' x `star` frame) `star` linv e m0) h1); let h1' : H.hheap ((fp' x `star` frame) `star` linv e m0) = h1 in assert (m1 == hmem_of_hheap m0 h1'); assert (with_inv_except m1 e (fp' x `star` frame)); assert (forall (hp:H.hprop frame). hp h0 == hp h1); mprop_preservation_of_hprop_preservation frame m0 m1; () in assert (is_frame_preserving g); g let frame_preserving_respects_preorder #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (m0:hmem_with_inv_except e fp) : Lemma (let (| x, m1 |) = f m0 in mem_evolves m0 m1) = let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1) = () in H.emp_unit fp; assert (interp (fp `star` linv e m0) m0); H.star_congruence (fp `star` emp) (linv e m0) fp (linv e m0); assert (interp ((fp `star` emp) `star` linv e m0) m0); aux emp m0 let lift_tot_action_nf #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') : MstTotNF a e fp fp' = let m0 = NMSTTotal.get () in let m0' : hmem_with_inv_except e fp = m0 in let r = f m0' in let (| x, m1 |) = r in let m1' : hmem_with_inv_except e (fp' x) = m1 in assert (is_frame_preserving f); assert (m1 == dsnd (f m0)); frame_preserving_respects_preorder f m0; NMSTTotal.put #_ #(mem_evolves) m1; x let lift_tot_action #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get #(full_mem) #_ () in ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); lift_tot_action_nf f (** Now defining the lift for heap actions with explicit frame *) let tot_action_with_frame_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = frame:slprop u#a -> m0:hmem_with_inv_except e (fp `star` frame) -> Pure (x:a & hmem_with_inv_except e (fp' x `star` frame)) (requires True) (ensures fun (| x, m1 |) -> mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_with_frame = tot_action_with_frame_except S.empty let lift_heap_action_with_frame (#fp:slprop u#a) (#a:Type u#b) (#fp':a -> slprop u#a) (e:inames) ($f:H.action_with_frame fp a fp') : tot_action_with_frame_except e fp a fp' = fun frame m0 -> let h0 = hheap_of_hmem m0 in calc (equiv) { fp `star` frame `star` locks_invariant e m0; (equiv) { star_associative fp frame (locks_invariant e m0) } fp `star` (frame `star` locks_invariant e m0); }; assert (H.interp (fp `star` frame `star` locks_invariant e m0) h0); assert (H.interp (fp `star` (frame `star` locks_invariant e m0)) h0); //key: apply the heap action with frame * locks_invariant e m0 let (| x, h1 |) = f (frame `star` locks_invariant e m0) h0 in calc (equiv) { fp' x `star` (frame `star` locks_invariant e m0); (equiv) { star_associative (fp' x) frame (locks_invariant e m0) } fp' x `star` frame `star` locks_invariant e m0; }; assert (H.interp (fp' x `star` (frame `star` locks_invariant e m0)) h1); assert (H.interp (fp' x `star` frame `star` locks_invariant e m0) h1); let m1 = hmem_of_hheap m0 h1 in assert (mem_evolves m0 m1); mprop_preservation_of_hprop_preservation (frame `star` locks_invariant e m0) m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)); (| x, m1 |) let lift_tot_action_with_frame #a #e #fp #fp' ($f:tot_action_with_frame_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in assert (inames_ok e m0); ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); let m0' : hmem_with_inv_except e fp = m0 in let r = f frame m0' in let (| x, m1 |) = r in ac_reasoning_for_m_frame_preserving (fp' x) frame (locks_invariant e m1) m1; assert (interp (fp' x `star` frame `star` locks_invariant e m1) m1); assert (interp (fp' x `star` locks_invariant e m1) m1); let m1' : hmem_with_inv_except e (fp' x) = m1 in NMSTTotal.put #_ #(mem_evolves) m1; x let sel_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.sel_action #a #pcm r v0)) let upd_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.upd_action #a #pcm r v0 v1)) let free_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.free_action #a #pcm r v0)) let split_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.split_action #a #pcm r v0 v1)) let gather_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.gather_action #a #pcm r v0 v1)) let weaken (p q r:slprop) (h:H.hheap (p `star` q) { H.stronger q r }) : H.hheap (p `star` r) = H.weaken p q r h; h let weaken_pure (q r: prop) : Lemma (requires (q ==> r)) (ensures H.stronger (H.pure q) (H.pure r)) = let aux (h:H.heap) : Lemma (ensures (H.interp (H.pure q) h ==> H.interp (H.pure r) h)) [SMTPat ()] = H.pure_interp q h; H.pure_interp r h in () let inc_ctr (#p:slprop) #e (m:hmem_with_inv_except e p) : m':hmem_with_inv_except e p{m'.ctr = m.ctr + 1 /\ H.stronger (linv e m) (linv e m')} = let m' : mem = { m with ctr = m.ctr + 1} in assert (interp (p `star` linv e m) m'); assert (linv e m == lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m)); assert (linv e m' == lock_store_invariant e m.locks `star` ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken_free_above (heap_of_mem m) m.ctr (m.ctr + 1); weaken_pure (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_ctr_valid (m.ctr + 1) (heap_of_mem m)); assert (H.stronger (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m))); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)); H.stronger_star (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken (p `star` lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)) (heap_of_mem m'); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity (m.ctr + 1) (heap_of_mem m)); let m' : hmem_with_inv_except e p = m' in m' let frame_related_mems (fp0 fp1:slprop u#a) e (m0:hmem_with_inv_except e fp0) (m1:hmem_with_inv_except e fp1) = forall (frame:slprop u#a). interp ((fp0 `star` frame) `star` linv e m0) m0 ==> interp ((fp1 `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) let refined_pre_action e (fp0:slprop) (a:Type) (fp1:a -> slprop) = m0:hmem_with_inv_except e fp0 -> Pure (x:a & hmem_with_inv_except e (fp1 x)) (requires True) (ensures fun (| x, m1 |) -> frame_related_mems fp0 (fp1 x) e m0 m1) let refined_pre_action_as_action (#fp0:slprop) (#a:Type) (#fp1:a -> slprop) #e ($f:refined_pre_action e fp0 a fp1) : tot_action_nf_except e fp0 a fp1 = let g : tot_pre_action_nf_except e fp0 a fp1 = fun m -> f m in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp0 `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp1 x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x', m1' |) = g m0 in let (| x, m1 |) = f m0 in assert (x == x' /\ m1 == m1') in g let alloc_action #a #pcm e x = let f : refined_pre_action e emp (ref a pcm) (fun r -> pts_to r x) = fun m0 -> (* NS: 9/29/22 I needed to annotate h : Heap.full_heap, for use with the Core checker which generates a guard for checking the implicit pattern "dot" term in the dependent pair pattern on the next line. That guard expects `h` to be a full_heap, which is it, because it is a projection of m0. However, this is not reflected in `h`'s type. So, the Core checker, which produces a guard for the pat_dot_term in isolation, cannot recheck the term. If we were to fold in the checking of pat_dot_terms and their guards with the rest of the VC, this would work. *) let h : Heap.full_heap = hheap_of_hmem m0 in let (|r, h'|) = H.extend #a #pcm x m0.ctr h in let m' : hmem_with_inv_except e emp = inc_ctr m0 in let h' : H.hheap (pts_to #a #pcm r x `star` linv e m') = weaken _ (linv e m0) (linv e m') h' in let m1 : hmem_with_inv_except e (pts_to #a #pcm r x) = hmem_of_hheap m' h' in assert (forall frame. H.frame_related_heaps h h' emp (pts_to #a #pcm r x) frame true); let aux (frame:slprop) : Lemma (requires interp ((emp `star` frame) `star` linv e m0) m0) (ensures interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) [SMTPat (emp `star` frame)] = star_associative emp frame (linv e m0); assert (H.interp (emp `star` (frame `star` linv e m0)) h); assert (H.interp (pts_to #a #pcm r x `star` (frame `star` linv e m0)) h'); star_associative (pts_to #a #pcm r x) frame (linv e m0); assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m0) h'); assert (H.stronger (linv e m0) (linv e m')); assert (H.equiv (linv e m') (linv e m1)); assert (H.stronger (linv e m0) (linv e m1)); let h' : H.hheap ((pts_to #a #pcm r x `star` frame) `star` linv e m1) = weaken _ (linv e m0) (linv e m1) h' in assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) h'); assert (forall (mp:H.hprop frame). mp h == mp h'); mprop_preservation_of_hprop_preservation frame m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) in assert (frame_related_mems emp (pts_to r x) e m0 m1); (| r, m1 |) in lift_tot_action (refined_pre_action_as_action f) let select_refine #a #p e r x f = lift_tot_action (lift_heap_action e (H.select_refine #a #p r x f)) let upd_gen #a #p e r x y f = lift_tot_action (lift_heap_action e (H.upd_gen_action r x y f)) //////////////////////////////////////////////////////////////////////////////// // witness / recall //////////////////////////////////////////////////////////////////////////////// let witnessed_ref #a #pcm (r:ref a pcm) (fact:property a) (m:full_mem) = H.witnessed_ref #a #pcm r fact (heap_of_mem m) let witnessed_ref_stability #a #pcm (r:ref a pcm) (fact:property a) : Lemma (requires FStar.Preorder.stable fact (Steel.Preorder.preorder_of_pcm pcm)) (ensures FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) = H.witnessed_ref_stability #a #pcm r fact let witnessed (#a:Type u#1) (#pcm:pcm a) (r:ref a pcm) (fact:property a) = W.witnessed _ mem_evolves (witnessed_ref r fact) let rearrange_pqr_prq (p q r:slprop) : Lemma (((p `star` q) `star` r) `equiv` ((p `star` r) `star` q)) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_associative p q r } p `star` (q `star` r); (equiv) { star_commutative q r; star_congruence p (q `star` r) p (r `star` q) } p `star` (r `star` q); (equiv) { star_associative p r q } (p `star` r) `star` q; } let preserves_frame_cong (e:inames) (p q:slprop) (r s:slprop) (m0 m1:mem) : Lemma (requires p `equiv` r /\ q `equiv` s /\ preserves_frame e p q m0 m1) (ensures preserves_frame e r s m0 m1) = let aux0 (p q r s:slprop) : Lemma (requires p `equiv` s) (ensures (((p `star` q) `star` r) `equiv` ((s `star` q) `star` r))) = star_congruence p q s q; star_congruence (p `star` q) r (s `star` q) r in let aux (frame:slprop) : Lemma (requires interp ((r `star` frame) `star` locks_invariant e m0) m0) (ensures interp ((s `star` frame) `star` locks_invariant e m1) m1 /\ interp ((p `star` frame) `star` locks_invariant e m0) m0) [SMTPat (r `star` frame)] = aux0 p frame (locks_invariant e m0) r; aux0 q frame (locks_invariant e m1) s; assert (((p `star` frame) `star` locks_invariant e m0) `equiv` ((r `star` frame) `star` locks_invariant e m0)); assert (interp ((p `star` frame) `star` locks_invariant e m0) m0); assert (interp ((q `star` frame) `star` locks_invariant e m1) m1); assert (((q `star` frame) `star` locks_invariant e m1) `equiv` ((s `star` frame) `star` locks_invariant e m1)); () in () let pure_true_equiv (p:slprop) : Lemma ((p `star` pure True) `equiv` p) = FStar.Classical.forall_intro (pure_star_interp p True); emp_unit p; assert ((p `star` pure True) `equiv` p) let preserves_frame_star_pure (e:inames) (p q:slprop) (r s:prop) (m:mem) : Lemma (requires r /\ s) (ensures preserves_frame e p q m m <==> preserves_frame e (p `star` pure r) (q `star` pure s) m m) = pure_equiv r True; star_congruence p (pure r) p (pure True); pure_equiv s True; star_congruence q (pure s) q (pure True); pure_true_equiv p; pure_true_equiv q; let fwd () : Lemma (requires preserves_frame e p q m m) (ensures preserves_frame e (p `star` pure r) (q `star` pure s) m m) [SMTPat ()] = preserves_frame_cong e p q (p `star` pure r) (q `star` pure s) m m in let bk () : Lemma (requires preserves_frame e (p `star` pure r) (q `star` pure s) m m) (ensures preserves_frame e p q m m) [SMTPat ()] = preserves_frame_cong e (p `star` pure r) (q `star` pure s) p q m m in () let witness (#a:Type) (#pcm:pcm a) (e:inames) (r:erased (ref a pcm)) (fact:stable_property pcm) (v:Ghost.erased a) (_:squash (forall z. compatible pcm v z ==> fact z)) (frame:slprop) : MstTot (witnessed r fact) e (pts_to r v) (fun _ -> pts_to r v) frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in let _ : unit = let hr : H.ref a pcm = r in let v' = H.sel_v hr v (heap_of_mem m0) in assert (interp (H.ptr hr) m0 /\ H.sel #a #pcm hr (heap_of_mem m0) == v'); assert (compatible pcm v v'); assert (fact v'); assert (witnessed_ref r fact m0); witnessed_ref_stability r fact; assert (FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) in let w = NMSTTotal.witness _ mem_evolves (witnessed_ref r fact) in w let recall (#a:Type u#1) (#pcm:pcm a) (#fact:property a) (e:inames) (r:erased (ref a pcm)) (v:Ghost.erased a) (w:witnessed r fact) (frame:slprop) = let m0 = NMSTTotal.get () in NMSTTotal.recall _ mem_evolves (witnessed_ref r fact) w; let hr : H.ref a pcm = r in assert (witnessed_ref r fact m0); let v1 = H.sel_v hr v (heap_of_mem m0) in assert (compatible pcm v v1); assert (H.sel hr (heap_of_mem m0) == v1); assert (fact v1); assert (interp ((pts_to r v `star` frame) `star` locks_invariant e m0) m0); emp_unit ((pts_to r v `star` frame) `star` locks_invariant e m0); pure_star_interp ((pts_to r v `star` frame) `star` locks_invariant e m0) (fact v1) m0; assert (interp (((pts_to r v `star` frame) `star` locks_invariant e m0) `star` pure (fact v1)) m0); rearrange_pqr_prq (pts_to r v `star` frame) (locks_invariant e m0) (pure (fact v1)); assert (interp (((pts_to r v `star` frame) `star` pure (fact v1)) `star` locks_invariant e m0) m0); rearrange_pqr_prq (pts_to r v) frame (pure (fact v1)); star_congruence ((pts_to r v `star` frame) `star` pure (fact v1)) (locks_invariant e m0) ((pts_to r v `star` pure (fact v1)) `star` frame) (locks_invariant e m0); Ghost.hide v1 let iname_for_p_mem (i:iname) (p:slprop) : W.s_predicate mem = fun m -> iname_for_p i p m.locks let iname_for_p_stable (i:iname) (p:slprop) : Lemma (W.stable full_mem mem_evolves (iname_for_p_mem i p)) = () let ( >--> ) (i:iname) (p:slprop) : Type0 = W.witnessed full_mem mem_evolves (iname_for_p_mem i p) let hmem_with_inv_equiv e (m:mem) (p:slprop) : Lemma (interp (p `star` linv e m) m <==> interp (p `star` lock_store_invariant e m.locks) m /\ heap_ctr_valid m.ctr (heap_of_mem m)) = calc (<==>) { interp (p `star` linv e m) m; (<==>) { H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) } interp ((p `star` lock_store_invariant e m.locks) `star` ctr_validity m.ctr (heap_of_mem m)) m; (<==>) { H.pure_star_interp (p `star` lock_store_invariant e m.locks) (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_of_mem m) } interp ((p `star` lock_store_invariant e m.locks) `star` emp) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); (<==>) { H.emp_unit (p `star` lock_store_invariant e m.locks) } interp (p `star` lock_store_invariant e m.locks) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); } let new_invariant_tot_action (e:inames) (p:slprop) (m0:hmem_with_inv_except e p{ e `inames_in` m0.locks }) : Pure (iname & hmem_with_inv_except e emp) (requires True) (ensures fun (i, m1) -> iname_for_p_mem i p m1 /\ frame_related_mems p emp e m0 m1 /\ mem_evolves m0 m1) = let (| i, l1 |) = extend_lock_store e m0.locks p in let m1 = { m0 with locks = l1 } in assert (lock_store_invariant e m1.locks == p `star` lock_store_invariant e m0.locks); calc (equiv) { linv e m1; (equiv) {} (lock_store_invariant e m1.locks `star` ctr_validity m1.ctr (heap_of_mem m1)); (equiv) {} ((p `star` lock_store_invariant e m0.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); (equiv) { H.star_associative p (lock_store_invariant e m0.locks) (ctr_validity m1.ctr (heap_of_mem m1)) } (p `star` (lock_store_invariant e m0.locks `star` ctr_validity m1.ctr (heap_of_mem m1))); (equiv) { } (p `star` linv e m0); }; assert (iname_for_p_mem i p m1); assert (lock_store_evolves m0.locks l1); assert (mem_evolves m0 m1); hmem_with_inv_equiv e m0 p; assert (interp (p `star` lock_store_invariant e m0.locks) m1); assert (interp (lock_store_invariant e m1.locks) m1); H.emp_unit (lock_store_invariant e m1.locks); H.star_commutative (lock_store_invariant e m1.locks) emp; assert (interp (emp `star` lock_store_invariant e m1.locks) m1); hmem_with_inv_equiv e m1 emp; let m1 : hmem_with_inv_except e emp = m1 in let aux (frame:slprop) : Lemma (requires interp ((p `star` frame) `star` linv e m0) m0) (ensures interp ((emp `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) <==> mp (core_mem m1))) [SMTPat (p `star` frame)] = assert (interp ((p `star` frame) `star` linv e m0) m1); calc (equiv) { ((p `star` frame) `star` linv e m0); (equiv) { H.star_commutative p frame; H.star_congruence (p `star` frame) (linv e m0) (frame `star` p) (linv e m0); H.star_associative frame p (linv e m0) } (frame `star` (p `star` linv e m0)); (equiv) { H.star_congruence frame (p `star` linv e m0) frame (linv e m1) } (frame `star` linv e m1); (equiv) { H.emp_unit (frame `star` linv e m1); H.star_commutative (frame `star` linv e m1) emp; H.star_associative emp frame (linv e m1) } ((emp `star` frame) `star` linv e m1); }; assert (interp ((emp `star` frame) `star` linv e m1) m1) in assert (frame_related_mems p emp e m0 m1); ( i, m1 ) let name_is_ok (i:iname) (m0:full_mem u#1) : prop = i < List.Tot.length m0.locks let witnessed_name_is_ok (i:iname) = W.witnessed full_mem mem_evolves (name_is_ok i) let pre_inv = i:erased iname & witnessed_name_is_ok i let inv (p:slprop u#1) = i:erased iname & witnessed_name_is_ok i & (i >--> p) let pre_inv_of_inv #p (i:inv p) = let (|i, w, _|) = i in (|i,w|) let name_of_pre_inv (i:pre_inv) = dfst i let rec recall_all (ctx:list pre_inv) : NMSTTotal.NMSTATETOT unit (full_mem u#1) mem_evolves (requires fun _ -> True) (ensures fun m0 _ m1 -> m0==m1 /\ (forall i. i `List.Tot.memP` ctx ==> name_is_ok (name_of_pre_inv i) m0)) = match ctx with | [] -> () | hd::tl -> let (| q, i |) = hd in let i : W.witnessed full_mem mem_evolves (name_is_ok q) = i in NMSTTotal.recall _ mem_evolves (name_is_ok q) i; recall_all tl let fresh_invariant (e:inames) (p:slprop) (ctx:list pre_inv) (frame:slprop) : MstTot (i:inv p { not (mem_inv e i) /\ fresh_wrt ctx (name_of_inv i)}) e p (fun _ -> emp) frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in recall_all ctx; ac_reasoning_for_m_frame_preserving p frame (locks_invariant e m0) m0; assert (interp (p `star` locks_invariant e m0) m0); let r = new_invariant_tot_action e p m0 in let ( i, m1 ) = r in assert (i == List.Tot.length m0.locks); assert (not (Set.mem i e)); assert (mem_evolves m0 m1); NMSTTotal.put #full_mem #mem_evolves m1; iname_for_p_stable i p; let w = NMSTTotal.witness full_mem mem_evolves (iname_for_p_mem i p) in let w0 = NMSTTotal.witness full_mem mem_evolves (name_is_ok i) in (| hide i, w0, w |) let new_invariant (e:inames) (p:slprop) (frame:slprop) : MstTot (inv p) e p (fun _ -> emp) frame (fun _ -> True) (fun _ _ _ -> True) = fresh_invariant e p [] frame let rearrange_invariant (p q r : slprop) (q0 q1:slprop) : Lemma (requires q `equiv` (q0 `star` q1)) (ensures (p `star` (q `star` r)) `equiv` ((q0 `star` p) `star` (q1 `star` r))) = calc (equiv) { p `star` (q `star` r); (equiv) { calc (equiv) { (q `star` r); (equiv) { star_congruence q r (q0 `star` q1) r } (q0 `star` q1) `star` r; }; star_congruence p (q `star` r) p ((q0 `star` q1) `star` r) } (p `star` ((q0 `star` q1) `star` r)); (equiv) { star_associative q0 q1 r; star_congruence p ((q0 `star` q1) `star` r) p (q0 `star` (q1 `star` r)); star_associative p q0 (q1 `star` r) } (p `star` q0) `star` (q1 `star` r); (equiv) { star_commutative p q0; star_congruence (p `star` q0) (q1 `star` r) (q0 `star` p) (q1 `star` r) } (q0 `star` p) `star` (q1 `star` r); } let preserves_frame_invariant (fp fp':slprop) (opened_invariants:inames) (p:slprop) (i:inv p{not (mem_inv opened_invariants i)}) (m0:hmem_with_inv_except (add_inv opened_invariants i) (p `star` fp)) (m1:mem) : Lemma (requires preserves_frame (set_add (name_of_inv i) opened_invariants) (p `star` fp) (p `star` fp') m0 m1 /\ interp (fp' `star` linv opened_invariants m1) m1 /\ inames_ok opened_invariants m1 /\ (lock_store_invariant opened_invariants m0.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks)) /\ (lock_store_invariant opened_invariants m1.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks))) (ensures preserves_frame opened_invariants fp fp' m0 m1) = let aux (frame:slprop) : Lemma (requires interp ((fp `star` frame) `star` linv opened_invariants m0) m0) (ensures interp ((fp' `star` frame) `star` linv opened_invariants m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) [SMTPat()] = rearrange_invariant (fp `star` frame) (lock_store_invariant opened_invariants m0.locks) (ctr_validity m0.ctr (heap_of_mem m0)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks); assert (interp ((p `star` (fp `star` frame)) `star` linv (set_add (name_of_inv i) opened_invariants) m0) m0); star_associative p fp frame; star_congruence (p `star` (fp `star` frame)) (linv (set_add (name_of_inv i) opened_invariants) m0) ((p `star` fp) `star` frame) (linv (set_add (name_of_inv i) opened_invariants) m0); assert (interp (((p `star` fp) `star` frame) `star` linv (set_add (name_of_inv i) opened_invariants) m0) m0); assert (interp (((p `star` fp') `star` frame) `star` linv (set_add (name_of_inv i) opened_invariants) m1) m1); star_associative p fp' frame; star_congruence ((p `star` fp') `star` frame) (linv (set_add (name_of_inv i) opened_invariants) m1) (p `star` (fp' `star` frame)) (linv (set_add (name_of_inv i) opened_invariants) m1); assert (interp ((p `star` (fp' `star` frame)) `star` linv (set_add (name_of_inv i) opened_invariants) m1) m1); rearrange_invariant (fp' `star` frame) (lock_store_invariant opened_invariants m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks); assert (interp ((fp' `star` frame) `star` linv opened_invariants m1) m1); () in () let equiv_ext_right (p q r:slprop) : Lemma (requires q `equiv` r) (ensures (p `star` q) `equiv` (p `star` r)) = calc (equiv) { p `star` q; (equiv) { star_commutative p q } q `star` p; (equiv) { equiv_extensional_on_star q r p } r `star` p; (equiv) { star_commutative p r } p `star` r; } let with_inv_helper (fp frame ls1 ctr p ls2:slprop) : Lemma (requires ls1 `equiv` (p `star` ls2)) (ensures (fp `star` frame `star` (ls1 `star` ctr)) `equiv` (p `star` fp `star` frame `star` (ls2 `star` ctr))) = calc (equiv) { ls1 `star` ctr; (equiv) { equiv_extensional_on_star ls1 (p `star` ls2) ctr } p `star` ls2 `star` ctr; }; calc (equiv) { p `star` ls2 `star` ctr; (equiv) { star_associative p ls2 ctr } p `star` (ls2 `star` ctr); }; calc (equiv) { fp `star` frame `star` p; (equiv) { star_commutative (fp `star` frame) p } p `star` (fp `star` frame); (equiv) { star_associative p fp frame } p `star` fp `star` frame; }; calc (equiv) { fp `star` frame `star` (ls1 `star` ctr); (equiv) { equiv_ext_right (fp `star` frame) (ls1 `star` ctr) (p `star` ls2 `star` ctr) } (fp `star` frame) `star` (p `star` ls2 `star` ctr); (equiv) { equiv_ext_right (fp `star` frame) (p `star` ls2 `star` ctr) (p `star` (ls2 `star` ctr)) } (fp `star` frame) `star` (p `star` (ls2 `star` ctr)); (equiv) { star_associative (fp `star` frame) p (ls2 `star` ctr) } (fp `star` frame `star` p) `star` (ls2 `star` ctr); (equiv) { equiv_extensional_on_star (fp `star` frame `star` p) (p `star` fp `star` frame) (ls2 `star` ctr) } (p `star` fp `star` frame) `star` (ls2 `star` ctr); } let token_of_inv #p (i:inv p) : (name_of_inv i >--> p) = let (| _, _, tok |) = i in tok let with_invariant (#a:Type) (#fp:slprop) (#fp':a -> slprop) (#opened_invariants:inames) (#p:slprop) (i:inv p{not (mem_inv opened_invariants i)}) (f:action_except a (add_inv opened_invariants i) (p `star` fp) (fun x -> p `star` fp' x)) (frame:slprop) : MstTot a opened_invariants fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in NMSTTotal.recall _ mem_evolves (iname_for_p_mem (name_of_inv i) p) (token_of_inv i); assert (iname_for_p (name_of_inv i) p m0.locks); assert (interp (fp `star` frame `star` locks_invariant opened_invariants m0) m0); assert (interp (fp `star` frame `star` (lock_store_invariant opened_invariants m0.locks `star` ctr_validity m0.ctr (heap_of_mem m0))) m0); move_invariant opened_invariants m0.locks p (name_of_inv i); assert (lock_store_invariant opened_invariants m0.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks)); with_inv_helper fp frame (lock_store_invariant opened_invariants m0.locks) (ctr_validity m0.ctr (heap_of_mem m0)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks); assert (interp (p `star` fp `star` frame `star` locks_invariant (set_add (name_of_inv i) opened_invariants) m0) m0); let r = f frame in let m1 : full_mem = NMSTTotal.get () in assert (interp (p `star` fp' r `star` frame `star` locks_invariant (set_add (name_of_inv i) opened_invariants) m1) m1); assert (interp (p `star` fp' r `star` frame `star` (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks `star` ctr_validity m1.ctr (heap_of_mem m1))) m1); NMSTTotal.recall _ mem_evolves (iname_for_p_mem (name_of_inv i) p) (token_of_inv i); move_invariant opened_invariants m1.locks p (name_of_inv i); assert (lock_store_invariant opened_invariants m1.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks)); with_inv_helper (fp' r) frame (lock_store_invariant opened_invariants m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks); assert (interp (fp' r `star` frame `star` locks_invariant opened_invariants m1) m1); assert (inames_ok opened_invariants m1); r let equiv_pqrs_p_qr_s (p q r s:slprop) : Lemma ((p `star` q `star` r `star` s) `equiv` (p `star` (q `star` r) `star` s)) = star_associative p q r; equiv_extensional_on_star (p `star` q `star` r) (p `star` (q `star` r)) s let frame (#a:Type) (#opened_invariants:inames) (#pre:slprop) (#post:a -> slprop) (#req:mprop pre) (#ens:mprop2 pre post) (frame:slprop) ($f:action_except_full a opened_invariants pre post req ens) (frame0:slprop) : MstTot a opened_invariants (pre `star` frame) (fun x -> post x `star` frame) frame0 req ens = let m0 : full_mem = NMSTTotal.get () in equiv_pqrs_p_qr_s pre frame frame0 (linv opened_invariants m0); assert (interp (pre `star` frame `star` frame0 `star` linv opened_invariants m0) m0); assert (interp (pre `star` (frame `star` frame0) `star` linv opened_invariants m0) m0); let x = f (frame `star` frame0) in let m1 : full_mem = NMSTTotal.get () in equiv_pqrs_p_qr_s (post x) frame frame0 (linv opened_invariants m1); assert (interp (post x `star` (frame `star` frame0) `star` linv opened_invariants m1) m1); assert (interp (post x `star` frame `star` frame0 `star` linv opened_invariants m1) m1); x let change_slprop (#opened_invariants:inames) (p q:slprop) (proof: (m:mem -> Lemma (requires interp p m) (ensures interp q m))) = let proof (h:H.heap) : Lemma (requires H.interp p h) (ensures H.interp q h) = proof (mem_of_heap h) in lift_tot_action (lift_heap_action opened_invariants (Steel.Heap.change_slprop p q proof)) (* This module reuses is_frame_monotonic from Heap, but does not expose that to clients, so we need this lemma to typecheck witness_h_exists below. *) let relate_frame_monotonic_1 #a p : Lemma (requires (H.is_frame_monotonic p)) (ensures (is_frame_monotonic p)) = () let relate_frame_monotonic_2 #a p : Lemma (requires (is_frame_monotonic p)) (ensures (H.is_frame_monotonic p)) = let aux (x y : a) (h : H.heap) (f : H.slprop) : Lemma (requires (H.interp (p x `H.star` f) h /\ H.interp (p y) h)) (ensures (H.interp (p y `H.star` f) h)) = let m = mem_of_heap h in assert (interp (p x `star` f) m); assert (interp (p y) m); assert (interp (p y `star` f) m) in Classical.forall_intro_4 (fun x y h f -> Classical.move_requires (aux x y h) f) let witness_h_exists #opened_invariants #a p = lift_tot_action_with_frame (lift_heap_action_with_frame opened_invariants (H.witness_h_exists p)) let lift_h_exists #opened_invariants p = lift_tot_action (lift_heap_action opened_invariants (H.lift_h_exists p)) let elim_pure #opened_invariants p = lift_tot_action (lift_heap_action opened_invariants (H.elim_pure p)) let pts_to_join (#a:Type) (#pcm:pcm a) (r:ref a pcm) (x y : a) (m:mem) : Lemma (requires (interp (pts_to r x) m /\ interp (pts_to r y) m)) (ensures (joinable pcm x y)) = H.pts_to_join #a #pcm r x y (heap_of_mem m) let pts_to_evolve (#a:Type u#a) (#pcm:_) (r:ref a pcm) (x y : a) (m:mem) : Lemma (requires (interp (pts_to r x) m /\ compatible pcm y x)) (ensures (interp (pts_to r y) m)) = H.pts_to_evolve #a #pcm r x y (heap_of_mem m)

{ "checked_file": "/", "dependencies": [ "Steel.Preorder.fst.checked", "Steel.Heap.fsti.checked", "prims.fst.checked", "FStar.Witnessed.Core.fsti.checked", "FStar.Set.fsti.checked", "FStar.Preorder.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.PCM.fst.checked", "FStar.NMSTTotal.fst.checked", "FStar.List.Tot.fst.checked", "FStar.IndefiniteDescription.fsti.checked", "FStar.Ghost.fsti.checked", "FStar.FunctionalExtensionality.fsti.checked", "FStar.Classical.Sugar.fsti.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Steel.Memory.fst" }

[ { "abbrev": true, "full_module": "Steel.Preorder", "short_module": "PP" }, { "abbrev": true, "full_module": "FStar.Witnessed.Core", "short_module": "W" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": true, "full_module": "Steel.Heap", "short_module": "H" }, { "abbrev": false, "full_module": "FStar.FunctionalExtensionality", "short_module": null }, { "abbrev": true, "full_module": "FStar.FunctionalExtensionality", "short_module": "F" }, { "abbrev": true, "full_module": "FStar.Universe", "short_module": "U" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": false, "full_module": "FStar.PCM", "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

p: Steel.Memory.slprop -> q: Steel.Memory.slprop -> m: Steel.Memory.mem -> Prims.Pure (FStar.Ghost.erased Steel.Memory.mem * FStar.Ghost.erased Steel.Memory.mem)

Prims.Pure

[]

[ "Steel.Memory.slprop", "Steel.Memory.mem", "FStar.Pervasives.Native.Mktuple2", "FStar.Ghost.erased", "FStar.Ghost.reveal", "FStar.IndefiniteDescription.indefinite_description_tot", "Prims.prop", "Prims.l_Exists", "Prims.unit", "Steel.Memory.elim_star", "Prims.logical", "Prims.l_and", "Steel.Memory.disjoint", "Prims.eq2", "Steel.Memory.join", "Steel.Memory.interp", "FStar.Pervasives.Native.tuple2" ]

[]

false

let id_elim_star p q m =

let starprop (ml mr: mem) = disjoint ml mr /\ m == join ml mr /\ interp p ml /\ interp q mr in elim_star p q m; let p1: mem -> prop = fun ml -> (exists mr. starprop ml mr) in let ml = IndefiniteDescription.indefinite_description_tot _ p1 in let starpropml mr : prop = starprop ml mr in let mr = IndefiniteDescription.indefinite_description_tot _ starpropml in (ml, mr)

false

Steel.Memory.fst

Steel.Memory.slimp_star

val slimp_star (p q r s : slprop) : Lemma (requires (slimp p q /\ slimp r s)) (ensures (slimp (p `star` r) (q `star` s)))

let slimp_star (p q r s : slprop) : Lemma (requires (slimp p q /\ slimp r s)) (ensures (slimp (p `star` r) (q `star` s))) = let aux (m:mem) : Lemma (requires (interp (p `star` r) m)) (ensures (interp (q `star` s) m)) = let (ml, mr) = id_elim_star p r m in intro_star q s ml mr in Classical.forall_intro (Classical.move_requires aux)

{ "file_name": "lib/steel/Steel.Memory.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 55, "end_line": 1602, "start_col": 0, "start_line": 1593 }

(* 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.Memory module F = FStar.FunctionalExtensionality open FStar.FunctionalExtensionality open FStar.PCM module H = Steel.Heap noeq type lock_state : Type u#(a + 1) = | Invariant : inv:H.slprop u#a -> lock_state let lock_store : Type u#(a+1) = list (lock_state u#a) noeq type mem : Type u#(a + 1) = { ctr: nat; heap: H.heap u#a; locks: lock_store u#a; } let heap_of_mem (x:mem) : H.heap = x.heap let mem_of_heap (h:H.heap) : mem = { ctr = 0; heap = h; locks = [] } let mem_set_heap (m:mem) (h:H.heap) : mem = { ctr = m.ctr; heap = h; locks = m.locks; } let core_mem (m:mem) : mem = mem_of_heap (heap_of_mem m) let core_mem_invol m = () let disjoint (m0 m1:mem u#h) : prop = m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks let disjoint_sym m0 m1 = () let join m0 m1 = { ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = m0.locks } let join_commutative m0 m1 = H.join_commutative m0.heap m1.heap let disjoint_join m0 m1 m2 = H.disjoint_join m0.heap m1.heap m2.heap let join_associative m0 m1 m2 = H.join_associative m0.heap m1.heap m2.heap let slprop = H.slprop let interp p m = H.interp p m.heap let equiv p1 p2 = forall m. interp p1 m <==> interp p2 m let slprop_extensionality p q = assert (forall m. interp p m <==> interp q m); let aux (h:H.heap) : Lemma (H.interp p h <==> H.interp q h) [SMTPat (H.interp p h)] = let m : mem = { ctr = 0; heap = h; locks = [] } in assert (interp p m <==> interp q m) in assert (forall h. H.interp p h <==> H.interp q h); Steel.Heap.slprop_extensionality p q let reveal_equiv p1 p2 = () let core_ref = H.core_ref let core_ref_null = H.core_ref_null let core_ref_is_null r = H.core_ref_is_null r let emp : slprop u#a = H.emp let pure = H.pure let pts_to = H.pts_to let h_and = H.h_and let h_or = H.h_or let star = H.star let wand = H.wand let h_exists = H.h_exists let h_forall = H.h_forall //////////////////////////////////////////////////////////////////////////////// //properties of equiv //////////////////////////////////////////////////////////////////////////////// let equiv_symmetric (p1 p2:slprop u#a) = H.equiv_symmetric p1 p2 #push-options "--warn_error -271" let equiv_heap_iff_equiv (p1 p2:slprop u#a) : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat (equiv p1 p2)] = let aux_lr () : Lemma (requires H.equiv p1 p2) (ensures equiv p1 p2) [SMTPat ()] = () in let aux_rl_helper1 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p1 h) (ensures H.interp p2 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl_helper2 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p2 h) (ensures H.interp p1 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl () : Lemma (requires equiv p1 p2) (ensures H.equiv p1 p2) [SMTPat ()] = () in () let equiv_heap_iff_equiv_forall () : Lemma (ensures (forall p1 p2. H.equiv p1 p2 <==> equiv p1 p2)) = let aux p1 p2 : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat ()] = equiv_heap_iff_equiv p1 p2 in () #pop-options let equiv_extensional_on_star (p1 p2 p3:slprop u#a) = equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3 let emp_unit p = H.emp_unit p let intro_emp m = H.intro_emp (heap_of_mem m) let pure_equiv p q = H.pure_equiv p q let pure_interp q m = H.pure_interp q (heap_of_mem m) let pure_star_interp p q m = H.pure_star_interp p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// //pts_to //////////////////////////////////////////////////////////////////////////////// let pts_to_compatible #a #pcm x v0 v1 m = H.pts_to_compatible #a #pcm x v0 v1 (heap_of_mem m) let pts_to_compatible_equiv #a #pcm x v0 v1 = H.pts_to_compatible_equiv #a #pcm x v0 v1 let pts_to_not_null #a #pcm x v m = H.pts_to_not_null #a #pcm x v (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // star //////////////////////////////////////////////////////////////////////////////// let intro_star p q mp mq = H.intro_star p q (heap_of_mem mp) (heap_of_mem mq) let elim_star p q m = let h = heap_of_mem m in H.elim_star p q h; assert (exists hl hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr); let hl = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hl -> exists hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let hr = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hr -> H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let ml = mem_set_heap m hl in let mr = mem_set_heap m hr in assert (disjoint ml mr); assert (m == join ml mr); assert (interp p ml); assert (interp q mr); () let interp_star (p q: slprop) (m: mem) : Lemma (interp (p `star` q) m <==> (exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m)) = let left = interp (p `star` q) m in let right = exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m in let f () : Lemma (requires left) (ensures right) = elim_star p q m in let g () : Lemma (requires right) (ensures left) = Classical.exists_elim left #_ #(fun mp -> exists (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mp -> Classical.exists_elim left #_ #(fun mq -> disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mq -> intro_star p q mp mq ) ) in Classical.move_requires f (); Classical.move_requires g () let star_commutative (p1 p2:slprop) = H.star_commutative p1 p2 let star_associative (p1 p2 p3:slprop) = H.star_associative p1 p2 p3 let star_congruence (p1 p2 p3 p4:slprop) = equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4 let affine_star (p q:slprop) (m:mem) = H.affine_star p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // Invariants on the lock store //////////////////////////////////////////////////////////////////////////////// let iname = nat module S = FStar.Set module L = FStar.List.Tot module W = FStar.Witnessed.Core let rec lock_store_invariant (e:inames) (l:lock_store u#a) : slprop u#a = let current_addr = L.length l - 1 in match l with | [] -> emp | Invariant p :: tl -> if current_addr `S.mem` e then lock_store_invariant e tl else p `star` lock_store_invariant e tl let lock_i (i:iname) (l:lock_store { i < L.length l }) = let ix = L.length l - i - 1 in L.index l ix let iname_for_p (i:iname) (p:slprop) : W.s_predicate lock_store = fun l -> i < L.length l /\ (lock_i i l).inv == p let lock_store_evolves : FStar.Preorder.preorder lock_store = fun (l1 l2 : lock_store) -> L.length l2 >= L.length l1 /\ (forall (i:nat{i < L.length l1}). (lock_i i l1).inv == (lock_i i l2).inv) let inames_in (e:inames) (l:lock_store) : prop = forall i. Set.mem i e ==> i < L.length l let inames_ok e m = inames_in e m.locks let inames_ok_empty m = () let extend_lock_store (e:inames) (l:lock_store{e `inames_in` l}) (p:slprop) : i:iname & l':lock_store { lock_store_invariant e l' == p `star` lock_store_invariant e l /\ iname_for_p i p l' } = (| L.length l, Invariant p :: l |) let set_add (i:iname) (s:inames) = Set.union (Set.singleton i) s let rec move_invariant (e:inames) (l:lock_store) (p:slprop) (i:iname{iname_for_p i p l /\ ~(i `Set.mem` e)}) : Lemma (H.equiv (lock_store_invariant e l) (p `star` lock_store_invariant (set_add i e) l)) = let rec aux (i:iname) (m:lock_store) : Lemma (requires i >= L.length m) (ensures (lock_store_invariant e m `H.equiv` lock_store_invariant (set_add i e) m)) = match m with | [] -> () | Invariant p::tl -> aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl) in let current_addr = L.length l - 1 in match l with | [] -> () | Invariant q::tl -> if i = current_addr then begin assert (lock_store_invariant e l == p `star` lock_store_invariant e tl); aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl); () end else begin move_invariant e tl p i; assert (lock_store_invariant e tl `equiv` (p `star` lock_store_invariant (set_add i e) tl)); H.star_congruence q (lock_store_invariant e tl) q (p `star` lock_store_invariant (set_add i e) tl); if Set.mem current_addr e then () else begin let r = lock_store_invariant (set_add i e) tl in assert (lock_store_invariant e l `equiv` (q `star` (p `star` r))); H.star_associative q p r; H.star_commutative q p; H.star_congruence (q `star` p) r (p `star` q) r; H.star_associative p q r end end let heap_ctr_valid (ctr:nat) (h:H.heap u#a) : prop = h `H.free_above_addr` ctr let ctr_validity (ctr:nat) (h:H.heap) : slprop = H.pure (heap_ctr_valid ctr h) let locks_invariant (e:inames) (m:mem u#a) : slprop u#a = lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m) let full_mem_pred (m:mem) = H.full_heap_pred (heap_of_mem m) (***** Following lemmas are needed in Steel.Effect *****) let core_mem_interp (hp:slprop u#a) (m:mem u#a) = () let interp_depends_only_on (hp:slprop u#a) = H.interp_depends_only_on hp let a_mem_prop_as_a_heap_prop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (H.a_heap_prop u#a) = let g (h: H.heap u#a) : Tot prop = interp sl (mem_of_heap h) /\ f (mem_of_heap h) in let phi0 (h0 h1: H.heap u#a) : Lemma (requires (g h0 /\ H.disjoint h0 h1)) (ensures (g h0 /\ H.disjoint h0 h1 /\ g (H.join h0 h1))) = assert (mem_of_heap (H.join h0 h1) == mem_of_heap h0 `join` mem_of_heap h1); interp_depends_only_on sl in let phi1 (h0 h1: H.heap u#a) : Lemma (ensures ((g h0 /\ H.disjoint h0 h1) ==> g (H.join h0 h1))) = Classical.move_requires (phi0 h0) h1 in Classical.forall_intro_2 phi1; g let refine_slprop sl f = H.as_slprop (a_mem_prop_as_a_heap_prop sl f) let interp_refine_slprop sl f m = assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_mem m)) let dep_hprop (s: slprop) (f: (hmem s -> Tot slprop)) (h: H.heap) : Tot prop = exists (h1: H.heap) . exists (h2: H.heap) . interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 let dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq' : squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h')) = let p2 (h h1 h2: H.heap) : Tot prop = interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 in let p1 (h h1: H.heap) : Tot prop = (exists h2 . p2 h h1 h2) in let h1 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p1 h) in let h2 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p2 h h1) in H.disjoint_join h' h1 h2; assert (H.disjoint h2 h'); let h2' = H.join h2 h' in H.join_commutative h2 h' ; assert (h2' == H.join h' h2); assert (H.disjoint h1 h2'); assert (mem_of_heap h2' == mem_of_heap h2 `join` mem_of_heap h'); interp_depends_only_on (f (mem_of_heap h1)); assert (interp (f (mem_of_heap h1)) (mem_of_heap h2')); H.join_commutative h1 h2; H.join_associative h' h2 h1; H.join_commutative h' h; H.join_commutative h2' h1; assert (H.join h h' == h1 `H.join` h2') let impl_intro_gen (#p: Type0) (#q: Type0) ($prf: (squash p -> Lemma (q ))) : Lemma (p ==> q) = Classical.impl_intro_gen #p #(fun _ -> q) prf let dep_hprop_is_affine1 (s: slprop) (f: (hmem s -> Tot slprop)) (h0 h1: H.heap) : Lemma ((dep_hprop s f h0 /\ H.disjoint h0 h1) ==> (H.disjoint h0 h1 /\ dep_hprop s f (H.join h0 h1))) = impl_intro_gen (dep_hprop_is_affine0 s f h0 h1) let dep_hprop_is_affine (s: slprop) (f: (hmem s -> Tot slprop)) : Lemma (H.heap_prop_is_affine (dep_hprop s f)) = Classical.forall_intro_2 (dep_hprop_is_affine1 s f) let sdep (s: slprop) (f: (hmem s -> Tot slprop)) : Tot slprop = dep_hprop_is_affine s f; H.as_slprop (dep_hprop s f) let interp_sdep (s: slprop) (f: (hmem s -> Tot slprop)) (m: mem) : Lemma (requires (dep_slprop_is_affine s f)) (ensures ( interp (sdep s f) m <==> (exists m1 m2 . interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) )) = dep_hprop_is_affine s f; assert (forall m1 m2 . (interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) ==> ( interp s (mem_of_heap m1.heap) /\ interp (f (mem_of_heap m1.heap)) (mem_of_heap m2.heap) /\ H.disjoint m1.heap m2.heap /\ H.join m1.heap m2.heap == m.heap )); interp_depends_only_on s; Classical.forall_intro (fun m -> interp_depends_only_on (f m)); assert (forall h1 h2 . (interp s (mem_of_heap h1) /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ H.disjoint h1 h2 /\ H.join h1 h2 == m.heap) ==> ( core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ interp s (core_mem (mem_of_heap h1)) /\ interp s (mem_set_heap m h1) /\ core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ f (mem_set_heap m h1) `equiv` f (mem_of_heap h1) /\ interp (f (mem_set_heap m h1)) (mem_of_heap h2) /\ interp (f (mem_set_heap m h1)) (mem_set_heap m h2) /\ disjoint (mem_set_heap m h1) (mem_set_heap m h2) /\ join (mem_set_heap m h1) (mem_set_heap m h2) == m )); () let h_exists_cong (#a:Type) (p q : a -> slprop) : Lemma (requires (forall x. p x `equiv` q x)) (ensures (h_exists p `equiv` h_exists q)) = equiv_heap_iff_equiv_forall (); H.h_exists_cong p q let intro_h_exists #a x p m = H.intro_h_exists x p (heap_of_mem m) let elim_h_exists (#a:_) (p:a -> slprop) (m:mem) = H.elim_h_exists p (heap_of_mem m) let intro_h_forall (#a:_) (p:a -> slprop) (m:mem) = H.intro_h_forall p (heap_of_mem m) let elim_h_forall (#a:_) (p:a -> slprop) (m:mem) (x:a) = H.elim_h_forall p (heap_of_mem m) x let intro_h_and (p q: slprop) (m:mem) = H.intro_h_and p q (heap_of_mem m) let elim_h_and (p q: slprop) (m:mem) = H.elim_h_and p q (heap_of_mem m) let intro_h_or_left (p q: slprop) (m:mem) = H.intro_h_or_left p q (heap_of_mem m) let intro_h_or_right (p q: slprop) (m:mem) = H.intro_h_or_right p q (heap_of_mem m) let elim_h_or (p q: slprop) (m:mem) = H.elim_h_or p q (heap_of_mem m) let intro_wand (p1 p2: slprop u#a) (m:mem) = introduce (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)) ==> interp (wand p1 p2) m with _. ( assert (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)); H.intro_wand p1 p2 (heap_of_mem m); let h = heap_of_mem m in assert ((forall h1. h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) ==> H.interp (wand p1 p2) h); introduce forall h1. (h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) with ( introduce (h `H.disjoint` h1 /\ H.interp p1 h1) ==> H.interp p2 (H.join h h1) with _. ( assert (h `H.disjoint` h1); let m1 = { ctr = m.ctr; heap = h1; locks = m.locks } in assert (m `disjoint` m1) ) ) ) (** Eliminating a wand by proving a heap that satisfies the LHS **) let elim_wand (p1 p2: slprop u#a) (m:mem) (m1:mem) = H.elim_wand p1 p2 (heap_of_mem m) (heap_of_mem m1) //////////////////////////////////////////////////////////////////////////////// // Preorders and effects //////////////////////////////////////////////////////////////////////////////// module PP = Steel.Preorder let mem_evolves = fun (m0 m1:full_mem) -> H.heap_evolves (heap_of_mem m0) (heap_of_mem m1) /\ m0.ctr <= m1.ctr /\ lock_store_evolves m0.locks m1.locks (** See [Steel.Heap.is_frame_preserving]. We add in [lock_invariants] now *) let preserves_frame (e:inames) (pre post:slprop) (m0 m1:mem) = forall (frame:slprop). interp ((pre `star` frame) `star` locks_invariant e m0) m0 ==> (interp ((post `star` frame) `star` locks_invariant e m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) (** This is a version of MstTot with frame quantified, as part of preserves_frame *) effect MstTotNF (a:Type u#a) (except:inames) (expects:slprop u#1) (provides: a -> slprop u#1) = NMSTTotal.NMSTATETOT a (full_mem u#1) mem_evolves (requires fun m0 -> inames_ok except m0 /\ interp (expects `star` locks_invariant except m0) m0) (ensures fun m0 x m1 -> inames_ok except m1 /\ interp (provides x `star` locks_invariant except m1) m1 /\ preserves_frame except expects (provides x) m0 m1) //////////////////////////////////////////////////////////////////////////////// // Lifting heap actions //////////////////////////////////////////////////////////////////////////////// (** Heap actions come in two equivalent flavors: - one that take an explicit frame as argument (action_with_frame) - and one that quantify over all the frame We therefore define two lift routes: - a direct route for those with explicit frame - via MstTotNF for the rest *) let tot_pre_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = hmem_with_inv_except e fp -> (x:a & hmem_with_inv_except e (fp' x)) let tot_pre_action_nf = tot_pre_action_nf_except S.empty let ac_reasoning_for_m_frame_preserving (p q r:slprop u#a) (m:mem u#a) : Lemma (requires interp ((p `star` q) `star` r) m) (ensures interp (p `star` r) m) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_commutative p q; equiv_extensional_on_star (p `star` q) (q `star` p) r } (q `star` p) `star` r; (equiv) { star_associative q p r } q `star` (p `star` r); }; assert (interp (q `star` (p `star` r)) m); affine_star q (p `star` r) m let is_frame_preserving (#e:inames) (#a:Type u#b) (#fp:slprop u#a) (#fp':a -> slprop u#a) (f:tot_pre_action_nf_except e fp a fp') = forall (frame:slprop u#a) (m0:hmem_with_inv_except e (fp `star` frame)). (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = f:tot_pre_action_nf_except e fp a fp'{ is_frame_preserving f } let tot_action_nf = tot_action_nf_except S.empty let linv e (m:mem) = locks_invariant e m let hheap_of_hmem #fp #e (m:hmem_with_inv_except e fp) : h:H.hheap (fp `star` linv e m) { h `H.free_above_addr` m.ctr} = let h = heap_of_mem m in H.pure_interp (heap_ctr_valid m.ctr (heap_of_mem m)) h; h let hmem_of_hheap #e (#fp0 #fp1:slprop) (m:hmem_with_inv_except e fp0) (h:H.full_hheap (fp1 `star` linv e m) { h `Heap.free_above_addr` m.ctr }) : m1:hmem_with_inv_except e fp1{linv e m `equiv` linv e m1} = let m1 : mem = { m with heap = h } in assert (interp (fp1 `star` linv e m) m1); star_commutative fp1 (linv e m); assert (interp (linv e m `star` fp1) m1); assert (linv e m1 == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); assert (linv e m == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m)); H.pure_interp (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_of_mem m); assert (heap_ctr_valid m1.ctr (heap_of_mem m) <==> heap_ctr_valid m1.ctr (heap_of_mem m1)); H.pure_equiv (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_ctr_valid m1.ctr (heap_of_mem m1)); H.star_congruence (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m)); assert (linv e m `equiv` linv e m1); let _ = equiv_extensional_on_star (linv e m) (linv e m1) fp1 in assert ((linv e m `star` fp1) `equiv` (linv e m1 `star` fp1)); assert (interp (linv e m1 `star` fp1) m1); star_commutative (linv e m1) fp1; assert (interp (fp1 `star` linv e m1) m1); m1 let with_inv_except (m:mem) e (fp:slprop) = interp (fp `star` locks_invariant e m) m #push-options "--warn_error -271" let as_hprop (frame:slprop) (mp:mprop frame) : hp:H.hprop frame{forall m. mp (core_mem m) == hp (heap_of_mem m)} = let f = fun h -> mp (mem_of_heap h) in assert (forall m. mp (core_mem m) == f (heap_of_mem m)); let aux (m0:H.hheap frame) (m1:H.heap{H.disjoint m0 m1}) : Lemma (ensures (mem_of_heap (H.join m0 m1) == join (mem_of_heap m0) (mem_of_heap m1))) [SMTPat ()] = () in f let mprop_preservation_of_hprop_preservation (p:slprop) (m0 m1:mem) : Lemma (requires (forall (hp:H.hprop p). hp (heap_of_mem m0) == hp (heap_of_mem m1))) (ensures (forall (mp:mprop p). mp (core_mem m0) == mp (core_mem m1))) = let aux (mp:mprop p) : Lemma (mp (core_mem m0) == mp (core_mem m1)) [SMTPat()] = assert (as_hprop p mp (heap_of_mem m0) == as_hprop p mp (heap_of_mem m1)) in () let lift_heap_action (#fp:slprop) (#a:Type) (#fp':a -> slprop) (e:inames) ($f:H.action fp a fp') : tot_action_nf_except e fp a fp' = let g : tot_pre_action_nf_except e fp a fp' = fun m -> let h0 = hheap_of_hmem m in let (| x, h' |) = f h0 in (| x, hmem_of_hheap m h' |) in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in let h0 = hheap_of_hmem m0 in let (| x', h1 |) = f h0 in H.action_framing f (linv e m0) h0; assert (x == x'); star_associative fp frame (linv e m0); H.action_framing f (frame `star` linv e m0) h0; assert (H.interp ((fp' x) `star` (frame `star` linv e m0)) h1); star_associative (fp' x) frame (linv e m0); assert (H.interp ((fp' x `star` frame) `star` linv e m0) h1); let h1' : H.hheap ((fp' x `star` frame) `star` linv e m0) = h1 in assert (m1 == hmem_of_hheap m0 h1'); assert (with_inv_except m1 e (fp' x `star` frame)); assert (forall (hp:H.hprop frame). hp h0 == hp h1); mprop_preservation_of_hprop_preservation frame m0 m1; () in assert (is_frame_preserving g); g let frame_preserving_respects_preorder #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (m0:hmem_with_inv_except e fp) : Lemma (let (| x, m1 |) = f m0 in mem_evolves m0 m1) = let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1) = () in H.emp_unit fp; assert (interp (fp `star` linv e m0) m0); H.star_congruence (fp `star` emp) (linv e m0) fp (linv e m0); assert (interp ((fp `star` emp) `star` linv e m0) m0); aux emp m0 let lift_tot_action_nf #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') : MstTotNF a e fp fp' = let m0 = NMSTTotal.get () in let m0' : hmem_with_inv_except e fp = m0 in let r = f m0' in let (| x, m1 |) = r in let m1' : hmem_with_inv_except e (fp' x) = m1 in assert (is_frame_preserving f); assert (m1 == dsnd (f m0)); frame_preserving_respects_preorder f m0; NMSTTotal.put #_ #(mem_evolves) m1; x let lift_tot_action #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get #(full_mem) #_ () in ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); lift_tot_action_nf f (** Now defining the lift for heap actions with explicit frame *) let tot_action_with_frame_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = frame:slprop u#a -> m0:hmem_with_inv_except e (fp `star` frame) -> Pure (x:a & hmem_with_inv_except e (fp' x `star` frame)) (requires True) (ensures fun (| x, m1 |) -> mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_with_frame = tot_action_with_frame_except S.empty let lift_heap_action_with_frame (#fp:slprop u#a) (#a:Type u#b) (#fp':a -> slprop u#a) (e:inames) ($f:H.action_with_frame fp a fp') : tot_action_with_frame_except e fp a fp' = fun frame m0 -> let h0 = hheap_of_hmem m0 in calc (equiv) { fp `star` frame `star` locks_invariant e m0; (equiv) { star_associative fp frame (locks_invariant e m0) } fp `star` (frame `star` locks_invariant e m0); }; assert (H.interp (fp `star` frame `star` locks_invariant e m0) h0); assert (H.interp (fp `star` (frame `star` locks_invariant e m0)) h0); //key: apply the heap action with frame * locks_invariant e m0 let (| x, h1 |) = f (frame `star` locks_invariant e m0) h0 in calc (equiv) { fp' x `star` (frame `star` locks_invariant e m0); (equiv) { star_associative (fp' x) frame (locks_invariant e m0) } fp' x `star` frame `star` locks_invariant e m0; }; assert (H.interp (fp' x `star` (frame `star` locks_invariant e m0)) h1); assert (H.interp (fp' x `star` frame `star` locks_invariant e m0) h1); let m1 = hmem_of_hheap m0 h1 in assert (mem_evolves m0 m1); mprop_preservation_of_hprop_preservation (frame `star` locks_invariant e m0) m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)); (| x, m1 |) let lift_tot_action_with_frame #a #e #fp #fp' ($f:tot_action_with_frame_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in assert (inames_ok e m0); ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); let m0' : hmem_with_inv_except e fp = m0 in let r = f frame m0' in let (| x, m1 |) = r in ac_reasoning_for_m_frame_preserving (fp' x) frame (locks_invariant e m1) m1; assert (interp (fp' x `star` frame `star` locks_invariant e m1) m1); assert (interp (fp' x `star` locks_invariant e m1) m1); let m1' : hmem_with_inv_except e (fp' x) = m1 in NMSTTotal.put #_ #(mem_evolves) m1; x let sel_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.sel_action #a #pcm r v0)) let upd_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.upd_action #a #pcm r v0 v1)) let free_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.free_action #a #pcm r v0)) let split_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.split_action #a #pcm r v0 v1)) let gather_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.gather_action #a #pcm r v0 v1)) let weaken (p q r:slprop) (h:H.hheap (p `star` q) { H.stronger q r }) : H.hheap (p `star` r) = H.weaken p q r h; h let weaken_pure (q r: prop) : Lemma (requires (q ==> r)) (ensures H.stronger (H.pure q) (H.pure r)) = let aux (h:H.heap) : Lemma (ensures (H.interp (H.pure q) h ==> H.interp (H.pure r) h)) [SMTPat ()] = H.pure_interp q h; H.pure_interp r h in () let inc_ctr (#p:slprop) #e (m:hmem_with_inv_except e p) : m':hmem_with_inv_except e p{m'.ctr = m.ctr + 1 /\ H.stronger (linv e m) (linv e m')} = let m' : mem = { m with ctr = m.ctr + 1} in assert (interp (p `star` linv e m) m'); assert (linv e m == lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m)); assert (linv e m' == lock_store_invariant e m.locks `star` ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken_free_above (heap_of_mem m) m.ctr (m.ctr + 1); weaken_pure (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_ctr_valid (m.ctr + 1) (heap_of_mem m)); assert (H.stronger (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m))); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)); H.stronger_star (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken (p `star` lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)) (heap_of_mem m'); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity (m.ctr + 1) (heap_of_mem m)); let m' : hmem_with_inv_except e p = m' in m' let frame_related_mems (fp0 fp1:slprop u#a) e (m0:hmem_with_inv_except e fp0) (m1:hmem_with_inv_except e fp1) = forall (frame:slprop u#a). interp ((fp0 `star` frame) `star` linv e m0) m0 ==> interp ((fp1 `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) let refined_pre_action e (fp0:slprop) (a:Type) (fp1:a -> slprop) = m0:hmem_with_inv_except e fp0 -> Pure (x:a & hmem_with_inv_except e (fp1 x)) (requires True) (ensures fun (| x, m1 |) -> frame_related_mems fp0 (fp1 x) e m0 m1) let refined_pre_action_as_action (#fp0:slprop) (#a:Type) (#fp1:a -> slprop) #e ($f:refined_pre_action e fp0 a fp1) : tot_action_nf_except e fp0 a fp1 = let g : tot_pre_action_nf_except e fp0 a fp1 = fun m -> f m in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp0 `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp1 x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x', m1' |) = g m0 in let (| x, m1 |) = f m0 in assert (x == x' /\ m1 == m1') in g let alloc_action #a #pcm e x = let f : refined_pre_action e emp (ref a pcm) (fun r -> pts_to r x) = fun m0 -> (* NS: 9/29/22 I needed to annotate h : Heap.full_heap, for use with the Core checker which generates a guard for checking the implicit pattern "dot" term in the dependent pair pattern on the next line. That guard expects `h` to be a full_heap, which is it, because it is a projection of m0. However, this is not reflected in `h`'s type. So, the Core checker, which produces a guard for the pat_dot_term in isolation, cannot recheck the term. If we were to fold in the checking of pat_dot_terms and their guards with the rest of the VC, this would work. *) let h : Heap.full_heap = hheap_of_hmem m0 in let (|r, h'|) = H.extend #a #pcm x m0.ctr h in let m' : hmem_with_inv_except e emp = inc_ctr m0 in let h' : H.hheap (pts_to #a #pcm r x `star` linv e m') = weaken _ (linv e m0) (linv e m') h' in let m1 : hmem_with_inv_except e (pts_to #a #pcm r x) = hmem_of_hheap m' h' in assert (forall frame. H.frame_related_heaps h h' emp (pts_to #a #pcm r x) frame true); let aux (frame:slprop) : Lemma (requires interp ((emp `star` frame) `star` linv e m0) m0) (ensures interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) [SMTPat (emp `star` frame)] = star_associative emp frame (linv e m0); assert (H.interp (emp `star` (frame `star` linv e m0)) h); assert (H.interp (pts_to #a #pcm r x `star` (frame `star` linv e m0)) h'); star_associative (pts_to #a #pcm r x) frame (linv e m0); assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m0) h'); assert (H.stronger (linv e m0) (linv e m')); assert (H.equiv (linv e m') (linv e m1)); assert (H.stronger (linv e m0) (linv e m1)); let h' : H.hheap ((pts_to #a #pcm r x `star` frame) `star` linv e m1) = weaken _ (linv e m0) (linv e m1) h' in assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) h'); assert (forall (mp:H.hprop frame). mp h == mp h'); mprop_preservation_of_hprop_preservation frame m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) in assert (frame_related_mems emp (pts_to r x) e m0 m1); (| r, m1 |) in lift_tot_action (refined_pre_action_as_action f) let select_refine #a #p e r x f = lift_tot_action (lift_heap_action e (H.select_refine #a #p r x f)) let upd_gen #a #p e r x y f = lift_tot_action (lift_heap_action e (H.upd_gen_action r x y f)) //////////////////////////////////////////////////////////////////////////////// // witness / recall //////////////////////////////////////////////////////////////////////////////// let witnessed_ref #a #pcm (r:ref a pcm) (fact:property a) (m:full_mem) = H.witnessed_ref #a #pcm r fact (heap_of_mem m) let witnessed_ref_stability #a #pcm (r:ref a pcm) (fact:property a) : Lemma (requires FStar.Preorder.stable fact (Steel.Preorder.preorder_of_pcm pcm)) (ensures FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) = H.witnessed_ref_stability #a #pcm r fact let witnessed (#a:Type u#1) (#pcm:pcm a) (r:ref a pcm) (fact:property a) = W.witnessed _ mem_evolves (witnessed_ref r fact) let rearrange_pqr_prq (p q r:slprop) : Lemma (((p `star` q) `star` r) `equiv` ((p `star` r) `star` q)) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_associative p q r } p `star` (q `star` r); (equiv) { star_commutative q r; star_congruence p (q `star` r) p (r `star` q) } p `star` (r `star` q); (equiv) { star_associative p r q } (p `star` r) `star` q; } let preserves_frame_cong (e:inames) (p q:slprop) (r s:slprop) (m0 m1:mem) : Lemma (requires p `equiv` r /\ q `equiv` s /\ preserves_frame e p q m0 m1) (ensures preserves_frame e r s m0 m1) = let aux0 (p q r s:slprop) : Lemma (requires p `equiv` s) (ensures (((p `star` q) `star` r) `equiv` ((s `star` q) `star` r))) = star_congruence p q s q; star_congruence (p `star` q) r (s `star` q) r in let aux (frame:slprop) : Lemma (requires interp ((r `star` frame) `star` locks_invariant e m0) m0) (ensures interp ((s `star` frame) `star` locks_invariant e m1) m1 /\ interp ((p `star` frame) `star` locks_invariant e m0) m0) [SMTPat (r `star` frame)] = aux0 p frame (locks_invariant e m0) r; aux0 q frame (locks_invariant e m1) s; assert (((p `star` frame) `star` locks_invariant e m0) `equiv` ((r `star` frame) `star` locks_invariant e m0)); assert (interp ((p `star` frame) `star` locks_invariant e m0) m0); assert (interp ((q `star` frame) `star` locks_invariant e m1) m1); assert (((q `star` frame) `star` locks_invariant e m1) `equiv` ((s `star` frame) `star` locks_invariant e m1)); () in () let pure_true_equiv (p:slprop) : Lemma ((p `star` pure True) `equiv` p) = FStar.Classical.forall_intro (pure_star_interp p True); emp_unit p; assert ((p `star` pure True) `equiv` p) let preserves_frame_star_pure (e:inames) (p q:slprop) (r s:prop) (m:mem) : Lemma (requires r /\ s) (ensures preserves_frame e p q m m <==> preserves_frame e (p `star` pure r) (q `star` pure s) m m) = pure_equiv r True; star_congruence p (pure r) p (pure True); pure_equiv s True; star_congruence q (pure s) q (pure True); pure_true_equiv p; pure_true_equiv q; let fwd () : Lemma (requires preserves_frame e p q m m) (ensures preserves_frame e (p `star` pure r) (q `star` pure s) m m) [SMTPat ()] = preserves_frame_cong e p q (p `star` pure r) (q `star` pure s) m m in let bk () : Lemma (requires preserves_frame e (p `star` pure r) (q `star` pure s) m m) (ensures preserves_frame e p q m m) [SMTPat ()] = preserves_frame_cong e (p `star` pure r) (q `star` pure s) p q m m in () let witness (#a:Type) (#pcm:pcm a) (e:inames) (r:erased (ref a pcm)) (fact:stable_property pcm) (v:Ghost.erased a) (_:squash (forall z. compatible pcm v z ==> fact z)) (frame:slprop) : MstTot (witnessed r fact) e (pts_to r v) (fun _ -> pts_to r v) frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in let _ : unit = let hr : H.ref a pcm = r in let v' = H.sel_v hr v (heap_of_mem m0) in assert (interp (H.ptr hr) m0 /\ H.sel #a #pcm hr (heap_of_mem m0) == v'); assert (compatible pcm v v'); assert (fact v'); assert (witnessed_ref r fact m0); witnessed_ref_stability r fact; assert (FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) in let w = NMSTTotal.witness _ mem_evolves (witnessed_ref r fact) in w let recall (#a:Type u#1) (#pcm:pcm a) (#fact:property a) (e:inames) (r:erased (ref a pcm)) (v:Ghost.erased a) (w:witnessed r fact) (frame:slprop) = let m0 = NMSTTotal.get () in NMSTTotal.recall _ mem_evolves (witnessed_ref r fact) w; let hr : H.ref a pcm = r in assert (witnessed_ref r fact m0); let v1 = H.sel_v hr v (heap_of_mem m0) in assert (compatible pcm v v1); assert (H.sel hr (heap_of_mem m0) == v1); assert (fact v1); assert (interp ((pts_to r v `star` frame) `star` locks_invariant e m0) m0); emp_unit ((pts_to r v `star` frame) `star` locks_invariant e m0); pure_star_interp ((pts_to r v `star` frame) `star` locks_invariant e m0) (fact v1) m0; assert (interp (((pts_to r v `star` frame) `star` locks_invariant e m0) `star` pure (fact v1)) m0); rearrange_pqr_prq (pts_to r v `star` frame) (locks_invariant e m0) (pure (fact v1)); assert (interp (((pts_to r v `star` frame) `star` pure (fact v1)) `star` locks_invariant e m0) m0); rearrange_pqr_prq (pts_to r v) frame (pure (fact v1)); star_congruence ((pts_to r v `star` frame) `star` pure (fact v1)) (locks_invariant e m0) ((pts_to r v `star` pure (fact v1)) `star` frame) (locks_invariant e m0); Ghost.hide v1 let iname_for_p_mem (i:iname) (p:slprop) : W.s_predicate mem = fun m -> iname_for_p i p m.locks let iname_for_p_stable (i:iname) (p:slprop) : Lemma (W.stable full_mem mem_evolves (iname_for_p_mem i p)) = () let ( >--> ) (i:iname) (p:slprop) : Type0 = W.witnessed full_mem mem_evolves (iname_for_p_mem i p) let hmem_with_inv_equiv e (m:mem) (p:slprop) : Lemma (interp (p `star` linv e m) m <==> interp (p `star` lock_store_invariant e m.locks) m /\ heap_ctr_valid m.ctr (heap_of_mem m)) = calc (<==>) { interp (p `star` linv e m) m; (<==>) { H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) } interp ((p `star` lock_store_invariant e m.locks) `star` ctr_validity m.ctr (heap_of_mem m)) m; (<==>) { H.pure_star_interp (p `star` lock_store_invariant e m.locks) (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_of_mem m) } interp ((p `star` lock_store_invariant e m.locks) `star` emp) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); (<==>) { H.emp_unit (p `star` lock_store_invariant e m.locks) } interp (p `star` lock_store_invariant e m.locks) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); } let new_invariant_tot_action (e:inames) (p:slprop) (m0:hmem_with_inv_except e p{ e `inames_in` m0.locks }) : Pure (iname & hmem_with_inv_except e emp) (requires True) (ensures fun (i, m1) -> iname_for_p_mem i p m1 /\ frame_related_mems p emp e m0 m1 /\ mem_evolves m0 m1) = let (| i, l1 |) = extend_lock_store e m0.locks p in let m1 = { m0 with locks = l1 } in assert (lock_store_invariant e m1.locks == p `star` lock_store_invariant e m0.locks); calc (equiv) { linv e m1; (equiv) {} (lock_store_invariant e m1.locks `star` ctr_validity m1.ctr (heap_of_mem m1)); (equiv) {} ((p `star` lock_store_invariant e m0.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); (equiv) { H.star_associative p (lock_store_invariant e m0.locks) (ctr_validity m1.ctr (heap_of_mem m1)) } (p `star` (lock_store_invariant e m0.locks `star` ctr_validity m1.ctr (heap_of_mem m1))); (equiv) { } (p `star` linv e m0); }; assert (iname_for_p_mem i p m1); assert (lock_store_evolves m0.locks l1); assert (mem_evolves m0 m1); hmem_with_inv_equiv e m0 p; assert (interp (p `star` lock_store_invariant e m0.locks) m1); assert (interp (lock_store_invariant e m1.locks) m1); H.emp_unit (lock_store_invariant e m1.locks); H.star_commutative (lock_store_invariant e m1.locks) emp; assert (interp (emp `star` lock_store_invariant e m1.locks) m1); hmem_with_inv_equiv e m1 emp; let m1 : hmem_with_inv_except e emp = m1 in let aux (frame:slprop) : Lemma (requires interp ((p `star` frame) `star` linv e m0) m0) (ensures interp ((emp `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) <==> mp (core_mem m1))) [SMTPat (p `star` frame)] = assert (interp ((p `star` frame) `star` linv e m0) m1); calc (equiv) { ((p `star` frame) `star` linv e m0); (equiv) { H.star_commutative p frame; H.star_congruence (p `star` frame) (linv e m0) (frame `star` p) (linv e m0); H.star_associative frame p (linv e m0) } (frame `star` (p `star` linv e m0)); (equiv) { H.star_congruence frame (p `star` linv e m0) frame (linv e m1) } (frame `star` linv e m1); (equiv) { H.emp_unit (frame `star` linv e m1); H.star_commutative (frame `star` linv e m1) emp; H.star_associative emp frame (linv e m1) } ((emp `star` frame) `star` linv e m1); }; assert (interp ((emp `star` frame) `star` linv e m1) m1) in assert (frame_related_mems p emp e m0 m1); ( i, m1 ) let name_is_ok (i:iname) (m0:full_mem u#1) : prop = i < List.Tot.length m0.locks let witnessed_name_is_ok (i:iname) = W.witnessed full_mem mem_evolves (name_is_ok i) let pre_inv = i:erased iname & witnessed_name_is_ok i let inv (p:slprop u#1) = i:erased iname & witnessed_name_is_ok i & (i >--> p) let pre_inv_of_inv #p (i:inv p) = let (|i, w, _|) = i in (|i,w|) let name_of_pre_inv (i:pre_inv) = dfst i let rec recall_all (ctx:list pre_inv) : NMSTTotal.NMSTATETOT unit (full_mem u#1) mem_evolves (requires fun _ -> True) (ensures fun m0 _ m1 -> m0==m1 /\ (forall i. i `List.Tot.memP` ctx ==> name_is_ok (name_of_pre_inv i) m0)) = match ctx with | [] -> () | hd::tl -> let (| q, i |) = hd in let i : W.witnessed full_mem mem_evolves (name_is_ok q) = i in NMSTTotal.recall _ mem_evolves (name_is_ok q) i; recall_all tl let fresh_invariant (e:inames) (p:slprop) (ctx:list pre_inv) (frame:slprop) : MstTot (i:inv p { not (mem_inv e i) /\ fresh_wrt ctx (name_of_inv i)}) e p (fun _ -> emp) frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in recall_all ctx; ac_reasoning_for_m_frame_preserving p frame (locks_invariant e m0) m0; assert (interp (p `star` locks_invariant e m0) m0); let r = new_invariant_tot_action e p m0 in let ( i, m1 ) = r in assert (i == List.Tot.length m0.locks); assert (not (Set.mem i e)); assert (mem_evolves m0 m1); NMSTTotal.put #full_mem #mem_evolves m1; iname_for_p_stable i p; let w = NMSTTotal.witness full_mem mem_evolves (iname_for_p_mem i p) in let w0 = NMSTTotal.witness full_mem mem_evolves (name_is_ok i) in (| hide i, w0, w |) let new_invariant (e:inames) (p:slprop) (frame:slprop) : MstTot (inv p) e p (fun _ -> emp) frame (fun _ -> True) (fun _ _ _ -> True) = fresh_invariant e p [] frame let rearrange_invariant (p q r : slprop) (q0 q1:slprop) : Lemma (requires q `equiv` (q0 `star` q1)) (ensures (p `star` (q `star` r)) `equiv` ((q0 `star` p) `star` (q1 `star` r))) = calc (equiv) { p `star` (q `star` r); (equiv) { calc (equiv) { (q `star` r); (equiv) { star_congruence q r (q0 `star` q1) r } (q0 `star` q1) `star` r; }; star_congruence p (q `star` r) p ((q0 `star` q1) `star` r) } (p `star` ((q0 `star` q1) `star` r)); (equiv) { star_associative q0 q1 r; star_congruence p ((q0 `star` q1) `star` r) p (q0 `star` (q1 `star` r)); star_associative p q0 (q1 `star` r) } (p `star` q0) `star` (q1 `star` r); (equiv) { star_commutative p q0; star_congruence (p `star` q0) (q1 `star` r) (q0 `star` p) (q1 `star` r) } (q0 `star` p) `star` (q1 `star` r); } let preserves_frame_invariant (fp fp':slprop) (opened_invariants:inames) (p:slprop) (i:inv p{not (mem_inv opened_invariants i)}) (m0:hmem_with_inv_except (add_inv opened_invariants i) (p `star` fp)) (m1:mem) : Lemma (requires preserves_frame (set_add (name_of_inv i) opened_invariants) (p `star` fp) (p `star` fp') m0 m1 /\ interp (fp' `star` linv opened_invariants m1) m1 /\ inames_ok opened_invariants m1 /\ (lock_store_invariant opened_invariants m0.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks)) /\ (lock_store_invariant opened_invariants m1.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks))) (ensures preserves_frame opened_invariants fp fp' m0 m1) = let aux (frame:slprop) : Lemma (requires interp ((fp `star` frame) `star` linv opened_invariants m0) m0) (ensures interp ((fp' `star` frame) `star` linv opened_invariants m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) [SMTPat()] = rearrange_invariant (fp `star` frame) (lock_store_invariant opened_invariants m0.locks) (ctr_validity m0.ctr (heap_of_mem m0)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks); assert (interp ((p `star` (fp `star` frame)) `star` linv (set_add (name_of_inv i) opened_invariants) m0) m0); star_associative p fp frame; star_congruence (p `star` (fp `star` frame)) (linv (set_add (name_of_inv i) opened_invariants) m0) ((p `star` fp) `star` frame) (linv (set_add (name_of_inv i) opened_invariants) m0); assert (interp (((p `star` fp) `star` frame) `star` linv (set_add (name_of_inv i) opened_invariants) m0) m0); assert (interp (((p `star` fp') `star` frame) `star` linv (set_add (name_of_inv i) opened_invariants) m1) m1); star_associative p fp' frame; star_congruence ((p `star` fp') `star` frame) (linv (set_add (name_of_inv i) opened_invariants) m1) (p `star` (fp' `star` frame)) (linv (set_add (name_of_inv i) opened_invariants) m1); assert (interp ((p `star` (fp' `star` frame)) `star` linv (set_add (name_of_inv i) opened_invariants) m1) m1); rearrange_invariant (fp' `star` frame) (lock_store_invariant opened_invariants m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks); assert (interp ((fp' `star` frame) `star` linv opened_invariants m1) m1); () in () let equiv_ext_right (p q r:slprop) : Lemma (requires q `equiv` r) (ensures (p `star` q) `equiv` (p `star` r)) = calc (equiv) { p `star` q; (equiv) { star_commutative p q } q `star` p; (equiv) { equiv_extensional_on_star q r p } r `star` p; (equiv) { star_commutative p r } p `star` r; } let with_inv_helper (fp frame ls1 ctr p ls2:slprop) : Lemma (requires ls1 `equiv` (p `star` ls2)) (ensures (fp `star` frame `star` (ls1 `star` ctr)) `equiv` (p `star` fp `star` frame `star` (ls2 `star` ctr))) = calc (equiv) { ls1 `star` ctr; (equiv) { equiv_extensional_on_star ls1 (p `star` ls2) ctr } p `star` ls2 `star` ctr; }; calc (equiv) { p `star` ls2 `star` ctr; (equiv) { star_associative p ls2 ctr } p `star` (ls2 `star` ctr); }; calc (equiv) { fp `star` frame `star` p; (equiv) { star_commutative (fp `star` frame) p } p `star` (fp `star` frame); (equiv) { star_associative p fp frame } p `star` fp `star` frame; }; calc (equiv) { fp `star` frame `star` (ls1 `star` ctr); (equiv) { equiv_ext_right (fp `star` frame) (ls1 `star` ctr) (p `star` ls2 `star` ctr) } (fp `star` frame) `star` (p `star` ls2 `star` ctr); (equiv) { equiv_ext_right (fp `star` frame) (p `star` ls2 `star` ctr) (p `star` (ls2 `star` ctr)) } (fp `star` frame) `star` (p `star` (ls2 `star` ctr)); (equiv) { star_associative (fp `star` frame) p (ls2 `star` ctr) } (fp `star` frame `star` p) `star` (ls2 `star` ctr); (equiv) { equiv_extensional_on_star (fp `star` frame `star` p) (p `star` fp `star` frame) (ls2 `star` ctr) } (p `star` fp `star` frame) `star` (ls2 `star` ctr); } let token_of_inv #p (i:inv p) : (name_of_inv i >--> p) = let (| _, _, tok |) = i in tok let with_invariant (#a:Type) (#fp:slprop) (#fp':a -> slprop) (#opened_invariants:inames) (#p:slprop) (i:inv p{not (mem_inv opened_invariants i)}) (f:action_except a (add_inv opened_invariants i) (p `star` fp) (fun x -> p `star` fp' x)) (frame:slprop) : MstTot a opened_invariants fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in NMSTTotal.recall _ mem_evolves (iname_for_p_mem (name_of_inv i) p) (token_of_inv i); assert (iname_for_p (name_of_inv i) p m0.locks); assert (interp (fp `star` frame `star` locks_invariant opened_invariants m0) m0); assert (interp (fp `star` frame `star` (lock_store_invariant opened_invariants m0.locks `star` ctr_validity m0.ctr (heap_of_mem m0))) m0); move_invariant opened_invariants m0.locks p (name_of_inv i); assert (lock_store_invariant opened_invariants m0.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks)); with_inv_helper fp frame (lock_store_invariant opened_invariants m0.locks) (ctr_validity m0.ctr (heap_of_mem m0)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks); assert (interp (p `star` fp `star` frame `star` locks_invariant (set_add (name_of_inv i) opened_invariants) m0) m0); let r = f frame in let m1 : full_mem = NMSTTotal.get () in assert (interp (p `star` fp' r `star` frame `star` locks_invariant (set_add (name_of_inv i) opened_invariants) m1) m1); assert (interp (p `star` fp' r `star` frame `star` (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks `star` ctr_validity m1.ctr (heap_of_mem m1))) m1); NMSTTotal.recall _ mem_evolves (iname_for_p_mem (name_of_inv i) p) (token_of_inv i); move_invariant opened_invariants m1.locks p (name_of_inv i); assert (lock_store_invariant opened_invariants m1.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks)); with_inv_helper (fp' r) frame (lock_store_invariant opened_invariants m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks); assert (interp (fp' r `star` frame `star` locks_invariant opened_invariants m1) m1); assert (inames_ok opened_invariants m1); r let equiv_pqrs_p_qr_s (p q r s:slprop) : Lemma ((p `star` q `star` r `star` s) `equiv` (p `star` (q `star` r) `star` s)) = star_associative p q r; equiv_extensional_on_star (p `star` q `star` r) (p `star` (q `star` r)) s let frame (#a:Type) (#opened_invariants:inames) (#pre:slprop) (#post:a -> slprop) (#req:mprop pre) (#ens:mprop2 pre post) (frame:slprop) ($f:action_except_full a opened_invariants pre post req ens) (frame0:slprop) : MstTot a opened_invariants (pre `star` frame) (fun x -> post x `star` frame) frame0 req ens = let m0 : full_mem = NMSTTotal.get () in equiv_pqrs_p_qr_s pre frame frame0 (linv opened_invariants m0); assert (interp (pre `star` frame `star` frame0 `star` linv opened_invariants m0) m0); assert (interp (pre `star` (frame `star` frame0) `star` linv opened_invariants m0) m0); let x = f (frame `star` frame0) in let m1 : full_mem = NMSTTotal.get () in equiv_pqrs_p_qr_s (post x) frame frame0 (linv opened_invariants m1); assert (interp (post x `star` (frame `star` frame0) `star` linv opened_invariants m1) m1); assert (interp (post x `star` frame `star` frame0 `star` linv opened_invariants m1) m1); x let change_slprop (#opened_invariants:inames) (p q:slprop) (proof: (m:mem -> Lemma (requires interp p m) (ensures interp q m))) = let proof (h:H.heap) : Lemma (requires H.interp p h) (ensures H.interp q h) = proof (mem_of_heap h) in lift_tot_action (lift_heap_action opened_invariants (Steel.Heap.change_slprop p q proof)) (* This module reuses is_frame_monotonic from Heap, but does not expose that to clients, so we need this lemma to typecheck witness_h_exists below. *) let relate_frame_monotonic_1 #a p : Lemma (requires (H.is_frame_monotonic p)) (ensures (is_frame_monotonic p)) = () let relate_frame_monotonic_2 #a p : Lemma (requires (is_frame_monotonic p)) (ensures (H.is_frame_monotonic p)) = let aux (x y : a) (h : H.heap) (f : H.slprop) : Lemma (requires (H.interp (p x `H.star` f) h /\ H.interp (p y) h)) (ensures (H.interp (p y `H.star` f) h)) = let m = mem_of_heap h in assert (interp (p x `star` f) m); assert (interp (p y) m); assert (interp (p y `star` f) m) in Classical.forall_intro_4 (fun x y h f -> Classical.move_requires (aux x y h) f) let witness_h_exists #opened_invariants #a p = lift_tot_action_with_frame (lift_heap_action_with_frame opened_invariants (H.witness_h_exists p)) let lift_h_exists #opened_invariants p = lift_tot_action (lift_heap_action opened_invariants (H.lift_h_exists p)) let elim_pure #opened_invariants p = lift_tot_action (lift_heap_action opened_invariants (H.elim_pure p)) let pts_to_join (#a:Type) (#pcm:pcm a) (r:ref a pcm) (x y : a) (m:mem) : Lemma (requires (interp (pts_to r x) m /\ interp (pts_to r y) m)) (ensures (joinable pcm x y)) = H.pts_to_join #a #pcm r x y (heap_of_mem m) let pts_to_evolve (#a:Type u#a) (#pcm:_) (r:ref a pcm) (x y : a) (m:mem) : Lemma (requires (interp (pts_to r x) m /\ compatible pcm y x)) (ensures (interp (pts_to r y) m)) = H.pts_to_evolve #a #pcm r x y (heap_of_mem m) let id_elim_star p q m = let starprop (ml:mem) (mr:mem) = disjoint ml mr /\ m == join ml mr /\ interp p ml /\ interp q mr in elim_star p q m; let p1 : mem -> prop = fun ml -> (exists mr. starprop ml mr) in let ml = IndefiniteDescription.indefinite_description_tot _ p1 in let starpropml mr : prop = starprop ml mr in // this prop annotation seems needed let mr = IndefiniteDescription.indefinite_description_tot _ starpropml in (ml, mr) let id_elim_exists #a p m = let existsprop (x:a) = interp (p x) m in elim_h_exists p m; let x = IndefiniteDescription.indefinite_description_tot _ existsprop in x

{ "checked_file": "/", "dependencies": [ "Steel.Preorder.fst.checked", "Steel.Heap.fsti.checked", "prims.fst.checked", "FStar.Witnessed.Core.fsti.checked", "FStar.Set.fsti.checked", "FStar.Preorder.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.PCM.fst.checked", "FStar.NMSTTotal.fst.checked", "FStar.List.Tot.fst.checked", "FStar.IndefiniteDescription.fsti.checked", "FStar.Ghost.fsti.checked", "FStar.FunctionalExtensionality.fsti.checked", "FStar.Classical.Sugar.fsti.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Steel.Memory.fst" }

[ { "abbrev": true, "full_module": "Steel.Preorder", "short_module": "PP" }, { "abbrev": true, "full_module": "FStar.Witnessed.Core", "short_module": "W" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": true, "full_module": "Steel.Heap", "short_module": "H" }, { "abbrev": false, "full_module": "FStar.FunctionalExtensionality", "short_module": null }, { "abbrev": true, "full_module": "FStar.FunctionalExtensionality", "short_module": "F" }, { "abbrev": true, "full_module": "FStar.Universe", "short_module": "U" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": false, "full_module": "FStar.PCM", "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

p: Steel.Memory.slprop -> q: Steel.Memory.slprop -> r: Steel.Memory.slprop -> s: Steel.Memory.slprop -> FStar.Pervasives.Lemma (requires Steel.Memory.slimp p q /\ Steel.Memory.slimp r s) (ensures Steel.Memory.slimp (Steel.Memory.star p r) (Steel.Memory.star q s))

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Steel.Memory.slprop", "FStar.Classical.forall_intro", "Steel.Memory.mem", "Prims.l_imp", "Steel.Memory.interp", "Steel.Memory.star", "FStar.Classical.move_requires", "Prims.unit", "Prims.squash", "Prims.Nil", "FStar.Pervasives.pattern", "FStar.Ghost.erased", "Steel.Memory.intro_star", "FStar.Ghost.reveal", "FStar.Pervasives.Native.tuple2", "Steel.Memory.id_elim_star", "Prims.l_and", "Steel.Memory.slimp" ]

[]

false

true

false

let slimp_star (p q r s: slprop) : Lemma (requires (slimp p q /\ slimp r s)) (ensures (slimp (p `star` r) (q `star` s))) =

let aux (m: mem) : Lemma (requires (interp (p `star` r) m)) (ensures (interp (q `star` s) m)) = let ml, mr = id_elim_star p r m in intro_star q s ml mr in Classical.forall_intro (Classical.move_requires aux)

false

Steel.Memory.fst

Steel.Memory.frame

val frame (#a:Type) (#opened_invariants:inames) (#pre:slprop) (#post:a -> slprop) (#req:mprop pre) (#ens:mprop2 pre post) (frame:slprop) ($f:action_except_full a opened_invariants pre post req ens) : action_except_full a opened_invariants (pre `star` frame) (fun x -> post x `star` frame) req ens

let frame (#a:Type) (#opened_invariants:inames) (#pre:slprop) (#post:a -> slprop) (#req:mprop pre) (#ens:mprop2 pre post) (frame:slprop) ($f:action_except_full a opened_invariants pre post req ens) (frame0:slprop) : MstTot a opened_invariants (pre `star` frame) (fun x -> post x `star` frame) frame0 req ens = let m0 : full_mem = NMSTTotal.get () in equiv_pqrs_p_qr_s pre frame frame0 (linv opened_invariants m0); assert (interp (pre `star` frame `star` frame0 `star` linv opened_invariants m0) m0); assert (interp (pre `star` (frame `star` frame0) `star` linv opened_invariants m0) m0); let x = f (frame `star` frame0) in let m1 : full_mem = NMSTTotal.get () in equiv_pqrs_p_qr_s (post x) frame frame0 (linv opened_invariants m1); assert (interp (post x `star` (frame `star` frame0) `star` linv opened_invariants m1) m1); assert (interp (post x `star` frame `star` frame0 `star` linv opened_invariants m1) m1); x

{ "file_name": "lib/steel/Steel.Memory.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 5, "end_line": 1520, "start_col": 0, "start_line": 1500 }

(* 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.Memory module F = FStar.FunctionalExtensionality open FStar.FunctionalExtensionality open FStar.PCM module H = Steel.Heap noeq type lock_state : Type u#(a + 1) = | Invariant : inv:H.slprop u#a -> lock_state let lock_store : Type u#(a+1) = list (lock_state u#a) noeq type mem : Type u#(a + 1) = { ctr: nat; heap: H.heap u#a; locks: lock_store u#a; } let heap_of_mem (x:mem) : H.heap = x.heap let mem_of_heap (h:H.heap) : mem = { ctr = 0; heap = h; locks = [] } let mem_set_heap (m:mem) (h:H.heap) : mem = { ctr = m.ctr; heap = h; locks = m.locks; } let core_mem (m:mem) : mem = mem_of_heap (heap_of_mem m) let core_mem_invol m = () let disjoint (m0 m1:mem u#h) : prop = m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks let disjoint_sym m0 m1 = () let join m0 m1 = { ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = m0.locks } let join_commutative m0 m1 = H.join_commutative m0.heap m1.heap let disjoint_join m0 m1 m2 = H.disjoint_join m0.heap m1.heap m2.heap let join_associative m0 m1 m2 = H.join_associative m0.heap m1.heap m2.heap let slprop = H.slprop let interp p m = H.interp p m.heap let equiv p1 p2 = forall m. interp p1 m <==> interp p2 m let slprop_extensionality p q = assert (forall m. interp p m <==> interp q m); let aux (h:H.heap) : Lemma (H.interp p h <==> H.interp q h) [SMTPat (H.interp p h)] = let m : mem = { ctr = 0; heap = h; locks = [] } in assert (interp p m <==> interp q m) in assert (forall h. H.interp p h <==> H.interp q h); Steel.Heap.slprop_extensionality p q let reveal_equiv p1 p2 = () let core_ref = H.core_ref let core_ref_null = H.core_ref_null let core_ref_is_null r = H.core_ref_is_null r let emp : slprop u#a = H.emp let pure = H.pure let pts_to = H.pts_to let h_and = H.h_and let h_or = H.h_or let star = H.star let wand = H.wand let h_exists = H.h_exists let h_forall = H.h_forall //////////////////////////////////////////////////////////////////////////////// //properties of equiv //////////////////////////////////////////////////////////////////////////////// let equiv_symmetric (p1 p2:slprop u#a) = H.equiv_symmetric p1 p2 #push-options "--warn_error -271" let equiv_heap_iff_equiv (p1 p2:slprop u#a) : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat (equiv p1 p2)] = let aux_lr () : Lemma (requires H.equiv p1 p2) (ensures equiv p1 p2) [SMTPat ()] = () in let aux_rl_helper1 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p1 h) (ensures H.interp p2 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl_helper2 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p2 h) (ensures H.interp p1 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl () : Lemma (requires equiv p1 p2) (ensures H.equiv p1 p2) [SMTPat ()] = () in () let equiv_heap_iff_equiv_forall () : Lemma (ensures (forall p1 p2. H.equiv p1 p2 <==> equiv p1 p2)) = let aux p1 p2 : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat ()] = equiv_heap_iff_equiv p1 p2 in () #pop-options let equiv_extensional_on_star (p1 p2 p3:slprop u#a) = equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3 let emp_unit p = H.emp_unit p let intro_emp m = H.intro_emp (heap_of_mem m) let pure_equiv p q = H.pure_equiv p q let pure_interp q m = H.pure_interp q (heap_of_mem m) let pure_star_interp p q m = H.pure_star_interp p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// //pts_to //////////////////////////////////////////////////////////////////////////////// let pts_to_compatible #a #pcm x v0 v1 m = H.pts_to_compatible #a #pcm x v0 v1 (heap_of_mem m) let pts_to_compatible_equiv #a #pcm x v0 v1 = H.pts_to_compatible_equiv #a #pcm x v0 v1 let pts_to_not_null #a #pcm x v m = H.pts_to_not_null #a #pcm x v (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // star //////////////////////////////////////////////////////////////////////////////// let intro_star p q mp mq = H.intro_star p q (heap_of_mem mp) (heap_of_mem mq) let elim_star p q m = let h = heap_of_mem m in H.elim_star p q h; assert (exists hl hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr); let hl = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hl -> exists hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let hr = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hr -> H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let ml = mem_set_heap m hl in let mr = mem_set_heap m hr in assert (disjoint ml mr); assert (m == join ml mr); assert (interp p ml); assert (interp q mr); () let interp_star (p q: slprop) (m: mem) : Lemma (interp (p `star` q) m <==> (exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m)) = let left = interp (p `star` q) m in let right = exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m in let f () : Lemma (requires left) (ensures right) = elim_star p q m in let g () : Lemma (requires right) (ensures left) = Classical.exists_elim left #_ #(fun mp -> exists (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mp -> Classical.exists_elim left #_ #(fun mq -> disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mq -> intro_star p q mp mq ) ) in Classical.move_requires f (); Classical.move_requires g () let star_commutative (p1 p2:slprop) = H.star_commutative p1 p2 let star_associative (p1 p2 p3:slprop) = H.star_associative p1 p2 p3 let star_congruence (p1 p2 p3 p4:slprop) = equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4 let affine_star (p q:slprop) (m:mem) = H.affine_star p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // Invariants on the lock store //////////////////////////////////////////////////////////////////////////////// let iname = nat module S = FStar.Set module L = FStar.List.Tot module W = FStar.Witnessed.Core let rec lock_store_invariant (e:inames) (l:lock_store u#a) : slprop u#a = let current_addr = L.length l - 1 in match l with | [] -> emp | Invariant p :: tl -> if current_addr `S.mem` e then lock_store_invariant e tl else p `star` lock_store_invariant e tl let lock_i (i:iname) (l:lock_store { i < L.length l }) = let ix = L.length l - i - 1 in L.index l ix let iname_for_p (i:iname) (p:slprop) : W.s_predicate lock_store = fun l -> i < L.length l /\ (lock_i i l).inv == p let lock_store_evolves : FStar.Preorder.preorder lock_store = fun (l1 l2 : lock_store) -> L.length l2 >= L.length l1 /\ (forall (i:nat{i < L.length l1}). (lock_i i l1).inv == (lock_i i l2).inv) let inames_in (e:inames) (l:lock_store) : prop = forall i. Set.mem i e ==> i < L.length l let inames_ok e m = inames_in e m.locks let inames_ok_empty m = () let extend_lock_store (e:inames) (l:lock_store{e `inames_in` l}) (p:slprop) : i:iname & l':lock_store { lock_store_invariant e l' == p `star` lock_store_invariant e l /\ iname_for_p i p l' } = (| L.length l, Invariant p :: l |) let set_add (i:iname) (s:inames) = Set.union (Set.singleton i) s let rec move_invariant (e:inames) (l:lock_store) (p:slprop) (i:iname{iname_for_p i p l /\ ~(i `Set.mem` e)}) : Lemma (H.equiv (lock_store_invariant e l) (p `star` lock_store_invariant (set_add i e) l)) = let rec aux (i:iname) (m:lock_store) : Lemma (requires i >= L.length m) (ensures (lock_store_invariant e m `H.equiv` lock_store_invariant (set_add i e) m)) = match m with | [] -> () | Invariant p::tl -> aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl) in let current_addr = L.length l - 1 in match l with | [] -> () | Invariant q::tl -> if i = current_addr then begin assert (lock_store_invariant e l == p `star` lock_store_invariant e tl); aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl); () end else begin move_invariant e tl p i; assert (lock_store_invariant e tl `equiv` (p `star` lock_store_invariant (set_add i e) tl)); H.star_congruence q (lock_store_invariant e tl) q (p `star` lock_store_invariant (set_add i e) tl); if Set.mem current_addr e then () else begin let r = lock_store_invariant (set_add i e) tl in assert (lock_store_invariant e l `equiv` (q `star` (p `star` r))); H.star_associative q p r; H.star_commutative q p; H.star_congruence (q `star` p) r (p `star` q) r; H.star_associative p q r end end let heap_ctr_valid (ctr:nat) (h:H.heap u#a) : prop = h `H.free_above_addr` ctr let ctr_validity (ctr:nat) (h:H.heap) : slprop = H.pure (heap_ctr_valid ctr h) let locks_invariant (e:inames) (m:mem u#a) : slprop u#a = lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m) let full_mem_pred (m:mem) = H.full_heap_pred (heap_of_mem m) (***** Following lemmas are needed in Steel.Effect *****) let core_mem_interp (hp:slprop u#a) (m:mem u#a) = () let interp_depends_only_on (hp:slprop u#a) = H.interp_depends_only_on hp let a_mem_prop_as_a_heap_prop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (H.a_heap_prop u#a) = let g (h: H.heap u#a) : Tot prop = interp sl (mem_of_heap h) /\ f (mem_of_heap h) in let phi0 (h0 h1: H.heap u#a) : Lemma (requires (g h0 /\ H.disjoint h0 h1)) (ensures (g h0 /\ H.disjoint h0 h1 /\ g (H.join h0 h1))) = assert (mem_of_heap (H.join h0 h1) == mem_of_heap h0 `join` mem_of_heap h1); interp_depends_only_on sl in let phi1 (h0 h1: H.heap u#a) : Lemma (ensures ((g h0 /\ H.disjoint h0 h1) ==> g (H.join h0 h1))) = Classical.move_requires (phi0 h0) h1 in Classical.forall_intro_2 phi1; g let refine_slprop sl f = H.as_slprop (a_mem_prop_as_a_heap_prop sl f) let interp_refine_slprop sl f m = assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_mem m)) let dep_hprop (s: slprop) (f: (hmem s -> Tot slprop)) (h: H.heap) : Tot prop = exists (h1: H.heap) . exists (h2: H.heap) . interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 let dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq' : squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h')) = let p2 (h h1 h2: H.heap) : Tot prop = interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 in let p1 (h h1: H.heap) : Tot prop = (exists h2 . p2 h h1 h2) in let h1 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p1 h) in let h2 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p2 h h1) in H.disjoint_join h' h1 h2; assert (H.disjoint h2 h'); let h2' = H.join h2 h' in H.join_commutative h2 h' ; assert (h2' == H.join h' h2); assert (H.disjoint h1 h2'); assert (mem_of_heap h2' == mem_of_heap h2 `join` mem_of_heap h'); interp_depends_only_on (f (mem_of_heap h1)); assert (interp (f (mem_of_heap h1)) (mem_of_heap h2')); H.join_commutative h1 h2; H.join_associative h' h2 h1; H.join_commutative h' h; H.join_commutative h2' h1; assert (H.join h h' == h1 `H.join` h2') let impl_intro_gen (#p: Type0) (#q: Type0) ($prf: (squash p -> Lemma (q ))) : Lemma (p ==> q) = Classical.impl_intro_gen #p #(fun _ -> q) prf let dep_hprop_is_affine1 (s: slprop) (f: (hmem s -> Tot slprop)) (h0 h1: H.heap) : Lemma ((dep_hprop s f h0 /\ H.disjoint h0 h1) ==> (H.disjoint h0 h1 /\ dep_hprop s f (H.join h0 h1))) = impl_intro_gen (dep_hprop_is_affine0 s f h0 h1) let dep_hprop_is_affine (s: slprop) (f: (hmem s -> Tot slprop)) : Lemma (H.heap_prop_is_affine (dep_hprop s f)) = Classical.forall_intro_2 (dep_hprop_is_affine1 s f) let sdep (s: slprop) (f: (hmem s -> Tot slprop)) : Tot slprop = dep_hprop_is_affine s f; H.as_slprop (dep_hprop s f) let interp_sdep (s: slprop) (f: (hmem s -> Tot slprop)) (m: mem) : Lemma (requires (dep_slprop_is_affine s f)) (ensures ( interp (sdep s f) m <==> (exists m1 m2 . interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) )) = dep_hprop_is_affine s f; assert (forall m1 m2 . (interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) ==> ( interp s (mem_of_heap m1.heap) /\ interp (f (mem_of_heap m1.heap)) (mem_of_heap m2.heap) /\ H.disjoint m1.heap m2.heap /\ H.join m1.heap m2.heap == m.heap )); interp_depends_only_on s; Classical.forall_intro (fun m -> interp_depends_only_on (f m)); assert (forall h1 h2 . (interp s (mem_of_heap h1) /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ H.disjoint h1 h2 /\ H.join h1 h2 == m.heap) ==> ( core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ interp s (core_mem (mem_of_heap h1)) /\ interp s (mem_set_heap m h1) /\ core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ f (mem_set_heap m h1) `equiv` f (mem_of_heap h1) /\ interp (f (mem_set_heap m h1)) (mem_of_heap h2) /\ interp (f (mem_set_heap m h1)) (mem_set_heap m h2) /\ disjoint (mem_set_heap m h1) (mem_set_heap m h2) /\ join (mem_set_heap m h1) (mem_set_heap m h2) == m )); () let h_exists_cong (#a:Type) (p q : a -> slprop) : Lemma (requires (forall x. p x `equiv` q x)) (ensures (h_exists p `equiv` h_exists q)) = equiv_heap_iff_equiv_forall (); H.h_exists_cong p q let intro_h_exists #a x p m = H.intro_h_exists x p (heap_of_mem m) let elim_h_exists (#a:_) (p:a -> slprop) (m:mem) = H.elim_h_exists p (heap_of_mem m) let intro_h_forall (#a:_) (p:a -> slprop) (m:mem) = H.intro_h_forall p (heap_of_mem m) let elim_h_forall (#a:_) (p:a -> slprop) (m:mem) (x:a) = H.elim_h_forall p (heap_of_mem m) x let intro_h_and (p q: slprop) (m:mem) = H.intro_h_and p q (heap_of_mem m) let elim_h_and (p q: slprop) (m:mem) = H.elim_h_and p q (heap_of_mem m) let intro_h_or_left (p q: slprop) (m:mem) = H.intro_h_or_left p q (heap_of_mem m) let intro_h_or_right (p q: slprop) (m:mem) = H.intro_h_or_right p q (heap_of_mem m) let elim_h_or (p q: slprop) (m:mem) = H.elim_h_or p q (heap_of_mem m) let intro_wand (p1 p2: slprop u#a) (m:mem) = introduce (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)) ==> interp (wand p1 p2) m with _. ( assert (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)); H.intro_wand p1 p2 (heap_of_mem m); let h = heap_of_mem m in assert ((forall h1. h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) ==> H.interp (wand p1 p2) h); introduce forall h1. (h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) with ( introduce (h `H.disjoint` h1 /\ H.interp p1 h1) ==> H.interp p2 (H.join h h1) with _. ( assert (h `H.disjoint` h1); let m1 = { ctr = m.ctr; heap = h1; locks = m.locks } in assert (m `disjoint` m1) ) ) ) (** Eliminating a wand by proving a heap that satisfies the LHS **) let elim_wand (p1 p2: slprop u#a) (m:mem) (m1:mem) = H.elim_wand p1 p2 (heap_of_mem m) (heap_of_mem m1) //////////////////////////////////////////////////////////////////////////////// // Preorders and effects //////////////////////////////////////////////////////////////////////////////// module PP = Steel.Preorder let mem_evolves = fun (m0 m1:full_mem) -> H.heap_evolves (heap_of_mem m0) (heap_of_mem m1) /\ m0.ctr <= m1.ctr /\ lock_store_evolves m0.locks m1.locks (** See [Steel.Heap.is_frame_preserving]. We add in [lock_invariants] now *) let preserves_frame (e:inames) (pre post:slprop) (m0 m1:mem) = forall (frame:slprop). interp ((pre `star` frame) `star` locks_invariant e m0) m0 ==> (interp ((post `star` frame) `star` locks_invariant e m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) (** This is a version of MstTot with frame quantified, as part of preserves_frame *) effect MstTotNF (a:Type u#a) (except:inames) (expects:slprop u#1) (provides: a -> slprop u#1) = NMSTTotal.NMSTATETOT a (full_mem u#1) mem_evolves (requires fun m0 -> inames_ok except m0 /\ interp (expects `star` locks_invariant except m0) m0) (ensures fun m0 x m1 -> inames_ok except m1 /\ interp (provides x `star` locks_invariant except m1) m1 /\ preserves_frame except expects (provides x) m0 m1) //////////////////////////////////////////////////////////////////////////////// // Lifting heap actions //////////////////////////////////////////////////////////////////////////////// (** Heap actions come in two equivalent flavors: - one that take an explicit frame as argument (action_with_frame) - and one that quantify over all the frame We therefore define two lift routes: - a direct route for those with explicit frame - via MstTotNF for the rest *) let tot_pre_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = hmem_with_inv_except e fp -> (x:a & hmem_with_inv_except e (fp' x)) let tot_pre_action_nf = tot_pre_action_nf_except S.empty let ac_reasoning_for_m_frame_preserving (p q r:slprop u#a) (m:mem u#a) : Lemma (requires interp ((p `star` q) `star` r) m) (ensures interp (p `star` r) m) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_commutative p q; equiv_extensional_on_star (p `star` q) (q `star` p) r } (q `star` p) `star` r; (equiv) { star_associative q p r } q `star` (p `star` r); }; assert (interp (q `star` (p `star` r)) m); affine_star q (p `star` r) m let is_frame_preserving (#e:inames) (#a:Type u#b) (#fp:slprop u#a) (#fp':a -> slprop u#a) (f:tot_pre_action_nf_except e fp a fp') = forall (frame:slprop u#a) (m0:hmem_with_inv_except e (fp `star` frame)). (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = f:tot_pre_action_nf_except e fp a fp'{ is_frame_preserving f } let tot_action_nf = tot_action_nf_except S.empty let linv e (m:mem) = locks_invariant e m let hheap_of_hmem #fp #e (m:hmem_with_inv_except e fp) : h:H.hheap (fp `star` linv e m) { h `H.free_above_addr` m.ctr} = let h = heap_of_mem m in H.pure_interp (heap_ctr_valid m.ctr (heap_of_mem m)) h; h let hmem_of_hheap #e (#fp0 #fp1:slprop) (m:hmem_with_inv_except e fp0) (h:H.full_hheap (fp1 `star` linv e m) { h `Heap.free_above_addr` m.ctr }) : m1:hmem_with_inv_except e fp1{linv e m `equiv` linv e m1} = let m1 : mem = { m with heap = h } in assert (interp (fp1 `star` linv e m) m1); star_commutative fp1 (linv e m); assert (interp (linv e m `star` fp1) m1); assert (linv e m1 == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); assert (linv e m == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m)); H.pure_interp (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_of_mem m); assert (heap_ctr_valid m1.ctr (heap_of_mem m) <==> heap_ctr_valid m1.ctr (heap_of_mem m1)); H.pure_equiv (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_ctr_valid m1.ctr (heap_of_mem m1)); H.star_congruence (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m)); assert (linv e m `equiv` linv e m1); let _ = equiv_extensional_on_star (linv e m) (linv e m1) fp1 in assert ((linv e m `star` fp1) `equiv` (linv e m1 `star` fp1)); assert (interp (linv e m1 `star` fp1) m1); star_commutative (linv e m1) fp1; assert (interp (fp1 `star` linv e m1) m1); m1 let with_inv_except (m:mem) e (fp:slprop) = interp (fp `star` locks_invariant e m) m #push-options "--warn_error -271" let as_hprop (frame:slprop) (mp:mprop frame) : hp:H.hprop frame{forall m. mp (core_mem m) == hp (heap_of_mem m)} = let f = fun h -> mp (mem_of_heap h) in assert (forall m. mp (core_mem m) == f (heap_of_mem m)); let aux (m0:H.hheap frame) (m1:H.heap{H.disjoint m0 m1}) : Lemma (ensures (mem_of_heap (H.join m0 m1) == join (mem_of_heap m0) (mem_of_heap m1))) [SMTPat ()] = () in f let mprop_preservation_of_hprop_preservation (p:slprop) (m0 m1:mem) : Lemma (requires (forall (hp:H.hprop p). hp (heap_of_mem m0) == hp (heap_of_mem m1))) (ensures (forall (mp:mprop p). mp (core_mem m0) == mp (core_mem m1))) = let aux (mp:mprop p) : Lemma (mp (core_mem m0) == mp (core_mem m1)) [SMTPat()] = assert (as_hprop p mp (heap_of_mem m0) == as_hprop p mp (heap_of_mem m1)) in () let lift_heap_action (#fp:slprop) (#a:Type) (#fp':a -> slprop) (e:inames) ($f:H.action fp a fp') : tot_action_nf_except e fp a fp' = let g : tot_pre_action_nf_except e fp a fp' = fun m -> let h0 = hheap_of_hmem m in let (| x, h' |) = f h0 in (| x, hmem_of_hheap m h' |) in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in let h0 = hheap_of_hmem m0 in let (| x', h1 |) = f h0 in H.action_framing f (linv e m0) h0; assert (x == x'); star_associative fp frame (linv e m0); H.action_framing f (frame `star` linv e m0) h0; assert (H.interp ((fp' x) `star` (frame `star` linv e m0)) h1); star_associative (fp' x) frame (linv e m0); assert (H.interp ((fp' x `star` frame) `star` linv e m0) h1); let h1' : H.hheap ((fp' x `star` frame) `star` linv e m0) = h1 in assert (m1 == hmem_of_hheap m0 h1'); assert (with_inv_except m1 e (fp' x `star` frame)); assert (forall (hp:H.hprop frame). hp h0 == hp h1); mprop_preservation_of_hprop_preservation frame m0 m1; () in assert (is_frame_preserving g); g let frame_preserving_respects_preorder #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (m0:hmem_with_inv_except e fp) : Lemma (let (| x, m1 |) = f m0 in mem_evolves m0 m1) = let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1) = () in H.emp_unit fp; assert (interp (fp `star` linv e m0) m0); H.star_congruence (fp `star` emp) (linv e m0) fp (linv e m0); assert (interp ((fp `star` emp) `star` linv e m0) m0); aux emp m0 let lift_tot_action_nf #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') : MstTotNF a e fp fp' = let m0 = NMSTTotal.get () in let m0' : hmem_with_inv_except e fp = m0 in let r = f m0' in let (| x, m1 |) = r in let m1' : hmem_with_inv_except e (fp' x) = m1 in assert (is_frame_preserving f); assert (m1 == dsnd (f m0)); frame_preserving_respects_preorder f m0; NMSTTotal.put #_ #(mem_evolves) m1; x let lift_tot_action #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get #(full_mem) #_ () in ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); lift_tot_action_nf f (** Now defining the lift for heap actions with explicit frame *) let tot_action_with_frame_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = frame:slprop u#a -> m0:hmem_with_inv_except e (fp `star` frame) -> Pure (x:a & hmem_with_inv_except e (fp' x `star` frame)) (requires True) (ensures fun (| x, m1 |) -> mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_with_frame = tot_action_with_frame_except S.empty let lift_heap_action_with_frame (#fp:slprop u#a) (#a:Type u#b) (#fp':a -> slprop u#a) (e:inames) ($f:H.action_with_frame fp a fp') : tot_action_with_frame_except e fp a fp' = fun frame m0 -> let h0 = hheap_of_hmem m0 in calc (equiv) { fp `star` frame `star` locks_invariant e m0; (equiv) { star_associative fp frame (locks_invariant e m0) } fp `star` (frame `star` locks_invariant e m0); }; assert (H.interp (fp `star` frame `star` locks_invariant e m0) h0); assert (H.interp (fp `star` (frame `star` locks_invariant e m0)) h0); //key: apply the heap action with frame * locks_invariant e m0 let (| x, h1 |) = f (frame `star` locks_invariant e m0) h0 in calc (equiv) { fp' x `star` (frame `star` locks_invariant e m0); (equiv) { star_associative (fp' x) frame (locks_invariant e m0) } fp' x `star` frame `star` locks_invariant e m0; }; assert (H.interp (fp' x `star` (frame `star` locks_invariant e m0)) h1); assert (H.interp (fp' x `star` frame `star` locks_invariant e m0) h1); let m1 = hmem_of_hheap m0 h1 in assert (mem_evolves m0 m1); mprop_preservation_of_hprop_preservation (frame `star` locks_invariant e m0) m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)); (| x, m1 |) let lift_tot_action_with_frame #a #e #fp #fp' ($f:tot_action_with_frame_except e fp a fp') (frame:slprop) : MstTot a e fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in assert (inames_ok e m0); ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; assert (interp (fp `star` frame `star` locks_invariant e m0) m0); assert (interp (fp `star` locks_invariant e m0) m0); let m0' : hmem_with_inv_except e fp = m0 in let r = f frame m0' in let (| x, m1 |) = r in ac_reasoning_for_m_frame_preserving (fp' x) frame (locks_invariant e m1) m1; assert (interp (fp' x `star` frame `star` locks_invariant e m1) m1); assert (interp (fp' x `star` locks_invariant e m1) m1); let m1' : hmem_with_inv_except e (fp' x) = m1 in NMSTTotal.put #_ #(mem_evolves) m1; x let sel_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.sel_action #a #pcm r v0)) let upd_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.upd_action #a #pcm r v0 v1)) let free_action #a #pcm e r v0 = lift_tot_action (lift_heap_action e (H.free_action #a #pcm r v0)) let split_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.split_action #a #pcm r v0 v1)) let gather_action #a #pcm e r v0 v1 = lift_tot_action (lift_heap_action e (H.gather_action #a #pcm r v0 v1)) let weaken (p q r:slprop) (h:H.hheap (p `star` q) { H.stronger q r }) : H.hheap (p `star` r) = H.weaken p q r h; h let weaken_pure (q r: prop) : Lemma (requires (q ==> r)) (ensures H.stronger (H.pure q) (H.pure r)) = let aux (h:H.heap) : Lemma (ensures (H.interp (H.pure q) h ==> H.interp (H.pure r) h)) [SMTPat ()] = H.pure_interp q h; H.pure_interp r h in () let inc_ctr (#p:slprop) #e (m:hmem_with_inv_except e p) : m':hmem_with_inv_except e p{m'.ctr = m.ctr + 1 /\ H.stronger (linv e m) (linv e m')} = let m' : mem = { m with ctr = m.ctr + 1} in assert (interp (p `star` linv e m) m'); assert (linv e m == lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m)); assert (linv e m' == lock_store_invariant e m.locks `star` ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken_free_above (heap_of_mem m) m.ctr (m.ctr + 1); weaken_pure (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_ctr_valid (m.ctr + 1) (heap_of_mem m)); assert (H.stronger (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m))); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)); H.stronger_star (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)); H.weaken (p `star` lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) (ctr_validity (m.ctr + 1) (heap_of_mem m)) (heap_of_mem m'); H.star_associative p (lock_store_invariant e m.locks) (ctr_validity (m.ctr + 1) (heap_of_mem m)); let m' : hmem_with_inv_except e p = m' in m' let frame_related_mems (fp0 fp1:slprop u#a) e (m0:hmem_with_inv_except e fp0) (m1:hmem_with_inv_except e fp1) = forall (frame:slprop u#a). interp ((fp0 `star` frame) `star` linv e m0) m0 ==> interp ((fp1 `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) let refined_pre_action e (fp0:slprop) (a:Type) (fp1:a -> slprop) = m0:hmem_with_inv_except e fp0 -> Pure (x:a & hmem_with_inv_except e (fp1 x)) (requires True) (ensures fun (| x, m1 |) -> frame_related_mems fp0 (fp1 x) e m0 m1) let refined_pre_action_as_action (#fp0:slprop) (#a:Type) (#fp1:a -> slprop) #e ($f:refined_pre_action e fp0 a fp1) : tot_action_nf_except e fp0 a fp1 = let g : tot_pre_action_nf_except e fp0 a fp1 = fun m -> f m in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp0 `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp1 x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp0 frame (locks_invariant e m0) m0; let (| x', m1' |) = g m0 in let (| x, m1 |) = f m0 in assert (x == x' /\ m1 == m1') in g let alloc_action #a #pcm e x = let f : refined_pre_action e emp (ref a pcm) (fun r -> pts_to r x) = fun m0 -> (* NS: 9/29/22 I needed to annotate h : Heap.full_heap, for use with the Core checker which generates a guard for checking the implicit pattern "dot" term in the dependent pair pattern on the next line. That guard expects `h` to be a full_heap, which is it, because it is a projection of m0. However, this is not reflected in `h`'s type. So, the Core checker, which produces a guard for the pat_dot_term in isolation, cannot recheck the term. If we were to fold in the checking of pat_dot_terms and their guards with the rest of the VC, this would work. *) let h : Heap.full_heap = hheap_of_hmem m0 in let (|r, h'|) = H.extend #a #pcm x m0.ctr h in let m' : hmem_with_inv_except e emp = inc_ctr m0 in let h' : H.hheap (pts_to #a #pcm r x `star` linv e m') = weaken _ (linv e m0) (linv e m') h' in let m1 : hmem_with_inv_except e (pts_to #a #pcm r x) = hmem_of_hheap m' h' in assert (forall frame. H.frame_related_heaps h h' emp (pts_to #a #pcm r x) frame true); let aux (frame:slprop) : Lemma (requires interp ((emp `star` frame) `star` linv e m0) m0) (ensures interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) [SMTPat (emp `star` frame)] = star_associative emp frame (linv e m0); assert (H.interp (emp `star` (frame `star` linv e m0)) h); assert (H.interp (pts_to #a #pcm r x `star` (frame `star` linv e m0)) h'); star_associative (pts_to #a #pcm r x) frame (linv e m0); assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m0) h'); assert (H.stronger (linv e m0) (linv e m')); assert (H.equiv (linv e m') (linv e m1)); assert (H.stronger (linv e m0) (linv e m1)); let h' : H.hheap ((pts_to #a #pcm r x `star` frame) `star` linv e m1) = weaken _ (linv e m0) (linv e m1) h' in assert (H.interp ((pts_to #a #pcm r x `star` frame) `star` linv e m1) h'); assert (forall (mp:H.hprop frame). mp h == mp h'); mprop_preservation_of_hprop_preservation frame m0 m1; assert (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)) in assert (frame_related_mems emp (pts_to r x) e m0 m1); (| r, m1 |) in lift_tot_action (refined_pre_action_as_action f) let select_refine #a #p e r x f = lift_tot_action (lift_heap_action e (H.select_refine #a #p r x f)) let upd_gen #a #p e r x y f = lift_tot_action (lift_heap_action e (H.upd_gen_action r x y f)) //////////////////////////////////////////////////////////////////////////////// // witness / recall //////////////////////////////////////////////////////////////////////////////// let witnessed_ref #a #pcm (r:ref a pcm) (fact:property a) (m:full_mem) = H.witnessed_ref #a #pcm r fact (heap_of_mem m) let witnessed_ref_stability #a #pcm (r:ref a pcm) (fact:property a) : Lemma (requires FStar.Preorder.stable fact (Steel.Preorder.preorder_of_pcm pcm)) (ensures FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) = H.witnessed_ref_stability #a #pcm r fact let witnessed (#a:Type u#1) (#pcm:pcm a) (r:ref a pcm) (fact:property a) = W.witnessed _ mem_evolves (witnessed_ref r fact) let rearrange_pqr_prq (p q r:slprop) : Lemma (((p `star` q) `star` r) `equiv` ((p `star` r) `star` q)) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_associative p q r } p `star` (q `star` r); (equiv) { star_commutative q r; star_congruence p (q `star` r) p (r `star` q) } p `star` (r `star` q); (equiv) { star_associative p r q } (p `star` r) `star` q; } let preserves_frame_cong (e:inames) (p q:slprop) (r s:slprop) (m0 m1:mem) : Lemma (requires p `equiv` r /\ q `equiv` s /\ preserves_frame e p q m0 m1) (ensures preserves_frame e r s m0 m1) = let aux0 (p q r s:slprop) : Lemma (requires p `equiv` s) (ensures (((p `star` q) `star` r) `equiv` ((s `star` q) `star` r))) = star_congruence p q s q; star_congruence (p `star` q) r (s `star` q) r in let aux (frame:slprop) : Lemma (requires interp ((r `star` frame) `star` locks_invariant e m0) m0) (ensures interp ((s `star` frame) `star` locks_invariant e m1) m1 /\ interp ((p `star` frame) `star` locks_invariant e m0) m0) [SMTPat (r `star` frame)] = aux0 p frame (locks_invariant e m0) r; aux0 q frame (locks_invariant e m1) s; assert (((p `star` frame) `star` locks_invariant e m0) `equiv` ((r `star` frame) `star` locks_invariant e m0)); assert (interp ((p `star` frame) `star` locks_invariant e m0) m0); assert (interp ((q `star` frame) `star` locks_invariant e m1) m1); assert (((q `star` frame) `star` locks_invariant e m1) `equiv` ((s `star` frame) `star` locks_invariant e m1)); () in () let pure_true_equiv (p:slprop) : Lemma ((p `star` pure True) `equiv` p) = FStar.Classical.forall_intro (pure_star_interp p True); emp_unit p; assert ((p `star` pure True) `equiv` p) let preserves_frame_star_pure (e:inames) (p q:slprop) (r s:prop) (m:mem) : Lemma (requires r /\ s) (ensures preserves_frame e p q m m <==> preserves_frame e (p `star` pure r) (q `star` pure s) m m) = pure_equiv r True; star_congruence p (pure r) p (pure True); pure_equiv s True; star_congruence q (pure s) q (pure True); pure_true_equiv p; pure_true_equiv q; let fwd () : Lemma (requires preserves_frame e p q m m) (ensures preserves_frame e (p `star` pure r) (q `star` pure s) m m) [SMTPat ()] = preserves_frame_cong e p q (p `star` pure r) (q `star` pure s) m m in let bk () : Lemma (requires preserves_frame e (p `star` pure r) (q `star` pure s) m m) (ensures preserves_frame e p q m m) [SMTPat ()] = preserves_frame_cong e (p `star` pure r) (q `star` pure s) p q m m in () let witness (#a:Type) (#pcm:pcm a) (e:inames) (r:erased (ref a pcm)) (fact:stable_property pcm) (v:Ghost.erased a) (_:squash (forall z. compatible pcm v z ==> fact z)) (frame:slprop) : MstTot (witnessed r fact) e (pts_to r v) (fun _ -> pts_to r v) frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in let _ : unit = let hr : H.ref a pcm = r in let v' = H.sel_v hr v (heap_of_mem m0) in assert (interp (H.ptr hr) m0 /\ H.sel #a #pcm hr (heap_of_mem m0) == v'); assert (compatible pcm v v'); assert (fact v'); assert (witnessed_ref r fact m0); witnessed_ref_stability r fact; assert (FStar.Preorder.stable (witnessed_ref r fact) mem_evolves) in let w = NMSTTotal.witness _ mem_evolves (witnessed_ref r fact) in w let recall (#a:Type u#1) (#pcm:pcm a) (#fact:property a) (e:inames) (r:erased (ref a pcm)) (v:Ghost.erased a) (w:witnessed r fact) (frame:slprop) = let m0 = NMSTTotal.get () in NMSTTotal.recall _ mem_evolves (witnessed_ref r fact) w; let hr : H.ref a pcm = r in assert (witnessed_ref r fact m0); let v1 = H.sel_v hr v (heap_of_mem m0) in assert (compatible pcm v v1); assert (H.sel hr (heap_of_mem m0) == v1); assert (fact v1); assert (interp ((pts_to r v `star` frame) `star` locks_invariant e m0) m0); emp_unit ((pts_to r v `star` frame) `star` locks_invariant e m0); pure_star_interp ((pts_to r v `star` frame) `star` locks_invariant e m0) (fact v1) m0; assert (interp (((pts_to r v `star` frame) `star` locks_invariant e m0) `star` pure (fact v1)) m0); rearrange_pqr_prq (pts_to r v `star` frame) (locks_invariant e m0) (pure (fact v1)); assert (interp (((pts_to r v `star` frame) `star` pure (fact v1)) `star` locks_invariant e m0) m0); rearrange_pqr_prq (pts_to r v) frame (pure (fact v1)); star_congruence ((pts_to r v `star` frame) `star` pure (fact v1)) (locks_invariant e m0) ((pts_to r v `star` pure (fact v1)) `star` frame) (locks_invariant e m0); Ghost.hide v1 let iname_for_p_mem (i:iname) (p:slprop) : W.s_predicate mem = fun m -> iname_for_p i p m.locks let iname_for_p_stable (i:iname) (p:slprop) : Lemma (W.stable full_mem mem_evolves (iname_for_p_mem i p)) = () let ( >--> ) (i:iname) (p:slprop) : Type0 = W.witnessed full_mem mem_evolves (iname_for_p_mem i p) let hmem_with_inv_equiv e (m:mem) (p:slprop) : Lemma (interp (p `star` linv e m) m <==> interp (p `star` lock_store_invariant e m.locks) m /\ heap_ctr_valid m.ctr (heap_of_mem m)) = calc (<==>) { interp (p `star` linv e m) m; (<==>) { H.star_associative p (lock_store_invariant e m.locks) (ctr_validity m.ctr (heap_of_mem m)) } interp ((p `star` lock_store_invariant e m.locks) `star` ctr_validity m.ctr (heap_of_mem m)) m; (<==>) { H.pure_star_interp (p `star` lock_store_invariant e m.locks) (heap_ctr_valid m.ctr (heap_of_mem m)) (heap_of_mem m) } interp ((p `star` lock_store_invariant e m.locks) `star` emp) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); (<==>) { H.emp_unit (p `star` lock_store_invariant e m.locks) } interp (p `star` lock_store_invariant e m.locks) m /\ (heap_ctr_valid m.ctr (heap_of_mem m)); } let new_invariant_tot_action (e:inames) (p:slprop) (m0:hmem_with_inv_except e p{ e `inames_in` m0.locks }) : Pure (iname & hmem_with_inv_except e emp) (requires True) (ensures fun (i, m1) -> iname_for_p_mem i p m1 /\ frame_related_mems p emp e m0 m1 /\ mem_evolves m0 m1) = let (| i, l1 |) = extend_lock_store e m0.locks p in let m1 = { m0 with locks = l1 } in assert (lock_store_invariant e m1.locks == p `star` lock_store_invariant e m0.locks); calc (equiv) { linv e m1; (equiv) {} (lock_store_invariant e m1.locks `star` ctr_validity m1.ctr (heap_of_mem m1)); (equiv) {} ((p `star` lock_store_invariant e m0.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); (equiv) { H.star_associative p (lock_store_invariant e m0.locks) (ctr_validity m1.ctr (heap_of_mem m1)) } (p `star` (lock_store_invariant e m0.locks `star` ctr_validity m1.ctr (heap_of_mem m1))); (equiv) { } (p `star` linv e m0); }; assert (iname_for_p_mem i p m1); assert (lock_store_evolves m0.locks l1); assert (mem_evolves m0 m1); hmem_with_inv_equiv e m0 p; assert (interp (p `star` lock_store_invariant e m0.locks) m1); assert (interp (lock_store_invariant e m1.locks) m1); H.emp_unit (lock_store_invariant e m1.locks); H.star_commutative (lock_store_invariant e m1.locks) emp; assert (interp (emp `star` lock_store_invariant e m1.locks) m1); hmem_with_inv_equiv e m1 emp; let m1 : hmem_with_inv_except e emp = m1 in let aux (frame:slprop) : Lemma (requires interp ((p `star` frame) `star` linv e m0) m0) (ensures interp ((emp `star` frame) `star` linv e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) <==> mp (core_mem m1))) [SMTPat (p `star` frame)] = assert (interp ((p `star` frame) `star` linv e m0) m1); calc (equiv) { ((p `star` frame) `star` linv e m0); (equiv) { H.star_commutative p frame; H.star_congruence (p `star` frame) (linv e m0) (frame `star` p) (linv e m0); H.star_associative frame p (linv e m0) } (frame `star` (p `star` linv e m0)); (equiv) { H.star_congruence frame (p `star` linv e m0) frame (linv e m1) } (frame `star` linv e m1); (equiv) { H.emp_unit (frame `star` linv e m1); H.star_commutative (frame `star` linv e m1) emp; H.star_associative emp frame (linv e m1) } ((emp `star` frame) `star` linv e m1); }; assert (interp ((emp `star` frame) `star` linv e m1) m1) in assert (frame_related_mems p emp e m0 m1); ( i, m1 ) let name_is_ok (i:iname) (m0:full_mem u#1) : prop = i < List.Tot.length m0.locks let witnessed_name_is_ok (i:iname) = W.witnessed full_mem mem_evolves (name_is_ok i) let pre_inv = i:erased iname & witnessed_name_is_ok i let inv (p:slprop u#1) = i:erased iname & witnessed_name_is_ok i & (i >--> p) let pre_inv_of_inv #p (i:inv p) = let (|i, w, _|) = i in (|i,w|) let name_of_pre_inv (i:pre_inv) = dfst i let rec recall_all (ctx:list pre_inv) : NMSTTotal.NMSTATETOT unit (full_mem u#1) mem_evolves (requires fun _ -> True) (ensures fun m0 _ m1 -> m0==m1 /\ (forall i. i `List.Tot.memP` ctx ==> name_is_ok (name_of_pre_inv i) m0)) = match ctx with | [] -> () | hd::tl -> let (| q, i |) = hd in let i : W.witnessed full_mem mem_evolves (name_is_ok q) = i in NMSTTotal.recall _ mem_evolves (name_is_ok q) i; recall_all tl let fresh_invariant (e:inames) (p:slprop) (ctx:list pre_inv) (frame:slprop) : MstTot (i:inv p { not (mem_inv e i) /\ fresh_wrt ctx (name_of_inv i)}) e p (fun _ -> emp) frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in recall_all ctx; ac_reasoning_for_m_frame_preserving p frame (locks_invariant e m0) m0; assert (interp (p `star` locks_invariant e m0) m0); let r = new_invariant_tot_action e p m0 in let ( i, m1 ) = r in assert (i == List.Tot.length m0.locks); assert (not (Set.mem i e)); assert (mem_evolves m0 m1); NMSTTotal.put #full_mem #mem_evolves m1; iname_for_p_stable i p; let w = NMSTTotal.witness full_mem mem_evolves (iname_for_p_mem i p) in let w0 = NMSTTotal.witness full_mem mem_evolves (name_is_ok i) in (| hide i, w0, w |) let new_invariant (e:inames) (p:slprop) (frame:slprop) : MstTot (inv p) e p (fun _ -> emp) frame (fun _ -> True) (fun _ _ _ -> True) = fresh_invariant e p [] frame let rearrange_invariant (p q r : slprop) (q0 q1:slprop) : Lemma (requires q `equiv` (q0 `star` q1)) (ensures (p `star` (q `star` r)) `equiv` ((q0 `star` p) `star` (q1 `star` r))) = calc (equiv) { p `star` (q `star` r); (equiv) { calc (equiv) { (q `star` r); (equiv) { star_congruence q r (q0 `star` q1) r } (q0 `star` q1) `star` r; }; star_congruence p (q `star` r) p ((q0 `star` q1) `star` r) } (p `star` ((q0 `star` q1) `star` r)); (equiv) { star_associative q0 q1 r; star_congruence p ((q0 `star` q1) `star` r) p (q0 `star` (q1 `star` r)); star_associative p q0 (q1 `star` r) } (p `star` q0) `star` (q1 `star` r); (equiv) { star_commutative p q0; star_congruence (p `star` q0) (q1 `star` r) (q0 `star` p) (q1 `star` r) } (q0 `star` p) `star` (q1 `star` r); } let preserves_frame_invariant (fp fp':slprop) (opened_invariants:inames) (p:slprop) (i:inv p{not (mem_inv opened_invariants i)}) (m0:hmem_with_inv_except (add_inv opened_invariants i) (p `star` fp)) (m1:mem) : Lemma (requires preserves_frame (set_add (name_of_inv i) opened_invariants) (p `star` fp) (p `star` fp') m0 m1 /\ interp (fp' `star` linv opened_invariants m1) m1 /\ inames_ok opened_invariants m1 /\ (lock_store_invariant opened_invariants m0.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks)) /\ (lock_store_invariant opened_invariants m1.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks))) (ensures preserves_frame opened_invariants fp fp' m0 m1) = let aux (frame:slprop) : Lemma (requires interp ((fp `star` frame) `star` linv opened_invariants m0) m0) (ensures interp ((fp' `star` frame) `star` linv opened_invariants m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) [SMTPat()] = rearrange_invariant (fp `star` frame) (lock_store_invariant opened_invariants m0.locks) (ctr_validity m0.ctr (heap_of_mem m0)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks); assert (interp ((p `star` (fp `star` frame)) `star` linv (set_add (name_of_inv i) opened_invariants) m0) m0); star_associative p fp frame; star_congruence (p `star` (fp `star` frame)) (linv (set_add (name_of_inv i) opened_invariants) m0) ((p `star` fp) `star` frame) (linv (set_add (name_of_inv i) opened_invariants) m0); assert (interp (((p `star` fp) `star` frame) `star` linv (set_add (name_of_inv i) opened_invariants) m0) m0); assert (interp (((p `star` fp') `star` frame) `star` linv (set_add (name_of_inv i) opened_invariants) m1) m1); star_associative p fp' frame; star_congruence ((p `star` fp') `star` frame) (linv (set_add (name_of_inv i) opened_invariants) m1) (p `star` (fp' `star` frame)) (linv (set_add (name_of_inv i) opened_invariants) m1); assert (interp ((p `star` (fp' `star` frame)) `star` linv (set_add (name_of_inv i) opened_invariants) m1) m1); rearrange_invariant (fp' `star` frame) (lock_store_invariant opened_invariants m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks); assert (interp ((fp' `star` frame) `star` linv opened_invariants m1) m1); () in () let equiv_ext_right (p q r:slprop) : Lemma (requires q `equiv` r) (ensures (p `star` q) `equiv` (p `star` r)) = calc (equiv) { p `star` q; (equiv) { star_commutative p q } q `star` p; (equiv) { equiv_extensional_on_star q r p } r `star` p; (equiv) { star_commutative p r } p `star` r; } let with_inv_helper (fp frame ls1 ctr p ls2:slprop) : Lemma (requires ls1 `equiv` (p `star` ls2)) (ensures (fp `star` frame `star` (ls1 `star` ctr)) `equiv` (p `star` fp `star` frame `star` (ls2 `star` ctr))) = calc (equiv) { ls1 `star` ctr; (equiv) { equiv_extensional_on_star ls1 (p `star` ls2) ctr } p `star` ls2 `star` ctr; }; calc (equiv) { p `star` ls2 `star` ctr; (equiv) { star_associative p ls2 ctr } p `star` (ls2 `star` ctr); }; calc (equiv) { fp `star` frame `star` p; (equiv) { star_commutative (fp `star` frame) p } p `star` (fp `star` frame); (equiv) { star_associative p fp frame } p `star` fp `star` frame; }; calc (equiv) { fp `star` frame `star` (ls1 `star` ctr); (equiv) { equiv_ext_right (fp `star` frame) (ls1 `star` ctr) (p `star` ls2 `star` ctr) } (fp `star` frame) `star` (p `star` ls2 `star` ctr); (equiv) { equiv_ext_right (fp `star` frame) (p `star` ls2 `star` ctr) (p `star` (ls2 `star` ctr)) } (fp `star` frame) `star` (p `star` (ls2 `star` ctr)); (equiv) { star_associative (fp `star` frame) p (ls2 `star` ctr) } (fp `star` frame `star` p) `star` (ls2 `star` ctr); (equiv) { equiv_extensional_on_star (fp `star` frame `star` p) (p `star` fp `star` frame) (ls2 `star` ctr) } (p `star` fp `star` frame) `star` (ls2 `star` ctr); } let token_of_inv #p (i:inv p) : (name_of_inv i >--> p) = let (| _, _, tok |) = i in tok let with_invariant (#a:Type) (#fp:slprop) (#fp':a -> slprop) (#opened_invariants:inames) (#p:slprop) (i:inv p{not (mem_inv opened_invariants i)}) (f:action_except a (add_inv opened_invariants i) (p `star` fp) (fun x -> p `star` fp' x)) (frame:slprop) : MstTot a opened_invariants fp fp' frame (fun _ -> True) (fun _ _ _ -> True) = let m0 = NMSTTotal.get () in NMSTTotal.recall _ mem_evolves (iname_for_p_mem (name_of_inv i) p) (token_of_inv i); assert (iname_for_p (name_of_inv i) p m0.locks); assert (interp (fp `star` frame `star` locks_invariant opened_invariants m0) m0); assert (interp (fp `star` frame `star` (lock_store_invariant opened_invariants m0.locks `star` ctr_validity m0.ctr (heap_of_mem m0))) m0); move_invariant opened_invariants m0.locks p (name_of_inv i); assert (lock_store_invariant opened_invariants m0.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks)); with_inv_helper fp frame (lock_store_invariant opened_invariants m0.locks) (ctr_validity m0.ctr (heap_of_mem m0)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m0.locks); assert (interp (p `star` fp `star` frame `star` locks_invariant (set_add (name_of_inv i) opened_invariants) m0) m0); let r = f frame in let m1 : full_mem = NMSTTotal.get () in assert (interp (p `star` fp' r `star` frame `star` locks_invariant (set_add (name_of_inv i) opened_invariants) m1) m1); assert (interp (p `star` fp' r `star` frame `star` (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks `star` ctr_validity m1.ctr (heap_of_mem m1))) m1); NMSTTotal.recall _ mem_evolves (iname_for_p_mem (name_of_inv i) p) (token_of_inv i); move_invariant opened_invariants m1.locks p (name_of_inv i); assert (lock_store_invariant opened_invariants m1.locks `equiv` (p `star` lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks)); with_inv_helper (fp' r) frame (lock_store_invariant opened_invariants m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) p (lock_store_invariant (set_add (name_of_inv i) opened_invariants) m1.locks); assert (interp (fp' r `star` frame `star` locks_invariant opened_invariants m1) m1); assert (inames_ok opened_invariants m1); r let equiv_pqrs_p_qr_s (p q r s:slprop) : Lemma ((p `star` q `star` r `star` s) `equiv` (p `star` (q `star` r) `star` s)) = star_associative p q r; equiv_extensional_on_star (p `star` q `star` r) (p `star` (q `star` r)) s

{ "checked_file": "/", "dependencies": [ "Steel.Preorder.fst.checked", "Steel.Heap.fsti.checked", "prims.fst.checked", "FStar.Witnessed.Core.fsti.checked", "FStar.Set.fsti.checked", "FStar.Preorder.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.PCM.fst.checked", "FStar.NMSTTotal.fst.checked", "FStar.List.Tot.fst.checked", "FStar.IndefiniteDescription.fsti.checked", "FStar.Ghost.fsti.checked", "FStar.FunctionalExtensionality.fsti.checked", "FStar.Classical.Sugar.fsti.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Steel.Memory.fst" }

[ { "abbrev": true, "full_module": "Steel.Preorder", "short_module": "PP" }, { "abbrev": true, "full_module": "FStar.Witnessed.Core", "short_module": "W" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": true, "full_module": "Steel.Heap", "short_module": "H" }, { "abbrev": false, "full_module": "FStar.FunctionalExtensionality", "short_module": null }, { "abbrev": true, "full_module": "FStar.FunctionalExtensionality", "short_module": "F" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": false, "full_module": "FStar.PCM", "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

frame: Steel.Memory.slprop -> $f: Steel.Memory.action_except_full a opened_invariants pre post req ens -> Steel.Memory.action_except_full a opened_invariants (Steel.Memory.star pre frame) (fun x -> Steel.Memory.star (post x) frame) req ens

Prims.Tot

[ "total" ]

[]

[ "Steel.Memory.inames", "Steel.Memory.slprop", "Steel.Memory.mprop", "Steel.Memory.mprop2", "Steel.Memory.action_except_full", "Prims.unit", "Prims._assert", "Steel.Memory.interp", "Steel.Memory.star", "Steel.Memory.linv", "Steel.Memory.equiv_pqrs_p_qr_s", "Steel.Memory.full_mem", "FStar.NMSTTotal.get", "Steel.Memory.mem_evolves" ]

[]

false

let frame (#a: Type) (#opened_invariants: inames) (#pre: slprop) (#post: (a -> slprop)) (#req: mprop pre) (#ens: mprop2 pre post) (frame: slprop) ($f: action_except_full a opened_invariants pre post req ens) (frame0: slprop) : MstTot a opened_invariants (pre `star` frame) (fun x -> (post x) `star` frame) frame0 req ens =

let m0:full_mem = NMSTTotal.get () in equiv_pqrs_p_qr_s pre frame frame0 (linv opened_invariants m0); assert (interp (((pre `star` frame) `star` frame0) `star` (linv opened_invariants m0)) m0); assert (interp ((pre `star` (frame `star` frame0)) `star` (linv opened_invariants m0)) m0); let x = f (frame `star` frame0) in let m1:full_mem = NMSTTotal.get () in equiv_pqrs_p_qr_s (post x) frame frame0 (linv opened_invariants m1); assert (interp (((post x) `star` (frame `star` frame0)) `star` (linv opened_invariants m1)) m1); assert (interp ((((post x) `star` frame) `star` frame0) `star` (linv opened_invariants m1)) m1); x

false

IfcRecursiveReify.fst

IfcRecursiveReify.p1_r

val p1_r : lo: FStar.DM4F.Heap.IntStoreFixed.id -> hi: FStar.DM4F.Heap.IntStoreFixed.id -> n: Prims.int -> h: FStar.DM4F.Heap.IntStoreFixed.heap -> FStar.DM4F.Heap.IntStoreFixed.heap

let p1_r lo hi n h = (* normalize_term *) (snd (reify (p1 lo hi n) h))

{ "file_name": "examples/rel/IfcRecursiveReify.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }

{ "end_col": 70, "end_line": 37, "start_col": 0, "start_line": 37 }

(* Copyright 2008-2018 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 IfcRecursiveReify open FStar.DM4F.Heap.IntStoreFixed open FStar.DM4F.IntStoreFixed open Rel type label = | Low | High type env = id -> Tot label type low_equiv (env:env) (h : rel heap) = forall (x:id). {:pattern (Low? (env x))} (Low? (env x) ==> sel (R?.l h) x = sel (R?.r h) x) val p1 (lo hi :id ): n:int -> ISNull unit (decreases n) let rec p1 lo hi n = if n > 0 then (write hi (read hi -1); p1 lo hi (n-1))

{ "checked_file": "/", "dependencies": [ "Rel.fst.checked", "prims.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.DM4F.IntStoreFixed.fst.checked", "FStar.DM4F.Heap.IntStoreFixed.fsti.checked" ], "interface_file": false, "source_file": "IfcRecursiveReify.fst" }

[ { "abbrev": false, "full_module": "Rel", "short_module": null }, { "abbrev": false, "full_module": "FStar.DM4F.IntStoreFixed", "short_module": null }, { "abbrev": false, "full_module": "FStar.DM4F.Heap.IntStoreFixed", "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

lo: FStar.DM4F.Heap.IntStoreFixed.id -> hi: FStar.DM4F.Heap.IntStoreFixed.id -> n: Prims.int -> h: FStar.DM4F.Heap.IntStoreFixed.heap -> FStar.DM4F.Heap.IntStoreFixed.heap

Prims.Tot

[ "total" ]

[]

[ "FStar.DM4F.Heap.IntStoreFixed.id", "Prims.int", "FStar.DM4F.Heap.IntStoreFixed.heap", "FStar.Pervasives.Native.snd", "Prims.unit", "IfcRecursiveReify.p1" ]

[]

false

true

false

let p1_r lo hi n h =

(snd (reify (p1 lo hi n) h))

false

Platform.Bytes.fst

Platform.Bytes.empty_bytes

val empty_bytes : lbytes 0

let empty_bytes = Seq.empty #byte

{ "file_name": "ucontrib/Platform/fst/Platform.Bytes.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }

{ "end_col": 33, "end_line": 78, "start_col": 0, "start_line": 78 }

(* Copyright 2008-2018 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 Platform.Bytes assume val repr_bytes : nat -> GTot (n:nat{n>0}) (* Integer literals are currently extracted to int32, rather than bigint, so the definition below breaks extraction: Unexpected error; please file a bug report, ideally with a minimized version of the source program that triggered the error. int_of_string Also, defining repr_bytes n <= 8 for all n is dubious *) (* let repr_bytes n = if n < 256 then 1 else if n < 65536 then 2 else if n < 16777216 then 3 else if n < 4294967296 then 4 else if n < 1099511627776 then 5 else if n < 281474976710656 then 6 else if n < 72057594037927936 then 7 else 8 *) (* NS: The two assumes below were previously defined as axioms. They are evil! They pollute the global environment and slow down verification enormously. I've made them assumed lemmas; if you want to make use of these axioms, call the lemmas as needed in the context. *) assume val lemma_repr_bytes_values: n:nat -> Lemma ( ( n < 256 <==> repr_bytes n = 1 ) /\ ( (n >= 256 /\ n < 65536) <==> repr_bytes n = 2 ) /\ ( (n >= 65536 /\ n < 16777216) <==> repr_bytes n = 3 ) /\ ( (n >= 16777216 /\ n < 4294967296) <==> repr_bytes n = 4 ) /\ ( (n >= 4294967296 /\ n < 1099511627776) <==> repr_bytes n = 5 ) /\ ( (n >= 1099511627776 /\ n < 281474976710656) <==> repr_bytes n = 6 ) /\ ( (n >= 281474976710656 /\ n < 72057594037927936) <==> repr_bytes n = 7 ) /\ ( (n >= 72057594037927936 /\ n < 18446744073709551616) <==> repr_bytes n = 8 ) ) unfold let byte:Type0 = FStar.UInt8.t type cbytes = string (* abstract *) type bytes = Seq.seq byte (* AR: adding this *) assume HasEq_bytes: hasEq bytes val seq_of_bytes: b:bytes -> GTot (Seq.seq byte) let seq_of_bytes b = b val op_At_Bar: bytes -> bytes -> Tot bytes let op_At_Bar (b1:bytes) (b2:bytes) = Seq.append b1 b2 (*@ function val B : (bytes -> byte array) @*) (*@ assume val length : (b:bytes -> (l:nat){Length (b) = l}) @*) val length : bytes -> Tot nat let length b = Seq.length b (*@ type (l:nat) lbytes = (b:bytes){Length (b) = l} @*) type lbytes (l:nat) = b:bytes{length b = l} (*@ val empty_bytes : (b:bytes){B (b) = C_array_of_list C_op_Nil ()} @*)

{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.UInt8.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked" ], "interface_file": false, "source_file": "Platform.Bytes.fst" }

[ { "abbrev": false, "full_module": "Platform", "short_module": null }, { "abbrev": false, "full_module": "Platform", "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

Platform.Bytes.lbytes 0

Prims.Tot

[ "total" ]

[]

[ "FStar.Seq.Base.empty", "Platform.Bytes.byte" ]

[]

false

let empty_bytes =

Seq.empty #byte

false

Platform.Bytes.fst

Platform.Bytes.cbyte2

val cbyte2 : b:bytes{Seq.length b >= 2} -> Tot (FStar.UInt8.t * FStar.UInt8.t)

let cbyte2 b = (Seq.index b 0, Seq.index b 1)

{ "file_name": "ucontrib/Platform/fst/Platform.Bytes.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }

{ "end_col": 45, "end_line": 97, "start_col": 0, "start_line": 97 }

(* Copyright 2008-2018 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 Platform.Bytes assume val repr_bytes : nat -> GTot (n:nat{n>0}) (* Integer literals are currently extracted to int32, rather than bigint, so the definition below breaks extraction: Unexpected error; please file a bug report, ideally with a minimized version of the source program that triggered the error. int_of_string Also, defining repr_bytes n <= 8 for all n is dubious *) (* let repr_bytes n = if n < 256 then 1 else if n < 65536 then 2 else if n < 16777216 then 3 else if n < 4294967296 then 4 else if n < 1099511627776 then 5 else if n < 281474976710656 then 6 else if n < 72057594037927936 then 7 else 8 *) (* NS: The two assumes below were previously defined as axioms. They are evil! They pollute the global environment and slow down verification enormously. I've made them assumed lemmas; if you want to make use of these axioms, call the lemmas as needed in the context. *) assume val lemma_repr_bytes_values: n:nat -> Lemma ( ( n < 256 <==> repr_bytes n = 1 ) /\ ( (n >= 256 /\ n < 65536) <==> repr_bytes n = 2 ) /\ ( (n >= 65536 /\ n < 16777216) <==> repr_bytes n = 3 ) /\ ( (n >= 16777216 /\ n < 4294967296) <==> repr_bytes n = 4 ) /\ ( (n >= 4294967296 /\ n < 1099511627776) <==> repr_bytes n = 5 ) /\ ( (n >= 1099511627776 /\ n < 281474976710656) <==> repr_bytes n = 6 ) /\ ( (n >= 281474976710656 /\ n < 72057594037927936) <==> repr_bytes n = 7 ) /\ ( (n >= 72057594037927936 /\ n < 18446744073709551616) <==> repr_bytes n = 8 ) ) unfold let byte:Type0 = FStar.UInt8.t type cbytes = string (* abstract *) type bytes = Seq.seq byte (* AR: adding this *) assume HasEq_bytes: hasEq bytes val seq_of_bytes: b:bytes -> GTot (Seq.seq byte) let seq_of_bytes b = b val op_At_Bar: bytes -> bytes -> Tot bytes let op_At_Bar (b1:bytes) (b2:bytes) = Seq.append b1 b2 (*@ function val B : (bytes -> byte array) @*) (*@ assume val length : (b:bytes -> (l:nat){Length (b) = l}) @*) val length : bytes -> Tot nat let length b = Seq.length b (*@ type (l:nat) lbytes = (b:bytes){Length (b) = l} @*) type lbytes (l:nat) = b:bytes{length b = l} (*@ val empty_bytes : (b:bytes){B (b) = C_array_of_list C_op_Nil ()} @*) val empty_bytes : lbytes 0 let empty_bytes = Seq.empty #byte (*@ assume val abytes : (b:cbytes -> (a:bytes){B (a) = b}) @*) assume val abytes : (cbytes -> Tot bytes) (*@ assume val abyte : (b:byte -> (a:bytes){B (a) = C_array_of_list C_op_ColonColon (b, C_op_Nil ())}) @*) val abyte : (FStar.UInt8.t -> Tot bytes) let abyte b = Seq.create 1 b val abyte2 : (FStar.UInt8.t * FStar.UInt8.t) -> Tot bytes let abyte2 (b1, b2) = Seq.append (Seq.create 1 b1) (Seq.create 1 b2) (*@ assume val get_cbytes : (a:bytes -> (b:cbytes){B (a) = b}) @*) assume val get_cbytes : (bytes -> Tot cbytes) val cbyte : b:bytes{Seq.length b > 0} -> Tot FStar.UInt8.t let cbyte b = Seq.index b 0

{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.UInt8.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked" ], "interface_file": false, "source_file": "Platform.Bytes.fst" }

[ { "abbrev": false, "full_module": "Platform", "short_module": null }, { "abbrev": false, "full_module": "Platform", "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

b: Platform.Bytes.bytes{FStar.Seq.Base.length b >= 2} -> FStar.UInt8.t * FStar.UInt8.t

Prims.Tot

[ "total" ]

[]

[ "Platform.Bytes.bytes", "Prims.b2t", "Prims.op_GreaterThanOrEqual", "FStar.Seq.Base.length", "Platform.Bytes.byte", "FStar.Pervasives.Native.Mktuple2", "FStar.UInt8.t", "FStar.Seq.Base.index", "FStar.Pervasives.Native.tuple2" ]

[]

false

let cbyte2 b =

(Seq.index b 0, Seq.index b 1)

false

IfcRecursiveReify.fst

IfcRecursiveReify.p2_r

val p2_r : lo: FStar.DM4F.Heap.IntStoreFixed.id -> hi: FStar.DM4F.Heap.IntStoreFixed.id -> n: Prims.int -> h: FStar.DM4F.Heap.IntStoreFixed.heap -> FStar.DM4F.Heap.IntStoreFixed.heap

let p2_r lo hi n h = (* normalize_term *) (snd (reify (p2 lo hi n) h))

{ "file_name": "examples/rel/IfcRecursiveReify.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }

{ "end_col": 70, "end_line": 62, "start_col": 0, "start_line": 62 }

(* Copyright 2008-2018 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 IfcRecursiveReify open FStar.DM4F.Heap.IntStoreFixed open FStar.DM4F.IntStoreFixed open Rel type label = | Low | High type env = id -> Tot label type low_equiv (env:env) (h : rel heap) = forall (x:id). {:pattern (Low? (env x))} (Low? (env x) ==> sel (R?.l h) x = sel (R?.r h) x) val p1 (lo hi :id ): n:int -> ISNull unit (decreases n) let rec p1 lo hi n = if n > 0 then (write hi (read hi -1); p1 lo hi (n-1)) let p1_r lo hi n h = (* normalize_term *) (snd (reify (p1 lo hi n) h)) val ni_p1 (lo hi : id) (n:int) (env:env) (h :rel heap) : Lemma (requires (lo <> hi /\ Low? (env lo) /\ High? (env hi) /\ low_equiv env h)) (ensures (low_equiv env (R (p1_r lo hi n (R?.l h)) (p1_r lo hi n (R?.r h))))) let rec ni_p1 lo hi n env h = if n > 0 then begin let R hl hr = h in let hl' = (upd hl hi (sel hl hi - 1)) in let hr' = (upd hr hi (sel hr hi - 1)) in ni_p1 lo hi (n-1) env (R hl' hr') end val p2 (lo hi :id ): n:int -> ISNull unit (decreases n) let rec p2 lo hi n = if n > 0 then (write hi (read hi + 1); p2 lo hi (n - 1))

{ "checked_file": "/", "dependencies": [ "Rel.fst.checked", "prims.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.DM4F.IntStoreFixed.fst.checked", "FStar.DM4F.Heap.IntStoreFixed.fsti.checked" ], "interface_file": false, "source_file": "IfcRecursiveReify.fst" }

[ { "abbrev": false, "full_module": "Rel", "short_module": null }, { "abbrev": false, "full_module": "FStar.DM4F.IntStoreFixed", "short_module": null }, { "abbrev": false, "full_module": "FStar.DM4F.Heap.IntStoreFixed", "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

lo: FStar.DM4F.Heap.IntStoreFixed.id -> hi: FStar.DM4F.Heap.IntStoreFixed.id -> n: Prims.int -> h: FStar.DM4F.Heap.IntStoreFixed.heap -> FStar.DM4F.Heap.IntStoreFixed.heap

Prims.Tot

[ "total" ]

[]

[ "FStar.DM4F.Heap.IntStoreFixed.id", "Prims.int", "FStar.DM4F.Heap.IntStoreFixed.heap", "FStar.Pervasives.Native.snd", "Prims.unit", "IfcRecursiveReify.p2" ]

[]

false

true

false

let p2_r lo hi n h =

(snd (reify (p2 lo hi n) h))

false

IfcRecursiveReify.fst

IfcRecursiveReify.p3

val p3 : lo1: FStar.DM4F.Heap.IntStoreFixed.id -> lo2: FStar.DM4F.Heap.IntStoreFixed.id -> hi: FStar.DM4F.Heap.IntStoreFixed.id -> n: Prims.int -> FStar.DM4F.IntStoreFixed.INT_STORE Prims.unit

let p3 lo1 lo2 hi n = p1 lo1 hi n ; p2 lo2 hi n

{ "file_name": "examples/rel/IfcRecursiveReify.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }

{ "end_col": 13, "end_line": 83, "start_col": 1, "start_line": 81 }

(* Copyright 2008-2018 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 IfcRecursiveReify open FStar.DM4F.Heap.IntStoreFixed open FStar.DM4F.IntStoreFixed open Rel type label = | Low | High type env = id -> Tot label type low_equiv (env:env) (h : rel heap) = forall (x:id). {:pattern (Low? (env x))} (Low? (env x) ==> sel (R?.l h) x = sel (R?.r h) x) val p1 (lo hi :id ): n:int -> ISNull unit (decreases n) let rec p1 lo hi n = if n > 0 then (write hi (read hi -1); p1 lo hi (n-1)) let p1_r lo hi n h = (* normalize_term *) (snd (reify (p1 lo hi n) h)) val ni_p1 (lo hi : id) (n:int) (env:env) (h :rel heap) : Lemma (requires (lo <> hi /\ Low? (env lo) /\ High? (env hi) /\ low_equiv env h)) (ensures (low_equiv env (R (p1_r lo hi n (R?.l h)) (p1_r lo hi n (R?.r h))))) let rec ni_p1 lo hi n env h = if n > 0 then begin let R hl hr = h in let hl' = (upd hl hi (sel hl hi - 1)) in let hr' = (upd hr hi (sel hr hi - 1)) in ni_p1 lo hi (n-1) env (R hl' hr') end val p2 (lo hi :id ): n:int -> ISNull unit (decreases n) let rec p2 lo hi n = if n > 0 then (write hi (read hi + 1); p2 lo hi (n - 1)) let p2_r lo hi n h = (* normalize_term *) (snd (reify (p2 lo hi n) h)) val ni_p2 (lo hi : id) (n:int) (env:env) (h :rel heap) : Lemma (requires (lo <> hi /\ Low? (env lo) /\ High? (env hi) /\ low_equiv env h)) (ensures (low_equiv env (R (p2_r lo hi n (R?.l h)) (p2_r lo hi n (R?.r h))))) let rec ni_p2 lo hi n env h = if n > 0 then begin let R hl hr = h in let hl' = (upd hl hi (sel hl hi + 1)) in let hr' = (upd hr hi (sel hr hi + 1)) in ni_p2 lo hi (n-1) env (R hl' hr') end

{ "checked_file": "/", "dependencies": [ "Rel.fst.checked", "prims.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.DM4F.IntStoreFixed.fst.checked", "FStar.DM4F.Heap.IntStoreFixed.fsti.checked" ], "interface_file": false, "source_file": "IfcRecursiveReify.fst" }

[ { "abbrev": false, "full_module": "Rel", "short_module": null }, { "abbrev": false, "full_module": "FStar.DM4F.IntStoreFixed", "short_module": null }, { "abbrev": false, "full_module": "FStar.DM4F.Heap.IntStoreFixed", "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

lo1: FStar.DM4F.Heap.IntStoreFixed.id -> lo2: FStar.DM4F.Heap.IntStoreFixed.id -> hi: FStar.DM4F.Heap.IntStoreFixed.id -> n: Prims.int -> FStar.DM4F.IntStoreFixed.INT_STORE Prims.unit

FStar.DM4F.IntStoreFixed.INT_STORE

[]

[ "FStar.DM4F.Heap.IntStoreFixed.id", "Prims.int", "IfcRecursiveReify.p2", "Prims.unit", "IfcRecursiveReify.p1" ]

[]

false

true

false

let p3 lo1 lo2 hi n =

p1 lo1 hi n; p2 lo2 hi n

false

Platform.Bytes.fst

Platform.Bytes.cbyte

val cbyte : b:bytes{Seq.length b > 0} -> Tot FStar.UInt8.t

let cbyte b = Seq.index b 0

{ "file_name": "ucontrib/Platform/fst/Platform.Bytes.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }

{ "end_col": 27, "end_line": 94, "start_col": 0, "start_line": 94 }

(* Copyright 2008-2018 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 Platform.Bytes assume val repr_bytes : nat -> GTot (n:nat{n>0}) (* Integer literals are currently extracted to int32, rather than bigint, so the definition below breaks extraction: Unexpected error; please file a bug report, ideally with a minimized version of the source program that triggered the error. int_of_string Also, defining repr_bytes n <= 8 for all n is dubious *) (* let repr_bytes n = if n < 256 then 1 else if n < 65536 then 2 else if n < 16777216 then 3 else if n < 4294967296 then 4 else if n < 1099511627776 then 5 else if n < 281474976710656 then 6 else if n < 72057594037927936 then 7 else 8 *) (* NS: The two assumes below were previously defined as axioms. They are evil! They pollute the global environment and slow down verification enormously. I've made them assumed lemmas; if you want to make use of these axioms, call the lemmas as needed in the context. *) assume val lemma_repr_bytes_values: n:nat -> Lemma ( ( n < 256 <==> repr_bytes n = 1 ) /\ ( (n >= 256 /\ n < 65536) <==> repr_bytes n = 2 ) /\ ( (n >= 65536 /\ n < 16777216) <==> repr_bytes n = 3 ) /\ ( (n >= 16777216 /\ n < 4294967296) <==> repr_bytes n = 4 ) /\ ( (n >= 4294967296 /\ n < 1099511627776) <==> repr_bytes n = 5 ) /\ ( (n >= 1099511627776 /\ n < 281474976710656) <==> repr_bytes n = 6 ) /\ ( (n >= 281474976710656 /\ n < 72057594037927936) <==> repr_bytes n = 7 ) /\ ( (n >= 72057594037927936 /\ n < 18446744073709551616) <==> repr_bytes n = 8 ) ) unfold let byte:Type0 = FStar.UInt8.t type cbytes = string (* abstract *) type bytes = Seq.seq byte (* AR: adding this *) assume HasEq_bytes: hasEq bytes val seq_of_bytes: b:bytes -> GTot (Seq.seq byte) let seq_of_bytes b = b val op_At_Bar: bytes -> bytes -> Tot bytes let op_At_Bar (b1:bytes) (b2:bytes) = Seq.append b1 b2 (*@ function val B : (bytes -> byte array) @*) (*@ assume val length : (b:bytes -> (l:nat){Length (b) = l}) @*) val length : bytes -> Tot nat let length b = Seq.length b (*@ type (l:nat) lbytes = (b:bytes){Length (b) = l} @*) type lbytes (l:nat) = b:bytes{length b = l} (*@ val empty_bytes : (b:bytes){B (b) = C_array_of_list C_op_Nil ()} @*) val empty_bytes : lbytes 0 let empty_bytes = Seq.empty #byte (*@ assume val abytes : (b:cbytes -> (a:bytes){B (a) = b}) @*) assume val abytes : (cbytes -> Tot bytes) (*@ assume val abyte : (b:byte -> (a:bytes){B (a) = C_array_of_list C_op_ColonColon (b, C_op_Nil ())}) @*) val abyte : (FStar.UInt8.t -> Tot bytes) let abyte b = Seq.create 1 b val abyte2 : (FStar.UInt8.t * FStar.UInt8.t) -> Tot bytes let abyte2 (b1, b2) = Seq.append (Seq.create 1 b1) (Seq.create 1 b2) (*@ assume val get_cbytes : (a:bytes -> (b:cbytes){B (a) = b}) @*) assume val get_cbytes : (bytes -> Tot cbytes)

{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.UInt8.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked" ], "interface_file": false, "source_file": "Platform.Bytes.fst" }

[ { "abbrev": false, "full_module": "Platform", "short_module": null }, { "abbrev": false, "full_module": "Platform", "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

b: Platform.Bytes.bytes{FStar.Seq.Base.length b > 0} -> FStar.UInt8.t

Prims.Tot

[ "total" ]

[]

[ "Platform.Bytes.bytes", "Prims.b2t", "Prims.op_GreaterThan", "FStar.Seq.Base.length", "Platform.Bytes.byte", "FStar.Seq.Base.index", "FStar.UInt8.t" ]

[]

false

let cbyte b =

Seq.index b 0

false

Config.fst

Config.emit_config_as_fstar_module

val emit_config_as_fstar_module : module_name: Prims.string -> c: Config.config -> FStar.All.ALL Prims.string

let emit_config_as_fstar_module (module_name:string) (c:config) = let flags = List.map (Printf.sprintf "[@@ CIfDef]\nassume\nval ___%s : bool" ) c.compile_time_flags.flags in let assumes = String.concat "\n\n" flags in Printf.sprintf "module %s\n%s\n" module_name assumes

{ "file_name": "src/3d/Config.fst", "git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa", "git_url": "https://github.com/project-everest/everparse.git", "project_name": "everparse" }

{ "end_col": 54, "end_line": 21, "start_col": 0, "start_line": 14 }

module Config module O = Options [@@ PpxDerivingYoJson] type compile_time_flags = { flags : list string; include_file : string; } [@@ PpxDerivingYoJson] type config = { compile_time_flags : compile_time_flags }

{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "Options.fsti.checked", "FStar.String.fsti.checked", "FStar.Printf.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.List.fst.checked" ], "interface_file": false, "source_file": "Config.fst" }

[ { "abbrev": true, "full_module": "Options", "short_module": "O" }, { "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

module_name: Prims.string -> c: Config.config -> FStar.All.ALL Prims.string

FStar.All.ALL

[ "trivial_postcondition" ]

[]

[ "Prims.string", "Config.config", "FStar.Printf.sprintf", "FStar.String.concat", "Prims.list", "FStar.List.map", "Config.__proj__Mkcompile_time_flags__item__flags", "Config.__proj__Mkconfig__item__compile_time_flags" ]

[]

false

true

false

let emit_config_as_fstar_module (module_name: string) (c: config) =

let flags = List.map (Printf.sprintf "[@@ CIfDef]\nassume\nval ___%s : bool") c.compile_time_flags.flags in let assumes = String.concat "\n\n" flags in Printf.sprintf "module %s\n%s\n" module_name assumes

false

Platform.Bytes.fst

Platform.Bytes.index

val index : b:bytes -> i:nat{Seq.length b > i} -> Tot FStar.UInt8.t

let index b i = Seq.index b i

{ "file_name": "ucontrib/Platform/fst/Platform.Bytes.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }

{ "end_col": 29, "end_line": 100, "start_col": 0, "start_line": 100 }

(* Copyright 2008-2018 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 Platform.Bytes assume val repr_bytes : nat -> GTot (n:nat{n>0}) (* Integer literals are currently extracted to int32, rather than bigint, so the definition below breaks extraction: Unexpected error; please file a bug report, ideally with a minimized version of the source program that triggered the error. int_of_string Also, defining repr_bytes n <= 8 for all n is dubious *) (* let repr_bytes n = if n < 256 then 1 else if n < 65536 then 2 else if n < 16777216 then 3 else if n < 4294967296 then 4 else if n < 1099511627776 then 5 else if n < 281474976710656 then 6 else if n < 72057594037927936 then 7 else 8 *) (* NS: The two assumes below were previously defined as axioms. They are evil! They pollute the global environment and slow down verification enormously. I've made them assumed lemmas; if you want to make use of these axioms, call the lemmas as needed in the context. *) assume val lemma_repr_bytes_values: n:nat -> Lemma ( ( n < 256 <==> repr_bytes n = 1 ) /\ ( (n >= 256 /\ n < 65536) <==> repr_bytes n = 2 ) /\ ( (n >= 65536 /\ n < 16777216) <==> repr_bytes n = 3 ) /\ ( (n >= 16777216 /\ n < 4294967296) <==> repr_bytes n = 4 ) /\ ( (n >= 4294967296 /\ n < 1099511627776) <==> repr_bytes n = 5 ) /\ ( (n >= 1099511627776 /\ n < 281474976710656) <==> repr_bytes n = 6 ) /\ ( (n >= 281474976710656 /\ n < 72057594037927936) <==> repr_bytes n = 7 ) /\ ( (n >= 72057594037927936 /\ n < 18446744073709551616) <==> repr_bytes n = 8 ) ) unfold let byte:Type0 = FStar.UInt8.t type cbytes = string (* abstract *) type bytes = Seq.seq byte (* AR: adding this *) assume HasEq_bytes: hasEq bytes val seq_of_bytes: b:bytes -> GTot (Seq.seq byte) let seq_of_bytes b = b val op_At_Bar: bytes -> bytes -> Tot bytes let op_At_Bar (b1:bytes) (b2:bytes) = Seq.append b1 b2 (*@ function val B : (bytes -> byte array) @*) (*@ assume val length : (b:bytes -> (l:nat){Length (b) = l}) @*) val length : bytes -> Tot nat let length b = Seq.length b (*@ type (l:nat) lbytes = (b:bytes){Length (b) = l} @*) type lbytes (l:nat) = b:bytes{length b = l} (*@ val empty_bytes : (b:bytes){B (b) = C_array_of_list C_op_Nil ()} @*) val empty_bytes : lbytes 0 let empty_bytes = Seq.empty #byte (*@ assume val abytes : (b:cbytes -> (a:bytes){B (a) = b}) @*) assume val abytes : (cbytes -> Tot bytes) (*@ assume val abyte : (b:byte -> (a:bytes){B (a) = C_array_of_list C_op_ColonColon (b, C_op_Nil ())}) @*) val abyte : (FStar.UInt8.t -> Tot bytes) let abyte b = Seq.create 1 b val abyte2 : (FStar.UInt8.t * FStar.UInt8.t) -> Tot bytes let abyte2 (b1, b2) = Seq.append (Seq.create 1 b1) (Seq.create 1 b2) (*@ assume val get_cbytes : (a:bytes -> (b:cbytes){B (a) = b}) @*) assume val get_cbytes : (bytes -> Tot cbytes) val cbyte : b:bytes{Seq.length b > 0} -> Tot FStar.UInt8.t let cbyte b = Seq.index b 0 val cbyte2 : b:bytes{Seq.length b >= 2} -> Tot (FStar.UInt8.t * FStar.UInt8.t) let cbyte2 b = (Seq.index b 0, Seq.index b 1)

{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.UInt8.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked" ], "interface_file": false, "source_file": "Platform.Bytes.fst" }

[ { "abbrev": false, "full_module": "Platform", "short_module": null }, { "abbrev": false, "full_module": "Platform", "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

b: Platform.Bytes.bytes -> i: Prims.nat{FStar.Seq.Base.length b > i} -> FStar.UInt8.t

Prims.Tot

[ "total" ]

[]

[ "Platform.Bytes.bytes", "Prims.nat", "Prims.b2t", "Prims.op_GreaterThan", "FStar.Seq.Base.length", "Platform.Bytes.byte", "FStar.Seq.Base.index", "FStar.UInt8.t" ]

[]

false

let index b i =

Seq.index b i

false

FStar.Pointer.Derived3.fst

FStar.Pointer.Derived3.fill_buffer_precond'

val fill_buffer_precond' (#t: typ) (b: buffer t) (h: HS.mem) : GTot Type0

let fill_buffer_precond' (#t: typ) (b: buffer t) (* destination *) (h: HS.mem) : GTot Type0 = buffer_live h b

{ "file_name": "ulib/legacy/FStar.Pointer.Derived3.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }

{ "end_col": 17, "end_line": 28, "start_col": 0, "start_line": 23 }

(* Copyright 2008-2018 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 FStar.Pointer.Derived3 module HH = FStar.HyperStack module HS = FStar.HyperStack module HST = FStar.HyperStack.ST

{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.UInt32.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Ghost.fsti.checked" ], "interface_file": true, "source_file": "FStar.Pointer.Derived3.fst" }

[ { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HH" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HH" }, { "abbrev": false, "full_module": "FStar.Pointer.Derived1", "short_module": null }, { "abbrev": false, "full_module": "FStar.Pointer.Base", "short_module": null }, { "abbrev": false, "full_module": "FStar.Pointer", "short_module": null }, { "abbrev": false, "full_module": "FStar.Pointer", "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

b: FStar.Pointer.Base.buffer t -> h: FStar.Monotonic.HyperStack.mem -> Prims.GTot Type0

Prims.GTot

[ "sometrivial" ]

[]

[ "FStar.Pointer.Base.typ", "FStar.Pointer.Base.buffer", "FStar.Monotonic.HyperStack.mem", "FStar.Pointer.Base.buffer_live" ]

[]

false

true

let fill_buffer_precond' (#t: typ) (b: buffer t) (h: HS.mem) : GTot Type0 =

buffer_live h b

false

IfcRecursiveReify.fst

IfcRecursiveReify.p3_r

val p3_r : lo1: FStar.DM4F.Heap.IntStoreFixed.id -> lo2: FStar.DM4F.Heap.IntStoreFixed.id -> hi: FStar.DM4F.Heap.IntStoreFixed.id -> n: Prims.int -> h: FStar.DM4F.Heap.IntStoreFixed.heap -> FStar.DM4F.Heap.IntStoreFixed.heap

let p3_r lo1 lo2 hi n h = (* normalize_term *) (snd (reify (p3 lo1 lo2 hi n) h))

{ "file_name": "examples/rel/IfcRecursiveReify.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }

{ "end_col": 80, "end_line": 86, "start_col": 0, "start_line": 86 }

(* Copyright 2008-2018 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 IfcRecursiveReify open FStar.DM4F.Heap.IntStoreFixed open FStar.DM4F.IntStoreFixed open Rel type label = | Low | High type env = id -> Tot label type low_equiv (env:env) (h : rel heap) = forall (x:id). {:pattern (Low? (env x))} (Low? (env x) ==> sel (R?.l h) x = sel (R?.r h) x) val p1 (lo hi :id ): n:int -> ISNull unit (decreases n) let rec p1 lo hi n = if n > 0 then (write hi (read hi -1); p1 lo hi (n-1)) let p1_r lo hi n h = (* normalize_term *) (snd (reify (p1 lo hi n) h)) val ni_p1 (lo hi : id) (n:int) (env:env) (h :rel heap) : Lemma (requires (lo <> hi /\ Low? (env lo) /\ High? (env hi) /\ low_equiv env h)) (ensures (low_equiv env (R (p1_r lo hi n (R?.l h)) (p1_r lo hi n (R?.r h))))) let rec ni_p1 lo hi n env h = if n > 0 then begin let R hl hr = h in let hl' = (upd hl hi (sel hl hi - 1)) in let hr' = (upd hr hi (sel hr hi - 1)) in ni_p1 lo hi (n-1) env (R hl' hr') end val p2 (lo hi :id ): n:int -> ISNull unit (decreases n) let rec p2 lo hi n = if n > 0 then (write hi (read hi + 1); p2 lo hi (n - 1)) let p2_r lo hi n h = (* normalize_term *) (snd (reify (p2 lo hi n) h)) val ni_p2 (lo hi : id) (n:int) (env:env) (h :rel heap) : Lemma (requires (lo <> hi /\ Low? (env lo) /\ High? (env hi) /\ low_equiv env h)) (ensures (low_equiv env (R (p2_r lo hi n (R?.l h)) (p2_r lo hi n (R?.r h))))) let rec ni_p2 lo hi n env h = if n > 0 then begin let R hl hr = h in let hl' = (upd hl hi (sel hl hi + 1)) in let hr' = (upd hr hi (sel hr hi + 1)) in ni_p2 lo hi (n-1) env (R hl' hr') end let p3 lo1 lo2 hi n = p1 lo1 hi n ; p2 lo2 hi n

{ "checked_file": "/", "dependencies": [ "Rel.fst.checked", "prims.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.DM4F.IntStoreFixed.fst.checked", "FStar.DM4F.Heap.IntStoreFixed.fsti.checked" ], "interface_file": false, "source_file": "IfcRecursiveReify.fst" }

[ { "abbrev": false, "full_module": "Rel", "short_module": null }, { "abbrev": false, "full_module": "FStar.DM4F.IntStoreFixed", "short_module": null }, { "abbrev": false, "full_module": "FStar.DM4F.Heap.IntStoreFixed", "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

lo1: FStar.DM4F.Heap.IntStoreFixed.id -> lo2: FStar.DM4F.Heap.IntStoreFixed.id -> hi: FStar.DM4F.Heap.IntStoreFixed.id -> n: Prims.int -> h: FStar.DM4F.Heap.IntStoreFixed.heap -> FStar.DM4F.Heap.IntStoreFixed.heap

Prims.Tot

[ "total" ]

[]

[ "FStar.DM4F.Heap.IntStoreFixed.id", "Prims.int", "FStar.DM4F.Heap.IntStoreFixed.heap", "FStar.Pervasives.Native.snd", "Prims.unit", "IfcRecursiveReify.p3" ]

[]

false

true

false

let p3_r lo1 lo2 hi n h =

(snd (reify (p3 lo1 lo2 hi n) h))

false

FStar.Pointer.Derived3.fst

FStar.Pointer.Derived3.fill_buffer

val fill_buffer (#t: typ) (b: buffer t) (* destination *) (idx_b: UInt32.t) (len: UInt32.t) (v: type_of_typ t) : HST.Stack unit (requires (fun h -> fill_buffer_precond b idx_b len h )) (ensures (fun h0 _ h1 -> fill_buffer_postcond b idx_b len v h0 h1 ))

let fill_buffer = fill_buffer'

{ "file_name": "ulib/legacy/FStar.Pointer.Derived3.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }

{ "end_col": 30, "end_line": 163, "start_col": 0, "start_line": 163 }

(* Copyright 2008-2018 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 FStar.Pointer.Derived3 module HH = FStar.HyperStack module HS = FStar.HyperStack module HST = FStar.HyperStack.ST private let fill_buffer_precond' (#t: typ) (b: buffer t) (* destination *) (h: HS.mem) : GTot Type0 = buffer_live h b private let fill_buffer_postcond' (#t: typ) (b: buffer t) (* destination *) (v: type_of_typ t) (h: HS.mem) (h' : HS.mem) : GTot Type0 = fill_buffer_precond' b h /\ modifies (loc_buffer b) h h' /\ buffer_readable h' b /\ buffer_as_seq h' b == Seq.create (UInt32.v (buffer_length b)) v private let fill_buffer_inv (#t: typ) (b: buffer t) (* destination *) (len' : UInt32.t) (v: type_of_typ t) (h: HS.mem) (h' : HS.mem) : GTot Type0 = fill_buffer_precond' b h /\ modifies (loc_buffer b) h h' /\ UInt32.v len' <= UInt32.v (buffer_length b) /\ buffer_readable h' (gsub_buffer b 0ul len') /\ buffer_as_seq h' (gsub_buffer b 0ul len') == Seq.create (UInt32.v len') v private val fill_buffer_init (#t: typ) (b: buffer t) (* destination *) (v: type_of_typ t) (h: HS.mem) : Lemma (requires (fill_buffer_precond' b h)) (ensures (fill_buffer_inv b 0ul v h h)) let fill_buffer_init #t b v h = buffer_readable_intro_empty h (gsub_buffer b 0ul 0ul); Seq.lemma_eq_intro (buffer_as_seq h (gsub_buffer b 0ul 0ul)) (Seq.create 0 v) private val fill_buffer_advance (#t: typ) (b: buffer t) (* destination *) (len' : UInt32.t) (v: type_of_typ t) (h: Ghost.erased HS.mem) : HST.Stack unit (requires (fun h0 -> fill_buffer_inv b len' v (Ghost.reveal h) h0 /\ UInt32.v len' < UInt32.v (buffer_length b) )) (ensures (fun h1 _ h2 -> fill_buffer_inv b len' v (Ghost.reveal h) h1 /\ UInt32.v len' < UInt32.v (buffer_length b) /\ fill_buffer_inv b (UInt32.add len' 1ul) v (Ghost.reveal h) h2 )) #set-options "--z3rlimit 16" let fill_buffer_advance #t b len' v h = buffer_snoc b 0ul len' v; Seq.lemma_eq_intro (Seq.snoc (Seq.create (UInt32.v len') v) v) (Seq.create (UInt32.v (UInt32.add len' 1ul)) v) private val fill_buffer_aux (#t: typ) (b: buffer t) (* destination *) (len: UInt32.t) (len': UInt32.t) (v: type_of_typ t) (h: Ghost.erased HS.mem) : HST.Stack unit (requires (fun h0 -> fill_buffer_inv b len' v (Ghost.reveal h) h0 /\ len == buffer_length b )) (ensures (fun h0 _ h1 -> fill_buffer_inv b len' v (Ghost.reveal h) h0 /\ fill_buffer_postcond' b v (Ghost.reveal h) h1 )) (decreases (UInt32.v (buffer_length b) - UInt32.v len')) let rec fill_buffer_aux #t b len len' v h = if len = len' then () else begin fill_buffer_advance b len' v h; fill_buffer_aux b len (UInt32.add len' 1ul) v h end let fill_buffer_fin (#t: typ) (b: buffer t) (* destination *) (idx_b: UInt32.t) (len: UInt32.t) (v: type_of_typ t) (h: HS.mem) (h' : HS.mem) : Lemma (requires ( fill_buffer_precond b idx_b len h /\ fill_buffer_postcond' (gsub_buffer b idx_b len) v h h' )) (ensures ( fill_buffer_precond b idx_b len h /\ fill_buffer_postcond b idx_b len v h h' )) = () let fill_buffer' (#t: typ) (b: buffer t) (* destination *) (idx_b: UInt32.t) (len: UInt32.t) (v: type_of_typ t) : HST.Stack unit (requires (fun h -> fill_buffer_precond b idx_b len h )) (ensures (fun h0 _ h1 -> fill_buffer_postcond b idx_b len v h0 h1 )) = let h0 = HST.get () in let b' = sub_buffer b idx_b len in fill_buffer_init b' v h0; fill_buffer_aux b' len 0ul v (Ghost.hide h0); let h1 = HST.get () in fill_buffer_fin b idx_b len v h0 h1

{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.UInt32.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Ghost.fsti.checked" ], "interface_file": true, "source_file": "FStar.Pointer.Derived3.fst" }

[ { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HH" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HH" }, { "abbrev": false, "full_module": "FStar.Pointer.Derived1", "short_module": null }, { "abbrev": false, "full_module": "FStar.Pointer.Base", "short_module": null }, { "abbrev": false, "full_module": "FStar.Pointer", "short_module": null }, { "abbrev": false, "full_module": "FStar.Pointer", "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": 16, "z3rlimit_factor": 1, "z3seed": 0, "z3smtopt": [], "z3version": "4.8.5" }

false

b: FStar.Pointer.Base.buffer t -> idx_b: FStar.UInt32.t -> len: FStar.UInt32.t -> v: FStar.Pointer.Base.type_of_typ t -> FStar.HyperStack.ST.Stack Prims.unit

FStar.HyperStack.ST.Stack

[]

[ "FStar.Pointer.Derived3.fill_buffer'" ]

[]

false

true

false

let fill_buffer =

fill_buffer'

false

Platform.Bytes.fst

Platform.Bytes.split

val split: b:bytes -> n:nat{n <= Seq.length b} -> Tot (x:(bytes * bytes) {Seq.length (fst (x))= n /\ Seq.length (snd (x)) == (Seq.length b) - n })

let split b (n:nat { n <= Seq.length b}) = Seq.split b n

{ "file_name": "ucontrib/Platform/fst/Platform.Bytes.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }

{ "end_col": 56, "end_line": 129, "start_col": 0, "start_line": 129 }

(* Copyright 2008-2018 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 Platform.Bytes assume val repr_bytes : nat -> GTot (n:nat{n>0}) (* Integer literals are currently extracted to int32, rather than bigint, so the definition below breaks extraction: Unexpected error; please file a bug report, ideally with a minimized version of the source program that triggered the error. int_of_string Also, defining repr_bytes n <= 8 for all n is dubious *) (* let repr_bytes n = if n < 256 then 1 else if n < 65536 then 2 else if n < 16777216 then 3 else if n < 4294967296 then 4 else if n < 1099511627776 then 5 else if n < 281474976710656 then 6 else if n < 72057594037927936 then 7 else 8 *) (* NS: The two assumes below were previously defined as axioms. They are evil! They pollute the global environment and slow down verification enormously. I've made them assumed lemmas; if you want to make use of these axioms, call the lemmas as needed in the context. *) assume val lemma_repr_bytes_values: n:nat -> Lemma ( ( n < 256 <==> repr_bytes n = 1 ) /\ ( (n >= 256 /\ n < 65536) <==> repr_bytes n = 2 ) /\ ( (n >= 65536 /\ n < 16777216) <==> repr_bytes n = 3 ) /\ ( (n >= 16777216 /\ n < 4294967296) <==> repr_bytes n = 4 ) /\ ( (n >= 4294967296 /\ n < 1099511627776) <==> repr_bytes n = 5 ) /\ ( (n >= 1099511627776 /\ n < 281474976710656) <==> repr_bytes n = 6 ) /\ ( (n >= 281474976710656 /\ n < 72057594037927936) <==> repr_bytes n = 7 ) /\ ( (n >= 72057594037927936 /\ n < 18446744073709551616) <==> repr_bytes n = 8 ) ) unfold let byte:Type0 = FStar.UInt8.t type cbytes = string (* abstract *) type bytes = Seq.seq byte (* AR: adding this *) assume HasEq_bytes: hasEq bytes val seq_of_bytes: b:bytes -> GTot (Seq.seq byte) let seq_of_bytes b = b val op_At_Bar: bytes -> bytes -> Tot bytes let op_At_Bar (b1:bytes) (b2:bytes) = Seq.append b1 b2 (*@ function val B : (bytes -> byte array) @*) (*@ assume val length : (b:bytes -> (l:nat){Length (b) = l}) @*) val length : bytes -> Tot nat let length b = Seq.length b (*@ type (l:nat) lbytes = (b:bytes){Length (b) = l} @*) type lbytes (l:nat) = b:bytes{length b = l} (*@ val empty_bytes : (b:bytes){B (b) = C_array_of_list C_op_Nil ()} @*) val empty_bytes : lbytes 0 let empty_bytes = Seq.empty #byte (*@ assume val abytes : (b:cbytes -> (a:bytes){B (a) = b}) @*) assume val abytes : (cbytes -> Tot bytes) (*@ assume val abyte : (b:byte -> (a:bytes){B (a) = C_array_of_list C_op_ColonColon (b, C_op_Nil ())}) @*) val abyte : (FStar.UInt8.t -> Tot bytes) let abyte b = Seq.create 1 b val abyte2 : (FStar.UInt8.t * FStar.UInt8.t) -> Tot bytes let abyte2 (b1, b2) = Seq.append (Seq.create 1 b1) (Seq.create 1 b2) (*@ assume val get_cbytes : (a:bytes -> (b:cbytes){B (a) = b}) @*) assume val get_cbytes : (bytes -> Tot cbytes) val cbyte : b:bytes{Seq.length b > 0} -> Tot FStar.UInt8.t let cbyte b = Seq.index b 0 val cbyte2 : b:bytes{Seq.length b >= 2} -> Tot (FStar.UInt8.t * FStar.UInt8.t) let cbyte2 b = (Seq.index b 0, Seq.index b 1) val index : b:bytes -> i:nat{Seq.length b > i} -> Tot FStar.UInt8.t let index b i = Seq.index b i (*@ function assume val BLength : (cbytes -> int) @*) (*@ function assume val Length : (bytes -> int) @*) (*@ assume (!x. (!y. BLength (C_bop_ArrayAppend (x, y)) = C_bop_Addition (BLength (x), BLength (y)))) @*) (*@ assume (!x. Length (x) = BLength (B (x))) @*) (*@ assume val createBytes : (l:int -> ((v:int){C_pr_LessThanOrEqual(0, v) /\ C_pr_LessThan(v, 256)} -> (;l) lbytes)) @*) val createBytes : l:nat -> FStar.UInt8.t -> Tot (lbytes l) let createBytes l b = Seq.create l b // TODO: not implemented in ML val initBytes: l:nat -> (i:nat {i<l} -> Tot byte) -> Tot (lbytes l) let initBytes l f = Seq.init l f (*@ assume val equalBytes : (b0:bytes -> (b1:bytes -> (r:bool){r = True /\ B (b0) = B (b1) \/ r = False /\ B (b0) <> B (b1)})) @*) assume val equalBytes : b1:bytes -> b2:bytes -> Tot (b:bool{b = (b1=b2)}) (*@ assume val xor : (bytes -> (bytes -> (nb:nat -> (b3:bytes){Length (b3) = nb}))) @*) assume val xor: l:nat -> lbytes l -> lbytes l -> Tot (lbytes l) // consider making the length implicit val split: b:bytes -> n:nat{n <= Seq.length b} -> Tot (x:(bytes * bytes) {Seq.length (fst (x))= n /\ Seq.length (snd (x)) == (Seq.length b) - n }) //(lbytes n * lbytes (length b - n))

{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.UInt8.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked" ], "interface_file": false, "source_file": "Platform.Bytes.fst" }

[ { "abbrev": false, "full_module": "Platform", "short_module": null }, { "abbrev": false, "full_module": "Platform", "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

b: Platform.Bytes.bytes -> n: Prims.nat{n <= FStar.Seq.Base.length b} -> x: (Platform.Bytes.bytes * Platform.Bytes.bytes) { FStar.Seq.Base.length (FStar.Pervasives.Native.fst x) = n /\ FStar.Seq.Base.length (FStar.Pervasives.Native.snd x) == FStar.Seq.Base.length b - n }

Prims.Tot

[ "total" ]

[]

[ "Platform.Bytes.bytes", "Prims.nat", "Prims.b2t", "Prims.op_LessThanOrEqual", "FStar.Seq.Base.length", "Platform.Bytes.byte", "FStar.Seq.Properties.split", "FStar.Pervasives.Native.tuple2", "Prims.l_and", "Prims.op_Equality", "FStar.Pervasives.Native.fst", "Prims.eq2", "Prims.int", "FStar.Pervasives.Native.snd", "Prims.op_Subtraction" ]

[]

false

let split b (n: nat{n <= Seq.length b}) =

Seq.split b n

false

Platform.Bytes.fst

Platform.Bytes.createBytes

val createBytes : l:nat -> FStar.UInt8.t -> Tot (lbytes l)

let createBytes l b = Seq.create l b

{ "file_name": "ucontrib/Platform/fst/Platform.Bytes.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }

{ "end_col": 36, "end_line": 112, "start_col": 0, "start_line": 112 }

(* Copyright 2008-2018 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 Platform.Bytes assume val repr_bytes : nat -> GTot (n:nat{n>0}) (* Integer literals are currently extracted to int32, rather than bigint, so the definition below breaks extraction: Unexpected error; please file a bug report, ideally with a minimized version of the source program that triggered the error. int_of_string Also, defining repr_bytes n <= 8 for all n is dubious *) (* let repr_bytes n = if n < 256 then 1 else if n < 65536 then 2 else if n < 16777216 then 3 else if n < 4294967296 then 4 else if n < 1099511627776 then 5 else if n < 281474976710656 then 6 else if n < 72057594037927936 then 7 else 8 *) (* NS: The two assumes below were previously defined as axioms. They are evil! They pollute the global environment and slow down verification enormously. I've made them assumed lemmas; if you want to make use of these axioms, call the lemmas as needed in the context. *) assume val lemma_repr_bytes_values: n:nat -> Lemma ( ( n < 256 <==> repr_bytes n = 1 ) /\ ( (n >= 256 /\ n < 65536) <==> repr_bytes n = 2 ) /\ ( (n >= 65536 /\ n < 16777216) <==> repr_bytes n = 3 ) /\ ( (n >= 16777216 /\ n < 4294967296) <==> repr_bytes n = 4 ) /\ ( (n >= 4294967296 /\ n < 1099511627776) <==> repr_bytes n = 5 ) /\ ( (n >= 1099511627776 /\ n < 281474976710656) <==> repr_bytes n = 6 ) /\ ( (n >= 281474976710656 /\ n < 72057594037927936) <==> repr_bytes n = 7 ) /\ ( (n >= 72057594037927936 /\ n < 18446744073709551616) <==> repr_bytes n = 8 ) ) unfold let byte:Type0 = FStar.UInt8.t type cbytes = string (* abstract *) type bytes = Seq.seq byte (* AR: adding this *) assume HasEq_bytes: hasEq bytes val seq_of_bytes: b:bytes -> GTot (Seq.seq byte) let seq_of_bytes b = b val op_At_Bar: bytes -> bytes -> Tot bytes let op_At_Bar (b1:bytes) (b2:bytes) = Seq.append b1 b2 (*@ function val B : (bytes -> byte array) @*) (*@ assume val length : (b:bytes -> (l:nat){Length (b) = l}) @*) val length : bytes -> Tot nat let length b = Seq.length b (*@ type (l:nat) lbytes = (b:bytes){Length (b) = l} @*) type lbytes (l:nat) = b:bytes{length b = l} (*@ val empty_bytes : (b:bytes){B (b) = C_array_of_list C_op_Nil ()} @*) val empty_bytes : lbytes 0 let empty_bytes = Seq.empty #byte (*@ assume val abytes : (b:cbytes -> (a:bytes){B (a) = b}) @*) assume val abytes : (cbytes -> Tot bytes) (*@ assume val abyte : (b:byte -> (a:bytes){B (a) = C_array_of_list C_op_ColonColon (b, C_op_Nil ())}) @*) val abyte : (FStar.UInt8.t -> Tot bytes) let abyte b = Seq.create 1 b val abyte2 : (FStar.UInt8.t * FStar.UInt8.t) -> Tot bytes let abyte2 (b1, b2) = Seq.append (Seq.create 1 b1) (Seq.create 1 b2) (*@ assume val get_cbytes : (a:bytes -> (b:cbytes){B (a) = b}) @*) assume val get_cbytes : (bytes -> Tot cbytes) val cbyte : b:bytes{Seq.length b > 0} -> Tot FStar.UInt8.t let cbyte b = Seq.index b 0 val cbyte2 : b:bytes{Seq.length b >= 2} -> Tot (FStar.UInt8.t * FStar.UInt8.t) let cbyte2 b = (Seq.index b 0, Seq.index b 1) val index : b:bytes -> i:nat{Seq.length b > i} -> Tot FStar.UInt8.t let index b i = Seq.index b i (*@ function assume val BLength : (cbytes -> int) @*) (*@ function assume val Length : (bytes -> int) @*) (*@ assume (!x. (!y. BLength (C_bop_ArrayAppend (x, y)) = C_bop_Addition (BLength (x), BLength (y)))) @*) (*@ assume (!x. Length (x) = BLength (B (x))) @*) (*@ assume val createBytes : (l:int -> ((v:int){C_pr_LessThanOrEqual(0, v) /\ C_pr_LessThan(v, 256)} -> (;l) lbytes)) @*)

{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.UInt8.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked" ], "interface_file": false, "source_file": "Platform.Bytes.fst" }

[ { "abbrev": false, "full_module": "Platform", "short_module": null }, { "abbrev": false, "full_module": "Platform", "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

l: Prims.nat -> b: FStar.UInt8.t -> Platform.Bytes.lbytes l

Prims.Tot

[ "total" ]

[]

[ "Prims.nat", "FStar.UInt8.t", "FStar.Seq.Base.create", "Platform.Bytes.byte", "Platform.Bytes.lbytes" ]

[]

false

let createBytes l b =

Seq.create l b

false

Steel.Memory.fst

Steel.Memory.lift_tot_action_nf

val lift_tot_action_nf (#a #e #fp #fp': _) ($f: tot_action_nf_except e fp a fp') : MstTotNF a e fp fp'

let lift_tot_action_nf #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') : MstTotNF a e fp fp' = let m0 = NMSTTotal.get () in let m0' : hmem_with_inv_except e fp = m0 in let r = f m0' in let (| x, m1 |) = r in let m1' : hmem_with_inv_except e (fp' x) = m1 in assert (is_frame_preserving f); assert (m1 == dsnd (f m0)); frame_preserving_respects_preorder f m0; NMSTTotal.put #_ #(mem_evolves) m1; x

{ "file_name": "lib/steel/Steel.Memory.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 5, "end_line": 757, "start_col": 0, "start_line": 746 }

(* 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.Memory module F = FStar.FunctionalExtensionality open FStar.FunctionalExtensionality open FStar.PCM module H = Steel.Heap noeq type lock_state : Type u#(a + 1) = | Invariant : inv:H.slprop u#a -> lock_state let lock_store : Type u#(a+1) = list (lock_state u#a) noeq type mem : Type u#(a + 1) = { ctr: nat; heap: H.heap u#a; locks: lock_store u#a; } let heap_of_mem (x:mem) : H.heap = x.heap let mem_of_heap (h:H.heap) : mem = { ctr = 0; heap = h; locks = [] } let mem_set_heap (m:mem) (h:H.heap) : mem = { ctr = m.ctr; heap = h; locks = m.locks; } let core_mem (m:mem) : mem = mem_of_heap (heap_of_mem m) let core_mem_invol m = () let disjoint (m0 m1:mem u#h) : prop = m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks let disjoint_sym m0 m1 = () let join m0 m1 = { ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = m0.locks } let join_commutative m0 m1 = H.join_commutative m0.heap m1.heap let disjoint_join m0 m1 m2 = H.disjoint_join m0.heap m1.heap m2.heap let join_associative m0 m1 m2 = H.join_associative m0.heap m1.heap m2.heap let slprop = H.slprop let interp p m = H.interp p m.heap let equiv p1 p2 = forall m. interp p1 m <==> interp p2 m let slprop_extensionality p q = assert (forall m. interp p m <==> interp q m); let aux (h:H.heap) : Lemma (H.interp p h <==> H.interp q h) [SMTPat (H.interp p h)] = let m : mem = { ctr = 0; heap = h; locks = [] } in assert (interp p m <==> interp q m) in assert (forall h. H.interp p h <==> H.interp q h); Steel.Heap.slprop_extensionality p q let reveal_equiv p1 p2 = () let core_ref = H.core_ref let core_ref_null = H.core_ref_null let core_ref_is_null r = H.core_ref_is_null r let emp : slprop u#a = H.emp let pure = H.pure let pts_to = H.pts_to let h_and = H.h_and let h_or = H.h_or let star = H.star let wand = H.wand let h_exists = H.h_exists let h_forall = H.h_forall //////////////////////////////////////////////////////////////////////////////// //properties of equiv //////////////////////////////////////////////////////////////////////////////// let equiv_symmetric (p1 p2:slprop u#a) = H.equiv_symmetric p1 p2 #push-options "--warn_error -271" let equiv_heap_iff_equiv (p1 p2:slprop u#a) : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat (equiv p1 p2)] = let aux_lr () : Lemma (requires H.equiv p1 p2) (ensures equiv p1 p2) [SMTPat ()] = () in let aux_rl_helper1 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p1 h) (ensures H.interp p2 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl_helper2 (h:H.heap) : Lemma (requires equiv p1 p2 /\ H.interp p2 h) (ensures H.interp p1 h) [SMTPat ()] = assert (interp p2 (mem_of_heap h)) in let aux_rl () : Lemma (requires equiv p1 p2) (ensures H.equiv p1 p2) [SMTPat ()] = () in () let equiv_heap_iff_equiv_forall () : Lemma (ensures (forall p1 p2. H.equiv p1 p2 <==> equiv p1 p2)) = let aux p1 p2 : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat ()] = equiv_heap_iff_equiv p1 p2 in () #pop-options let equiv_extensional_on_star (p1 p2 p3:slprop u#a) = equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3 let emp_unit p = H.emp_unit p let intro_emp m = H.intro_emp (heap_of_mem m) let pure_equiv p q = H.pure_equiv p q let pure_interp q m = H.pure_interp q (heap_of_mem m) let pure_star_interp p q m = H.pure_star_interp p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// //pts_to //////////////////////////////////////////////////////////////////////////////// let pts_to_compatible #a #pcm x v0 v1 m = H.pts_to_compatible #a #pcm x v0 v1 (heap_of_mem m) let pts_to_compatible_equiv #a #pcm x v0 v1 = H.pts_to_compatible_equiv #a #pcm x v0 v1 let pts_to_not_null #a #pcm x v m = H.pts_to_not_null #a #pcm x v (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // star //////////////////////////////////////////////////////////////////////////////// let intro_star p q mp mq = H.intro_star p q (heap_of_mem mp) (heap_of_mem mq) let elim_star p q m = let h = heap_of_mem m in H.elim_star p q h; assert (exists hl hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr); let hl = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hl -> exists hr. H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let hr = FStar.IndefiniteDescription.indefinite_description_tot H.heap (fun hr -> H.disjoint hl hr /\ H.join hl hr == h /\ H.interp p hl /\ H.interp q hr) in let ml = mem_set_heap m hl in let mr = mem_set_heap m hr in assert (disjoint ml mr); assert (m == join ml mr); assert (interp p ml); assert (interp q mr); () let interp_star (p q: slprop) (m: mem) : Lemma (interp (p `star` q) m <==> (exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m)) = let left = interp (p `star` q) m in let right = exists (mp: mem) (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m in let f () : Lemma (requires left) (ensures right) = elim_star p q m in let g () : Lemma (requires right) (ensures left) = Classical.exists_elim left #_ #(fun mp -> exists (mq: mem) . disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mp -> Classical.exists_elim left #_ #(fun mq -> disjoint mp mq /\ interp p mp /\ interp q mq /\ join mp mq == m) () (fun mq -> intro_star p q mp mq ) ) in Classical.move_requires f (); Classical.move_requires g () let star_commutative (p1 p2:slprop) = H.star_commutative p1 p2 let star_associative (p1 p2 p3:slprop) = H.star_associative p1 p2 p3 let star_congruence (p1 p2 p3 p4:slprop) = equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4 let affine_star (p q:slprop) (m:mem) = H.affine_star p q (heap_of_mem m) //////////////////////////////////////////////////////////////////////////////// // Invariants on the lock store //////////////////////////////////////////////////////////////////////////////// let iname = nat module S = FStar.Set module L = FStar.List.Tot module W = FStar.Witnessed.Core let rec lock_store_invariant (e:inames) (l:lock_store u#a) : slprop u#a = let current_addr = L.length l - 1 in match l with | [] -> emp | Invariant p :: tl -> if current_addr `S.mem` e then lock_store_invariant e tl else p `star` lock_store_invariant e tl let lock_i (i:iname) (l:lock_store { i < L.length l }) = let ix = L.length l - i - 1 in L.index l ix let iname_for_p (i:iname) (p:slprop) : W.s_predicate lock_store = fun l -> i < L.length l /\ (lock_i i l).inv == p let lock_store_evolves : FStar.Preorder.preorder lock_store = fun (l1 l2 : lock_store) -> L.length l2 >= L.length l1 /\ (forall (i:nat{i < L.length l1}). (lock_i i l1).inv == (lock_i i l2).inv) let inames_in (e:inames) (l:lock_store) : prop = forall i. Set.mem i e ==> i < L.length l let inames_ok e m = inames_in e m.locks let inames_ok_empty m = () let extend_lock_store (e:inames) (l:lock_store{e `inames_in` l}) (p:slprop) : i:iname & l':lock_store { lock_store_invariant e l' == p `star` lock_store_invariant e l /\ iname_for_p i p l' } = (| L.length l, Invariant p :: l |) let set_add (i:iname) (s:inames) = Set.union (Set.singleton i) s let rec move_invariant (e:inames) (l:lock_store) (p:slprop) (i:iname{iname_for_p i p l /\ ~(i `Set.mem` e)}) : Lemma (H.equiv (lock_store_invariant e l) (p `star` lock_store_invariant (set_add i e) l)) = let rec aux (i:iname) (m:lock_store) : Lemma (requires i >= L.length m) (ensures (lock_store_invariant e m `H.equiv` lock_store_invariant (set_add i e) m)) = match m with | [] -> () | Invariant p::tl -> aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl) in let current_addr = L.length l - 1 in match l with | [] -> () | Invariant q::tl -> if i = current_addr then begin assert (lock_store_invariant e l == p `star` lock_store_invariant e tl); aux i tl; H.star_congruence p (lock_store_invariant e tl) p (lock_store_invariant (set_add i e) tl); () end else begin move_invariant e tl p i; assert (lock_store_invariant e tl `equiv` (p `star` lock_store_invariant (set_add i e) tl)); H.star_congruence q (lock_store_invariant e tl) q (p `star` lock_store_invariant (set_add i e) tl); if Set.mem current_addr e then () else begin let r = lock_store_invariant (set_add i e) tl in assert (lock_store_invariant e l `equiv` (q `star` (p `star` r))); H.star_associative q p r; H.star_commutative q p; H.star_congruence (q `star` p) r (p `star` q) r; H.star_associative p q r end end let heap_ctr_valid (ctr:nat) (h:H.heap u#a) : prop = h `H.free_above_addr` ctr let ctr_validity (ctr:nat) (h:H.heap) : slprop = H.pure (heap_ctr_valid ctr h) let locks_invariant (e:inames) (m:mem u#a) : slprop u#a = lock_store_invariant e m.locks `star` ctr_validity m.ctr (heap_of_mem m) let full_mem_pred (m:mem) = H.full_heap_pred (heap_of_mem m) (***** Following lemmas are needed in Steel.Effect *****) let core_mem_interp (hp:slprop u#a) (m:mem u#a) = () let interp_depends_only_on (hp:slprop u#a) = H.interp_depends_only_on hp let a_mem_prop_as_a_heap_prop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (H.a_heap_prop u#a) = let g (h: H.heap u#a) : Tot prop = interp sl (mem_of_heap h) /\ f (mem_of_heap h) in let phi0 (h0 h1: H.heap u#a) : Lemma (requires (g h0 /\ H.disjoint h0 h1)) (ensures (g h0 /\ H.disjoint h0 h1 /\ g (H.join h0 h1))) = assert (mem_of_heap (H.join h0 h1) == mem_of_heap h0 `join` mem_of_heap h1); interp_depends_only_on sl in let phi1 (h0 h1: H.heap u#a) : Lemma (ensures ((g h0 /\ H.disjoint h0 h1) ==> g (H.join h0 h1))) = Classical.move_requires (phi0 h0) h1 in Classical.forall_intro_2 phi1; g let refine_slprop sl f = H.as_slprop (a_mem_prop_as_a_heap_prop sl f) let interp_refine_slprop sl f m = assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_mem m)) let dep_hprop (s: slprop) (f: (hmem s -> Tot slprop)) (h: H.heap) : Tot prop = exists (h1: H.heap) . exists (h2: H.heap) . interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 let dep_hprop_is_affine0 (s: slprop) (f: (hmem s -> Tot slprop)) (h h': H.heap) (sq' : squash (dep_hprop s f h /\ H.disjoint h h')) : Lemma (H.disjoint h h' /\ dep_hprop s f (H.join h h')) = let p2 (h h1 h2: H.heap) : Tot prop = interp s (mem_of_heap h1) /\ H.disjoint h1 h2 /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ h == h1 `H.join` h2 in let p1 (h h1: H.heap) : Tot prop = (exists h2 . p2 h h1 h2) in let h1 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p1 h) in let h2 = FStar.IndefiniteDescription.indefinite_description_ghost H.heap (p2 h h1) in H.disjoint_join h' h1 h2; assert (H.disjoint h2 h'); let h2' = H.join h2 h' in H.join_commutative h2 h' ; assert (h2' == H.join h' h2); assert (H.disjoint h1 h2'); assert (mem_of_heap h2' == mem_of_heap h2 `join` mem_of_heap h'); interp_depends_only_on (f (mem_of_heap h1)); assert (interp (f (mem_of_heap h1)) (mem_of_heap h2')); H.join_commutative h1 h2; H.join_associative h' h2 h1; H.join_commutative h' h; H.join_commutative h2' h1; assert (H.join h h' == h1 `H.join` h2') let impl_intro_gen (#p: Type0) (#q: Type0) ($prf: (squash p -> Lemma (q ))) : Lemma (p ==> q) = Classical.impl_intro_gen #p #(fun _ -> q) prf let dep_hprop_is_affine1 (s: slprop) (f: (hmem s -> Tot slprop)) (h0 h1: H.heap) : Lemma ((dep_hprop s f h0 /\ H.disjoint h0 h1) ==> (H.disjoint h0 h1 /\ dep_hprop s f (H.join h0 h1))) = impl_intro_gen (dep_hprop_is_affine0 s f h0 h1) let dep_hprop_is_affine (s: slprop) (f: (hmem s -> Tot slprop)) : Lemma (H.heap_prop_is_affine (dep_hprop s f)) = Classical.forall_intro_2 (dep_hprop_is_affine1 s f) let sdep (s: slprop) (f: (hmem s -> Tot slprop)) : Tot slprop = dep_hprop_is_affine s f; H.as_slprop (dep_hprop s f) let interp_sdep (s: slprop) (f: (hmem s -> Tot slprop)) (m: mem) : Lemma (requires (dep_slprop_is_affine s f)) (ensures ( interp (sdep s f) m <==> (exists m1 m2 . interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) )) = dep_hprop_is_affine s f; assert (forall m1 m2 . (interp s m1 /\ interp (f m1) m2 /\ disjoint m1 m2 /\ join m1 m2 == m) ==> ( interp s (mem_of_heap m1.heap) /\ interp (f (mem_of_heap m1.heap)) (mem_of_heap m2.heap) /\ H.disjoint m1.heap m2.heap /\ H.join m1.heap m2.heap == m.heap )); interp_depends_only_on s; Classical.forall_intro (fun m -> interp_depends_only_on (f m)); assert (forall h1 h2 . (interp s (mem_of_heap h1) /\ interp (f (mem_of_heap h1)) (mem_of_heap h2) /\ H.disjoint h1 h2 /\ H.join h1 h2 == m.heap) ==> ( core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ interp s (core_mem (mem_of_heap h1)) /\ interp s (mem_set_heap m h1) /\ core_mem (mem_of_heap h1) == core_mem (mem_set_heap m h1) /\ f (mem_set_heap m h1) `equiv` f (mem_of_heap h1) /\ interp (f (mem_set_heap m h1)) (mem_of_heap h2) /\ interp (f (mem_set_heap m h1)) (mem_set_heap m h2) /\ disjoint (mem_set_heap m h1) (mem_set_heap m h2) /\ join (mem_set_heap m h1) (mem_set_heap m h2) == m )); () let h_exists_cong (#a:Type) (p q : a -> slprop) : Lemma (requires (forall x. p x `equiv` q x)) (ensures (h_exists p `equiv` h_exists q)) = equiv_heap_iff_equiv_forall (); H.h_exists_cong p q let intro_h_exists #a x p m = H.intro_h_exists x p (heap_of_mem m) let elim_h_exists (#a:_) (p:a -> slprop) (m:mem) = H.elim_h_exists p (heap_of_mem m) let intro_h_forall (#a:_) (p:a -> slprop) (m:mem) = H.intro_h_forall p (heap_of_mem m) let elim_h_forall (#a:_) (p:a -> slprop) (m:mem) (x:a) = H.elim_h_forall p (heap_of_mem m) x let intro_h_and (p q: slprop) (m:mem) = H.intro_h_and p q (heap_of_mem m) let elim_h_and (p q: slprop) (m:mem) = H.elim_h_and p q (heap_of_mem m) let intro_h_or_left (p q: slprop) (m:mem) = H.intro_h_or_left p q (heap_of_mem m) let intro_h_or_right (p q: slprop) (m:mem) = H.intro_h_or_right p q (heap_of_mem m) let elim_h_or (p q: slprop) (m:mem) = H.elim_h_or p q (heap_of_mem m) let intro_wand (p1 p2: slprop u#a) (m:mem) = introduce (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)) ==> interp (wand p1 p2) m with _. ( assert (forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)); H.intro_wand p1 p2 (heap_of_mem m); let h = heap_of_mem m in assert ((forall h1. h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) ==> H.interp (wand p1 p2) h); introduce forall h1. (h `H.disjoint` h1 /\ H.interp p1 h1 ==> H.interp p2 (H.join h h1)) with ( introduce (h `H.disjoint` h1 /\ H.interp p1 h1) ==> H.interp p2 (H.join h h1) with _. ( assert (h `H.disjoint` h1); let m1 = { ctr = m.ctr; heap = h1; locks = m.locks } in assert (m `disjoint` m1) ) ) ) (** Eliminating a wand by proving a heap that satisfies the LHS **) let elim_wand (p1 p2: slprop u#a) (m:mem) (m1:mem) = H.elim_wand p1 p2 (heap_of_mem m) (heap_of_mem m1) //////////////////////////////////////////////////////////////////////////////// // Preorders and effects //////////////////////////////////////////////////////////////////////////////// module PP = Steel.Preorder let mem_evolves = fun (m0 m1:full_mem) -> H.heap_evolves (heap_of_mem m0) (heap_of_mem m1) /\ m0.ctr <= m1.ctr /\ lock_store_evolves m0.locks m1.locks (** See [Steel.Heap.is_frame_preserving]. We add in [lock_invariants] now *) let preserves_frame (e:inames) (pre post:slprop) (m0 m1:mem) = forall (frame:slprop). interp ((pre `star` frame) `star` locks_invariant e m0) m0 ==> (interp ((post `star` frame) `star` locks_invariant e m1) m1 /\ (forall (f_frame:mprop frame). f_frame (core_mem m0) == f_frame (core_mem m1))) (** This is a version of MstTot with frame quantified, as part of preserves_frame *) effect MstTotNF (a:Type u#a) (except:inames) (expects:slprop u#1) (provides: a -> slprop u#1) = NMSTTotal.NMSTATETOT a (full_mem u#1) mem_evolves (requires fun m0 -> inames_ok except m0 /\ interp (expects `star` locks_invariant except m0) m0) (ensures fun m0 x m1 -> inames_ok except m1 /\ interp (provides x `star` locks_invariant except m1) m1 /\ preserves_frame except expects (provides x) m0 m1) //////////////////////////////////////////////////////////////////////////////// // Lifting heap actions //////////////////////////////////////////////////////////////////////////////// (** Heap actions come in two equivalent flavors: - one that take an explicit frame as argument (action_with_frame) - and one that quantify over all the frame We therefore define two lift routes: - a direct route for those with explicit frame - via MstTotNF for the rest *) let tot_pre_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = hmem_with_inv_except e fp -> (x:a & hmem_with_inv_except e (fp' x)) let tot_pre_action_nf = tot_pre_action_nf_except S.empty let ac_reasoning_for_m_frame_preserving (p q r:slprop u#a) (m:mem u#a) : Lemma (requires interp ((p `star` q) `star` r) m) (ensures interp (p `star` r) m) = calc (equiv) { (p `star` q) `star` r; (equiv) { star_commutative p q; equiv_extensional_on_star (p `star` q) (q `star` p) r } (q `star` p) `star` r; (equiv) { star_associative q p r } q `star` (p `star` r); }; assert (interp (q `star` (p `star` r)) m); affine_star q (p `star` r) m let is_frame_preserving (#e:inames) (#a:Type u#b) (#fp:slprop u#a) (#fp':a -> slprop u#a) (f:tot_pre_action_nf_except e fp a fp') = forall (frame:slprop u#a) (m0:hmem_with_inv_except e (fp `star` frame)). (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1))) let tot_action_nf_except (e:inames) (fp:slprop u#a) (a:Type u#b) (fp':a -> slprop u#a) = f:tot_pre_action_nf_except e fp a fp'{ is_frame_preserving f } let tot_action_nf = tot_action_nf_except S.empty let linv e (m:mem) = locks_invariant e m let hheap_of_hmem #fp #e (m:hmem_with_inv_except e fp) : h:H.hheap (fp `star` linv e m) { h `H.free_above_addr` m.ctr} = let h = heap_of_mem m in H.pure_interp (heap_ctr_valid m.ctr (heap_of_mem m)) h; h let hmem_of_hheap #e (#fp0 #fp1:slprop) (m:hmem_with_inv_except e fp0) (h:H.full_hheap (fp1 `star` linv e m) { h `Heap.free_above_addr` m.ctr }) : m1:hmem_with_inv_except e fp1{linv e m `equiv` linv e m1} = let m1 : mem = { m with heap = h } in assert (interp (fp1 `star` linv e m) m1); star_commutative fp1 (linv e m); assert (interp (linv e m `star` fp1) m1); assert (linv e m1 == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m1)); assert (linv e m == (lock_store_invariant e m1.locks) `star` ctr_validity m1.ctr (heap_of_mem m)); H.pure_interp (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_of_mem m); assert (heap_ctr_valid m1.ctr (heap_of_mem m) <==> heap_ctr_valid m1.ctr (heap_of_mem m1)); H.pure_equiv (heap_ctr_valid m1.ctr (heap_of_mem m)) (heap_ctr_valid m1.ctr (heap_of_mem m1)); H.star_congruence (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m1)) (lock_store_invariant e m1.locks) (ctr_validity m1.ctr (heap_of_mem m)); assert (linv e m `equiv` linv e m1); let _ = equiv_extensional_on_star (linv e m) (linv e m1) fp1 in assert ((linv e m `star` fp1) `equiv` (linv e m1 `star` fp1)); assert (interp (linv e m1 `star` fp1) m1); star_commutative (linv e m1) fp1; assert (interp (fp1 `star` linv e m1) m1); m1 let with_inv_except (m:mem) e (fp:slprop) = interp (fp `star` locks_invariant e m) m #push-options "--warn_error -271" let as_hprop (frame:slprop) (mp:mprop frame) : hp:H.hprop frame{forall m. mp (core_mem m) == hp (heap_of_mem m)} = let f = fun h -> mp (mem_of_heap h) in assert (forall m. mp (core_mem m) == f (heap_of_mem m)); let aux (m0:H.hheap frame) (m1:H.heap{H.disjoint m0 m1}) : Lemma (ensures (mem_of_heap (H.join m0 m1) == join (mem_of_heap m0) (mem_of_heap m1))) [SMTPat ()] = () in f let mprop_preservation_of_hprop_preservation (p:slprop) (m0 m1:mem) : Lemma (requires (forall (hp:H.hprop p). hp (heap_of_mem m0) == hp (heap_of_mem m1))) (ensures (forall (mp:mprop p). mp (core_mem m0) == mp (core_mem m1))) = let aux (mp:mprop p) : Lemma (mp (core_mem m0) == mp (core_mem m1)) [SMTPat()] = assert (as_hprop p mp (heap_of_mem m0) == as_hprop p mp (heap_of_mem m1)) in () let lift_heap_action (#fp:slprop) (#a:Type) (#fp':a -> slprop) (e:inames) ($f:H.action fp a fp') : tot_action_nf_except e fp a fp' = let g : tot_pre_action_nf_except e fp a fp' = fun m -> let h0 = hheap_of_hmem m in let (| x, h' |) = f h0 in (| x, hmem_of_hheap m h' |) in let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ensures (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1 /\ (forall (mp:mprop frame). mp (core_mem m0) == mp (core_mem m1)))) [SMTPat ()] = ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = g m0 in let h0 = hheap_of_hmem m0 in let (| x', h1 |) = f h0 in H.action_framing f (linv e m0) h0; assert (x == x'); star_associative fp frame (linv e m0); H.action_framing f (frame `star` linv e m0) h0; assert (H.interp ((fp' x) `star` (frame `star` linv e m0)) h1); star_associative (fp' x) frame (linv e m0); assert (H.interp ((fp' x `star` frame) `star` linv e m0) h1); let h1' : H.hheap ((fp' x `star` frame) `star` linv e m0) = h1 in assert (m1 == hmem_of_hheap m0 h1'); assert (with_inv_except m1 e (fp' x `star` frame)); assert (forall (hp:H.hprop frame). hp h0 == hp h1); mprop_preservation_of_hprop_preservation frame m0 m1; () in assert (is_frame_preserving g); g let frame_preserving_respects_preorder #a #e #fp #fp' ($f:tot_action_nf_except e fp a fp') (m0:hmem_with_inv_except e fp) : Lemma (let (| x, m1 |) = f m0 in mem_evolves m0 m1) = let aux (frame:slprop) (m0:hmem_with_inv_except e (fp `star` frame)) : Lemma (ac_reasoning_for_m_frame_preserving fp frame (locks_invariant e m0) m0; let (| x, m1 |) = f m0 in interp ((fp' x `star` frame) `star` locks_invariant e m1) m1 /\ mem_evolves m0 m1) = () in H.emp_unit fp; assert (interp (fp `star` linv e m0) m0); H.star_congruence (fp `star` emp) (linv e m0) fp (linv e m0); assert (interp ((fp `star` emp) `star` linv e m0) m0); aux emp m0

{ "checked_file": "/", "dependencies": [ "Steel.Preorder.fst.checked", "Steel.Heap.fsti.checked", "prims.fst.checked", "FStar.Witnessed.Core.fsti.checked", "FStar.Set.fsti.checked", "FStar.Preorder.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.PCM.fst.checked", "FStar.NMSTTotal.fst.checked", "FStar.List.Tot.fst.checked", "FStar.IndefiniteDescription.fsti.checked", "FStar.Ghost.fsti.checked", "FStar.FunctionalExtensionality.fsti.checked", "FStar.Classical.Sugar.fsti.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Steel.Memory.fst" }

[ { "abbrev": true, "full_module": "Steel.Preorder", "short_module": "PP" }, { "abbrev": true, "full_module": "FStar.Witnessed.Core", "short_module": "W" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": true, "full_module": "FStar.Set", "short_module": "S" }, { "abbrev": true, "full_module": "Steel.Heap", "short_module": "H" }, { "abbrev": false, "full_module": "FStar.PCM", "short_module": null }, { "abbrev": false, "full_module": "FStar.FunctionalExtensionality", "short_module": null }, { "abbrev": true, "full_module": "FStar.FunctionalExtensionality", "short_module": "F" }, { "abbrev": false, "full_module": "FStar.PCM", "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

$f: Steel.Memory.tot_action_nf_except e fp a fp' -> Steel.Memory.MstTotNF a

Steel.Memory.MstTotNF

[]

[ "Steel.Memory.inames", "Steel.Memory.slprop", "Steel.Memory.tot_action_nf_except", "Steel.Memory.hmem_with_inv_except", "Prims.unit", "FStar.NMSTTotal.put", "Steel.Memory.full_mem", "Steel.Memory.mem_evolves", "Steel.Memory.frame_preserving_respects_preorder", "Prims._assert", "Prims.eq2", "Prims.l_or", "Prims.l_and", "Steel.Memory.inames_ok", "Steel.Memory.interp", "Steel.Memory.star", "Steel.Memory.locks_invariant", "Prims.__proj__Mkdtuple2__item___1", "FStar.Pervasives.dsnd", "Steel.Memory.is_frame_preserving", "Prims.dtuple2", "FStar.NMSTTotal.get" ]

[]

false

true

false

let lift_tot_action_nf #a #e #fp #fp' ($f: tot_action_nf_except e fp a fp') : MstTotNF a e fp fp' =

let m0 = NMSTTotal.get () in let m0':hmem_with_inv_except e fp = m0 in let r = f m0' in let (| x , m1 |) = r in let m1':hmem_with_inv_except e (fp' x) = m1 in assert (is_frame_preserving f); assert (m1 == dsnd (f m0)); frame_preserving_respects_preorder f m0; NMSTTotal.put #_ #(mem_evolves) m1; x

false

Platform.Bytes.fst

Platform.Bytes.split_eq

val split_eq: s:bytes -> i:nat{(0 <= i /\ i <= length s)} -> Pure (x:(bytes * bytes){length (fst x) = i && length (snd x) = length s - i}) (requires True) (ensures (fun x -> ((fst x) @| (snd x) = s)))

let split_eq s i = let x = split s i in lemma_split s i; x

{ "file_name": "ucontrib/Platform/fst/Platform.Bytes.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }

{ "end_col": 3, "end_line": 143, "start_col": 0, "start_line": 140 }

(* Copyright 2008-2018 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 Platform.Bytes assume val repr_bytes : nat -> GTot (n:nat{n>0}) (* Integer literals are currently extracted to int32, rather than bigint, so the definition below breaks extraction: Unexpected error; please file a bug report, ideally with a minimized version of the source program that triggered the error. int_of_string Also, defining repr_bytes n <= 8 for all n is dubious *) (* let repr_bytes n = if n < 256 then 1 else if n < 65536 then 2 else if n < 16777216 then 3 else if n < 4294967296 then 4 else if n < 1099511627776 then 5 else if n < 281474976710656 then 6 else if n < 72057594037927936 then 7 else 8 *) (* NS: The two assumes below were previously defined as axioms. They are evil! They pollute the global environment and slow down verification enormously. I've made them assumed lemmas; if you want to make use of these axioms, call the lemmas as needed in the context. *) assume val lemma_repr_bytes_values: n:nat -> Lemma ( ( n < 256 <==> repr_bytes n = 1 ) /\ ( (n >= 256 /\ n < 65536) <==> repr_bytes n = 2 ) /\ ( (n >= 65536 /\ n < 16777216) <==> repr_bytes n = 3 ) /\ ( (n >= 16777216 /\ n < 4294967296) <==> repr_bytes n = 4 ) /\ ( (n >= 4294967296 /\ n < 1099511627776) <==> repr_bytes n = 5 ) /\ ( (n >= 1099511627776 /\ n < 281474976710656) <==> repr_bytes n = 6 ) /\ ( (n >= 281474976710656 /\ n < 72057594037927936) <==> repr_bytes n = 7 ) /\ ( (n >= 72057594037927936 /\ n < 18446744073709551616) <==> repr_bytes n = 8 ) ) unfold let byte:Type0 = FStar.UInt8.t type cbytes = string (* abstract *) type bytes = Seq.seq byte (* AR: adding this *) assume HasEq_bytes: hasEq bytes val seq_of_bytes: b:bytes -> GTot (Seq.seq byte) let seq_of_bytes b = b val op_At_Bar: bytes -> bytes -> Tot bytes let op_At_Bar (b1:bytes) (b2:bytes) = Seq.append b1 b2 (*@ function val B : (bytes -> byte array) @*) (*@ assume val length : (b:bytes -> (l:nat){Length (b) = l}) @*) val length : bytes -> Tot nat let length b = Seq.length b (*@ type (l:nat) lbytes = (b:bytes){Length (b) = l} @*) type lbytes (l:nat) = b:bytes{length b = l} (*@ val empty_bytes : (b:bytes){B (b) = C_array_of_list C_op_Nil ()} @*) val empty_bytes : lbytes 0 let empty_bytes = Seq.empty #byte (*@ assume val abytes : (b:cbytes -> (a:bytes){B (a) = b}) @*) assume val abytes : (cbytes -> Tot bytes) (*@ assume val abyte : (b:byte -> (a:bytes){B (a) = C_array_of_list C_op_ColonColon (b, C_op_Nil ())}) @*) val abyte : (FStar.UInt8.t -> Tot bytes) let abyte b = Seq.create 1 b val abyte2 : (FStar.UInt8.t * FStar.UInt8.t) -> Tot bytes let abyte2 (b1, b2) = Seq.append (Seq.create 1 b1) (Seq.create 1 b2) (*@ assume val get_cbytes : (a:bytes -> (b:cbytes){B (a) = b}) @*) assume val get_cbytes : (bytes -> Tot cbytes) val cbyte : b:bytes{Seq.length b > 0} -> Tot FStar.UInt8.t let cbyte b = Seq.index b 0 val cbyte2 : b:bytes{Seq.length b >= 2} -> Tot (FStar.UInt8.t * FStar.UInt8.t) let cbyte2 b = (Seq.index b 0, Seq.index b 1) val index : b:bytes -> i:nat{Seq.length b > i} -> Tot FStar.UInt8.t let index b i = Seq.index b i (*@ function assume val BLength : (cbytes -> int) @*) (*@ function assume val Length : (bytes -> int) @*) (*@ assume (!x. (!y. BLength (C_bop_ArrayAppend (x, y)) = C_bop_Addition (BLength (x), BLength (y)))) @*) (*@ assume (!x. Length (x) = BLength (B (x))) @*) (*@ assume val createBytes : (l:int -> ((v:int){C_pr_LessThanOrEqual(0, v) /\ C_pr_LessThan(v, 256)} -> (;l) lbytes)) @*) val createBytes : l:nat -> FStar.UInt8.t -> Tot (lbytes l) let createBytes l b = Seq.create l b // TODO: not implemented in ML val initBytes: l:nat -> (i:nat {i<l} -> Tot byte) -> Tot (lbytes l) let initBytes l f = Seq.init l f (*@ assume val equalBytes : (b0:bytes -> (b1:bytes -> (r:bool){r = True /\ B (b0) = B (b1) \/ r = False /\ B (b0) <> B (b1)})) @*) assume val equalBytes : b1:bytes -> b2:bytes -> Tot (b:bool{b = (b1=b2)}) (*@ assume val xor : (bytes -> (bytes -> (nb:nat -> (b3:bytes){Length (b3) = nb}))) @*) assume val xor: l:nat -> lbytes l -> lbytes l -> Tot (lbytes l) // consider making the length implicit val split: b:bytes -> n:nat{n <= Seq.length b} -> Tot (x:(bytes * bytes) {Seq.length (fst (x))= n /\ Seq.length (snd (x)) == (Seq.length b) - n }) //(lbytes n * lbytes (length b - n)) //val split: bytes -> nat -> Tot (bytes * bytes) let split b (n:nat { n <= Seq.length b}) = Seq.split b n val lemma_split : s:bytes -> i:nat{(0 <= i /\ i <= length s)} -> Lemma (ensures ((fst (split s i)) @| (snd (split s i)) = s)) let lemma_split s i = cut (Seq.equal ((fst (split s i)) @| (snd (split s i))) s) val split_eq: s:bytes -> i:nat{(0 <= i /\ i <= length s)} -> Pure (x:(bytes * bytes){length (fst x) = i && length (snd x) = length s - i}) (requires True)

{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.UInt8.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked" ], "interface_file": false, "source_file": "Platform.Bytes.fst" }

[ { "abbrev": false, "full_module": "Platform", "short_module": null }, { "abbrev": false, "full_module": "Platform", "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: Platform.Bytes.bytes -> i: Prims.nat{0 <= i /\ i <= Platform.Bytes.length s} -> Prims.Pure (x: (Platform.Bytes.bytes * Platform.Bytes.bytes) { Platform.Bytes.length (FStar.Pervasives.Native.fst x) = i && Platform.Bytes.length (FStar.Pervasives.Native.snd x) = Platform.Bytes.length s - i })

Prims.Pure

[]

[ "Platform.Bytes.bytes", "Prims.nat", "Prims.l_and", "Prims.b2t", "Prims.op_LessThanOrEqual", "Platform.Bytes.length", "Prims.unit", "Platform.Bytes.lemma_split", "FStar.Pervasives.Native.tuple2", "Prims.op_Equality", "FStar.Seq.Base.length", "FStar.UInt8.t", "FStar.Pervasives.Native.fst", "Prims.eq2", "Prims.int", "FStar.Pervasives.Native.snd", "Prims.op_Subtraction", "Platform.Bytes.split", "Prims.op_AmpAmp" ]

[]

false

let split_eq s i =

let x = split s i in lemma_split s i; x

false

Platform.Bytes.fst

Platform.Bytes.lemma_split

val lemma_split : s:bytes -> i:nat{(0 <= i /\ i <= length s)} -> Lemma (ensures ((fst (split s i)) @| (snd (split s i)) = s))

let lemma_split s i = cut (Seq.equal ((fst (split s i)) @| (snd (split s i))) s)

{ "file_name": "ucontrib/Platform/fst/Platform.Bytes.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }

{ "end_col": 61, "end_line": 134, "start_col": 0, "start_line": 133 }

(* Copyright 2008-2018 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 Platform.Bytes assume val repr_bytes : nat -> GTot (n:nat{n>0}) (* Integer literals are currently extracted to int32, rather than bigint, so the definition below breaks extraction: Unexpected error; please file a bug report, ideally with a minimized version of the source program that triggered the error. int_of_string Also, defining repr_bytes n <= 8 for all n is dubious *) (* let repr_bytes n = if n < 256 then 1 else if n < 65536 then 2 else if n < 16777216 then 3 else if n < 4294967296 then 4 else if n < 1099511627776 then 5 else if n < 281474976710656 then 6 else if n < 72057594037927936 then 7 else 8 *) (* NS: The two assumes below were previously defined as axioms. They are evil! They pollute the global environment and slow down verification enormously. I've made them assumed lemmas; if you want to make use of these axioms, call the lemmas as needed in the context. *) assume val lemma_repr_bytes_values: n:nat -> Lemma ( ( n < 256 <==> repr_bytes n = 1 ) /\ ( (n >= 256 /\ n < 65536) <==> repr_bytes n = 2 ) /\ ( (n >= 65536 /\ n < 16777216) <==> repr_bytes n = 3 ) /\ ( (n >= 16777216 /\ n < 4294967296) <==> repr_bytes n = 4 ) /\ ( (n >= 4294967296 /\ n < 1099511627776) <==> repr_bytes n = 5 ) /\ ( (n >= 1099511627776 /\ n < 281474976710656) <==> repr_bytes n = 6 ) /\ ( (n >= 281474976710656 /\ n < 72057594037927936) <==> repr_bytes n = 7 ) /\ ( (n >= 72057594037927936 /\ n < 18446744073709551616) <==> repr_bytes n = 8 ) ) unfold let byte:Type0 = FStar.UInt8.t type cbytes = string (* abstract *) type bytes = Seq.seq byte (* AR: adding this *) assume HasEq_bytes: hasEq bytes val seq_of_bytes: b:bytes -> GTot (Seq.seq byte) let seq_of_bytes b = b val op_At_Bar: bytes -> bytes -> Tot bytes let op_At_Bar (b1:bytes) (b2:bytes) = Seq.append b1 b2 (*@ function val B : (bytes -> byte array) @*) (*@ assume val length : (b:bytes -> (l:nat){Length (b) = l}) @*) val length : bytes -> Tot nat let length b = Seq.length b (*@ type (l:nat) lbytes = (b:bytes){Length (b) = l} @*) type lbytes (l:nat) = b:bytes{length b = l} (*@ val empty_bytes : (b:bytes){B (b) = C_array_of_list C_op_Nil ()} @*) val empty_bytes : lbytes 0 let empty_bytes = Seq.empty #byte (*@ assume val abytes : (b:cbytes -> (a:bytes){B (a) = b}) @*) assume val abytes : (cbytes -> Tot bytes) (*@ assume val abyte : (b:byte -> (a:bytes){B (a) = C_array_of_list C_op_ColonColon (b, C_op_Nil ())}) @*) val abyte : (FStar.UInt8.t -> Tot bytes) let abyte b = Seq.create 1 b val abyte2 : (FStar.UInt8.t * FStar.UInt8.t) -> Tot bytes let abyte2 (b1, b2) = Seq.append (Seq.create 1 b1) (Seq.create 1 b2) (*@ assume val get_cbytes : (a:bytes -> (b:cbytes){B (a) = b}) @*) assume val get_cbytes : (bytes -> Tot cbytes) val cbyte : b:bytes{Seq.length b > 0} -> Tot FStar.UInt8.t let cbyte b = Seq.index b 0 val cbyte2 : b:bytes{Seq.length b >= 2} -> Tot (FStar.UInt8.t * FStar.UInt8.t) let cbyte2 b = (Seq.index b 0, Seq.index b 1) val index : b:bytes -> i:nat{Seq.length b > i} -> Tot FStar.UInt8.t let index b i = Seq.index b i (*@ function assume val BLength : (cbytes -> int) @*) (*@ function assume val Length : (bytes -> int) @*) (*@ assume (!x. (!y. BLength (C_bop_ArrayAppend (x, y)) = C_bop_Addition (BLength (x), BLength (y)))) @*) (*@ assume (!x. Length (x) = BLength (B (x))) @*) (*@ assume val createBytes : (l:int -> ((v:int){C_pr_LessThanOrEqual(0, v) /\ C_pr_LessThan(v, 256)} -> (;l) lbytes)) @*) val createBytes : l:nat -> FStar.UInt8.t -> Tot (lbytes l) let createBytes l b = Seq.create l b // TODO: not implemented in ML val initBytes: l:nat -> (i:nat {i<l} -> Tot byte) -> Tot (lbytes l) let initBytes l f = Seq.init l f (*@ assume val equalBytes : (b0:bytes -> (b1:bytes -> (r:bool){r = True /\ B (b0) = B (b1) \/ r = False /\ B (b0) <> B (b1)})) @*) assume val equalBytes : b1:bytes -> b2:bytes -> Tot (b:bool{b = (b1=b2)}) (*@ assume val xor : (bytes -> (bytes -> (nb:nat -> (b3:bytes){Length (b3) = nb}))) @*) assume val xor: l:nat -> lbytes l -> lbytes l -> Tot (lbytes l) // consider making the length implicit val split: b:bytes -> n:nat{n <= Seq.length b} -> Tot (x:(bytes * bytes) {Seq.length (fst (x))= n /\ Seq.length (snd (x)) == (Seq.length b) - n }) //(lbytes n * lbytes (length b - n)) //val split: bytes -> nat -> Tot (bytes * bytes) let split b (n:nat { n <= Seq.length b}) = Seq.split b n val lemma_split : s:bytes -> i:nat{(0 <= i /\ i <= length s)} -> Lemma

{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.UInt8.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked" ], "interface_file": false, "source_file": "Platform.Bytes.fst" }

[ { "abbrev": false, "full_module": "Platform", "short_module": null }, { "abbrev": false, "full_module": "Platform", "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: Platform.Bytes.bytes -> i: Prims.nat{0 <= i /\ i <= Platform.Bytes.length s} -> FStar.Pervasives.Lemma (ensures FStar.Pervasives.Native.fst (Platform.Bytes.split s i) @| FStar.Pervasives.Native.snd (Platform.Bytes.split s i) = s)

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Platform.Bytes.bytes", "Prims.nat", "Prims.l_and", "Prims.b2t", "Prims.op_LessThanOrEqual", "Platform.Bytes.length", "Prims.cut", "FStar.Seq.Base.equal", "Platform.Bytes.byte", "Platform.Bytes.op_At_Bar", "FStar.Pervasives.Native.fst", "Platform.Bytes.split", "FStar.Pervasives.Native.snd", "Prims.unit" ]

[]

true

false

true

false

let lemma_split s i =

cut (Seq.equal ((fst (split s i)) @| (snd (split s i))) s)

false

IfcRecursiveReify.fst

IfcRecursiveReify.p2

val p2 (lo hi :id ): n:int -> ISNull unit (decreases n)

let rec p2 lo hi n = if n > 0 then (write hi (read hi + 1); p2 lo hi (n - 1))

{ "file_name": "examples/rel/IfcRecursiveReify.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }

{ "end_col": 21, "end_line": 60, "start_col": 1, "start_line": 57 }

(* Copyright 2008-2018 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 IfcRecursiveReify open FStar.DM4F.Heap.IntStoreFixed open FStar.DM4F.IntStoreFixed open Rel type label = | Low | High type env = id -> Tot label type low_equiv (env:env) (h : rel heap) = forall (x:id). {:pattern (Low? (env x))} (Low? (env x) ==> sel (R?.l h) x = sel (R?.r h) x) val p1 (lo hi :id ): n:int -> ISNull unit (decreases n) let rec p1 lo hi n = if n > 0 then (write hi (read hi -1); p1 lo hi (n-1)) let p1_r lo hi n h = (* normalize_term *) (snd (reify (p1 lo hi n) h)) val ni_p1 (lo hi : id) (n:int) (env:env) (h :rel heap) : Lemma (requires (lo <> hi /\ Low? (env lo) /\ High? (env hi) /\ low_equiv env h)) (ensures (low_equiv env (R (p1_r lo hi n (R?.l h)) (p1_r lo hi n (R?.r h))))) let rec ni_p1 lo hi n env h = if n > 0 then begin let R hl hr = h in let hl' = (upd hl hi (sel hl hi - 1)) in let hr' = (upd hr hi (sel hr hi - 1)) in ni_p1 lo hi (n-1) env (R hl' hr') end

{ "checked_file": "/", "dependencies": [ "Rel.fst.checked", "prims.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.DM4F.IntStoreFixed.fst.checked", "FStar.DM4F.Heap.IntStoreFixed.fsti.checked" ], "interface_file": false, "source_file": "IfcRecursiveReify.fst" }

[ { "abbrev": false, "full_module": "Rel", "short_module": null }, { "abbrev": false, "full_module": "FStar.DM4F.IntStoreFixed", "short_module": null }, { "abbrev": false, "full_module": "FStar.DM4F.Heap.IntStoreFixed", "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

lo: FStar.DM4F.Heap.IntStoreFixed.id -> hi: FStar.DM4F.Heap.IntStoreFixed.id -> n: Prims.int -> FStar.DM4F.IntStoreFixed.ISNull Prims.unit

FStar.DM4F.IntStoreFixed.ISNull

[ "" ]

[]

[ "FStar.DM4F.Heap.IntStoreFixed.id", "Prims.int", "Prims.op_GreaterThan", "IfcRecursiveReify.p2", "Prims.op_Subtraction", "Prims.unit", "FStar.DM4F.IntStoreFixed.write", "Prims.op_Addition", "FStar.DM4F.IntStoreFixed.read", "Prims.bool" ]

[ "recursion" ]

false

true

false

let rec p2 lo hi n =

if n > 0 then (write hi (read hi + 1); p2 lo hi (n - 1))

false

Platform.Bytes.fst

Platform.Bytes.append_empty_bytes_r

val append_empty_bytes_r (l: bytes) : Lemma (ensures (l @| empty_bytes == l))

let append_empty_bytes_r (l: bytes): Lemma (ensures (l @| empty_bytes == l)) = Seq.append_empty_r l

{ "file_name": "ucontrib/Platform/fst/Platform.Bytes.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }

{ "end_col": 22, "end_line": 154, "start_col": 0, "start_line": 153 }

(* Copyright 2008-2018 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 Platform.Bytes assume val repr_bytes : nat -> GTot (n:nat{n>0}) (* Integer literals are currently extracted to int32, rather than bigint, so the definition below breaks extraction: Unexpected error; please file a bug report, ideally with a minimized version of the source program that triggered the error. int_of_string Also, defining repr_bytes n <= 8 for all n is dubious *) (* let repr_bytes n = if n < 256 then 1 else if n < 65536 then 2 else if n < 16777216 then 3 else if n < 4294967296 then 4 else if n < 1099511627776 then 5 else if n < 281474976710656 then 6 else if n < 72057594037927936 then 7 else 8 *) (* NS: The two assumes below were previously defined as axioms. They are evil! They pollute the global environment and slow down verification enormously. I've made them assumed lemmas; if you want to make use of these axioms, call the lemmas as needed in the context. *) assume val lemma_repr_bytes_values: n:nat -> Lemma ( ( n < 256 <==> repr_bytes n = 1 ) /\ ( (n >= 256 /\ n < 65536) <==> repr_bytes n = 2 ) /\ ( (n >= 65536 /\ n < 16777216) <==> repr_bytes n = 3 ) /\ ( (n >= 16777216 /\ n < 4294967296) <==> repr_bytes n = 4 ) /\ ( (n >= 4294967296 /\ n < 1099511627776) <==> repr_bytes n = 5 ) /\ ( (n >= 1099511627776 /\ n < 281474976710656) <==> repr_bytes n = 6 ) /\ ( (n >= 281474976710656 /\ n < 72057594037927936) <==> repr_bytes n = 7 ) /\ ( (n >= 72057594037927936 /\ n < 18446744073709551616) <==> repr_bytes n = 8 ) ) unfold let byte:Type0 = FStar.UInt8.t type cbytes = string (* abstract *) type bytes = Seq.seq byte (* AR: adding this *) assume HasEq_bytes: hasEq bytes val seq_of_bytes: b:bytes -> GTot (Seq.seq byte) let seq_of_bytes b = b val op_At_Bar: bytes -> bytes -> Tot bytes let op_At_Bar (b1:bytes) (b2:bytes) = Seq.append b1 b2 (*@ function val B : (bytes -> byte array) @*) (*@ assume val length : (b:bytes -> (l:nat){Length (b) = l}) @*) val length : bytes -> Tot nat let length b = Seq.length b (*@ type (l:nat) lbytes = (b:bytes){Length (b) = l} @*) type lbytes (l:nat) = b:bytes{length b = l} (*@ val empty_bytes : (b:bytes){B (b) = C_array_of_list C_op_Nil ()} @*) val empty_bytes : lbytes 0 let empty_bytes = Seq.empty #byte (*@ assume val abytes : (b:cbytes -> (a:bytes){B (a) = b}) @*) assume val abytes : (cbytes -> Tot bytes) (*@ assume val abyte : (b:byte -> (a:bytes){B (a) = C_array_of_list C_op_ColonColon (b, C_op_Nil ())}) @*) val abyte : (FStar.UInt8.t -> Tot bytes) let abyte b = Seq.create 1 b val abyte2 : (FStar.UInt8.t * FStar.UInt8.t) -> Tot bytes let abyte2 (b1, b2) = Seq.append (Seq.create 1 b1) (Seq.create 1 b2) (*@ assume val get_cbytes : (a:bytes -> (b:cbytes){B (a) = b}) @*) assume val get_cbytes : (bytes -> Tot cbytes) val cbyte : b:bytes{Seq.length b > 0} -> Tot FStar.UInt8.t let cbyte b = Seq.index b 0 val cbyte2 : b:bytes{Seq.length b >= 2} -> Tot (FStar.UInt8.t * FStar.UInt8.t) let cbyte2 b = (Seq.index b 0, Seq.index b 1) val index : b:bytes -> i:nat{Seq.length b > i} -> Tot FStar.UInt8.t let index b i = Seq.index b i (*@ function assume val BLength : (cbytes -> int) @*) (*@ function assume val Length : (bytes -> int) @*) (*@ assume (!x. (!y. BLength (C_bop_ArrayAppend (x, y)) = C_bop_Addition (BLength (x), BLength (y)))) @*) (*@ assume (!x. Length (x) = BLength (B (x))) @*) (*@ assume val createBytes : (l:int -> ((v:int){C_pr_LessThanOrEqual(0, v) /\ C_pr_LessThan(v, 256)} -> (;l) lbytes)) @*) val createBytes : l:nat -> FStar.UInt8.t -> Tot (lbytes l) let createBytes l b = Seq.create l b // TODO: not implemented in ML val initBytes: l:nat -> (i:nat {i<l} -> Tot byte) -> Tot (lbytes l) let initBytes l f = Seq.init l f (*@ assume val equalBytes : (b0:bytes -> (b1:bytes -> (r:bool){r = True /\ B (b0) = B (b1) \/ r = False /\ B (b0) <> B (b1)})) @*) assume val equalBytes : b1:bytes -> b2:bytes -> Tot (b:bool{b = (b1=b2)}) (*@ assume val xor : (bytes -> (bytes -> (nb:nat -> (b3:bytes){Length (b3) = nb}))) @*) assume val xor: l:nat -> lbytes l -> lbytes l -> Tot (lbytes l) // consider making the length implicit val split: b:bytes -> n:nat{n <= Seq.length b} -> Tot (x:(bytes * bytes) {Seq.length (fst (x))= n /\ Seq.length (snd (x)) == (Seq.length b) - n }) //(lbytes n * lbytes (length b - n)) //val split: bytes -> nat -> Tot (bytes * bytes) let split b (n:nat { n <= Seq.length b}) = Seq.split b n val lemma_split : s:bytes -> i:nat{(0 <= i /\ i <= length s)} -> Lemma (ensures ((fst (split s i)) @| (snd (split s i)) = s)) let lemma_split s i = cut (Seq.equal ((fst (split s i)) @| (snd (split s i))) s) val split_eq: s:bytes -> i:nat{(0 <= i /\ i <= length s)} -> Pure (x:(bytes * bytes){length (fst x) = i && length (snd x) = length s - i}) (requires True) (ensures (fun x -> ((fst x) @| (snd x) = s))) let split_eq s i = let x = split s i in lemma_split s i; x val lemma_append_inj: s1:bytes -> s2:bytes -> t1:bytes -> t2:bytes {Seq.length s1 = Seq.length t1 \/ Seq.length s2 = Seq.length t2} -> Lemma (requires (Seq.equal (Seq.append s1 s2) (Seq.append t1 t2))) (ensures (Seq.equal s1 t1 /\ Seq.equal s2 t2)) let lemma_append_inj s1 s2 t1 t2 = admit() (* CH: this used to fail *) let append_empty_bytes_l (l: bytes): Lemma (ensures ((empty_bytes @| l) == l)) = Seq.append_empty_l l

{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.UInt8.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked" ], "interface_file": false, "source_file": "Platform.Bytes.fst" }

[ { "abbrev": false, "full_module": "Platform", "short_module": null }, { "abbrev": false, "full_module": "Platform", "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

l: Platform.Bytes.bytes -> FStar.Pervasives.Lemma (ensures l @| Platform.Bytes.empty_bytes == l)

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Platform.Bytes.bytes", "FStar.Seq.Base.append_empty_r", "Platform.Bytes.byte", "Prims.unit", "Prims.l_True", "Prims.squash", "Prims.eq2", "Platform.Bytes.op_At_Bar", "Platform.Bytes.empty_bytes", "Prims.Nil", "FStar.Pervasives.pattern" ]

[]

true

false

true

false

let append_empty_bytes_r (l: bytes) : Lemma (ensures (l @| empty_bytes == l)) =

Seq.append_empty_r l

false

Platform.Bytes.fst

Platform.Bytes.byte_of_int

val byte_of_int: n:nat{n < 256} -> Tot byte

let byte_of_int n = lemma_repr_bytes_values n; Seq.index (bytes_of_int 1 n) 0

{ "file_name": "ucontrib/Platform/fst/Platform.Bytes.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }

{ "end_col": 32, "end_line": 202, "start_col": 0, "start_line": 200 }

(* Copyright 2008-2018 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 Platform.Bytes assume val repr_bytes : nat -> GTot (n:nat{n>0}) (* Integer literals are currently extracted to int32, rather than bigint, so the definition below breaks extraction: Unexpected error; please file a bug report, ideally with a minimized version of the source program that triggered the error. int_of_string Also, defining repr_bytes n <= 8 for all n is dubious *) (* let repr_bytes n = if n < 256 then 1 else if n < 65536 then 2 else if n < 16777216 then 3 else if n < 4294967296 then 4 else if n < 1099511627776 then 5 else if n < 281474976710656 then 6 else if n < 72057594037927936 then 7 else 8 *) (* NS: The two assumes below were previously defined as axioms. They are evil! They pollute the global environment and slow down verification enormously. I've made them assumed lemmas; if you want to make use of these axioms, call the lemmas as needed in the context. *) assume val lemma_repr_bytes_values: n:nat -> Lemma ( ( n < 256 <==> repr_bytes n = 1 ) /\ ( (n >= 256 /\ n < 65536) <==> repr_bytes n = 2 ) /\ ( (n >= 65536 /\ n < 16777216) <==> repr_bytes n = 3 ) /\ ( (n >= 16777216 /\ n < 4294967296) <==> repr_bytes n = 4 ) /\ ( (n >= 4294967296 /\ n < 1099511627776) <==> repr_bytes n = 5 ) /\ ( (n >= 1099511627776 /\ n < 281474976710656) <==> repr_bytes n = 6 ) /\ ( (n >= 281474976710656 /\ n < 72057594037927936) <==> repr_bytes n = 7 ) /\ ( (n >= 72057594037927936 /\ n < 18446744073709551616) <==> repr_bytes n = 8 ) ) unfold let byte:Type0 = FStar.UInt8.t type cbytes = string (* abstract *) type bytes = Seq.seq byte (* AR: adding this *) assume HasEq_bytes: hasEq bytes val seq_of_bytes: b:bytes -> GTot (Seq.seq byte) let seq_of_bytes b = b val op_At_Bar: bytes -> bytes -> Tot bytes let op_At_Bar (b1:bytes) (b2:bytes) = Seq.append b1 b2 (*@ function val B : (bytes -> byte array) @*) (*@ assume val length : (b:bytes -> (l:nat){Length (b) = l}) @*) val length : bytes -> Tot nat let length b = Seq.length b (*@ type (l:nat) lbytes = (b:bytes){Length (b) = l} @*) type lbytes (l:nat) = b:bytes{length b = l} (*@ val empty_bytes : (b:bytes){B (b) = C_array_of_list C_op_Nil ()} @*) val empty_bytes : lbytes 0 let empty_bytes = Seq.empty #byte (*@ assume val abytes : (b:cbytes -> (a:bytes){B (a) = b}) @*) assume val abytes : (cbytes -> Tot bytes) (*@ assume val abyte : (b:byte -> (a:bytes){B (a) = C_array_of_list C_op_ColonColon (b, C_op_Nil ())}) @*) val abyte : (FStar.UInt8.t -> Tot bytes) let abyte b = Seq.create 1 b val abyte2 : (FStar.UInt8.t * FStar.UInt8.t) -> Tot bytes let abyte2 (b1, b2) = Seq.append (Seq.create 1 b1) (Seq.create 1 b2) (*@ assume val get_cbytes : (a:bytes -> (b:cbytes){B (a) = b}) @*) assume val get_cbytes : (bytes -> Tot cbytes) val cbyte : b:bytes{Seq.length b > 0} -> Tot FStar.UInt8.t let cbyte b = Seq.index b 0 val cbyte2 : b:bytes{Seq.length b >= 2} -> Tot (FStar.UInt8.t * FStar.UInt8.t) let cbyte2 b = (Seq.index b 0, Seq.index b 1) val index : b:bytes -> i:nat{Seq.length b > i} -> Tot FStar.UInt8.t let index b i = Seq.index b i (*@ function assume val BLength : (cbytes -> int) @*) (*@ function assume val Length : (bytes -> int) @*) (*@ assume (!x. (!y. BLength (C_bop_ArrayAppend (x, y)) = C_bop_Addition (BLength (x), BLength (y)))) @*) (*@ assume (!x. Length (x) = BLength (B (x))) @*) (*@ assume val createBytes : (l:int -> ((v:int){C_pr_LessThanOrEqual(0, v) /\ C_pr_LessThan(v, 256)} -> (;l) lbytes)) @*) val createBytes : l:nat -> FStar.UInt8.t -> Tot (lbytes l) let createBytes l b = Seq.create l b // TODO: not implemented in ML val initBytes: l:nat -> (i:nat {i<l} -> Tot byte) -> Tot (lbytes l) let initBytes l f = Seq.init l f (*@ assume val equalBytes : (b0:bytes -> (b1:bytes -> (r:bool){r = True /\ B (b0) = B (b1) \/ r = False /\ B (b0) <> B (b1)})) @*) assume val equalBytes : b1:bytes -> b2:bytes -> Tot (b:bool{b = (b1=b2)}) (*@ assume val xor : (bytes -> (bytes -> (nb:nat -> (b3:bytes){Length (b3) = nb}))) @*) assume val xor: l:nat -> lbytes l -> lbytes l -> Tot (lbytes l) // consider making the length implicit val split: b:bytes -> n:nat{n <= Seq.length b} -> Tot (x:(bytes * bytes) {Seq.length (fst (x))= n /\ Seq.length (snd (x)) == (Seq.length b) - n }) //(lbytes n * lbytes (length b - n)) //val split: bytes -> nat -> Tot (bytes * bytes) let split b (n:nat { n <= Seq.length b}) = Seq.split b n val lemma_split : s:bytes -> i:nat{(0 <= i /\ i <= length s)} -> Lemma (ensures ((fst (split s i)) @| (snd (split s i)) = s)) let lemma_split s i = cut (Seq.equal ((fst (split s i)) @| (snd (split s i))) s) val split_eq: s:bytes -> i:nat{(0 <= i /\ i <= length s)} -> Pure (x:(bytes * bytes){length (fst x) = i && length (snd x) = length s - i}) (requires True) (ensures (fun x -> ((fst x) @| (snd x) = s))) let split_eq s i = let x = split s i in lemma_split s i; x val lemma_append_inj: s1:bytes -> s2:bytes -> t1:bytes -> t2:bytes {Seq.length s1 = Seq.length t1 \/ Seq.length s2 = Seq.length t2} -> Lemma (requires (Seq.equal (Seq.append s1 s2) (Seq.append t1 t2))) (ensures (Seq.equal s1 t1 /\ Seq.equal s2 t2)) let lemma_append_inj s1 s2 t1 t2 = admit() (* CH: this used to fail *) let append_empty_bytes_l (l: bytes): Lemma (ensures ((empty_bytes @| l) == l)) = Seq.append_empty_l l let append_empty_bytes_r (l: bytes): Lemma (ensures (l @| empty_bytes == l)) = Seq.append_empty_r l let append_assoc (l1 l2 l3: bytes): Lemma (ensures ((l1 @| l2) @| l3 == l1 @| (l2 @| l3))) = Seq.append_assoc l1 l2 l3 (*@ assume val split2 : (b:bytes -> (i:nat -> ((j:nat){C_pr_GreaterThanOrEqual(Length (b), C_bop_Addition (i, j))} -> (b1:bytes * b2:bytes * b3:bytes){Length (b1) = i /\ Length (b2) = j /\ B (b) = C_bop_ArrayAppend (B (b1), C_bop_ArrayAppend (B (b2), B (b3)))}))) @*) assume val split2 : b:bytes -> n1:nat{n1 <= Seq.length b} -> n2:nat{n1 + n2 <= Seq.length b} -> Tot (lbytes n1 * lbytes n2 * lbytes (length b - n1 - n2)) (*@ assume (!x. C_bop_ArrayAppend (x, C_array_of_list C_op_Nil ()) = x) @*) (*@ assume (!b1. (!b2. (!c1. (!c2. C_bop_ArrayAppend (b1, b2) = C_bop_ArrayAppend (c1, c2) /\ BLength (b1) = BLength (c1) => b1 = c1 /\ b2 = c2)))) @*) (*@ assume (!b1. (!b2. (!c1. (!c2. C_bop_ArrayAppend (b1, b2) = C_bop_ArrayAppend (c1, c2) /\ BLength (b2) = BLength (c2) => b1 = c1 /\ b2 = c2)))) @*) (*@ assume (!b1. (!b2. (!b3. C_bop_ArrayAppend (C_bop_ArrayAppend (b1, b2), b3) = C_bop_ArrayAppend (b1, C_bop_ArrayAppend (b2, b3))))) @*) (*@ function assume val IntBytes : ((int * int) -> bytes) @*) assume val bytes_of_int : l:nat -> n:nat{repr_bytes n <= l} -> Tot (lbytes l) assume val int_of_bytes : b:bytes -> Tot (n:nat{repr_bytes n <= Seq.length b /\ (Seq.length b = 1 ==> n < 256) /\ b=bytes_of_int (Seq.length b) n}) assume val int_of_bytes_of_int : l:nat -> n:nat{repr_bytes n <= l} -> Lemma (n = int_of_bytes (bytes_of_int l n)) (*@ assume val int_of_bytes : ((b:bytes){C_pr_LessThanOrEqual(Length (b), 8)} -> (i:nat){b = IntBytes (Length (b), i) /\ Length (b) = 1 => C_pr_LessThanOrEqual(0, i) /\ C_pr_LessThan(i, 256)}) @*) (*@ assume (!l. (!i. Length (IntBytes (l, i)) = l)) @*) (*@ assume (!l. (!i0. (!i1. IntBytes (l, i0) = IntBytes (l, i1) => i0 = i1))) @*) (*@ function assume val Utf8 : (string -> bytes) @*) (*@ assume val utf8 : (s:string -> (b:bytes){b = Utf8 (s)}) @*) assume val utf8 : string -> Tot bytes (*@ assume val iutf8 : (b:bytes -> (s:string){b = Utf8 (s)}) @*) assume val iutf8_opt : m:bytes -> Tot (option (s:string{utf8 s = m})) assume val iutf8 : m:bytes -> s:string{utf8 s = m} (*@ assume (!x. (!y. Utf8 (x) = Utf8 (y) => x = y)) @*) // Pretty printing of bytes for debugging assume val print_bytes: bytes -> Tot string

{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.UInt8.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked" ], "interface_file": false, "source_file": "Platform.Bytes.fst" }

[ { "abbrev": false, "full_module": "Platform", "short_module": null }, { "abbrev": false, "full_module": "Platform", "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

n: Prims.nat{n < 256} -> Platform.Bytes.byte

Prims.Tot

[ "total" ]

[]

[ "Prims.nat", "Prims.b2t", "Prims.op_LessThan", "FStar.Seq.Base.index", "Platform.Bytes.byte", "Platform.Bytes.bytes_of_int", "Prims.unit", "Platform.Bytes.lemma_repr_bytes_values" ]

[]

false

let byte_of_int n =

lemma_repr_bytes_values n; Seq.index (bytes_of_int 1 n) 0

false

Platform.Bytes.fst

Platform.Bytes.append_empty_bytes_l

val append_empty_bytes_l (l: bytes) : Lemma (ensures ((empty_bytes @| l) == l))

let append_empty_bytes_l (l: bytes): Lemma (ensures ((empty_bytes @| l) == l)) = Seq.append_empty_l l

{ "file_name": "ucontrib/Platform/fst/Platform.Bytes.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }

{ "end_col": 22, "end_line": 151, "start_col": 0, "start_line": 150 }

(* Copyright 2008-2018 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 Platform.Bytes assume val repr_bytes : nat -> GTot (n:nat{n>0}) (* Integer literals are currently extracted to int32, rather than bigint, so the definition below breaks extraction: Unexpected error; please file a bug report, ideally with a minimized version of the source program that triggered the error. int_of_string Also, defining repr_bytes n <= 8 for all n is dubious *) (* let repr_bytes n = if n < 256 then 1 else if n < 65536 then 2 else if n < 16777216 then 3 else if n < 4294967296 then 4 else if n < 1099511627776 then 5 else if n < 281474976710656 then 6 else if n < 72057594037927936 then 7 else 8 *) (* NS: The two assumes below were previously defined as axioms. They are evil! They pollute the global environment and slow down verification enormously. I've made them assumed lemmas; if you want to make use of these axioms, call the lemmas as needed in the context. *) assume val lemma_repr_bytes_values: n:nat -> Lemma ( ( n < 256 <==> repr_bytes n = 1 ) /\ ( (n >= 256 /\ n < 65536) <==> repr_bytes n = 2 ) /\ ( (n >= 65536 /\ n < 16777216) <==> repr_bytes n = 3 ) /\ ( (n >= 16777216 /\ n < 4294967296) <==> repr_bytes n = 4 ) /\ ( (n >= 4294967296 /\ n < 1099511627776) <==> repr_bytes n = 5 ) /\ ( (n >= 1099511627776 /\ n < 281474976710656) <==> repr_bytes n = 6 ) /\ ( (n >= 281474976710656 /\ n < 72057594037927936) <==> repr_bytes n = 7 ) /\ ( (n >= 72057594037927936 /\ n < 18446744073709551616) <==> repr_bytes n = 8 ) ) unfold let byte:Type0 = FStar.UInt8.t type cbytes = string (* abstract *) type bytes = Seq.seq byte (* AR: adding this *) assume HasEq_bytes: hasEq bytes val seq_of_bytes: b:bytes -> GTot (Seq.seq byte) let seq_of_bytes b = b val op_At_Bar: bytes -> bytes -> Tot bytes let op_At_Bar (b1:bytes) (b2:bytes) = Seq.append b1 b2 (*@ function val B : (bytes -> byte array) @*) (*@ assume val length : (b:bytes -> (l:nat){Length (b) = l}) @*) val length : bytes -> Tot nat let length b = Seq.length b (*@ type (l:nat) lbytes = (b:bytes){Length (b) = l} @*) type lbytes (l:nat) = b:bytes{length b = l} (*@ val empty_bytes : (b:bytes){B (b) = C_array_of_list C_op_Nil ()} @*) val empty_bytes : lbytes 0 let empty_bytes = Seq.empty #byte (*@ assume val abytes : (b:cbytes -> (a:bytes){B (a) = b}) @*) assume val abytes : (cbytes -> Tot bytes) (*@ assume val abyte : (b:byte -> (a:bytes){B (a) = C_array_of_list C_op_ColonColon (b, C_op_Nil ())}) @*) val abyte : (FStar.UInt8.t -> Tot bytes) let abyte b = Seq.create 1 b val abyte2 : (FStar.UInt8.t * FStar.UInt8.t) -> Tot bytes let abyte2 (b1, b2) = Seq.append (Seq.create 1 b1) (Seq.create 1 b2) (*@ assume val get_cbytes : (a:bytes -> (b:cbytes){B (a) = b}) @*) assume val get_cbytes : (bytes -> Tot cbytes) val cbyte : b:bytes{Seq.length b > 0} -> Tot FStar.UInt8.t let cbyte b = Seq.index b 0 val cbyte2 : b:bytes{Seq.length b >= 2} -> Tot (FStar.UInt8.t * FStar.UInt8.t) let cbyte2 b = (Seq.index b 0, Seq.index b 1) val index : b:bytes -> i:nat{Seq.length b > i} -> Tot FStar.UInt8.t let index b i = Seq.index b i (*@ function assume val BLength : (cbytes -> int) @*) (*@ function assume val Length : (bytes -> int) @*) (*@ assume (!x. (!y. BLength (C_bop_ArrayAppend (x, y)) = C_bop_Addition (BLength (x), BLength (y)))) @*) (*@ assume (!x. Length (x) = BLength (B (x))) @*) (*@ assume val createBytes : (l:int -> ((v:int){C_pr_LessThanOrEqual(0, v) /\ C_pr_LessThan(v, 256)} -> (;l) lbytes)) @*) val createBytes : l:nat -> FStar.UInt8.t -> Tot (lbytes l) let createBytes l b = Seq.create l b // TODO: not implemented in ML val initBytes: l:nat -> (i:nat {i<l} -> Tot byte) -> Tot (lbytes l) let initBytes l f = Seq.init l f (*@ assume val equalBytes : (b0:bytes -> (b1:bytes -> (r:bool){r = True /\ B (b0) = B (b1) \/ r = False /\ B (b0) <> B (b1)})) @*) assume val equalBytes : b1:bytes -> b2:bytes -> Tot (b:bool{b = (b1=b2)}) (*@ assume val xor : (bytes -> (bytes -> (nb:nat -> (b3:bytes){Length (b3) = nb}))) @*) assume val xor: l:nat -> lbytes l -> lbytes l -> Tot (lbytes l) // consider making the length implicit val split: b:bytes -> n:nat{n <= Seq.length b} -> Tot (x:(bytes * bytes) {Seq.length (fst (x))= n /\ Seq.length (snd (x)) == (Seq.length b) - n }) //(lbytes n * lbytes (length b - n)) //val split: bytes -> nat -> Tot (bytes * bytes) let split b (n:nat { n <= Seq.length b}) = Seq.split b n val lemma_split : s:bytes -> i:nat{(0 <= i /\ i <= length s)} -> Lemma (ensures ((fst (split s i)) @| (snd (split s i)) = s)) let lemma_split s i = cut (Seq.equal ((fst (split s i)) @| (snd (split s i))) s) val split_eq: s:bytes -> i:nat{(0 <= i /\ i <= length s)} -> Pure (x:(bytes * bytes){length (fst x) = i && length (snd x) = length s - i}) (requires True) (ensures (fun x -> ((fst x) @| (snd x) = s))) let split_eq s i = let x = split s i in lemma_split s i; x val lemma_append_inj: s1:bytes -> s2:bytes -> t1:bytes -> t2:bytes {Seq.length s1 = Seq.length t1 \/ Seq.length s2 = Seq.length t2} -> Lemma (requires (Seq.equal (Seq.append s1 s2) (Seq.append t1 t2))) (ensures (Seq.equal s1 t1 /\ Seq.equal s2 t2)) let lemma_append_inj s1 s2 t1 t2 = admit() (* CH: this used to fail *)

{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.UInt8.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked" ], "interface_file": false, "source_file": "Platform.Bytes.fst" }

[ { "abbrev": false, "full_module": "Platform", "short_module": null }, { "abbrev": false, "full_module": "Platform", "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

l: Platform.Bytes.bytes -> FStar.Pervasives.Lemma (ensures Platform.Bytes.empty_bytes @| l == l)

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Platform.Bytes.bytes", "FStar.Seq.Base.append_empty_l", "Platform.Bytes.byte", "Prims.unit", "Prims.l_True", "Prims.squash", "Prims.eq2", "Platform.Bytes.op_At_Bar", "Platform.Bytes.empty_bytes", "Prims.Nil", "FStar.Pervasives.pattern" ]

[]

true

false

true

false

let append_empty_bytes_l (l: bytes) : Lemma (ensures ((empty_bytes @| l) == l)) =

Seq.append_empty_l l

false

Platform.Bytes.fst

Platform.Bytes.append_assoc

val append_assoc (l1 l2 l3: bytes) : Lemma (ensures ((l1 @| l2) @| l3 == l1 @| (l2 @| l3)))

let append_assoc (l1 l2 l3: bytes): Lemma (ensures ((l1 @| l2) @| l3 == l1 @| (l2 @| l3))) = Seq.append_assoc l1 l2 l3

{ "file_name": "ucontrib/Platform/fst/Platform.Bytes.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }

{ "end_col": 27, "end_line": 158, "start_col": 0, "start_line": 156 }

(* Copyright 2008-2018 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 Platform.Bytes assume val repr_bytes : nat -> GTot (n:nat{n>0}) (* Integer literals are currently extracted to int32, rather than bigint, so the definition below breaks extraction: Unexpected error; please file a bug report, ideally with a minimized version of the source program that triggered the error. int_of_string Also, defining repr_bytes n <= 8 for all n is dubious *) (* let repr_bytes n = if n < 256 then 1 else if n < 65536 then 2 else if n < 16777216 then 3 else if n < 4294967296 then 4 else if n < 1099511627776 then 5 else if n < 281474976710656 then 6 else if n < 72057594037927936 then 7 else 8 *) (* NS: The two assumes below were previously defined as axioms. They are evil! They pollute the global environment and slow down verification enormously. I've made them assumed lemmas; if you want to make use of these axioms, call the lemmas as needed in the context. *) assume val lemma_repr_bytes_values: n:nat -> Lemma ( ( n < 256 <==> repr_bytes n = 1 ) /\ ( (n >= 256 /\ n < 65536) <==> repr_bytes n = 2 ) /\ ( (n >= 65536 /\ n < 16777216) <==> repr_bytes n = 3 ) /\ ( (n >= 16777216 /\ n < 4294967296) <==> repr_bytes n = 4 ) /\ ( (n >= 4294967296 /\ n < 1099511627776) <==> repr_bytes n = 5 ) /\ ( (n >= 1099511627776 /\ n < 281474976710656) <==> repr_bytes n = 6 ) /\ ( (n >= 281474976710656 /\ n < 72057594037927936) <==> repr_bytes n = 7 ) /\ ( (n >= 72057594037927936 /\ n < 18446744073709551616) <==> repr_bytes n = 8 ) ) unfold let byte:Type0 = FStar.UInt8.t type cbytes = string (* abstract *) type bytes = Seq.seq byte (* AR: adding this *) assume HasEq_bytes: hasEq bytes val seq_of_bytes: b:bytes -> GTot (Seq.seq byte) let seq_of_bytes b = b val op_At_Bar: bytes -> bytes -> Tot bytes let op_At_Bar (b1:bytes) (b2:bytes) = Seq.append b1 b2 (*@ function val B : (bytes -> byte array) @*) (*@ assume val length : (b:bytes -> (l:nat){Length (b) = l}) @*) val length : bytes -> Tot nat let length b = Seq.length b (*@ type (l:nat) lbytes = (b:bytes){Length (b) = l} @*) type lbytes (l:nat) = b:bytes{length b = l} (*@ val empty_bytes : (b:bytes){B (b) = C_array_of_list C_op_Nil ()} @*) val empty_bytes : lbytes 0 let empty_bytes = Seq.empty #byte (*@ assume val abytes : (b:cbytes -> (a:bytes){B (a) = b}) @*) assume val abytes : (cbytes -> Tot bytes) (*@ assume val abyte : (b:byte -> (a:bytes){B (a) = C_array_of_list C_op_ColonColon (b, C_op_Nil ())}) @*) val abyte : (FStar.UInt8.t -> Tot bytes) let abyte b = Seq.create 1 b val abyte2 : (FStar.UInt8.t * FStar.UInt8.t) -> Tot bytes let abyte2 (b1, b2) = Seq.append (Seq.create 1 b1) (Seq.create 1 b2) (*@ assume val get_cbytes : (a:bytes -> (b:cbytes){B (a) = b}) @*) assume val get_cbytes : (bytes -> Tot cbytes) val cbyte : b:bytes{Seq.length b > 0} -> Tot FStar.UInt8.t let cbyte b = Seq.index b 0 val cbyte2 : b:bytes{Seq.length b >= 2} -> Tot (FStar.UInt8.t * FStar.UInt8.t) let cbyte2 b = (Seq.index b 0, Seq.index b 1) val index : b:bytes -> i:nat{Seq.length b > i} -> Tot FStar.UInt8.t let index b i = Seq.index b i (*@ function assume val BLength : (cbytes -> int) @*) (*@ function assume val Length : (bytes -> int) @*) (*@ assume (!x. (!y. BLength (C_bop_ArrayAppend (x, y)) = C_bop_Addition (BLength (x), BLength (y)))) @*) (*@ assume (!x. Length (x) = BLength (B (x))) @*) (*@ assume val createBytes : (l:int -> ((v:int){C_pr_LessThanOrEqual(0, v) /\ C_pr_LessThan(v, 256)} -> (;l) lbytes)) @*) val createBytes : l:nat -> FStar.UInt8.t -> Tot (lbytes l) let createBytes l b = Seq.create l b // TODO: not implemented in ML val initBytes: l:nat -> (i:nat {i<l} -> Tot byte) -> Tot (lbytes l) let initBytes l f = Seq.init l f (*@ assume val equalBytes : (b0:bytes -> (b1:bytes -> (r:bool){r = True /\ B (b0) = B (b1) \/ r = False /\ B (b0) <> B (b1)})) @*) assume val equalBytes : b1:bytes -> b2:bytes -> Tot (b:bool{b = (b1=b2)}) (*@ assume val xor : (bytes -> (bytes -> (nb:nat -> (b3:bytes){Length (b3) = nb}))) @*) assume val xor: l:nat -> lbytes l -> lbytes l -> Tot (lbytes l) // consider making the length implicit val split: b:bytes -> n:nat{n <= Seq.length b} -> Tot (x:(bytes * bytes) {Seq.length (fst (x))= n /\ Seq.length (snd (x)) == (Seq.length b) - n }) //(lbytes n * lbytes (length b - n)) //val split: bytes -> nat -> Tot (bytes * bytes) let split b (n:nat { n <= Seq.length b}) = Seq.split b n val lemma_split : s:bytes -> i:nat{(0 <= i /\ i <= length s)} -> Lemma (ensures ((fst (split s i)) @| (snd (split s i)) = s)) let lemma_split s i = cut (Seq.equal ((fst (split s i)) @| (snd (split s i))) s) val split_eq: s:bytes -> i:nat{(0 <= i /\ i <= length s)} -> Pure (x:(bytes * bytes){length (fst x) = i && length (snd x) = length s - i}) (requires True) (ensures (fun x -> ((fst x) @| (snd x) = s))) let split_eq s i = let x = split s i in lemma_split s i; x val lemma_append_inj: s1:bytes -> s2:bytes -> t1:bytes -> t2:bytes {Seq.length s1 = Seq.length t1 \/ Seq.length s2 = Seq.length t2} -> Lemma (requires (Seq.equal (Seq.append s1 s2) (Seq.append t1 t2))) (ensures (Seq.equal s1 t1 /\ Seq.equal s2 t2)) let lemma_append_inj s1 s2 t1 t2 = admit() (* CH: this used to fail *) let append_empty_bytes_l (l: bytes): Lemma (ensures ((empty_bytes @| l) == l)) = Seq.append_empty_l l let append_empty_bytes_r (l: bytes): Lemma (ensures (l @| empty_bytes == l)) = Seq.append_empty_r l

{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.UInt8.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked" ], "interface_file": false, "source_file": "Platform.Bytes.fst" }

[ { "abbrev": false, "full_module": "Platform", "short_module": null }, { "abbrev": false, "full_module": "Platform", "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

l1: Platform.Bytes.bytes -> l2: Platform.Bytes.bytes -> l3: Platform.Bytes.bytes -> FStar.Pervasives.Lemma (ensures (l1 @| l2) @| l3 == l1 @| l2 @| l3)

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Platform.Bytes.bytes", "FStar.Seq.Base.append_assoc", "Platform.Bytes.byte", "Prims.unit", "Prims.l_True", "Prims.squash", "Prims.eq2", "Platform.Bytes.op_At_Bar", "Prims.Nil", "FStar.Pervasives.pattern" ]

[]

true

false

true

false

let append_assoc (l1 l2 l3: bytes) : Lemma (ensures ((l1 @| l2) @| l3 == l1 @| (l2 @| l3))) =

Seq.append_assoc l1 l2 l3

false

IfcRecursiveReify.fst

IfcRecursiveReify.ni_p1

val ni_p1 (lo hi : id) (n:int) (env:env) (h :rel heap) : Lemma (requires (lo <> hi /\ Low? (env lo) /\ High? (env hi) /\ low_equiv env h)) (ensures (low_equiv env (R (p1_r lo hi n (R?.l h)) (p1_r lo hi n (R?.r h)))))

let rec ni_p1 lo hi n env h = if n > 0 then begin let R hl hr = h in let hl' = (upd hl hi (sel hl hi - 1)) in let hr' = (upd hr hi (sel hr hi - 1)) in ni_p1 lo hi (n-1) env (R hl' hr') end

{ "file_name": "examples/rel/IfcRecursiveReify.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }

{ "end_col": 5, "end_line": 53, "start_col": 0, "start_line": 46 }

(* Copyright 2008-2018 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 IfcRecursiveReify open FStar.DM4F.Heap.IntStoreFixed open FStar.DM4F.IntStoreFixed open Rel type label = | Low | High type env = id -> Tot label type low_equiv (env:env) (h : rel heap) = forall (x:id). {:pattern (Low? (env x))} (Low? (env x) ==> sel (R?.l h) x = sel (R?.r h) x) val p1 (lo hi :id ): n:int -> ISNull unit (decreases n) let rec p1 lo hi n = if n > 0 then (write hi (read hi -1); p1 lo hi (n-1)) let p1_r lo hi n h = (* normalize_term *) (snd (reify (p1 lo hi n) h)) val ni_p1 (lo hi : id) (n:int) (env:env) (h :rel heap) : Lemma (requires (lo <> hi /\ Low? (env lo) /\ High? (env hi) /\ low_equiv env h))

{ "checked_file": "/", "dependencies": [ "Rel.fst.checked", "prims.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.DM4F.IntStoreFixed.fst.checked", "FStar.DM4F.Heap.IntStoreFixed.fsti.checked" ], "interface_file": false, "source_file": "IfcRecursiveReify.fst" }

[ { "abbrev": false, "full_module": "Rel", "short_module": null }, { "abbrev": false, "full_module": "FStar.DM4F.IntStoreFixed", "short_module": null }, { "abbrev": false, "full_module": "FStar.DM4F.Heap.IntStoreFixed", "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

lo: FStar.DM4F.Heap.IntStoreFixed.id -> hi: FStar.DM4F.Heap.IntStoreFixed.id -> n: Prims.int -> env: IfcRecursiveReify.env -> h: Rel.rel FStar.DM4F.Heap.IntStoreFixed.heap -> FStar.Pervasives.Lemma (requires lo <> hi /\ Low? (env lo) /\ High? (env hi) /\ IfcRecursiveReify.low_equiv env h) (ensures IfcRecursiveReify.low_equiv env (Rel.R (IfcRecursiveReify.p1_r lo hi n (R?.l h)) (IfcRecursiveReify.p1_r lo hi n (R?.r h)) ))

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "FStar.DM4F.Heap.IntStoreFixed.id", "Prims.int", "IfcRecursiveReify.env", "Rel.rel", "FStar.DM4F.Heap.IntStoreFixed.heap", "Prims.op_GreaterThan", "IfcRecursiveReify.ni_p1", "Prims.op_Subtraction", "Rel.R", "FStar.DM4F.Heap.IntStoreFixed.upd", "FStar.DM4F.Heap.IntStoreFixed.sel", "Prims.unit", "Prims.bool" ]

[ "recursion" ]

false

true

false

let rec ni_p1 lo hi n env h =

if n > 0 then let R hl hr = h in let hl' = (upd hl hi (sel hl hi - 1)) in let hr' = (upd hr hi (sel hr hi - 1)) in ni_p1 lo hi (n - 1) env (R hl' hr')

false

Platform.Bytes.fst

Platform.Bytes.initBytes

val initBytes: l:nat -> (i:nat {i<l} -> Tot byte) -> Tot (lbytes l)

let initBytes l f = Seq.init l f

{ "file_name": "ucontrib/Platform/fst/Platform.Bytes.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }

{ "end_col": 32, "end_line": 116, "start_col": 0, "start_line": 116 }

(* Copyright 2008-2018 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 Platform.Bytes assume val repr_bytes : nat -> GTot (n:nat{n>0}) (* Integer literals are currently extracted to int32, rather than bigint, so the definition below breaks extraction: Unexpected error; please file a bug report, ideally with a minimized version of the source program that triggered the error. int_of_string Also, defining repr_bytes n <= 8 for all n is dubious *) (* let repr_bytes n = if n < 256 then 1 else if n < 65536 then 2 else if n < 16777216 then 3 else if n < 4294967296 then 4 else if n < 1099511627776 then 5 else if n < 281474976710656 then 6 else if n < 72057594037927936 then 7 else 8 *) (* NS: The two assumes below were previously defined as axioms. They are evil! They pollute the global environment and slow down verification enormously. I've made them assumed lemmas; if you want to make use of these axioms, call the lemmas as needed in the context. *) assume val lemma_repr_bytes_values: n:nat -> Lemma ( ( n < 256 <==> repr_bytes n = 1 ) /\ ( (n >= 256 /\ n < 65536) <==> repr_bytes n = 2 ) /\ ( (n >= 65536 /\ n < 16777216) <==> repr_bytes n = 3 ) /\ ( (n >= 16777216 /\ n < 4294967296) <==> repr_bytes n = 4 ) /\ ( (n >= 4294967296 /\ n < 1099511627776) <==> repr_bytes n = 5 ) /\ ( (n >= 1099511627776 /\ n < 281474976710656) <==> repr_bytes n = 6 ) /\ ( (n >= 281474976710656 /\ n < 72057594037927936) <==> repr_bytes n = 7 ) /\ ( (n >= 72057594037927936 /\ n < 18446744073709551616) <==> repr_bytes n = 8 ) ) unfold let byte:Type0 = FStar.UInt8.t type cbytes = string (* abstract *) type bytes = Seq.seq byte (* AR: adding this *) assume HasEq_bytes: hasEq bytes val seq_of_bytes: b:bytes -> GTot (Seq.seq byte) let seq_of_bytes b = b val op_At_Bar: bytes -> bytes -> Tot bytes let op_At_Bar (b1:bytes) (b2:bytes) = Seq.append b1 b2 (*@ function val B : (bytes -> byte array) @*) (*@ assume val length : (b:bytes -> (l:nat){Length (b) = l}) @*) val length : bytes -> Tot nat let length b = Seq.length b (*@ type (l:nat) lbytes = (b:bytes){Length (b) = l} @*) type lbytes (l:nat) = b:bytes{length b = l} (*@ val empty_bytes : (b:bytes){B (b) = C_array_of_list C_op_Nil ()} @*) val empty_bytes : lbytes 0 let empty_bytes = Seq.empty #byte (*@ assume val abytes : (b:cbytes -> (a:bytes){B (a) = b}) @*) assume val abytes : (cbytes -> Tot bytes) (*@ assume val abyte : (b:byte -> (a:bytes){B (a) = C_array_of_list C_op_ColonColon (b, C_op_Nil ())}) @*) val abyte : (FStar.UInt8.t -> Tot bytes) let abyte b = Seq.create 1 b val abyte2 : (FStar.UInt8.t * FStar.UInt8.t) -> Tot bytes let abyte2 (b1, b2) = Seq.append (Seq.create 1 b1) (Seq.create 1 b2) (*@ assume val get_cbytes : (a:bytes -> (b:cbytes){B (a) = b}) @*) assume val get_cbytes : (bytes -> Tot cbytes) val cbyte : b:bytes{Seq.length b > 0} -> Tot FStar.UInt8.t let cbyte b = Seq.index b 0 val cbyte2 : b:bytes{Seq.length b >= 2} -> Tot (FStar.UInt8.t * FStar.UInt8.t) let cbyte2 b = (Seq.index b 0, Seq.index b 1) val index : b:bytes -> i:nat{Seq.length b > i} -> Tot FStar.UInt8.t let index b i = Seq.index b i (*@ function assume val BLength : (cbytes -> int) @*) (*@ function assume val Length : (bytes -> int) @*) (*@ assume (!x. (!y. BLength (C_bop_ArrayAppend (x, y)) = C_bop_Addition (BLength (x), BLength (y)))) @*) (*@ assume (!x. Length (x) = BLength (B (x))) @*) (*@ assume val createBytes : (l:int -> ((v:int){C_pr_LessThanOrEqual(0, v) /\ C_pr_LessThan(v, 256)} -> (;l) lbytes)) @*) val createBytes : l:nat -> FStar.UInt8.t -> Tot (lbytes l) let createBytes l b = Seq.create l b // TODO: not implemented in ML

{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.UInt8.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked" ], "interface_file": false, "source_file": "Platform.Bytes.fst" }

[ { "abbrev": false, "full_module": "Platform", "short_module": null }, { "abbrev": false, "full_module": "Platform", "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

l: Prims.nat -> f: (i: Prims.nat{i < l} -> Platform.Bytes.byte) -> Platform.Bytes.lbytes l

Prims.Tot

[ "total" ]

[]

[ "Prims.nat", "Prims.b2t", "Prims.op_LessThan", "Platform.Bytes.byte", "FStar.Seq.Base.init", "Platform.Bytes.lbytes" ]

[]

false

let initBytes l f =

Seq.init l f

false

IfcRecursiveReify.fst

IfcRecursiveReify.ni_p2

val ni_p2 (lo hi : id) (n:int) (env:env) (h :rel heap) : Lemma (requires (lo <> hi /\ Low? (env lo) /\ High? (env hi) /\ low_equiv env h)) (ensures (low_equiv env (R (p2_r lo hi n (R?.l h)) (p2_r lo hi n (R?.r h)))))

let rec ni_p2 lo hi n env h = if n > 0 then begin let R hl hr = h in let hl' = (upd hl hi (sel hl hi + 1)) in let hr' = (upd hr hi (sel hr hi + 1)) in ni_p2 lo hi (n-1) env (R hl' hr') end

{ "file_name": "examples/rel/IfcRecursiveReify.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }

{ "end_col": 5, "end_line": 78, "start_col": 0, "start_line": 71 }

(* Copyright 2008-2018 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 IfcRecursiveReify open FStar.DM4F.Heap.IntStoreFixed open FStar.DM4F.IntStoreFixed open Rel type label = | Low | High type env = id -> Tot label type low_equiv (env:env) (h : rel heap) = forall (x:id). {:pattern (Low? (env x))} (Low? (env x) ==> sel (R?.l h) x = sel (R?.r h) x) val p1 (lo hi :id ): n:int -> ISNull unit (decreases n) let rec p1 lo hi n = if n > 0 then (write hi (read hi -1); p1 lo hi (n-1)) let p1_r lo hi n h = (* normalize_term *) (snd (reify (p1 lo hi n) h)) val ni_p1 (lo hi : id) (n:int) (env:env) (h :rel heap) : Lemma (requires (lo <> hi /\ Low? (env lo) /\ High? (env hi) /\ low_equiv env h)) (ensures (low_equiv env (R (p1_r lo hi n (R?.l h)) (p1_r lo hi n (R?.r h))))) let rec ni_p1 lo hi n env h = if n > 0 then begin let R hl hr = h in let hl' = (upd hl hi (sel hl hi - 1)) in let hr' = (upd hr hi (sel hr hi - 1)) in ni_p1 lo hi (n-1) env (R hl' hr') end val p2 (lo hi :id ): n:int -> ISNull unit (decreases n) let rec p2 lo hi n = if n > 0 then (write hi (read hi + 1); p2 lo hi (n - 1)) let p2_r lo hi n h = (* normalize_term *) (snd (reify (p2 lo hi n) h)) val ni_p2 (lo hi : id) (n:int) (env:env) (h :rel heap) : Lemma (requires (lo <> hi /\ Low? (env lo) /\ High? (env hi) /\ low_equiv env h))

{ "checked_file": "/", "dependencies": [ "Rel.fst.checked", "prims.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.DM4F.IntStoreFixed.fst.checked", "FStar.DM4F.Heap.IntStoreFixed.fsti.checked" ], "interface_file": false, "source_file": "IfcRecursiveReify.fst" }

[ { "abbrev": false, "full_module": "Rel", "short_module": null }, { "abbrev": false, "full_module": "FStar.DM4F.IntStoreFixed", "short_module": null }, { "abbrev": false, "full_module": "FStar.DM4F.Heap.IntStoreFixed", "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

lo: FStar.DM4F.Heap.IntStoreFixed.id -> hi: FStar.DM4F.Heap.IntStoreFixed.id -> n: Prims.int -> env: IfcRecursiveReify.env -> h: Rel.rel FStar.DM4F.Heap.IntStoreFixed.heap -> FStar.Pervasives.Lemma (requires lo <> hi /\ Low? (env lo) /\ High? (env hi) /\ IfcRecursiveReify.low_equiv env h) (ensures IfcRecursiveReify.low_equiv env (Rel.R (IfcRecursiveReify.p2_r lo hi n (R?.l h)) (IfcRecursiveReify.p2_r lo hi n (R?.r h)) ))

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "FStar.DM4F.Heap.IntStoreFixed.id", "Prims.int", "IfcRecursiveReify.env", "Rel.rel", "FStar.DM4F.Heap.IntStoreFixed.heap", "Prims.op_GreaterThan", "IfcRecursiveReify.ni_p2", "Prims.op_Subtraction", "Rel.R", "FStar.DM4F.Heap.IntStoreFixed.upd", "Prims.op_Addition", "FStar.DM4F.Heap.IntStoreFixed.sel", "Prims.unit", "Prims.bool" ]

[ "recursion" ]

false

true

false

let rec ni_p2 lo hi n env h =

if n > 0 then let R hl hr = h in let hl' = (upd hl hi (sel hl hi + 1)) in let hr' = (upd hr hi (sel hr hi + 1)) in ni_p2 lo hi (n - 1) env (R hl' hr')

false

IfcRecursiveReify.fst

IfcRecursiveReify.p1

val p1 (lo hi :id ): n:int -> ISNull unit (decreases n)

let rec p1 lo hi n = if n > 0 then (write hi (read hi -1); p1 lo hi (n-1))

{ "file_name": "examples/rel/IfcRecursiveReify.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }

{ "end_col": 19, "end_line": 35, "start_col": 1, "start_line": 32 }

(* Copyright 2008-2018 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 IfcRecursiveReify open FStar.DM4F.Heap.IntStoreFixed open FStar.DM4F.IntStoreFixed open Rel type label = | Low | High type env = id -> Tot label type low_equiv (env:env) (h : rel heap) = forall (x:id). {:pattern (Low? (env x))} (Low? (env x) ==> sel (R?.l h) x = sel (R?.r h) x)

{ "checked_file": "/", "dependencies": [ "Rel.fst.checked", "prims.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.DM4F.IntStoreFixed.fst.checked", "FStar.DM4F.Heap.IntStoreFixed.fsti.checked" ], "interface_file": false, "source_file": "IfcRecursiveReify.fst" }

[ { "abbrev": false, "full_module": "Rel", "short_module": null }, { "abbrev": false, "full_module": "FStar.DM4F.IntStoreFixed", "short_module": null }, { "abbrev": false, "full_module": "FStar.DM4F.Heap.IntStoreFixed", "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

lo: FStar.DM4F.Heap.IntStoreFixed.id -> hi: FStar.DM4F.Heap.IntStoreFixed.id -> n: Prims.int -> FStar.DM4F.IntStoreFixed.ISNull Prims.unit

FStar.DM4F.IntStoreFixed.ISNull

[ "" ]

[]

[ "FStar.DM4F.Heap.IntStoreFixed.id", "Prims.int", "Prims.op_GreaterThan", "IfcRecursiveReify.p1", "Prims.op_Subtraction", "Prims.unit", "FStar.DM4F.IntStoreFixed.write", "FStar.DM4F.IntStoreFixed.read", "Prims.bool" ]

[ "recursion" ]

false

true

false

let rec p1 lo hi n =

if n > 0 then (write hi (read hi - 1); p1 lo hi (n - 1))

false

IfcRecursiveReify.fst

IfcRecursiveReify.ni_p3

val ni_p3 (lo1 lo2 hi : id) (n:int) (env:env) (h :rel heap) : Lemma (requires (lo1 <> lo2 /\ lo1 <> hi /\ lo2 <> hi /\ Low? (env lo1) /\ Low? (env lo2) /\ High? (env hi) /\ low_equiv env h)) (ensures (low_equiv env (R (p3_r lo1 lo2 hi n (R?.l h)) (p3_r lo1 lo2 hi n (R?.r h)))))

let ni_p3 lo1 lo2 hi n env h = ni_p1 lo1 hi n env h; let R hl hr = h in let hl' = p1_r lo1 hi n hl in let hr' = p1_r lo1 hi n hr in ni_p2 lo2 hi n env (R hl' hr')

{ "file_name": "examples/rel/IfcRecursiveReify.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }

{ "end_col": 32, "end_line": 102, "start_col": 0, "start_line": 97 }

(* Copyright 2008-2018 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 IfcRecursiveReify open FStar.DM4F.Heap.IntStoreFixed open FStar.DM4F.IntStoreFixed open Rel type label = | Low | High type env = id -> Tot label type low_equiv (env:env) (h : rel heap) = forall (x:id). {:pattern (Low? (env x))} (Low? (env x) ==> sel (R?.l h) x = sel (R?.r h) x) val p1 (lo hi :id ): n:int -> ISNull unit (decreases n) let rec p1 lo hi n = if n > 0 then (write hi (read hi -1); p1 lo hi (n-1)) let p1_r lo hi n h = (* normalize_term *) (snd (reify (p1 lo hi n) h)) val ni_p1 (lo hi : id) (n:int) (env:env) (h :rel heap) : Lemma (requires (lo <> hi /\ Low? (env lo) /\ High? (env hi) /\ low_equiv env h)) (ensures (low_equiv env (R (p1_r lo hi n (R?.l h)) (p1_r lo hi n (R?.r h))))) let rec ni_p1 lo hi n env h = if n > 0 then begin let R hl hr = h in let hl' = (upd hl hi (sel hl hi - 1)) in let hr' = (upd hr hi (sel hr hi - 1)) in ni_p1 lo hi (n-1) env (R hl' hr') end val p2 (lo hi :id ): n:int -> ISNull unit (decreases n) let rec p2 lo hi n = if n > 0 then (write hi (read hi + 1); p2 lo hi (n - 1)) let p2_r lo hi n h = (* normalize_term *) (snd (reify (p2 lo hi n) h)) val ni_p2 (lo hi : id) (n:int) (env:env) (h :rel heap) : Lemma (requires (lo <> hi /\ Low? (env lo) /\ High? (env hi) /\ low_equiv env h)) (ensures (low_equiv env (R (p2_r lo hi n (R?.l h)) (p2_r lo hi n (R?.r h))))) let rec ni_p2 lo hi n env h = if n > 0 then begin let R hl hr = h in let hl' = (upd hl hi (sel hl hi + 1)) in let hr' = (upd hr hi (sel hr hi + 1)) in ni_p2 lo hi (n-1) env (R hl' hr') end let p3 lo1 lo2 hi n = p1 lo1 hi n ; p2 lo2 hi n let p3_r lo1 lo2 hi n h = (* normalize_term *) (snd (reify (p3 lo1 lo2 hi n) h)) val ni_p3 (lo1 lo2 hi : id) (n:int) (env:env) (h :rel heap) : Lemma (requires (lo1 <> lo2 /\ lo1 <> hi /\ lo2 <> hi /\ Low? (env lo1) /\ Low? (env lo2) /\ High? (env hi) /\ low_equiv env h))

{ "checked_file": "/", "dependencies": [ "Rel.fst.checked", "prims.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.DM4F.IntStoreFixed.fst.checked", "FStar.DM4F.Heap.IntStoreFixed.fsti.checked" ], "interface_file": false, "source_file": "IfcRecursiveReify.fst" }

[ { "abbrev": false, "full_module": "Rel", "short_module": null }, { "abbrev": false, "full_module": "FStar.DM4F.IntStoreFixed", "short_module": null }, { "abbrev": false, "full_module": "FStar.DM4F.Heap.IntStoreFixed", "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

lo1: FStar.DM4F.Heap.IntStoreFixed.id -> lo2: FStar.DM4F.Heap.IntStoreFixed.id -> hi: FStar.DM4F.Heap.IntStoreFixed.id -> n: Prims.int -> env: IfcRecursiveReify.env -> h: Rel.rel FStar.DM4F.Heap.IntStoreFixed.heap -> FStar.Pervasives.Lemma (requires lo1 <> lo2 /\ lo1 <> hi /\ lo2 <> hi /\ Low? (env lo1) /\ Low? (env lo2) /\ High? (env hi) /\ IfcRecursiveReify.low_equiv env h) (ensures IfcRecursiveReify.low_equiv env (Rel.R (IfcRecursiveReify.p3_r lo1 lo2 hi n (R?.l h)) (IfcRecursiveReify.p3_r lo1 lo2 hi n (R?.r h))))

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "FStar.DM4F.Heap.IntStoreFixed.id", "Prims.int", "IfcRecursiveReify.env", "Rel.rel", "FStar.DM4F.Heap.IntStoreFixed.heap", "IfcRecursiveReify.ni_p2", "Rel.R", "IfcRecursiveReify.p1_r", "Prims.unit", "IfcRecursiveReify.ni_p1" ]

[]

false

true

false

let ni_p3 lo1 lo2 hi n env h =

ni_p1 lo1 hi n env h; let R hl hr = h in let hl' = p1_r lo1 hi n hl in let hr' = p1_r lo1 hi n hr in ni_p2 lo2 hi n env (R hl' hr')

false

FStar.Pointer.Derived3.fst

FStar.Pointer.Derived3.fill_buffer_postcond'

val fill_buffer_postcond' (#t: typ) (b: buffer t) (v: type_of_typ t) (h h': HS.mem) : GTot Type0

let fill_buffer_postcond' (#t: typ) (b: buffer t) (* destination *) (v: type_of_typ t) (h: HS.mem) (h' : HS.mem) : GTot Type0 = fill_buffer_precond' b h /\ modifies (loc_buffer b) h h' /\ buffer_readable h' b /\ buffer_as_seq h' b == Seq.create (UInt32.v (buffer_length b)) v

{ "file_name": "ulib/legacy/FStar.Pointer.Derived3.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }

{ "end_col": 65, "end_line": 41, "start_col": 0, "start_line": 31 }

(* Copyright 2008-2018 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 FStar.Pointer.Derived3 module HH = FStar.HyperStack module HS = FStar.HyperStack module HST = FStar.HyperStack.ST private let fill_buffer_precond' (#t: typ) (b: buffer t) (* destination *) (h: HS.mem) : GTot Type0 = buffer_live h b

{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.UInt32.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Ghost.fsti.checked" ], "interface_file": true, "source_file": "FStar.Pointer.Derived3.fst" }

[ { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HH" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HH" }, { "abbrev": false, "full_module": "FStar.Pointer.Derived1", "short_module": null }, { "abbrev": false, "full_module": "FStar.Pointer.Base", "short_module": null }, { "abbrev": false, "full_module": "FStar.Pointer", "short_module": null }, { "abbrev": false, "full_module": "FStar.Pointer", "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

b: FStar.Pointer.Base.buffer t -> v: FStar.Pointer.Base.type_of_typ t -> h: FStar.Monotonic.HyperStack.mem -> h': FStar.Monotonic.HyperStack.mem -> Prims.GTot Type0

Prims.GTot

[ "sometrivial" ]

[]

[ "FStar.Pointer.Base.typ", "FStar.Pointer.Base.buffer", "FStar.Pointer.Base.type_of_typ", "FStar.Monotonic.HyperStack.mem", "Prims.l_and", "FStar.Pointer.Derived3.fill_buffer_precond'", "FStar.Pointer.Base.modifies", "FStar.Pointer.Base.loc_buffer", "FStar.Pointer.Base.buffer_readable", "Prims.eq2", "FStar.Seq.Base.seq", "FStar.Pointer.Base.buffer_as_seq", "FStar.Seq.Base.create", "FStar.UInt32.v", "FStar.Pointer.Base.buffer_length" ]

[]

false

true

let fill_buffer_postcond' (#t: typ) (b: buffer t) (v: type_of_typ t) (h h': HS.mem) : GTot Type0 =

fill_buffer_precond' b h /\ modifies (loc_buffer b) h h' /\ buffer_readable h' b /\ buffer_as_seq h' b == Seq.create (UInt32.v (buffer_length b)) v

false

FStar.Pointer.Derived3.fst

FStar.Pointer.Derived3.fill_buffer_inv

val fill_buffer_inv (#t: typ) (b: buffer t) (len': UInt32.t) (v: type_of_typ t) (h h': HS.mem) : GTot Type0

let fill_buffer_inv (#t: typ) (b: buffer t) (* destination *) (len' : UInt32.t) (v: type_of_typ t) (h: HS.mem) (h' : HS.mem) : GTot Type0 = fill_buffer_precond' b h /\ modifies (loc_buffer b) h h' /\ UInt32.v len' <= UInt32.v (buffer_length b) /\ buffer_readable h' (gsub_buffer b 0ul len') /\ buffer_as_seq h' (gsub_buffer b 0ul len') == Seq.create (UInt32.v len') v

{ "file_name": "ulib/legacy/FStar.Pointer.Derived3.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }

{ "end_col": 75, "end_line": 56, "start_col": 0, "start_line": 44 }

(* Copyright 2008-2018 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 FStar.Pointer.Derived3 module HH = FStar.HyperStack module HS = FStar.HyperStack module HST = FStar.HyperStack.ST private let fill_buffer_precond' (#t: typ) (b: buffer t) (* destination *) (h: HS.mem) : GTot Type0 = buffer_live h b private let fill_buffer_postcond' (#t: typ) (b: buffer t) (* destination *) (v: type_of_typ t) (h: HS.mem) (h' : HS.mem) : GTot Type0 = fill_buffer_precond' b h /\ modifies (loc_buffer b) h h' /\ buffer_readable h' b /\ buffer_as_seq h' b == Seq.create (UInt32.v (buffer_length b)) v

{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.UInt32.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Ghost.fsti.checked" ], "interface_file": true, "source_file": "FStar.Pointer.Derived3.fst" }

[ { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HH" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HH" }, { "abbrev": false, "full_module": "FStar.Pointer.Derived1", "short_module": null }, { "abbrev": false, "full_module": "FStar.Pointer.Base", "short_module": null }, { "abbrev": false, "full_module": "FStar.Pointer", "short_module": null }, { "abbrev": false, "full_module": "FStar.Pointer", "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

b: FStar.Pointer.Base.buffer t -> len': FStar.UInt32.t -> v: FStar.Pointer.Base.type_of_typ t -> h: FStar.Monotonic.HyperStack.mem -> h': FStar.Monotonic.HyperStack.mem -> Prims.GTot Type0

Prims.GTot

[ "sometrivial" ]

[]

[ "FStar.Pointer.Base.typ", "FStar.Pointer.Base.buffer", "FStar.UInt32.t", "FStar.Pointer.Base.type_of_typ", "FStar.Monotonic.HyperStack.mem", "Prims.l_and", "FStar.Pointer.Derived3.fill_buffer_precond'", "FStar.Pointer.Base.modifies", "FStar.Pointer.Base.loc_buffer", "Prims.b2t", "Prims.op_LessThanOrEqual", "FStar.UInt32.v", "FStar.Pointer.Base.buffer_length", "FStar.Pointer.Base.buffer_readable", "FStar.Pointer.Base.gsub_buffer", "FStar.UInt32.__uint_to_t", "Prims.eq2", "FStar.Seq.Base.seq", "FStar.Pointer.Base.buffer_as_seq", "FStar.Seq.Base.create" ]

[]

false

true

let fill_buffer_inv (#t: typ) (b: buffer t) (len': UInt32.t) (v: type_of_typ t) (h h': HS.mem) : GTot Type0 =

fill_buffer_precond' b h /\ modifies (loc_buffer b) h h' /\ UInt32.v len' <= UInt32.v (buffer_length b) /\ buffer_readable h' (gsub_buffer b 0ul len') /\ buffer_as_seq h' (gsub_buffer b 0ul len') == Seq.create (UInt32.v len') v

false

Hacl.Spec.Poly1305.Field32xN.Lemmas.fst

Hacl.Spec.Poly1305.Field32xN.Lemmas.set_bit5_lemma

val set_bit5_lemma: #w:lanes -> f:lseq (uint64xN w) 5 -> i:size_nat{i <= 128} -> Lemma (requires lfelem_fits f (1, 1, 1, 1, 1) /\ lfelem_less f (pow2 i)) (ensures lfelem_fits (set_bit5 f i) (1, 1, 1, 1, 1) /\ lfeval (set_bit5 f i) == map (Vec.pfadd (pow2 i)) (lfeval f))

let set_bit5_lemma #w f i = let tmp = map (Vec.pfadd (pow2 i)) (lfeval f) in match w with | 1 -> set_bit5_lemma_k #w f i 0; eq_intro (lfeval (set_bit5 f i)) tmp | 2 -> set_bit5_lemma_k #w f i 0; set_bit5_lemma_k #w f i 1; eq_intro (lfeval (set_bit5 f i)) tmp | 4 -> set_bit5_lemma_k #w f i 0; set_bit5_lemma_k #w f i 1; set_bit5_lemma_k #w f i 2; set_bit5_lemma_k #w f i 3; eq_intro (lfeval (set_bit5 f i)) tmp

{ "file_name": "code/poly1305/Hacl.Spec.Poly1305.Field32xN.Lemmas.fst", "git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872", "git_url": "https://github.com/project-everest/hacl-star.git", "project_name": "hacl-star" }

{ "end_col": 40, "end_line": 857, "start_col": 0, "start_line": 842 }

module Hacl.Spec.Poly1305.Field32xN.Lemmas open Lib.IntTypes open Lib.IntVector open Lib.Sequence open FStar.Mul open Hacl.Spec.Poly1305.Field32xN open Hacl.Poly1305.Field32xN.Lemmas0 open Hacl.Poly1305.Field32xN.Lemmas1 open Hacl.Poly1305.Field32xN.Lemmas2 module Vec = Hacl.Spec.Poly1305.Vec #set-options "--z3rlimit 100 --max_fuel 0 --initial_ifuel 1 --max_ifuel 1 --using_facts_from '* -FStar.Seq'" val lemma_feval_is_fas_nat_i: #w:lanes -> f:felem5 w{felem_less5 f (pow2 128)} -> i:size_nat{i < w} -> Lemma ((feval5 f).[i] == (fas_nat5 f).[i]) let lemma_feval_is_fas_nat_i #w f i = assert_norm (pow2 128 < Vec.prime); assert ((feval5 f).[i] == (as_nat5 (transpose f).[i]) % Vec.prime); FStar.Math.Lemmas.modulo_lemma (as_nat5 (transpose f).[i]) Vec.prime val lemma_feval_is_fas_nat: #w:lanes -> f:felem5 w{felem_less5 f (pow2 128)} -> Lemma (forall (i:nat). i < w ==> (fas_nat5 f).[i] == (feval5 f).[i]) let lemma_feval_is_fas_nat #w f = FStar.Classical.forall_intro (lemma_feval_is_fas_nat_i #w f) val precomp_r5_fits_lemma: #w:lanes -> r:felem5 w{felem_fits5 r (1, 1, 1, 1, 1)} -> Lemma (felem_fits5 (precomp_r5 #w r) (5, 5, 5, 5, 5)) [SMTPat (precomp_r5 #w r)] let precomp_r5_fits_lemma #w r = FStar.Classical.forall_intro (precomp_r5_as_tup64 #w r) val precomp_r5_fits_lemma2: #w:lanes -> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)} -> Lemma (felem_fits5 (precomp_r5 #w r) (10, 10, 10, 10, 10)) [SMTPat (precomp_r5 #w r)] let precomp_r5_fits_lemma2 #w r = FStar.Classical.forall_intro (precomp_r5_as_tup64 #w r) val precomp_r5_zeros: w:lanes -> Lemma (let r = (zero w, zero w, zero w, zero w, zero w) in precomp_r5 r == (zero w, zero w, zero w, zero w, zero w)) let precomp_r5_zeros w = let r = (zero w, zero w, zero w, zero w, zero w) in let (r0, r1, r2, r3, r4) = precomp_r5 r in let aux (i:nat{i < w}) : Lemma ((vec_v (vec_smul_mod (zero w) (u64 5))).[i] == u64 0) = () in Classical.forall_intro aux; eq_intro (vec_v (vec_smul_mod (zero w) (u64 5))) (vec_v (zero w)); vecv_extensionality (vec_smul_mod (zero w) (u64 5)) (zero w) val fadd5_fits_lemma: #w:lanes -> f1:felem5 w{felem_fits5 f1 (2,2,2,2,2)} -> f2:felem5 w{felem_fits5 f2 (1,1,1,1,1)} -> Lemma (felem_fits5 (fadd5 f1 f2) (3,3,3,3,3)) [SMTPat (fadd5 f1 f2)] let fadd5_fits_lemma #w f1 f2 = let (f10, f11, f12, f13, f14) = f1 in let (f20, f21, f22, f23, f24) = f2 in let o = fadd5 f1 f2 in vec_add_mod_lemma f10 f20; vec_add_mod_lemma f11 f21; vec_add_mod_lemma f12 f22; vec_add_mod_lemma f13 f23; vec_add_mod_lemma f14 f24 val fadd5_eval_lemma: #w:lanes -> f1:felem5 w{felem_fits5 f1 (2,2,2,2,2)} -> f2:felem5 w{felem_fits5 f2 (1,1,1,1,1)} -> Lemma (feval5 (fadd5 f1 f2) == map2 Vec.pfadd (feval5 f1) (feval5 f2)) [SMTPat (fadd5 f1 f2)] let fadd5_eval_lemma #w f1 f2 = let o = fadd5 f1 f2 in FStar.Classical.forall_intro (fadd5_eval_lemma_i f1 f2); eq_intro (feval5 o) (map2 Vec.pfadd (feval5 f1) (feval5 f2)) val mul_felem5_fits_lemma: #w:lanes -> f1:felem5 w{felem_fits5 f1 (3, 3, 3, 3, 3)} -> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)} -> r5:felem5 w{felem_fits5 r5 (10, 10, 10, 10, 10)} -> Lemma (felem_wide_fits5 (mul_felem5 #w f1 r r5) (126, 102, 78, 54, 30)) [SMTPat (mul_felem5 #w f1 r r5)] let mul_felem5_fits_lemma #w f1 r r5 = let (r0, r1, r2, r3, r4) = r in let (f10, f11, f12, f13, f14) = f1 in let (r50, r51, r52, r53, r54) = r5 in let (a0,a1,a2,a3,a4) = smul_felem5 #w f10 (r0,r1,r2,r3,r4) in smul_felem5_fits_lemma #w #3 #(2,2,2,2,2) f10 (r0,r1,r2,r3,r4); let (a10,a11,a12,a13,a14) = smul_add_felem5 #w f11 (r54,r0,r1,r2,r3) (a0,a1,a2,a3,a4) in smul_add_felem5_fits_lemma #w #3 #(10,2,2,2,2) #(6,6,6,6,6) f11 (r54,r0,r1,r2,r3) (a0,a1,a2,a3,a4); let (a20,a21,a22,a23,a24) = smul_add_felem5 #w f12 (r53,r54,r0,r1,r2) (a10,a11,a12,a13,a14) in smul_add_felem5_fits_lemma #w #3 #(10,10,2,2,2) #(36,12,12,12,12) f12 (r53,r54,r0,r1,r2) (a10,a11,a12,a13,a14); let (a30,a31,a32,a33,a34) = smul_add_felem5 #w f13 (r52,r53,r54,r0,r1) (a20,a21,a22,a23,a24) in smul_add_felem5_fits_lemma #w #3 #(10,10,10,2,2) #(66,42,18,18,18) f13 (r52,r53,r54,r0,r1) (a20,a21,a22,a23,a24); let (a40,a41,a42,a43,a44) = smul_add_felem5 #w f14 (r51,r52,r53,r54,r0) (a30,a31,a32,a33,a34) in smul_add_felem5_fits_lemma #w #3 #(10,10,10,10,2) #(96,72,48,24,24) f14 (r51,r52,r53,r54,r0) (a30,a31,a32,a33,a34) val mul_felem5_eval_lemma_i: #w:lanes -> f1:felem5 w{felem_fits5 f1 (3, 3, 3, 3, 3)} -> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)} -> r5:felem5 w{felem_fits5 r5 (10, 10, 10, 10, 10) /\ r5 == precomp_r5 r} -> i:nat{i < w} -> Lemma ((feval5 (mul_felem5 #w f1 r r5)).[i] == (feval5 f1).[i] `Vec.pfmul` (feval5 r).[i]) let mul_felem5_eval_lemma_i #w f1 r r5 i = let (r0, r1, r2, r3, r4) = r in let (f10, f11, f12, f13, f14) = f1 in let (r50, r51, r52, r53, r54) = r5 in let (a0,a1,a2,a3,a4) = smul_felem5 #w f10 (r0,r1,r2,r3,r4) in smul_felem5_eval_lemma #w #3 #(2,2,2,2,2) f10 (r0,r1,r2,r3,r4); smul_felem5_fits_lemma #w #3 #(2,2,2,2,2) f10 (r0,r1,r2,r3,r4); assert ((fas_nat5 (a0,a1,a2,a3,a4)).[i] == (uint64xN_v f10).[i] * (fas_nat5 (r0,r1,r2,r3,r4)).[i]); let (a10,a11,a12,a13,a14) = smul_add_felem5 #w f11 (r54,r0,r1,r2,r3) (a0,a1,a2,a3,a4) in smul_add_felem5_eval_lemma #w #3 #(10,2,2,2,2) #(6,6,6,6,6) f11 (r54,r0,r1,r2,r3) (a0,a1,a2,a3,a4); smul_add_felem5_fits_lemma #w #3 #(10,2,2,2,2) #(6,6,6,6,6) f11 (r54,r0,r1,r2,r3) (a0,a1,a2,a3,a4); assert ((fas_nat5 (a10,a11,a12,a13,a14)).[i] == (fas_nat5 (a0,a1,a2,a3,a4)).[i] + (uint64xN_v f11).[i] * (fas_nat5 (r54,r0,r1,r2,r3)).[i]); let (a20,a21,a22,a23,a24) = smul_add_felem5 #w f12 (r53,r54,r0,r1,r2) (a10,a11,a12,a13,a14) in smul_add_felem5_eval_lemma #w #3 #(10,10,2,2,2) #(36,12,12,12,12) f12 (r53,r54,r0,r1,r2) (a10,a11,a12,a13,a14); smul_add_felem5_fits_lemma #w #3 #(10,10,2,2,2) #(36,12,12,12,12) f12 (r53,r54,r0,r1,r2) (a10,a11,a12,a13,a14); assert ((fas_nat5 (a20,a21,a22,a23,a24)).[i] == (fas_nat5 (a10,a11,a12,a13,a14)).[i] + (uint64xN_v f12).[i] * (fas_nat5 (r53,r54,r0,r1,r2)).[i]); let (a30,a31,a32,a33,a34) = smul_add_felem5 #w f13 (r52,r53,r54,r0,r1) (a20,a21,a22,a23,a24) in smul_add_felem5_eval_lemma #w #3 #(10,10,10,2,2) #(66,42,18,18,18) f13 (r52,r53,r54,r0,r1) (a20,a21,a22,a23,a24); smul_add_felem5_fits_lemma #w #3 #(10,10,10,2,2) #(66,42,18,18,18) f13 (r52,r53,r54,r0,r1) (a20,a21,a22,a23,a24); assert ((fas_nat5 (a30,a31,a32,a33,a34)).[i] == (fas_nat5 (a20,a21,a22,a23,a24)).[i] + (uint64xN_v f13).[i] * (fas_nat5 (r52,r53,r54,r0,r1)).[i]); let (a40,a41,a42,a43,a44) = smul_add_felem5 #w f14 (r51,r52,r53,r54,r0) (a30,a31,a32,a33,a34) in smul_add_felem5_eval_lemma #w #3 #(10,10,10,10,2) #(96,72,48,24,24) f14 (r51,r52,r53,r54,r0) (a30,a31,a32,a33,a34); smul_add_felem5_fits_lemma #w #3 #(10,10,10,10,2) #(96,72,48,24,24) f14 (r51,r52,r53,r54,r0) (a30,a31,a32,a33,a34); assert ((fas_nat5 (a40,a41,a42,a43,a44)).[i] == (fas_nat5 (a30,a31,a32,a33,a34)).[i] + (uint64xN_v f14).[i] * (fas_nat5 (r51,r52,r53,r54,r0)).[i]); assert ((fas_nat5 (a40,a41,a42,a43,a44)).[i] == (uint64xN_v f10).[i] * (fas_nat5 (r0,r1,r2,r3,r4)).[i] + (uint64xN_v f11).[i] * (fas_nat5 (r54,r0,r1,r2,r3)).[i] + (uint64xN_v f12).[i] * (fas_nat5 (r53,r54,r0,r1,r2)).[i] + (uint64xN_v f13).[i] * (fas_nat5 (r52,r53,r54,r0,r1)).[i] + (uint64xN_v f14).[i] * (fas_nat5 (r51,r52,r53,r54,r0)).[i]); mul_felem5_eval_as_tup64 #w f1 r r5 i; mul_felem5_lemma (as_tup64_i f1 i) (as_tup64_i r i) val mul_felem5_eval_lemma: #w:lanes -> f1:felem5 w{felem_fits5 f1 (3, 3, 3, 3, 3)} -> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)} -> r5:felem5 w{felem_fits5 r5 (10, 10, 10, 10, 10) /\ r5 == precomp_r5 r} -> Lemma (feval5 (mul_felem5 #w f1 r r5) == map2 (Vec.pfmul) (feval5 f1) (feval5 r)) [SMTPat (mul_felem5 #w f1 r r5)] let mul_felem5_eval_lemma #w f1 r r5 = let tmp = map2 (Vec.pfmul) (feval5 f1) (feval5 r) in FStar.Classical.forall_intro (mul_felem5_eval_lemma_i #w f1 r r5); eq_intro (feval5 (mul_felem5 #w f1 r r5)) tmp val fmul_r5_fits_lemma: #w:lanes -> f1:felem5 w{felem_fits5 f1 (3, 3, 3, 3, 3)} -> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)} -> r5:felem5 w{felem_fits5 r5 (10, 10, 10, 10, 10)} -> Lemma (felem_fits5 (fmul_r5 #w f1 r r5) (1, 2, 1, 1, 2)) [SMTPat (fmul_r5 #w f1 r r5)] let fmul_r5_fits_lemma #w f1 r r5 = let tmp = mul_felem5 f1 r r5 in mul_felem5_fits_lemma #w f1 r r5; let res = carry_wide_felem5 tmp in carry_wide_felem5_fits_lemma #w tmp val fmul_r5_eval_lemma: #w:lanes -> f1:felem5 w{felem_fits5 f1 (3, 3, 3, 3, 3)} -> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)} -> r5:felem5 w{felem_fits5 r5 (10, 10, 10, 10, 10) /\ r5 == precomp_r5 r} -> Lemma (feval5 (fmul_r5 #w f1 r r5) == map2 (Vec.pfmul) (feval5 f1) (feval5 r)) [SMTPat (fmul_r5 #w f1 r r5)] let fmul_r5_eval_lemma #w f1 r r5 = let tmp = mul_felem5 f1 r r5 in mul_felem5_eval_lemma #w f1 r r5; let res = carry_wide_felem5 tmp in carry_wide_felem5_eval_lemma #w tmp val fadd_mul_r5_fits_lemma: #w:lanes -> acc:felem5 w{felem_fits5 acc (2, 2, 2, 2, 2)} -> f1:felem5 w{felem_fits5 f1 (1, 1, 1, 1, 1)} -> r:felem5 w{felem_fits5 r (1, 1, 1, 1, 1)} -> r5:felem5 w{felem_fits5 r5 (5, 5, 5, 5, 5)} -> Lemma (felem_fits5 (fadd_mul_r5 acc f1 r r5) (1, 2, 1, 1, 2)) [SMTPat (fadd_mul_r5 acc f1 r r5)] let fadd_mul_r5_fits_lemma #w acc f1 r r5 = let acc1 = fadd5 acc f1 in fadd5_fits_lemma #w acc f1; let tmp = mul_felem5 acc1 r r5 in mul_felem5_fits_lemma #w acc1 r r5; let res = carry_wide_felem5 tmp in carry_wide_felem5_fits_lemma #w tmp val fadd_mul_r5_eval_lemma: #w:lanes -> acc:felem5 w{felem_fits5 acc (2, 2, 2, 2, 2)} -> f1:felem5 w{felem_fits5 f1 (1, 1, 1, 1, 1)} -> r:felem5 w{felem_fits5 r (1, 1, 1, 1, 1)} -> r5:felem5 w{felem_fits5 r5 (5, 5, 5, 5, 5) /\ r5 == precomp_r5 r} -> Lemma (feval5 (fadd_mul_r5 acc f1 r r5) == map2 (Vec.pfmul) (map2 (Vec.pfadd) (feval5 acc) (feval5 f1)) (feval5 r)) [SMTPat (fadd_mul_r5 acc f1 r r5)] let fadd_mul_r5_eval_lemma #w acc f1 r r5 = let acc1 = fadd5 acc f1 in fadd5_eval_lemma #w acc f1; let tmp = mul_felem5 acc1 r r5 in mul_felem5_eval_lemma #w acc1 r r5; let res = carry_wide_felem5 tmp in carry_wide_felem5_eval_lemma #w tmp val reduce_felem5_eval_lemma: #w:lanes -> f:felem5 w{felem_fits5 f (2, 2, 2, 2, 2)} -> Lemma (felem_fits5 (reduce_felem5 f) (1, 1, 1, 1, 1) /\ (feval5 f).[0] == (fas_nat5 (reduce_felem5 f)).[0]) [SMTPat (reduce_felem5 f)] let reduce_felem5_eval_lemma #w f = carry_full_felem5_eval_lemma f; carry_full_felem5_fits_lemma f; let f = carry_full_felem5 f in carry_reduce_felem5_lemma #w f; subtract_p5_felem5_lemma #w (carry_full_felem5 f) val fmul_r2_normalize50: acc:felem5 2 -> r:felem5 2 -> r2:felem5 2 -> Pure (felem5 2) (requires felem_fits5 acc (3, 3, 3, 3, 3) /\ felem_fits5 r (1, 1, 1, 1, 1) /\ felem_fits5 r2 (2, 2, 2, 2, 2) /\ feval5 r2 == Vec.compute_r2 (feval5 r).[0]) (ensures fun a -> let fr21 = create2 (feval5 r2).[0] (feval5 r).[0] in feval5 a == Vec.fmul (feval5 acc) fr21 /\ felem_fits5 a (1, 2, 1, 1, 2)) let fmul_r2_normalize50 (a0, a1, a2, a3, a4) (r0, r1, r2, r3, r4) (r20, r21, r22, r23, r24) = let r210 = vec_interleave_low r20 r0 in vec_interleave_low_lemma2 r20 r0; let r211 = vec_interleave_low r21 r1 in vec_interleave_low_lemma2 r21 r1; let r212 = vec_interleave_low r22 r2 in vec_interleave_low_lemma2 r22 r2; let r213 = vec_interleave_low r23 r3 in vec_interleave_low_lemma2 r23 r3; let r214 = vec_interleave_low r24 r4 in vec_interleave_low_lemma2 r24 r4; let acc = (a0, a1, a2, a3, a4) in let fr = (r0, r1, r2, r3, r4) in let fr2 = (r20, r21, r22, r23, r24) in assert ((feval5 fr2).[0] == Vec.pfmul ((feval5 fr).[0]) ((feval5 fr).[0])); let fr21 = (r210, r211, r212, r213, r214) in eq_intro (feval5 fr21) (create2 (feval5 fr2).[0] (feval5 fr).[0]); assert (feval5 fr21 == create2 (feval5 fr2).[0] (feval5 fr).[0]); assert (felem_fits5 fr21 (2, 2, 2, 2, 2)); let fr215 = precomp_r5 #2 fr21 in let a = fmul_r5 #2 acc fr21 fr215 in fmul_r5_eval_lemma acc fr21 fr215; fmul_r5_fits_lemma acc fr21 fr215; assert (feval5 a == Vec.fmul (feval5 acc) (feval5 fr21)); assert (felem_fits5 a (1, 2, 1, 1, 2)); a #push-options "--z3rlimit 150" val fmul_r2_normalize51: a:felem5 2 -> fa1:felem5 2 -> Pure (felem5 2) (requires felem_fits5 a (1, 2, 1, 1, 2) /\ felem_fits5 fa1 (1, 2, 1, 1, 2) /\ feval5 fa1 == create2 (feval5 a).[1] (feval5 a).[1]) (ensures fun out -> (feval5 out).[0] == Vec.pfadd (feval5 a).[0] (feval5 a).[1] /\ felem_fits5 out (2, 4, 2, 2, 4)) let fmul_r2_normalize51 a fa1 = let (a0, a1, a2, a3, a4) = a in let (a10, a11, a12, a13, a14) = fa1 in let o0 = vec_add_mod a0 a10 in let o1 = vec_add_mod a1 a11 in let o2 = vec_add_mod a2 a12 in let o3 = vec_add_mod a3 a13 in let o4 = vec_add_mod a4 a14 in let out = (o0, o1, o2, o3, o4) in let (a0, a1, a2, a3, a4) = as_tup64_i a 0 in let (a10, a11, a12, a13, a14) = as_tup64_i fa1 0 in let (o0, o1, o2, o3, o4) = as_tup64_i out 0 in FStar.Math.Lemmas.modulo_lemma (v a0 + v a10) (pow2 64); FStar.Math.Lemmas.modulo_lemma (v a1 + v a11) (pow2 64); FStar.Math.Lemmas.modulo_lemma (v a2 + v a12) (pow2 64); FStar.Math.Lemmas.modulo_lemma (v a3 + v a13) (pow2 64); FStar.Math.Lemmas.modulo_lemma (v a4 + v a14) (pow2 64); assert (felem_fits5 out (2, 4, 2, 2, 4)); calc (==) { ((feval5 a).[0] + (feval5 a).[1]) % Vec.prime; (==) { } (as_nat5 (a0, a1, a2, a3, a4) % Vec.prime + as_nat5 (a10, a11, a12, a13, a14) % Vec.prime) % Vec.prime; (==) { FStar.Math.Lemmas.lemma_mod_plus_distr_l (as_nat5 (a0, a1, a2, a3, a4)) (as_nat5 (a10, a11, a12, a13, a14)) Vec.prime; FStar.Math.Lemmas.lemma_mod_plus_distr_r (as_nat5 (a0, a1, a2, a3, a4) % Vec.prime) (as_nat5 (a10, a11, a12, a13, a14)) Vec.prime } (as_nat5 (a0, a1, a2, a3, a4) + as_nat5 (a10, a11, a12, a13, a14)) % Vec.prime; (==) { } (feval5 out).[0]; }; out #pop-options val fmul_r2_normalize5_lemma: acc:felem5 2 -> r:felem5 2 -> r2:felem5 2 -> Lemma (requires felem_fits5 acc (3, 3, 3, 3, 3) /\ felem_fits5 r (1, 1, 1, 1, 1) /\ felem_fits5 r2 (2, 2, 2, 2, 2) /\ feval5 r2 == Vec.compute_r2 (feval5 r).[0]) (ensures (let out = fmul_r2_normalize5 acc r r2 in felem_fits5 out (2, 1, 1, 1, 1) /\ (feval5 out).[0] == Vec.normalize_2 (feval5 r).[0] (feval5 acc))) [SMTPat (fmul_r2_normalize5 acc r r2)] let fmul_r2_normalize5_lemma acc r r2 = let a = fmul_r2_normalize50 acc r r2 in let (a0, a1, a2, a3, a4) = a in let a10 = vec_interleave_high a0 a0 in vec_interleave_high_lemma2 a0 a0; let a11 = vec_interleave_high a1 a1 in vec_interleave_high_lemma2 a1 a1; let a12 = vec_interleave_high a2 a2 in vec_interleave_high_lemma2 a2 a2; let a13 = vec_interleave_high a3 a3 in vec_interleave_high_lemma2 a3 a3; let a14 = vec_interleave_high a4 a4 in vec_interleave_high_lemma2 a4 a4; let fa1 = (a10, a11, a12, a13, a14) in eq_intro (feval5 fa1) (create2 (feval5 a).[1] (feval5 a).[1]); assert (feval5 fa1 == create2 (feval5 a).[1] (feval5 a).[1]); assert (felem_fits5 fa1 (1, 2, 1, 1, 2)); let out = fmul_r2_normalize51 a fa1 in assert ((feval5 out).[0] == Vec.pfadd (feval5 a).[0] (feval5 a).[1]); let res = carry_full_felem5 out in carry_full_felem5_lemma out val fmul_r4_normalize50: acc:felem5 4 -> r:felem5 4 -> r2:felem5 4 -> r3:felem5 4 -> r4:felem5 4 -> Pure (felem5 4) (requires felem_fits5 acc (3, 3, 3, 3, 3) /\ felem_fits5 r (1, 1, 1, 1, 1) /\ felem_fits5 r2 (2, 2, 2, 2, 2) /\ felem_fits5 r3 (2, 2, 2, 2, 2) /\ felem_fits5 r4 (2, 2, 2, 2, 2) /\ feval5 r2 == Vec.fmul (feval5 r) (feval5 r) /\ feval5 r3 == Vec.fmul (feval5 r2) (feval5 r) /\ feval5 r4 == Vec.compute_r4 (feval5 r).[0]) (ensures fun out -> let fr4321 = create4 (feval5 r4).[0] (feval5 r3).[0] (feval5 r2).[0] (feval5 r).[0] in feval5 out == Vec.fmul (feval5 acc) fr4321 /\ felem_fits5 out (1, 2, 1, 1, 2)) let fmul_r4_normalize50 acc fr fr2 fr3 fr4 = let (r10, r11, r12, r13, r14) = fr in let (r20, r21, r22, r23, r24) = fr2 in let (r30, r31, r32, r33, r34) = fr3 in let (r40, r41, r42, r43, r44) = fr4 in let (a0, a1, a2, a3, a4) = acc in let v12120 = vec_interleave_low r20 r10 in vec_interleave_low_lemma_uint64_4 r20 r10; let v34340 = vec_interleave_low r40 r30 in vec_interleave_low_lemma_uint64_4 r40 r30; let r12340 = vec_interleave_low_n 2 v34340 v12120 in vec_interleave_low_n_lemma_uint64_4_2 v34340 v12120; let v12121 = vec_interleave_low r21 r11 in vec_interleave_low_lemma_uint64_4 r21 r11; let v34341 = vec_interleave_low r41 r31 in vec_interleave_low_lemma_uint64_4 r41 r31; let r12341 = vec_interleave_low_n 2 v34341 v12121 in vec_interleave_low_n_lemma_uint64_4_2 v34341 v12121; let v12122 = vec_interleave_low r22 r12 in vec_interleave_low_lemma_uint64_4 r22 r12; let v34342 = vec_interleave_low r42 r32 in vec_interleave_low_lemma_uint64_4 r42 r32; let r12342 = vec_interleave_low_n 2 v34342 v12122 in vec_interleave_low_n_lemma_uint64_4_2 v34342 v12122; let v12123 = vec_interleave_low r23 r13 in vec_interleave_low_lemma_uint64_4 r23 r13; let v34343 = vec_interleave_low r43 r33 in vec_interleave_low_lemma_uint64_4 r43 r33; let r12343 = vec_interleave_low_n 2 v34343 v12123 in vec_interleave_low_n_lemma_uint64_4_2 v34343 v12123; let v12124 = vec_interleave_low r24 r14 in vec_interleave_low_lemma_uint64_4 r24 r14; let v34344 = vec_interleave_low r44 r34 in vec_interleave_low_lemma_uint64_4 r44 r34; let r12344 = vec_interleave_low_n 2 v34344 v12124 in vec_interleave_low_n_lemma_uint64_4_2 v34344 v12124; let fr1234 = (r12340, r12341, r12342, r12343, r12344) in eq_intro (feval5 fr1234) (create4 (feval5 fr4).[0] (feval5 fr3).[0] (feval5 fr2).[0] (feval5 fr).[0]); let fr12345 = precomp_r5 #4 fr1234 in let out = fmul_r5 #4 acc fr1234 fr12345 in fmul_r5_eval_lemma acc fr1234 fr12345; fmul_r5_fits_lemma acc fr1234 fr12345; out val lemma_fmul_r4_normalize51: #m:scale32{m <= 2} -> o:uint64xN 4{felem_fits1 o m} -> Lemma (let v00 = vec_interleave_high_n 2 o o in let v10 = vec_add_mod o v00 in let v10h = vec_interleave_high v10 v10 in let v20 = vec_add_mod v10 v10h in felem_fits1 v20 (4 * m) /\ (uint64xN_v v20).[0] == (uint64xN_v o).[0] + (uint64xN_v o).[1] + (uint64xN_v o).[2] + (uint64xN_v o).[3]) let lemma_fmul_r4_normalize51 #m o = let v00 = vec_interleave_high_n 2 o o in vec_interleave_high_n_lemma_uint64_4_2 o o; let (o0, o1, o2, o3) = ((vec_v o).[0], (vec_v o).[1], (vec_v o).[2], (vec_v o).[3]) in assert (vec_v v00 == create4 o2 o3 o2 o3); let v10 = vec_add_mod o v00 in FStar.Math.Lemmas.modulo_lemma (v o0 + v o2) (pow2 64); FStar.Math.Lemmas.modulo_lemma (v o1 + v o3) (pow2 64); assert (v (vec_v v10).[0] == v o0 + v o2); assert (v (vec_v v10).[1] == v o1 + v o3); let v10h = vec_interleave_high v10 v10 in vec_interleave_high_lemma_uint64_4 v10 v10; assert (v (vec_v v10h).[0] == v (vec_v v10).[1]); let v20 = vec_add_mod v10 v10h in FStar.Math.Lemmas.modulo_lemma (v o0 + v o2 + v o1 + v o3) (pow2 64) val lemma_fmul_r4_normalize51_expand: v2:felem5 4 -> out:felem5 4 -> Lemma (requires (let (v20, v21, v22, v23, v24) = v2 in let (o0, o1, o2, o3, o4) = out in (uint64xN_v v20).[0] == (uint64xN_v o0).[0] + (uint64xN_v o0).[1] + (uint64xN_v o0).[2] + (uint64xN_v o0).[3] /\ (uint64xN_v v21).[0] == (uint64xN_v o1).[0] + (uint64xN_v o1).[1] + (uint64xN_v o1).[2] + (uint64xN_v o1).[3] /\ (uint64xN_v v22).[0] == (uint64xN_v o2).[0] + (uint64xN_v o2).[1] + (uint64xN_v o2).[2] + (uint64xN_v o2).[3] /\ (uint64xN_v v23).[0] == (uint64xN_v o3).[0] + (uint64xN_v o3).[1] + (uint64xN_v o3).[2] + (uint64xN_v o3).[3] /\ (uint64xN_v v24).[0] == (uint64xN_v o4).[0] + (uint64xN_v o4).[1] + (uint64xN_v o4).[2] + (uint64xN_v o4).[3])) (ensures (let (v20, v21, v22, v23, v24) = v2 in let (o0, o1, o2, o3, o4) = out in (feval5 v2).[0] == Vec.pfadd (Vec.pfadd (Vec.pfadd (feval5 out).[0] (feval5 out).[1]) (feval5 out).[2]) (feval5 out).[3])) let lemma_fmul_r4_normalize51_expand v2 out = let (v20, v21, v22, v23, v24) = as_tup64_i v2 0 in let (o0, o1, o2, o3, o4) = out in calc (==) { as_nat5 (v20, v21, v22, v23, v24) % Vec.prime; (==) { } (as_nat5 (as_tup64_i out 0) + as_nat5 (as_tup64_i out 1) + as_nat5 (as_tup64_i out 2) + as_nat5 (as_tup64_i out 3)) % Vec.prime; (==) { FStar.Math.Lemmas.lemma_mod_plus_distr_l (as_nat5 (as_tup64_i out 0) + as_nat5 (as_tup64_i out 1)) (as_nat5 (as_tup64_i out 2) + as_nat5 (as_tup64_i out 3)) Vec.prime } ((as_nat5 (as_tup64_i out 0) + as_nat5 (as_tup64_i out 1)) % Vec.prime + as_nat5 (as_tup64_i out 2) + as_nat5 (as_tup64_i out 3)) % Vec.prime; (==) { FStar.Math.Lemmas.modulo_distributivity (as_nat5 (as_tup64_i out 0)) (as_nat5 (as_tup64_i out 1)) Vec.prime } (((feval5 out).[0] + (feval5 out).[1]) % Vec.prime + as_nat5 (as_tup64_i out 2) + as_nat5 (as_tup64_i out 3)) % Vec.prime; (==) { FStar.Math.Lemmas.lemma_mod_plus_distr_l (((feval5 out).[0] + (feval5 out).[1]) % Vec.prime + as_nat5 (as_tup64_i out 2)) (as_nat5 (as_tup64_i out 3)) Vec.prime } ((((feval5 out).[0] + (feval5 out).[1]) % Vec.prime + as_nat5 (as_tup64_i out 2)) % Vec.prime + as_nat5 (as_tup64_i out 3)) % Vec.prime; (==) { FStar.Math.Lemmas.lemma_mod_plus_distr_r (((feval5 out).[0] + (feval5 out).[1]) % Vec.prime) (as_nat5 (as_tup64_i out 2)) Vec.prime } ((((feval5 out).[0] + (feval5 out).[1]) % Vec.prime + (feval5 out).[2]) % Vec.prime + as_nat5 (as_tup64_i out 3)) % Vec.prime; (==) { FStar.Math.Lemmas.lemma_mod_plus_distr_r ((((feval5 out).[0] + (feval5 out).[1]) % Vec.prime + (feval5 out).[2]) % Vec.prime) (as_nat5 (as_tup64_i out 3)) Vec.prime } ((((feval5 out).[0] + (feval5 out).[1]) % Vec.prime + (feval5 out).[2]) % Vec.prime + (feval5 out).[3]) % Vec.prime; }; assert ((feval5 v2).[0] == ((((feval5 out).[0] + (feval5 out).[1]) % Vec.prime + (feval5 out).[2]) % Vec.prime + (feval5 out).[3]) % Vec.prime) val fmul_r4_normalize51: a:felem5 4 -> Pure (felem5 4) (requires felem_fits5 a (1, 2, 1, 1, 2)) (ensures fun res -> felem_fits5 res (4, 8, 4, 4, 8) /\ (feval5 res).[0] == Vec.pfadd (Vec.pfadd (Vec.pfadd (feval5 a).[0] (feval5 a).[1]) (feval5 a).[2]) (feval5 a).[3]) let fmul_r4_normalize51 fa = let (o0, o1, o2, o3, o4) = fa in let v00 = vec_interleave_high_n 2 o0 o0 in let v10 = vec_add_mod o0 v00 in let v10h = vec_interleave_high v10 v10 in let v20 = vec_add_mod v10 v10h in lemma_fmul_r4_normalize51 #1 o0; let v01 = vec_interleave_high_n 2 o1 o1 in let v11 = vec_add_mod o1 v01 in let v11h = vec_interleave_high v11 v11 in let v21 = vec_add_mod v11 v11h in lemma_fmul_r4_normalize51 #2 o1; let v02 = vec_interleave_high_n 2 o2 o2 in let v12 = vec_add_mod o2 v02 in let v12h = vec_interleave_high v12 v12 in let v22 = vec_add_mod v12 v12h in lemma_fmul_r4_normalize51 #1 o2; let v03 = vec_interleave_high_n 2 o3 o3 in let v13 = vec_add_mod o3 v03 in let v13h = vec_interleave_high v13 v13 in let v23 = vec_add_mod v13 v13h in lemma_fmul_r4_normalize51 #1 o3; let v04 = vec_interleave_high_n 2 o4 o4 in let v14 = vec_add_mod o4 v04 in let v14h = vec_interleave_high v14 v14 in let v24 = vec_add_mod v14 v14h in lemma_fmul_r4_normalize51 #2 o4; let res = (v20, v21, v22, v23, v24) in lemma_fmul_r4_normalize51_expand res fa; res val fmul_r4_normalize5_lemma: acc:felem5 4 -> r:felem5 4 -> r_5:felem5 4 -> r4:felem5 4 -> Lemma (requires felem_fits5 acc (3, 3, 3, 3, 3) /\ felem_fits5 r (1, 1, 1, 1, 1) /\ felem_fits5 r4 (2, 2, 2, 2, 2) /\ r_5 == precomp_r5 r /\ feval5 r4 == Vec.compute_r4 (feval5 r).[0]) (ensures (let out = fmul_r4_normalize5 acc r r_5 r4 in felem_fits5 out (2, 1, 1, 1, 1) /\ (feval5 out).[0] == Vec.normalize_4 (feval5 r).[0] (feval5 acc))) [SMTPat (fmul_r4_normalize5 acc r r_5 r4)] #restart-solver #push-options "--z3rlimit 500" let fmul_r4_normalize5_lemma acc fr fr_5 fr4 = let fr2 = fmul_r5 #4 fr fr fr_5 in let fr3 = fmul_r5 #4 fr2 fr fr_5 in let out = fmul_r4_normalize50 acc fr fr2 fr3 fr4 in let v2 = fmul_r4_normalize51 out in let res = carry_full_felem5 v2 in carry_full_felem5_lemma v2 #pop-options val load_felem5_lemma: #w:lanes -> lo:uint64xN w -> hi:uint64xN w -> Lemma (let f = load_felem5 #w lo hi in felem_fits5 f (1, 1, 1, 1, 1) /\ felem_less5 f (pow2 128) /\ feval5 f == createi #Vec.pfelem w (fun i -> (uint64xN_v hi).[i] * pow2 64 + (uint64xN_v lo).[i])) let load_felem5_lemma #w lo hi = let f = load_felem5 #w lo hi in assert_norm (pow2 64 * pow2 64 = pow2 128); assert_norm (pow2 128 < Vec.prime); let res = createi #Vec.pfelem w (fun i -> (uint64xN_v hi).[i] * pow2 64 + (uint64xN_v lo).[i]) in match w with | 1 -> load_felem5_lemma_i #w lo hi 0; eq_intro (feval5 f) res | 2 -> load_felem5_lemma_i #w lo hi 0; load_felem5_lemma_i #w lo hi 1; eq_intro (feval5 f) res | 4 -> load_felem5_lemma_i #w lo hi 0; load_felem5_lemma_i #w lo hi 1; load_felem5_lemma_i #w lo hi 2; load_felem5_lemma_i #w lo hi 3; eq_intro (feval5 f) res val load_felem5_4_interleave: lo:uint64xN 4 -> hi:uint64xN 4 -> Lemma (let m0 = vec_interleave_low_n 2 lo hi in let m1 = vec_interleave_high_n 2 lo hi in let m2 = cast U64 4 (vec_shift_right (cast U128 2 m0) 48ul) in let m3 = cast U64 4 (vec_shift_right (cast U128 2 m1) 48ul) in let m4 = vec_interleave_high m0 m1 in let t0 = vec_interleave_low m0 m1 in let t3 = vec_interleave_low m2 m3 in vec_v m4 == create4 (vec_v lo).[1] (vec_v lo).[3] (vec_v hi).[1] (vec_v hi).[3] /\ vec_v t0 == create4 (vec_v lo).[0] (vec_v lo).[2] (vec_v hi).[0] (vec_v hi).[2] /\ t3 == vec_or (vec_shift_right t0 48ul) (vec_shift_left m4 16ul)) let load_felem5_4_interleave lo hi = let m0 = vec_interleave_low_n 2 lo hi in vec_interleave_low_n_lemma_uint64_4_2 lo hi; //assert (vec_v m0 == create4 (vec_v lo).[0] (vec_v lo).[1] (vec_v hi).[0] (vec_v hi).[1]); let m1 = vec_interleave_high_n 2 lo hi in vec_interleave_high_n_lemma_uint64_4_2 lo hi; //assert (vec_v m1 == create4 (vec_v lo).[2] (vec_v lo).[3] (vec_v hi).[2] (vec_v hi).[3]); let m4 = vec_interleave_high m0 m1 in vec_interleave_high_lemma_uint64_4 m0 m1; //assert (vec_v m4 == create4 (vec_v m0).[1] (vec_v m1).[1] (vec_v m0).[3] (vec_v m1).[3]); assert (vec_v m4 == create4 (vec_v lo).[1] (vec_v lo).[3] (vec_v hi).[1] (vec_v hi).[3]); let t0 = vec_interleave_low m0 m1 in vec_interleave_low_lemma_uint64_4 m0 m1; //assert (vec_v t0 == create4 (vec_v m0).[0] (vec_v m1).[0] (vec_v m0).[2] (vec_v m1).[2]); assert (vec_v t0 == create4 (vec_v lo).[0] (vec_v lo).[2] (vec_v hi).[0] (vec_v hi).[2]); let m2 = cast U64 4 (vec_shift_right (cast U128 2 m0) 48ul) in vec_shift_right_uint128_small2 m0 48ul; assert ((vec_v m2).[0] == (((vec_v lo).[0] >>. 48ul) |. ((vec_v lo).[1] <<. 16ul))); assert ((vec_v m2).[2] == (((vec_v hi).[0] >>. 48ul) |. ((vec_v hi).[1] <<. 16ul))); let m3 = cast U64 4 (vec_shift_right (cast U128 2 m1) 48ul) in vec_shift_right_uint128_small2 m1 48ul; assert ((vec_v m3).[0] == (((vec_v lo).[2] >>. 48ul) |. ((vec_v lo).[3] <<. 16ul))); assert ((vec_v m3).[2] == (((vec_v hi).[2] >>. 48ul) |. ((vec_v hi).[3] <<. 16ul))); let t3 = vec_interleave_low m2 m3 in vec_interleave_low_lemma_uint64_4 m2 m3; eq_intro (vec_v t3) (vec_v (vec_or (vec_shift_right t0 48ul) (vec_shift_left m4 16ul))); vecv_extensionality t3 (vec_or (vec_shift_right t0 48ul) (vec_shift_left m4 16ul)) noextract val load_felem5_4_compact: lo:uint64xN 4 -> hi:uint64xN 4 -> felem5 4 let load_felem5_4_compact lo hi = let mask26 = mask26 4 in let t3 = vec_or (vec_shift_right lo 48ul) (vec_shift_left hi 16ul) in let o0 = vec_and lo mask26 in let o1 = vec_and (vec_shift_right lo 26ul) mask26 in let o2 = vec_and (vec_shift_right t3 4ul) mask26 in let o3 = vec_and (vec_shift_right t3 30ul) mask26 in let o4 = vec_shift_right hi 40ul in (o0, o1, o2, o3, o4) val load_felem5_4_compact_lemma_i: lo:uint64xN 4 -> hi:uint64xN 4 -> i:nat{i < 4} -> Lemma (let f = as_tup64_i (load_felem5_4_compact lo hi) i in tup64_fits5 f (1, 1, 1, 1, 1) /\ as_nat5 f < pow2 128 /\ as_nat5 f % Vec.prime == (uint64xN_v hi).[i] * pow2 64 + (uint64xN_v lo).[i]) let load_felem5_4_compact_lemma_i lo hi i = assert (as_tup64_i (load_felem5_4_compact lo hi) i == load_tup64_4_compact (vec_v lo).[i] (vec_v hi).[i]); load_tup64_4_compact_lemma (vec_v lo).[i] (vec_v hi).[i] val load_felem5_4_lemma: lo:uint64xN 4 -> hi:uint64xN 4 -> Lemma (let f = load_felem5_4_compact lo hi in felem_fits5 f (1, 1, 1, 1, 1) /\ felem_less5 f (pow2 128) /\ feval5 f == createi #Vec.pfelem 4 (fun i -> (uint64xN_v hi).[i] * pow2 64 + (uint64xN_v lo).[i])) let load_felem5_4_lemma lo hi = let f = load_felem5_4_compact lo hi in assert_norm (pow2 64 * pow2 64 = pow2 128); assert_norm (pow2 128 < Vec.prime); let res = createi #Vec.pfelem 4 (fun i -> (uint64xN_v hi).[i] * pow2 64 + (uint64xN_v lo).[i]) in load_felem5_4_compact_lemma_i lo hi 0; load_felem5_4_compact_lemma_i lo hi 1; load_felem5_4_compact_lemma_i lo hi 2; load_felem5_4_compact_lemma_i lo hi 3; eq_intro (feval5 f) res val load_felem5_le: b:lseq uint8 64 -> Lemma (let lo0 = vec_from_bytes_le U64 4 (sub b 0 32) in let hi0 = vec_from_bytes_le U64 4 (sub b 32 32) in let f = load_felem5_4 lo0 hi0 in felem_fits5 f (1, 1, 1, 1, 1) /\ felem_less5 f (pow2 128) /\ feval5 f == Vec.load_elem4 b) let load_felem5_le b = let lo0 = vec_from_bytes_le U64 4 (sub b 0 32) in let hi0 = vec_from_bytes_le U64 4 (sub b 32 32) in let lo1 = vec_interleave_low_n 2 lo0 hi0 in let hi1 = vec_interleave_high_n 2 lo0 hi0 in let lo = vec_interleave_low lo1 hi1 in let hi = vec_interleave_high lo1 hi1 in let out = load_felem5_4_compact lo hi in load_felem5_4_interleave lo0 hi0; assert (out == load_felem5_4 lo0 hi0); load_felem5_4_lemma lo hi; Hacl.Impl.Poly1305.Lemmas.uints_from_bytes_le_lemma64_4 b; eq_intro (feval5 out) (Vec.load_elem4 b) val load_acc5_2_lemma: f:felem5 2{felem_fits5 f (2, 2, 2, 2, 2)} -> e:felem5 2{felem_fits5 e (1, 1, 1, 1, 1)} -> Lemma (let res = load_acc5_2 f e in felem_fits5 res (3, 3, 3, 3, 3) /\ feval5 res == Vec.fadd (create2 (feval5 f).[0] 0) (feval5 e)) [SMTPat (load_acc5_2 f e)] let load_acc5_2_lemma f e = let (f0, f1, f2, f3, f4) = f in let r0 = vec_set f0 1ul (u64 0) in let r1 = vec_set f1 1ul (u64 0) in let r2 = vec_set f2 1ul (u64 0) in let r3 = vec_set f3 1ul (u64 0) in let r4 = vec_set f4 1ul (u64 0) in let r = (r0, r1, r2, r3, r4) in //assert ((feval5 r).[0] == (feval5 f).[0]); assert ((feval5 r).[1] == 0); eq_intro (feval5 r) (create2 (feval5 f).[0] 0) val load_acc5_4_lemma: f:felem5 4{felem_fits5 f (2, 2, 2, 2, 2)} -> e:felem5 4{felem_fits5 e (1, 1, 1, 1, 1)} -> Lemma (let res = load_acc5_4 f e in felem_fits5 res (3, 3, 3, 3, 3) /\ feval5 res == Vec.fadd (create4 (feval5 f).[0] 0 0 0) (feval5 e)) [SMTPat (load_acc5_4 f e)] let load_acc5_4_lemma f e = let (f0, f1, f2, f3, f4) = f in let (r0, r1, r2, r3, r4) = (zero 4, zero 4, zero 4, zero 4, zero 4) in let r = (r0, r1, r2, r3, r4) in assert ((feval5 r).[1] == 0); assert ((feval5 r).[2] == 0); assert ((feval5 r).[3] == 0); let r0 = vec_set r0 0ul (vec_get f0 0ul) in let r1 = vec_set r1 0ul (vec_get f1 0ul) in let r2 = vec_set r2 0ul (vec_get f2 0ul) in let r3 = vec_set r3 0ul (vec_get f3 0ul) in let r4 = vec_set r4 0ul (vec_get f4 0ul) in let r = (r0, r1, r2, r3, r4) in assert ((feval5 r).[0] == (feval5 f).[0]); assert ((feval5 r).[1] == 0); assert ((feval5 r).[2] == 0); assert ((feval5 r).[3] == 0); eq_intro (feval5 r) (create4 (feval5 f).[0] 0 0 0) val store_felem5_lemma: #w:lanes -> f:felem5 w{felem_fits5 f (1, 1, 1, 1, 1)} -> Lemma (let (lo, hi) = store_felem5 f in v hi * pow2 64 + v lo == (fas_nat5 f).[0] % pow2 128) [SMTPat (store_felem5 f)] let store_felem5_lemma #w f = store_felem5_lemma #w f val set_bit5_lemma: #w:lanes -> f:lseq (uint64xN w) 5 -> i:size_nat{i <= 128} -> Lemma (requires lfelem_fits f (1, 1, 1, 1, 1) /\ lfelem_less f (pow2 i)) (ensures lfelem_fits (set_bit5 f i) (1, 1, 1, 1, 1) /\ lfeval (set_bit5 f i) == map (Vec.pfadd (pow2 i)) (lfeval f))

{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "Lib.Sequence.fsti.checked", "Lib.IntVector.fsti.checked", "Lib.IntTypes.fsti.checked", "Hacl.Spec.Poly1305.Vec.fst.checked", "Hacl.Spec.Poly1305.Field32xN.fst.checked", "Hacl.Poly1305.Field32xN.Lemmas2.fst.checked", "Hacl.Poly1305.Field32xN.Lemmas1.fst.checked", "Hacl.Poly1305.Field32xN.Lemmas0.fst.checked", "Hacl.Impl.Poly1305.Lemmas.fst.checked", "FStar.UInt32.fsti.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Mul.fst.checked", "FStar.Math.Lemmas.fst.checked", "FStar.Classical.fsti.checked", "FStar.Calc.fsti.checked" ], "interface_file": false, "source_file": "Hacl.Spec.Poly1305.Field32xN.Lemmas.fst" }

[ { "abbrev": true, "full_module": "Hacl.Spec.Poly1305.Vec", "short_module": "Vec" }, { "abbrev": false, "full_module": "Hacl.Poly1305.Field32xN.Lemmas2", "short_module": null }, { "abbrev": false, "full_module": "Hacl.Poly1305.Field32xN.Lemmas1", "short_module": null }, { "abbrev": false, "full_module": "Hacl.Poly1305.Field32xN.Lemmas0", "short_module": null }, { "abbrev": false, "full_module": "Hacl.Spec.Poly1305.Field32xN", "short_module": null }, { "abbrev": false, "full_module": "FStar.Mul", "short_module": null }, { "abbrev": false, "full_module": "Lib.Sequence", "short_module": null }, { "abbrev": false, "full_module": "Lib.IntVector", "short_module": null }, { "abbrev": false, "full_module": "Lib.IntTypes", "short_module": null }, { "abbrev": false, "full_module": "Hacl.Spec.Poly1305.Field32xN", "short_module": null }, { "abbrev": false, "full_module": "Hacl.Spec.Poly1305.Field32xN", "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": 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": 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": 100, "z3rlimit_factor": 1, "z3seed": 0, "z3smtopt": [], "z3version": "4.8.5" }

false

f: Lib.Sequence.lseq (Hacl.Spec.Poly1305.Field32xN.uint64xN w) 5 -> i: Lib.IntTypes.size_nat{i <= 128} -> FStar.Pervasives.Lemma (requires Hacl.Spec.Poly1305.Field32xN.lfelem_fits f (1, 1, 1, 1, 1) /\ Hacl.Spec.Poly1305.Field32xN.lfelem_less f (Prims.pow2 i)) (ensures Hacl.Spec.Poly1305.Field32xN.lfelem_fits (Hacl.Spec.Poly1305.Field32xN.set_bit5 f i) (1, 1, 1, 1, 1) /\ Hacl.Spec.Poly1305.Field32xN.lfeval (Hacl.Spec.Poly1305.Field32xN.set_bit5 f i) == Lib.Sequence.map (Hacl.Spec.Poly1305.Vec.pfadd (Prims.pow2 i)) (Hacl.Spec.Poly1305.Field32xN.lfeval f))

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Hacl.Spec.Poly1305.Field32xN.lanes", "Lib.Sequence.lseq", "Hacl.Spec.Poly1305.Field32xN.uint64xN", "Lib.IntTypes.size_nat", "Prims.b2t", "Prims.op_LessThanOrEqual", "Lib.Sequence.eq_intro", "Hacl.Spec.Poly1305.Vec.pfelem", "Hacl.Spec.Poly1305.Field32xN.lfeval", "Hacl.Spec.Poly1305.Field32xN.set_bit5", "Prims.unit", "Hacl.Poly1305.Field32xN.Lemmas2.set_bit5_lemma_k", "Prims.l_Forall", "Prims.nat", "Prims.l_imp", "Prims.op_LessThan", "Prims.eq2", "Lib.Sequence.index", "Hacl.Spec.Poly1305.Vec.pfadd", "Prims.pow2", "Lib.Sequence.map" ]

[]

false

true

false

let set_bit5_lemma #w f i =

let tmp = map (Vec.pfadd (pow2 i)) (lfeval f) in match w with | 1 -> set_bit5_lemma_k #w f i 0; eq_intro (lfeval (set_bit5 f i)) tmp | 2 -> set_bit5_lemma_k #w f i 0; set_bit5_lemma_k #w f i 1; eq_intro (lfeval (set_bit5 f i)) tmp | 4 -> set_bit5_lemma_k #w f i 0; set_bit5_lemma_k #w f i 1; set_bit5_lemma_k #w f i 2; set_bit5_lemma_k #w f i 3; eq_intro (lfeval (set_bit5 f i)) tmp

false

FStar.Pointer.Derived3.fst

FStar.Pointer.Derived3.fill_buffer_init

val fill_buffer_init (#t: typ) (b: buffer t) (* destination *) (v: type_of_typ t) (h: HS.mem) : Lemma (requires (fill_buffer_precond' b h)) (ensures (fill_buffer_inv b 0ul v h h))

let fill_buffer_init #t b v h = buffer_readable_intro_empty h (gsub_buffer b 0ul 0ul); Seq.lemma_eq_intro (buffer_as_seq h (gsub_buffer b 0ul 0ul)) (Seq.create 0 v)

{ "file_name": "ulib/legacy/FStar.Pointer.Derived3.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }

{ "end_col": 79, "end_line": 70, "start_col": 0, "start_line": 68 }

(* Copyright 2008-2018 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 FStar.Pointer.Derived3 module HH = FStar.HyperStack module HS = FStar.HyperStack module HST = FStar.HyperStack.ST private let fill_buffer_precond' (#t: typ) (b: buffer t) (* destination *) (h: HS.mem) : GTot Type0 = buffer_live h b private let fill_buffer_postcond' (#t: typ) (b: buffer t) (* destination *) (v: type_of_typ t) (h: HS.mem) (h' : HS.mem) : GTot Type0 = fill_buffer_precond' b h /\ modifies (loc_buffer b) h h' /\ buffer_readable h' b /\ buffer_as_seq h' b == Seq.create (UInt32.v (buffer_length b)) v private let fill_buffer_inv (#t: typ) (b: buffer t) (* destination *) (len' : UInt32.t) (v: type_of_typ t) (h: HS.mem) (h' : HS.mem) : GTot Type0 = fill_buffer_precond' b h /\ modifies (loc_buffer b) h h' /\ UInt32.v len' <= UInt32.v (buffer_length b) /\ buffer_readable h' (gsub_buffer b 0ul len') /\ buffer_as_seq h' (gsub_buffer b 0ul len') == Seq.create (UInt32.v len') v private val fill_buffer_init (#t: typ) (b: buffer t) (* destination *) (v: type_of_typ t) (h: HS.mem) : Lemma (requires (fill_buffer_precond' b h)) (ensures (fill_buffer_inv b 0ul v h h))

{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.UInt32.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Ghost.fsti.checked" ], "interface_file": true, "source_file": "FStar.Pointer.Derived3.fst" }

[ { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HH" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HH" }, { "abbrev": false, "full_module": "FStar.Pointer.Derived1", "short_module": null }, { "abbrev": false, "full_module": "FStar.Pointer.Base", "short_module": null }, { "abbrev": false, "full_module": "FStar.Pointer", "short_module": null }, { "abbrev": false, "full_module": "FStar.Pointer", "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

b: FStar.Pointer.Base.buffer t -> v: FStar.Pointer.Base.type_of_typ t -> h: FStar.Monotonic.HyperStack.mem -> FStar.Pervasives.Lemma (requires FStar.Pointer.Derived3.fill_buffer_precond' b h) (ensures FStar.Pointer.Derived3.fill_buffer_inv b 0ul v h h)

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "FStar.Pointer.Base.typ", "FStar.Pointer.Base.buffer", "FStar.Pointer.Base.type_of_typ", "FStar.Monotonic.HyperStack.mem", "FStar.Seq.Base.lemma_eq_intro", "FStar.Pointer.Base.buffer_as_seq", "FStar.Pointer.Base.gsub_buffer", "FStar.UInt32.__uint_to_t", "FStar.Seq.Base.create", "Prims.unit", "FStar.Pointer.Derived1.buffer_readable_intro_empty" ]

[]

true

false

true

false

let fill_buffer_init #t b v h =

buffer_readable_intro_empty h (gsub_buffer b 0ul 0ul); Seq.lemma_eq_intro (buffer_as_seq h (gsub_buffer b 0ul 0ul)) (Seq.create 0 v)

false

FStar.Pointer.Derived3.fst

FStar.Pointer.Derived3.fill_buffer_aux

val fill_buffer_aux (#t: typ) (b: buffer t) (* destination *) (len: UInt32.t) (len': UInt32.t) (v: type_of_typ t) (h: Ghost.erased HS.mem) : HST.Stack unit (requires (fun h0 -> fill_buffer_inv b len' v (Ghost.reveal h) h0 /\ len == buffer_length b )) (ensures (fun h0 _ h1 -> fill_buffer_inv b len' v (Ghost.reveal h) h0 /\ fill_buffer_postcond' b v (Ghost.reveal h) h1 )) (decreases (UInt32.v (buffer_length b) - UInt32.v len'))

let rec fill_buffer_aux #t b len len' v h = if len = len' then () else begin fill_buffer_advance b len' v h; fill_buffer_aux b len (UInt32.add len' 1ul) v h end

{ "file_name": "ulib/legacy/FStar.Pointer.Derived3.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }

{ "end_col": 5, "end_line": 121, "start_col": 0, "start_line": 115 }

(* Copyright 2008-2018 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 FStar.Pointer.Derived3 module HH = FStar.HyperStack module HS = FStar.HyperStack module HST = FStar.HyperStack.ST private let fill_buffer_precond' (#t: typ) (b: buffer t) (* destination *) (h: HS.mem) : GTot Type0 = buffer_live h b private let fill_buffer_postcond' (#t: typ) (b: buffer t) (* destination *) (v: type_of_typ t) (h: HS.mem) (h' : HS.mem) : GTot Type0 = fill_buffer_precond' b h /\ modifies (loc_buffer b) h h' /\ buffer_readable h' b /\ buffer_as_seq h' b == Seq.create (UInt32.v (buffer_length b)) v private let fill_buffer_inv (#t: typ) (b: buffer t) (* destination *) (len' : UInt32.t) (v: type_of_typ t) (h: HS.mem) (h' : HS.mem) : GTot Type0 = fill_buffer_precond' b h /\ modifies (loc_buffer b) h h' /\ UInt32.v len' <= UInt32.v (buffer_length b) /\ buffer_readable h' (gsub_buffer b 0ul len') /\ buffer_as_seq h' (gsub_buffer b 0ul len') == Seq.create (UInt32.v len') v private val fill_buffer_init (#t: typ) (b: buffer t) (* destination *) (v: type_of_typ t) (h: HS.mem) : Lemma (requires (fill_buffer_precond' b h)) (ensures (fill_buffer_inv b 0ul v h h)) let fill_buffer_init #t b v h = buffer_readable_intro_empty h (gsub_buffer b 0ul 0ul); Seq.lemma_eq_intro (buffer_as_seq h (gsub_buffer b 0ul 0ul)) (Seq.create 0 v) private val fill_buffer_advance (#t: typ) (b: buffer t) (* destination *) (len' : UInt32.t) (v: type_of_typ t) (h: Ghost.erased HS.mem) : HST.Stack unit (requires (fun h0 -> fill_buffer_inv b len' v (Ghost.reveal h) h0 /\ UInt32.v len' < UInt32.v (buffer_length b) )) (ensures (fun h1 _ h2 -> fill_buffer_inv b len' v (Ghost.reveal h) h1 /\ UInt32.v len' < UInt32.v (buffer_length b) /\ fill_buffer_inv b (UInt32.add len' 1ul) v (Ghost.reveal h) h2 )) #set-options "--z3rlimit 16" let fill_buffer_advance #t b len' v h = buffer_snoc b 0ul len' v; Seq.lemma_eq_intro (Seq.snoc (Seq.create (UInt32.v len') v) v) (Seq.create (UInt32.v (UInt32.add len' 1ul)) v) private val fill_buffer_aux (#t: typ) (b: buffer t) (* destination *) (len: UInt32.t) (len': UInt32.t) (v: type_of_typ t) (h: Ghost.erased HS.mem) : HST.Stack unit (requires (fun h0 -> fill_buffer_inv b len' v (Ghost.reveal h) h0 /\ len == buffer_length b )) (ensures (fun h0 _ h1 -> fill_buffer_inv b len' v (Ghost.reveal h) h0 /\ fill_buffer_postcond' b v (Ghost.reveal h) h1 )) (decreases (UInt32.v (buffer_length b) - UInt32.v len'))

{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.UInt32.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Ghost.fsti.checked" ], "interface_file": true, "source_file": "FStar.Pointer.Derived3.fst" }

[ { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HH" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HH" }, { "abbrev": false, "full_module": "FStar.Pointer.Derived1", "short_module": null }, { "abbrev": false, "full_module": "FStar.Pointer.Base", "short_module": null }, { "abbrev": false, "full_module": "FStar.Pointer", "short_module": null }, { "abbrev": false, "full_module": "FStar.Pointer", "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": 16, "z3rlimit_factor": 1, "z3seed": 0, "z3smtopt": [], "z3version": "4.8.5" }

false

b: FStar.Pointer.Base.buffer t -> len: FStar.UInt32.t -> len': FStar.UInt32.t -> v: FStar.Pointer.Base.type_of_typ t -> h: FStar.Ghost.erased FStar.Monotonic.HyperStack.mem -> FStar.HyperStack.ST.Stack Prims.unit

FStar.HyperStack.ST.Stack

[ "" ]

[]

[ "FStar.Pointer.Base.typ", "FStar.Pointer.Base.buffer", "FStar.UInt32.t", "FStar.Pointer.Base.type_of_typ", "FStar.Ghost.erased", "FStar.Monotonic.HyperStack.mem", "Prims.op_Equality", "Prims.unit", "Prims.bool", "FStar.Pointer.Derived3.fill_buffer_aux", "FStar.UInt32.add", "FStar.UInt32.__uint_to_t", "FStar.Pointer.Derived3.fill_buffer_advance" ]

[ "recursion" ]

false

true

false

let rec fill_buffer_aux #t b len len' v h =

if len = len' then () else (fill_buffer_advance b len' v h; fill_buffer_aux b len (UInt32.add len' 1ul) v h)

false

Hacl.Spec.K256.PrecompTable.fst

Hacl.Spec.K256.PrecompTable.proj_point_to_list_eval

val proj_point_to_list_eval: p:S.proj_point -> Lemma (point_eval_list (proj_point_to_list p) == p)

let proj_point_to_list_eval p = let (px, py, pz) = p in proj_point_to_list_sub p; felem_to_list_lemma_eval px; felem_to_list_lemma_eval py; felem_to_list_lemma_eval pz; Math.Lemmas.small_mod px S.prime; Math.Lemmas.small_mod py S.prime; Math.Lemmas.small_mod pz S.prime

{ "file_name": "code/k256/Hacl.Spec.K256.PrecompTable.fst", "git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872", "git_url": "https://github.com/project-everest/hacl-star.git", "project_name": "hacl-star" }

{ "end_col": 34, "end_line": 168, "start_col": 0, "start_line": 160 }

module Hacl.Spec.K256.PrecompTable open FStar.Mul open Lib.IntTypes open Lib.Sequence open Hacl.Spec.K256.Field52.Definitions open Hacl.Impl.K256.Point module S = Spec.K256 module FL = FStar.List.Tot module SPT = Hacl.Spec.PrecompBaseTable #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" let create5_lseq (x0 x1 x2 x3 x4:uint64) : lseq uint64 5 = let l = [x0; x1; x2; x3; x4] in assert_norm (FL.length l = 5); Seq.seq_of_list l val create5_lemma (x0 x1 x2 x3 x4:uint64) : Lemma (let s = create5_lseq x0 x1 x2 x3 x4 in s.[0] == x0 /\ s.[1] == x1 /\ s.[2] == x2 /\ s.[3] == x3 /\ s.[4] == x4) let create5_lemma x0 x1 x2 x3 x4 = Seq.elim_of_list [x0; x1; x2; x3; x4] //----------------------------------- noextract let list_as_felem5 (f:felem_list) : felem5 = let x = Seq.seq_of_list f <: lseq uint64 5 in as_felem5_lseq x val felem_to_list_index_lemma: x:S.felem -> Lemma (let (f0, f1, f2, f3, f4) = list_as_felem5 (felem_to_list x) in let x0 = x % pow52 in let x1 = x / pow52 % pow52 in let x2 = x / pow104 % pow52 in let x3 = x / pow156 % pow52 in let x4 = x / pow208 in v f0 == x0 /\ v f1 == x1 /\ v f2 == x2 /\ v f3 == x3 /\ v f4 == x4) let felem_to_list_index_lemma x = let x0 = x % pow52 in let x1 = x / pow52 % pow52 in let x2 = x / pow104 % pow52 in let x3 = x / pow156 % pow52 in let x4 = x / pow208 in let f = felem_to_list x in let (f0, f1, f2, f3, f4) = list_as_felem5 f in create5_lemma (u64 x0) (u64 x1) (u64 x2) (u64 x3) (u64 x4); assert (v f0 == x0 /\ v f1 == x1 /\ v f2 == x2 /\ v f3 == x3 /\ v f4 == x4) val felem_to_list_lemma_fits: x:S.felem -> Lemma (felem_fits5 (list_as_felem5 (felem_to_list x)) (1, 1, 1, 1, 1)) let felem_to_list_lemma_fits x = felem_to_list_index_lemma x; let x0 = x % pow52 in let x1 = x / pow52 % pow52 in let x2 = x / pow104 % pow52 in let x3 = x / pow156 % pow52 in let x4 = x / pow208 in assert (felem_fits1 (u64 x0) 1); assert (felem_fits1 (u64 x1) 1); assert (felem_fits1 (u64 x2) 1); assert (felem_fits1 (u64 x3) 1); Math.Lemmas.lemma_div_lt_nat x 256 208; assert (felem_fits_last1 (u64 x4) 1) val lemma_mod_pow2_sub: x:nat -> a:nat -> b:nat -> Lemma (x / pow2 a % pow2 b * pow2 a == x % pow2 (a + b) - x % pow2 a) let lemma_mod_pow2_sub x a b = calc (==) { x / pow2 a % pow2 b * pow2 a; (==) { Math.Lemmas.pow2_modulo_division_lemma_1 x a (a + b) } x % pow2 (a + b) / pow2 a * pow2 a; (==) { Math.Lemmas.euclidean_division_definition (x % pow2 (a + b)) (pow2 a) } x % pow2 (a + b) - x % pow2 (a + b) % pow2 a; (==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 x a (a + b) } x % pow2 (a + b) - x % pow2 a; } val felem_to_list_lemma_eval: x:S.felem -> Lemma (as_nat5 (list_as_felem5 (felem_to_list x)) == x) let felem_to_list_lemma_eval x = felem_to_list_index_lemma x; let x0 = x % pow52 in let x1 = x / pow52 % pow52 in let x2 = x / pow104 % pow52 in let x3 = x / pow156 % pow52 in let x4 = x / pow208 in let (f0, f1, f2, f3, f4) = list_as_felem5 (felem_to_list x) in let nat_x = as_nat5 (f0, f1, f2, f3, f4) in assert (nat_x == x0 + x1 * pow52 + x2 * pow104 + x3 * pow156 + x4 * pow208); calc (==) { x0 + x1 * pow52 + x2 * pow104 + x3 * pow156 + x4 * pow208; (==) { } x0 + x1 * pow52 + x2 * pow104 + (x / pow156 % pow52) * pow156 + x / pow208 * pow208; (==) { lemma_mod_pow2_sub x 156 52 } x0 + x1 * pow52 + x2 * pow104 + x % pow208 - x % pow156 + x / pow208 * pow208; (==) { Math.Lemmas.euclidean_division_definition x pow208 } x0 + x1 * pow52 + (x / pow104 % pow52) * pow104 - x % pow156 + x; (==) { lemma_mod_pow2_sub x 104 52 } x0 + (x / pow52 % pow52) * pow52 - x % pow104 + x; (==) { lemma_mod_pow2_sub x 52 52 } x; } //-------------------------------------------- val proj_point_to_list_sub: p:S.proj_point -> Lemma (let (px, py, pz) = p in let px_list = felem_to_list px in let py_list = felem_to_list py in let pz_list = felem_to_list pz in let p_list = FL.(px_list @ py_list @ pz_list) in let p_lseq = Seq.seq_of_list p_list <: lseq uint64 15 in let px_lseq = Seq.seq_of_list px_list <: lseq uint64 5 in let py_lseq = Seq.seq_of_list py_list <: lseq uint64 5 in let pz_lseq = Seq.seq_of_list pz_list <: lseq uint64 5 in sub p_lseq 0 5 == px_lseq /\ sub p_lseq 5 5 == py_lseq /\ sub p_lseq 10 5 == pz_lseq) let proj_point_to_list_sub p = let (px, py, pz) = p in let px_list = felem_to_list px in let py_list = felem_to_list py in let pz_list = felem_to_list pz in FL.append_assoc px_list py_list pz_list; SPT.seq_of_list_append_lemma px_list py_list; SPT.seq_of_list_append_lemma FL.(px_list @ py_list) pz_list val proj_point_to_list_fits: p:S.proj_point -> Lemma (point_inv_list (proj_point_to_list p)) let proj_point_to_list_fits p = let (px, py, pz) = p in proj_point_to_list_sub p; felem_to_list_lemma_fits px; felem_to_list_lemma_fits py; felem_to_list_lemma_fits pz val proj_point_to_list_eval: p:S.proj_point -> Lemma (point_eval_list (proj_point_to_list p) == p)

{ "checked_file": "/", "dependencies": [ "Spec.K256.fst.checked", "prims.fst.checked", "Lib.Sequence.fsti.checked", "Lib.IntTypes.fsti.checked", "Hacl.Spec.PrecompBaseTable.fsti.checked", "Hacl.Spec.K256.Field52.Definitions.fst.checked", "Hacl.Impl.K256.Point.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Mul.fst.checked", "FStar.Math.Lemmas.fst.checked", "FStar.List.Tot.fst.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Hacl.Spec.K256.PrecompTable.fst" }

[ { "abbrev": true, "full_module": "Hacl.Spec.PrecompBaseTable", "short_module": "SPT" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "FL" }, { "abbrev": true, "full_module": "Spec.K256", "short_module": "S" }, { "abbrev": false, "full_module": "Hacl.Impl.K256.Point", "short_module": null }, { "abbrev": false, "full_module": "Hacl.Spec.K256.Field52.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": true, "full_module": "FStar.List.Tot", "short_module": "FL" }, { "abbrev": true, "full_module": "Spec.K256", "short_module": "S" }, { "abbrev": false, "full_module": "Hacl.Impl.K256.Point", "short_module": null }, { "abbrev": false, "full_module": "Hacl.Spec.K256.Field52.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.K256", "short_module": null }, { "abbrev": false, "full_module": "Hacl.Spec.K256", "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

p: Spec.K256.PointOps.proj_point -> FStar.Pervasives.Lemma (ensures Hacl.Spec.K256.PrecompTable.point_eval_list (Hacl.Spec.K256.PrecompTable.proj_point_to_list p) == p)

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Spec.K256.PointOps.proj_point", "Spec.K256.PointOps.felem", "FStar.Math.Lemmas.small_mod", "Spec.K256.PointOps.prime", "Prims.unit", "Hacl.Spec.K256.PrecompTable.felem_to_list_lemma_eval", "Hacl.Spec.K256.PrecompTable.proj_point_to_list_sub" ]

[]

false

true

false

let proj_point_to_list_eval p =

let px, py, pz = p in proj_point_to_list_sub p; felem_to_list_lemma_eval px; felem_to_list_lemma_eval py; felem_to_list_lemma_eval pz; Math.Lemmas.small_mod px S.prime; Math.Lemmas.small_mod py S.prime; Math.Lemmas.small_mod pz S.prime

false

Hacl.Spec.K256.PrecompTable.fst

Hacl.Spec.K256.PrecompTable.proj_point_to_list_lemma

val proj_point_to_list_lemma: p:S.proj_point -> Lemma (point_inv_list (proj_point_to_list p) /\ point_eval_list (proj_point_to_list p) == p)

let proj_point_to_list_lemma p = proj_point_to_list_fits p; proj_point_to_list_eval p

{ "file_name": "code/k256/Hacl.Spec.K256.PrecompTable.fst", "git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872", "git_url": "https://github.com/project-everest/hacl-star.git", "project_name": "hacl-star" }

{ "end_col": 27, "end_line": 173, "start_col": 0, "start_line": 171 }

module Hacl.Spec.K256.PrecompTable open FStar.Mul open Lib.IntTypes open Lib.Sequence open Hacl.Spec.K256.Field52.Definitions open Hacl.Impl.K256.Point module S = Spec.K256 module FL = FStar.List.Tot module SPT = Hacl.Spec.PrecompBaseTable #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" let create5_lseq (x0 x1 x2 x3 x4:uint64) : lseq uint64 5 = let l = [x0; x1; x2; x3; x4] in assert_norm (FL.length l = 5); Seq.seq_of_list l val create5_lemma (x0 x1 x2 x3 x4:uint64) : Lemma (let s = create5_lseq x0 x1 x2 x3 x4 in s.[0] == x0 /\ s.[1] == x1 /\ s.[2] == x2 /\ s.[3] == x3 /\ s.[4] == x4) let create5_lemma x0 x1 x2 x3 x4 = Seq.elim_of_list [x0; x1; x2; x3; x4] //----------------------------------- noextract let list_as_felem5 (f:felem_list) : felem5 = let x = Seq.seq_of_list f <: lseq uint64 5 in as_felem5_lseq x val felem_to_list_index_lemma: x:S.felem -> Lemma (let (f0, f1, f2, f3, f4) = list_as_felem5 (felem_to_list x) in let x0 = x % pow52 in let x1 = x / pow52 % pow52 in let x2 = x / pow104 % pow52 in let x3 = x / pow156 % pow52 in let x4 = x / pow208 in v f0 == x0 /\ v f1 == x1 /\ v f2 == x2 /\ v f3 == x3 /\ v f4 == x4) let felem_to_list_index_lemma x = let x0 = x % pow52 in let x1 = x / pow52 % pow52 in let x2 = x / pow104 % pow52 in let x3 = x / pow156 % pow52 in let x4 = x / pow208 in let f = felem_to_list x in let (f0, f1, f2, f3, f4) = list_as_felem5 f in create5_lemma (u64 x0) (u64 x1) (u64 x2) (u64 x3) (u64 x4); assert (v f0 == x0 /\ v f1 == x1 /\ v f2 == x2 /\ v f3 == x3 /\ v f4 == x4) val felem_to_list_lemma_fits: x:S.felem -> Lemma (felem_fits5 (list_as_felem5 (felem_to_list x)) (1, 1, 1, 1, 1)) let felem_to_list_lemma_fits x = felem_to_list_index_lemma x; let x0 = x % pow52 in let x1 = x / pow52 % pow52 in let x2 = x / pow104 % pow52 in let x3 = x / pow156 % pow52 in let x4 = x / pow208 in assert (felem_fits1 (u64 x0) 1); assert (felem_fits1 (u64 x1) 1); assert (felem_fits1 (u64 x2) 1); assert (felem_fits1 (u64 x3) 1); Math.Lemmas.lemma_div_lt_nat x 256 208; assert (felem_fits_last1 (u64 x4) 1) val lemma_mod_pow2_sub: x:nat -> a:nat -> b:nat -> Lemma (x / pow2 a % pow2 b * pow2 a == x % pow2 (a + b) - x % pow2 a) let lemma_mod_pow2_sub x a b = calc (==) { x / pow2 a % pow2 b * pow2 a; (==) { Math.Lemmas.pow2_modulo_division_lemma_1 x a (a + b) } x % pow2 (a + b) / pow2 a * pow2 a; (==) { Math.Lemmas.euclidean_division_definition (x % pow2 (a + b)) (pow2 a) } x % pow2 (a + b) - x % pow2 (a + b) % pow2 a; (==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 x a (a + b) } x % pow2 (a + b) - x % pow2 a; } val felem_to_list_lemma_eval: x:S.felem -> Lemma (as_nat5 (list_as_felem5 (felem_to_list x)) == x) let felem_to_list_lemma_eval x = felem_to_list_index_lemma x; let x0 = x % pow52 in let x1 = x / pow52 % pow52 in let x2 = x / pow104 % pow52 in let x3 = x / pow156 % pow52 in let x4 = x / pow208 in let (f0, f1, f2, f3, f4) = list_as_felem5 (felem_to_list x) in let nat_x = as_nat5 (f0, f1, f2, f3, f4) in assert (nat_x == x0 + x1 * pow52 + x2 * pow104 + x3 * pow156 + x4 * pow208); calc (==) { x0 + x1 * pow52 + x2 * pow104 + x3 * pow156 + x4 * pow208; (==) { } x0 + x1 * pow52 + x2 * pow104 + (x / pow156 % pow52) * pow156 + x / pow208 * pow208; (==) { lemma_mod_pow2_sub x 156 52 } x0 + x1 * pow52 + x2 * pow104 + x % pow208 - x % pow156 + x / pow208 * pow208; (==) { Math.Lemmas.euclidean_division_definition x pow208 } x0 + x1 * pow52 + (x / pow104 % pow52) * pow104 - x % pow156 + x; (==) { lemma_mod_pow2_sub x 104 52 } x0 + (x / pow52 % pow52) * pow52 - x % pow104 + x; (==) { lemma_mod_pow2_sub x 52 52 } x; } //-------------------------------------------- val proj_point_to_list_sub: p:S.proj_point -> Lemma (let (px, py, pz) = p in let px_list = felem_to_list px in let py_list = felem_to_list py in let pz_list = felem_to_list pz in let p_list = FL.(px_list @ py_list @ pz_list) in let p_lseq = Seq.seq_of_list p_list <: lseq uint64 15 in let px_lseq = Seq.seq_of_list px_list <: lseq uint64 5 in let py_lseq = Seq.seq_of_list py_list <: lseq uint64 5 in let pz_lseq = Seq.seq_of_list pz_list <: lseq uint64 5 in sub p_lseq 0 5 == px_lseq /\ sub p_lseq 5 5 == py_lseq /\ sub p_lseq 10 5 == pz_lseq) let proj_point_to_list_sub p = let (px, py, pz) = p in let px_list = felem_to_list px in let py_list = felem_to_list py in let pz_list = felem_to_list pz in FL.append_assoc px_list py_list pz_list; SPT.seq_of_list_append_lemma px_list py_list; SPT.seq_of_list_append_lemma FL.(px_list @ py_list) pz_list val proj_point_to_list_fits: p:S.proj_point -> Lemma (point_inv_list (proj_point_to_list p)) let proj_point_to_list_fits p = let (px, py, pz) = p in proj_point_to_list_sub p; felem_to_list_lemma_fits px; felem_to_list_lemma_fits py; felem_to_list_lemma_fits pz val proj_point_to_list_eval: p:S.proj_point -> Lemma (point_eval_list (proj_point_to_list p) == p) let proj_point_to_list_eval p = let (px, py, pz) = p in proj_point_to_list_sub p; felem_to_list_lemma_eval px; felem_to_list_lemma_eval py; felem_to_list_lemma_eval pz; Math.Lemmas.small_mod px S.prime; Math.Lemmas.small_mod py S.prime; Math.Lemmas.small_mod pz S.prime

{ "checked_file": "/", "dependencies": [ "Spec.K256.fst.checked", "prims.fst.checked", "Lib.Sequence.fsti.checked", "Lib.IntTypes.fsti.checked", "Hacl.Spec.PrecompBaseTable.fsti.checked", "Hacl.Spec.K256.Field52.Definitions.fst.checked", "Hacl.Impl.K256.Point.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Mul.fst.checked", "FStar.Math.Lemmas.fst.checked", "FStar.List.Tot.fst.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Hacl.Spec.K256.PrecompTable.fst" }

[ { "abbrev": true, "full_module": "Hacl.Spec.PrecompBaseTable", "short_module": "SPT" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "FL" }, { "abbrev": true, "full_module": "Spec.K256", "short_module": "S" }, { "abbrev": false, "full_module": "Hacl.Impl.K256.Point", "short_module": null }, { "abbrev": false, "full_module": "Hacl.Spec.K256.Field52.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.K256", "short_module": null }, { "abbrev": false, "full_module": "Hacl.Spec.K256", "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

p: Spec.K256.PointOps.proj_point -> FStar.Pervasives.Lemma (ensures Hacl.Spec.K256.PrecompTable.point_inv_list (Hacl.Spec.K256.PrecompTable.proj_point_to_list p) /\ Hacl.Spec.K256.PrecompTable.point_eval_list (Hacl.Spec.K256.PrecompTable.proj_point_to_list p) == p)

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Spec.K256.PointOps.proj_point", "Hacl.Spec.K256.PrecompTable.proj_point_to_list_eval", "Prims.unit", "Hacl.Spec.K256.PrecompTable.proj_point_to_list_fits" ]

[]

true

false

true

false

let proj_point_to_list_lemma p =

proj_point_to_list_fits p; proj_point_to_list_eval p

false

Hacl.Spec.K256.PrecompTable.fst

Hacl.Spec.K256.PrecompTable.proj_point_to_list_fits

val proj_point_to_list_fits: p:S.proj_point -> Lemma (point_inv_list (proj_point_to_list p))

let proj_point_to_list_fits p = let (px, py, pz) = p in proj_point_to_list_sub p; felem_to_list_lemma_fits px; felem_to_list_lemma_fits py; felem_to_list_lemma_fits pz

{ "file_name": "code/k256/Hacl.Spec.K256.PrecompTable.fst", "git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872", "git_url": "https://github.com/project-everest/hacl-star.git", "project_name": "hacl-star" }

{ "end_col": 29, "end_line": 154, "start_col": 0, "start_line": 149 }

module Hacl.Spec.K256.PrecompTable open FStar.Mul open Lib.IntTypes open Lib.Sequence open Hacl.Spec.K256.Field52.Definitions open Hacl.Impl.K256.Point module S = Spec.K256 module FL = FStar.List.Tot module SPT = Hacl.Spec.PrecompBaseTable #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" let create5_lseq (x0 x1 x2 x3 x4:uint64) : lseq uint64 5 = let l = [x0; x1; x2; x3; x4] in assert_norm (FL.length l = 5); Seq.seq_of_list l val create5_lemma (x0 x1 x2 x3 x4:uint64) : Lemma (let s = create5_lseq x0 x1 x2 x3 x4 in s.[0] == x0 /\ s.[1] == x1 /\ s.[2] == x2 /\ s.[3] == x3 /\ s.[4] == x4) let create5_lemma x0 x1 x2 x3 x4 = Seq.elim_of_list [x0; x1; x2; x3; x4] //----------------------------------- noextract let list_as_felem5 (f:felem_list) : felem5 = let x = Seq.seq_of_list f <: lseq uint64 5 in as_felem5_lseq x val felem_to_list_index_lemma: x:S.felem -> Lemma (let (f0, f1, f2, f3, f4) = list_as_felem5 (felem_to_list x) in let x0 = x % pow52 in let x1 = x / pow52 % pow52 in let x2 = x / pow104 % pow52 in let x3 = x / pow156 % pow52 in let x4 = x / pow208 in v f0 == x0 /\ v f1 == x1 /\ v f2 == x2 /\ v f3 == x3 /\ v f4 == x4) let felem_to_list_index_lemma x = let x0 = x % pow52 in let x1 = x / pow52 % pow52 in let x2 = x / pow104 % pow52 in let x3 = x / pow156 % pow52 in let x4 = x / pow208 in let f = felem_to_list x in let (f0, f1, f2, f3, f4) = list_as_felem5 f in create5_lemma (u64 x0) (u64 x1) (u64 x2) (u64 x3) (u64 x4); assert (v f0 == x0 /\ v f1 == x1 /\ v f2 == x2 /\ v f3 == x3 /\ v f4 == x4) val felem_to_list_lemma_fits: x:S.felem -> Lemma (felem_fits5 (list_as_felem5 (felem_to_list x)) (1, 1, 1, 1, 1)) let felem_to_list_lemma_fits x = felem_to_list_index_lemma x; let x0 = x % pow52 in let x1 = x / pow52 % pow52 in let x2 = x / pow104 % pow52 in let x3 = x / pow156 % pow52 in let x4 = x / pow208 in assert (felem_fits1 (u64 x0) 1); assert (felem_fits1 (u64 x1) 1); assert (felem_fits1 (u64 x2) 1); assert (felem_fits1 (u64 x3) 1); Math.Lemmas.lemma_div_lt_nat x 256 208; assert (felem_fits_last1 (u64 x4) 1) val lemma_mod_pow2_sub: x:nat -> a:nat -> b:nat -> Lemma (x / pow2 a % pow2 b * pow2 a == x % pow2 (a + b) - x % pow2 a) let lemma_mod_pow2_sub x a b = calc (==) { x / pow2 a % pow2 b * pow2 a; (==) { Math.Lemmas.pow2_modulo_division_lemma_1 x a (a + b) } x % pow2 (a + b) / pow2 a * pow2 a; (==) { Math.Lemmas.euclidean_division_definition (x % pow2 (a + b)) (pow2 a) } x % pow2 (a + b) - x % pow2 (a + b) % pow2 a; (==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 x a (a + b) } x % pow2 (a + b) - x % pow2 a; } val felem_to_list_lemma_eval: x:S.felem -> Lemma (as_nat5 (list_as_felem5 (felem_to_list x)) == x) let felem_to_list_lemma_eval x = felem_to_list_index_lemma x; let x0 = x % pow52 in let x1 = x / pow52 % pow52 in let x2 = x / pow104 % pow52 in let x3 = x / pow156 % pow52 in let x4 = x / pow208 in let (f0, f1, f2, f3, f4) = list_as_felem5 (felem_to_list x) in let nat_x = as_nat5 (f0, f1, f2, f3, f4) in assert (nat_x == x0 + x1 * pow52 + x2 * pow104 + x3 * pow156 + x4 * pow208); calc (==) { x0 + x1 * pow52 + x2 * pow104 + x3 * pow156 + x4 * pow208; (==) { } x0 + x1 * pow52 + x2 * pow104 + (x / pow156 % pow52) * pow156 + x / pow208 * pow208; (==) { lemma_mod_pow2_sub x 156 52 } x0 + x1 * pow52 + x2 * pow104 + x % pow208 - x % pow156 + x / pow208 * pow208; (==) { Math.Lemmas.euclidean_division_definition x pow208 } x0 + x1 * pow52 + (x / pow104 % pow52) * pow104 - x % pow156 + x; (==) { lemma_mod_pow2_sub x 104 52 } x0 + (x / pow52 % pow52) * pow52 - x % pow104 + x; (==) { lemma_mod_pow2_sub x 52 52 } x; } //-------------------------------------------- val proj_point_to_list_sub: p:S.proj_point -> Lemma (let (px, py, pz) = p in let px_list = felem_to_list px in let py_list = felem_to_list py in let pz_list = felem_to_list pz in let p_list = FL.(px_list @ py_list @ pz_list) in let p_lseq = Seq.seq_of_list p_list <: lseq uint64 15 in let px_lseq = Seq.seq_of_list px_list <: lseq uint64 5 in let py_lseq = Seq.seq_of_list py_list <: lseq uint64 5 in let pz_lseq = Seq.seq_of_list pz_list <: lseq uint64 5 in sub p_lseq 0 5 == px_lseq /\ sub p_lseq 5 5 == py_lseq /\ sub p_lseq 10 5 == pz_lseq) let proj_point_to_list_sub p = let (px, py, pz) = p in let px_list = felem_to_list px in let py_list = felem_to_list py in let pz_list = felem_to_list pz in FL.append_assoc px_list py_list pz_list; SPT.seq_of_list_append_lemma px_list py_list; SPT.seq_of_list_append_lemma FL.(px_list @ py_list) pz_list val proj_point_to_list_fits: p:S.proj_point -> Lemma (point_inv_list (proj_point_to_list p))

{ "checked_file": "/", "dependencies": [ "Spec.K256.fst.checked", "prims.fst.checked", "Lib.Sequence.fsti.checked", "Lib.IntTypes.fsti.checked", "Hacl.Spec.PrecompBaseTable.fsti.checked", "Hacl.Spec.K256.Field52.Definitions.fst.checked", "Hacl.Impl.K256.Point.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.Native.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Mul.fst.checked", "FStar.Math.Lemmas.fst.checked", "FStar.List.Tot.fst.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Hacl.Spec.K256.PrecompTable.fst" }

[ { "abbrev": true, "full_module": "Hacl.Spec.PrecompBaseTable", "short_module": "SPT" }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "FL" }, { "abbrev": true, "full_module": "Spec.K256", "short_module": "S" }, { "abbrev": false, "full_module": "Hacl.Impl.K256.Point", "short_module": null }, { "abbrev": false, "full_module": "Hacl.Spec.K256.Field52.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": true, "full_module": "FStar.List.Tot", "short_module": "FL" }, { "abbrev": true, "full_module": "Spec.K256", "short_module": "S" }, { "abbrev": false, "full_module": "Hacl.Impl.K256.Point", "short_module": null }, { "abbrev": false, "full_module": "Hacl.Spec.K256.Field52.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.K256", "short_module": null }, { "abbrev": false, "full_module": "Hacl.Spec.K256", "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

p: Spec.K256.PointOps.proj_point -> FStar.Pervasives.Lemma (ensures Hacl.Spec.K256.PrecompTable.point_inv_list (Hacl.Spec.K256.PrecompTable.proj_point_to_list p))

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Spec.K256.PointOps.proj_point", "Spec.K256.PointOps.felem", "Hacl.Spec.K256.PrecompTable.felem_to_list_lemma_fits", "Prims.unit", "Hacl.Spec.K256.PrecompTable.proj_point_to_list_sub" ]

[]

false

true

false

let proj_point_to_list_fits p =

let px, py, pz = p in proj_point_to_list_sub p; felem_to_list_lemma_fits px; felem_to_list_lemma_fits py; felem_to_list_lemma_fits pz

false

Hacl.Impl.Ed25519.PointDecompress.fst

Hacl.Impl.Ed25519.PointDecompress.point_decompress_

val point_decompress_: out:point -> s:lbuffer uint8 32ul -> tmp:lbuffer uint64 10ul -> Stack bool (requires fun h -> live h out /\ live h s /\ live h tmp /\ disjoint s tmp /\ disjoint out tmp /\ F51.mul_inv_t h (gsub tmp 5ul 5ul) ) (ensures fun h0 b h1 -> modifies (loc out |+| loc tmp) h0 h1 /\ (b <==> Some? (SE.point_decompress (as_seq h0 s))) /\ (b ==> F51.point_inv_t h1 out) /\ (b ==> (F51.point_eval h1 out == Some?.v (SE.point_decompress (as_seq h0 s)))) )

let point_decompress_ out s tmp = let y = sub tmp 0ul 5ul in let x = sub tmp 5ul 5ul in let sign = most_significant_bit s in load_51 y s; let z = Hacl.Impl.Ed25519.RecoverX.recover_x x y sign in let res = if z = false then false else ( let outx = getx out in let outy = gety out in let outz = getz out in let outt = gett out in copy outx x; copy outy y; make_one outz; fmul outt x y; true ) in res

{ "file_name": "code/ed25519/Hacl.Impl.Ed25519.PointDecompress.fst", "git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872", "git_url": "https://github.com/project-everest/hacl-star.git", "project_name": "hacl-star" }

{ "end_col": 5, "end_line": 88, "start_col": 0, "start_line": 68 }

module Hacl.Impl.Ed25519.PointDecompress module ST = FStar.HyperStack.ST open FStar.HyperStack.All open FStar.Mul open Lib.IntTypes open Lib.Buffer open Lib.ByteSequence open Hacl.Bignum25519 module F51 = Hacl.Impl.Ed25519.Field51 module SC = Spec.Curve25519 module SE = Spec.Ed25519 #set-options "--z3rlimit 30 --max_fuel 0 --max_ifuel 0" inline_for_extraction noextract val most_significant_bit: s:lbuffer uint8 32ul -> Stack uint64 (requires fun h -> live h s) (ensures fun h0 z h1 -> h0 == h1 /\ (v z = 0 \/ v z = 1) /\ v z == (nat_from_bytes_le (as_seq h0 s) / pow2 255) % 2 ) open FStar.Calc let most_significant_bit s = let s31 = s.(31ul) in let z = s31 >>. 7ul in (**) let h0 = ST.get() in (**) FStar.Math.Lemmas.lemma_div_lt_nat (v s31) 8 7; (**) uints_from_bytes_le_nat_lemma #U8 #SEC #32 (as_seq h0 s); (**) nat_from_intseq_le_slice_lemma (as_seq h0 s) 31; (**) nat_from_intseq_le_lemma0 (Seq.slice (as_seq h0 s) 31 32); (**) assert_norm (31 * 8 == 248); (**) FStar.Math.Lemmas.lemma_div_mod_plus (nat_from_intseq_le (Seq.slice (as_seq h0 s) 0 31)) (v s31) (pow2 248); (**) FStar.Math.Lemmas.small_div (nat_from_intseq_le (Seq.slice (as_seq h0 s) 0 31)) (pow2 248); (**) FStar.Math.Lemmas.division_multiplication_lemma (nat_from_bytes_le (as_seq h0 s)) (pow2 248) (pow2 7); (**) assert_norm (pow2 248 * pow2 7 = pow2 255); (**) FStar.Math.Lemmas.small_mod (v s31 / pow2 7) 2; to_u64 z inline_for_extraction noextract val point_decompress_: out:point -> s:lbuffer uint8 32ul -> tmp:lbuffer uint64 10ul -> Stack bool (requires fun h -> live h out /\ live h s /\ live h tmp /\ disjoint s tmp /\ disjoint out tmp /\ F51.mul_inv_t h (gsub tmp 5ul 5ul) ) (ensures fun h0 b h1 -> modifies (loc out |+| loc tmp) h0 h1 /\ (b <==> Some? (SE.point_decompress (as_seq h0 s))) /\ (b ==> F51.point_inv_t h1 out) /\ (b ==> (F51.point_eval h1 out == Some?.v (SE.point_decompress (as_seq h0 s)))) ) #push-options "--z3rlimit 50"

{ "checked_file": "/", "dependencies": [ "Spec.Ed25519.fst.checked", "Spec.Curve25519.fst.checked", "prims.fst.checked", "Lib.IntTypes.fsti.checked", "Lib.ByteSequence.fsti.checked", "Lib.Buffer.fsti.checked", "Hacl.Impl.Ed25519.RecoverX.fst.checked", "Hacl.Impl.Ed25519.Field51.fst.checked", "Hacl.Bignum25519.fsti.checked", "FStar.UInt32.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Mul.fst.checked", "FStar.Math.Lemmas.fst.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.All.fst.checked", "FStar.Calc.fsti.checked" ], "interface_file": false, "source_file": "Hacl.Impl.Ed25519.PointDecompress.fst" }

[ { "abbrev": false, "full_module": "FStar.Calc", "short_module": null }, { "abbrev": true, "full_module": "Spec.Ed25519", "short_module": "SE" }, { "abbrev": true, "full_module": "Spec.Curve25519", "short_module": "SC" }, { "abbrev": true, "full_module": "Hacl.Impl.Ed25519.Field51", "short_module": "F51" }, { "abbrev": false, "full_module": "Hacl.Bignum25519", "short_module": null }, { "abbrev": false, "full_module": "Lib.ByteSequence", "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.Mul", "short_module": null }, { "abbrev": false, "full_module": "FStar.HyperStack.All", "short_module": null }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "ST" }, { "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": 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

out: Hacl.Bignum25519.point -> s: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul -> tmp: Lib.Buffer.lbuffer Lib.IntTypes.uint64 10ul -> FStar.HyperStack.ST.Stack Prims.bool

FStar.HyperStack.ST.Stack

[]

[ "Hacl.Bignum25519.point", "Lib.Buffer.lbuffer", "Lib.IntTypes.uint8", "FStar.UInt32.__uint_to_t", "Lib.IntTypes.uint64", "Prims.bool", "Prims.op_Equality", "Prims.unit", "Hacl.Bignum25519.fmul", "Hacl.Bignum25519.make_one", "Lib.Buffer.copy", "Lib.Buffer.MUT", "Hacl.Bignum25519.felem", "Hacl.Bignum25519.gett", "Hacl.Bignum25519.getz", "Hacl.Bignum25519.gety", "Hacl.Bignum25519.getx", "Hacl.Impl.Ed25519.RecoverX.recover_x", "Hacl.Bignum25519.load_51", "Lib.IntTypes.int_t", "Lib.IntTypes.U64", "Lib.IntTypes.SEC", "Hacl.Impl.Ed25519.PointDecompress.most_significant_bit", "Lib.Buffer.lbuffer_t", "FStar.UInt32.uint_to_t", "FStar.UInt32.t", "Lib.Buffer.sub" ]

[]

false

true

false

let point_decompress_ out s tmp =

let y = sub tmp 0ul 5ul in let x = sub tmp 5ul 5ul in let sign = most_significant_bit s in load_51 y s; let z = Hacl.Impl.Ed25519.RecoverX.recover_x x y sign in let res = if z = false then false else (let outx = getx out in let outy = gety out in let outz = getz out in let outt = gett out in copy outx x; copy outy y; make_one outz; fmul outt x y; true) in res

false

FStar.Pointer.Derived3.fst

FStar.Pointer.Derived3.fill_buffer_advance

val fill_buffer_advance (#t: typ) (b: buffer t) (* destination *) (len' : UInt32.t) (v: type_of_typ t) (h: Ghost.erased HS.mem) : HST.Stack unit (requires (fun h0 -> fill_buffer_inv b len' v (Ghost.reveal h) h0 /\ UInt32.v len' < UInt32.v (buffer_length b) )) (ensures (fun h1 _ h2 -> fill_buffer_inv b len' v (Ghost.reveal h) h1 /\ UInt32.v len' < UInt32.v (buffer_length b) /\ fill_buffer_inv b (UInt32.add len' 1ul) v (Ghost.reveal h) h2 ))

let fill_buffer_advance #t b len' v h = buffer_snoc b 0ul len' v; Seq.lemma_eq_intro (Seq.snoc (Seq.create (UInt32.v len') v) v) (Seq.create (UInt32.v (UInt32.add len' 1ul)) v)

{ "file_name": "ulib/legacy/FStar.Pointer.Derived3.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }

{ "end_col": 112, "end_line": 94, "start_col": 0, "start_line": 92 }

(* Copyright 2008-2018 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 FStar.Pointer.Derived3 module HH = FStar.HyperStack module HS = FStar.HyperStack module HST = FStar.HyperStack.ST private let fill_buffer_precond' (#t: typ) (b: buffer t) (* destination *) (h: HS.mem) : GTot Type0 = buffer_live h b private let fill_buffer_postcond' (#t: typ) (b: buffer t) (* destination *) (v: type_of_typ t) (h: HS.mem) (h' : HS.mem) : GTot Type0 = fill_buffer_precond' b h /\ modifies (loc_buffer b) h h' /\ buffer_readable h' b /\ buffer_as_seq h' b == Seq.create (UInt32.v (buffer_length b)) v private let fill_buffer_inv (#t: typ) (b: buffer t) (* destination *) (len' : UInt32.t) (v: type_of_typ t) (h: HS.mem) (h' : HS.mem) : GTot Type0 = fill_buffer_precond' b h /\ modifies (loc_buffer b) h h' /\ UInt32.v len' <= UInt32.v (buffer_length b) /\ buffer_readable h' (gsub_buffer b 0ul len') /\ buffer_as_seq h' (gsub_buffer b 0ul len') == Seq.create (UInt32.v len') v private val fill_buffer_init (#t: typ) (b: buffer t) (* destination *) (v: type_of_typ t) (h: HS.mem) : Lemma (requires (fill_buffer_precond' b h)) (ensures (fill_buffer_inv b 0ul v h h)) let fill_buffer_init #t b v h = buffer_readable_intro_empty h (gsub_buffer b 0ul 0ul); Seq.lemma_eq_intro (buffer_as_seq h (gsub_buffer b 0ul 0ul)) (Seq.create 0 v) private val fill_buffer_advance (#t: typ) (b: buffer t) (* destination *) (len' : UInt32.t) (v: type_of_typ t) (h: Ghost.erased HS.mem) : HST.Stack unit (requires (fun h0 -> fill_buffer_inv b len' v (Ghost.reveal h) h0 /\ UInt32.v len' < UInt32.v (buffer_length b) )) (ensures (fun h1 _ h2 -> fill_buffer_inv b len' v (Ghost.reveal h) h1 /\ UInt32.v len' < UInt32.v (buffer_length b) /\ fill_buffer_inv b (UInt32.add len' 1ul) v (Ghost.reveal h) h2 )) #set-options "--z3rlimit 16"

{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.UInt32.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Ghost.fsti.checked" ], "interface_file": true, "source_file": "FStar.Pointer.Derived3.fst" }

[ { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HH" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HH" }, { "abbrev": false, "full_module": "FStar.Pointer.Derived1", "short_module": null }, { "abbrev": false, "full_module": "FStar.Pointer.Base", "short_module": null }, { "abbrev": false, "full_module": "FStar.Pointer", "short_module": null }, { "abbrev": false, "full_module": "FStar.Pointer", "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": 16, "z3rlimit_factor": 1, "z3seed": 0, "z3smtopt": [], "z3version": "4.8.5" }

false

b: FStar.Pointer.Base.buffer t -> len': FStar.UInt32.t -> v: FStar.Pointer.Base.type_of_typ t -> h: FStar.Ghost.erased FStar.Monotonic.HyperStack.mem -> FStar.HyperStack.ST.Stack Prims.unit

FStar.HyperStack.ST.Stack

[]

[ "FStar.Pointer.Base.typ", "FStar.Pointer.Base.buffer", "FStar.UInt32.t", "FStar.Pointer.Base.type_of_typ", "FStar.Ghost.erased", "FStar.Monotonic.HyperStack.mem", "FStar.Seq.Base.lemma_eq_intro", "FStar.Seq.Properties.snoc", "FStar.Seq.Base.create", "FStar.UInt32.v", "FStar.UInt32.add", "FStar.UInt32.__uint_to_t", "Prims.unit", "FStar.Pointer.Derived1.buffer_snoc" ]

[]

false

true

false

let fill_buffer_advance #t b len' v h =

buffer_snoc b 0ul len' v; Seq.lemma_eq_intro (Seq.snoc (Seq.create (UInt32.v len') v) v) (Seq.create (UInt32.v (UInt32.add len' 1ul)) v)

false

FStar.Pointer.Derived3.fst

FStar.Pointer.Derived3.fill_buffer'

val fill_buffer' (#t: typ) (b: buffer t) (idx_b len: UInt32.t) (v: type_of_typ t) : HST.Stack unit (requires (fun h -> fill_buffer_precond b idx_b len h)) (ensures (fun h0 _ h1 -> fill_buffer_postcond b idx_b len v h0 h1))

let fill_buffer' (#t: typ) (b: buffer t) (* destination *) (idx_b: UInt32.t) (len: UInt32.t) (v: type_of_typ t) : HST.Stack unit (requires (fun h -> fill_buffer_precond b idx_b len h )) (ensures (fun h0 _ h1 -> fill_buffer_postcond b idx_b len v h0 h1 )) = let h0 = HST.get () in let b' = sub_buffer b idx_b len in fill_buffer_init b' v h0; fill_buffer_aux b' len 0ul v (Ghost.hide h0); let h1 = HST.get () in fill_buffer_fin b idx_b len v h0 h1

{ "file_name": "ulib/legacy/FStar.Pointer.Derived3.fst", "git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3", "git_url": "https://github.com/FStarLang/FStar.git", "project_name": "FStar" }

{ "end_col": 37, "end_line": 160, "start_col": 0, "start_line": 142 }

(* Copyright 2008-2018 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 FStar.Pointer.Derived3 module HH = FStar.HyperStack module HS = FStar.HyperStack module HST = FStar.HyperStack.ST private let fill_buffer_precond' (#t: typ) (b: buffer t) (* destination *) (h: HS.mem) : GTot Type0 = buffer_live h b private let fill_buffer_postcond' (#t: typ) (b: buffer t) (* destination *) (v: type_of_typ t) (h: HS.mem) (h' : HS.mem) : GTot Type0 = fill_buffer_precond' b h /\ modifies (loc_buffer b) h h' /\ buffer_readable h' b /\ buffer_as_seq h' b == Seq.create (UInt32.v (buffer_length b)) v private let fill_buffer_inv (#t: typ) (b: buffer t) (* destination *) (len' : UInt32.t) (v: type_of_typ t) (h: HS.mem) (h' : HS.mem) : GTot Type0 = fill_buffer_precond' b h /\ modifies (loc_buffer b) h h' /\ UInt32.v len' <= UInt32.v (buffer_length b) /\ buffer_readable h' (gsub_buffer b 0ul len') /\ buffer_as_seq h' (gsub_buffer b 0ul len') == Seq.create (UInt32.v len') v private val fill_buffer_init (#t: typ) (b: buffer t) (* destination *) (v: type_of_typ t) (h: HS.mem) : Lemma (requires (fill_buffer_precond' b h)) (ensures (fill_buffer_inv b 0ul v h h)) let fill_buffer_init #t b v h = buffer_readable_intro_empty h (gsub_buffer b 0ul 0ul); Seq.lemma_eq_intro (buffer_as_seq h (gsub_buffer b 0ul 0ul)) (Seq.create 0 v) private val fill_buffer_advance (#t: typ) (b: buffer t) (* destination *) (len' : UInt32.t) (v: type_of_typ t) (h: Ghost.erased HS.mem) : HST.Stack unit (requires (fun h0 -> fill_buffer_inv b len' v (Ghost.reveal h) h0 /\ UInt32.v len' < UInt32.v (buffer_length b) )) (ensures (fun h1 _ h2 -> fill_buffer_inv b len' v (Ghost.reveal h) h1 /\ UInt32.v len' < UInt32.v (buffer_length b) /\ fill_buffer_inv b (UInt32.add len' 1ul) v (Ghost.reveal h) h2 )) #set-options "--z3rlimit 16" let fill_buffer_advance #t b len' v h = buffer_snoc b 0ul len' v; Seq.lemma_eq_intro (Seq.snoc (Seq.create (UInt32.v len') v) v) (Seq.create (UInt32.v (UInt32.add len' 1ul)) v) private val fill_buffer_aux (#t: typ) (b: buffer t) (* destination *) (len: UInt32.t) (len': UInt32.t) (v: type_of_typ t) (h: Ghost.erased HS.mem) : HST.Stack unit (requires (fun h0 -> fill_buffer_inv b len' v (Ghost.reveal h) h0 /\ len == buffer_length b )) (ensures (fun h0 _ h1 -> fill_buffer_inv b len' v (Ghost.reveal h) h0 /\ fill_buffer_postcond' b v (Ghost.reveal h) h1 )) (decreases (UInt32.v (buffer_length b) - UInt32.v len')) let rec fill_buffer_aux #t b len len' v h = if len = len' then () else begin fill_buffer_advance b len' v h; fill_buffer_aux b len (UInt32.add len' 1ul) v h end let fill_buffer_fin (#t: typ) (b: buffer t) (* destination *) (idx_b: UInt32.t) (len: UInt32.t) (v: type_of_typ t) (h: HS.mem) (h' : HS.mem) : Lemma (requires ( fill_buffer_precond b idx_b len h /\ fill_buffer_postcond' (gsub_buffer b idx_b len) v h h' )) (ensures ( fill_buffer_precond b idx_b len h /\ fill_buffer_postcond b idx_b len v h h' )) = ()

{ "checked_file": "/", "dependencies": [ "prims.fst.checked", "FStar.UInt32.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.HyperStack.ST.fsti.checked", "FStar.HyperStack.fst.checked", "FStar.Ghost.fsti.checked" ], "interface_file": true, "source_file": "FStar.Pointer.Derived3.fst" }

[ { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HH" }, { "abbrev": true, "full_module": "FStar.HyperStack.ST", "short_module": "HST" }, { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HS" }, { "abbrev": true, "full_module": "FStar.HyperStack", "short_module": "HH" }, { "abbrev": false, "full_module": "FStar.Pointer.Derived1", "short_module": null }, { "abbrev": false, "full_module": "FStar.Pointer.Base", "short_module": null }, { "abbrev": false, "full_module": "FStar.Pointer", "short_module": null }, { "abbrev": false, "full_module": "FStar.Pointer", "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": 16, "z3rlimit_factor": 1, "z3seed": 0, "z3smtopt": [], "z3version": "4.8.5" }

false

b: FStar.Pointer.Base.buffer t -> idx_b: FStar.UInt32.t -> len: FStar.UInt32.t -> v: FStar.Pointer.Base.type_of_typ t -> FStar.HyperStack.ST.Stack Prims.unit

FStar.HyperStack.ST.Stack

[]

[ "FStar.Pointer.Base.typ", "FStar.Pointer.Base.buffer", "FStar.UInt32.t", "FStar.Pointer.Base.type_of_typ", "FStar.Pointer.Derived3.fill_buffer_fin", "Prims.unit", "FStar.Monotonic.HyperStack.mem", "FStar.HyperStack.ST.get", "FStar.Pointer.Derived3.fill_buffer_aux", "FStar.UInt32.__uint_to_t", "FStar.Ghost.hide", "FStar.Pointer.Derived3.fill_buffer_init", "FStar.Pointer.Base.sub_buffer", "FStar.Pointer.Derived3.fill_buffer_precond", "FStar.Pointer.Derived3.fill_buffer_postcond" ]

[]

false

true

false

let fill_buffer' (#t: typ) (b: buffer t) (idx_b len: UInt32.t) (v: type_of_typ t) : HST.Stack unit (requires (fun h -> fill_buffer_precond b idx_b len h)) (ensures (fun h0 _ h1 -> fill_buffer_postcond b idx_b len v h0 h1)) =

let h0 = HST.get () in let b' = sub_buffer b idx_b len in fill_buffer_init b' v h0; fill_buffer_aux b' len 0ul v (Ghost.hide h0); let h1 = HST.get () in fill_buffer_fin b idx_b len v h0 h1

false