microsoft/FStarDataSet-V2 · Datasets at Hugging Face

Steel.Memory.fst

Steel.Memory.disjoint

val disjoint (m0 m1:mem u#h) : prop

let disjoint (m0 m1:mem u#h) : prop = m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks

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

{ "end_col": 24, "end_line": 58, "start_col": 0, "start_line": 54 }

(* 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 = ()

{ "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.Heap", "short_module": "H" }, { "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

m0: Steel.Memory.mem -> m1: Steel.Memory.mem -> Prims.prop

Prims.Tot

[ "total" ]

[]

[ "Steel.Memory.mem", "Prims.l_and", "Prims.eq2", "Prims.nat", "Steel.Memory.__proj__Mkmem__item__ctr", "Steel.Heap.disjoint", "Steel.Memory.__proj__Mkmem__item__heap", "Steel.Memory.lock_store", "Steel.Memory.__proj__Mkmem__item__locks", "Prims.prop" ]

[]

false

true

let disjoint (m0 m1: mem u#h) : prop =

m0.ctr == m1.ctr /\ H.disjoint m0.heap m1.heap /\ m0.locks == m1.locks

false

Hacl.Spec.Poly1305.Field32xN.Lemmas.fst

Hacl.Spec.Poly1305.Field32xN.Lemmas.load_acc5_2_lemma

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)

{ "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": 48, "end_line": 786, "start_col": 0, "start_line": 776 }

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)]

{ "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: Hacl.Spec.Poly1305.Field32xN.felem5 2 {Hacl.Spec.Poly1305.Field32xN.felem_fits5 f (2, 2, 2, 2, 2)} -> e: Hacl.Spec.Poly1305.Field32xN.felem5 2 {Hacl.Spec.Poly1305.Field32xN.felem_fits5 e (1, 1, 1, 1, 1)} -> FStar.Pervasives.Lemma (ensures (let res = Hacl.Spec.Poly1305.Field32xN.load_acc5_2 f e in Hacl.Spec.Poly1305.Field32xN.felem_fits5 res (3, 3, 3, 3, 3) /\ Hacl.Spec.Poly1305.Field32xN.feval5 res == Hacl.Spec.Poly1305.Vec.fadd (Lib.Sequence.create2 (Hacl.Spec.Poly1305.Field32xN.feval5 f).[ 0 ] 0) (Hacl.Spec.Poly1305.Field32xN.feval5 e))) [SMTPat (Hacl.Spec.Poly1305.Field32xN.load_acc5_2 f e)]

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Hacl.Spec.Poly1305.Field32xN.felem5", "Hacl.Spec.Poly1305.Field32xN.felem_fits5", "FStar.Pervasives.Native.Mktuple5", "Prims.nat", "Hacl.Spec.Poly1305.Field32xN.uint64xN", "Lib.Sequence.eq_intro", "Hacl.Spec.Poly1305.Vec.pfelem", "Hacl.Spec.Poly1305.Field32xN.feval5", "Lib.Sequence.create2", "Lib.Sequence.op_String_Access", "Prims.unit", "Prims._assert", "Prims.eq2", "Prims.int", "FStar.Pervasives.Native.tuple5", "Lib.IntVector.vec_t", "Lib.IntTypes.U64", "Lib.Sequence.lseq", "Lib.IntTypes.int_t", "Lib.IntTypes.SEC", "Lib.IntVector.vec_v", "Lib.Sequence.upd", "Lib.IntTypes.v", "Lib.IntTypes.U32", "Lib.IntTypes.PUB", "FStar.UInt32.uint_to_t", "FStar.UInt32.t", "Lib.IntTypes.mk_int", "Lib.IntVector.vec_set", "FStar.UInt32.__uint_to_t", "Lib.IntTypes.u64" ]

[]

false

true

false

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).[ 1 ] == 0); eq_intro (feval5 r) (create2 (feval5 f).[ 0 ] 0)

false

Steel.Memory.fst

Steel.Memory.interp

val interp (p:slprop u#a) (m:mem u#a) : prop

let interp p m = H.interp p m.heap

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

{ "end_col": 34, "end_line": 79, "start_col": 0, "start_line": 79 }

(* 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

{ "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.Heap", "short_module": "H" }, { "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 -> m: Steel.Memory.mem -> Prims.prop

Prims.Tot

[ "total" ]

[]

[ "Steel.Memory.slprop", "Steel.Memory.mem", "Steel.Heap.interp", "Steel.Memory.__proj__Mkmem__item__heap", "Prims.prop" ]

[]

false

true

let interp p m =

H.interp p m.heap

false

Steel.Memory.fst

Steel.Memory.slprop

val slprop : Type u#(a + 1)

let slprop = H.slprop

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

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

(* 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

{ "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.Heap", "short_module": "H" }, { "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

Type

Prims.Tot

[ "total" ]

[]

[ "Steel.Heap.slprop" ]

[]

false

true

let slprop =

H.slprop

false

Steel.Memory.fst

Steel.Memory.equiv

val equiv (p1 p2:slprop u#a) : prop

let equiv p1 p2 = forall m. interp p1 m <==> interp p2 m

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

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

(* 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

{ "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.Heap", "short_module": "H" }, { "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

p1: Steel.Memory.slprop -> p2: Steel.Memory.slprop -> Prims.prop

Prims.Tot

[ "total" ]

[]

[ "Steel.Memory.slprop", "Prims.l_Forall", "Steel.Memory.mem", "Prims.l_iff", "Steel.Memory.interp", "Prims.prop" ]

[]

false

true

let equiv p1 p2 =

forall m. interp p1 m <==> interp p2 m

false

Vale.Poly1305.Equiv.fst

Vale.Poly1305.Equiv.lemma_poly1305_equiv_rec

val lemma_poly1305_equiv_rec (text: bytes) (acc0 r: felem) (k: nat) : Lemma (requires k <= length text / size_block) (ensures (let f = S.poly1305_update1 r size_block in let repeat_f = repeat_blocks_f size_block text f (length text / size_block) in let pad = pow2 (8 * size_block) in V.poly1305_hash_blocks acc0 pad r (block_fun text) k == repeati k repeat_f acc0)) (decreases k)

let rec lemma_poly1305_equiv_rec (text:bytes) (acc0:felem) (r:felem) (k:nat) : Lemma (requires k <= length text / size_block) (ensures ( let f = S.poly1305_update1 r size_block in let repeat_f = repeat_blocks_f size_block text f (length text / size_block) in let pad = pow2 (8 * size_block) in V.poly1305_hash_blocks acc0 pad r (block_fun text) k == repeati k repeat_f acc0 )) (decreases k) = let inp = block_fun text in let f = S.poly1305_update1 r size_block in let len = length text in let nb = len / size_block in let repeat_f = repeat_blocks_f size_block text f nb in let pad = pow2 (8 * size_block) in assert_norm (pow2 128 + pow2 128 < prime); if k = 0 then Lib.LoopCombinators.eq_repeati0 nb repeat_f acc0 else ( let kk = k - 1 in let hh = V.poly1305_hash_blocks acc0 pad r inp kk in let r0:felem = repeati kk repeat_f acc0 in let block = Seq.slice text (kk * size_block) (kk * size_block + size_block) in calc (==) { V.poly1305_hash_blocks acc0 pad r inp k; == {} modp ((hh + pad + inp kk) * r); == {assert_norm (modp ((hh + pad + inp kk) * r) == (hh + pad + inp kk) * r % prime)} (hh + pad + inp kk) * r % prime; == {FStar.Math.Lemmas.lemma_mod_mul_distr_l (hh + pad + inp kk) r prime} ((hh + pad + inp kk) % prime) * r % prime; == {lemma_poly1305_equiv_rec text acc0 r kk} ((pad + inp kk + r0) % prime) * r % prime; == {assert_norm (fmul (fadd (pad + inp kk) r0) r == ((pad + inp kk + r0) % prime) * r % prime)} fmul (fadd (pad + inp kk) r0) r; == { FStar.Math.Lemmas.lemma_mod_plus_distr_l (pad + inp kk) r0 prime } fmul (fadd (fadd pad (inp kk)) r0) r; == {} S.poly1305_update1 r size_block block (repeati kk repeat_f acc0); }; calc (==) { S.poly1305_update1 r size_block block (repeati kk repeat_f acc0); == {} f block (repeati kk repeat_f acc0); == {} repeat_f kk (repeati kk repeat_f acc0); == {Lib.LoopCombinators.unfold_repeati nb repeat_f acc0 kk} repeati k repeat_f acc0; } )

{ "file_name": "vale/code/crypto/poly1305/Vale.Poly1305.Equiv.fst", "git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872", "git_url": "https://github.com/project-everest/hacl-star.git", "project_name": "hacl-star" }

{ "end_col": 3, "end_line": 84, "start_col": 0, "start_line": 33 }

module Vale.Poly1305.Equiv open FStar.Mul module BSeq = Lib.ByteSequence // REVIEW: S and V use different smtencoding flags, // so some equalities between S and V definitions aren't as obvious to Z3 as we might want. unfold let pow2_128 = Vale.Def.Words_s.pow2_128 unfold let nat64 = Vale.Def.Words_s.nat64 unfold let iand #n = Vale.Def.Types_s.iand #n unfold let size_nat = Lib.IntTypes.size_nat unfold let uint_v #t #l = Lib.IntTypes.uint_v #t #l unfold let uint8 = Lib.IntTypes.uint8 unfold let u64 = Lib.IntTypes.u64 unfold let logand #t #l = Lib.IntTypes.logand #t #l unfold let repeati = Lib.LoopCombinators.repeati unfold let repeat_blocks = Lib.Sequence.repeat_blocks unfold let repeat_blocks_f = Lib.Sequence.repeat_blocks_f unfold let sub #a #len = Lib.Sequence.sub #a #len unfold let lbytes = Lib.ByteSequence.lbytes unfold let uint_from_bytes_le #t #l = Lib.ByteSequence.uint_from_bytes_le #t #l unfold let prime = S.prime unfold let felem = S.felem unfold let fadd = S.fadd unfold let fmul = S.fmul unfold let to_felem = S.to_felem unfold let modp = V.modp unfold let mod2_128 = V.mod2_128 #set-options "--z3rlimit 150 --max_fuel 1 --max_ifuel 1"

{ "checked_file": "/", "dependencies": [ "Vale.Poly1305.Math.fsti.checked", "Vale.Def.Words_s.fsti.checked", "Vale.Def.Types_s.fst.checked", "Vale.Arch.TypesNative.fsti.checked", "prims.fst.checked", "Lib.Sequence.fsti.checked", "Lib.LoopCombinators.fsti.checked", "Lib.IntTypes.fsti.checked", "Lib.ByteSequence.fsti.checked", "Hacl.Impl.Poly1305.Lemmas.fst.checked", "FStar.UInt.fsti.checked", "FStar.Seq.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Mul.fst.checked", "FStar.Math.Lemmas.fst.checked", "FStar.Calc.fsti.checked" ], "interface_file": true, "source_file": "Vale.Poly1305.Equiv.fst" }

[ { "abbrev": true, "full_module": "Lib.ByteSequence", "short_module": "BSeq" }, { "abbrev": false, "full_module": "FStar.Mul", "short_module": null }, { "abbrev": true, "full_module": "Vale.Poly1305.Spec_s", "short_module": "V" }, { "abbrev": true, "full_module": "Spec.Poly1305", "short_module": "S" }, { "abbrev": false, "full_module": "FStar.Seq.Base", "short_module": null }, { "abbrev": false, "full_module": "FStar.Mul", "short_module": null }, { "abbrev": false, "full_module": "Vale.Poly1305", "short_module": null }, { "abbrev": false, "full_module": "Vale.Poly1305", "short_module": null }, { "abbrev": false, "full_module": "FStar.Pervasives", "short_module": null }, { "abbrev": false, "full_module": "Prims", "short_module": null }, { "abbrev": false, "full_module": "FStar", "short_module": null } ]

{ "detail_errors": false, "detail_hint_replay": false, "initial_fuel": 2, "initial_ifuel": 0, "max_fuel": 1, "max_ifuel": 1, "no_plugins": false, "no_smt": false, "no_tactics": false, "quake_hi": 1, "quake_keep": false, "quake_lo": 1, "retry": false, "reuse_hint_for": null, "smtencoding_elim_box": true, "smtencoding_l_arith_repr": "native", "smtencoding_nl_arith_repr": "wrapped", "smtencoding_valid_elim": false, "smtencoding_valid_intro": true, "tcnorm": true, "trivial_pre_for_unannotated_effectful_fns": false, "z3cliopt": [ "smt.arith.nl=false", "smt.QI.EAGER_THRESHOLD=100", "smt.CASE_SPLIT=3" ], "z3refresh": false, "z3rlimit": 150, "z3rlimit_factor": 1, "z3seed": 0, "z3smtopt": [], "z3version": "4.8.5" }

false

text: Vale.Poly1305.Equiv.bytes -> acc0: Vale.Poly1305.Equiv.felem -> r: Vale.Poly1305.Equiv.felem -> k: Prims.nat -> FStar.Pervasives.Lemma (requires k <= FStar.Seq.Base.length text / Vale.Poly1305.Equiv.size_block) (ensures (let f = Spec.Poly1305.poly1305_update1 r Vale.Poly1305.Equiv.size_block in let repeat_f = Vale.Poly1305.Equiv.repeat_blocks_f Vale.Poly1305.Equiv.size_block text f (FStar.Seq.Base.length text / Vale.Poly1305.Equiv.size_block) in let pad = Prims.pow2 (8 * Vale.Poly1305.Equiv.size_block) in Vale.Poly1305.Spec_s.poly1305_hash_blocks acc0 pad r (Vale.Poly1305.Equiv.block_fun text) k == Vale.Poly1305.Equiv.repeati k repeat_f acc0)) (decreases k)

FStar.Pervasives.Lemma

[ "lemma", "" ]

[]

[ "Vale.Poly1305.Equiv.bytes", "Vale.Poly1305.Equiv.felem", "Prims.nat", "Prims.op_Equality", "Prims.int", "Lib.LoopCombinators.eq_repeati0", "Spec.Poly1305.felem", "Prims.bool", "FStar.Calc.calc_finish", "Prims.eq2", "Spec.Poly1305.poly1305_update1", "Vale.Poly1305.Equiv.size_block", "Vale.Poly1305.Equiv.repeati", "Prims.Cons", "FStar.Preorder.relation", "Prims.Nil", "Prims.unit", "FStar.Calc.calc_step", "FStar.Calc.calc_init", "FStar.Calc.calc_pack", "Prims.squash", "Lib.LoopCombinators.unfold_repeati", "Vale.Poly1305.Spec_s.poly1305_hash_blocks", "Vale.Poly1305.Equiv.fmul", "Vale.Poly1305.Equiv.fadd", "Prims.op_Addition", "Prims.op_Modulus", "FStar.Mul.op_Star", "Vale.Poly1305.Equiv.prime", "Vale.Poly1305.Equiv.modp", "FStar.Pervasives.assert_norm", "FStar.Math.Lemmas.lemma_mod_mul_distr_l", "Vale.Poly1305.Equiv.lemma_poly1305_equiv_rec", "FStar.Math.Lemmas.lemma_mod_plus_distr_l", "FStar.Seq.Base.seq", "Lib.IntTypes.int_t", "Lib.IntTypes.U8", "Lib.IntTypes.SEC", "FStar.Seq.Base.slice", "Lib.IntTypes.uint_t", "Prims.op_Subtraction", "Prims.b2t", "Prims.op_LessThan", "Prims.pow2", "Prims.pos", "Vale.Poly1305.Equiv.repeat_blocks_f", "Prims.op_Division", "FStar.Seq.Base.length", "Lib.Sequence.lseq", "Spec.Poly1305.size_block", "Vale.Def.Words_s.nat128", "Vale.Poly1305.Equiv.block_fun", "Prims.op_LessThanOrEqual", "FStar.Pervasives.pattern" ]

[ "recursion" ]

false

true

false

let rec lemma_poly1305_equiv_rec (text: bytes) (acc0 r: felem) (k: nat) : Lemma (requires k <= length text / size_block) (ensures (let f = S.poly1305_update1 r size_block in let repeat_f = repeat_blocks_f size_block text f (length text / size_block) in let pad = pow2 (8 * size_block) in V.poly1305_hash_blocks acc0 pad r (block_fun text) k == repeati k repeat_f acc0)) (decreases k) =

false

Selectors.LList2.fst

Selectors.LList2.llist0_of_nllist

val llist0_of_nllist (#opened: _) (#a: Type0) (n: Ghost.erased nat) (r: t a) : SteelGhost unit opened (nllist a n r) (fun _ -> llist0 r) (fun _ -> True) (fun h0 res h1 -> h1 (llist0 r) == h0 (nllist a n r))

let llist0_of_nllist (#opened: _) (#a: Type0) (n: Ghost.erased nat) (r: t a) : SteelGhost unit opened (nllist a n r) (fun _ -> llist0 r) (fun _ -> True) (fun h0 res h1 -> h1 (llist0 r) == h0 (nllist a n r) ) = if is_null r then begin change_equal_slprop (nllist a n r) (llist0 r); () end else begin nllist_eq_not_null a n r; change_equal_slprop (nllist a n r) (((vptr r `vrefine` v_c n r) `vdep` v_c_dep n r (nllist a)) `vrewrite` v_c_l_rewrite n r (nllist a)); elim_vrewrite ((vptr r `vrefine` v_c n r) `vdep` v_c_dep n r (nllist a)) (v_c_l_rewrite n r (nllist a)); let gk = elim_vdep (vptr r `vrefine` v_c n r) (v_c_dep n r (nllist a)) in elim_vrefine (vptr r) (v_c n r); intro_vdep (vptr r) (v_c_dep n r (nllist a) (Ghost.reveal gk)) (llist_vdep r); intro_vrewrite (vptr r `vdep` llist_vdep r) (llist_vrewrite r); change_equal_slprop ((vptr r `vdep` llist_vdep r) `vrewrite` llist_vrewrite r) (llist0 r) end

{ "file_name": "share/steel/examples/steel/Selectors.LList2.fst", "git_rev": "f984200f79bdc452374ae994a5ca837496476c41", "git_url": "https://github.com/FStarLang/steel.git", "project_name": "steel" }

{ "end_col": 5, "end_line": 185, "start_col": 0, "start_line": 150 }

module Selectors.LList2 open Steel.FractionalPermission module Mem = Steel.Memory #push-options "--__no_positivity" noeq type cell (a: Type0) = { tail_fuel: Ghost.erased nat; next: ref (cell a); data: a; } #pop-options let next #a (c:cell a) : t a = c.next let data #a (c:cell a) : a = c.data let mk_cell #a (n: t a) (d:a) = { tail_fuel = Ghost.hide 0; next = n; data = d } let null_llist #a = null let is_null #a ptr = is_null ptr let v_null_rewrite (a: Type0) (_: t_of emp) : GTot (list a) = [] let v_c (n: Ghost.erased nat) (#a: Type0) (r: t a) (c: normal (t_of (vptr r))) : GTot prop = (Ghost.reveal c.tail_fuel < Ghost.reveal n) == true // to ensure vprop termination let v_c_dep (n: Ghost.erased nat) (#a: Type0) (r: t a) (nllist: (n': Ghost.erased nat) -> (r: t a { Ghost.reveal n' < Ghost.reveal n }) -> Pure vprop (requires True) (ensures (fun y -> t_of y == list a))) (c: normal (t_of (vrefine (vptr r) (v_c n r)))) : Tot vprop = nllist c.tail_fuel c.next let v_c_l_rewrite (n: Ghost.erased nat) (#a: Type0) (r: t a) (nllist: (n': Ghost.erased nat) -> (r: t a { Ghost.reveal n' < Ghost.reveal n }) -> Pure vprop (requires True) (ensures (fun y -> t_of y == list a))) (res: normal (t_of ((vptr r `vrefine` v_c n r) `vdep` v_c_dep n r nllist))) : Tot (list a) = let (| c, l |) = res in c.data :: l let rec nllist (a: Type0) (n: Ghost.erased nat) (r: t a) : Pure vprop (requires True) (ensures (fun y -> t_of y == list a)) (decreases (Ghost.reveal n)) = if is_null r then emp `vrewrite` v_null_rewrite a else ((vptr r `vrefine` v_c n r) `vdep` v_c_dep n r (nllist a)) `vrewrite` v_c_l_rewrite n r (nllist a) let nllist_eq_not_null (a: Type0) (n: Ghost.erased nat) (r: t a) : Lemma (requires (is_null r == false)) (ensures ( nllist a n r == ((vptr r `vrefine` v_c n r) `vdep` v_c_dep n r (nllist a)) `vrewrite` v_c_l_rewrite n r (nllist a) )) = assert_norm (nllist a n r == begin if is_null r then emp `vrewrite` v_null_rewrite a else ((vptr r `vrefine` v_c n r) `vdep` v_c_dep n r (nllist a)) `vrewrite` v_c_l_rewrite n r (nllist a) end ) let llist_vdep (#a: Type0) (r: t a) (c: normal (t_of (vptr r))) : Tot vprop = nllist a c.tail_fuel c.next let llist_vrewrite (#a: Type0) (r: t a) (cl: normal (t_of (vptr r `vdep` llist_vdep r))) : GTot (list a) = (dfst cl).data :: dsnd cl let llist0 (#a: Type0) (r: t a) : Pure vprop (requires True) (ensures (fun y -> t_of y == list a)) = if is_null r then emp `vrewrite` v_null_rewrite a else (vptr r `vdep` llist_vdep r) `vrewrite` llist_vrewrite r let nllist_of_llist0 (#opened: _) (#a: Type0) (r: t a) : SteelGhost (Ghost.erased nat) opened (llist0 r) (fun res -> nllist a res r) (fun _ -> True) (fun h0 res h1 -> h0 (llist0 r) == h1 (nllist a res r) ) = if is_null r then begin let res = Ghost.hide 0 in change_equal_slprop (llist0 r) (nllist a res r); res end else begin change_equal_slprop (llist0 r) ((vptr r `vdep` llist_vdep r) `vrewrite` llist_vrewrite r); elim_vrewrite (vptr r `vdep` llist_vdep r) (llist_vrewrite r); let gk : normal (Ghost.erased (t_of (vptr r))) = elim_vdep (vptr r) (llist_vdep r) in let res = Ghost.hide (Ghost.reveal (Ghost.reveal gk).tail_fuel + 1) in intro_vrefine (vptr r) (v_c res r); intro_vdep (vptr r `vrefine` v_c res r) (llist_vdep r (Ghost.reveal gk)) (v_c_dep res r (nllist a)); intro_vrewrite ((vptr r `vrefine` v_c res r) `vdep` v_c_dep res r (nllist a)) (v_c_l_rewrite res r (nllist a)); nllist_eq_not_null a res r; change_equal_slprop (((vptr r `vrefine` v_c res r) `vdep` v_c_dep res r (nllist a)) `vrewrite` v_c_l_rewrite res r (nllist a)) (nllist a res r); res end

{ "checked_file": "/", "dependencies": [ "Steel.Memory.fsti.checked", "Steel.FractionalPermission.fst.checked", "prims.fst.checked", "FStar.Pervasives.fsti.checked", "FStar.Ghost.fsti.checked" ], "interface_file": true, "source_file": "Selectors.LList2.fst" }

[ { "abbrev": true, "full_module": "Steel.Memory", "short_module": "Mem" }, { "abbrev": false, "full_module": "Steel.FractionalPermission", "short_module": null }, { "abbrev": true, "full_module": "FStar.List.Tot", "short_module": "L" }, { "abbrev": false, "full_module": "Steel.Reference", "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": "Selectors", "short_module": null }, { "abbrev": false, "full_module": "Selectors", "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: FStar.Ghost.erased Prims.nat -> r: Selectors.LList2.t a -> Steel.Effect.Atomic.SteelGhost Prims.unit

Steel.Effect.Atomic.SteelGhost

[]

[ "Steel.Memory.inames", "FStar.Ghost.erased", "Prims.nat", "Selectors.LList2.t", "Selectors.LList2.is_null", "Prims.unit", "Steel.Effect.Atomic.change_equal_slprop", "Selectors.LList2.nllist", "Selectors.LList2.llist0", "Prims.bool", "Steel.Effect.Common.vrewrite", "Steel.Effect.Common.vdep", "Steel.Reference.vptr", "Selectors.LList2.cell", "Selectors.LList2.llist_vdep", "Prims.list", "Selectors.LList2.llist_vrewrite", "Steel.Effect.Atomic.intro_vrewrite", "Steel.Effect.Atomic.intro_vdep", "Selectors.LList2.v_c_dep", "FStar.Ghost.reveal", "Steel.Effect.Common.t_of", "Steel.Effect.Common.vrefine", "Selectors.LList2.v_c", "Steel.Effect.Atomic.elim_vrefine", "Steel.Effect.Common.VUnit", "Steel.Reference.vptr'", "Steel.FractionalPermission.full_perm", "Steel.Effect.Atomic.elim_vdep", "Steel.Effect.Atomic.elim_vrewrite", "Selectors.LList2.v_c_l_rewrite", "Selectors.LList2.nllist_eq_not_null", "Steel.Effect.Common.vprop", "Steel.Effect.Common.rmem", "Prims.l_True", "Prims.eq2", "Steel.Effect.Common.normal" ]

[]

false

true

false

let llist0_of_nllist (#opened: _) (#a: Type0) (n: Ghost.erased nat) (r: t a) : SteelGhost unit opened (nllist a n r) (fun _ -> llist0 r) (fun _ -> True) (fun h0 res h1 -> h1 (llist0 r) == h0 (nllist a n r)) =

if is_null r then (change_equal_slprop (nllist a n r) (llist0 r); ()) else (nllist_eq_not_null a n r; change_equal_slprop (nllist a n r) ((((vptr r) `vrefine` (v_c n r)) `vdep` (v_c_dep n r (nllist a))) `vrewrite` (v_c_l_rewrite n r (nllist a))); elim_vrewrite (((vptr r) `vrefine` (v_c n r)) `vdep` (v_c_dep n r (nllist a))) (v_c_l_rewrite n r (nllist a)); let gk = elim_vdep ((vptr r) `vrefine` (v_c n r)) (v_c_dep n r (nllist a)) in elim_vrefine (vptr r) (v_c n r); intro_vdep (vptr r) (v_c_dep n r (nllist a) (Ghost.reveal gk)) (llist_vdep r); intro_vrewrite ((vptr r) `vdep` (llist_vdep r)) (llist_vrewrite r); change_equal_slprop (((vptr r) `vdep` (llist_vdep r)) `vrewrite` (llist_vrewrite r)) (llist0 r))

false

Steel.Memory.fst

Steel.Memory.core_ref

val core_ref : Type u#0

let core_ref = H.core_ref

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

{ "end_col": 25, "end_line": 96, "start_col": 0, "start_line": 96 }

(* 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 = ()

{ "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.Heap", "short_module": "H" }, { "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

Type0

Prims.Tot

[ "total" ]

[]

[ "Steel.Heap.core_ref" ]

[]

false

true

let core_ref =

H.core_ref

false

Steel.Memory.fst

Steel.Memory.disjoint_join

val disjoint_join (m0 m1 m2:mem) : Lemma (disjoint m1 m2 /\ disjoint m0 (join m1 m2) ==> disjoint m0 m1 /\ disjoint m0 m2 /\ disjoint (join m0 m1) m2 /\ disjoint (join m0 m2) m1)

let disjoint_join m0 m1 m2 = H.disjoint_join m0.heap m1.heap m2.heap

{ "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": 72, "start_col": 0, "start_line": 71 }

(* 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

{ "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.Heap", "short_module": "H" }, { "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

m0: Steel.Memory.mem -> m1: Steel.Memory.mem -> m2: Steel.Memory.mem -> FStar.Pervasives.Lemma (ensures Steel.Memory.disjoint m1 m2 /\ Steel.Memory.disjoint m0 (Steel.Memory.join m1 m2) ==> Steel.Memory.disjoint m0 m1 /\ Steel.Memory.disjoint m0 m2 /\ Steel.Memory.disjoint (Steel.Memory.join m0 m1) m2 /\ Steel.Memory.disjoint (Steel.Memory.join m0 m2) m1)

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Steel.Memory.mem", "Steel.Heap.disjoint_join", "Steel.Memory.__proj__Mkmem__item__heap", "Prims.unit" ]

[]

true

false

true

false

let disjoint_join m0 m1 m2 =

H.disjoint_join m0.heap m1.heap m2.heap

false

Steel.Memory.fst

Steel.Memory.pts_to

val pts_to (#a:Type u#a) (#pcm:_) (r:ref a pcm) (v:a) : slprop u#a

let pts_to = H.pts_to

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

{ "end_col": 21, "end_line": 102, "start_col": 0, "start_line": 102 }

(* 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

{ "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.Heap", "short_module": "H" }, { "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 -> v: a -> Steel.Memory.slprop

Prims.Tot

[ "total" ]

[]

[ "Steel.Heap.pts_to" ]

[]

false

let pts_to =

H.pts_to

false

Steel.Memory.fst

Steel.Memory.join

val join (m0:mem u#h) (m1:mem u#h{disjoint m0 m1}) : mem u#h

let join m0 m1 = { ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = 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": 1, "end_line": 66, "start_col": 0, "start_line": 62 }

(* 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 = ()

{ "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.Heap", "short_module": "H" }, { "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

m0: Steel.Memory.mem -> m1: Steel.Memory.mem{Steel.Memory.disjoint m0 m1} -> Steel.Memory.mem

Prims.Tot

[ "total" ]

[]

[ "Steel.Memory.mem", "Steel.Memory.disjoint", "Steel.Memory.Mkmem", "Steel.Memory.__proj__Mkmem__item__ctr", "Steel.Heap.join", "Steel.Memory.__proj__Mkmem__item__heap", "Steel.Memory.__proj__Mkmem__item__locks" ]

[]

false

let join m0 m1 =

{ ctr = m0.ctr; heap = H.join m0.heap m1.heap; locks = m0.locks }

false

Steel.Memory.fst

Steel.Memory.join_commutative

val join_commutative (m0 m1:mem) : Lemma (requires disjoint m0 m1) (ensures (disjoint m0 m1 /\ disjoint m1 m0 /\ join m0 m1 == join m1 m0))

let join_commutative m0 m1 = H.join_commutative m0.heap m1.heap

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

{ "end_col": 36, "end_line": 69, "start_col": 0, "start_line": 68 }

(* 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 }

{ "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.Heap", "short_module": "H" }, { "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

m0: Steel.Memory.mem -> m1: Steel.Memory.mem -> FStar.Pervasives.Lemma (requires Steel.Memory.disjoint m0 m1) (ensures Steel.Memory.disjoint m0 m1 /\ Steel.Memory.disjoint m1 m0 /\ Steel.Memory.join m0 m1 == Steel.Memory.join m1 m0)

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Steel.Memory.mem", "Steel.Heap.join_commutative", "Steel.Memory.__proj__Mkmem__item__heap", "Prims.unit" ]

[]

true

false

true

false

let join_commutative m0 m1 =

H.join_commutative m0.heap m1.heap

false

Steel.Memory.fst

Steel.Memory.core_ref_null

val core_ref_null : core_ref

let core_ref_null = H.core_ref_null

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

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

(* 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 = ()

{ "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.Heap", "short_module": "H" }, { "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

Steel.Memory.core_ref

Prims.Tot

[ "total" ]

[]

[ "Steel.Heap.core_ref_null" ]

[]

false

true

false

let core_ref_null =

H.core_ref_null

false

Steel.Memory.fst

Steel.Memory.emp

val emp : slprop u#a

let emp : slprop u#a = H.emp

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

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

(* 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

{ "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.Heap", "short_module": "H" }, { "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

Steel.Memory.slprop

Prims.Tot

[ "total" ]

[]

[ "Steel.Heap.emp", "Steel.Memory.slprop" ]

[]

false

true

false

let emp:slprop u#a =

H.emp

false

Steel.Memory.fst

Steel.Memory.pure

val pure (p:prop) : slprop u#a

let pure = H.pure

{ "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": 101, "start_col": 0, "start_line": 101 }

(* 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

{ "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.Heap", "short_module": "H" }, { "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: Prims.prop -> Steel.Memory.slprop

Prims.Tot

[ "total" ]

[]

[ "Steel.Heap.pure" ]

[]

false

true

false

let pure =

H.pure

false

Steel.Memory.fst

Steel.Memory.star

val star (p1 p2:slprop u#a) : slprop u#a

let star = H.star

{ "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": 105, "start_col": 0, "start_line": 105 }

(* 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

{ "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.Heap", "short_module": "H" }, { "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

p1: Steel.Memory.slprop -> p2: Steel.Memory.slprop -> Steel.Memory.slprop

Prims.Tot

[ "total" ]

[]

[ "Steel.Heap.star" ]

[]

false

true

false

let star =

H.star

false

Steel.Memory.fst

Steel.Memory.h_and

val h_and (p1 p2:slprop u#a) : slprop u#a

let h_and = H.h_and

{ "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": 103, "start_col": 0, "start_line": 103 }

(* 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

{ "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.Heap", "short_module": "H" }, { "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

p1: Steel.Memory.slprop -> p2: Steel.Memory.slprop -> Steel.Memory.slprop

Prims.Tot

[ "total" ]

[]

[ "Steel.Heap.h_and" ]

[]

false

true

false

let h_and =

H.h_and

false

Steel.Memory.fst

Steel.Memory.wand

val wand (p1 p2:slprop u#a) : slprop u#a

let wand = H.wand

{ "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": 106, "start_col": 0, "start_line": 106 }

(* 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

{ "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.Heap", "short_module": "H" }, { "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

p1: Steel.Memory.slprop -> p2: Steel.Memory.slprop -> Steel.Memory.slprop

Prims.Tot

[ "total" ]

[]

[ "Steel.Heap.wand" ]

[]

false

true

false

let wand =

H.wand

false

Steel.Memory.fst

Steel.Memory.h_forall

val h_forall (#a:Type u#b) (f: (a -> slprop u#a)) : slprop u#a

let h_forall = H.h_forall

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

{ "end_col": 25, "end_line": 108, "start_col": 0, "start_line": 108 }

(* 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

{ "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.Heap", "short_module": "H" }, { "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: (_: a -> Steel.Memory.slprop) -> Steel.Memory.slprop

Prims.Tot

[ "total" ]

[]

[ "Steel.Heap.h_forall" ]

[]

false

true

false

let h_forall =

H.h_forall

false

Steel.Memory.fst

Steel.Memory.h_exists

val h_exists (#a:Type u#b) (f: (a -> slprop u#a)) : slprop u#a

let h_exists = H.h_exists

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

{ "end_col": 25, "end_line": 107, "start_col": 0, "start_line": 107 }

(* 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

{ "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.Heap", "short_module": "H" }, { "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: (_: a -> Steel.Memory.slprop) -> Steel.Memory.slprop

Prims.Tot

[ "total" ]

[]

[ "Steel.Heap.h_exists" ]

[]

false

true

false

let h_exists =

H.h_exists

false

Steel.Memory.fst

Steel.Memory.h_or

val h_or (p1 p2:slprop u#a) : slprop u#a

let h_or = H.h_or

{ "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": 104, "start_col": 0, "start_line": 104 }

(* Copyright 2020 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module Steel.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

{ "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.Heap", "short_module": "H" }, { "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

p1: Steel.Memory.slprop -> p2: Steel.Memory.slprop -> Steel.Memory.slprop

Prims.Tot

[ "total" ]

[]

[ "Steel.Heap.h_or" ]

[]

false

true

false

let h_or =

H.h_or

false

Steel.Memory.fst

Steel.Memory.join_associative

val join_associative (m0 m1 m2:mem) : Lemma (requires disjoint m1 m2 /\ disjoint m0 (join m1 m2)) (ensures (disjoint_join m0 m1 m2; join m0 (join m1 m2) == join (join m0 m1) m2))

let join_associative m0 m1 m2 = H.join_associative m0.heap m1.heap m2.heap

{ "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": 75, "start_col": 0, "start_line": 74 }

(* 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

{ "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.Heap", "short_module": "H" }, { "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

m0: Steel.Memory.mem -> m1: Steel.Memory.mem -> m2: Steel.Memory.mem -> FStar.Pervasives.Lemma (requires Steel.Memory.disjoint m1 m2 /\ Steel.Memory.disjoint m0 (Steel.Memory.join m1 m2)) (ensures (Steel.Memory.disjoint_join m0 m1 m2; Steel.Memory.join m0 (Steel.Memory.join m1 m2) == Steel.Memory.join (Steel.Memory.join m0 m1) m2))

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Steel.Memory.mem", "Steel.Heap.join_associative", "Steel.Memory.__proj__Mkmem__item__heap", "Prims.unit" ]

[]

true

false

true

false

let join_associative m0 m1 m2 =

H.join_associative m0.heap m1.heap m2.heap

false

Steel.Memory.fst

Steel.Memory.slprop_extensionality

val slprop_extensionality (p q:slprop) : Lemma (requires p `equiv` q) (ensures p == q)

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

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

{ "end_col": 38, "end_line": 92, "start_col": 0, "start_line": 83 }

(* 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

{ "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.Heap", "short_module": "H" }, { "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 -> FStar.Pervasives.Lemma (requires Steel.Memory.equiv p q) (ensures p == q)

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Steel.Memory.slprop", "Steel.Heap.slprop_extensionality", "Prims.unit", "Prims._assert", "Prims.l_Forall", "Steel.Heap.heap", "Prims.l_iff", "Steel.Heap.interp", "Prims.l_True", "Prims.squash", "Prims.Cons", "FStar.Pervasives.pattern", "FStar.Pervasives.smt_pat", "Prims.prop", "Prims.Nil", "Steel.Memory.interp", "Steel.Memory.mem", "Steel.Memory.Mkmem", "Steel.Memory.lock_state" ]

[]

false

true

false

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

false

Hacl.Spec.Poly1305.Field32xN.Lemmas.fst

Hacl.Spec.Poly1305.Field32xN.Lemmas.load_felem5_4_interleave

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))

{ "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": 84, "end_line": 697, "start_col": 0, "start_line": 668 }

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))

{ "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

lo: Hacl.Spec.Poly1305.Field32xN.uint64xN 4 -> hi: Hacl.Spec.Poly1305.Field32xN.uint64xN 4 -> FStar.Pervasives.Lemma (ensures (let m0 = Lib.IntVector.vec_interleave_low_n 2 lo hi in let m1 = Lib.IntVector.vec_interleave_high_n 2 lo hi in let m2 = Lib.IntVector.cast Lib.IntTypes.U64 4 (Lib.IntVector.vec_shift_right (Lib.IntVector.cast Lib.IntTypes.U128 2 m0) 48ul) in let m3 = Lib.IntVector.cast Lib.IntTypes.U64 4 (Lib.IntVector.vec_shift_right (Lib.IntVector.cast Lib.IntTypes.U128 2 m1) 48ul) in let m4 = Lib.IntVector.vec_interleave_high m0 m1 in let t0 = Lib.IntVector.vec_interleave_low m0 m1 in let t3 = Lib.IntVector.vec_interleave_low m2 m3 in Lib.IntVector.vec_v m4 == Lib.Sequence.create4 (Lib.IntVector.vec_v lo).[ 1 ] (Lib.IntVector.vec_v lo).[ 3 ] (Lib.IntVector.vec_v hi).[ 1 ] (Lib.IntVector.vec_v hi).[ 3 ] /\ Lib.IntVector.vec_v t0 == Lib.Sequence.create4 (Lib.IntVector.vec_v lo).[ 0 ] (Lib.IntVector.vec_v lo).[ 2 ] (Lib.IntVector.vec_v hi).[ 0 ] (Lib.IntVector.vec_v hi).[ 2 ] /\ t3 == Lib.IntVector.vec_or (Lib.IntVector.vec_shift_right t0 48ul) (Lib.IntVector.vec_shift_left m4 16ul)))

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Hacl.Spec.Poly1305.Field32xN.uint64xN", "Lib.IntVector.vecv_extensionality", "Lib.IntTypes.U64", "Lib.IntVector.vec_or", "Lib.IntVector.vec_shift_right", "FStar.UInt32.__uint_to_t", "Lib.IntVector.vec_shift_left", "Prims.unit", "Lib.Sequence.eq_intro", "Lib.IntTypes.uint_t", "Lib.IntTypes.SEC", "Lib.IntVector.vec_v", "Lib.IntVector.vec_interleave_low_lemma_uint64_4", "Lib.IntVector.vec_t", "Lib.IntVector.vec_interleave_low", "Prims._assert", "Prims.eq2", "Lib.IntTypes.int_t", "Lib.Sequence.op_String_Access", "Lib.IntTypes.op_Bar_Dot", "Lib.IntTypes.op_Greater_Greater_Dot", "Lib.IntTypes.op_Less_Less_Dot", "Lib.IntVector.vec_shift_right_uint128_small2", "Lib.IntVector.cast", "Lib.IntTypes.U128", "Lib.Sequence.lseq", "Lib.Sequence.create4", "Lib.IntVector.vec_interleave_high_lemma_uint64_4", "Lib.IntVector.vec_interleave_high", "Lib.IntVector.vec_interleave_high_n_lemma_uint64_4_2", "Lib.IntVector.vec_interleave_high_n", "Lib.IntVector.vec_interleave_low_n_lemma_uint64_4_2", "Lib.IntVector.vec_interleave_low_n" ]

[]

true

false

true

false

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; let m1 = vec_interleave_high_n 2 lo hi in vec_interleave_high_n_lemma_uint64_4_2 lo hi; let m4 = vec_interleave_high m0 m1 in vec_interleave_high_lemma_uint64_4 m0 m1; 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 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))

false

Steel.Memory.fst

Steel.Memory.core_ref_is_null

val core_ref_is_null (r:core_ref) : b:bool { b <==> r == core_ref_null }

let core_ref_is_null r = H.core_ref_is_null r

{ "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": 98, "start_col": 0, "start_line": 98 }

(* 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

{ "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.Heap", "short_module": "H" }, { "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.core_ref -> b: Prims.bool{b <==> r == Steel.Memory.core_ref_null}

Prims.Tot

[ "total" ]

[]

[ "Steel.Memory.core_ref", "Steel.Heap.core_ref_is_null", "Prims.bool", "Prims.l_iff", "Prims.b2t", "Prims.eq2", "Steel.Memory.core_ref_null" ]

[]

false

let core_ref_is_null r =

H.core_ref_is_null r

false

Steel.Memory.fst

Steel.Memory.equiv_symmetric

val equiv_symmetric (p1 p2:slprop) : squash (p1 `equiv` p2 ==> p2 `equiv` p1)

let equiv_symmetric (p1 p2:slprop u#a) = H.equiv_symmetric p1 p2

{ "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": 114, "start_col": 0, "start_line": 114 }

(* 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 ////////////////////////////////////////////////////////////////////////////////

{ "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.Heap", "short_module": "H" }, { "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

p1: Steel.Memory.slprop -> p2: Steel.Memory.slprop -> Prims.squash (Steel.Memory.equiv p1 p2 ==> Steel.Memory.equiv p2 p1)

Prims.Tot

[ "total" ]

[]

[ "Steel.Memory.slprop", "Steel.Heap.equiv_symmetric", "Prims.squash", "Prims.l_imp", "Steel.Memory.equiv" ]

[]

false

true

false

let equiv_symmetric (p1 p2: slprop u#a) =

H.equiv_symmetric p1 p2

false

Hacl.Spec.Poly1305.Field32xN.Lemmas.fst

Hacl.Spec.Poly1305.Field32xN.Lemmas.load_acc5_4_lemma

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)

{ "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": 52, "end_line": 815, "start_col": 0, "start_line": 798 }

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)]

{ "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: Hacl.Spec.Poly1305.Field32xN.felem5 4 {Hacl.Spec.Poly1305.Field32xN.felem_fits5 f (2, 2, 2, 2, 2)} -> e: Hacl.Spec.Poly1305.Field32xN.felem5 4 {Hacl.Spec.Poly1305.Field32xN.felem_fits5 e (1, 1, 1, 1, 1)} -> FStar.Pervasives.Lemma (ensures (let res = Hacl.Spec.Poly1305.Field32xN.load_acc5_4 f e in Hacl.Spec.Poly1305.Field32xN.felem_fits5 res (3, 3, 3, 3, 3) /\ Hacl.Spec.Poly1305.Field32xN.feval5 res == Hacl.Spec.Poly1305.Vec.fadd (Lib.Sequence.create4 (Hacl.Spec.Poly1305.Field32xN.feval5 f).[ 0 ] 0 0 0) (Hacl.Spec.Poly1305.Field32xN.feval5 e))) [SMTPat (Hacl.Spec.Poly1305.Field32xN.load_acc5_4 f e)]

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Hacl.Spec.Poly1305.Field32xN.felem5", "Hacl.Spec.Poly1305.Field32xN.felem_fits5", "FStar.Pervasives.Native.Mktuple5", "Prims.nat", "Hacl.Spec.Poly1305.Field32xN.uint64xN", "Lib.IntVector.vec_t", "Lib.IntTypes.U64", "Lib.Sequence.eq_intro", "Hacl.Spec.Poly1305.Vec.pfelem", "Hacl.Spec.Poly1305.Field32xN.feval5", "Lib.Sequence.create4", "Lib.Sequence.op_String_Access", "Prims.unit", "Prims._assert", "Prims.eq2", "Prims.int", "Prims.l_or", "FStar.Seq.Base.index", "Lib.Sequence.to_seq", "FStar.Pervasives.Native.tuple5", "Lib.Sequence.lseq", "Lib.IntTypes.int_t", "Lib.IntTypes.SEC", "Lib.IntVector.vec_v", "Lib.Sequence.upd", "Lib.IntTypes.v", "Lib.IntTypes.U32", "Lib.IntTypes.PUB", "FStar.UInt32.uint_to_t", "FStar.UInt32.t", "Lib.IntVector.vec_get", "Lib.IntVector.vec_set", "FStar.UInt32.__uint_to_t", "Hacl.Spec.Poly1305.Field32xN.zero" ]

[]

false

true

false

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)

false

Steel.Memory.fst

Steel.Memory.equiv_heap_iff_equiv

val equiv_heap_iff_equiv (p1 p2: slprop u#a) : Lemma (ensures (H.equiv p1 p2 <==> equiv p1 p2)) [SMTPat (equiv p1 p2)]

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 ()

{ "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": 147, "start_col": 0, "start_line": 117 }

(* 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

{ "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.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

p1: Steel.Memory.slprop -> p2: Steel.Memory.slprop -> FStar.Pervasives.Lemma (ensures Steel.Heap.equiv p1 p2 <==> Steel.Memory.equiv p1 p2) [SMTPat (Steel.Memory.equiv p1 p2)]

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Steel.Memory.slprop", "Prims.unit", "Steel.Memory.equiv", "Prims.squash", "Steel.Heap.equiv", "Prims.Cons", "FStar.Pervasives.pattern", "FStar.Pervasives.smt_pat", "Prims.Nil", "Steel.Heap.heap", "Prims.l_and", "Steel.Heap.interp", "Prims._assert", "Steel.Memory.interp", "Steel.Memory.mem_of_heap", "Prims.l_True", "Prims.l_iff", "Prims.prop" ]

[]

false

true

false

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 ()

false

Steel.Memory.fst

Steel.Memory.equiv_extensional_on_star

val equiv_extensional_on_star (p1 p2 p3:slprop) : squash (p1 `equiv` p2 ==> (p1 `star` p3) `equiv` (p2 `star` p3))

let equiv_extensional_on_star (p1 p2 p3:slprop u#a) = equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3

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

{ "end_col": 38, "end_line": 161, "start_col": 0, "start_line": 159 }

(* 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

{ "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.Heap", "short_module": "H" }, { "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

p1: Steel.Memory.slprop -> p2: Steel.Memory.slprop -> p3: Steel.Memory.slprop -> Prims.squash (Steel.Memory.equiv p1 p2 ==> Steel.Memory.equiv (Steel.Memory.star p1 p3) (Steel.Memory.star p2 p3))

Prims.Tot

[ "total" ]

[]

[ "Steel.Memory.slprop", "Steel.Heap.equiv_extensional_on_star", "Prims.unit", "Steel.Memory.equiv_heap_iff_equiv_forall", "Prims.squash", "Prims.l_imp", "Steel.Memory.equiv", "Steel.Memory.star" ]

[]

false

true

false

let equiv_extensional_on_star (p1 p2 p3: slprop u#a) =

equiv_heap_iff_equiv_forall (); H.equiv_extensional_on_star p1 p2 p3

false

Steel.Memory.fst

Steel.Memory.inames_in

val inames_in (e: inames) (l: lock_store) : prop

let inames_in (e:inames) (l:lock_store) : prop = forall i. Set.mem i e ==> i < L.length l

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

{ "end_col": 89, "end_line": 280, "start_col": 0, "start_line": 280 }

(* 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)

{ "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

e: Steel.Memory.inames -> l: Steel.Memory.lock_store -> Prims.prop

Prims.Tot

[ "total" ]

[]

[ "Steel.Memory.inames", "Steel.Memory.lock_store", "Prims.l_Forall", "Prims.int", "Prims.b2t", "Prims.op_GreaterThanOrEqual", "Prims.l_imp", "FStar.Set.mem", "Steel.Memory.iname", "FStar.Ghost.reveal", "FStar.Set.set", "Prims.op_LessThan", "FStar.List.Tot.Base.length", "Steel.Memory.lock_state", "Prims.prop" ]

[]

false

true

let inames_in (e: inames) (l: lock_store) : prop =

forall i. Set.mem i e ==> i < L.length l

false

Steel.Memory.fst

Steel.Memory.pure_interp

val pure_interp (q:prop) (m:mem) : Lemma (interp (pure q) m <==> q)

let pure_interp q m = H.pure_interp q (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": 53, "end_line": 168, "start_col": 0, "start_line": 168 }

(* 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)

{ "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.Heap", "short_module": "H" }, { "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 -> m: Steel.Memory.mem -> FStar.Pervasives.Lemma (ensures Steel.Memory.interp (Steel.Memory.pure q) m <==> q)

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Prims.prop", "Steel.Memory.mem", "Steel.Heap.pure_interp", "Steel.Memory.heap_of_mem", "Prims.unit" ]

[]

true

false

true

false

let pure_interp q m =

H.pure_interp q (heap_of_mem m)

false

Steel.Memory.fst

Steel.Memory.pure_equiv

val pure_equiv (p q:prop) : Lemma ((p <==> q) ==> (pure p `equiv` pure q))

let pure_equiv p q = H.pure_equiv p q

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

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

(* 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)

{ "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.Heap", "short_module": "H" }, { "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: Prims.prop -> q: Prims.prop -> FStar.Pervasives.Lemma (ensures (p <==> q) ==> Steel.Memory.equiv (Steel.Memory.pure p) (Steel.Memory.pure q))

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Prims.prop", "Steel.Heap.pure_equiv", "Prims.unit" ]

[]

true

false

true

false

let pure_equiv p q =

H.pure_equiv p q

false

Steel.Memory.fst

Steel.Memory.equiv_heap_iff_equiv_forall

val equiv_heap_iff_equiv_forall: Prims.unit -> Lemma (ensures (forall p1 p2. H.equiv p1 p2 <==> equiv p1 p2))

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 ()

{ "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": 156, "start_col": 0, "start_line": 149 }

(* 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 ()

{ "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.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

_: Prims.unit -> FStar.Pervasives.Lemma (ensures forall (p1: Steel.Heap.slprop) (p2: Steel.Heap.slprop). Steel.Heap.equiv p1 p2 <==> Steel.Memory.equiv p1 p2)

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Prims.unit", "Steel.Heap.slprop", "Prims.l_True", "Prims.squash", "Prims.l_iff", "Steel.Heap.equiv", "Steel.Memory.equiv", "Prims.Cons", "FStar.Pervasives.pattern", "FStar.Pervasives.smt_pat", "Prims.Nil", "Steel.Memory.equiv_heap_iff_equiv", "Prims.l_Forall" ]

[]

false

true

false

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 ()

false

Steel.Memory.fst

Steel.Memory.pts_to_not_null

val pts_to_not_null (#a:Type u#a) (#pcm:_) (x:ref a pcm) (v:a) (m:mem u#a) : Lemma (requires interp (pts_to x v) m) (ensures x =!= null)

let pts_to_not_null #a #pcm x v m = H.pts_to_not_null #a #pcm x v (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": 180, "start_col": 0, "start_line": 179 }

(* 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

{ "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.Heap", "short_module": "H" }, { "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

x: Steel.Memory.ref a pcm -> v: a -> m: Steel.Memory.mem -> FStar.Pervasives.Lemma (requires Steel.Memory.interp (Steel.Memory.pts_to x v) m) (ensures ~(x == Steel.Memory.null))

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "FStar.PCM.pcm", "Steel.Memory.ref", "Steel.Memory.mem", "Steel.Heap.pts_to_not_null", "Steel.Memory.heap_of_mem", "Prims.unit" ]

[]

true

false

true

false

let pts_to_not_null #a #pcm x v m =

H.pts_to_not_null #a #pcm x v (heap_of_mem m)

false

Steel.Memory.fst

Steel.Memory.inames_ok

val inames_ok (e:inames) (m:mem) : prop

let inames_ok e m = inames_in e m.locks

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

{ "end_col": 39, "end_line": 282, "start_col": 0, "start_line": 282 }

(* 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

{ "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": "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 -> m: Steel.Memory.mem -> Prims.prop

Prims.Tot

[ "total" ]

[]

[ "Steel.Memory.inames", "Steel.Memory.mem", "Steel.Memory.inames_in", "Steel.Memory.__proj__Mkmem__item__locks", "Prims.prop" ]

[]

false

true

let inames_ok e m =

inames_in e m.locks

false

Steel.Memory.fst

Steel.Memory.star_commutative

val star_commutative (p1 p2:slprop) : Lemma ((p1 `star` p2) `equiv` (p2 `star` p1))

let star_commutative (p1 p2:slprop) = H.star_commutative p1 p2

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

{ "end_col": 26, "end_line": 234, "start_col": 0, "start_line": 233 }

(* 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 ()

{ "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.Heap", "short_module": "H" }, { "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

p1: Steel.Memory.slprop -> p2: Steel.Memory.slprop -> FStar.Pervasives.Lemma (ensures Steel.Memory.equiv (Steel.Memory.star p1 p2) (Steel.Memory.star p2 p1))

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Steel.Memory.slprop", "Steel.Heap.star_commutative", "Prims.unit" ]

[]

true

false

true

false

let star_commutative (p1 p2: slprop) =

H.star_commutative p1 p2

false

Steel.Memory.fst

Steel.Memory.intro_star

val intro_star (p q:slprop) (mp:hmem p) (mq:hmem q) : Lemma (requires disjoint mp mq) (ensures interp (p `star` q) (join mp mq))

let intro_star p q mp mq = H.intro_star p q (heap_of_mem mp) (heap_of_mem mq)

{ "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": 187, "start_col": 0, "start_line": 186 }

(* 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 ////////////////////////////////////////////////////////////////////////////////

{ "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.Heap", "short_module": "H" }, { "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 -> mp: Steel.Memory.hmem p -> mq: Steel.Memory.hmem q -> FStar.Pervasives.Lemma (requires Steel.Memory.disjoint mp mq) (ensures Steel.Memory.interp (Steel.Memory.star p q) (Steel.Memory.join mp mq))

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Steel.Memory.slprop", "Steel.Memory.hmem", "Steel.Heap.intro_star", "Steel.Memory.heap_of_mem", "Prims.unit" ]

[]

true

false

true

false

let intro_star p q mp mq =

H.intro_star p q (heap_of_mem mp) (heap_of_mem mq)

false

Steel.Memory.fst

Steel.Memory.pure_star_interp

val pure_star_interp (p:slprop u#a) (q:prop) (m:mem) : Lemma (interp (p `star` pure q) m <==> interp (p `star` emp) m /\ q)

let pure_star_interp p q m = H.pure_star_interp p q (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": 67, "end_line": 169, "start_col": 0, "start_line": 169 }

(* 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

{ "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.Heap", "short_module": "H" }, { "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: Prims.prop -> m: Steel.Memory.mem -> FStar.Pervasives.Lemma (ensures Steel.Memory.interp (Steel.Memory.star p (Steel.Memory.pure q)) m <==> Steel.Memory.interp (Steel.Memory.star p Steel.Memory.emp) m /\ q)

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Steel.Memory.slprop", "Prims.prop", "Steel.Memory.mem", "Steel.Heap.pure_star_interp", "Steel.Memory.heap_of_mem", "Prims.unit" ]

[]

true

false

true

false

let pure_star_interp p q m =

H.pure_star_interp p q (heap_of_mem m)

false

Steel.Memory.fst

Steel.Memory.set_add

val set_add : i: Steel.Memory.iname -> s: Steel.Memory.inames -> Prims.GTot (FStar.Set.set Steel.Memory.iname)

let set_add (i:iname) (s:inames) = Set.union (Set.singleton i) s

{ "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": 294, "start_col": 0, "start_line": 294 }

(* 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 |)

{ "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

i: Steel.Memory.iname -> s: Steel.Memory.inames -> Prims.GTot (FStar.Set.set Steel.Memory.iname)

Prims.GTot

[ "sometrivial" ]

[]

[ "Steel.Memory.iname", "Steel.Memory.inames", "FStar.Set.union", "FStar.Set.singleton", "FStar.Ghost.reveal", "FStar.Set.set" ]

[]

false

let set_add (i: iname) (s: inames) =

Set.union (Set.singleton i) s

false

Steel.Memory.fst

Steel.Memory.emp_unit

val emp_unit (p:slprop) : Lemma (p `equiv` (p `star` emp))

let emp_unit p = H.emp_unit p

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

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

(* 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

{ "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.Heap", "short_module": "H" }, { "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 p (Steel.Memory.star p Steel.Memory.emp))

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Steel.Memory.slprop", "Steel.Heap.emp_unit", "Prims.unit" ]

[]

true

false

true

false

let emp_unit p =

H.emp_unit p

false

Steel.Memory.fst

Steel.Memory.star_associative

val star_associative (p1 p2 p3:slprop) : Lemma ((p1 `star` (p2 `star` p3)) `equiv` ((p1 `star` p2) `star` p3))

let star_associative (p1 p2 p3:slprop) = H.star_associative p1 p2 p3

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

{ "end_col": 29, "end_line": 237, "start_col": 0, "start_line": 236 }

(* 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

{ "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.Heap", "short_module": "H" }, { "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

p1: Steel.Memory.slprop -> p2: Steel.Memory.slprop -> p3: Steel.Memory.slprop -> FStar.Pervasives.Lemma (ensures Steel.Memory.equiv (Steel.Memory.star p1 (Steel.Memory.star p2 p3)) (Steel.Memory.star (Steel.Memory.star p1 p2) p3))

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Steel.Memory.slprop", "Steel.Heap.star_associative", "Prims.unit" ]

[]

true

false

true

false

let star_associative (p1 p2 p3: slprop) =

H.star_associative p1 p2 p3

false

Steel.Memory.fst

Steel.Memory.intro_emp

val intro_emp (m:mem) : Lemma (interp emp m)

let intro_emp m = H.intro_emp (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": 165, "start_col": 0, "start_line": 165 }

(* 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

{ "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.Heap", "short_module": "H" }, { "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.mem -> FStar.Pervasives.Lemma (ensures Steel.Memory.interp Steel.Memory.emp m)

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Steel.Memory.mem", "Steel.Heap.intro_emp", "Steel.Memory.heap_of_mem", "Prims.unit" ]

[]

true

false

true

false

let intro_emp m =

H.intro_emp (heap_of_mem m)

false

Steel.Memory.fst

Steel.Memory.locks_invariant

val locks_invariant (e:inames) (m:mem u#a) : slprop u#a

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)

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

{ "end_col": 37, "end_line": 347, "start_col": 0, "start_line": 344 }

(* Copyright 2020 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module Steel.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)

{ "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": "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 -> m: Steel.Memory.mem -> Steel.Memory.slprop

Prims.Tot

[ "total" ]

[]

[ "Steel.Memory.inames", "Steel.Memory.mem", "Steel.Memory.star", "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", "Steel.Memory.slprop" ]

[]

false

true

false

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))

false

Steel.Memory.fst

Steel.Memory.heap_ctr_valid

val heap_ctr_valid (ctr: nat) (h: H.heap u#a) : prop

let heap_ctr_valid (ctr:nat) (h:H.heap u#a) : prop = h `H.free_above_addr` ctr

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

{ "end_col": 29, "end_line": 339, "start_col": 0, "start_line": 338 }

(* 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

{ "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

ctr: Prims.nat -> h: Steel.Heap.heap -> Prims.prop

Prims.Tot

[ "total" ]

[]

[ "Prims.nat", "Steel.Heap.heap", "Steel.Heap.free_above_addr", "Prims.prop" ]

[]

false

true

let heap_ctr_valid (ctr: nat) (h: H.heap u#a) : prop =

h `H.free_above_addr` ctr

false

Steel.Memory.fst

Steel.Memory.elim_star

val elim_star (p q:slprop) (m:hmem (p `star` q)) : Lemma (requires interp (p `star` q) m) (ensures exists ml mr. disjoint ml mr /\ m == join ml mr /\ interp p ml /\ interp q mr)

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); ()

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

{ "end_col": 4, "end_line": 203, "start_col": 0, "start_line": 189 }

(* 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)

{ "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.Heap", "short_module": "H" }, { "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 -> m: Steel.Memory.hmem (Steel.Memory.star p q) -> FStar.Pervasives.Lemma (requires Steel.Memory.interp (Steel.Memory.star p q) m) (ensures exists (ml: Steel.Memory.mem) (mr: m1: Steel.Memory.mem{Steel.Memory.disjoint ml m1}). Steel.Memory.disjoint ml mr /\ m == Steel.Memory.join ml mr /\ Steel.Memory.interp p ml /\ Steel.Memory.interp q mr)

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Steel.Memory.slprop", "Steel.Memory.hmem", "Steel.Memory.star", "Prims.unit", "Prims._assert", "Steel.Memory.interp", "Prims.eq2", "Steel.Memory.mem", "Steel.Memory.join", "Steel.Memory.disjoint", "Steel.Memory.mem_set_heap", "FStar.Ghost.reveal", "Steel.Heap.heap", "FStar.Ghost.erased", "Prims.l_and", "Steel.Heap.disjoint", "Steel.Heap.join", "Steel.Heap.interp", "FStar.IndefiniteDescription.indefinite_description_tot", "Prims.prop", "Prims.l_Exists", "Steel.Heap.elim_star", "Steel.Memory.heap_of_mem" ]

[]

false

true

false

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); ()

false

Steel.Memory.fst

Steel.Memory.pts_to_compatible

val pts_to_compatible (#a:Type u#a) (#pcm:pcm a) (x:ref a pcm) (v0 v1:a) (m:mem u#a) : Lemma (interp (pts_to x v0 `star` pts_to x v1) m <==> composable pcm v0 v1 /\ interp (pts_to x (op pcm v0 v1)) m)

let pts_to_compatible #a #pcm x v0 v1 m = H.pts_to_compatible #a #pcm x v0 v1 (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": 55, "end_line": 176, "start_col": 0, "start_line": 175 }

(* 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 ////////////////////////////////////////////////////////////////////////////////

{ "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.Heap", "short_module": "H" }, { "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

x: Steel.Memory.ref a pcm -> v0: a -> v1: a -> m: Steel.Memory.mem -> FStar.Pervasives.Lemma (ensures Steel.Memory.interp (Steel.Memory.star (Steel.Memory.pts_to x v0) (Steel.Memory.pts_to x v1)) m <==> FStar.PCM.composable pcm v0 v1 /\ Steel.Memory.interp (Steel.Memory.pts_to x (FStar.PCM.op pcm v0 v1)) m)

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "FStar.PCM.pcm", "Steel.Memory.ref", "Steel.Memory.mem", "Steel.Heap.pts_to_compatible", "Steel.Memory.heap_of_mem", "Prims.unit" ]

[]

true

false

true

false

let pts_to_compatible #a #pcm x v0 v1 m =

H.pts_to_compatible #a #pcm x v0 v1 (heap_of_mem m)

false

Steel.Memory.fst

Steel.Memory.iname

val iname : eqtype

let iname = nat

{ "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": 250, "start_col": 0, "start_line": 250 }

(* 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 ////////////////////////////////////////////////////////////////////////////////

{ "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.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

Prims.eqtype

Prims.Tot

[ "total" ]

[]

[ "Prims.nat" ]

[]

false

true

false

let iname =

nat

false

Steel.Memory.fst

Steel.Memory.lock_i

val lock_i : i: Steel.Memory.iname -> l: Steel.Memory.lock_store{i < FStar.List.Tot.Base.length l} -> Steel.Memory.lock_state

let lock_i (i:iname) (l:lock_store { i < L.length l }) = let ix = L.length l - i - 1 in L.index l ix

{ "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": 267, "start_col": 0, "start_line": 265 }

(* 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

{ "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

i: Steel.Memory.iname -> l: Steel.Memory.lock_store{i < FStar.List.Tot.Base.length l} -> Steel.Memory.lock_state

Prims.Tot

[ "total" ]

[]

[ "Steel.Memory.iname", "Steel.Memory.lock_store", "Prims.b2t", "Prims.op_LessThan", "FStar.List.Tot.Base.length", "Steel.Memory.lock_state", "FStar.List.Tot.Base.index", "Prims.int", "Prims.op_Subtraction" ]

[]

false

let lock_i (i: iname) (l: lock_store{i < L.length l}) =

let ix = L.length l - i - 1 in L.index l ix

false

Steel.Memory.fst

Steel.Memory.interp_star

val 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 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 ()

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

{ "end_col": 30, "end_line": 231, "start_col": 0, "start_line": 205 }

(* 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); ()

{ "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.Heap", "short_module": "H" }, { "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 -> m: Steel.Memory.mem -> FStar.Pervasives.Lemma (ensures Steel.Memory.interp (Steel.Memory.star p q) m <==> (exists (mp: Steel.Memory.mem) (mq: Steel.Memory.mem). Steel.Memory.disjoint mp mq /\ Steel.Memory.interp p mp /\ Steel.Memory.interp q mq /\ Steel.Memory.join mp mq == m))

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Steel.Memory.slprop", "Steel.Memory.mem", "FStar.Classical.move_requires", "Prims.unit", "Prims.squash", "Prims.Nil", "FStar.Pervasives.pattern", "FStar.Classical.exists_elim", "Prims.l_Exists", "Prims.l_and", "Steel.Memory.disjoint", "Steel.Memory.interp", "Prims.eq2", "Steel.Memory.join", "Steel.Memory.intro_star", "Steel.Memory.elim_star", "Prims.logical", "Prims.prop", "Steel.Memory.star", "Prims.l_True", "Prims.l_iff" ]

[]

false

true

false

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 ()

false

Steel.Memory.fst

Steel.Memory.pts_to_compatible_equiv

val pts_to_compatible_equiv (#a:Type) (#pcm:_) (x:ref a pcm) (v0:a) (v1:a{composable pcm v0 v1}) : Lemma (equiv (pts_to x v0 `star` pts_to x v1) (pts_to x (op pcm v0 v1)))

let pts_to_compatible_equiv #a #pcm x v0 v1 = H.pts_to_compatible_equiv #a #pcm x 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": 45, "end_line": 178, "start_col": 0, "start_line": 177 }

(* 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

{ "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.Heap", "short_module": "H" }, { "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

x: Steel.Memory.ref a pcm -> v0: a -> v1: a{FStar.PCM.composable pcm v0 v1} -> FStar.Pervasives.Lemma (ensures Steel.Memory.equiv (Steel.Memory.star (Steel.Memory.pts_to x v0) (Steel.Memory.pts_to x v1)) (Steel.Memory.pts_to x (FStar.PCM.op pcm v0 v1)))

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "FStar.PCM.pcm", "Steel.Memory.ref", "FStar.PCM.composable", "Steel.Heap.pts_to_compatible_equiv", "Prims.unit" ]

[]

true

false

true

false

let pts_to_compatible_equiv #a #pcm x v0 v1 =

H.pts_to_compatible_equiv #a #pcm x v0 v1

false

Steel.Memory.fst

Steel.Memory.ctr_validity

val ctr_validity (ctr: nat) (h: H.heap) : slprop

let ctr_validity (ctr:nat) (h:H.heap) : slprop = H.pure (heap_ctr_valid ctr h)

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

{ "end_col": 33, "end_line": 342, "start_col": 0, "start_line": 341 }

(* 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

{ "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

ctr: Prims.nat -> h: Steel.Heap.heap -> Steel.Memory.slprop

Prims.Tot

[ "total" ]

[]

[ "Prims.nat", "Steel.Heap.heap", "Steel.Heap.pure", "Steel.Memory.heap_ctr_valid", "Steel.Memory.slprop" ]

[]

false

true

false

let ctr_validity (ctr: nat) (h: H.heap) : slprop =

H.pure (heap_ctr_valid ctr h)

false

Steel.Memory.fst

Steel.Memory.affine_star

val affine_star (p q:slprop) (m:mem) : Lemma ((interp (p `star` q) m ==> interp p m /\ interp q m))

let affine_star (p q:slprop) (m:mem) = H.affine_star p q (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": 35, "end_line": 244, "start_col": 0, "start_line": 243 }

(* 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

{ "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.Heap", "short_module": "H" }, { "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 -> m: Steel.Memory.mem -> FStar.Pervasives.Lemma (ensures Steel.Memory.interp (Steel.Memory.star p q) m ==> Steel.Memory.interp p m /\ Steel.Memory.interp q m)

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Steel.Memory.slprop", "Steel.Memory.mem", "Steel.Heap.affine_star", "Steel.Memory.heap_of_mem", "Prims.unit" ]

[]

true

false

true

false

let affine_star (p q: slprop) (m: mem) =

H.affine_star p q (heap_of_mem m)

false

Steel.Memory.fst

Steel.Memory.refine_slprop

val refine_slprop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (slprop u#a)

let refine_slprop sl f = H.as_slprop (a_mem_prop_as_a_heap_prop sl f)

{ "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": 377, "start_col": 0, "start_line": 377 }

(* 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

{ "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": "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

sl: Steel.Memory.slprop -> f: Steel.Memory.a_mem_prop sl -> Steel.Memory.slprop

Prims.Tot

[ "total" ]

[]

[ "Steel.Memory.slprop", "Steel.Memory.a_mem_prop", "Steel.Heap.as_slprop", "Steel.Memory.a_mem_prop_as_a_heap_prop" ]

[]

false

let refine_slprop sl f =

H.as_slprop (a_mem_prop_as_a_heap_prop sl f)

false

Steel.Memory.fst

Steel.Memory.full_mem_pred

val full_mem_pred: mem -> prop

let full_mem_pred (m:mem) = H.full_heap_pred (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": 60, "end_line": 349, "start_col": 0, "start_line": 349 }

(* 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)

{ "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": "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

m: Steel.Memory.mem -> Prims.prop

Prims.Tot

[ "total" ]

[]

[ "Steel.Memory.mem", "Steel.Heap.full_heap_pred", "Steel.Memory.heap_of_mem", "Prims.prop" ]

[]

false

true

let full_mem_pred (m: mem) =

H.full_heap_pred (heap_of_mem m)

false

Steel.Memory.fst

Steel.Memory.lock_store_invariant

val lock_store_invariant (e: inames) (l: lock_store u#a) : slprop u#a

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

{ "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": 263, "start_col": 0, "start_line": 255 }

(* 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

{ "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

e: Steel.Memory.inames -> l: Steel.Memory.lock_store -> Steel.Memory.slprop

Prims.Tot

[ "total" ]

[]

[ "Steel.Memory.inames", "Steel.Memory.lock_store", "Steel.Memory.emp", "Steel.Heap.slprop", "Prims.list", "Steel.Memory.lock_state", "FStar.Set.mem", "Steel.Memory.iname", "FStar.Ghost.reveal", "FStar.Set.set", "Steel.Memory.lock_store_invariant", "Prims.bool", "Steel.Memory.star", "Steel.Memory.slprop", "Prims.int", "Prims.op_Subtraction", "FStar.List.Tot.Base.length" ]

[ "recursion" ]

false

true

false

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)

false

Steel.Memory.fst

Steel.Memory.star_congruence

val star_congruence (p1 p2 p3 p4:slprop) : Lemma (requires p1 `equiv` p3 /\ p2 `equiv` p4) (ensures (p1 `star` p2) `equiv` (p3 `star` p4))

let star_congruence (p1 p2 p3 p4:slprop) = equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4

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

{ "end_col": 31, "end_line": 241, "start_col": 0, "start_line": 239 }

(* 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

{ "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.Heap", "short_module": "H" }, { "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

p1: Steel.Memory.slprop -> p2: Steel.Memory.slprop -> p3: Steel.Memory.slprop -> p4: Steel.Memory.slprop -> FStar.Pervasives.Lemma (requires Steel.Memory.equiv p1 p3 /\ Steel.Memory.equiv p2 p4) (ensures Steel.Memory.equiv (Steel.Memory.star p1 p2) (Steel.Memory.star p3 p4))

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Steel.Memory.slprop", "Steel.Heap.star_congruence", "Prims.unit", "Steel.Memory.equiv_heap_iff_equiv_forall" ]

[]

true

false

true

false

let star_congruence (p1 p2 p3 p4: slprop) =

equiv_heap_iff_equiv_forall (); H.star_congruence p1 p2 p3 p4

false

Steel.Memory.fst

Steel.Memory.lock_store_evolves

val lock_store_evolves:FStar.Preorder.preorder lock_store

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)

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

{ "end_col": 46, "end_line": 278, "start_col": 0, "start_line": 274 }

(* 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

{ "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

FStar.Preorder.preorder Steel.Memory.lock_store

Prims.Tot

[ "total" ]

[]

[ "Steel.Memory.lock_store", "Prims.l_and", "Prims.b2t", "Prims.op_GreaterThanOrEqual", "FStar.List.Tot.Base.length", "Steel.Memory.lock_state", "Prims.l_Forall", "Prims.nat", "Prims.op_LessThan", "Prims.eq2", "Steel.Heap.slprop", "Steel.Memory.__proj__Invariant__item__inv", "Steel.Memory.lock_i", "Prims.logical" ]

[]

false

true

false

let lock_store_evolves:FStar.Preorder.preorder lock_store =

fun (l1: lock_store) (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)

false

Steel.Memory.fst

Steel.Memory.impl_intro_gen

val impl_intro_gen (#p #q: Type0) ($prf: (squash p -> Lemma (q))) : Lemma (p ==> q)

let impl_intro_gen (#p: Type0) (#q: Type0) ($prf: (squash p -> Lemma (q ))) : Lemma (p ==> q) = Classical.impl_intro_gen #p #(fun _ -> q) prf

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

{ "end_col": 47, "end_line": 427, "start_col": 0, "start_line": 425 }

(* 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')

{ "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

$prf: (_: Prims.squash p -> FStar.Pervasives.Lemma (ensures q)) -> FStar.Pervasives.Lemma (ensures p ==> q)

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Prims.squash", "Prims.unit", "Prims.l_True", "Prims.Nil", "FStar.Pervasives.pattern", "FStar.Classical.impl_intro_gen", "Prims.l_imp" ]

[]

false

true

false

let impl_intro_gen (#p #q: Type0) ($prf: (squash p -> Lemma (q))) : Lemma (p ==> q) =

Classical.impl_intro_gen #p #(fun _ -> q) prf

false

Hacl.Spec.Poly1305.Field32xN.Lemmas.fst

Hacl.Spec.Poly1305.Field32xN.Lemmas.load_felem5_4_lemma

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

{ "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": 25, "end_line": 741, "start_col": 0, "start_line": 730 }

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]))

{ "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

lo: Hacl.Spec.Poly1305.Field32xN.uint64xN 4 -> hi: Hacl.Spec.Poly1305.Field32xN.uint64xN 4 -> FStar.Pervasives.Lemma (ensures (let f = Hacl.Spec.Poly1305.Field32xN.Lemmas.load_felem5_4_compact lo hi 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 == Lib.Sequence.createi 4 (fun i -> (Hacl.Spec.Poly1305.Field32xN.uint64xN_v hi).[ i ] * Prims.pow2 64 + (Hacl.Spec.Poly1305.Field32xN.uint64xN_v lo).[ i ])))

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Hacl.Spec.Poly1305.Field32xN.uint64xN", "Lib.Sequence.eq_intro", "Hacl.Spec.Poly1305.Vec.pfelem", "Hacl.Spec.Poly1305.Field32xN.feval5", "Prims.unit", "Hacl.Spec.Poly1305.Field32xN.Lemmas.load_felem5_4_compact_lemma_i", "Lib.Sequence.lseq", "Prims.l_Forall", "Prims.nat", "Prims.l_imp", "Prims.b2t", "Prims.op_LessThan", "Prims.eq2", "Lib.Sequence.index", "Prims.op_Addition", "Prims.op_Multiply", "Hacl.Spec.Poly1305.Field32xN.uint64xN_v", "Prims.pow2", "Lib.Sequence.createi", "FStar.Mul.op_Star", "Lib.Sequence.op_String_Access", "FStar.Pervasives.assert_norm", "Hacl.Spec.Poly1305.Vec.prime", "Prims.op_Equality", "Prims.int", "Hacl.Spec.Poly1305.Field32xN.felem5", "Hacl.Spec.Poly1305.Field32xN.Lemmas.load_felem5_4_compact" ]

[]

false

true

false

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

false

Steel.Memory.fst

Steel.Memory.extend_lock_store

val 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'}

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 |)

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

{ "end_col": 38, "end_line": 292, "start_col": 0, "start_line": 286 }

(* 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 = ()

{ "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

e: Steel.Memory.inames -> l: Steel.Memory.lock_store{Steel.Memory.inames_in e l} -> p: Steel.Memory.slprop -> Prims.dtuple2 Steel.Memory.iname (fun i -> l': Steel.Memory.lock_store { Steel.Memory.lock_store_invariant e l' == Steel.Memory.star p (Steel.Memory.lock_store_invariant e l) /\ Steel.Memory.iname_for_p i p l' })

Prims.Tot

[ "total" ]

[]

[ "Steel.Memory.inames", "Steel.Memory.lock_store", "Steel.Memory.inames_in", "Steel.Memory.slprop", "Prims.Mkdtuple2", "Steel.Memory.iname", "Prims.l_and", "Prims.eq2", "Steel.Memory.lock_store_invariant", "Steel.Memory.star", "Steel.Memory.iname_for_p", "FStar.List.Tot.Base.length", "Steel.Memory.lock_state", "Prims.Cons", "Steel.Memory.Invariant", "Prims.dtuple2" ]

[]

false

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 |)

false

Steel.Memory.fst

Steel.Memory.a_mem_prop_as_a_heap_prop

val a_mem_prop_as_a_heap_prop (sl: slprop u#a) (f: a_mem_prop sl) : Tot (H.a_heap_prop u#a)

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

{ "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": 375, "start_col": 0, "start_line": 357 }

(* 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

{ "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

sl: Steel.Memory.slprop -> f: Steel.Memory.a_mem_prop sl -> Steel.Heap.a_heap_prop

Prims.Tot

[ "total" ]

[]

[ "Steel.Memory.slprop", "Steel.Memory.a_mem_prop", "Prims.unit", "FStar.Classical.forall_intro_2", "Steel.Heap.heap", "Prims.l_imp", "Prims.l_and", "Steel.Heap.disjoint", "Steel.Heap.join", "Prims.l_True", "Prims.squash", "Prims.Nil", "FStar.Pervasives.pattern", "FStar.Classical.move_requires", "Steel.Memory.interp_depends_only_on", "Prims._assert", "Prims.eq2", "Steel.Memory.mem", "Steel.Memory.mem_of_heap", "Steel.Memory.join", "Prims.prop", "Steel.Memory.interp", "Steel.Heap.a_heap_prop" ]

[]

false

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

false

Steel.Memory.fst

Steel.Memory.interp_depends_only_on

val interp_depends_only_on (hp:slprop u#a) : Lemma (forall (m0:hmem hp) (m1:mem u#a{disjoint m0 m1}). interp hp m0 <==> interp hp (join m0 m1))

let interp_depends_only_on (hp:slprop u#a) = H.interp_depends_only_on hp

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

{ "end_col": 72, "end_line": 355, "start_col": 0, "start_line": 355 }

(* 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) = ()

{ "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": "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

hp: Steel.Memory.slprop -> FStar.Pervasives.Lemma (ensures forall (m0: Steel.Memory.hmem hp) (m1: Steel.Memory.mem{Steel.Memory.disjoint m0 m1}). Steel.Memory.interp hp m0 <==> Steel.Memory.interp hp (Steel.Memory.join m0 m1))

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Steel.Memory.slprop", "Steel.Heap.interp_depends_only_on", "Prims.unit" ]

[]

true

false

true

false

let interp_depends_only_on (hp: slprop u#a) =

H.interp_depends_only_on hp

false

Steel.Memory.fst

Steel.Memory.move_invariant

val 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 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

{ "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": 336, "start_col": 0, "start_line": 296 }

(* Copyright 2020 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module Steel.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

{ "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

e: Steel.Memory.inames -> l: Steel.Memory.lock_store -> p: Steel.Memory.slprop -> i: Steel.Memory.iname {Steel.Memory.iname_for_p i p l /\ ~(FStar.Set.mem i (FStar.Ghost.reveal e))} -> FStar.Pervasives.Lemma (ensures Steel.Heap.equiv (Steel.Memory.lock_store_invariant e l) (Steel.Memory.star p (Steel.Memory.lock_store_invariant (FStar.Ghost.hide (Steel.Memory.set_add i e)) l)))

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Steel.Memory.inames", "Steel.Memory.lock_store", "Steel.Memory.slprop", "Steel.Memory.iname", "Prims.l_and", "Steel.Memory.iname_for_p", "Prims.l_not", "Prims.b2t", "FStar.Set.mem", "FStar.Ghost.reveal", "FStar.Set.set", "Steel.Heap.slprop", "Prims.list", "Steel.Memory.lock_state", "Prims.op_Equality", "Prims.int", "Prims.unit", "Steel.Heap.star_congruence", "Steel.Memory.lock_store_invariant", "FStar.Ghost.hide", "Steel.Memory.set_add", "Prims._assert", "Prims.eq2", "Steel.Memory.star", "Prims.bool", "Steel.Heap.star_associative", "Steel.Heap.star_commutative", "Steel.Memory.equiv", "Steel.Memory.move_invariant", "Prims.op_Subtraction", "FStar.List.Tot.Base.length", "Prims.op_GreaterThanOrEqual", "Prims.squash", "Steel.Heap.equiv", "Prims.Nil", "FStar.Pervasives.pattern", "Prims.l_True" ]

[ "recursion" ]

false

true

false

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 (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); ()) else (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 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)

false

Steel.Memory.fst

Steel.Memory.preserves_frame

val preserves_frame : e: Steel.Memory.inames -> pre: Steel.Memory.slprop -> post: Steel.Memory.slprop -> m0: Steel.Memory.mem -> m1: Steel.Memory.mem -> Prims.logical

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)))

{ "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": 555, "start_col": 0, "start_line": 551 }

(* 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

{ "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 -> pre: Steel.Memory.slprop -> post: Steel.Memory.slprop -> m0: Steel.Memory.mem -> m1: Steel.Memory.mem -> Prims.logical

Prims.Tot

[ "total" ]

[]

[ "Steel.Memory.inames", "Steel.Memory.slprop", "Steel.Memory.mem", "Prims.l_Forall", "Prims.l_imp", "Steel.Memory.interp", "Steel.Memory.star", "Steel.Memory.locks_invariant", "Prims.l_and", "Steel.Memory.mprop", "Prims.eq2", "Prims.prop", "Steel.Memory.core_mem", "Prims.logical" ]

[]

false

true

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)))

false

Steel.Memory.fst

Steel.Memory.tot_pre_action_nf

val tot_pre_action_nf : fp: Steel.Memory.slprop -> a: Type -> fp': (_: a -> Steel.Memory.slprop) -> Type

let tot_pre_action_nf = tot_pre_action_nf_except S.empty

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

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

(* 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))

{ "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 -> a: Type -> fp': (_: a -> Steel.Memory.slprop) -> Type

Prims.Tot

[ "total" ]

[]

[ "Steel.Memory.tot_pre_action_nf_except", "FStar.Ghost.hide", "FStar.Set.set", "Steel.Memory.iname", "FStar.Set.empty" ]

[]

false

true

let tot_pre_action_nf =

tot_pre_action_nf_except S.empty

false

Steel.Memory.fst

Steel.Memory.with_inv_except

val with_inv_except : m: Steel.Memory.mem -> e: Steel.Memory.inames -> fp: Steel.Memory.slprop -> Prims.prop

let with_inv_except (m:mem) e (fp:slprop) = interp (fp `star` locks_invariant e m) m

{ "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": 663, "start_col": 0, "start_line": 663 }

(* 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

{ "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.mem -> e: Steel.Memory.inames -> fp: Steel.Memory.slprop -> Prims.prop

Prims.Tot

[ "total" ]

[]

[ "Steel.Memory.mem", "Steel.Memory.inames", "Steel.Memory.slprop", "Steel.Memory.interp", "Steel.Memory.star", "Steel.Memory.locks_invariant", "Prims.prop" ]

[]

false

true

let with_inv_except (m: mem) e (fp: slprop) =

interp (fp `star` (locks_invariant e m)) m

false

Steel.Memory.fst

Steel.Memory.tot_pre_action_nf_except

val tot_pre_action_nf_except : e: Steel.Memory.inames -> fp: Steel.Memory.slprop -> a: Type -> fp': (_: a -> Steel.Memory.slprop) -> Type

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))

{ "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": 586, "start_col": 0, "start_line": 584 }

(* 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 *)

{ "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 -> fp: Steel.Memory.slprop -> a: Type -> fp': (_: a -> Steel.Memory.slprop) -> Type

Prims.Tot

[ "total" ]

[]

[ "Steel.Memory.inames", "Steel.Memory.slprop", "Steel.Memory.hmem_with_inv_except", "Prims.dtuple2" ]

[]

false

true

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))

false

Steel.Memory.fst

Steel.Memory.linv

val linv : e: Steel.Memory.inames -> m: Steel.Memory.mem -> Steel.Memory.slprop

let linv e (m:mem) = locks_invariant e m

{ "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": 624, "start_col": 0, "start_line": 624 }

(* 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

{ "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 -> Steel.Memory.slprop

Prims.Tot

[ "total" ]

[]

[ "Steel.Memory.inames", "Steel.Memory.mem", "Steel.Memory.locks_invariant", "Steel.Memory.slprop" ]

[]

false

true

false

let linv e (m: mem) =

locks_invariant e m

false

Steel.Memory.fst

Steel.Memory.tot_action_nf

val tot_action_nf : fp: Steel.Memory.slprop -> a: Type -> fp': (_: a -> Steel.Memory.slprop) -> Type

let tot_action_nf = tot_action_nf_except S.empty

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

{ "end_col": 48, "end_line": 622, "start_col": 0, "start_line": 622 }

(* 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 }

{ "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 -> a: Type -> fp': (_: a -> Steel.Memory.slprop) -> Type

Prims.Tot

[ "total" ]

[]

[ "Steel.Memory.tot_action_nf_except", "FStar.Ghost.hide", "FStar.Set.set", "Steel.Memory.iname", "FStar.Set.empty" ]

[]

false

true

let tot_action_nf =

tot_action_nf_except S.empty

false

Steel.HigherReference.fst

Steel.HigherReference.gather_atomic_raw

val gather_atomic_raw (#a: Type) (#uses: _) (#p0 #p1: perm) (r: ref a) (v0 v1: erased a) : SteelGhostT (_: unit{v0 == v1 /\ perm_ok (sum_perm p0 p1)}) uses ((pts_to_raw r p0 v0) `star` (pts_to_raw r p1 v1)) (fun _ -> pts_to_raw r (sum_perm p0 p1) v0)

let gather_atomic_raw (#a:Type) (#uses:_) (#p0 #p1:perm) (r:ref a) (v0:erased a) (v1:erased a) : SteelGhostT (_:unit{v0==v1 /\ perm_ok (sum_perm p0 p1)}) uses (pts_to_raw r p0 v0 `star` pts_to_raw r p1 v1) (fun _ -> pts_to_raw r (sum_perm p0 p1) v0) = rewrite_slprop (pts_to_raw r p0 v0) (RP.pts_to r (Ghost.reveal (Some (Ghost.reveal v0, p0)))) (fun _ -> ()); rewrite_slprop (pts_to_raw r p1 v1) (RP.pts_to r (Ghost.reveal (Some (Ghost.reveal v1, p1)))) (fun _ -> ()); let _ = RP.gather r (Some (Ghost.reveal v0, p0)) (Some (Ghost.reveal v1, p1)) in rewrite_slprop (RP.pts_to r _) (pts_to_raw r (sum_perm p0 p1) v0) (fun _ -> ())

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

{ "end_col": 19, "end_line": 289, "start_col": 0, "start_line": 272 }

(* 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 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 let read_refine (#a:Type) (#p:perm) (q:a -> vprop) (r:ref a) : SteelT a (h_exists (fun (v:a) -> pts_to r p v `star` q v)) (fun v -> pts_to r p v `star` q v) = let vs:erased a = witness_exists () in rewrite_slprop (pts_to r p (Ghost.hide (Ghost.reveal vs))) (pts_to r p vs) (fun _ -> ()); let v = read r in rewrite_slprop (q vs) (q v) (fun _ -> ()); return v let write (#a:Type) (#v:erased a) (r:ref a) (x:a) : SteelT unit (pts_to r full_perm v) (fun _ -> pts_to r full_perm x) = let v_old : erased (fractional a) = Ghost.hide (Some (Ghost.reveal v, full_perm)) in let v_new : fractional a = Some (x, full_perm) in rewrite_slprop (pts_to r full_perm v) (RP.pts_to r v_old `star` pure (perm_ok full_perm)) (fun _ -> ()); elim_pure (perm_ok full_perm); RP.write r v_old v_new; rewrite_slprop (RP.pts_to r v_new) (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) let atomic_write #opened #a #v r x = let v_old : erased (fractional a) = Ghost.hide (Some (Ghost.reveal v, full_perm)) in let v_new : fractional a = Some (x, full_perm) in rewrite_slprop (pts_to r full_perm v) (RP.pts_to r v_old `star` pure (perm_ok full_perm)) (fun _ -> ()); elim_pure (perm_ok full_perm); RP.atomic_write r v_old v_new; rewrite_slprop (RP.pts_to r v_new) (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) let free (#a:Type) (#v:erased a) (r:ref a) : SteelT unit (pts_to r full_perm v) (fun _ -> emp) = let v_old : erased (fractional a) = Ghost.hide (Some (Ghost.reveal v, full_perm)) in rewrite_slprop (pts_to r full_perm v) (RP.pts_to r v_old `star` pure (perm_ok full_perm)) (fun _ -> ()); elim_pure (perm_ok full_perm); RP.free r v_old; drop (RP.pts_to r (Mkpcm'?.one (Mkpcm?.p pcm_frac))) let share_atomic_raw_gen #a #uses (#p:perm) (r:ref a{perm_ok p}) (v0:erased a) (p1 p2: perm) : SteelGhost unit uses (pts_to_raw r p v0) (fun _ -> pts_to_raw r p1 v0 `star` pts_to_raw r p2 v0) (fun _ -> p == p1 `sum_perm` p2) (fun _ _ _ -> True) = rewrite_slprop (pts_to_raw r p v0) (RP.pts_to r _) (fun _ -> ()); RP.split r (Some (Ghost.reveal v0, p)) (Some (Ghost.reveal v0, p1)) (Some (Ghost.reveal v0, p2)); rewrite_slprop (RP.pts_to r _) (pts_to_raw r p1 v0) (fun _ -> ()); rewrite_slprop (RP.pts_to r _) (pts_to_raw r p2 v0) (fun _ -> ()) let share_atomic_raw #a #uses (#p:perm) (r:ref a{perm_ok p}) (v0:erased a) : SteelGhostT unit uses (pts_to_raw r p v0) (fun _ -> pts_to_raw r (half_perm p) v0 `star` pts_to_raw r (half_perm p) v0) = share_atomic_raw_gen r v0 (half_perm p) (half_perm p) let share_gen (#a:Type) (#uses:_) (#p:perm) (#v:erased a) (r:ref a) (p1 p2: perm) : SteelGhost unit uses (pts_to r p v) (fun _ -> pts_to r p1 v `star` pts_to r p2 v) (fun _ -> p == p1 `sum_perm` p2) (fun _ _ _ -> True) = let v_old : erased (fractional a) = Ghost.hide (Some (Ghost.reveal v, p)) in rewrite_slprop (pts_to r p v) (pts_to' r p v) (fun _ -> ()); elim_pure (perm_ok p); share_atomic_raw_gen r v p1 p2; intro_pts_to p1 r; intro_pts_to p2 r let share (#a:Type) #uses (#p:perm) (#v:erased a) (r:ref a) : SteelGhostT unit uses (pts_to r p v) (fun _ -> pts_to r (half_perm p) v `star` pts_to r (half_perm p) v) = share_gen r (half_perm p) (half_perm p)

{ "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 -> v0: FStar.Ghost.erased a -> v1: FStar.Ghost.erased a -> Steel.Effect.Atomic.SteelGhostT (_: Prims.unit {v0 == v1 /\ Steel.HigherReference.perm_ok (Steel.FractionalPermission.sum_perm p0 p1)})

Steel.Effect.Atomic.SteelGhostT

[]

[ "Steel.Memory.inames", "Steel.FractionalPermission.perm", "Steel.HigherReference.ref", "FStar.Ghost.erased", "Steel.Effect.Atomic.rewrite_slprop", "Steel.PCMReference.pts_to", "Steel.PCMFrac.fractional", "Steel.PCMFrac.pcm_frac", "FStar.PCM.op", "FStar.Pervasives.Native.Some", "FStar.Pervasives.Native.tuple2", "FStar.Pervasives.Native.Mktuple2", "FStar.Ghost.reveal", "Steel.HigherReference.pts_to_raw", "Steel.FractionalPermission.sum_perm", "Steel.Memory.mem", "Prims.unit", "FStar.PCM.composable", "FStar.Ghost.hide", "Steel.PCMReference.gather", "Prims.l_and", "Prims.eq2", "Steel.HigherReference.perm_ok", "Steel.Effect.Common.star", "Steel.Effect.Common.vprop" ]

[]

false

true

false

let gather_atomic_raw (#a: Type) (#uses: _) (#p0 #p1: perm) (r: ref a) (v0 v1: erased a) : SteelGhostT (_: unit{v0 == v1 /\ perm_ok (sum_perm p0 p1)}) uses ((pts_to_raw r p0 v0) `star` (pts_to_raw r p1 v1)) (fun _ -> pts_to_raw r (sum_perm p0 p1) v0) =

rewrite_slprop (pts_to_raw r p0 v0) (RP.pts_to r (Ghost.reveal (Some (Ghost.reveal v0, p0)))) (fun _ -> ()); rewrite_slprop (pts_to_raw r p1 v1) (RP.pts_to r (Ghost.reveal (Some (Ghost.reveal v1, p1)))) (fun _ -> ()); let _ = RP.gather r (Some (Ghost.reveal v0, p0)) (Some (Ghost.reveal v1, p1)) in rewrite_slprop (RP.pts_to r _) (pts_to_raw r (sum_perm p0 p1) v0) (fun _ -> ())

false

Steel.Memory.fst

Steel.Memory.interp_refine_slprop

val interp_refine_slprop (sl: slprop u#a) (f: a_mem_prop sl) (m: mem u#a) : Lemma (interp (refine_slprop sl f) m <==> (interp sl m /\ f m)) [SMTPat (interp (refine_slprop sl f) m)]

let interp_refine_slprop sl f m = assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_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": 77, "end_line": 380, "start_col": 0, "start_line": 379 }

(* 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)

{ "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": "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

sl: Steel.Memory.slprop -> f: Steel.Memory.a_mem_prop sl -> m: Steel.Memory.mem -> FStar.Pervasives.Lemma (ensures Steel.Memory.interp (Steel.Memory.refine_slprop sl f) m <==> Steel.Memory.interp sl m /\ f m ) [SMTPat (Steel.Memory.interp (Steel.Memory.refine_slprop sl f) m)]

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Steel.Memory.slprop", "Steel.Memory.a_mem_prop", "Steel.Memory.mem", "Prims._assert", "Prims.l_iff", "Prims.l_and", "Steel.Memory.interp", "Steel.Memory.core_mem", "Prims.unit" ]

[]

true

false

true

false

let interp_refine_slprop sl f m =

assert ((interp sl m /\ f m) <==> interp sl (core_mem m) /\ f (core_mem m))

false

Steel.Memory.fst

Steel.Memory.h_exists_cong

val 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))

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

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

{ "end_col": 25, "end_line": 488, "start_col": 0, "start_line": 483 }

(* 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 )); ()

{ "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": "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: (_: a -> Steel.Memory.slprop) -> q: (_: a -> Steel.Memory.slprop) -> FStar.Pervasives.Lemma (requires forall (x: a). Steel.Memory.equiv (p x) (q x)) (ensures Steel.Memory.equiv (Steel.Memory.h_exists p) (Steel.Memory.h_exists q))

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Steel.Memory.slprop", "Steel.Heap.h_exists_cong", "Prims.unit", "Steel.Memory.equiv_heap_iff_equiv_forall", "Prims.l_Forall", "Steel.Memory.equiv", "Prims.squash", "Steel.Memory.h_exists", "Prims.Nil", "FStar.Pervasives.pattern" ]

[]

true

false

true

false

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

false

Steel.Memory.fst

Steel.Memory.intro_h_and

val intro_h_and (p q: slprop) (m:mem) : Lemma (interp p m /\ interp q m ==> interp (h_and p q) m)

let intro_h_and (p q: slprop) (m:mem) = H.intro_h_and p q (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": 73, "end_line": 498, "start_col": 0, "start_line": 498 }

(* 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

{ "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": "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 -> m: Steel.Memory.mem -> FStar.Pervasives.Lemma (ensures Steel.Memory.interp p m /\ Steel.Memory.interp q m ==> Steel.Memory.interp (Steel.Memory.h_and p q) m)

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Steel.Memory.slprop", "Steel.Memory.mem", "Steel.Heap.intro_h_and", "Steel.Memory.heap_of_mem", "Prims.unit" ]

[]

true

false

true

false

let intro_h_and (p q: slprop) (m: mem) =

H.intro_h_and p q (heap_of_mem m)

false

Steel.Memory.fst

Steel.Memory.tot_action_nf_except

val tot_action_nf_except : e: Steel.Memory.inames -> fp: Steel.Memory.slprop -> a: Type -> fp': (_: a -> Steel.Memory.slprop) -> Type

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 }

{ "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": 620, "start_col": 0, "start_line": 619 }

(* 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)))

{ "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 -> fp: Steel.Memory.slprop -> a: Type -> fp': (_: a -> Steel.Memory.slprop) -> Type

Prims.Tot

[ "total" ]

[]

[ "Steel.Memory.inames", "Steel.Memory.slprop", "Steel.Memory.tot_pre_action_nf_except", "Steel.Memory.is_frame_preserving" ]

[]

false

true

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}

false

Steel.Memory.fst

Steel.Memory.sdep

val sdep (s: slprop u#a) (f: (hmem s -> Tot (slprop u#a))) : Tot (slprop u#a)

let sdep (s: slprop) (f: (hmem s -> Tot slprop)) : Tot slprop = dep_hprop_is_affine s f; H.as_slprop (dep_hprop s f)

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

{ "end_col": 29, "end_line": 450, "start_col": 0, "start_line": 444 }

(* 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)

{ "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": "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

s: Steel.Memory.slprop -> f: (_: Steel.Memory.hmem s -> Steel.Memory.slprop) -> Steel.Memory.slprop

Prims.Tot

[ "total" ]

[]

[ "Steel.Memory.slprop", "Steel.Memory.hmem", "Steel.Heap.as_slprop", "Steel.Memory.dep_hprop", "Prims.unit", "Steel.Memory.dep_hprop_is_affine" ]

[]

false

let sdep (s: slprop) (f: (hmem s -> Tot slprop)) : Tot slprop =

dep_hprop_is_affine s f; H.as_slprop (dep_hprop s f)

false

Steel.Memory.fst

Steel.Memory.tot_action_with_frame_except

val tot_action_with_frame_except : e: Steel.Memory.inames -> fp: Steel.Memory.slprop -> a: Type -> fp': (_: a -> Steel.Memory.slprop) -> Type

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)))

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

{ "end_col": 72, "end_line": 785, "start_col": 0, "start_line": 774 }

(* 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 *)

{ "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 -> fp: Steel.Memory.slprop -> a: Type -> fp': (_: a -> Steel.Memory.slprop) -> Type

Prims.Tot

[ "total" ]

[]

[ "Steel.Memory.inames", "Steel.Memory.slprop", "Steel.Memory.hmem_with_inv_except", "Steel.Memory.star", "Prims.dtuple2", "Prims.l_True", "Prims.l_and", "Steel.Memory.mem_evolves", "Prims.l_Forall", "Steel.Memory.mprop", "Prims.eq2", "Prims.prop", "Steel.Memory.core_mem" ]

[]

false

true

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)))

false

Steel.Memory.fst

Steel.Memory.elim_h_exists

val elim_h_exists (#a:_) (p:a -> slprop) (m:mem) : Lemma (interp (h_exists p) m ==> (exists x. interp (p x) m))

let elim_h_exists (#a:_) (p:a -> slprop) (m:mem) = H.elim_h_exists p (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": 84, "end_line": 492, "start_col": 0, "start_line": 492 }

(* 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)

{ "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": "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: (_: a -> Steel.Memory.slprop) -> m: Steel.Memory.mem -> FStar.Pervasives.Lemma (ensures Steel.Memory.interp (Steel.Memory.h_exists p) m ==> (exists (x: a). Steel.Memory.interp (p x) m))

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Steel.Memory.slprop", "Steel.Memory.mem", "Steel.Heap.elim_h_exists", "Steel.Memory.heap_of_mem", "Prims.unit" ]

[]

true

false

true

false

let elim_h_exists (#a: _) (p: (a -> slprop)) (m: mem) =

H.elim_h_exists p (heap_of_mem m)

false

Steel.Memory.fst

Steel.Memory.intro_h_forall

val intro_h_forall (#a:_) (p:a -> slprop) (m:mem) : Lemma ((forall x. interp (p x) m) ==> interp (h_forall p) m)

let intro_h_forall (#a:_) (p:a -> slprop) (m:mem) = H.intro_h_forall p (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": 86, "end_line": 494, "start_col": 0, "start_line": 494 }

(* 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)

{ "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": "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: (_: a -> Steel.Memory.slprop) -> m: Steel.Memory.mem -> FStar.Pervasives.Lemma (ensures (forall (x: a). Steel.Memory.interp (p x) m) ==> Steel.Memory.interp (Steel.Memory.h_forall p) m)

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Steel.Memory.slprop", "Steel.Memory.mem", "Steel.Heap.intro_h_forall", "Steel.Memory.heap_of_mem", "Prims.unit" ]

[]

true

false

true

false

let intro_h_forall (#a: _) (p: (a -> slprop)) (m: mem) =

H.intro_h_forall p (heap_of_mem m)

false

Steel.Memory.fst

Steel.Memory.dep_hprop_is_affine1

val 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)))

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)

{ "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": 435, "start_col": 0, "start_line": 429 }

(* 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

{ "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) -> h0: Steel.Heap.heap -> h1: Steel.Heap.heap -> FStar.Pervasives.Lemma (ensures Steel.Memory.dep_hprop s f h0 /\ Steel.Heap.disjoint h0 h1 ==> Steel.Heap.disjoint h0 h1 /\ Steel.Memory.dep_hprop s f (Steel.Heap.join h0 h1))

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Steel.Memory.slprop", "Steel.Memory.hmem", "Steel.Heap.heap", "Steel.Memory.impl_intro_gen", "Prims.l_and", "Steel.Memory.dep_hprop", "Steel.Heap.disjoint", "Steel.Heap.join", "Steel.Memory.dep_hprop_is_affine0", "Prims.unit", "Prims.l_True", "Prims.squash", "Prims.l_imp", "Prims.Nil", "FStar.Pervasives.pattern" ]

[]

true

false

true

false

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)

false

Steel.Memory.fst

Steel.Memory.elim_h_forall

val elim_h_forall (#a:_) (p:a -> slprop) (m:mem) (x:a) : Lemma (interp (h_forall p) m ==> interp (p x) m)

let elim_h_forall (#a:_) (p:a -> slprop) (m:mem) (x:a) = H.elim_h_forall p (heap_of_mem m) x

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

{ "end_col": 92, "end_line": 496, "start_col": 0, "start_line": 496 }

(* Copyright 2020 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module Steel.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)

{ "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": "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: (_: a -> Steel.Memory.slprop) -> m: Steel.Memory.mem -> x: a -> FStar.Pervasives.Lemma (ensures Steel.Memory.interp (Steel.Memory.h_forall p) m ==> Steel.Memory.interp (p x) m)

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Steel.Memory.slprop", "Steel.Memory.mem", "Steel.Heap.elim_h_forall", "Steel.Memory.heap_of_mem", "Prims.unit" ]

[]

true

false

true

false

let elim_h_forall (#a: _) (p: (a -> slprop)) (m: mem) (x: a) =

H.elim_h_forall p (heap_of_mem m) x

false

Steel.Memory.fst

Steel.Memory.intro_h_exists

val intro_h_exists (#a:_) (x:a) (p:a -> slprop) (m:mem) : Lemma (interp (p x) m ==> interp (h_exists p) m)

let intro_h_exists #a x p m = H.intro_h_exists x p (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": 66, "end_line": 490, "start_col": 0, "start_line": 490 }

(* Copyright 2020 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module Steel.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

{ "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": "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

x: a -> p: (_: a -> Steel.Memory.slprop) -> m: Steel.Memory.mem -> FStar.Pervasives.Lemma (ensures Steel.Memory.interp (p x) m ==> Steel.Memory.interp (Steel.Memory.h_exists p) m)

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Steel.Memory.slprop", "Steel.Memory.mem", "Steel.Heap.intro_h_exists", "Steel.Memory.heap_of_mem", "Prims.unit" ]

[]

true

false

true

false

let intro_h_exists #a x p m =

H.intro_h_exists x p (heap_of_mem m)

false

Steel.Memory.fst

Steel.Memory.hheap_of_hmem

val 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 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

{ "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": 630, "start_col": 0, "start_line": 626 }

(* 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

{ "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 fp -> h: Steel.Heap.hheap (Steel.Memory.star fp (Steel.Memory.linv e m)) {Steel.Heap.free_above_addr h (Mkmem?.ctr m)}

Prims.Tot

[ "total" ]

[]

[ "Steel.Memory.slprop", "Steel.Memory.inames", "Steel.Memory.hmem_with_inv_except", "Prims.unit", "Steel.Heap.pure_interp", "Steel.Memory.heap_ctr_valid", "Steel.Memory.__proj__Mkmem__item__ctr", "Steel.Memory.heap_of_mem", "Steel.Heap.heap", "Steel.Heap.hheap", "Steel.Memory.star", "Steel.Memory.linv", "Steel.Heap.free_above_addr" ]

[]

false

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

false

Steel.Memory.fst

Steel.Memory.intro_h_or_left

val intro_h_or_left (p q: slprop) (m:mem) : Lemma (interp p m ==> interp (h_or p q) m)

let intro_h_or_left (p q: slprop) (m:mem) = H.intro_h_or_left p q (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": 81, "end_line": 502, "start_col": 0, "start_line": 502 }

(* 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)

{ "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": "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 -> m: Steel.Memory.mem -> FStar.Pervasives.Lemma (ensures Steel.Memory.interp p m ==> Steel.Memory.interp (Steel.Memory.h_or p q) m)

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Steel.Memory.slprop", "Steel.Memory.mem", "Steel.Heap.intro_h_or_left", "Steel.Memory.heap_of_mem", "Prims.unit" ]

[]

true

false

true

false

let intro_h_or_left (p q: slprop) (m: mem) =

H.intro_h_or_left p q (heap_of_mem m)

false

Steel.Memory.fst

Steel.Memory.elim_h_and

val elim_h_and (p q: slprop) (m:mem) : Lemma (interp (h_and p q) m ==> (interp p m /\ interp q m))

let elim_h_and (p q: slprop) (m:mem) = H.elim_h_and p q (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": 71, "end_line": 500, "start_col": 0, "start_line": 500 }

(* 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)

{ "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": "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 -> m: Steel.Memory.mem -> FStar.Pervasives.Lemma (ensures Steel.Memory.interp (Steel.Memory.h_and p q) m ==> Steel.Memory.interp p m /\ Steel.Memory.interp q m)

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Steel.Memory.slprop", "Steel.Memory.mem", "Steel.Heap.elim_h_and", "Steel.Memory.heap_of_mem", "Prims.unit" ]

[]

true

false

true

false

let elim_h_and (p q: slprop) (m: mem) =

H.elim_h_and p q (heap_of_mem m)

false

Steel.Memory.fst

Steel.Memory.mem_evolves

val mem_evolves : FStar.Preorder.preorder full_mem

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

{ "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": 548, "start_col": 0, "start_line": 544 }

(* 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

{ "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

FStar.Preorder.preorder Steel.Memory.full_mem

Prims.Tot

[ "total" ]

[]

[ "Steel.Memory.full_mem", "Prims.l_and", "Steel.Heap.heap_evolves", "Steel.Memory.heap_of_mem", "Prims.b2t", "Prims.op_LessThanOrEqual", "Steel.Memory.__proj__Mkmem__item__ctr", "Steel.Memory.lock_store_evolves", "Steel.Memory.__proj__Mkmem__item__locks", "Prims.logical" ]

[]

false

true

false

let mem_evolves =

fun (m0: full_mem) (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

false

Steel.Memory.fst

Steel.Memory.tot_action_with_frame

val tot_action_with_frame : fp: Steel.Memory.slprop -> a: Type -> fp': (_: a -> Steel.Memory.slprop) -> Type

let tot_action_with_frame = tot_action_with_frame_except S.empty

{ "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": 787, "start_col": 0, "start_line": 787 }

(* 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)))

{ "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 -> a: Type -> fp': (_: a -> Steel.Memory.slprop) -> Type

Prims.Tot

[ "total" ]

[]

[ "Steel.Memory.tot_action_with_frame_except", "FStar.Ghost.hide", "FStar.Set.set", "Steel.Memory.iname", "FStar.Set.empty" ]

[]

false

true

let tot_action_with_frame =

tot_action_with_frame_except S.empty

false

Steel.Memory.fst

Steel.Memory.dep_hprop_is_affine

val dep_hprop_is_affine (s: slprop) (f: (hmem s -> Tot slprop)) : Lemma (H.heap_prop_is_affine (dep_hprop s f))

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)

{ "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": 442, "start_col": 0, "start_line": 437 }

(* 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)

{ "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) -> FStar.Pervasives.Lemma (ensures Steel.Heap.heap_prop_is_affine (Steel.Memory.dep_hprop s f))

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Steel.Memory.slprop", "Steel.Memory.hmem", "FStar.Classical.forall_intro_2", "Steel.Heap.heap", "Prims.l_imp", "Prims.l_and", "Steel.Memory.dep_hprop", "Steel.Heap.disjoint", "Steel.Heap.join", "Steel.Memory.dep_hprop_is_affine1", "Prims.unit", "Prims.l_True", "Prims.squash", "Steel.Heap.heap_prop_is_affine", "Prims.Nil", "FStar.Pervasives.pattern" ]

[]

false

true

false

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)

false

Steel.Memory.fst

Steel.Memory.elim_wand

val elim_wand (p1 p2: slprop u#a) (m:mem) (m1:mem) : Lemma ((interp (wand p1 p2) m /\ m `disjoint` m1 /\ interp p1 m1) ==> interp p2 (join m m1))

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)

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

{ "end_col": 103, "end_line": 534, "start_col": 0, "start_line": 534 }

(* 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) ) ) )

{ "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": "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

p1: Steel.Memory.slprop -> p2: Steel.Memory.slprop -> m: Steel.Memory.mem -> m1: Steel.Memory.mem -> FStar.Pervasives.Lemma (ensures Steel.Memory.interp (Steel.Memory.wand p1 p2) m /\ Steel.Memory.disjoint m m1 /\ Steel.Memory.interp p1 m1 ==> Steel.Memory.interp p2 (Steel.Memory.join m m1))

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Steel.Memory.slprop", "Steel.Memory.mem", "Steel.Heap.elim_wand", "Steel.Memory.heap_of_mem", "Prims.unit" ]

[]

true

false

true

false

let elim_wand (p1 p2: slprop u#a) (m m1: mem) =

H.elim_wand p1 p2 (heap_of_mem m) (heap_of_mem m1)

false

Steel.Memory.fst

Steel.Memory.interp_sdep

val 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) )) [SMTPat (interp (sdep s f) m)]

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 )); ()

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

{ "end_col": 4, "end_line": 481, "start_col": 0, "start_line": 452 }

(* 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)

{ "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": "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

s: Steel.Memory.slprop -> f: (_: Steel.Memory.hmem s -> Steel.Memory.slprop) -> m: Steel.Memory.mem -> FStar.Pervasives.Lemma (requires Steel.Memory.dep_slprop_is_affine s f) (ensures Steel.Memory.interp (Steel.Memory.sdep s f) m <==> (exists (m1: m: Steel.Memory.mem{Steel.Memory.interp s m}) (m2: m1: Steel.Memory.mem{Steel.Memory.disjoint m1 m1}). Steel.Memory.interp s m1 /\ Steel.Memory.interp (f m1) m2 /\ Steel.Memory.disjoint m1 m2 /\ Steel.Memory.join m1 m2 == m)) [SMTPat (Steel.Memory.interp (Steel.Memory.sdep s f) m)]

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Steel.Memory.slprop", "Steel.Memory.hmem", "Steel.Memory.mem", "Prims.unit", "Prims._assert", "Prims.l_Forall", "Steel.Heap.heap", "Steel.Heap.disjoint", "Prims.l_imp", "Prims.l_and", "Steel.Memory.interp", "Steel.Memory.mem_of_heap", "Prims.eq2", "Steel.Heap.join", "Steel.Memory.__proj__Mkmem__item__heap", "Steel.Memory.core_mem", "Steel.Memory.mem_set_heap", "Steel.Memory.equiv", "Steel.Memory.disjoint", "Steel.Memory.join", "FStar.Classical.forall_intro", "Prims.l_iff", "Steel.Memory.interp_depends_only_on", "Steel.Memory.dep_hprop_is_affine", "Steel.Memory.dep_slprop_is_affine", "Prims.squash", "Steel.Memory.sdep", "Prims.l_Exists", "Prims.Nil", "FStar.Pervasives.pattern" ]

[]

false

true

false

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)); ()

false

Steel.Memory.fst

Steel.Memory.elim_h_or

val elim_h_or (p q: slprop) (m:mem) : Lemma (interp (h_or p q) m ==> (interp p m \/ interp q m))

let elim_h_or (p q: slprop) (m:mem) = H.elim_h_or p q (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": 69, "end_line": 506, "start_col": 0, "start_line": 506 }

(* 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)

{ "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": "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 -> m: Steel.Memory.mem -> FStar.Pervasives.Lemma (ensures Steel.Memory.interp (Steel.Memory.h_or p q) m ==> Steel.Memory.interp p m \/ Steel.Memory.interp q m)

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Steel.Memory.slprop", "Steel.Memory.mem", "Steel.Heap.elim_h_or", "Steel.Memory.heap_of_mem", "Prims.unit" ]

[]

true

false

true

false

let elim_h_or (p q: slprop) (m: mem) =

H.elim_h_or p q (heap_of_mem m)

false

Steel.Memory.fst

Steel.Memory.ac_reasoning_for_m_frame_preserving

val 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)

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

{ "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": 604, "start_col": 0, "start_line": 590 }

(* 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

{ "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 -> m: Steel.Memory.mem -> FStar.Pervasives.Lemma (requires Steel.Memory.interp (Steel.Memory.star (Steel.Memory.star p q) r) m) (ensures Steel.Memory.interp (Steel.Memory.star p r) m)

FStar.Pervasives.Lemma

[ "lemma" ]

[]

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

[]

false

true

false

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

false

Hacl.Spec.Poly1305.Field32xN.Lemmas.fst

Hacl.Spec.Poly1305.Field32xN.Lemmas.fmul_r4_normalize50

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

{ "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": 477, "start_col": 0, "start_line": 428 }

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))

{ "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 4 -> r: Hacl.Spec.Poly1305.Field32xN.felem5 4 -> r2: Hacl.Spec.Poly1305.Field32xN.felem5 4 -> r3: Hacl.Spec.Poly1305.Field32xN.felem5 4 -> r4: Hacl.Spec.Poly1305.Field32xN.felem5 4 -> Prims.Pure (Hacl.Spec.Poly1305.Field32xN.felem5 4)

Prims.Pure

[]

[ "Hacl.Spec.Poly1305.Field32xN.felem5", "Hacl.Spec.Poly1305.Field32xN.uint64xN", "Prims.unit", "Hacl.Spec.Poly1305.Field32xN.Lemmas.fmul_r5_fits_lemma", "Hacl.Spec.Poly1305.Field32xN.Lemmas.fmul_r5_eval_lemma", "Hacl.Spec.Poly1305.Field32xN.fmul_r5", "Hacl.Spec.Poly1305.Field32xN.precomp_r5", "Lib.Sequence.eq_intro", "Hacl.Spec.Poly1305.Vec.pfelem", "Hacl.Spec.Poly1305.Field32xN.feval5", "Lib.Sequence.create4", "Lib.Sequence.op_String_Access", "FStar.Pervasives.Native.tuple5", "FStar.Pervasives.Native.Mktuple5", "Lib.IntVector.vec_interleave_low_n_lemma_uint64_4_2", "Lib.IntVector.vec_t", "Lib.IntTypes.U64", "Lib.IntVector.vec_interleave_low_n", "Lib.IntVector.vec_interleave_low_lemma_uint64_4", "Lib.IntVector.vec_interleave_low" ]

[]

false

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

false

Steel.Memory.fst

Steel.Memory.frame_related_mems

val frame_related_mems : fp0: Steel.Memory.slprop -> fp1: Steel.Memory.slprop -> e: Steel.Memory.inames -> m0: Steel.Memory.hmem_with_inv_except e fp0 -> m1: Steel.Memory.hmem_with_inv_except e fp1 -> Prims.logical

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))

{ "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": 909, "start_col": 0, "start_line": 904 }

(* 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'

{ "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

fp0: Steel.Memory.slprop -> fp1: Steel.Memory.slprop -> e: Steel.Memory.inames -> m0: Steel.Memory.hmem_with_inv_except e fp0 -> m1: Steel.Memory.hmem_with_inv_except e fp1 -> Prims.logical

Prims.Tot

[ "total" ]

[]

[ "Steel.Memory.slprop", "Steel.Memory.inames", "Steel.Memory.hmem_with_inv_except", "Prims.l_Forall", "Prims.l_imp", "Steel.Memory.interp", "Steel.Memory.star", "Steel.Memory.linv", "Prims.l_and", "Steel.Memory.mem_evolves", "Steel.Memory.mprop", "Prims.eq2", "Prims.prop", "Steel.Memory.core_mem", "Prims.logical" ]

[]

false

true

let frame_related_mems (fp0: slprop u#a) (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))

false

Steel.Memory.fst

Steel.Memory.intro_h_or_right

val intro_h_or_right (p q: slprop) (m:mem) : Lemma (interp q m ==> interp (h_or p q) m)

let intro_h_or_right (p q: slprop) (m:mem) = H.intro_h_or_right p q (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": 83, "end_line": 504, "start_col": 0, "start_line": 504 }

(* 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)

{ "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": "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 -> m: Steel.Memory.mem -> FStar.Pervasives.Lemma (ensures Steel.Memory.interp q m ==> Steel.Memory.interp (Steel.Memory.h_or p q) m)

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Steel.Memory.slprop", "Steel.Memory.mem", "Steel.Heap.intro_h_or_right", "Steel.Memory.heap_of_mem", "Prims.unit" ]

[]

true

false

true

false

let intro_h_or_right (p q: slprop) (m: mem) =

H.intro_h_or_right p q (heap_of_mem m)

false

Steel.Memory.fst

Steel.Memory.refined_pre_action

val refined_pre_action : e: Steel.Memory.inames -> fp0: Steel.Memory.slprop -> a: Type -> fp1: (_: a -> Steel.Memory.slprop) -> Type

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)

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

{ "end_col": 48, "end_line": 917, "start_col": 0, "start_line": 911 }

(* 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))

{ "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 -> fp0: Steel.Memory.slprop -> a: Type -> fp1: (_: a -> Steel.Memory.slprop) -> Type

Prims.Tot

[ "total" ]

[]

[ "Steel.Memory.inames", "Steel.Memory.slprop", "Steel.Memory.hmem_with_inv_except", "Prims.dtuple2", "Prims.l_True", "Steel.Memory.frame_related_mems" ]

[]

false

true

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)

false

Steel.Memory.fst

Steel.Memory.hmem_of_hheap

val 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 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

{ "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": 661, "start_col": 0, "start_line": 632 }

(* 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

{ "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 fp0 -> h: Steel.Heap.full_hheap (Steel.Memory.star fp1 (Steel.Memory.linv e m)) {Steel.Heap.free_above_addr h (Mkmem?.ctr m)} -> m1: Steel.Memory.hmem_with_inv_except e fp1 {Steel.Memory.equiv (Steel.Memory.linv e m) (Steel.Memory.linv e m1)}

Prims.Tot

[ "total" ]

[]

[ "Steel.Memory.inames", "Steel.Memory.slprop", "Steel.Memory.hmem_with_inv_except", "Steel.Heap.full_hheap", "Steel.Memory.star", "Steel.Memory.linv", "Steel.Heap.free_above_addr", "Steel.Memory.__proj__Mkmem__item__ctr", "Prims.unit", "Prims._assert", "Steel.Memory.interp", "Steel.Memory.star_commutative", "Steel.Memory.equiv", "Prims.squash", "Prims.l_imp", "Steel.Memory.equiv_extensional_on_star", "Steel.Heap.star_congruence", "Steel.Memory.lock_store_invariant", "Steel.Memory.__proj__Mkmem__item__locks", "Steel.Memory.ctr_validity", "Steel.Memory.heap_of_mem", "Steel.Heap.pure_equiv", "Steel.Memory.heap_ctr_valid", "Prims.l_iff", "Steel.Heap.pure_interp", "Prims.eq2", "Steel.Memory.mem", "Steel.Memory.Mkmem" ]

[]

false

let hmem_of_hheap #e (#fp0: slprop) (#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

false

Steel.Memory.fst

Steel.Memory.intro_wand

val intro_wand (p1 p2: slprop u#a) (m:mem) : Lemma ((forall m1. m `disjoint` m1 /\ interp p1 m1 ==> interp p2 (join m m1)) ==> interp (wand p1 p2) 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) ) ) )

{ "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": 531, "start_col": 0, "start_line": 508 }

(* 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)

{ "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": "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

p1: Steel.Memory.slprop -> p2: Steel.Memory.slprop -> m: Steel.Memory.mem -> FStar.Pervasives.Lemma (ensures (forall (m1: Steel.Memory.mem{Steel.Memory.disjoint m m1}). Steel.Memory.disjoint m m1 /\ Steel.Memory.interp p1 m1 ==> Steel.Memory.interp p2 (Steel.Memory.join m m1)) ==> Steel.Memory.interp (Steel.Memory.wand p1 p2) m)

FStar.Pervasives.Lemma

[ "lemma" ]

[]

[ "Steel.Memory.slprop", "Steel.Memory.mem", "FStar.Classical.Sugar.implies_intro", "Prims.l_Forall", "Steel.Memory.disjoint", "Prims.l_imp", "Prims.l_and", "Steel.Memory.interp", "Steel.Memory.join", "Prims.squash", "Steel.Memory.wand", "FStar.Classical.Sugar.forall_intro", "Steel.Heap.heap", "Steel.Heap.disjoint", "Steel.Heap.interp", "Steel.Heap.join", "Prims._assert", "Steel.Memory.Mkmem", "Steel.Memory.__proj__Mkmem__item__ctr", "Steel.Memory.__proj__Mkmem__item__locks", "Prims.unit", "Steel.Memory.heap_of_mem", "Steel.Heap.intro_wand" ]

[]

false

true

false

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))))

false

Steel.Memory.fst

Steel.Memory.lift_tot_action

val 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 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

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

{ "end_col": 24, "end_line": 767, "start_col": 0, "start_line": 759 }

(* 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

{ "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' -> frame: Steel.Memory.slprop -> Steel.Memory.MstTot a

Steel.Memory.MstTot

[]

[ "Steel.Memory.inames", "Steel.Memory.slprop", "Steel.Memory.tot_action_nf_except", "Steel.Memory.lift_tot_action_nf", "Prims.unit", "Prims._assert", "Steel.Memory.interp", "Steel.Memory.star", "Steel.Memory.locks_invariant", "Steel.Memory.ac_reasoning_for_m_frame_preserving", "Steel.Memory.full_mem", "FStar.NMSTTotal.get", "Steel.Memory.mem_evolves", "Steel.Memory.mem", "Prims.l_True", "Prims.prop" ]

[]

false

true

false

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

false

Steel.Memory.fst

Steel.Memory.as_hprop

val as_hprop (frame: slprop) (mp: mprop frame) : hp: H.hprop frame {forall m. mp (core_mem m) == hp (heap_of_mem m)}

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

{ "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": 676, "start_col": 0, "start_line": 666 }

(* 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

{ "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

frame: Steel.Memory.slprop -> mp: Steel.Memory.mprop frame -> hp: Steel.Heap.hprop frame { forall (m: Steel.Memory.mem). mp (Steel.Memory.core_mem m) == hp (Steel.Memory.heap_of_mem m) }

Prims.Tot

[ "total" ]

[]

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

[]

false

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

false

Steel.Memory.fst

Steel.Memory.is_frame_preserving

val is_frame_preserving : f: Steel.Memory.tot_pre_action_nf_except e fp a fp' -> Prims.logical

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)))

{ "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": 617, "start_col": 0, "start_line": 606 }

(* 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

{ "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_pre_action_nf_except e fp a fp' -> Prims.logical

Prims.Tot

[ "total" ]

[]

[ "Steel.Memory.inames", "Steel.Memory.slprop", "Steel.Memory.tot_pre_action_nf_except", "Prims.l_Forall", "Steel.Memory.hmem_with_inv_except", "Steel.Memory.star", "Prims.l_and", "Steel.Memory.interp", "Steel.Memory.locks_invariant", "Steel.Memory.mem_evolves", "Steel.Memory.mprop", "Prims.eq2", "Prims.prop", "Steel.Memory.core_mem", "Prims.dtuple2", "Prims.unit", "Steel.Memory.ac_reasoning_for_m_frame_preserving", "Prims.logical" ]

[]

false

true

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)))

false